Install
npm i -g @antasphere/slideless exposes the slideless binary (the package
publishes under the Antasphere org’s npm scope; the binary name is unchanged).
The published package is a single self-contained bundle (dist/bin.js, built
with esbuild): the workspace-internal @slideless/contract, @slideless/sdk,
@antasphere/cli-core, and commander are inlined at build time, so the
published manifest carries zero runtime dependencies — nothing internal or
git-pinned leaks into a public install.
From a checkout:
Configuration: profiles, flags, environment
Config lives in the shared Antasphere CLI config home (provided by@antasphere/cli-core — one home for the whole tool family), under the
slideless namespace: $XDG_CONFIG_HOME/antasphere/tools/slideless.json
(default ~/.config/antasphere/tools/slideless.json), directories 0700,
file 0600:
~/.config/slideless/config.json. On first run, if that file still exists,
holds at least one profile, and the new home has no slideless profiles yet,
it is imported automatically and non-destructively — the old file stays in
place (older CLI builds keep working) but stops being read. Note the
corollary: after slideless config clear, a still-present legacy file is
imported again on the next run; delete ~/.config/slideless/config.json too
if you want a truly clean slate.
A profile is an instance. Each profile names one Slideless instance by its
baseUrl and holds how you sign in there: the instance’s own key (apiKey),
or the keys your Antasphere login was exchanged for there (connectKeys, one
per Antasphere login). The profile cloud exists before anything is on disk:
it is the Antasphere cloud, https://slideless.antasphere.com, and it carries
no baseUrl because that is its default. So a command on a clean machine runs
on the cloud. --api-url https://share.example.com selects the profile of that
instance, or makes one named for its host (share.example.com; a local
instance on port 3400 gets localhost:3400). A self-hosted instance is named
once, as a profile. No command renames a profile: the config file is yours,
and you can edit a name there. slideless use <profile> switches the active
profile, and slideless login makes its profile the active one.
slideless profiles lists them: the active mark, the name, the url, and how
each signs in:
(not signed in). Every command selects its
profile in this order: --profile <name>, then the profile of the
--api-url / SLIDELESS_URL instance, then the active profile (use), then
cloud. A key cached by the Antasphere login is only ever sent to the
instance its profile names.
Every command accepts --api-url (alias --url), --api-key,
--api-key-stdin, --profile, --org, --workspace, and --json.
Resolution order:
--org <id or name> (or
SLIDELESS_ORG) names the organization a command runs in, by the id the
account site shows or by its name; the instance maps it to its workspace.
--workspace <id or name> (or SLIDELESS_WORKSPACE) names a workspace of the
instance, by the Slideless workspace id slideless workspaces prints or by its
name. A self-hosted instance has no organization ids, so there you use
--workspace. Passing both is an error. A name is matched without regard to
case; a name that matches several workspaces, or none, is an error that lists
the candidates. An id is sent as it is, and a name costs one extra request to
look it up. Nothing is saved on the machine: with no selection, the server
picks your default workspace. The server’s default is yours to choose:
slideless workspace default <id or name> on a self-hosted instance; on the
cloud it is a setting of your Antasphere account, and the command answers with
the page. slideless workspaces lists your memberships, with
organization <id> on the rows that have one. slideless whoami shows the
workspace the command ran in, its organization id, what chose it, what the
command signed in with, and the Antasphere login (used, not used and why, or
not connected).
A key pinned to one workspace only ever acts there: selecting another one is
refused, and the error names the pin.
A deck lives in one workspace: a deck id (a linked folder’s, a pasted one)
asked of another workspace answers “not found”, and the error names the
workspace that was asked and what selected it.
Keeping secrets out of argv: a value passed as --api-key slk_… or
--password … is visible to every process on the machine (ps) and lands in
the shell history. Both have alternatives that do not touch the command line:
--api-key-stdin reads the key from the first line of stdin
(pass show slideless | slideless --api-key-stdin files list), SLIDELESS_API_KEY
carries it in the environment, and share / share-email take
--password-stdin or SLIDELESS_SHARE_PASSWORD. stdin can only be spent
once per invocation — asking twice is a usage error rather than two commands
silently sharing one secret.
Cloud instances: one login for the whole family
On an Antasphere-cloud instance you sign in with your Antasphere account, once for every Antasphere tool CLI.antasphere login is the family entry,
and after it slideless needs no flag on a clean machine:
slideless login alone does both: it signs you in to Antasphere when no
Antasphere login is stored on this machine, then does the exchange (see
Sign in).
When no direct key resolves, the CLI asks discovery (GET /api/v1/instance)
whether the instance signs in through the hub (auth.methods contains
antasphere); if so, it exchanges the stored Antasphere login
for a user-scoped tool-local slk_ key (hub → tool; see
Your Antasphere account) and
caches it in the profile per Antasphere login (connectKeys — ONE
key per Antasphere account, valid for every organization; the organization is
a per-command selection, --org, never part of the credential).
- The exchange names no organization (the Antasphere login identifies the USER, never one organization); a single cached key serves whatever organization a command names. Second and later runs make zero hub calls and mint nothing.
- The hub key is sent to the hub only; the instance sees a short-lived user-scoped JWT (plus its own one-time offline grant, relayed once and never stored by the CLI) and answers with an ordinary local key.
- A cached key is only ever sent to the instance its profile names (the
profile’s
baseUrlscopes the cache). - A cached key the instance refuses (401: revoked at Antasphere, a membership
removed) is evicted and exchanged again once, and the command is retried
once. The CLI says so on stderr:
The cached key was refused; signed in again through Antasphere. - When Antasphere refuses the exchange (for example, an organization not granted the tool), the CLI prints Antasphere’s own sentence and exits 3. Exit 1 is a usage or wire error.
slideless logoutrevokes the cached key(s) server-side (see Sign in), then forgets them.
oss) instances never take this branch: slideless login there
is the instance’s own email code or a pasted key, and the hub is never
contacted.
Sign in
slideless login is the one sign-in command. With no URL it signs in on the
selected profile: the active one, else the cloud. It makes its profile the
active one.
On the cloud it is your Antasphere account:
Antasphere email: and Code: ;
--email skips the first). This is the same sign-in antasphere login does,
against https://account.antasphere.com (ANTASPHERE_URL overrides it), and
the key is stored where antasphere login stores it, so every other
Antasphere tool CLI is signed in too. It then exchanges that login for the
Slideless key and ends with:
The stored Antasphere login was rejected: signing in again. and asks
for the email and the code.
On a self-hosted instance it is the instance’s own email code, both legs
in the one command:
EMAIL_DRIVER=smtp|resend|brevo); it signs in existing accounts only —
sign-up stays closed (accounts enter via setup, workspace invitations, or
collaborator claims). It mints an slk_ API key server-side (scopes
presentations:read + presentations:write, never data:export) and saves
it on the instance’s profile. Once that profile is active, slideless login
alone signs in there again. Accounts with 2FA enabled are refused
(two_factor_required), and an instance with no email driver has no email
code at all. For those, mint a key in the dashboard (API keys,
Create key; tick presentations:write, which the dialog leaves unchecked,
for push and share) and paste it:
slk_, and the CLI checks it against the
instance before it saves it. --key-name <name> names the key the sign-in
mints, as the dashboard lists it, and --expires-in-days <n> gives it a TTL
(it never expires otherwise). On the cloud that key is the Antasphere account
key; on a self-hosted instance it is the instance key.
Profile management:
slideless logout works on the active profile, or the one --profile names.
Every key the profile holds (its own key and each Antasphere login’s key) is
revoked on the instance the profile names, never on an --api-url one:
DELETE /cli/auth/key, where the presenting key revokes exactly itself. Then
the keys are forgotten. The profile stays, with its url. An older instance
whose machine allowlist predates the self-revoke refuses it (403): the CLI
says the key STAYS VALID server-side; revoke it from the dashboard, and
forgets the local copy. The Antasphere login itself stays stored for the other
tool CLIs.
Author: push / pull / dev
precheck (the server answers which blobs it is missing) →
upload exactly those → commit the manifest. Unchanged files are never
re-uploaded.
-
New deck vs new version: the first push writes
.slideless.jsoninto the deck folder ({ presentationId, baseUrl }). Later pushes find it and commit a new version of that deck with optimistic concurrency (expectedBaseVersion; a concurrent push answers a clean retry error).--id <deckId>targets a deck explicitly;--newforces a fresh deck. A link pointing at a different instance errors loudly instead of silently targeting a foreign id. -
Ignores:
node_modules,Thumbs.db,.slideless.json,.slidelessignore, every dot-prefixed file or directory (.git,.DS_Store,.env,.github, …) andpackage.json/ the common lockfiles are always skipped. That is not a taste call: a manifest path is whatslideless pullwrites onto someone’s disk, so those names are refused by the wire contract at commit and by the CLI again at pull —.git/hooks/pre-commit,.envandpackage.jsonare all “write this and something else runs it later” paths. Pushing a single dotfile (slideless push .env) errors instead of uploading it. A.slidelessignorein the deck root adds gitignore-style rules (a pragmatic subset:#comments,*,?,**; trailing/= directories only; patterns with/anchor to the deck root, without/they match any path segment; no!negation). Patterns are capped at 256 characters and 8**wildcards, and a longer or heavier one errors — an unbounded pattern used to hang the scan. Symlinks are never followed. -
Entry detection:
--entrywins, elseindex.html, else the only.htmlfile, else an error listing candidates. A single-file push (slideless push deck.html) uses that file as the entry. -
The deck’s page: every push answers with the deck’s own page on the
instance,
<instance>/decks/<id>/present(the master page: the owner’s full view, where share links are minted from — no link is created by a push; The deck is the artifact describes the page and its bar). The human summary prints it asurl:;--jsoncarries it asurlnext topresentationandversion. The first push of a folder (the one that creates the deck) also opens that page in your default browser; later pushes only print it.--openopens it on any push,--no-opennever does. A run whose stdout is not a terminal, or any--jsonrun, never opens a browser — whatever the flags say — so a push in CI or under an agent stays silent. The opener is the platform’s own (open,xdg-open, the Windows URL handler) with the URL as an argument, never a shell string. -
Attachments: a
downloads/folder at the root of the deck is the version’s attachment set (Attachments, and the Downloads page for the URLs and the API): files handed to a link’s recipient as downloads, never rendered. The bar over the share link offers them (a Download button listing each file, and Download all for the zip); on a link made with--no-bar, or inside an embed, the bar is absent and your deck must link its own files for a recipient to find them:<a href="downloads/figures.csv">for one,<a href="downloads.zip">for the set, relative to the deck’s own URL. The push classifies them by the same rule the server uses and prints anAttachments: N files, X MB (downloads/)line under the summary when the folder carries some;--jsoncarriesattachments: { count, sizeBytes }. They ride the same content-addressed protocol as every file: an unchanged attachment is never re-uploaded when you iterate on the HTML (the precheck reports it present), and only what changed travels. -
The per-file cap, refused before anything is uploaded: every file of
the deck is checked against the instance’s per-file cap before the upload
session, the precheck or any upload. A file over it names itself and the
cap, and no byte has left the machine:
The cap the CLI checks against is the 100 MB default: no instance publishes its own
MAX_FILE_SIZE_MByet. On an instance configured with a lower cap the server stays the enforcement point and still answers413to the oversized blob after its upload, with the smaller files already stored. -
Flags:
--title,--entry,--kind presentation|app|plan,--interactive,--id,--new,--open/--no-open,--brand/--template(the references this deck was made from, recorded on it: “References: brand, template” below), and--project(repeatable — the projects the deck goes in: “Projects” below).
.slideless.json (deck id + instance) and composes the same URL a push
prints, with no key and no network call. --json prints
{ presentationId, baseUrl, url } instead of opening. An unlinked folder is
an error pointing at push, and a link file whose instance is not an
http(s) URL is refused before anything reaches the opener (the file can
arrive with a cloned folder; the opener would dispatch any scheme).
pull downloads a version’s manifest and streams every blob to disk —
byte-identical to what was pushed, attachments under downloads/ included
(the summary counts them) — then writes/refreshes .slideless.json
so a later push in that folder targets the same deck. It treats the
instance’s answer as untrusted input: every manifest path is re-validated
locally, each blob is capped at the size the manifest declared and must hash
to the sha256 the manifest claims before anything is written, deck file writes
refuse to follow a symlink (file or directory) and never leave a file executable
(the .slideless.json link file itself is written plainly),
and a destination whose .slideless.json names a different instance errors
loudly — the same refusal push has always had.
dev serves the folder locally under the same sandbox headers as the public viewer —
Content-Security-Policy: sandbox allow-scripts allow-forms allow-popups allow-popups-to-escape-sandbox allow-modals allow-downloads, nosniff, no-referrer, no-store — so isolation
and relative paths match what share-link recipients get. It is not the hosted
viewer: it injects live reload and nothing else (no recipient bar, no annotation
layer, no forms runtime, so a marked form submits nowhere), it serves
downloads/ files inline and has no downloads.zip, it serves files a push
would ignore, and a root-absolute URL (/style.css) resolves locally but breaks
under /v/<secret>/. Test forms, notes and downloads on a real share link. Any
file change reloads the browser. No backend, no credentials.
It serves the deck folder and nothing else: a path is resolved with
realpath and re-checked against the root, so a symlink inside the folder
cannot serve a file from elsewhere on the disk; dot-prefixed paths 404
outright; and requests whose Host header is not the address the server
bound answer 403, which is what stops a DNS-rebinding page from reading your
deck (and anything else) through the browser.
References: brand, template
A reference is a deck the workspace keeps to make other decks from, andbrand
and template are its two types: References is the
model. The type is one line of the AGENT.md frontmatter, and the server reads
it at push. The CLI has one real family, slideless reference <verb>, whose
verbs take --type brand|template where the type matters, and two shortcut
families, slideless brand and slideless template, the same verbs with the
type already chosen.
<ref> is a reference’s id, else its exact title, else the start of its
title without regard to case, as long as one reference matches. A name that
matches several is refused: the error lists the candidates with their ids, and
the command exits non-zero. Every verb also takes --json, and list pages
like the other listings (--cursor, --limit, --all).
pull downloads a reference into .slideless/<type>/ of the current deck
folder, so the brand an agent reads sits beside the deck it is authoring.
.slideless is dot-prefixed on purpose: a push skips every dot-prefixed file
and directory, so a pulled brand can never travel into the deck beside it. With
no <ref> the command takes the workspace’s default of the type, and a
workspace with no default says so and points at slideless brand list. --at <version> pulls an older version, --into <dir> writes somewhere else. The
folder gets a .slideless.json link file naming the reference’s id, the
instance and the type and version that were pulled. That link file is also the
replace rule: a second pull of the same type empties the folder and writes it
again, while a folder that is not empty and carries no such link file is refused
with is not empty and is not a folder a previous pull wrote. Delete it to pull there, or pull into another folder (--into). The download is the same safe
path as slideless pull: every manifest path is re-validated locally, each blob
is capped at the size the manifest declares and must hash to the sha256 it
claims before anything is written, and no write follows a symlink. A pull that
fails part way (a blob that does not hash, a dropped connection) removes what it
had written and says so on stderr, so the next pull of that type starts clean;
it removes only what it created: a folder that existed before the pull is
emptied and kept, and a parent folder you made is never touched. Pushing a new version
of the reference from its pulled folder (slideless brand push .slideless/brand,
as its owner) keeps the link file’s type and moves its version to the one just
pushed, so the deck beside it keeps recording the brand.
new scaffolds a folder to fill in: an AGENT.md carrying the frontmatter of
the type with every field it has, an index.html with one page per layout for a
brand or the skeleton pages for a template, and an empty assets/ (plus
assets/fonts/ for a brand). The content is neutral and invented, no real brand
and no real client, so every value is an example to replace. --title writes the
title into the frontmatter. The command touches no instance: the type is the
frontmatter’s, and the server classifies the deck at the next push.
push is slideless push with one refusal in front of it. Before a single
byte leaves the machine, the folder must carry an AGENT.md whose frontmatter
names a type, and, on a shortcut family, that type: a folder with no AGENT.md,
a file with no frontmatter, a frontmatter with no type: line, a type the server
does not know, or a brand pushed with slideless template push each end with a
sentence saying what is wrong and Nothing was uploaded. It takes --title,
--entry, --id, --new, --open and --no-open like an ordinary push. A
reference is named by its frontmatter, not by its folder: with no --title, a
push that creates the deck names it after the title: line of the AGENT.md
frontmatter, quotes stripped, so <ref> later resolves by the name the author
wrote. A frontmatter with no title: line, or an empty one, falls back to the
folder name as an ordinary push does. A push that adds a version to an existing
reference keeps the deck’s title unless --title gives a new one. After
the commit, the summary carries a reference: line naming the type, the title,
whether the reference is private or published to the workspace, and whether it is
the workspace default; a warning: line carries whatever the server found
unusable in the frontmatter, and what the deck lost when a push takes its audience
back to private or drops its default. A push that the instance classified as an
ordinary deck adds warning: the instance classified this push as an ordinary deck, not a brand. A concurrent push is Someone pushed a new version while this push was running — rerun to retry on top of it. Pushing a reference you read but
do not own is refused with This brand is not yours to push: only its owner (or a collaborator with a dev grant) pushes a new version, and the instance answers "not found" to anyone else., which points at slideless brand start.
publish and unpublish set the audience: publish opens the reference to
every member of the workspace, unpublish closes it to its owner, the workspace
admins and its collaborators again. Whoever administers the deck may do it, its
owner or a workspace admin or owner; anyone else gets Only the owner of "…", or a workspace admin or owner, changes who reads it. default makes a reference
the workspace’s default of its type, which is what slideless brand pull with no
name fetches; only a workspace admin or owner sets it. --clear removes the
default: with a <ref> it clears that reference, with none it clears whichever
reference is the default of the type. The server’s refusals arrive as sentences.
A private reference cannot be the default, and the message says to publish it
first. A default reference cannot go private while it is the default, and the
message says to clear the default first. An ordinary deck has no audience and no
default: "…" is an ordinary deck, not a brand: its AGENT.md frontmatter names no type. Push it with one first.
start copies a reference’s files into a fresh folder, which must be missing
or empty. The type: line is removed from the AGENT.md and the rest of the
frontmatter is kept, so the deck is not a reference but the agent keeps the
briefing: the title, the description, the fonts, the colours, the pages. No link
file is written, so the first push of that folder creates a deck of its own, and
the command prints the next step, slideless push --new --brand <id>@<n>. That
is the difference from pushing a copy of the reference itself: a duplicate on the
server is a reference again, while starting a deck is a local copy that becomes
an ordinary deck.
Provenance is what a deck records about the references it was made from.
slideless push --brand <ref> and --template <ref> record one each, and
<ref>@n pins the version instead of the reference’s latest; both take the same
<ref> forms as everywhere else and are resolved before any upload, so a wrong
name costs nothing. The value is tried whole first, so a reference whose title
ends in @2 is named as written; only when nothing matches the whole value is
the trailing @n read as a version; when both readings name a real reference,
the title wins and a note on stderr says how to pin the other by its id. With
neither flag, a push reads the link
files of .slideless/brand/ and .slideless/template/ beside the deck and
records what was pulled there, which makes the ordinary sequence, pull then
author then push, record itself. A reference pulled from another instance is not
recorded, and the push says so on stderr: Note: the brand in .slideless/brand/ was pulled from <url>, not <url>; it is not recorded on this deck. A folder
whose link names the other type (a template moved under .slideless/brand/) is
not recorded either, with the same kind of note. What is recorded is merged
into metadata.references, one entry per type, every other entry and every other
metadata key kept. The push prints the result as a references: line, brand <id>@<n>, template <id>@<n>, and slideless get <id> shows the same entries as
made from:.
Projects
A project is a subgroup of the workspace: a name, its own members with one of three roles (viewer < editor < manager), the decks linked to it and at most one brand. Projects is the model — a workspace membership is not a grant on its decks, and the project is the grant.--cursor,
--limit, --all) and take --json. list shows the live projects;
--archived true shows the archived ones and --archived all both.
create makes you the project’s first manager and takes --description and
--metadata (a JSON object of your own, opaque to the server); update takes
--name, --description or --clear-description, and --metadata, which
replaces the whole object. archive takes a project out of the default listing
and makes it read-only; nothing is ever deleted, and unarchive brings it back.
Members come from the workspace’s own roster, named by email (anything with
an @) or by user id. add takes a required --role viewer|editor|manager.
A manager removes anyone; anyone removes themselves. A stranger’s address is
No active member of this workspace matches — check the user id or email. Only a member of the workspace can join a project., and a per-deck guest is refused
with That person is a guest of the workspace, and a guest cannot be a project member. Invite them as a workspace member first.
A team is a member too. add --team <team> (a slug or an id, in place of
the person) puts one of the workspace’s teams on the project with the
role, and every member of the team holds it; role and remove take --team
to name a team as their second argument. members list prints a person or
team column first, then the user id or the team’s slug. A person’s role on
the project is the highest of their own entry and their teams’ entries.
link / unlink are the deck’s side. Linking widens who reads the deck, so it
is the deck administrator’s act — its owner, or a workspace admin or owner —
with editor or more on the project; unlinking is theirs or a project manager’s.
The deck is named by id, or by a folder whose .slideless.json names it, or by
nothing at all, in which case the current folder’s link file is read (the same
file push, open and pull use). Both print the projects the deck is in
afterwards, and --json is the deck payload verbatim.
brand reads, sets and clears the project’s brand: with no <deck> it prints
the brand deck’s title, id and version (--json is { brand }, { "brand": null } when there is none); with one, named like every reference ref (its id, its
title or the start of its title, or a folder a push linked), it makes that deck the brand, and
--clear removes it. The deck must be a brand reference already linked to the
project, so the two refusals are That deck is not in this project. Link it first (slideless projects link <project> <deck>). and That deck is not a brand reference: its AGENT.md frontmatter names no type: brand. Push it as a brand first (slideless brand push). Only a project manager changes it.
--project <id> filters the deck listings: slideless list --project keeps
the decks linked to it, and slideless brand list --project / template list /
reference list do the same for the references. A project you cannot read
answers the same way the project itself does, so the filter refuses with No such project, or it is not yours to read. rather than an empty page.
slideless push --project <id> is repeatable, and the two branches differ on
purpose. On a new deck the projects ride in the commit itself: one
transaction, and a project that does not qualify refuses the whole push, so a
new deck is never half-placed. On an existing deck (the folder’s
.slideless.json names one) the version is committed first and each project is
linked after it, one call each: the push stays a success, the summary’s
projects: line names what the deck is in, and a project that refused prints its
sentence on stderr under project <id>: without touching the others. --json
carries the same as projectLinks, one { projectId, linked, error? } per
--project given.
The refusals every project verb shares read as sentences: No such project, or it is not yours to read. (A project you are not a member of answers the same way: its existence is not probeable.), You need the manager role on this project to do that., This project is archived and read-only. Unarchive it first to change it., and You are a guest of this workspace, and guests do not take part in projects.
Teams
A team is a named group of the workspace’s people, which a project can take as a member. Every member of the workspace reads the teams; an owner or an admin shapes them. On a workspace managed by the Antasphere account site, the teams are read here and managed there.list and members read every page, and every verb takes --json (the API
answer verbatim). A team from the Antasphere account site is marked
(Antasphere) in list. The refusals read as sentences: Only an owner or an admin manages teams., Teams of this workspace are managed on the Antasphere account site: <link>, A team of this workspace already uses the slug "design"., and ada@acme.co is already in this team.
Demo links
On a self-hosted instance whose operator turned demo sign-in on (DEMO_SIGN_IN, Demo links), an owner makes a
link that signs one member in without a password, for a demonstration.
--owner-email or SLIDELESS_OWNER_EMAIL; the password is
SLIDELESS_OWNER_PASSWORD or, with --owner-password-stdin, the first line of
stdin. There is no password flag (a password on a command line lands in the
shell history), and nothing (address, password, session) is written to the
profile. The instance comes from the usual --api-url / SLIDELESS_URL /
profile, and --workspace selects the workspace as for every command. An owner
with a second factor is refused: mint that owner’s links from the dashboard.
demo link mints ONE pass per member --email names (repeatable: several
members cost one sign-in) and prints, for each, one link per --path
(repeatable), all opening that member’s pass; the first --path is the pass’s
own page, and with none it is /. A member the instance refuses does not stop
the others: the command names who was refused and why, and exits 1. Each page must be a path on the
instance (one leading /, no #, no space), checked before any sign-in.
--hours <n> or --minutes <n> sets the lifetime (a day by default, a week at
most; not both). The human output is the person, the expiry, then the links one
per line; --json is { passes: [{ pass, links: [{ path, url }] }], refused: [{ email, code, message }] }, and the links are the only place the secret ever
appears. Keep them like a password until they expire.
The instance allows three sign-ins per ten seconds from one address. A script
that runs several demo commands in a row meets that limit: the command waits
it out (a few seconds, three times at most) and says so on stderr. Name every
member on ONE demo link to sign in once.
demo list prints each pass’s id, the person’s address, the page, the
expiry, the revocation, the last use and the number of uses (--json:
{ passes }). demo revoke <id> revokes a pass and ends every session it
opened (--json: the pass).
The refusals are the instance’s own sentences: no member of the workspace holds
that address, a link cannot open another owner’s account, the address is not a
demonstration address (a reserved example or test domain, or one in
DEMO_SIGN_IN_EMAIL_DOMAINS), the account has a second factor, the person is a
guest or belongs to another workspace, or the page is not a path on this
instance. On an instance where the switch is off, and on the cloud edition,
every demo command says: Demo sign-in is off on this instance (DEMO_SIGN_IN), or this is the cloud edition, where demo links are minted at the Antasphere hub.
Share
A share link is a secret URL made on top of the deck, public to whoever holds it, following the latest version or pinned to one, with its own switches, expiry, password and counts: Share links is the model, Versions the latest-or-pinned story.share-email mints and mails a fresh secret per
send).
Embedding from the CLI: share --json always carries an embed object
({ script, iframe, embedJsUrl }) alongside the token and URL, so an agent
that both manages decks and builds websites mints the link and pastes the
snippet in one step — no second command, nothing to assemble by hand. In
human output, --embed prints the same two snippets. Both come from the
same builder as the dashboard’s copy dialog (identical sandbox attributes);
--placement <label> bakes a per-spot analytics label into them (it shows
up per view in slideless views). Details: the Embedding page under
Sharing & review.
tokens lists every link of the deck, the dashboard’s own preview links
included: rows named Dashboard preview that expire within the hour and
count nothing; the dashboard hides them, the CLI and the API do not. The human table has no column for the
bar: --json carries showBar on every token, which is how a bare link is told apart from the
others. Access stats count entry loads only, de-duplicated per browser within a short window (VIEW_DEDUPE_WINDOW_MINUTES, default 10 min) — so one human
open is one count, while cookie-less fetches of the deck’s HTML (?raw, a script asking for
text/html) count each time. A fetch that does not ask for HTML (plain curl, an agent) gets the
link’s index instead and counts as an agent read, never as an open: the agent reads column
(Share links, read by agents).
“Last opened” is the last counted open. The downloads column is the link’s
downloadCount (one per attachment taken through the link, one per zip,
never a view) when the link allows downloads, and no downloads when it was
minted with --no-download (canDownload: false; the deck still opens, the
file URLs answer 404). --json carries both fields on every token.
Collecting form responses: slideless responses with no filters prints
the summary first (responses per form × link × source × placement, with the
latest activity), then the most recent rows. Filters narrow the row listing:
--form to one named form, --link to one share link (token id or link
name, never a share URL: secrets are hash-only server-side and cannot be
resolved back to a token), --source link|embed and --placement <label>
to one distribution spot, --since <ISO datetime> to a time window (a
response created OR edited at or after it — an edit is activity, so an
edited answer resurfaces). --all
follows pagination, --json prints the wire shape for agents, and --csv
writes a spreadsheet-safe CSV (cells are guarded against formula injection)
built client-side from the same rows. Links minted with --no-forms refuse
submissions (403 forms_disabled); everything else about them works
unchanged. Every edit is kept as a revision:
slideless response <id> <responseId> prints the current answer and every
kept revision (at most
100 per response; the first and the latest 99 always survive), each with the
link and the moment it was written through. slideless notify <id> --off
silences the owner mails (one on a new response, a different one on an edit,
never carrying the answers, at most one per deck per ten minutes) without
touching forms. Details: the Forms page under Sharing & review.
Files uploaded through a form: a form can carry a file field, and what
respondents upload is attached to their response. responses shows a files
count per row, --csv adds one column per file field met in the exported
rows, named <field> (files) and holding that field’s file names joined
with ; (guarded like every other cell), and --json carries files on
every response (id, field, name, contentType, sizeBytes, sha256).
response lists the current files and, in the history, the names each
revision held (- on a revision from before file fields existed).
slideless response-files <id> brings the bytes to disk. Without a
responseId it takes every file of the deck’s responses, narrowed by
--form, --link, --source, --placement and --since exactly as
responses reads them; with one
it takes that response’s files (the filters are refused there). Two modes:
- A folder (the default,
--out <dir>): one download per file, laid out as<dir>/<form>/<response>/<field>/<name>where<response>is when the response was first sent plus the head of its id (20260914-2000-7f3a9c1e), or<dir>/<field>/<name>for one response. File and field names are the respondent’s raw input, so no name is ever used as a path: each segment is reduced to one plain name (separators resolved to the basename, control characters dropped, a leading dot replaced by_, so../../xis written asxand.envas_env), two files with the same name in one field becomename.extandname (2).ext, and every write is contained in<dir>(symlinks refused, mode forced to 0644). Each download is capped at the size the response declares and its sha256 is verified before the file is kept; a mismatch stops the command with an error and exit code 1. The human output prints the path written for each file, with the name as sent when the two differ. - One zip (
--zip [path]): the server builds the archive (<form>/<response>/<field>/<file>, or<field>/<file>for one response) and the CLI streams it to disk without buffering it. Without a path, the file takes the server’s name (<deck-title>-form-files.zip), reduced to a plain file name and written in the current directory; a path you type is used verbatim.--outand--zipcannot be combined.
404 no_files, which the CLI reads as the same
empty result). --json prints a summary instead of the table: in folder mode
{ mode: "folder", path, files: [{ responseId, formName, fileId, field, name, sizeBytes, sha256, path }], totalBytes } (path is null and files empty
when there was nothing), in zip mode { mode: "zip", path, sizeBytes }.
Uploads are a per-link switch, like forms and downloads: a new link has them
on, share --no-uploads mints one without, and
slideless uploads <id> <tokenId> --on turns them on for a link minted
before file fields existed (those stay off until their owner says otherwise;
a link already in circulation never gains a public write capability by
itself). Without a flag uploads prints the current state. An upload rides a
form submit, so the switch does nothing on a link minted with --no-forms.
Collaborators
Decks, files, export
Paging
Every listing command (list, versions, tokens, views, responses,
files list) answers one page at a time, newest first: --limit <n> sets the
page size (1 to 100), --cursor <cursor> resumes from the nextCursor a
previous page printed, and --all follows the cursors until every page is
fetched.
Shell completion
Machine use
Add--json to any command except files download for the wire shape; every error prints to stderr
and exits non-zero: 1 for a usage or wire error, 3 when Antasphere refuses you (its own sentence
is printed). On the cloud, the key variable is not needed once slideless login has run. Typical
agent loop on a self-hosted instance:
--json push never opens a browser; hand .url (the deck’s page on the
instance, behind the owner’s session) to the person, and mint a share link
only when a recipient needs one.
Server endpoints behind login
The self-hosted email code of slideless login rides
POST /api/v1/cli/auth/request and POST /api/v1/cli/auth/complete. They are
public pre-auth endpoints (like /setup), riding the better-auth email-OTP
plugin with disableSignUp — an unknown email gets a generic success and no
mail (no account enumeration, no account creation), codes are attempt-limited
(3) and both endpoints sit behind the instance’s OTP/login rate walls. The
key is returned exactly once; the flow’s throwaway session is deleted
server-side. Without an email driver both answer 400 otp_unavailable; on
the cloud edition both answer 403 cli_otp_disabled (hub-only login: there
slideless login signs in through the Antasphere account instead).
DELETE /api/v1/cli/auth/key is the logout counterpart on both editions: an
authenticated route where the presenting API key revokes exactly ITSELF
(machine-allowed under presentations:write in the fail-closed scope
allowlist; sessions are refused — the dashboard is their key surface).