artifact-cafe 0.0.0 → 0.0.1

package/dist/index.js

@@ -0,0 +1,760 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { defineCommand, runMain } from "citty";
+
+// src/comments.ts
+import path2 from "path";
+
+// ../shared/src/publish.ts
+import { z } from "zod";
+function isSafeArtifactPath(p) {
+  if (p.length === 0 || p.length > 1024) return false;
+  if (p.includes("\\") || p.includes("\0")) return false;
+  if (p.startsWith("/") || p.startsWith("~")) return false;
+  return p.split("/").every((seg) => seg.length > 0 && seg !== "." && seg !== "..");
+}
+var manifestFileSchema = z.object({
+  path: z.string().min(1).max(1024).refine(isSafeArtifactPath, { message: "path must be a safe relative path" }),
+  hash: z.string().regex(/^sha256_[a-f0-9]{64}$/),
+  size: z.number().int().positive(),
+  mimeType: z.string().regex(/^[-\w.+]+\/[-\w.+]+$/, { message: "invalid MIME type" })
+});
+var publishSourceSchema = z.object({
+  type: z.literal("cli"),
+  agent: z.string().optional(),
+  runId: z.string().optional()
+});
+var createPublishSessionSchema = z.object({
+  artifactId: z.string().nullable(),
+  title: z.string().max(200).optional(),
+  entryPath: z.string().optional(),
+  files: z.array(manifestFileSchema).min(1).max(1e3),
+  source: publishSourceSchema
+});
+var publishSessionResponseSchema = z.object({
+  publishSessionId: z.string(),
+  artifactId: z.string(),
+  versionId: z.string(),
+  filesToUpload: z.array(
+    z.object({
+      path: z.string(),
+      uploadUrl: z.string().url(),
+      method: z.literal("PUT")
+    })
+  ),
+  skippedFiles: z.array(z.string()),
+  expiresAt: z.string()
+});
+var finalizeResponseSchema = z.object({
+  artifactId: z.string(),
+  versionId: z.string(),
+  versionNumber: z.number().int().positive(),
+  url: z.string().url(),
+  // Returned only on first publish of a new artifact (one-time).
+  claimUrl: z.string().url().optional(),
+  publishToken: z.string().optional()
+});
+var artifactResponseSchema = z.object({
+  id: z.string(),
+  slug: z.string(),
+  title: z.string(),
+  currentVersion: z.object({
+    id: z.string(),
+    versionNumber: z.number().int().positive(),
+    entryUrl: z.string().url()
+  }).nullable(),
+  claimed: z.boolean()
+});
+
+// ../shared/src/comments.ts
+import { z as z2 } from "zod";
+var elementSnapshotSchema = z2.object({
+  tag: z2.string().min(1).max(128),
+  id: z2.string().max(256).optional(),
+  classes: z2.string().max(256).optional(),
+  text: z2.string().max(200).optional()
+});
+var pointAnchorSchema = z2.object({
+  type: z2.literal("point"),
+  // elementPath is the primary anchor; x/y are offsets within the
+  // element's box, normalized 0..1 (SPEC.md §8.1).
+  elementPath: z2.string().max(2048),
+  x: z2.number().min(0).max(1),
+  y: z2.number().min(0).max(1),
+  viewportWidth: z2.number().int().positive().max(1e5),
+  viewportHeight: z2.number().int().positive().max(1e5),
+  element: elementSnapshotSchema.optional()
+});
+var textAnchorSchema = z2.object({
+  type: z2.literal("text"),
+  quote: z2.string().min(1).max(1e3),
+  prefix: z2.string().max(200).optional(),
+  suffix: z2.string().max(200).optional(),
+  startOffset: z2.number().int().nonnegative().max(1e8),
+  endOffset: z2.number().int().nonnegative().max(1e8),
+  elementPath: z2.string().max(2048)
+});
+var anchorSchema = z2.discriminatedUnion("type", [
+  pointAnchorSchema,
+  textAnchorSchema
+]);
+var guestSchema = z2.object({
+  guestId: z2.string().min(16),
+  displayName: z2.string().min(1).max(64)
+});
+var createCommentThreadSchema = z2.object({
+  versionId: z2.string(),
+  guest: guestSchema.optional(),
+  anchor: anchorSchema,
+  body: z2.string().min(1).max(1e4)
+});
+var createCommentMessageSchema = z2.object({
+  guest: guestSchema.optional(),
+  body: z2.string().min(1).max(1e4)
+});
+var threadActionSchema = z2.object({
+  guest: guestSchema.optional()
+});
+var commentAuthorSchema = z2.object({
+  guestId: z2.string().nullable(),
+  displayName: z2.string()
+});
+var commentMessageSchema = z2.object({
+  id: z2.string(),
+  body: z2.string(),
+  author: commentAuthorSchema,
+  createdAt: z2.string()
+});
+var commentThreadSchema = z2.object({
+  id: z2.string(),
+  artifactId: z2.string(),
+  versionId: z2.string(),
+  anchor: anchorSchema,
+  status: z2.enum(["open", "resolved"]),
+  createdBy: commentAuthorSchema,
+  createdAt: z2.string(),
+  messages: z2.array(commentMessageSchema)
+});
+var commentThreadListSchema = z2.object({
+  threads: z2.array(commentThreadSchema)
+});
+var commentExportQuerySchema = z2.object({
+  status: z2.enum(["open", "resolved", "all"]).default("open"),
+  version: z2.enum(["current", "all"]).default("current")
+});
+var commentExportReplySchema = z2.object({
+  author: z2.string(),
+  body: z2.string(),
+  createdAt: z2.string()
+});
+var commentExportThreadSchema = z2.object({
+  id: z2.string(),
+  status: z2.enum(["open", "resolved"]),
+  versionNumber: z2.number().int().positive(),
+  author: z2.string(),
+  body: z2.string(),
+  anchor: anchorSchema,
+  createdAt: z2.string(),
+  replies: z2.array(commentExportReplySchema)
+});
+var commentExportSchema = z2.object({
+  artifactId: z2.string(),
+  // The artifact's current version (null before the first finalize).
+  versionNumber: z2.number().int().positive().nullable(),
+  comments: z2.array(commentExportThreadSchema)
+});
+function elementLabel(el) {
+  if (el.id) return `<${el.tag}#${el.id}>`;
+  const classes = el.classes ? el.classes.split(" ").slice(0, 2) : [];
+  return classes.length ? `<${el.tag}.${classes.join(".")}>` : `<${el.tag}>`;
+}
+
+// ../shared/src/errors.ts
+import { z as z3 } from "zod";
+var apiErrorSchema = z3.object({
+  code: z3.string(),
+  message: z3.string(),
+  retryAfter: z3.number().int().positive().optional(),
+  docsUrl: z3.string().url()
+});
+
+// ../shared/src/versions.ts
+import { z as z4 } from "zod";
+var versionSourceSchema = z4.object({
+  type: z4.string(),
+  agentName: z4.string().nullable()
+});
+var versionChangesSchema = z4.object({
+  added: z4.array(z4.string()),
+  changed: z4.array(z4.string()),
+  removed: z4.array(z4.string())
+});
+var versionSummarySchema = z4.object({
+  id: z4.string(),
+  versionNumber: z4.number().int().positive(),
+  createdAt: z4.string(),
+  entryUrl: z4.string().url(),
+  fileCount: z4.number().int().nonnegative(),
+  totalSizeBytes: z4.number().int().nonnegative(),
+  source: versionSourceSchema,
+  isCurrent: z4.boolean(),
+  // Absent for the first version — there is no previous version to diff against.
+  changes: versionChangesSchema.nullable()
+});
+var versionListResponseSchema = z4.object({
+  versions: z4.array(versionSummarySchema)
+});
+
+// ../shared/src/owner.ts
+import { z as z5 } from "zod";
+var SLUG_PATTERN = /^[a-z0-9](?:[a-z0-9-]{1,61}[a-z0-9])$/;
+var claimResponseSchema = z5.object({
+  artifactId: z5.string(),
+  slug: z5.string(),
+  title: z5.string(),
+  url: z5.string().url()
+});
+var updateArtifactSchema = z5.object({
+  title: z5.string().min(1).max(200).optional(),
+  slug: z5.string().min(3).max(63).regex(SLUG_PATTERN, {
+    message: "slug must be lowercase letters, digits, and hyphens, with no leading/trailing hyphen"
+  }).optional()
+}).refine((body) => body.title !== void 0 || body.slug !== void 0, {
+  message: "provide at least one of title, slug"
+});
+var deleteArtifactResponseSchema = z5.object({
+  deleted: z5.literal(true)
+});
+
+// src/api.ts
+var ApiRequestError = class extends Error {
+  constructor(status, code, message, retryAfter) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.retryAfter = retryAfter;
+    this.name = "ApiRequestError";
+  }
+  status;
+  code;
+  retryAfter;
+};
+async function request(url, init, parse) {
+  let res;
+  try {
+    res = await fetch(url, init);
+  } catch (err) {
+    throw new Error(
+      `Could not reach ${new URL(url).origin} \u2014 is the API up? (${err instanceof Error ? err.message : err})`
+    );
+  }
+  const body = await res.json().catch(() => null);
+  if (!res.ok) {
+    const parsed = apiErrorSchema.safeParse(body);
+    if (parsed.success) {
+      throw new ApiRequestError(
+        res.status,
+        parsed.data.code,
+        parsed.data.message,
+        parsed.data.retryAfter
+      );
+    }
+    throw new ApiRequestError(res.status, "unknown_error", `API returned ${res.status}`);
+  }
+  return parse(body);
+}
+function createApiClient(apiUrl, publishToken) {
+  const base = apiUrl.replace(/\/$/, "");
+  const headers = { "content-type": "application/json" };
+  if (publishToken) headers.authorization = `Bearer ${publishToken}`;
+  return {
+    async createSession(body) {
+      return request(
+        `${base}/api/v1/publish`,
+        { method: "POST", headers, body: JSON.stringify(body) },
+        (d) => publishSessionResponseSchema.parse(d)
+      );
+    },
+    async finalize(publishSessionId) {
+      return request(
+        `${base}/api/v1/publish/${publishSessionId}/finalize`,
+        { method: "POST", headers },
+        (d) => finalizeResponseSchema.parse(d)
+      );
+    },
+    async getArtifact(artifactId) {
+      return request(
+        `${base}/api/v1/artifacts/${artifactId}`,
+        { method: "GET" },
+        (d) => artifactResponseSchema.parse(d)
+      );
+    },
+    async exportComments(artifactId, query) {
+      const params = new URLSearchParams({ status: query.status, version: query.version });
+      return request(
+        `${base}/api/v1/artifacts/${artifactId}/comments/export?${params}`,
+        { method: "GET" },
+        (d) => commentExportSchema.parse(d)
+      );
+    }
+  };
+}
+async function uploadFile(uploadUrl, content, mimeType) {
+  const res = await fetch(uploadUrl, {
+    method: "PUT",
+    headers: { "content-type": mimeType, "content-length": String(content.byteLength) },
+    body: new Uint8Array(content)
+  });
+  if (!res.ok) {
+    throw new Error(`Upload failed (${res.status}): ${(await res.text()).slice(0, 200)}`);
+  }
+}
+
+// src/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync, appendFileSync } from "fs";
+import path from "path";
+import { z as z6 } from "zod";
+var configSchema = z6.object({
+  artifactId: z6.string(),
+  slug: z6.string(),
+  url: z6.string(),
+  apiUrl: z6.string(),
+  publishToken: z6.string()
+});
+var CONFIG_DIR = ".artifactcafe";
+var CONFIG_FILE = "config.json";
+function readConfig(dir) {
+  const file = path.join(dir, CONFIG_DIR, CONFIG_FILE);
+  if (!existsSync(file)) return null;
+  try {
+    return configSchema.parse(JSON.parse(readFileSync(file, "utf8")));
+  } catch {
+    return null;
+  }
+}
+function writeConfig(dir, config) {
+  mkdirSync(path.join(dir, CONFIG_DIR), { recursive: true });
+  writeFileSync(
+    path.join(dir, CONFIG_DIR, CONFIG_FILE),
+    JSON.stringify(config, null, 2) + "\n",
+    { mode: 384 }
+  );
+  ensureGitignored(dir);
+}
+function ensureGitignored(dir) {
+  const gitignore = path.join(dir, ".gitignore");
+  if (!existsSync(gitignore)) return;
+  const lines = readFileSync(gitignore, "utf8").split(/\r?\n/);
+  const present = lines.some((l) => {
+    const t = l.trim();
+    return t === CONFIG_DIR || t === `${CONFIG_DIR}/` || t === `/${CONFIG_DIR}` || t === `/${CONFIG_DIR}/`;
+  });
+  if (!present) {
+    appendFileSync(gitignore, `
+# artifact.cafe publish token
+${CONFIG_DIR}/
+`);
+  }
+}
+
+// src/comments.ts
+var STATUSES = ["open", "resolved", "all"];
+var VERSIONS = ["current", "all"];
+async function comments(opts) {
+  if (!STATUSES.includes(opts.status)) {
+    throw new Error(`--status must be one of: ${STATUSES.join(", ")} (got "${opts.status}").`);
+  }
+  if (!VERSIONS.includes(opts.version)) {
+    throw new Error(`--version must be one of: ${VERSIONS.join(", ")} (got "${opts.version}").`);
+  }
+  const status = opts.status;
+  const version = opts.version;
+  const dir = path2.resolve(opts.dir);
+  const config = readConfig(dir);
+  if (!config) {
+    throw new Error(
+      `No artifact linked in ${dir} \u2014 run \`artifact-cafe publish\` there first (.artifactcafe/config.json not found).`
+    );
+  }
+  const apiUrl = process.env.ARTIFACT_CAFE_URL ?? config.apiUrl;
+  const client = createApiClient(apiUrl);
+  const data = await client.exportComments(config.artifactId, { status, version });
+  if (opts.json) {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+  printHuman(data, config.url, status, version);
+}
+function printHuman(data, url, status, version) {
+  const statusLabel = status === "all" ? "" : `${status} `;
+  const scope = version === "current" ? data.versionNumber !== null ? `on v${data.versionNumber}` : "on the current version" : "across all versions";
+  if (data.comments.length === 0) {
+    console.log(`No ${statusLabel}comments ${scope}.`);
+    return;
+  }
+  const plural = data.comments.length === 1 ? "" : "s";
+  console.log(`${data.comments.length} ${statusLabel}thread${plural} ${scope} \u2014 ${url}
+`);
+  for (const thread of data.comments) {
+    printThread(thread);
+  }
+}
+function printThread(t) {
+  const marker = t.status === "resolved" ? "\u2713" : "\u25CF";
+  const date = t.createdAt.slice(0, 10);
+  console.log(`${marker} ${t.author} \xB7 v${t.versionNumber} \xB7 ${date} \xB7 ${t.id}`);
+  if (t.anchor.type === "text") {
+    console.log(`  \u21B3 "${t.anchor.quote}"`);
+  } else if (t.anchor.element) {
+    const el = t.anchor.element;
+    const text = el.text ? ` "${el.text}"` : "";
+    console.log(`  \u21B3 at ${elementLabel(el)}${text} \u2014 ${t.anchor.elementPath}`);
+  } else {
+    console.log(`  \u21B3 at ${t.anchor.elementPath}`);
+  }
+  console.log(indent(t.body, "  "));
+  for (const reply of t.replies) {
+    console.log(indent(`${reply.author}: ${reply.body}`, "    "));
+  }
+  console.log("");
+}
+function indent(text, pad) {
+  return text.split("\n").map((line) => pad + line).join("\n");
+}
+
+// src/errors.ts
+function printCliError(err, json) {
+  if (err instanceof ApiRequestError) {
+    if (json) {
+      console.log(
+        JSON.stringify({
+          error: { code: err.code, message: err.message, retryAfter: err.retryAfter }
+        })
+      );
+    } else {
+      console.error(`\u2717 ${err.message} (${err.code})`);
+      if (err.retryAfter) console.error(`  Retry in ${err.retryAfter}s.`);
+    }
+    return;
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  if (json) console.log(JSON.stringify({ error: { code: "cli_error", message } }));
+  else console.error(`\u2717 ${message}`);
+}
+
+// src/open.ts
+import path5 from "path";
+
+// src/publish.ts
+import { readFileSync as readFileSync3 } from "fs";
+import path4 from "path";
+import { exec } from "child_process";
+
+// src/manifest.ts
+import { createHash } from "crypto";
+import { readdirSync, readFileSync as readFileSync2, statSync } from "fs";
+import path3 from "path";
+var IGNORED_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", ".artifactcafe"]);
+var IGNORED_FILES = /* @__PURE__ */ new Set([".DS_Store"]);
+function isIgnoredFile(name) {
+  if (IGNORED_FILES.has(name)) return true;
+  if (name === ".env" || name.startsWith(".env.")) return true;
+  if (name.endsWith(".pem") || name.endsWith(".key")) return true;
+  if (name.startsWith(".git")) return true;
+  return false;
+}
+var MIME_TYPES = {
+  ".html": "text/html",
+  ".htm": "text/html",
+  ".css": "text/css",
+  ".js": "text/javascript",
+  ".mjs": "text/javascript",
+  ".json": "application/json",
+  ".map": "application/json",
+  ".txt": "text/plain",
+  ".md": "text/markdown",
+  ".xml": "application/xml",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".otf": "font/otf",
+  ".pdf": "application/pdf",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".wasm": "application/wasm"
+};
+function mimeFor(filePath) {
+  return MIME_TYPES[path3.extname(filePath).toLowerCase()] ?? "application/octet-stream";
+}
+function scanDirectory(dir) {
+  const files = [];
+  const skipped = [];
+  function walk(current, relPrefix) {
+    for (const entry of readdirSync(current, { withFileTypes: true })) {
+      const rel = relPrefix ? `${relPrefix}/${entry.name}` : entry.name;
+      const abs = path3.join(current, entry.name);
+      if (entry.isSymbolicLink()) {
+        skipped.push(rel);
+        continue;
+      }
+      if (entry.isDirectory()) {
+        if (IGNORED_DIRS.has(entry.name) || entry.name.startsWith(".git")) {
+          skipped.push(`${rel}/`);
+        } else {
+          walk(abs, rel);
+        }
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      if (isIgnoredFile(entry.name) || !isSafeArtifactPath(rel)) {
+        skipped.push(rel);
+        continue;
+      }
+      const size = statSync(abs).size;
+      if (size === 0) {
+        skipped.push(rel);
+        continue;
+      }
+      const content = readFileSync2(abs);
+      files.push({
+        path: rel,
+        hash: `sha256_${createHash("sha256").update(content).digest("hex")}`,
+        size,
+        mimeType: mimeFor(rel),
+        absPath: abs
+      });
+    }
+  }
+  walk(dir, "");
+  files.sort((a, b) => a.path.localeCompare(b.path));
+  return { files, skipped };
+}
+function resolveEntry(files, explicit) {
+  if (explicit) {
+    if (!files.some((f) => f.path === explicit)) {
+      throw new Error(`Entry file "${explicit}" not found in the publish folder.`);
+    }
+    return explicit;
+  }
+  if (files.some((f) => f.path === "index.html")) return "index.html";
+  const htmlFiles = files.filter((f) => f.path.endsWith(".html") && !f.path.includes("/"));
+  if (htmlFiles.length === 1) return htmlFiles[0].path;
+  throw new Error(
+    htmlFiles.length === 0 ? "No entry file found. Add an index.html or pass --entry <file>." : `Multiple HTML files found (${htmlFiles.map((f) => f.path).join(", ")}). Pass --entry <file>.`
+  );
+}
+
+// src/publish.ts
+var DEFAULT_API_URL = "https://artifact.cafe";
+var UPLOAD_CONCURRENCY = 6;
+async function publish(opts) {
+  const dir = path4.resolve(opts.dir);
+  const config = readConfig(dir);
+  const artifactId = opts.artifact ?? config?.artifactId ?? null;
+  const token = (artifactId !== null && artifactId === config?.artifactId ? config.publishToken : void 0) ?? process.env.ARTIFACT_CAFE_TOKEN;
+  const apiUrl = process.env.ARTIFACT_CAFE_URL ?? config?.apiUrl ?? DEFAULT_API_URL;
+  const { files, skipped } = scanDirectory(dir);
+  if (files.length === 0) {
+    throw new Error(`Nothing to publish in ${dir} (after ignore rules).`);
+  }
+  const entryPath = resolveEntry(files, opts.entry);
+  const log = (msg) => {
+    if (!opts.json) console.log(msg);
+  };
+  if (skipped.length) {
+    log(`  ignoring ${skipped.length} item(s): ${preview(skipped)}`);
+  }
+  const client = createApiClient(apiUrl, token);
+  const session = await client.createSession({
+    artifactId,
+    title: opts.title,
+    entryPath,
+    files: files.map(({ absPath: _absPath, ...manifest }) => manifest),
+    source: {
+      type: "cli",
+      agent: process.env.ARTIFACT_CAFE_AGENT,
+      runId: process.env.ARTIFACT_CAFE_RUN_ID
+    }
+  });
+  const byPath = new Map(files.map((f) => [f.path, f]));
+  log(
+    `  uploading ${session.filesToUpload.length} file(s)` + (session.skippedFiles.length ? `, ${session.skippedFiles.length} unchanged` : "")
+  );
+  await inBatches(session.filesToUpload, UPLOAD_CONCURRENCY, async (upload) => {
+    const file = byPath.get(upload.path);
+    if (!file) throw new Error(`Server asked for unknown file ${upload.path}`);
+    await uploadFile(upload.uploadUrl, readFileSync3(file.absPath), file.mimeType);
+  });
+  const result = await client.finalize(session.publishSessionId);
+  if (result.publishToken) {
+    writeConfig(dir, {
+      artifactId: result.artifactId,
+      slug: slugFromUrl(result.url),
+      url: result.url,
+      apiUrl,
+      publishToken: result.publishToken
+    });
+  }
+  if (opts.json) {
+    console.log(
+      JSON.stringify(
+        {
+          artifactId: result.artifactId,
+          versionNumber: result.versionNumber,
+          url: result.url,
+          ...result.claimUrl ? { claimUrl: result.claimUrl } : {},
+          filesUploaded: session.filesToUpload.map((f) => f.path),
+          skippedFiles: session.skippedFiles,
+          ignored: skipped
+        },
+        null,
+        2
+      )
+    );
+  } else if (result.versionNumber === 1) {
+    console.log(`
+\u2713 Published to artifact.cafe
+`);
+    console.log(`Review URL:
+${result.url}
+`);
+    if (result.claimUrl) {
+      console.log(`Claim URL (shown once \u2014 claim to keep this artifact):
+${result.claimUrl}
+`);
+    }
+  } else {
+    console.log(`
+\u2713 Published v${result.versionNumber}
+`);
+    console.log(`${result.url}
+`);
+  }
+  if (opts.open && !opts.json && process.stdout.isTTY) {
+    openInBrowser(result.url);
+  }
+}
+async function inBatches(items, concurrency, fn) {
+  let next = 0;
+  const workers = Array.from({ length: Math.min(concurrency, items.length) }, async () => {
+    while (next < items.length) {
+      const item = items[next++];
+      await fn(item);
+    }
+  });
+  await Promise.all(workers);
+}
+function slugFromUrl(url) {
+  return url.split("/a/")[1] ?? "";
+}
+function preview(items) {
+  return items.slice(0, 5).join(", ") + (items.length > 5 ? ", \u2026" : "");
+}
+function openInBrowser(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  exec(`${cmd} ${JSON.stringify(url)}`, () => {
+  });
+}
+
+// src/open.ts
+function openArtifact(opts) {
+  const dir = path5.resolve(opts.dir);
+  const config = readConfig(dir);
+  if (!config) {
+    throw new Error(
+      `No artifact linked in ${dir} \u2014 run \`artifact-cafe publish\` there first (.artifactcafe/config.json not found).`
+    );
+  }
+  console.log(config.url);
+  if (process.stdout.isTTY) openInBrowser(config.url);
+}
+
+// src/index.ts
+var publish2 = defineCommand({
+  meta: { name: "publish", description: "Publish a folder as an artifact" },
+  args: {
+    dir: { type: "positional", description: "Directory to publish", default: "." },
+    title: { type: "string", description: "Artifact title" },
+    entry: { type: "string", description: "Entry file (default: auto-detect)" },
+    artifact: { type: "string", description: "Publish to an existing artifact ID" },
+    json: { type: "boolean", description: "Machine-readable output" },
+    "no-open": { type: "boolean", description: "Don't open the review URL" }
+  },
+  async run({ args }) {
+    try {
+      await publish({
+        dir: args.dir,
+        title: args.title,
+        entry: args.entry,
+        artifact: args.artifact,
+        json: Boolean(args.json),
+        open: !args["no-open"]
+      });
+    } catch (err) {
+      printCliError(err, Boolean(args.json));
+      process.exit(1);
+    }
+  }
+});
+var comments2 = defineCommand({
+  meta: { name: "comments", description: "Pull comments for the linked artifact" },
+  args: {
+    dir: { type: "positional", description: "Published directory", default: "." },
+    json: { type: "boolean", description: "Machine-readable output" },
+    status: { type: "string", description: "Filter: open | resolved | all", default: "open" },
+    version: { type: "string", description: "Filter: current | all", default: "current" }
+  },
+  async run({ args }) {
+    try {
+      await comments({
+        dir: args.dir,
+        json: Boolean(args.json),
+        status: args.status,
+        version: args.version
+      });
+    } catch (err) {
+      printCliError(err, Boolean(args.json));
+      process.exit(1);
+    }
+  }
+});
+var open = defineCommand({
+  meta: { name: "open", description: "Open the linked artifact's review URL" },
+  args: {
+    dir: { type: "positional", description: "Published directory", default: "." }
+  },
+  run({ args }) {
+    try {
+      openArtifact({ dir: args.dir });
+    } catch (err) {
+      printCliError(err, false);
+      process.exit(1);
+    }
+  }
+});
+var login = defineCommand({
+  meta: { name: "login", description: "Log in (optional; needed for owner actions)" },
+  async run() {
+    console.error("login not implemented yet");
+    process.exit(1);
+  }
+});
+var main = defineCommand({
+  meta: {
+    name: "artifact-cafe",
+    description: "Publish AI-generated artifacts for review \u2014 https://artifact.cafe"
+  },
+  subCommands: { publish: publish2, comments: comments2, open, login }
+});
+runMain(main);

package/package.json

@@ -1,9 +1,27 @@
 {
   "name": "artifact-cafe",
-  "version": "0.0.0",
-  "description": "Publish AI-generated artifacts for review on artifact.cafe. Name reserved — the CLI is in active development.",
-  "keywords": ["artifact", "artifact.cafe", "review", "cli"],
-  "homepage": "https://artifact.cafe",
-  "license": "MIT",
-  "files": ["README.md"]
+  "version": "0.0.1",
+  "description": "Publish AI-generated artifacts for review on artifact.cafe",
+  "type": "module",
+  "bin": {
+    "artifact-cafe": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "dev": "tsup --watch"
+  },
+  "dependencies": {
+    "citty": "^0.1.6",
+    "zod": "^4.1.0"
+  },
+  "devDependencies": {
+    "@artifact-cafe/shared": "workspace:*",
+    "@types/node": "^24.0.0",
+    "tsup": "^8.5.0",
+    "typescript": "^5.9.0"
+  }
 }

package/README.md

@@ -1,11 +0,0 @@
-# artifact-cafe
-
-The home for AI-generated work. Agents publish interactive static artifacts
-via CLI; humans review and comment through a share link.
-
-```
-npx artifact-cafe publish .
-```
-
-> **This package name is reserved.** `0.0.0` is a placeholder — the real CLI
-> is in active development and will ship as `0.0.1`+. See https://artifact.cafe