@agentprojectcontext/apx 1.66.0 → 1.68.0

package/src/interfaces/acp/jsonrpc.js

@@ -0,0 +1,180 @@
+// Newline-delimited JSON-RPC 2.0 connection — the ACP stdio framing.
+//
+// Per the ACP transport spec (agentclientprotocol.com, transports.mdx):
+// messages are individual JSON-RPC requests/notifications/responses, UTF-8,
+// delimited by "\n", never containing embedded newlines. Both peers can act
+// as caller and callee (the agent calls `session/request_permission` on the
+// client), so this connection is symmetric: it dispatches incoming requests
+// to registered handlers AND tracks ids of our own outgoing requests.
+//
+// Hand-rolled on purpose — the repo rule is no new npm dependencies, and the
+// framing is small enough that a library would cost more than it saves.
+
+export const JSONRPC_ERROR_CODES = Object.freeze({
+  PARSE_ERROR: -32700,
+  INVALID_REQUEST: -32600,
+  METHOD_NOT_FOUND: -32601,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603,
+});
+
+export class JsonRpcError extends Error {
+  constructor(code, message, data) {
+    super(message);
+    this.code = code;
+    if (data !== undefined) this.data = data;
+  }
+}
+
+export class JsonRpcConnection {
+  /**
+   * @param {{ input: import("node:stream").Readable,
+   *           output: import("node:stream").Writable,
+   *           onError?: (err: Error) => void }} opts
+   */
+  constructor({ input, output, onError = null }) {
+    this.output = output;
+    this.onError = onError;
+    this.handlers = new Map();
+    this.pending = new Map(); // id → {resolve, reject} for our outgoing requests
+    this.nextId = 0;
+    this.buffer = "";
+    this.closed = false;
+    this._closeResolvers = [];
+
+    input.setEncoding?.("utf8");
+    input.on("data", (chunk) => this._onData(String(chunk)));
+    input.on("end", () => this._close());
+    input.on("close", () => this._close());
+    input.on("error", () => this._close());
+  }
+
+  /** Register a handler for an incoming method (request or notification). */
+  method(name, handler) {
+    this.handlers.set(name, handler);
+    return this;
+  }
+
+  /** Resolves when the peer closes its side of the pipe. */
+  whenClosed() {
+    if (this.closed) return Promise.resolve();
+    return new Promise((resolve) => this._closeResolvers.push(resolve));
+  }
+
+  /** Send a one-way notification to the peer. */
+  notify(method, params) {
+    this._send({ jsonrpc: "2.0", method, params });
+  }
+
+  /** Send a request to the peer and await its response. */
+  request(method, params) {
+    const id = ++this.nextId;
+    return new Promise((resolve, reject) => {
+      if (this.closed) return reject(new Error("connection closed"));
+      this.pending.set(id, { resolve, reject });
+      this._send({ jsonrpc: "2.0", id, method, params });
+    });
+  }
+
+  _close() {
+    if (this.closed) return;
+    this.closed = true;
+    for (const { reject } of this.pending.values()) {
+      reject(new Error("connection closed"));
+    }
+    this.pending.clear();
+    for (const resolve of this._closeResolvers) resolve();
+    this._closeResolvers = [];
+  }
+
+  _send(msg) {
+    if (this.closed) return;
+    try {
+      this.output.write(JSON.stringify(msg) + "\n");
+    } catch (e) {
+      this.onError?.(e);
+    }
+  }
+
+  _onData(text) {
+    this.buffer += text;
+    let idx;
+    while ((idx = this.buffer.indexOf("\n")) !== -1) {
+      const line = this.buffer.slice(0, idx).trim();
+      this.buffer = this.buffer.slice(idx + 1);
+      if (!line) continue;
+      let msg;
+      try {
+        msg = JSON.parse(line);
+      } catch {
+        this._send({
+          jsonrpc: "2.0",
+          id: null,
+          error: { code: JSONRPC_ERROR_CODES.PARSE_ERROR, message: "parse error" },
+        });
+        continue;
+      }
+      // Fire-and-forget: a long-running request (session/prompt) must not
+      // block later frames — `session/cancel` has to be processed while the
+      // prompt handler is still awaiting the daemon stream.
+      this._dispatch(msg).catch((e) => this.onError?.(e));
+    }
+  }
+
+  async _dispatch(msg) {
+    if (!msg || typeof msg !== "object") return;
+
+    if (typeof msg.method === "string") {
+      const hasId = msg.id !== undefined && msg.id !== null;
+      const handler = this.handlers.get(msg.method);
+      if (!handler) {
+        if (hasId) {
+          this._send({
+            jsonrpc: "2.0",
+            id: msg.id,
+            error: {
+              code: JSONRPC_ERROR_CODES.METHOD_NOT_FOUND,
+              message: `method not found: ${msg.method}`,
+            },
+          });
+        }
+        return;
+      }
+      try {
+        const result = await handler(msg.params ?? {});
+        if (hasId) this._send({ jsonrpc: "2.0", id: msg.id, result: result ?? null });
+      } catch (e) {
+        if (hasId) {
+          this._send({
+            jsonrpc: "2.0",
+            id: msg.id,
+            error: {
+              code: typeof e?.code === "number" ? e.code : JSONRPC_ERROR_CODES.INTERNAL_ERROR,
+              message: e?.message || "internal error",
+              ...(e?.data !== undefined ? { data: e.data } : {}),
+            },
+          });
+        } else {
+          this.onError?.(e);
+        }
+      }
+      return;
+    }
+
+    // Response to one of our outgoing requests.
+    if (msg.id !== undefined && this.pending.has(msg.id)) {
+      const { resolve, reject } = this.pending.get(msg.id);
+      this.pending.delete(msg.id);
+      if (msg.error) {
+        reject(
+          Object.assign(new Error(msg.error.message || "remote error"), {
+            code: msg.error.code,
+            data: msg.error.data,
+          })
+        );
+      } else {
+        resolve(msg.result);
+      }
+    }
+  }
+}

package/src/interfaces/acp/session.js

@@ -0,0 +1,205 @@
+// ACP session plumbing — daemon HTTP client, project resolution for a
+// session's cwd, and the small mapping helpers between APX daemon stream
+// events and ACP wire shapes.
+//
+// The daemon client is deliberately NOT the CLI's http.js: that module pins
+// its base URL to env vars at import time, while tests (and future embeddings)
+// need a per-instance {baseUrl, token}. The NDJSON reader mirrors
+// src/interfaces/cli/http.js streamRequest so both surfaces parse the daemon
+// stream identically.
+
+import path from "node:path";
+import { findApfRoot } from "#core/apc/parser.js";
+
+/**
+ * Minimal daemon HTTP client bound to an injected base URL + token.
+ * `token` may be a string or a () => string (re-read per request so a daemon
+ * restart with a rotated token keeps working mid-session).
+ */
+export function createDaemonClient({ baseUrl, token = "", ensureReady = null }) {
+  const authHeaders = () => {
+    const t = typeof token === "function" ? token() : token;
+    return t ? { authorization: `Bearer ${t}` } : {};
+  };
+
+  async function request(method, p, body) {
+    if (ensureReady) await ensureReady();
+    const res = await fetch(`${baseUrl}${p}`, {
+      method,
+      headers: {
+        ...(body ? { "content-type": "application/json" } : {}),
+        ...authHeaders(),
+      },
+      body: body ? JSON.stringify(body) : undefined,
+    });
+    const text = await res.text();
+    let json = null;
+    try {
+      json = text ? JSON.parse(text) : null;
+    } catch {
+      /* non-JSON body — handled below */
+    }
+    if (!res.ok) throw new Error(json?.error || `${method} ${p} → ${res.status}`);
+    return json;
+  }
+
+  /**
+   * POST to an NDJSON stream endpoint. Awaits `onEvent` per event so a
+   * confirmation round-trip naturally back-pressures the stream. Returns the
+   * `result` of the `{type:"final"}` event, or null when aborted early.
+   */
+  async function streamPost(p, body, onEvent, { signal } = {}) {
+    if (ensureReady) await ensureReady();
+    const res = await fetch(`${baseUrl}${p}`, {
+      method: "POST",
+      headers: { "content-type": "application/json", ...authHeaders() },
+      body: JSON.stringify(body),
+      signal,
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      let json = null;
+      try {
+        json = text ? JSON.parse(text) : null;
+      } catch {}
+      throw new Error(json?.error || `POST ${p} → ${res.status}`);
+    }
+    if (!res.body?.getReader) {
+      throw new Error("streaming response is not supported by this Node.js runtime");
+    }
+
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let finalResult = null;
+
+    if (signal) {
+      signal.addEventListener("abort", () => reader.cancel().catch(() => {}), { once: true });
+    }
+
+    const handleLine = async (line) => {
+      if (!line.trim()) return;
+      const event = JSON.parse(line);
+      if (event.type === "final") finalResult = event.result;
+      if (event.type === "error") throw new Error(event.error || "stream error");
+      await onEvent?.(event);
+    };
+
+    while (true) {
+      let chunk;
+      try {
+        chunk = await reader.read();
+      } catch {
+        break; // abort/cancel — treat as clean end, caller checks its own flag
+      }
+      if (chunk.done) break;
+      buffer += decoder.decode(chunk.value, { stream: true });
+      const lines = buffer.split(/\r?\n/);
+      buffer = lines.pop() || "";
+      for (const line of lines) await handleLine(line);
+    }
+
+    buffer += decoder.decode();
+    if (buffer.trim()) {
+      try {
+        await handleLine(buffer);
+      } catch {}
+    }
+
+    return finalResult;
+  }
+
+  return {
+    baseUrl,
+    get: (p) => request("GET", p),
+    post: (p, body) => request("POST", p, body),
+    streamPost,
+  };
+}
+
+/**
+ * Resolve the APC project for an ACP session's cwd — same contract as the
+ * mcp-server surface: walk up to the .apc root, match a registered daemon
+ * project by path, register it when unknown.
+ */
+export async function resolveProjectForCwd(client, cwd) {
+  const root = findApfRoot(cwd || process.cwd());
+  if (!root) {
+    throw new Error(
+      `No APC project found at or above: ${cwd}. Run \`apx init\` in the workspace first.`
+    );
+  }
+  const projects = await client.get("/projects");
+  const match = (projects || []).find(
+    (p) => path.resolve(p.path) === path.resolve(root)
+  );
+  if (match) return match;
+  return client.post("/projects", { path: root });
+}
+
+/** Flatten an ACP prompt (ContentBlock[]) into the text the daemon expects. */
+export function extractPromptText(blocks) {
+  if (typeof blocks === "string") return blocks;
+  if (!Array.isArray(blocks)) return "";
+  const parts = [];
+  for (const block of blocks) {
+    if (!block || typeof block !== "object") continue;
+    if (block.type === "text" && typeof block.text === "string") {
+      parts.push(block.text);
+    } else if (block.type === "resource_link" && block.uri) {
+      // Baseline capability: resource links arrive as URIs; surface them to
+      // the model as plain references (we don't fetch on the agent side).
+      parts.push(String(block.uri));
+    }
+  }
+  return parts.join("\n").trim();
+}
+
+// Best-effort mapping from APX tool names (snake_case verbs) to ACP ToolKind.
+const KIND_RULES = [
+  [/^(search|find)_/, "search"],
+  [/^(read|list|get|show)_/, "read"],
+  [/^(edit|write|update|set|create|add|remember|import)_?/, "edit"],
+  [/^(delete|remove)_/, "delete"],
+  [/(shell|exec|run|call)/, "execute"],
+  [/(fetch|http|web|download)/, "fetch"],
+];
+
+export function toolKindFor(toolName) {
+  const name = String(toolName || "").toLowerCase();
+  for (const [re, kind] of KIND_RULES) {
+    if (re.test(name)) return kind;
+  }
+  return "other";
+}
+
+/** Compact text summary of a tool result for tool_call_update content. */
+export function summarizeToolResult(result, max = 2000) {
+  let text;
+  if (result == null) text = "";
+  else if (typeof result === "string") text = result;
+  else {
+    try {
+      text = JSON.stringify(result, null, 2);
+    } catch {
+      text = String(result);
+    }
+  }
+  return text.length > max ? text.slice(0, max - 1) + "…" : text;
+}
+
+let sessionCounter = 0;
+
+/** Per-connection session state. History feeds `previousMessages` so multi-turn
+ * ACP sessions keep context without any daemon-side session storage. */
+export function createSession({ id, project, cwd }) {
+  sessionCounter += 1;
+  return {
+    id,
+    project,
+    cwd,
+    history: [], // [{role: "user"|"assistant", content: string}]
+    activeTurn: null, // { abort: AbortController, cancelled: boolean }
+    seq: sessionCounter,
+  };
+}

package/src/interfaces/cli/commands/acp.js

@@ -0,0 +1,10 @@
+// apx acp — serve the APX super-agent over the Agent Client Protocol on the
+// current stdio. ACP clients (Zed, JetBrains, marimo, …) spawn this command
+// as a subprocess and speak JSON-RPC over stdin/stdout, so the command must
+// never print to stdout itself; all human-facing output goes to stderr.
+
+export async function cmdAcp() {
+  const { startStdioAcpServer } = await import("#interfaces/acp/index.js");
+  process.stderr.write("apx acp: Agent Client Protocol server on stdio (ctrl-c to stop)\n");
+  await startStdioAcpServer();
+}

package/src/interfaces/cli/commands/artifact.js

@@ -1,9 +1,20 @@
 import fs from "node:fs";
 import { spawn } from "node:child_process";
 import path from "node:path";
+import open from "open";
 import { http } from "../http.js";
 import { resolveProjectId } from "./project.js";
 
+// Emit an OSC 8 terminal hyperlink when stdout is a TTY that likely supports
+// it (iTerm2, modern VS Code, kitty, WezTerm, …). Falls back to the raw URL
+// elsewhere so the link is always at least copy-pasteable.
+function hyperlink(url, label = url) {
+  if (process.stdout.isTTY) {
+    return `\x1b]8;;${url}\x07${label}\x1b]8;;\x07`;
+  }
+  return label === url ? url : `${label} (${url})`;
+}
+
 // First two bytes of an executable script. Used as a hint when the file
 // doesn't have the exec bit but clearly intends to run (shebang line).
 const SHEBANG = "#!";
@@ -142,3 +153,107 @@ export async function cmdArtifactRun(args) {
     });
   });
 }
+
+// `apx artifact preview <name> [--open] [--share] [--no-watch]`
+//
+// Asks the daemon to spin up an ephemeral local web server that renders the
+// artifact (HTML / React / static) and prints an interactive localhost link.
+// The page auto-reloads when the artifact file changes (unless --no-watch).
+// With --open the link is opened in the default browser; with --share a public
+// tunnel URL is created too.
+export async function cmdArtifactPreview(args) {
+  const name = args._[0];
+  if (!name) throw new Error("apx artifact preview: missing <name>");
+  const pid = await resolveProjectId(args?.flags?.project);
+  const watch = args.flags["no-watch"] ? false : true;
+
+  let view;
+  try {
+    view = await http.post(
+      `/projects/${pid}/artifacts/${encodeURIComponent(name)}/preview`,
+      { watch }
+    );
+  } catch (e) {
+    throw new Error(`could not preview "${name}": ${e.message}`);
+  }
+
+  console.log(`preview ready — ${view.kind} artifact "${view.name}"`);
+  console.log(`  local:  ${hyperlink(view.url)}`);
+  if (view.watch) console.log("  (auto-reloads on change — edit the artifact and the tab refreshes)");
+  console.log(`  stop:   apx artifact stop ${view.id}`);
+
+  if (args.flags.share) {
+    await sharePreview(view.id, { open: !!args.flags.open });
+  } else if (args.flags.open) {
+    await open(view.url);
+    console.log("  opened in your browser.");
+  } else {
+    console.log(`  open:   apx artifact preview ${name} --open`);
+  }
+}
+
+// Shared helper: open a tunnel for an existing preview id and print the URL.
+async function sharePreview(previewId, { open: doOpen = false } = {}) {
+  let tunnel;
+  try {
+    tunnel = await http.post(`/previews/${previewId}/tunnel`, {});
+  } catch (e) {
+    throw new Error(`could not create tunnel: ${e.message}`);
+  }
+  console.log(`  public: ${hyperlink(tunnel.url)}  (${tunnel.provider})`);
+  console.log("  ⚠ anyone with this URL can reach the preview while it's open.");
+  if (doOpen) {
+    await open(tunnel.url);
+    console.log("  opened public URL in your browser.");
+  }
+}
+
+// `apx artifact share <name> [--open] [--no-watch]`
+// Convenience: preview + tunnel in one shot.
+export async function cmdArtifactShare(args) {
+  const name = args._[0];
+  if (!name) throw new Error("apx artifact share: missing <name>");
+  const pid = await resolveProjectId(args?.flags?.project);
+  const watch = args.flags["no-watch"] ? false : true;
+
+  const view = await http.post(
+    `/projects/${pid}/artifacts/${encodeURIComponent(name)}/preview`,
+    { watch }
+  );
+  console.log(`sharing ${view.kind} artifact "${view.name}"`);
+  console.log(`  local:  ${hyperlink(view.url)}`);
+  await sharePreview(view.id, { open: !!args.flags.open });
+  console.log(`  stop:   apx artifact stop ${view.id}`);
+}
+
+// `apx artifact previews` — list running preview servers.
+export async function cmdArtifactPreviews(args = {}) {
+  const rows = await http.get(`/previews`);
+  if (!rows.length) {
+    console.log("(no running previews)");
+    return;
+  }
+  console.log("ID".padEnd(10) + "NAME".padEnd(24) + "KIND".padEnd(8) + "URL");
+  for (const r of rows) {
+    console.log(
+      r.id.padEnd(10) +
+      String(r.name).slice(0, 22).padEnd(24) +
+      String(r.kind).padEnd(8) +
+      r.url + (r.tunnel ? `  → ${r.tunnel.url}` : "")
+    );
+  }
+}
+
+// `apx artifact stop <id> | --all` — stop preview server(s).
+export async function cmdArtifactStop(args) {
+  if (args.flags.all) {
+    const rows = await http.get(`/previews`);
+    for (const r of rows) await http.delete(`/previews/${r.id}`);
+    console.log(`stopped ${rows.length} preview(s)`);
+    return;
+  }
+  const id = args._[0];
+  if (!id) throw new Error("apx artifact stop: missing <id> (or --all)");
+  await http.delete(`/previews/${encodeURIComponent(id)}`);
+  console.log(`stopped preview ${id}`);
+}

package/src/interfaces/cli/index.js

@@ -91,6 +91,7 @@ import {
   cmdConversationsGet,
 } from "./commands/chat.js";
 import { cmdCode } from "./commands/code.js";
+import { cmdAcp } from "./commands/acp.js";
 import { cmdRun, cmdEnvDetect } from "./commands/runtime.js";
 import { cmdSend, cmdConnections } from "./commands/a2a.js";
 import {
@@ -130,6 +131,10 @@ import {
   cmdArtifactShow,
   cmdArtifactRemove,
   cmdArtifactRun,
+  cmdArtifactPreview,
+  cmdArtifactShare,
+  cmdArtifactPreviews,
+  cmdArtifactStop,
 } from "./commands/artifact.js";
 import {
   cmdTaskAdd,
@@ -1133,6 +1138,17 @@ const HELP_TOPICS = new Map(Object.entries({
     ],
     examples: ["apx chat reviewer", "apx chat reviewer --conversation abc123"],
   }),
+  acp: topic({
+    title: "apx acp",
+    summary: "Serve the APX super-agent over the Agent Client Protocol (ACP) on stdio.",
+    usage: ["apx acp"],
+    notes: [
+      "For ACP clients (Zed, JetBrains, marimo, …) that spawn agents as subprocesses.",
+      "stdout carries the protocol — logs go to stderr and ~/.apx/logs/apx.log.",
+      "Sessions resolve the APC project from the client's workspace cwd.",
+    ],
+    examples: ["apx acp"],
+  }),
   code: topic({
     title: "apx code",
     summary: "Start the APX terminal coding assistant with system and workspace context.",
@@ -1315,6 +1331,10 @@ const HELP_TOPICS = new Map(Object.entries({
       ["list | ls", "List artifacts in the project."],
       ["show <name>", "Print artifact content."],
       ["run <name> [args...]", "Execute a runnable artifact (shebang or +x). Stdio is inherited."],
+      ["preview <name> [--open] [--share]", "Serve HTML/React/static artifacts on an ephemeral local server with live-reload."],
+      ["share <name> [--open]", "Preview + open a public tunnel URL (cloudflared/localtunnel)."],
+      ["previews", "List running preview servers."],
+      ["stop <id> | --all", "Stop a preview server."],
       ["remove | rm <name>", "Delete an artifact."],
     ],
     examples: [
@@ -1322,8 +1342,49 @@ const HELP_TOPICS = new Map(Object.entries({
       "apx artifact list",
       "apx artifact show check_asana.sh",
       "apx artifact run check_asana.sh",
+      "apx artifact preview dashboard.html --open",
+      "apx artifact share report.jsx",
+    ],
+  }),
+  "artifact preview": topic({
+    title: "apx artifact preview",
+    summary: "Serve an artifact on an ephemeral local web server and print an interactive link. HTML, single-file React (.jsx/.tsx), static dirs, and text are all rendered; the page auto-reloads when the file changes.",
+    usage: ["apx artifact preview <name> [--open] [--share] [--no-watch] [--project <name|id|path>]"],
+    options: [
+      ["--open", "Open the local URL in your default browser."],
+      ["--share", "Also create a public tunnel URL for quick sharing."],
+      ["--no-watch", "Disable live-reload on file change."],
+      ["--project <name|id|path>", "Pin command to a specific project."],
+    ],
+    examples: [
+      "apx artifact preview dashboard.html --open",
+      "apx artifact preview app.jsx --share",
     ],
   }),
+  "artifact share": topic({
+    title: "apx artifact share",
+    summary: "Preview an artifact and expose it through a secure public tunnel (cloudflared, falling back to localtunnel). Prints a temporary public URL anyone can open.",
+    usage: ["apx artifact share <name> [--open] [--no-watch] [--project <name|id|path>]"],
+    options: [
+      ["--open", "Open the public URL in your default browser."],
+      ["--no-watch", "Disable live-reload on file change."],
+      ["--project <name|id|path>", "Pin command to a specific project."],
+    ],
+    examples: ["apx artifact share report.jsx --open"],
+  }),
+  "artifact previews": topic({
+    title: "apx artifact previews",
+    summary: "List running artifact preview servers (id, name, kind, local + public URLs).",
+    usage: ["apx artifact previews"],
+    examples: ["apx artifact previews"],
+  }),
+  "artifact stop": topic({
+    title: "apx artifact stop",
+    summary: "Stop a running preview server (and its tunnel).",
+    usage: ["apx artifact stop <id>", "apx artifact stop --all"],
+    options: [["--all", "Stop every running preview."]],
+    examples: ["apx artifact stop 3f9a1c2b", "apx artifact stop --all"],
+  }),
   "artifact create": topic({
     title: "apx artifact create",
     summary: "Create a new managed artifact file.",
@@ -2099,6 +2160,7 @@ function buildHelp(version) {
     hCmd("apx search \"query\"",       36, "web search (ddg | brave | browser)  --mode <m>  -n N"),
     hCmd("apx conversations list",     36, "stored exec/chat conversations for <agent>"),
     hCmd("apx conversations get",      36, "<agent> <id>"),
+    hCmd("apx acp",                    36, "serve the super-agent over the Agent Client Protocol (stdio, for IDEs)"),
 
     hSec("Runtimes"),
     hCmd("apx run <agent>",            36, "--runtime <id> \"prompt\"  --timeout <s>"),
@@ -2137,6 +2199,9 @@ function buildHelp(version) {
     hCmd("apx artifact create <name>", 36, "create managed file in project storage  [--content '...'] [--project 0]"),
     hCmd("apx artifact list",          36, "list artifacts"),
     hCmd("apx artifact show <name>",   36, "print artifact content"),
+    hCmd("apx artifact preview <name>",36, "serve HTML/React on a local URL w/ live-reload  [--open] [--share]"),
+    hCmd("apx artifact share <name>",  36, "preview + public tunnel URL"),
+    hCmd("apx artifact previews",      36, "list running previews  (stop with: apx artifact stop <id>)"),
     hCmd("apx artifact remove <name>", 36, ""),
 
     hSec("Commands & Skills"),
@@ -2516,6 +2581,11 @@ async function dispatch(cmd, rest) {
         await cmdExec(parseArgs(rest));
         break;
 
+      case "acp":
+        // ACP server owns stdio until the client closes the pipe.
+        await cmdAcp(parseArgs(rest));
+        return;
+
       case "search":
         await cmdSearch(parseArgs(rest));
         break;
@@ -2613,6 +2683,10 @@ async function dispatch(cmd, rest) {
         else if (sub === "show" || sub === "get") await cmdArtifactShow(a);
         else if (sub === "remove" || sub === "rm") await cmdArtifactRemove(a);
         else if (sub === "run") await cmdArtifactRun(a);
+        else if (sub === "preview" || sub === "serve") await cmdArtifactPreview(a);
+        else if (sub === "share") await cmdArtifactShare(a);
+        else if (sub === "previews") await cmdArtifactPreviews(a);
+        else if (sub === "stop") await cmdArtifactStop(a);
         else die(`unknown artifact subcommand: ${sub}`);
         break;
       }