Skip to main content

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:
Nothing in the file names a workspace: a command names its organization or its workspace itself (below). Migrating from older builds: the config used to live at ~/.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:
A profile with no key reads (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: Choosing the organization or the workspace: an API key identifies a person, and a person can belong to several workspaces. On the cloud, each workspace is an Antasphere organization. --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 baseUrl scopes 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 logout revokes the cached key(s) server-side (see Sign in), then forgets them.
Self-hosted (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:
When no Antasphere login is stored on this machine, it asks your email and the code sent to it, inline (prompts 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 second line appears only when you have several organizations. A stored Antasphere login that Antasphere no longer accepts is replaced once: the CLI says 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:
The flow needs the instance to have a delivering email driver (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:
A pasted key must start with 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

push implements the content-addressed 3-step protocol: scan → hash every file (sha256) → 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.json into 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; --new forces 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, …) and package.json / the common lockfiles are always skipped. That is not a taste call: a manifest path is what slideless pull writes 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, .env and package.json are all “write this and something else runs it later” paths. Pushing a single dotfile (slideless push .env) errors instead of uploading it. A .slidelessignore in 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: --entry wins, else index.html, else the only .html file, 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 as url:; --json carries it as url next to presentation and version. 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. --open opens it on any push, --no-open never does. A run whose stdout is not a terminal, or any --json run, 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 an Attachments: N files, X MB (downloads/) line under the summary when the folder carries some; --json carries attachments: { 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_MB yet. On an instance configured with a lower cap the server stays the enforcement point and still answers 413 to 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).
open opens the page of the deck a folder is linked to: it reads .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, and brand 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.
The projects themselves page like every other listing (--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. 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.
These commands never use an API key. The instance refuses every machine credential on its demo routes, so each command signs in as the owner for its own length and signs out when it ends, whatever happened. The owner’s address is --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.
Secrets are stored hash-only server-side: the URL printed at creation is never retrievable again (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 ../../x is written as x and .env as _env), two files with the same name in one field become name.ext and name (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. --out and --zip cannot be combined.
Nothing to download is not an error: the command says so and exits 0, in both modes (the zip routes answer 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:
A --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).