Get set up with Artifyde

Artifyde gives every artifact your agent builds a home. You publish the HTML, get a stable shareable URL, and collect version-pinned feedback. This guide takes you from nothing to your first published page.

1 · Install the CLI

Everything you publish goes through the artifyde CLI. Run it one-off with npx/bunx, or install it globally. Requires Node 18+ (or Bun). Pick your package manager in the sidebar:

# one-off, no install
npx artifyde-cli push --help

# or install the command globally
npm i -g artifyde-cli
artifyde push --help

# one-off, no install
bunx artifyde-cli push --help

# or install the command globally
bun add -g artifyde-cli
artifyde push --help

The CLI defaults to the hosted instance at https://artifyde.com. Point it at another server any time with --url or the ARTIFYDE_URL environment variable.

Sign in once per machine. artifyde login opens your browser, you approve, and a per-user token is stored under ~/.config/artifyde/config.json. After that every command runs as you with no further setup.

artifyde login            # opens the browser, approve, done
artifyde whoami           # who am I logged in as?
artifyde logout           # revoke + forget this machine's token

TipOn a headless or remote machine, artifyde login --no-browser prints a URL you can open from any other device to approve this one.

3 · Publish your first artifact

artifyde push turns HTML into a versioned artifact. Give it a file, or pipe HTML in on stdin.

# from a file
artifyde push artifact.html

# from stdin
echo '<!doctype html><h1>Hello</h1>' | artifyde push

On success it prints the version number plus two URLs: the view URL (the human review page) and the raw URL (the byte-exact artifact). Open the view URL — or visit your gallery — to see it.

4 · Add new versions

An artifact is immutable, but a page collects an ordered history. Append a new version by passing an existing page id. Use the pg_... value from the view URL (/p/<PAGE_ID>) or from artifyde list:

artifyde push artifact.html --page-id <PAGE_ID>

# raw JSON instead of the friendly summary
artifyde push artifact.html --page-id <PAGE_ID> --json

In the JSON response, id is the version id; the page id is the pg_... id used in the view URL.

Re-pushing identical bytes is a no-op — it returns the existing version rather than creating a duplicate.

5 · Review and comment

Open a page's view URL to read it. The artifact renders inside a sandboxed frame; the review UI lives around it. Sign in and you can leave comments — each one is pinned to the version you're viewing, so feedback never drifts onto a later revision. Select text in the document to anchor a comment to a specific passage. Use the version picker in the header to move through history.

You can also pin a comment from the terminal with artifyde markup. Pass the page id and the exact passage to anchor to; the note comes from --body or stdin. The quote must appear verbatim in the version (the current one unless you pass --version), so the highlight resolves:

artifyde markup <PAGE_ID> --quote "Q3 revenue" --body "where's the source?"

# note on stdin, pinned to a specific version
echo "needs a unit" | artifyde markup <PAGE_ID> --quote "42.5" --version 2

If the quote can't be found in the target version the command refuses, so a comment never points at a highlight that won't appear. Pass --force to post the note anyway (it lands on the version, just without an anchored highlight).

Feedback flows back to the terminal too: artifyde comments <PAGE_ID> prints a page's comment threads — anchored markup and page-level notes with their replies — so an agent can read what reviewers said without opening a browser. Add --version to scope to one version.

6 · Manage your pages

List the artifacts you own with artifyde list. By default it shows live pages; add --archived for archived-only or --all for both. --search narrows the list to pages whose title or description contains a term (or whose id matches exactly) — the same search as the gallery's search box.

artifyde list                  # your live pages
artifyde list --all            # live + archived
artifyde list --search "dash"  # title/description contains "dash"
artifyde list --json           # raw JSON for scripts

Need the HTML back? artifyde pull <PAGE_ID> writes the byte-exact artifact to stdout (or a file with -o); pass --version for an older snapshot, or a ver_… id directly.

Archiving hides a page from the gallery and makes it read-only — the bytes, versions, comments, and URLs stay intact, but new versions and comments are paused until you restore it. Page owner only.

artifyde archive <PAGE_ID>        # hide + freeze
artifyde unarchive <PAGE_ID>      # back to live

You can also archive (or restore) a page from its view in the browser — the Archive control in the page header is visible only to the owner.

Every page is private by default — only you can open it. Widen access two ways: invite specific people by email, or make the page public so anyone with the link can view. Invited people sign in as that email to view and comment. Page owner only.

artifyde share <PAGE_ID>                       # show who can see it
artifyde share <PAGE_ID> reviewer@acme.com     # invite by email
artifyde share <PAGE_ID> --public              # anyone with the link
artifyde share <PAGE_ID> --private             # back to invite-only
artifyde unshare <PAGE_ID> reviewer@acme.com   # revoke a person
artifyde unshare <PAGE_ID> --public            # stop link-sharing

The same controls live in the browser: open a page you own and pick Share… from the account menu to flip visibility, invite or remove people, and copy the link.

8 · Let your agent publish

Artifyde is built for agent-authored HTML, so the shortest path is to let the agent that made the page publish it and hand you back a link. How it authenticates depends on whether the agent shares your shell.

Your coding agent drives the CLI

If your coding agent — Claude Code, Cursor, and the like — runs in a terminal where artifyde is installed and you've already run artifyde login, it publishes as you. The stored login token is all it needs; there's no separate key to hand it. Just ask, in plain language:

# in your agent session
Publish the page you just built to Artifyde with `artifyde push`,
then give me the view URL.

The agent runs the command, reads back the view and raw URLs from the output, and you open the view URL to review and comment on the exact version it shipped. To get on the same page on every revision instead of asking each time, give the agent a standing instruction — a Claude Code skill, a Cursor rule, or a line in the AGENTS.md / CLAUDE.md the agent already reads each session:

# e.g. in AGENTS.md or CLAUDE.md
When you build or change an HTML artifact, publish it with
`artifyde push <file>` (add `--page-id <id>` to add a version to an
existing page) and share the view URL so we can review it together.

TipSince the agent uses your artifyde login token, everything it pushes is attributed to you and lands in your gallery — the same as if you ran push yourself. Nothing else to configure.

Unattended jobs and CI

A runner with no browser and no interactive login publishes by hitting the HTTP API directly with the shared owner key in the X-Api-Key header. POST the raw HTML — the response is JSON with the new version's id, its version_number, and the view + raw URLs:

curl -X POST https://artifyde.com/v1/pages \
  -H "X-Api-Key: <your-api-key>" \
  -H "Content-Type: text/html" \
  --data-binary '<!doctype html><h1>Hello from an agent</h1>'

Add ?page_id=<id> to append a version to an existing page. Pushes authenticated this way are attributed to the shared owner identity.

NoteThe artifyde CLI authenticates only with a stored artifyde login token — it does not read an API key — so it's built for the interactive, per-user flow above, not unattended jobs. For programmatic publishing use the call here, or the zero-dependency ArtifydeClient from @artifyde/core (pass apiKey), which sends the same X-Api-Key header for you.

Command reference

Every artifyde command at a glance. Run artifyde <command> --help for the full flag list. --url (or ARTIFYDE_URL) and --json work on every command that talks to the server.

Command	What it does	Key flags
`artifyde login`	Authenticate this machine (opens your browser).	`--no-browser`
`artifyde whoami`	Show the identity you're logged in as.	—
`artifyde logout`	Revoke and forget this machine's token.	—
`artifyde push [file]`	Publish HTML (file or stdin) as a new artifact or version.	`--page-id`, `--public`, `--json`
`artifyde pull <id>`	Download an artifact's byte-exact HTML (page or version id).	`--version`, `--output`
`artifyde list`	List the pages you own.	`--archived`, `--all`, `--json`
`artifyde markup <page-id>`	Pin a comment to a passage from the terminal.	`--quote`, `--body`, `--version`, `--force`
`artifyde comments <page-id>`	Read the comment threads left on a page.	`--version`, `--json`
`artifyde share <page-id>`	Show who can see a page, invite by email, or make it public.	`--public`, `--private`
`artifyde unshare <page-id>`	Revoke invited people or stop link-sharing.	`--public`
`artifyde archive <page-id>`	Hide a page from the gallery and freeze it read-only.	—
`artifyde unarchive <page-id>`	Restore an archived page to live.	—
`artifyde version`	Print the installed CLI version.	—