chamba 0.3.1 → 0.5.0

package/dist/cli.js

@@ -1,1582 +0,0 @@
-#!/usr/bin/env node
-
-// packages/cli/src/index.ts
-import { realpathSync as realpathSync2 } from "node:fs";
-import { fileURLToPath as fileURLToPath6 } from "node:url";
-
-// packages/server/src/index.ts
-import { serve as honoServe } from "@hono/node-server";
-
-// packages/shared/src/annotations.ts
-import { z as z3 } from "zod";
-
-// packages/shared/src/messages.ts
-import { z as z2 } from "zod";
-
-// packages/shared/src/events.ts
-import { z } from "zod";
-var eventSourceSchema = z.enum(["user", "agent", "system"]);
-var eventEnvelopeSchema = z.object({
-  id: z.uuid(),
-  seq: z.number().int().nonnegative(),
-  sessionId: z.string().min(1),
-  ts: z.iso.datetime(),
-  type: z.string().min(1),
-  source: eventSourceSchema,
-  payload: z.unknown()
-});
-
-// packages/shared/src/messages.ts
-var attachmentSchema = z2.object({
-  id: z2.string().min(1),
-  name: z2.string().min(1),
-  relPath: z2.string().min(1),
-  contentType: z2.string().min(1),
-  size: z2.number().int().nonnegative()
-});
-var replyRefSchema = z2.object({
-  seq: z2.number().int().nonnegative(),
-  id: z2.string().min(1),
-  source: eventSourceSchema,
-  snippet: z2.string()
-});
-var messagePayloadSchema = z2.object({
-  text: z2.string().min(1).optional(),
-  attachments: z2.array(attachmentSchema).optional(),
-  replyTo: replyRefSchema.optional(),
-  answerIn: z2.literal("terminal").optional()
-}).refine((p) => (p.text?.length ?? 0) > 0 || (p.attachments?.length ?? 0) > 0, {
-  error: "a message needs text or at least one attachment"
-});
-var systemReasonSchema = z2.enum(["session-created", "session-ended"]);
-var systemPayloadSchema = z2.object({
-  reason: systemReasonSchema
-});
-
-// packages/shared/src/annotations.ts
-var ANNOTATION_BATCH = "annotation-batch";
-var annotationSourceSchema = z3.object({
-  file: z3.string().min(1),
-  line: z3.number().int().positive().optional(),
-  column: z3.number().int().positive().optional()
-});
-var annotationComponentSchema = z3.object({
-  name: z3.string().min(1),
-  source: annotationSourceSchema.optional()
-});
-var annotationTargetSchema = z3.object({
-  selector: z3.string().min(1),
-  pageUrl: z3.string().min(1),
-  viewport: z3.object({
-    width: z3.number().int().positive(),
-    height: z3.number().int().positive()
-  }),
-  label: z3.string().optional(),
-  component: annotationComponentSchema.optional()
-});
-var annotationItemSchema = z3.object({
-  note: z3.string().min(1).optional(),
-  target: annotationTargetSchema,
-  screenshot: attachmentSchema.optional()
-});
-var annotationBatchPayloadSchema = z3.object({
-  items: z3.array(annotationItemSchema).min(1)
-});
-
-// packages/shared/src/api.ts
-import { z as z6 } from "zod";
-
-// packages/shared/src/presence.ts
-import { z as z4 } from "zod";
-var presenceSchema = z4.enum(["listening", "working", "away"]);
-
-// packages/shared/src/session.ts
-import { z as z5 } from "zod";
-var sessionStatusSchema = z5.enum(["active", "ended"]);
-var sessionMetaSchema = z5.object({
-  id: z5.string().min(1),
-  /** The agent session that created this session (e.g. a Claude Code session id).
-   * `open` uses it to reconnect the same agent session to its existing workspace. */
-  agentKey: z5.string().min(1).optional(),
-  title: z5.string().optional(),
-  status: sessionStatusSchema,
-  createdAt: z5.string().datetime(),
-  updatedAt: z5.string().datetime()
-});
-
-// packages/shared/src/api.ts
-var cursorSchema = z6.number().int().nonnegative();
-var POLL_DEFAULT_WAIT_MS = 25e3;
-var POLL_MAX_WAIT_MS = 3e4;
-var SESSION_QUERY_PARAM = "s";
-function sessionPageUrl(baseUrl, id) {
-  return `${baseUrl.replace(/\/+$/, "")}/?${SESSION_QUERY_PARAM}=${encodeURIComponent(id)}`;
-}
-async function errorBodyMessage(res) {
-  try {
-    const body = await res.json();
-    return typeof body.error === "string" ? body.error : null;
-  } catch {
-    return null;
-  }
-}
-var createSessionReqSchema = z6.object({
-  title: z6.string().min(1).optional(),
-  agentKey: z6.string().min(1).optional()
-});
-var messageBodyBase = z6.object({
-  text: z6.string().min(1).optional(),
-  attachmentIds: z6.array(z6.string().min(1)).optional(),
-  replyTo: z6.number().int().nonnegative().optional()
-});
-var needsContent = (r) => (r.text?.length ?? 0) > 0 || (r.attachmentIds?.length ?? 0) > 0;
-var needsContentMessage = { error: "a message needs text or at least one attachment" };
-var postMessageReqSchema = messageBodyBase.extend({ answerIn: z6.literal("terminal").optional() }).refine(needsContent, needsContentMessage);
-var replyReqSchema = messageBodyBase.refine(needsContent, needsContentMessage);
-var annotationItemReqSchema = z6.object({
-  note: z6.string().min(1).optional(),
-  target: annotationTargetSchema,
-  screenshotAttachmentId: z6.string().min(1).optional()
-});
-var postAnnotationsReqSchema = z6.object({
-  items: z6.array(annotationItemReqSchema).min(1)
-});
-var attachmentResSchema = z6.object({
-  attachment: attachmentSchema
-});
-var eventResSchema = z6.object({
-  event: eventEnvelopeSchema
-});
-var pollResSchema = z6.object({
-  events: z6.array(eventEnvelopeSchema),
-  cursor: cursorSchema,
-  ended: z6.boolean().optional(),
-  /** Set when the server is shutting down on purpose and woke this poll to say
-   * so; the caller should exit its loop cleanly instead of retrying. */
-  stopping: z6.boolean().optional()
-});
-var fetchMoreSchema = z6.object({
-  hasMore: z6.boolean(),
-  earliestLoadedSeq: cursorSchema,
-  hint: z6.string()
-});
-var attachDigestSchema = z6.object({
-  meta: sessionMetaSchema,
-  presence: presenceSchema,
-  tail: z6.array(eventEnvelopeSchema),
-  cursor: cursorSchema,
-  fetchMore: fetchMoreSchema
-});
-var sessionSummarySchema = z6.object({
-  meta: sessionMetaSchema,
-  presence: presenceSchema
-});
-var listResSchema = z6.object({
-  sessions: z6.array(sessionSummarySchema)
-});
-var sessionResSchema = z6.object({
-  session: sessionSummarySchema
-});
-var healthResSchema = z6.object({
-  ok: z6.boolean(),
-  sessions: cursorSchema,
-  home: z6.string().min(1).optional(),
-  port: z6.number().int().positive().optional(),
-  version: z6.string().min(1).optional()
-});
-
-// packages/shared/src/issues.ts
-import { z as z7 } from "zod";
-var issueTypeSchema = z7.enum(["bug", "feature"]);
-var postIssueReqSchema = z7.object({
-  type: issueTypeSchema,
-  text: z7.string().min(1),
-  screenshotAttachmentIds: z7.array(z7.string().min(1)).optional()
-});
-var issueResSchema = z7.object({
-  id: z7.string().min(1),
-  path: z7.string().min(1)
-});
-
-// packages/shared/src/page.ts
-import { z as z8 } from "zod";
-var PAGE = "page";
-var pageRefSchema = z8.object({
-  name: z8.string().min(1),
-  relPath: z8.string().min(1),
-  contentType: z8.string().min(1),
-  size: z8.number().int().nonnegative()
-});
-var pagePayloadSchema = z8.object({
-  page: pageRefSchema
-});
-var postPageReqSchema = z8.object({
-  name: z8.string().min(1).max(120),
-  content: z8.string().min(1)
-});
-
-// packages/shared/src/payload.ts
-var attachmentsSchema = attachmentSchema.array();
-function eventText(event) {
-  const payload = event.payload;
-  if (payload && typeof payload === "object") {
-    const record = payload;
-    if (typeof record.text === "string") return record.text;
-    if (typeof record.reason === "string") return record.reason;
-  }
-  return "";
-}
-function eventAttachments(event) {
-  if (!event.payload || typeof event.payload !== "object") return [];
-  const parsed = attachmentsSchema.safeParse(
-    event.payload.attachments
-  );
-  return parsed.success ? parsed.data : [];
-}
-
-// packages/shared/src/reference.ts
-function parseRef(input) {
-  let ref = input.trim();
-  const token = ref.match(/^\[?\s*chamba\s+([^\s\]]+)/i);
-  if (token?.[1]) ref = token[1];
-  const match = ref.match(/^(?:([A-Za-z0-9_-]+)#)?#?(\d+)$/);
-  if (!match?.[2]) return null;
-  return { ...match[1] ? { session: match[1] } : {}, seq: Number(match[2]) };
-}
-function sourceLabel(source) {
-  return source === "user" ? "you" : source;
-}
-
-// packages/shared/src/ws.ts
-import { z as z9 } from "zod";
-var wsServerMessageSchema = z9.discriminatedUnion("t", [
-  z9.object({
-    t: z9.literal("hello"),
-    meta: sessionMetaSchema,
-    presence: presenceSchema
-  }),
-  z9.object({
-    t: z9.literal("append"),
-    event: eventEnvelopeSchema
-  }),
-  z9.object({
-    t: z9.literal("presence"),
-    state: presenceSchema
-  }),
-  z9.object({
-    t: z9.literal("ended"),
-    meta: sessionMetaSchema
-  })
-]);
-
-// packages/server/src/app.ts
-import { createNodeWebSocket } from "@hono/node-ws";
-import { Hono } from "hono";
-
-// packages/server/src/inject.ts
-import { existsSync as existsSync2 } from "node:fs";
-import path2 from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-
-// packages/server/src/static.ts
-import { existsSync } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-// packages/server/src/mime.ts
-var CONTENT_TYPES = {
-  ".html": "text/html; charset=utf-8",
-  ".js": "text/javascript; charset=utf-8",
-  ".mjs": "text/javascript; charset=utf-8",
-  ".css": "text/css; charset=utf-8",
-  ".json": "application/json; charset=utf-8",
-  ".svg": "image/svg+xml",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".webp": "image/webp",
-  ".ico": "image/x-icon",
-  ".woff2": "font/woff2",
-  ".map": "application/json; charset=utf-8",
-  ".pdf": "application/pdf",
-  ".txt": "text/plain; charset=utf-8",
-  ".md": "text/markdown; charset=utf-8"
-};
-var EXTENSIONS = {};
-for (const [ext, type] of Object.entries(CONTENT_TYPES)) {
-  const base = type.split(";")[0] ?? type;
-  if (!(base in EXTENSIONS)) EXTENSIONS[base] = ext;
-}
-
-// packages/server/src/static.ts
-function resolveWebDist() {
-  const here = path.dirname(fileURLToPath(import.meta.url));
-  const dev = path.resolve(here, "../../web/dist");
-  const packaged = path.resolve(here, "../web");
-  return [dev, packaged].find((dir) => existsSync(path.join(dir, "index.html"))) ?? dev;
-}
-
-// packages/server/src/inject.ts
-function resolveInjectDist() {
-  const here = path2.dirname(fileURLToPath2(import.meta.url));
-  const dev = path2.resolve(here, "../../inject/dist");
-  const packaged = path2.resolve(here, "../inject");
-  return [dev, packaged].find((dir) => existsSync2(path2.join(dir, "annotate.js"))) ?? dev;
-}
-
-// packages/server/src/version.ts
-import { existsSync as existsSync3, readFileSync } from "node:fs";
-import path3 from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
-function chambaVersion() {
-  let dir = path3.dirname(fileURLToPath3(import.meta.url));
-  for (; ; ) {
-    const manifest = path3.join(dir, "package.json");
-    if (existsSync3(manifest)) {
-      try {
-        const { version } = JSON.parse(readFileSync(manifest, "utf8"));
-        if (typeof version === "string" && version) return version;
-      } catch {
-      }
-    }
-    const parent = path3.dirname(dir);
-    if (parent === dir) return "0.0.0-dev";
-    dir = parent;
-  }
-}
-
-// packages/server/src/sessions/meta.ts
-import { readdir, readFile as readFile2 } from "node:fs/promises";
-
-// packages/server/src/sessions/atomic.ts
-import { randomUUID } from "node:crypto";
-import { rename, rm, writeFile } from "node:fs/promises";
-async function writeJsonAtomic(file, value) {
-  const tmp = `${file}.${randomUUID()}.tmp`;
-  try {
-    await writeFile(tmp, `${JSON.stringify(value, null, 2)}
-`, "utf8");
-    await rename(tmp, file);
-  } catch (err) {
-    await rm(tmp, { force: true }).catch(() => void 0);
-    throw err;
-  }
-}
-
-// packages/server/src/sessions/paths.ts
-import { existsSync as existsSync4, realpathSync } from "node:fs";
-import { appendFile, mkdir, readFile } from "node:fs/promises";
-import path4 from "node:path";
-function defaultContext() {
-  return { cwd: process.cwd(), env: process.env };
-}
-function resolveHome(ctx = defaultContext()) {
-  return findExistingHome(ctx) ?? plannedHome(ctx);
-}
-function findExistingHome(ctx = defaultContext()) {
-  const dir = ctx.env.CHAMBA_DIR;
-  if (dir && dir.length > 0) return canonicalize(dir);
-  const inside = enclosingChamba(ctx.cwd);
-  if (inside) return canonicalize(inside);
-  const root = gitRoot(ctx.cwd);
-  let cursor = path4.resolve(ctx.cwd);
-  while (true) {
-    if (existsSync4(path4.join(cursor, ".chamba"))) return canonicalize(path4.join(cursor, ".chamba"));
-    if (!root) break;
-    if (cursor === root) break;
-    const parent = path4.dirname(cursor);
-    if (parent === cursor) break;
-    cursor = parent;
-  }
-  return null;
-}
-function plannedHome(ctx = defaultContext()) {
-  const root = gitRoot(ctx.cwd) ?? path4.resolve(ctx.cwd);
-  return canonicalize(path4.join(root, ".chamba"));
-}
-function gitRoot(cwd) {
-  let cursor = path4.resolve(cwd);
-  while (true) {
-    if (existsSync4(path4.join(cursor, ".git"))) return cursor;
-    const parent = path4.dirname(cursor);
-    if (parent === cursor) return null;
-    cursor = parent;
-  }
-}
-function enclosingChamba(cwd) {
-  const parts = path4.resolve(cwd).split(path4.sep);
-  const index = parts.lastIndexOf(".chamba");
-  if (index < 0) return null;
-  return parts.slice(0, index + 1).join(path4.sep) || path4.sep;
-}
-function canonicalize(p) {
-  const resolved = path4.resolve(p);
-  let existing = resolved;
-  const tail = [];
-  while (!existsSync4(existing)) {
-    tail.unshift(path4.basename(existing));
-    const parent = path4.dirname(existing);
-    if (parent === existing) return resolved;
-    existing = parent;
-  }
-  return path4.join(realpathSync(existing), ...tail);
-}
-function sessionsDir(home) {
-  return path4.join(home, "sessions");
-}
-function sessionDir(home, id) {
-  return path4.join(sessionsDir(home), id);
-}
-function metaPath(home, id) {
-  return path4.join(sessionDir(home, id), "meta.json");
-}
-function pidfilePath(home) {
-  return path4.join(home, "server.json");
-}
-function agentStatePath(home) {
-  return path4.join(home, "agent-state.json");
-}
-async function ensureChambaHome(home) {
-  await mkdir(sessionsDir(home), { recursive: true });
-  await ensureGitignored(home);
-}
-async function ensureGitignored(home) {
-  if (path4.basename(home) !== ".chamba") return;
-  const gitignore = path4.join(path4.dirname(home), ".gitignore");
-  const entry = ".chamba/";
-  try {
-    let content = "";
-    try {
-      content = await readFile(gitignore, "utf8");
-    } catch (err) {
-      if (err.code !== "ENOENT") return;
-    }
-    const already = content.split(/\r?\n/).some((line) => {
-      const trimmed = line.trim();
-      return trimmed === entry || trimmed === ".chamba";
-    });
-    if (already) return;
-    const prefix = content.length > 0 && !content.endsWith("\n") ? "\n" : "";
-    await appendFile(gitignore, `${prefix}${entry}
-`, "utf8");
-  } catch {
-  }
-}
-
-// packages/server/src/sessions/meta.ts
-async function readMeta(home, id) {
-  try {
-    const raw = await readFile2(metaPath(home, id), "utf8");
-    return sessionMetaSchema.parse(JSON.parse(raw));
-  } catch (err) {
-    if (err.code === "ENOENT") return null;
-    throw err;
-  }
-}
-async function listSessionIds(home) {
-  try {
-    const entries = await readdir(sessionsDir(home), { withFileTypes: true });
-    return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-  } catch (err) {
-    if (err.code === "ENOENT") return [];
-    throw err;
-  }
-}
-
-// packages/server/src/app.ts
-var MAX_UPLOAD_BYTES = 25 * 1024 * 1024;
-
-// packages/server/src/lifecycle.ts
-import { open, readFile as readFile3, rm as rm2 } from "node:fs/promises";
-function readServerInfo(home) {
-  return readPidfile(pidfilePath(home));
-}
-async function readPidfile(file) {
-  try {
-    const raw = await readFile3(file, "utf8");
-    const parsed = JSON.parse(raw);
-    if (typeof parsed.pid === "number" && typeof parsed.port === "number") return parsed;
-    return null;
-  } catch {
-    return null;
-  }
-}
-
-// packages/server/src/port.ts
-var DEFAULT_PORT = 4319;
-var DEFAULT_BIND_HOST = "127.0.0.1";
-function resolveBindHost(argv = process.argv.slice(2)) {
-  const flag = readFlag(argv, "--host");
-  if (flag !== void 0 && flag.length > 0) return flag;
-  const env = process.env.CHAMBA_HOST;
-  if (env !== void 0 && env.length > 0) return env;
-  return DEFAULT_BIND_HOST;
-}
-function resolvePort(argv = process.argv.slice(2), home) {
-  const flag = readFlag(argv, "--port");
-  if (flag !== void 0) return parsePort(flag, "--port");
-  const env = process.env.CHAMBA_PORT;
-  if (env !== void 0 && env.length > 0) return parsePort(env, "CHAMBA_PORT");
-  return home !== void 0 ? derivePort(home) : DEFAULT_PORT;
-}
-function derivePort(home) {
-  let hash = 2166136261;
-  for (let i = 0; i < home.length; i++) {
-    hash ^= home.charCodeAt(i);
-    hash = Math.imul(hash, 16777619);
-  }
-  return DEFAULT_PORT + Math.abs(hash) % 512;
-}
-function readFlag(argv, name) {
-  for (let i = 0; i < argv.length; i++) {
-    const arg = argv[i];
-    if (arg === name) return argv[i + 1];
-    if (arg?.startsWith(`${name}=`)) return arg.slice(name.length + 1);
-  }
-  return void 0;
-}
-function parsePort(value, source) {
-  const port = Number(value);
-  if (!Number.isInteger(port) || port < 1 || port > 65535) {
-    throw new Error(`invalid ${source}: ${value}`);
-  }
-  return port;
-}
-
-// packages/server/src/index.ts
-var DEFAULT_IDLE_MS = 5 * 6e4;
-
-// packages/cli/src/args.ts
-function parseArgs(argv) {
-  const positionals = [];
-  const flags = {};
-  for (let i = 0; i < argv.length; i++) {
-    const arg = argv[i];
-    if (arg === void 0) continue;
-    if (!arg.startsWith("--")) {
-      positionals.push(arg);
-      continue;
-    }
-    const eq = arg.indexOf("=");
-    if (eq !== -1) {
-      flags[arg.slice(2, eq)] = arg.slice(eq + 1);
-      continue;
-    }
-    const next = argv[i + 1];
-    if (next !== void 0 && !next.startsWith("-")) {
-      flags[arg.slice(2)] = next;
-      i++;
-    } else {
-      flags[arg.slice(2)] = "true";
-    }
-  }
-  return { positionals, flags };
-}
-
-// packages/cli/src/client.ts
-import { readFile as readFile4 } from "node:fs/promises";
-import path5 from "node:path";
-var ChannelError = class extends Error {
-  constructor(status2, message) {
-    super(message);
-    this.status = status2;
-    this.name = "ChannelError";
-  }
-  status;
-};
-var Client = class {
-  constructor(baseUrl) {
-    this.baseUrl = baseUrl;
-  }
-  baseUrl;
-  /** Liveness probe with a short deadline; never throws - `false` means "spawn it". */
-  async isUp(timeoutMs = 800) {
-    try {
-      const res = await this.fetch("/api/health", { method: "GET", timeoutMs });
-      return res.ok;
-    } catch {
-      return false;
-    }
-  }
-  async health() {
-    return this.json("/api/health", { method: "GET", timeoutMs: 2e3 }, healthResSchema);
-  }
-  /** True when a server answers here *and* reports `home` as the workspace it
-   * owns - the identity check that keeps commands off a foreign server sharing
-   * the port (derived ports can collide across projects). Never throws. */
-  async ownsHome(home) {
-    if (!await this.isUp()) return false;
-    try {
-      return (await this.health()).home === home;
-    } catch {
-      return false;
-    }
-  }
-  async create(req) {
-    const res = await this.json(
-      "/api/sessions",
-      { method: "POST", body: req, timeoutMs: 5e3 },
-      sessionResSchema
-    );
-    return res.session;
-  }
-  async list() {
-    const res = await this.json("/api/sessions", { method: "GET", timeoutMs: 5e3 }, listResSchema);
-    return res.sessions;
-  }
-  async get(id) {
-    const res = await this.json(
-      `/api/sessions/${encodeURIComponent(id)}`,
-      { method: "GET", timeoutMs: 5e3 },
-      sessionResSchema
-    );
-    return res.session;
-  }
-  async postMessage(id, body) {
-    const res = await this.json(
-      `/api/sessions/${encodeURIComponent(id)}/messages`,
-      { method: "POST", body, timeoutMs: 5e3 },
-      eventResSchema
-    );
-    return res.event;
-  }
-  async reply(id, body) {
-    const res = await this.json(
-      `/api/sessions/${encodeURIComponent(id)}/reply`,
-      { method: "POST", body, timeoutMs: 5e3 },
-      eventResSchema
-    );
-    return res.event;
-  }
-  /** Show or revise a page (self-contained HTML for the Illustration tab). */
-  async showPage(id, body) {
-    const res = await this.json(
-      `/api/sessions/${encodeURIComponent(id)}/pages`,
-      { method: "POST", body, timeoutMs: 1e4 },
-      eventResSchema
-    );
-    return res.event;
-  }
-  /**
-   * Upload a local file into the session, returning its stored reference. The
-   * agent uses this to send an image back (`reply --image`); the returned id is
-   * then referenced from a `reply`. Multipart, so the server persists the raw
-   * bytes into the session directory rather than smuggling them through JSON.
-   */
-  async uploadAttachment(id, filePath) {
-    const bytes = await readFile4(filePath);
-    const form = new FormData();
-    form.append("file", new Blob([bytes]), path5.basename(filePath));
-    const res = await this.json(
-      `/api/sessions/${encodeURIComponent(id)}/attachments`,
-      { method: "POST", body: form, timeoutMs: 3e4 },
-      attachmentResSchema
-    );
-    return res.attachment;
-  }
-  /**
-   * The blocking long-poll. The server parks for up to `waitMs`; the client
-   * deadline is a little longer so a healthy server always answers before the
-   * client gives up (a client timeout would look like a lost message).
-   */
-  async poll(id, since, waitMs) {
-    return this.json(
-      `/api/sessions/${encodeURIComponent(id)}/poll?since=${since}&wait=${waitMs}`,
-      { method: "GET", timeoutMs: waitMs + 5e3 },
-      pollResSchema
-    );
-  }
-  async events(id, since, limit) {
-    const query = limit === void 0 ? `since=${since}` : `since=${since}&limit=${limit}`;
-    return this.json(
-      `/api/sessions/${encodeURIComponent(id)}/events?${query}`,
-      { method: "GET", timeoutMs: 5e3 },
-      pollResSchema
-    );
-  }
-  async end(id) {
-    const res = await this.json(
-      `/api/sessions/${encodeURIComponent(id)}/end`,
-      { method: "POST", timeoutMs: 5e3 },
-      sessionResSchema
-    );
-    return res.session;
-  }
-  async json(path12, options, schema) {
-    const res = await this.fetch(path12, options);
-    if (!res.ok) throw await toError(res);
-    return schema.parse(await res.json());
-  }
-  async fetch(path12, options) {
-    const { method = "GET", body, timeoutMs } = options;
-    const controller = timeoutMs !== void 0 ? new AbortController() : void 0;
-    const timer = controller && timeoutMs !== void 0 ? setTimeout(() => controller.abort(), timeoutMs) : void 0;
-    try {
-      return await fetch(new URL(path12, this.baseUrl), {
-        method,
-        signal: controller?.signal,
-        ...bodyInit(body)
-      });
-    } finally {
-      if (timer) clearTimeout(timer);
-    }
-  }
-};
-function bodyInit(body) {
-  if (body === void 0) return {};
-  if (body instanceof FormData) return { body };
-  return { headers: { "content-type": "application/json" }, body: JSON.stringify(body) };
-}
-async function toError(res) {
-  const message = await errorBodyMessage(res) ?? `${res.status} ${res.statusText}`;
-  return new ChannelError(res.status, message);
-}
-
-// packages/cli/src/output.ts
-import path6 from "node:path";
-function out(message) {
-  process.stdout.write(`${message}
-`);
-}
-function note(message) {
-  process.stderr.write(`${message}
-`);
-}
-function formatSystemEvent(event) {
-  const parsed = systemPayloadSchema.safeParse(event.payload);
-  if (!parsed.success) return `\xB7 ${eventText(event)}`;
-  switch (parsed.data.reason) {
-    case "session-ended":
-      return "\xB7 Session ended";
-    case "session-created":
-      return "\xB7 Session created";
-  }
-}
-function eventMarkers(event) {
-  if (!event.payload || typeof event.payload !== "object") return "";
-  const record = event.payload;
-  const parts = [];
-  const ref = replyRefSchema.safeParse(record.replyTo);
-  if (ref.success) {
-    const who = sourceLabel(ref.data.source);
-    const snippet = ref.data.snippet ? `: "${ref.data.snippet}"` : "";
-    parts.push(`[re #${ref.data.seq} ${who}${snippet}]`);
-  }
-  if (record.answerIn === "terminal") parts.push("[answer in terminal]");
-  return parts.length > 0 ? ` ${parts.join(" ")}` : "";
-}
-function formatEvent(event) {
-  if (event.source === "system") return formatSystemEvent(event);
-  const who = sourceLabel(event.source);
-  const markers = eventMarkers(event);
-  const text = eventText(event);
-  return text ? `${who}${markers}: ${text}` : `${who}${markers}:`;
-}
-function annotationItems(event) {
-  const parsed = annotationBatchPayloadSchema.safeParse(event.payload);
-  return parsed.success ? parsed.data.items : [];
-}
-function formatAnnotationBatch(event, home) {
-  const items = annotationItems(event);
-  const who = sourceLabel(event.source);
-  const lines = [`${who} [${items.length} annotation${items.length === 1 ? "" : "s"}]:`];
-  items.forEach((item, index) => {
-    const { target } = item;
-    lines.push(`  ${index + 1}. ${item.note ?? "(no comment)"}`);
-    lines.push(`     element: ${target.label ?? target.selector}`);
-    lines.push(`     selector: ${target.selector}`);
-    lines.push(
-      `     page: ${target.pageUrl}   viewport: ${target.viewport.width}x${target.viewport.height}`
-    );
-    if (target.component) {
-      const source = target.component.source;
-      const at = source ? `  (${source.file}${source.line ? `:${source.line}` : ""})` : "";
-      lines.push(`     component: ${target.component.name}${at}`);
-    }
-    if (item.screenshot) {
-      const abs = path6.join(sessionDir(home, event.sessionId), item.screenshot.relPath);
-      lines.push(`     [shot] ${item.screenshot.name} -> ${abs}`);
-    }
-  });
-  return lines;
-}
-function formatPage(event, home) {
-  const parsed = pageRefSchema.safeParse(event.payload?.page);
-  if (!parsed.success) return formatEvent(event);
-  const ref = parsed.data;
-  const abs = path6.join(sessionDir(home, event.sessionId), ref.relPath);
-  return `agent [page "${ref.name}"] -> ${abs}`;
-}
-function printEvents(events, home) {
-  for (const event of events) {
-    if (event.type === ANNOTATION_BATCH) {
-      for (const line of formatAnnotationBatch(event, home)) out(line);
-      continue;
-    }
-    if (event.type === PAGE) {
-      out(formatPage(event, home));
-      continue;
-    }
-    out(formatEvent(event));
-    for (const att of eventAttachments(event)) {
-      out(`  [file] ${att.name} -> ${path6.join(sessionDir(home, event.sessionId), att.relPath)}`);
-    }
-  }
-}
-function formatSession(meta, presence, current) {
-  const marker = current ? "*" : " ";
-  const title = meta.title ? ` "${meta.title}"` : "";
-  const live = presence ? ` ${presence}` : "";
-  return `${marker} ${meta.id}  ${meta.status}${live}${title}`;
-}
-
-// packages/cli/src/state.ts
-import { mkdir as mkdir2, readFile as readFile5 } from "node:fs/promises";
-import path7 from "node:path";
-import { z as z10 } from "zod";
-var agentStateSchema = z10.object({
-  currentSessionId: z10.string().optional(),
-  bindings: z10.record(z10.string(), z10.string()).default({}),
-  cursors: z10.record(z10.string(), z10.number().int().nonnegative()).default({})
-});
-var EMPTY = { bindings: {}, cursors: {} };
-async function readState(home = resolveHome()) {
-  try {
-    const raw = await readFile5(agentStatePath(home), "utf8");
-    return agentStateSchema.parse(JSON.parse(raw));
-  } catch {
-    return EMPTY;
-  }
-}
-async function writeState(state, home = resolveHome()) {
-  const file = agentStatePath(home);
-  await mkdir2(path7.dirname(file), { recursive: true });
-  await writeJsonAtomic(file, state);
-}
-function cursorFor(state, id) {
-  return state.cursors[id] ?? 0;
-}
-function withSession(state, id, cursor, key) {
-  return {
-    currentSessionId: id,
-    bindings: key ? { ...state.bindings, [key]: id } : state.bindings,
-    cursors: { ...state.cursors, [id]: cursor }
-  };
-}
-
-// packages/cli/src/commands/context.ts
-var UsageError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "UsageError";
-  }
-};
-function agentKey(env = process.env) {
-  return env.CHAMBA_SESSION_KEY || env.CLAUDE_CODE_SESSION_ID || void 0;
-}
-async function resolveSessionId(ctx, env = process.env) {
-  const flag = ctx.flags.session;
-  if (flag === "true" || flag === "") {
-    throw new UsageError("`--session` needs a session id, e.g. --session <id>");
-  }
-  if (flag) return flag;
-  const state = await readState(ctx.home);
-  const key = agentKey(env);
-  if (key) {
-    const bound = state.bindings[key];
-    if (bound) return bound;
-    throw new UsageError("no session bound to this agent - run `chamba open`");
-  }
-  if (state.currentSessionId) return state.currentSessionId;
-  throw new UsageError("no current session - run `chamba open` or pass --session <id>");
-}
-function intFlag(value, fallback) {
-  if (value === void 0) return fallback;
-  const n = Number(value);
-  return Number.isInteger(n) && n >= 0 ? n : fallback;
-}
-
-// packages/cli/src/commands/end.ts
-async function end(ctx) {
-  const id = await resolveSessionId(ctx);
-  const summary = await ctx.client.end(id);
-  note(`session ${summary.meta.id} ended`);
-  return 0;
-}
-
-// packages/cli/src/commands/get.ts
-async function get(ctx) {
-  const input = ctx.positionals.join(" ").trim();
-  if (!input) {
-    throw new UsageError("usage: chamba get <ref>   (42, <session>#42, or a pasted token)");
-  }
-  const ref = parseRef(input);
-  if (!ref) throw new UsageError(`not a message reference: ${input}`);
-  const id = ref.session ?? await resolveSessionId(ctx);
-  const res = await ctx.client.events(id, ref.seq, 1);
-  const event = res.events[0];
-  if (!event || event.seq !== ref.seq) {
-    note(`no event #${ref.seq} in session ${id} on this server`);
-    return 1;
-  }
-  printEvents([event], ctx.home);
-  return 0;
-}
-
-// packages/cli/src/commands/help.ts
-var USAGE = `chamba - a browser companion for your terminal agent
-
-Usage:
-  chamba                     list sessions and show which is current
-  chamba init [dir]          create the .chamba workspace (at the git root, or
-             [--here]        <dir>, or the current dir with --here); prints its
-                             location and per-project port
-  chamba open [--title T]    open a session and print its URL (creates the
-             [--new]         workspace at the repo root if none yet). Reconnects
-             [--last]        to this agent's bound session when one is active;
-                             --new always creates, --last rebinds to the newest
-                             active session
-  chamba poll                wait for the next human/system events, blocking
-             [--wait ms]     indefinitely until a batch arrives (zero cost while
-             [--for ms]      quiet). --for bounds the wait: after a quiet stretch
-             [--once]        it prints a heartbeat and exits 0 - just re-run.
-                             --once does one bounded check instead (scripts/
-                             tests); --wait is the per-request window (max 30s)
-  chamba reply <text>        send a line from the agent into the session
-             [--to <seq>]    mark it as answering a specific earlier event
-             [--file a,b]    attach files by path (comma-separated); --image is
-             [--image a,b]   an alias. text is optional when files are attached
-  chamba get <ref>           print one event by reference: 42, <session>#42, or
-                             a pasted [chamba <session>#42 "..."] token
-  chamba show <file.html>    render a self-contained HTML page in the browser's
-             [--name N]      Illustration tab. Re-show the same name to revise
-  chamba end                 end the current session
-  chamba stop                stop this project's server (it otherwise self-stops
-                             after an idle spell); the next open starts a fresh one
-
-  chamba skill install       install the chamba skill (/chamba) into
-             [--global]      ./.claude/skills, or ~/.claude/skills with --global
-  chamba --version           print the chamba version
-  chamba help                show this help
-
-Global:
-  --session <id>             act on a specific session instead of the bound one
-  --port <n>                 server port (default: CHAMBA_PORT, else a per-project
-                             port derived from the workspace location)`;
-function help(_ctx) {
-  note(USAGE);
-  return Promise.resolve(0);
-}
-
-// packages/cli/src/commands/init.ts
-import path8 from "node:path";
-async function init(ctx) {
-  const target = resolveTarget(ctx);
-  const existing = findExistingHome({ cwd: target, env: {} });
-  if (existing && !ctx.flags.here) {
-    report("chamba workspace already exists", existing);
-    return 0;
-  }
-  if (existing && ctx.flags.here) {
-    note(`note: shadowing an existing workspace at ${existing}`);
-  }
-  await ensureChambaHome(path8.join(target, ".chamba"));
-  const home = findExistingHome({ cwd: target, env: {} }) ?? path8.join(target, ".chamba");
-  report("created chamba workspace", home);
-  if (path8.basename(home) !== ".chamba") {
-    note("warning: home is not a .chamba directory, so it will not be auto-gitignored");
-  }
-  return 0;
-}
-function resolveTarget(ctx) {
-  const explicit = ctx.positionals[0];
-  if (explicit) return path8.resolve(explicit);
-  const root = gitRoot(process.cwd());
-  if (root) return root;
-  if (ctx.flags.here) return path8.resolve(process.cwd());
-  throw new UsageError(
-    "no .git found here - pass a directory (`chamba init <dir>`) or `chamba init --here` to choose where .chamba lives"
-  );
-}
-function report(headline, home) {
-  note(headline);
-  note(`home: ${home}  port: ${derivePort(home)}`);
-  note("each project gets its own server on its own port; other projects are unaffected");
-}
-
-// packages/cli/src/launch.ts
-import { spawn, spawnSync } from "node:child_process";
-import { existsSync as existsSync5 } from "node:fs";
-import { createRequire } from "node:module";
-import path9 from "node:path";
-import { fileURLToPath as fileURLToPath4, pathToFileURL } from "node:url";
-var require2 = createRequire(import.meta.url);
-async function ensureServer(client, target) {
-  if (await client.isUp()) {
-    await verifyHome(client, target);
-    return { spawned: false };
-  }
-  ensureDevBuilds();
-  spawnServer(target);
-  await waitUntilUp(client, target);
-  return { spawned: true };
-}
-async function verifyHome(client, target) {
-  const health = await client.health();
-  if (health.home === target.home) return;
-  if (health.home === void 0) {
-    throw new Error(
-      `a chamba server already owns port ${target.port} but predates workspace isolation - stop that process and retry`
-    );
-  }
-  throw new Error(
-    `port ${target.port} is serving a different chamba workspace (${health.home}); run from that project, or set --port / CHAMBA_PORT to run a separate server`
-  );
-}
-function spawnServer(target) {
-  const child = spawn(process.execPath, serverLaunchArgs(), {
-    detached: true,
-    stdio: "ignore",
-    env: { ...process.env, CHAMBA_DIR: target.home, CHAMBA_PORT: String(target.port) }
-  });
-  child.unref();
-}
-function serverLaunchArgs() {
-  const here = path9.dirname(fileURLToPath4(import.meta.url));
-  const packagedServer = path9.join(here, "server.js");
-  if (existsSync5(packagedServer)) return [packagedServer];
-  const serverBin = require2.resolve("@chamba/server/bin");
-  const tsxLoader = pathToFileURL(require2.resolve("tsx")).href;
-  return ["--import", tsxLoader, serverBin];
-}
-function ensureDevBuilds() {
-  const here = path9.dirname(fileURLToPath4(import.meta.url));
-  if (existsSync5(path9.join(here, "server.js"))) return;
-  const repoRoot = path9.resolve(path9.dirname(require2.resolve("@chamba/server/bin")), "../../..");
-  const deps = [
-    { label: "web UI", filter: "@chamba/web", dist: resolveWebDist(), marker: "index.html" },
-    {
-      label: "annotation client",
-      filter: "@chamba/inject",
-      dist: resolveInjectDist(),
-      marker: "annotate.js"
-    }
-  ];
-  for (const dep of deps) {
-    if (existsSync5(path9.join(dep.dist, dep.marker))) continue;
-    note(`building chamba ${dep.label} (first run in this environment)...`);
-    const result = spawnSync("pnpm", ["--filter", dep.filter, "build"], {
-      cwd: repoRoot,
-      encoding: "utf8"
-    });
-    if (result.error || result.status !== 0) {
-      const detail = `${result.stderr ?? ""}${result.stdout ?? ""}`.trim();
-      throw new Error(
-        `could not build ${dep.filter} (needed to serve the ${dep.label})${detail ? `:
-${detail}` : ""}`
-      );
-    }
-  }
-}
-async function waitUntilUp(client, target, timeoutMs = 1e4) {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    if (await client.isUp()) {
-      const health = await client.health();
-      if (health.home === target.home) return;
-      throw new Error(
-        `port ${target.port} was taken by a different chamba workspace (${health.home ?? "unknown"})`
-      );
-    }
-    await delay(150);
-  }
-  throw new Error("server did not become healthy in time");
-}
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-// packages/cli/src/commands/open.ts
-async function open2(ctx) {
-  if (!ctx.workspaceExists) {
-    if (!gitRoot(process.cwd())) {
-      throw new UsageError(
-        "no chamba workspace, and no .git here to anchor one - run `chamba init <dir>` or `chamba init --here` to choose where .chamba lives"
-      );
-    }
-    await ensureChambaHome(ctx.home);
-    note(`created chamba workspace at ${ctx.home}`);
-  }
-  note(`home: ${ctx.home}  port: ${ctx.port}`);
-  const { spawned } = await ensureServer(ctx.client, { home: ctx.home, port: ctx.port });
-  if (spawned) note(`started chamba server on :${ctx.port}`);
-  const key = agentKey();
-  const state = await readState(ctx.home);
-  const existing = await resolveExisting(ctx, key, state);
-  const meta = existing ?? await create(ctx, key);
-  const cursor = state.cursors[meta.id] ?? (existing ? 0 : 1);
-  await writeState(withSession(state, meta.id, cursor, key), ctx.home);
-  out(sessionPageUrl(`http://localhost:${ctx.port}`, meta.id));
-  note("  in a container? if this link is unreachable from your host:");
-  note(
-    `  - the server bound ${resolveBindHost([])}; set CHAMBA_HOST=0.0.0.0 so the host can reach it`
-  );
-  note(`  - forward port ${ctx.port} to the host (1:1); pin it with CHAMBA_PORT to keep it stable`);
-  if (existing) {
-    note(`reconnected to session ${meta.id} - open the URL, then run \`chamba poll\``);
-  } else {
-    note(
-      `session ${meta.id} created - open the URL, then run \`chamba poll\` to wait for messages`
-    );
-  }
-  return 0;
-}
-async function resolveExisting(ctx, key, state) {
-  if (ctx.flags.new !== void 0) return null;
-  const wantLast = ctx.flags.last !== void 0;
-  if (!wantLast && !key) return null;
-  const active = (await ctx.client.list()).filter((s) => s.meta.status === "active").map((s) => s.meta);
-  if (wantLast) {
-    const found = active[0];
-    if (!found)
-      throw new UsageError("no active session to rebind - run `chamba open` to create one");
-    return found;
-  }
-  const bound = key ? state.bindings[key] : void 0;
-  return active.find((m) => m.id === bound) ?? active.find((m) => m.agentKey === key) ?? null;
-}
-async function create(ctx, key) {
-  const req = {
-    ...ctx.flags.title ? { title: ctx.flags.title } : {},
-    ...key ? { agentKey: key } : {}
-  };
-  const summary = await ctx.client.create(req);
-  return summary.meta;
-}
-
-// packages/cli/src/errors.ts
-function errorCode(err) {
-  const seen = /* @__PURE__ */ new Set();
-  const queue = [err];
-  while (queue.length > 0) {
-    const current = queue.shift();
-    if (!current || typeof current !== "object" || seen.has(current)) continue;
-    seen.add(current);
-    const code = current.code;
-    if (typeof code === "string") return code;
-    const cause = current.cause;
-    if (cause) queue.push(cause);
-    const errors = current.errors;
-    if (Array.isArray(errors)) queue.push(...errors);
-  }
-  return void 0;
-}
-function isConnectionRefused(err) {
-  return errorCode(err) === "ECONNREFUSED";
-}
-
-// packages/cli/src/commands/poll.ts
-var DEFAULT_FOLLOW_MS = 4 * 6e4;
-var BACKOFF_START_MS = 500;
-var BACKOFF_MAX_MS = 5e3;
-var RESPAWN_BUDGET = 3;
-var IDLE_GUARD_MS = 1e3;
-var realClock = {
-  now: () => Date.now(),
-  sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms))
-};
-async function poll(ctx, clock = realClock) {
-  const id = await resolveSessionId(ctx);
-  const wait = Math.min(intFlag(ctx.flags.wait, POLL_DEFAULT_WAIT_MS), POLL_MAX_WAIT_MS);
-  if (ctx.flags.once !== void 0) return pollOnce(ctx, id, wait);
-  const followMs = ctx.flags.for !== void 0 ? intFlag(ctx.flags.for, DEFAULT_FOLLOW_MS) : null;
-  let respawnsLeft = RESPAWN_BUDGET;
-  return follow(
-    {
-      now: clock.now,
-      sleep: clock.sleep,
-      cursor: async () => cursorFor(await readState(ctx.home), id),
-      poll: async (since) => {
-        const res = await ctx.client.poll(id, since, wait);
-        respawnsLeft = RESPAWN_BUDGET;
-        return res;
-      },
-      deliver: async (res) => {
-        printEvents(res.events, ctx.home);
-        await writeState(withSession(await readState(ctx.home), id, res.cursor), ctx.home);
-      },
-      recover: async (err) => {
-        if (!isConnectionRefused(err)) return "not-mine";
-        if (!await readServerInfo(ctx.home)) return "server-stopped";
-        if (respawnsLeft <= 0) return "unrecoverable";
-        respawnsLeft -= 1;
-        note("chamba server was down - restarting it");
-        try {
-          await ensureServer(ctx.client, { home: ctx.home, port: ctx.port });
-          return "respawned";
-        } catch (e) {
-          note(`could not restart the server: ${e.message}`);
-          return "unrecoverable";
-        }
-      },
-      onError: (err, giveUp) => note(pollErrorMessage(err, giveUp)),
-      onHeartbeat: () => note("still listening - re-run chamba poll to keep waiting"),
-      onEnded: () => note("session has ended - nothing more to wait for"),
-      onServerStopped: () => note("chamba server stopped - run `chamba open` to continue"),
-      isFatal
-    },
-    // The park floor never drops below the guard sleep, so a small (or zero) `--wait`
-    // - which makes the server answer empty at once - cannot spin the loop hot.
-    {
-      deadline: followMs === null ? null : clock.now() + followMs,
-      parkFloorMs: Math.max(IDLE_GUARD_MS, Math.floor(wait / 2))
-    }
-  );
-}
-async function pollOnce(ctx, id, wait) {
-  const state = await readState(ctx.home);
-  const since = cursorFor(state, id);
-  const res = await ctx.client.poll(id, since, wait);
-  if (res.events.length === 0) {
-    note("(no new messages)");
-    return 0;
-  }
-  printEvents(res.events, ctx.home);
-  await writeState(withSession(state, id, res.cursor), ctx.home);
-  return 0;
-}
-async function follow(io, cfg) {
-  let backoff = BACKOFF_START_MS;
-  while (true) {
-    const since = await io.cursor();
-    const start = io.now();
-    let res;
-    try {
-      res = await io.poll(since);
-    } catch (err) {
-      if (io.isFatal(err)) {
-        io.onError(err, true);
-        return 1;
-      }
-      const outcome = await io.recover?.(err) ?? "not-mine";
-      if (outcome === "respawned") {
-        backoff = BACKOFF_START_MS;
-        continue;
-      }
-      if (outcome === "server-stopped") {
-        io.onServerStopped?.();
-        return 0;
-      }
-      if (outcome === "unrecoverable") {
-        io.onError(err, true);
-        return 1;
-      }
-      const giveUp = cfg.deadline !== null && io.now() >= cfg.deadline;
-      io.onError(err, giveUp);
-      if (giveUp) return 1;
-      await io.sleep(backoff);
-      backoff = Math.min(backoff * 2, BACKOFF_MAX_MS);
-      continue;
-    }
-    backoff = BACKOFF_START_MS;
-    if (res.events.length > 0) {
-      await io.deliver(res);
-      return 0;
-    }
-    if (res.ended) {
-      io.onEnded?.();
-      return 0;
-    }
-    if (res.stopping) {
-      io.onServerStopped?.();
-      return 0;
-    }
-    if (cfg.deadline !== null && io.now() >= cfg.deadline) {
-      io.onHeartbeat();
-      return 0;
-    }
-    if (io.now() - start < cfg.parkFloorMs) await io.sleep(IDLE_GUARD_MS);
-  }
-}
-function isFatal(err) {
-  if (err instanceof ChannelError) return err.status === 404;
-  if (err instanceof SyntaxError) return true;
-  return err instanceof Error && err.name === "ZodError";
-}
-function pollErrorMessage(err, giveUp) {
-  if (err instanceof ChannelError && err.status === 404) {
-    return "session not found - it may have been removed";
-  }
-  const detail = err instanceof Error ? err.message : String(err);
-  return giveUp ? `poll failed: ${detail}` : `poll failed, retrying: ${detail}`;
-}
-
-// packages/cli/src/commands/reply.ts
-import { stat } from "node:fs/promises";
-async function reply(ctx) {
-  const text = ctx.positionals.join(" ").trim();
-  const files = filePaths(ctx.flags);
-  if (!text && files.length === 0) {
-    throw new UsageError("usage: chamba reply <text> [--to <seq>] [--file a,b] [--image a,b]");
-  }
-  const replyTo = replyToSeq(ctx.flags);
-  const id = await resolveSessionId(ctx);
-  for (const file of files) {
-    try {
-      const info = await stat(file);
-      if (!info.isFile()) throw new UsageError(`not a file: ${file}`);
-    } catch (err) {
-      if (err instanceof UsageError) throw err;
-      throw new UsageError(`file not found: ${file}`);
-    }
-  }
-  const attachmentIds = [];
-  for (const file of files) {
-    const attachment = await ctx.client.uploadAttachment(id, file);
-    attachmentIds.push(attachment.id);
-    note(`uploaded ${attachment.name}`);
-  }
-  await ctx.client.reply(id, {
-    ...text ? { text } : {},
-    ...attachmentIds.length > 0 ? { attachmentIds } : {},
-    ...replyTo !== void 0 ? { replyTo } : {}
-  });
-  note(`sent to ${id}`);
-  return 0;
-}
-function replyToSeq(flags) {
-  const raw = flags.to;
-  if (raw === void 0) return void 0;
-  const n = Number(raw);
-  if (raw === "true" || !Number.isInteger(n) || n < 0) {
-    throw new UsageError("`--to` needs an event seq, e.g. --to 42");
-  }
-  return n;
-}
-function filePaths(flags) {
-  return [flags.file, flags.image].filter((value) => typeof value === "string" && value !== "true").flatMap((value) => value.split(",")).map((value) => value.trim()).filter((value) => value.length > 0);
-}
-
-// packages/cli/src/commands/show.ts
-import { readFile as readFile6 } from "node:fs/promises";
-import path10 from "node:path";
-async function show(ctx) {
-  const file = ctx.positionals[0];
-  if (!file) throw new UsageError("usage: chamba show <file.html> [--name <name>]");
-  if (!/\.html?$/i.test(file)) {
-    throw new UsageError(`chamba show takes a self-contained HTML file, got: ${file}`);
-  }
-  let content;
-  try {
-    content = await readFile6(file, "utf8");
-  } catch (err) {
-    throw new UsageError(`could not read ${file}: ${err.message}`);
-  }
-  const flagName = ctx.flags.name?.trim();
-  const name = flagName && flagName !== "true" ? flagName : path10.basename(file).replace(/\.html?$/i, "");
-  const result = postPageReqSchema.safeParse({ name, content });
-  if (!result.success) {
-    throw new UsageError(`invalid page: ${result.error.issues.map((i) => i.message).join("; ")}`);
-  }
-  const id = await resolveSessionId(ctx);
-  const event = await ctx.client.showPage(id, result.data);
-  const ref = pageRefSchema.safeParse(event.payload?.page);
-  const shownAs = ref.success ? ref.data.name : name;
-  note(`showing "${shownAs}" in session ${id}${ref.success ? ` (${ref.data.relPath})` : ""}`);
-  return 0;
-}
-
-// packages/cli/src/commands/skill.ts
-import { cpSync, existsSync as existsSync6, rmSync } from "node:fs";
-import { homedir } from "node:os";
-import path11 from "node:path";
-import { fileURLToPath as fileURLToPath5 } from "node:url";
-async function skill(ctx) {
-  if (ctx.positionals[0] !== "install") {
-    throw new UsageError("usage: chamba skill install [--global]");
-  }
-  const source = resolveSkillSource();
-  if (!source) {
-    note("bundled skill not found");
-    return 1;
-  }
-  const base = ctx.flags.global ? homedir() : process.cwd();
-  const target = path11.join(base, ".claude", "skills", "chamba");
-  rmSync(target, { recursive: true, force: true });
-  cpSync(source, target, { recursive: true });
-  note(`installed the chamba skill to ${target}`);
-  note("reload your agent's skills, then use /chamba");
-  return 0;
-}
-function resolveSkillSource() {
-  const here = path11.dirname(fileURLToPath5(import.meta.url));
-  const candidates = [
-    path11.resolve(here, "../skill"),
-    // packaged: dist/cli.js -> <pkg>/skill
-    path11.resolve(here, "../../../../skill")
-    // dev: packages/cli/src/commands -> <repo>/skill
-  ];
-  return candidates.find((dir) => existsSync6(path11.join(dir, "SKILL.md"))) ?? null;
-}
-
-// packages/cli/src/commands/status.ts
-async function status(ctx) {
-  if (!ctx.workspaceExists) {
-    note(
-      "no chamba workspace here - run `chamba open` to start one (creates .chamba at the repo root), or `chamba init` to choose where"
-    );
-    return 0;
-  }
-  const state = await readState(ctx.home);
-  const up = await ctx.client.ownsHome(ctx.home);
-  const rows = up ? await rowsFromServer(ctx) : await rowsFromDisk(ctx);
-  note(`home: ${ctx.home}`);
-  if (rows.length === 0) {
-    note("no sessions yet - run `chamba open` to start one");
-    return 0;
-  }
-  note(up ? `chamba server up on :${ctx.port}` : "chamba server not running (disk state)");
-  for (const row of rows) {
-    out(formatSession(row.meta, row.presence, row.meta.id === state.currentSessionId));
-  }
-  return 0;
-}
-async function rowsFromServer(ctx) {
-  const summaries = await ctx.client.list();
-  return summaries.map((s) => ({ meta: s.meta, presence: s.presence }));
-}
-async function rowsFromDisk(ctx) {
-  const ids = await listSessionIds(ctx.home);
-  const metas = await Promise.all(ids.map((id) => readMeta(ctx.home, id)));
-  return metas.filter((meta) => meta !== null).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt)).map((meta) => ({ meta }));
-}
-
-// packages/cli/src/commands/stop.ts
-async function stop(ctx) {
-  const info = await readServerInfo(ctx.home);
-  if (!info) {
-    note("no chamba server running here");
-    return 0;
-  }
-  const client = new Client(`http://127.0.0.1:${info.port}/`);
-  if (!await client.ownsHome(ctx.home)) {
-    note("no chamba server running here");
-    return 0;
-  }
-  try {
-    process.kill(info.pid, "SIGTERM");
-  } catch {
-    note("no chamba server running here");
-    return 0;
-  }
-  if (await waitUntilDown(client)) {
-    note(`stopped chamba server on :${info.port}`);
-    return 0;
-  }
-  note(`sent stop to the chamba server (pid ${info.pid}) but it did not exit in time`);
-  return 1;
-}
-async function waitUntilDown(client, timeoutMs = 5e3) {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    if (!await client.isUp()) return true;
-    await delay(150);
-  }
-  return false;
-}
-
-// packages/cli/src/commands/index.ts
-var COMMANDS = {
-  init,
-  open: open2,
-  poll,
-  reply,
-  get,
-  show,
-  end,
-  status,
-  stop,
-  // Distribution: install the bundled skill into a Claude skills directory.
-  skill,
-  help,
-  "-h": help
-};
-function runCommand(name, ctx) {
-  const handler = COMMANDS[name];
-  if (!handler) {
-    note(`unknown command: ${name}`);
-    return help(ctx).then(() => 2);
-  }
-  return handler(ctx);
-}
-
-// packages/cli/src/index.ts
-var REQUIRES_WORKSPACE = /* @__PURE__ */ new Set(["poll", "reply", "get", "show", "end"]);
-async function main(argv = process.argv.slice(2)) {
-  const { positionals, flags } = parseArgs(argv);
-  if (flags.version && positionals.length === 0) {
-    out(chambaVersion());
-    return 0;
-  }
-  const command = positionals[0] ?? (flags.help ? "help" : "status");
-  const existing = findExistingHome();
-  const home = existing ?? plannedHome();
-  const port = resolvePort(argv, home);
-  const ctx = {
-    client: new Client(`http://127.0.0.1:${port}/`),
-    home,
-    port,
-    flags,
-    positionals: positionals.slice(1),
-    workspaceExists: existing !== null
-  };
-  if (!ctx.workspaceExists && REQUIRES_WORKSPACE.has(command)) {
-    note(
-      "no chamba workspace here - run `chamba open` to start one (creates .chamba at the repo root), or `chamba init` to choose where"
-    );
-    return 2;
-  }
-  try {
-    return await runCommand(command, ctx);
-  } catch (err) {
-    return reportError(err);
-  }
-}
-function reportError(err) {
-  if (err instanceof UsageError) {
-    note(err.message);
-    return 2;
-  }
-  if (err instanceof ChannelError) {
-    note(`error: ${err.message}`);
-    return 1;
-  }
-  if (isConnectionRefused(err)) {
-    note("cannot reach the chamba server - run `chamba open` first");
-    return 1;
-  }
-  note(`error: ${err.message}`);
-  return 1;
-}
-function invokedAsEntry() {
-  const entry = process.argv[1];
-  if (entry === void 0) return false;
-  try {
-    return realpathSync2(entry) === realpathSync2(fileURLToPath6(import.meta.url));
-  } catch {
-    return false;
-  }
-}
-if (invokedAsEntry()) {
-  main().then(
-    (code) => process.exit(code),
-    (err) => {
-      note(`fatal: ${err.message}`);
-      process.exit(1);
-    }
-  );
-}
-export {
-  main
-};