vellum-cli 0.3.0 → 0.3.2

package/README.md

@@ -71,6 +71,31 @@ vellum push artifact.html --page-id pg_123 --json
 On success it prints the new version number, the human view URL, and the raw
 URL. With `--json` it prints the server's `CreateVersionResponse` verbatim.
 
+### `vellum markup <page-id>`
+
+Pin a comment to a passage of a published document. The `--quote` text must
+appear verbatim in the document; the viewer highlights it and links your note to
+the highlight. Without `--version`, the page's current version is used.
+
+```bash
+# anchor a note to a passage
+vellum markup pg_123 --quote "Q3 dashboard" --body "tighten this headline"
+
+# pipe the note in on stdin instead of --body
+echo "tighten this headline" | vellum markup pg_123 --quote "Q3 dashboard"
+```
+
+The CLI checks the quote is anchorable before posting; pass `--force` to post
+anyway, or `--json` for the raw response.
+
+### `vellum whoami`
+
+Show the identity the CLI is authenticated as for a server.
+
+### `vellum logout`
+
+Revoke this machine's stored token server-side and forget it locally.
+
 ## Development
 
 From the repo root, Bun runs the TypeScript source directly (no build):

package/dist/index.js

@@ -61,7 +61,7 @@ async function clearToken(baseUrl) {
   return existing;
 }
 
-// src/commands/comments.ts
+// src/commands/archive.ts
 import { parseArgs } from "node:util";
 // ../core/src/client.ts
 class VellumApiError extends Error {
@@ -119,6 +119,30 @@ class VellumClient {
       await this.fail(res);
     return await res.json();
   }
+  async listPages(opts = {}) {
+    const url = new URL(`${this.baseUrl}/v1/pages`);
+    if (opts.archived)
+      url.searchParams.set("status", "archived");
+    else if (opts.all)
+      url.searchParams.set("include", "archived");
+    const res = await this.fetchImpl(url, { headers: this.authHeaders() });
+    if (!res.ok)
+      await this.fail(res);
+    return await res.json();
+  }
+  async archivePage(pageId) {
+    return this.setArchived(pageId, true);
+  }
+  async unarchivePage(pageId) {
+    return this.setArchived(pageId, false);
+  }
+  async setArchived(pageId, archived) {
+    const action = archived ? "archive" : "unarchive";
+    const res = await this.fetchImpl(`${this.baseUrl}/v1/pages/${encodeURIComponent(pageId)}/${action}`, { method: "POST", headers: this.authHeaders() });
+    if (!res.ok)
+      await this.fail(res);
+    return await res.json();
+  }
   async createComment(pageId, opts) {
     const res = await this.fetchImpl(`${this.baseUrl}/v1/pages/${encodeURIComponent(pageId)}/comments`, {
       method: "POST",
@@ -134,21 +158,6 @@ class VellumClient {
       await this.fail(res);
     return await res.json();
   }
-  async listComments(pageId, opts = {}) {
-    const url = new URL(`${this.baseUrl}/v1/pages/${encodeURIComponent(pageId)}/comments`);
-    if (opts.versionId)
-      url.searchParams.set("version_id", opts.versionId);
-    const res = await this.fetchImpl(url, { headers: this.authHeaders() });
-    if (!res.ok)
-      await this.fail(res);
-    return await res.json();
-  }
-  async resolveComment(commentId) {
-    const res = await this.fetchImpl(`${this.baseUrl}/v1/comments/${encodeURIComponent(commentId)}/resolve`, { method: "POST", headers: this.authHeaders() });
-    if (!res.ok)
-      await this.fail(res);
-    return await res.json();
-  }
   async startCliAuth() {
     const res = await this.fetchImpl(`${this.baseUrl}/v1/cli/auth/start`, {
       method: "POST",
@@ -186,143 +195,159 @@ class VellumClient {
       await this.fail(res);
   }
 }
-// src/commands/comments.ts
-var HELP = `vellum comments — list the comments on a document
+// src/commands/archive.ts
+function help(verb) {
+  const what = verb === "archive" ? "hide a page from the gallery and make it read-only" : "restore an archived page to live";
+  return `vellum ${verb} — ${what}
 
 Usage:
-  vellum comments <page-id> [options]
+  vellum ${verb} <page-id> [options]
 
-Reads are public, so no login is required. Comments print as threads; replies
-are indented under their parent.
+${verb === "archive" ? `Archiving keeps the bytes, versions, comments, and URLs intact — new
+versions and comments are paused until you unarchive. Owner/admin only.` : `Unarchiving restores the page to the gallery and re-opens it for new
+versions and comments. Owner/admin only.`}
 
 Options:
-  --open             Show only unresolved threads
-  --version <id>     Only comments anchored to this version id
   --url <url>        Server base URL          (env: VELLUM_URL)
+  --api-key <key>    Shared API key           (env: VELLUM_API_KEY)
   --json             Print the raw JSON response
   -h, --help         Show this help`;
-var truncate = (s, n) => s.length > n ? `${s.slice(0, n - 1)}…` : s;
-var oneLine = (s) => s.replace(/\s+/g, " ").trim();
-function printComment(c, indent) {
-  const who = c.author_email ?? c.author_name ?? "(unknown)";
-  const state = c.resolved ? "resolved" : "open";
-  console.log(`${indent}${c.id}  [${state}]  ${who}`);
-  if (c.anchor?.exact) {
-    console.log(`${indent}  on “${truncate(oneLine(c.anchor.exact), 70)}”`);
-  }
-  console.log(`${indent}  ${truncate(oneLine(c.body), 100)}`);
-  for (const reply of c.replies ?? []) {
-    printComment(reply, `${indent}    `);
-  }
 }
-async function commentsCommand(argv) {
+async function run(verb, argv) {
   const { values, positionals } = parseArgs({
     args: argv,
     allowPositionals: true,
     options: {
-      open: { type: "boolean", default: false },
-      version: { type: "string" },
       url: { type: "string" },
+      "api-key": { type: "string" },
       json: { type: "boolean", default: false },
       help: { type: "boolean", short: "h", default: false }
     }
   });
   if (values.help) {
-    console.log(HELP);
+    console.log(help(verb));
     return 0;
   }
   const pageId = positionals[0];
   if (!pageId) {
     console.error(`Error: missing <page-id>.
 `);
-    console.error(HELP);
+    console.error(help(verb));
     return 1;
   }
-  const baseUrl = resolveBaseUrl({ url: values.url });
-  const client2 = new VellumClient({ baseUrl });
-  let comments = await client2.listComments(pageId, {
-    versionId: values.version
-  });
-  if (values.open)
-    comments = comments.filter((c) => !c.resolved);
-  if (values.json) {
-    console.log(JSON.stringify(comments, null, 2));
-    return 0;
-  }
-  if (comments.length === 0) {
-    console.log(values.open ? "No open comments." : "No comments.");
+  const flags = { url: values.url, apiKey: values["api-key"] };
+  const baseUrl = resolveBaseUrl(flags);
+  const credential = await resolveCredential(flags, baseUrl);
+  const client2 = new VellumClient({ baseUrl, ...credential });
+  try {
+    const res = verb === "archive" ? await client2.archivePage(pageId) : await client2.unarchivePage(pageId);
+    if (values.json) {
+      console.log(JSON.stringify(res, null, 2));
+    } else {
+      console.log(`✓ ${verb}d ${res.id}`);
+    }
     return 0;
+  } catch (err) {
+    if (err instanceof VellumApiError && err.status === 401) {
+      console.error(`Error: ${verb} requires the owner API key. Set VELLUM_API_KEY or pass --api-key.`);
+      return 1;
+    }
+    if (err instanceof VellumApiError && err.status === 404) {
+      console.error(`Error: no page found at ${pageId}.`);
+      return 1;
+    }
+    throw err;
   }
-  for (const c of comments)
-    printComment(c, "");
-  return 0;
+}
+function archiveCommand(argv) {
+  return run("archive", argv);
+}
+function unarchiveCommand(argv) {
+  return run("unarchive", argv);
 }
 
-// src/commands/get.ts
+// src/commands/list.ts
 import { parseArgs as parseArgs2 } from "node:util";
-var HELP2 = `vellum get — print a document's raw HTML
+var HELP = `vellum list — list your artifacts (owner/admin only)
 
 Usage:
-  vellum get <page-id> [options]
+  vellum list [options]
 
-Reads are public, so no login is required. Without --version, the page's
-current version is printed.
+By default only live pages are shown. Use --archived for archived-only, or
+--all for both. Listing requires the owner API key (VELLUM_API_KEY / --api-key).
 
 Options:
-  --version <n>      Print a specific version number (default: current)
+  --archived         Show only archived pages
+  --all              Show both live and archived pages
   --url <url>        Server base URL          (env: VELLUM_URL)
+  --api-key <key>    Shared API key           (env: VELLUM_API_KEY)
+  --json             Print the raw JSON response
   -h, --help         Show this help`;
-function resolveVersion(page, requested) {
-  if (requested != null) {
-    return page.versions.find((v) => v.version_number === requested) ?? null;
-  }
-  const current = page.current_version_id ? page.versions.find((v) => v.id === page.current_version_id) : undefined;
-  return current ?? page.versions[page.versions.length - 1] ?? null;
+function cell(value, width) {
+  if (value.length > width)
+    return `${value.slice(0, width - 1)}…`;
+  return value.padEnd(width);
+}
+function renderTable(pages) {
+  const lines = [
+    `${cell("PAGE", 26)} ${cell("LATEST", 7)} ${cell("VERS", 5)} ${cell("COMM", 5)} TITLE`
+  ];
+  for (const p of pages) {
+    const id = p.archived_at ? `${p.id} *` : p.id;
+    const latest = p.latest_version != null ? `v${p.latest_version}` : "—";
+    lines.push(`${cell(id, 26)} ${cell(latest, 7)} ${cell(String(p.version_count), 5)} ` + `${cell(String(p.comment_count), 5)} ${p.title ?? ""}`.trimEnd());
+  }
+  return lines.join(`
+`);
 }
-async function getCommand(argv) {
-  const { values, positionals } = parseArgs2({
+async function listCommand(argv) {
+  const { values } = parseArgs2({
     args: argv,
-    allowPositionals: true,
+    allowPositionals: false,
     options: {
-      version: { type: "string" },
+      archived: { type: "boolean", default: false },
+      all: { type: "boolean", default: false },
       url: { type: "string" },
+      "api-key": { type: "string" },
+      json: { type: "boolean", default: false },
       help: { type: "boolean", short: "h", default: false }
     }
   });
   if (values.help) {
-    console.log(HELP2);
+    console.log(HELP);
     return 0;
   }
-  const pageId = positionals[0];
-  if (!pageId) {
-    console.error(`Error: missing <page-id>.
-`);
-    console.error(HELP2);
-    return 1;
-  }
-  let version;
-  if (values.version != null) {
-    version = Number.parseInt(values.version, 10);
-    if (!Number.isInteger(version) || version < 1) {
-      console.error("Error: --version must be a positive integer.");
+  const flags = { url: values.url, apiKey: values["api-key"] };
+  const baseUrl = resolveBaseUrl(flags);
+  const credential = await resolveCredential(flags, baseUrl);
+  const client2 = new VellumClient({ baseUrl, ...credential });
+  try {
+    const { pages } = await client2.listPages({
+      archived: values.archived,
+      all: values.all
+    });
+    if (values.json) {
+      console.log(JSON.stringify(pages, null, 2));
+      return 0;
+    }
+    if (pages.length === 0) {
+      const scope = values.archived ? "archived " : "";
+      console.log(`No ${scope}pages.`);
+      return 0;
+    }
+    console.log(renderTable(pages));
+    const archivedCount = pages.filter((p) => p.archived_at).length;
+    const suffix = archivedCount ? ` (${archivedCount} archived, marked *)` : "";
+    console.log(`
+${pages.length} page${pages.length === 1 ? "" : "s"}${suffix}`);
+    return 0;
+  } catch (err) {
+    if (err instanceof VellumApiError && err.status === 401) {
+      console.error("Error: list requires the owner API key. Set VELLUM_API_KEY or pass --api-key.");
       return 1;
     }
+    throw err;
   }
-  const baseUrl = resolveBaseUrl({ url: values.url });
-  const client2 = new VellumClient({ baseUrl });
-  const page = await client2.getPage(pageId);
-  const target = resolveVersion(page, version);
-  if (!target) {
-    console.error(version != null ? `Error: page has no version ${version}.` : "Error: page has no versions.");
-    return 1;
-  }
-  const res = await fetch(target.raw_url);
-  if (!res.ok) {
-    console.error(`Error: could not fetch raw HTML (${res.status}).`);
-    return 1;
-  }
-  process.stdout.write(await res.text());
-  return 0;
 }
 
 // src/commands/login.ts
@@ -344,7 +369,7 @@ function openBrowser(url) {
 }
 
 // src/commands/login.ts
-var HELP3 = `vellum login — authenticate this machine to a Vellum server
+var HELP2 = `vellum login — authenticate this machine to a Vellum server
 
 Opens your browser to approve a CLI login, then stores a token under
 ~/.config/vellum/config.json so future commands authenticate as you.
@@ -367,7 +392,7 @@ async function loginCommand(argv) {
     }
   });
   if (values.help) {
-    console.log(HELP3);
+    console.log(HELP2);
     return 0;
   }
   const baseUrl = resolveBaseUrl({ url: values.url });
@@ -408,7 +433,7 @@ To authorize this CLI, visit:
 
 // src/commands/logout.ts
 import { parseArgs as parseArgs4 } from "node:util";
-var HELP4 = `vellum logout — remove this machine's stored CLI token
+var HELP3 = `vellum logout — remove this machine's stored CLI token
 
 Usage:
   vellum logout [options]
@@ -425,7 +450,7 @@ async function logoutCommand(argv) {
     }
   });
   if (values.help) {
-    console.log(HELP4);
+    console.log(HELP3);
     return 0;
   }
   const baseUrl = resolveBaseUrl({ url: values.url });
@@ -443,7 +468,7 @@ async function logoutCommand(argv) {
 
 // src/commands/markup.ts
 import { parseArgs as parseArgs5 } from "node:util";
-var HELP5 = `vellum markup — pin a comment to a passage of a document
+var HELP4 = `vellum markup — pin a comment to a passage of a document
 
 Usage:
   vellum markup <page-id> --quote "<text>" --body "<note>" [options]
@@ -468,7 +493,7 @@ async function readStdin() {
     chunks.push(chunk);
   return Buffer.concat(chunks).toString("utf8");
 }
-function resolveVersion2(page, requested) {
+function resolveVersion(page, requested) {
   if (requested != null) {
     return page.versions.find((v) => v.version_number === requested) ?? null;
   }
@@ -499,14 +524,14 @@ async function markupCommand(argv) {
     }
   });
   if (values.help) {
-    console.log(HELP5);
+    console.log(HELP4);
     return 0;
   }
   const pageId = positionals[0];
   if (!pageId) {
     console.error(`Error: missing <page-id>.
 `);
-    console.error(HELP5);
+    console.error(HELP4);
     return 1;
   }
   const quote = (values.quote ?? "").trim();
@@ -532,7 +557,7 @@ async function markupCommand(argv) {
   const credential = await resolveCredential(flags, baseUrl);
   const client2 = new VellumClient({ baseUrl, ...credential });
   const page = await client2.getPage(pageId);
-  const target = resolveVersion2(page, version);
+  const target = resolveVersion(page, version);
   if (!target) {
     console.error(version != null ? `Error: page has no version ${version}.` : "Error: page has no versions to mark up.");
     return 1;
@@ -561,50 +586,10 @@ async function markupCommand(argv) {
   return 0;
 }
 
-// src/commands/open.ts
-import { parseArgs as parseArgs6 } from "node:util";
-var HELP6 = `vellum open — print (and open) a document's view URL
-
-Usage:
-  vellum open <page-id> [options]
-
-Options:
-  --no-browser       Just print the URL; don't open the browser
-  --url <url>        Server base URL          (env: VELLUM_URL)
-  -h, --help         Show this help`;
-async function openCommand(argv) {
-  const { values, positionals } = parseArgs6({
-    args: argv,
-    allowPositionals: true,
-    options: {
-      "no-browser": { type: "boolean", default: false },
-      url: { type: "string" },
-      help: { type: "boolean", short: "h", default: false }
-    }
-  });
-  if (values.help) {
-    console.log(HELP6);
-    return 0;
-  }
-  const pageId = positionals[0];
-  if (!pageId) {
-    console.error(`Error: missing <page-id>.
-`);
-    console.error(HELP6);
-    return 1;
-  }
-  const baseUrl = resolveBaseUrl({ url: values.url });
-  const page = await new VellumClient({ baseUrl }).getPage(pageId);
-  console.log(page.view_url);
-  if (!values["no-browser"])
-    openBrowser(page.view_url);
-  return 0;
-}
-
 // src/commands/push.ts
 import { readFile as readFile2 } from "node:fs/promises";
-import { parseArgs as parseArgs7 } from "node:util";
-var HELP7 = `vellum push — create a Vellum artifact from HTML
+import { parseArgs as parseArgs6 } from "node:util";
+var HELP5 = `vellum push — create a Vellum artifact from HTML
 
 Usage:
   vellum push <file.html> [options]
@@ -623,7 +608,7 @@ async function readStdin2() {
   return Buffer.concat(chunks).toString("utf8");
 }
 async function pushCommand(argv) {
-  const { values, positionals } = parseArgs7({
+  const { values, positionals } = parseArgs6({
     args: argv,
     allowPositionals: true,
     options: {
@@ -635,7 +620,7 @@ async function pushCommand(argv) {
     }
   });
   if (values.help) {
-    console.log(HELP7);
+    console.log(HELP5);
     return 0;
   }
   const file = positionals[0];
@@ -658,144 +643,57 @@ async function pushCommand(argv) {
   }
   return 0;
 }
-
-// src/commands/reply.ts
-import { parseArgs as parseArgs8 } from "node:util";
-var HELP8 = `vellum reply — reply to a comment thread
-
-Usage:
-  vellum reply <page-id> <comment-id> --body "<note>"
-  echo "<note>" | vellum reply <page-id> <comment-id>
-
-The reply is threaded under <comment-id> and inherits the parent's version.
-Run \`vellum comments <page-id>\` to find the page and comment ids.
-
-Options:
-  --body <note>      Your reply (or pipe it via stdin)
-  --url <url>        Server base URL          (env: VELLUM_URL)
-  --api-key <key>    Shared API key           (env: VELLUM_API_KEY)
-  --json             Print the raw JSON response
-  -h, --help         Show this help`;
-async function readStdin3() {
-  const chunks = [];
-  for await (const chunk of process.stdin)
-    chunks.push(chunk);
-  return Buffer.concat(chunks).toString("utf8");
-}
-function flatten(comments) {
-  const out = [];
-  const walk = (c) => {
-    out.push(c);
-    for (const reply of c.replies ?? [])
-      walk(reply);
-  };
-  for (const c of comments)
-    walk(c);
-  return out;
-}
-async function replyCommand(argv) {
-  const { values, positionals } = parseArgs8({
-    args: argv,
-    allowPositionals: true,
-    options: {
-      body: { type: "string" },
-      url: { type: "string" },
-      "api-key": { type: "string" },
-      json: { type: "boolean", default: false },
-      help: { type: "boolean", short: "h", default: false }
-    }
-  });
-  if (values.help) {
-    console.log(HELP8);
-    return 0;
-  }
-  const [pageId, commentId] = positionals;
-  if (!pageId || !commentId) {
-    console.error("Error: usage is `vellum reply <page-id> <comment-id>`.\n");
-    console.error(HELP8);
-    return 1;
+// package.json
+var package_default = {
+  name: "vellum-cli",
+  version: "0.3.2",
+  description: "The vellum CLI — publish agent-authored HTML artifacts to a Vellum server.",
+  type: "module",
+  license: "MIT",
+  bin: {
+    vellum: "dist/index.js"
+  },
+  files: [
+    "dist",
+    "README.md"
+  ],
+  engines: {
+    node: ">=18"
+  },
+  keywords: [
+    "vellum",
+    "cli",
+    "html",
+    "artifacts",
+    "agents"
+  ],
+  publishConfig: {
+    access: "public"
+  },
+  scripts: {
+    start: "bun run src/index.ts",
+    build: "bun build src/index.ts --target=node --format=esm --outfile=dist/index.js",
+    prepack: "bun run build",
+    release: "bun publish --access public",
+    typecheck: "tsc -p tsconfig.json --noEmit"
+  },
+  devDependencies: {
+    "@vellum/core": "workspace:*"
   }
-  const body = (values.body ?? await readStdin3()).trim();
-  if (!body) {
-    console.error("Error: no note provided (pass --body or pipe it via stdin).");
-    return 1;
-  }
-  const flags = { url: values.url, apiKey: values["api-key"] };
-  const baseUrl = resolveBaseUrl(flags);
-  const credential = await resolveCredential(flags, baseUrl);
-  const client2 = new VellumClient({ baseUrl, ...credential });
-  const parent = flatten(await client2.listComments(pageId)).find((c) => c.id === commentId);
-  if (!parent) {
-    console.error(`Error: no comment ${commentId} on page ${pageId}.`);
-    return 1;
-  }
-  if (!parent.version_id) {
-    console.error("Error: parent comment has no version to reply on.");
-    return 1;
-  }
-  const reply = await client2.createComment(pageId, {
-    versionId: parent.version_id,
-    body,
-    parentId: commentId
-  });
-  if (values.json) {
-    console.log(JSON.stringify(reply, null, 2));
-  } else {
-    console.log(`✓ replied to ${commentId}`);
-  }
-  return 0;
-}
+};
 
-// src/commands/resolve.ts
-import { parseArgs as parseArgs9 } from "node:util";
-var HELP9 = `vellum resolve — mark a comment as resolved
+// src/version.ts
+var VERSION = package_default.version;
 
-Usage:
-  vellum resolve <comment-id> [options]
-
-Options:
-  --url <url>        Server base URL          (env: VELLUM_URL)
-  --api-key <key>    Shared API key           (env: VELLUM_API_KEY)
-  --json             Print the raw JSON response
-  -h, --help         Show this help`;
-async function resolveCommand(argv) {
-  const { values, positionals } = parseArgs9({
-    args: argv,
-    allowPositionals: true,
-    options: {
-      url: { type: "string" },
-      "api-key": { type: "string" },
-      json: { type: "boolean", default: false },
-      help: { type: "boolean", short: "h", default: false }
-    }
-  });
-  if (values.help) {
-    console.log(HELP9);
-    return 0;
-  }
-  const commentId = positionals[0];
-  if (!commentId) {
-    console.error(`Error: missing <comment-id>.
-`);
-    console.error(HELP9);
-    return 1;
-  }
-  const flags = { url: values.url, apiKey: values["api-key"] };
-  const baseUrl = resolveBaseUrl(flags);
-  const credential = await resolveCredential(flags, baseUrl);
-  const client2 = new VellumClient({ baseUrl, ...credential });
-  const comment = await client2.resolveComment(commentId);
-  if (values.json) {
-    console.log(JSON.stringify(comment, null, 2));
-  } else {
-    console.log(`✓ resolved ${comment.id}`);
-  }
+// src/commands/version.ts
+async function versionCommand(_argv) {
+  console.log(VERSION);
   return 0;
 }
 
 // src/commands/whoami.ts
-import { parseArgs as parseArgs10 } from "node:util";
-var HELP10 = `vellum whoami — show the identity the CLI is authenticated as
+import { parseArgs as parseArgs7 } from "node:util";
+var HELP6 = `vellum whoami — show the identity the CLI is authenticated as
 
 Usage:
   vellum whoami [options]
@@ -805,7 +703,7 @@ Options:
   --api-key <key>    Shared API key           (env: VELLUM_API_KEY)
   -h, --help         Show this help`;
 async function whoamiCommand(argv) {
-  const { values } = parseArgs10({
+  const { values } = parseArgs7({
     args: argv,
     options: {
       url: { type: "string" },
@@ -814,7 +712,7 @@ async function whoamiCommand(argv) {
     }
   });
   if (values.help) {
-    console.log(HELP10);
+    console.log(HELP6);
     return 0;
   }
   const baseUrl = resolveBaseUrl({ url: values.url });
@@ -830,7 +728,7 @@ async function whoamiCommand(argv) {
 }
 
 // src/index.ts
-var HELP11 = `vellum — CLI for the Vellum artifact store
+var HELP7 = `vellum — CLI for the Vellum artifact store
 
 Usage:
   vellum <command> [options]
@@ -840,12 +738,11 @@ Commands:
   logout    Remove this machine's stored CLI token
   whoami    Show the identity the CLI is authenticated as
   push      Create an artifact (page) from HTML (file or stdin)
-  get       Print a document's raw HTML
-  open      Print (and open) a document's view URL
+  list      List your artifacts (owner/admin only)
   markup    Pin a comment to a passage of a document
-  comments  List the comments on a document
-  reply     Reply to a comment thread
-  resolve   Mark a comment as resolved
+  archive   Archive a page (read-only, hidden from the gallery)
+  unarchive Restore an archived page to live
+  version   Print the installed CLI version
 
 Run 'vellum <command> --help' for command-specific options.`;
 var commands = {
@@ -853,24 +750,26 @@ var commands = {
   logout: logoutCommand,
   whoami: whoamiCommand,
   push: pushCommand,
-  get: getCommand,
-  open: openCommand,
+  list: listCommand,
   markup: markupCommand,
-  comments: commentsCommand,
-  reply: replyCommand,
-  resolve: resolveCommand
+  archive: archiveCommand,
+  unarchive: unarchiveCommand,
+  version: versionCommand
 };
 async function main() {
   const [, , cmd, ...rest] = process.argv;
   if (!cmd || cmd === "-h" || cmd === "--help" || cmd === "help") {
-    console.log(HELP11);
+    console.log(HELP7);
     return cmd ? 0 : 1;
   }
+  if (cmd === "-v" || cmd === "--version") {
+    return versionCommand(rest);
+  }
   const handler = commands[cmd];
   if (!handler) {
     console.error(`Unknown command: ${cmd}
 `);
-    console.error(HELP11);
+    console.error(HELP7);
     return 1;
   }
   return handler(rest);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vellum-cli",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "The vellum CLI — publish agent-authored HTML artifacts to a Vellum server.",
   "type": "module",
   "license": "MIT",
@@ -28,9 +28,10 @@
     "start": "bun run src/index.ts",
     "build": "bun build src/index.ts --target=node --format=esm --outfile=dist/index.js",
     "prepack": "bun run build",
+    "release": "bun publish --access public",
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "devDependencies": {
-    "@vellum/core": "workspace:*"
+    "@vellum/core": "0.1.0"
   }
 }