@vm0/cli 9.252.1 → 9.254.0

package/{agent-6DLY56R2.js → agent-RMGI2J4J.js}

@@ -4,14 +4,14 @@ const require = __createRequire(import.meta.url);
 import {
   loadConnectorPermissionInfos,
   policyIcon
-} from "./chunk-KBUXPDDX.js";
+} from "./chunk-CMTIFAL7.js";
 import {
   isInteractive,
   promptConfirm
 } from "./chunk-X2545RBX.js";
 import {
   permissionGrantsToFirewallPolicies
-} from "./chunk-CPJVE3HV.js";
+} from "./chunk-OVTYR6LM.js";
 import {
   createZeroAgent,
   deleteZeroAgent,
@@ -23,14 +23,14 @@ import {
   listZeroUserPermissionGrants,
   updateZeroAgent,
   updateZeroAgentInstructions
-} from "./chunk-FBISVSTZ.js";
-import "./chunk-OAESJHRL.js";
+} from "./chunk-RPYYZK6K.js";
+import "./chunk-5SWLOAHS.js";
 import "./chunk-SB7EZ2ZO.js";
 import {
   source_default,
   withErrorHandler
-} from "./chunk-7NPYHUEQ.js";
-import "./chunk-DK3C2ME6.js";
+} from "./chunk-7JATDT76.js";
+import "./chunk-D4OTAABD.js";
 import {
   Command
 } from "./chunk-LD4ZVU4O.js";
@@ -594,4 +594,4 @@ Notes:
 export {
   zeroAgentCommand
 };
-//# sourceMappingURL=agent-6DLY56R2.js.map
+//# sourceMappingURL=agent-RMGI2J4J.js.map

package/{banking-22B7QVCY.js → banking-MY3UOHLJ.js}

@@ -3,14 +3,14 @@ import { createRequire as __createRequire } from "node:module";
 const require = __createRequire(import.meta.url);
 import {
   callZeroBanking
-} from "./chunk-FBISVSTZ.js";
-import "./chunk-OAESJHRL.js";
+} from "./chunk-RPYYZK6K.js";
+import "./chunk-5SWLOAHS.js";
 import "./chunk-SB7EZ2ZO.js";
 import {
   source_default,
   withErrorHandler
-} from "./chunk-7NPYHUEQ.js";
-import "./chunk-DK3C2ME6.js";
+} from "./chunk-7JATDT76.js";
+import "./chunk-D4OTAABD.js";
 import {
   Command,
   InvalidArgumentError
@@ -114,4 +114,4 @@ Notes:
 export {
   zeroBankingCommand
 };
-//# sourceMappingURL=banking-22B7QVCY.js.map
+//# sourceMappingURL=banking-MY3UOHLJ.js.map

package/chat-YXUYGE6R.js

@@ -0,0 +1,622 @@
+#!/usr/bin/env node
+import { createRequire as __createRequire } from "node:module";
+const require = __createRequire(import.meta.url);
+import {
+  formatIsoTimestamp,
+  isUuid,
+  parseBoundedLogCount
+} from "./chunk-B6ELBBRJ.js";
+import {
+  formatModelProviderRoute
+} from "./chunk-SISEWEDH.js";
+import {
+  chatThreadEventSchema,
+  chatThreadSnapshotProjectionSchema,
+  getZeroChatThread,
+  getZeroChatThreadSnapshot,
+  listZeroChatThreadEvents,
+  listZeroModelPolicies,
+  renameZeroChatThread,
+  updateZeroChatThreadModelSelection
+} from "./chunk-RPYYZK6K.js";
+import "./chunk-5SWLOAHS.js";
+import "./chunk-SB7EZ2ZO.js";
+import {
+  getApiUrl,
+  source_default,
+  withErrorHandler
+} from "./chunk-7JATDT76.js";
+import {
+  decodeZeroTokenPayload
+} from "./chunk-D4OTAABD.js";
+import {
+  Command
+} from "./chunk-LD4ZVU4O.js";
+import {
+  init_esm_shims
+} from "./chunk-3VVCUQPB.js";
+
+// src/commands/zero/chat/index.ts
+init_esm_shims();
+
+// src/commands/zero/chat/get.ts
+init_esm_shims();
+function getCurrentChatThreadId() {
+  return process.env.ZERO_CHAT_THREAD_ID?.trim() || void 0;
+}
+function printUsageError(message, hint) {
+  console.error(source_default.red(`\u2717 ${message}`));
+  console.error(source_default.dim(`  ${hint}`));
+  process.exit(1);
+}
+var getCommand = new Command().name("get").description("Show the current web chat thread").option("--json", "Print machine-readable JSON").addHelpText(
+  "after",
+  `
+Examples:
+  Show this chat:    zero chat get
+  Print JSON:        zero chat get --json
+
+Notes:
+  - Uses ZERO_CHAT_THREAD_ID from the current web chat thread
+  - Authenticates via ZERO_TOKEN (requires chat-thread:read capability)`
+).action(
+  withErrorHandler(async (options) => {
+    const threadId = getCurrentChatThreadId();
+    if (!threadId) {
+      printUsageError(
+        "ZERO_CHAT_THREAD_ID is not set",
+        "Run this command from a Zero web chat thread."
+      );
+    }
+    const thread = await getZeroChatThread({ threadId });
+    if (options.json) {
+      console.log(JSON.stringify(thread));
+      return;
+    }
+    console.log(source_default.green("\u2713 Chat thread loaded"));
+    console.log(source_default.dim(`  Thread: ${thread.id}`));
+    console.log(source_default.dim(`  Title:  ${thread.title ?? "(untitled)"}`));
+    console.log(
+      source_default.dim(`  Model:  ${thread.selectedModel ?? "(default)"}`)
+    );
+  })
+);
+
+// src/commands/zero/chat/list.ts
+init_esm_shims();
+
+// src/commands/zero/chat/chat-thread-cache.ts
+init_esm_shims();
+import { createHash, randomUUID } from "crypto";
+import { mkdir, readFile, rename, rm, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { dirname, join } from "path";
+
+// ../../packages/core/src/chat-thread-event-replay.ts
+init_esm_shims();
+function compareThreadOrder(left, right) {
+  const leftPinned = left.pinnedAt !== null;
+  const rightPinned = right.pinnedAt !== null;
+  if (leftPinned !== rightPinned) {
+    return leftPinned ? -1 : 1;
+  }
+  const sortCompare = right.sortAt.localeCompare(left.sortAt);
+  if (sortCompare !== 0) {
+    return sortCompare;
+  }
+  return right.id.localeCompare(left.id);
+}
+function applyEvent(threads, event, pendingThreadUpdates) {
+  if (event.kind === "created") {
+    threads.set(event.chatThreadId, {
+      id: event.chatThreadId,
+      agentId: event.agentId,
+      title: event.title,
+      sortAt: event.createdAt,
+      createdAt: event.createdAt,
+      updatedAt: event.createdAt,
+      pinnedAt: null,
+      renamedAt: null,
+      selectedModel: event.selectedModel,
+      serviceTier: event.serviceTier,
+      computerUseHostId: event.computerUseHostId
+    });
+    const pendingUpdates = pendingThreadUpdates.get(event.chatThreadId) ?? [];
+    pendingThreadUpdates.delete(event.chatThreadId);
+    for (const pendingUpdate of pendingUpdates) {
+      if (pendingUpdate.createdAt.localeCompare(event.createdAt) >= 0) {
+        applyEvent(threads, pendingUpdate, pendingThreadUpdates);
+      }
+    }
+    return;
+  }
+  if (event.kind === "deleted") {
+    threads.delete(event.chatThreadId);
+    return;
+  }
+  const thread = threads.get(event.chatThreadId);
+  if (!thread) {
+    if (event.kind === "model_selection_updated" || event.kind === "service_tier_updated" || event.kind === "computer_use_host_updated") {
+      const pendingUpdates = pendingThreadUpdates.get(event.chatThreadId) ?? [];
+      pendingThreadUpdates.set(event.chatThreadId, [...pendingUpdates, event]);
+    }
+    return;
+  }
+  if (event.kind === "renamed") {
+    threads.set(event.chatThreadId, {
+      ...thread,
+      title: event.title,
+      renamedAt: event.createdAt,
+      updatedAt: event.createdAt
+    });
+    return;
+  }
+  if (event.kind === "pinned") {
+    threads.set(event.chatThreadId, {
+      ...thread,
+      pinnedAt: event.createdAt,
+      updatedAt: event.createdAt
+    });
+    return;
+  }
+  if (event.kind === "unpinned") {
+    threads.set(event.chatThreadId, {
+      ...thread,
+      pinnedAt: null,
+      updatedAt: event.createdAt
+    });
+    return;
+  }
+  if (event.kind === "model_selection_updated") {
+    threads.set(event.chatThreadId, {
+      ...thread,
+      selectedModel: event.selectedModel,
+      updatedAt: event.createdAt
+    });
+    return;
+  }
+  if (event.kind === "service_tier_updated") {
+    threads.set(event.chatThreadId, {
+      ...thread,
+      serviceTier: event.serviceTier,
+      updatedAt: event.createdAt
+    });
+    return;
+  }
+  if (event.kind === "computer_use_host_updated") {
+    threads.set(event.chatThreadId, {
+      ...thread,
+      computerUseHostId: event.computerUseHostId,
+      updatedAt: event.createdAt
+    });
+    return;
+  }
+  threads.set(event.chatThreadId, {
+    ...thread,
+    sortAt: event.createdAt
+  });
+}
+function replayChatThreadEvents(snapshot, events) {
+  const threads = /* @__PURE__ */ new Map();
+  for (const thread of snapshot) {
+    threads.set(thread.id, {
+      ...thread,
+      selectedModel: thread.selectedModel ?? null,
+      serviceTier: thread.serviceTier ?? null,
+      computerUseHostId: thread.computerUseHostId ?? null
+    });
+  }
+  const pendingThreadUpdates = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    applyEvent(threads, event, pendingThreadUpdates);
+  }
+  return [...threads.values()].sort(compareThreadOrder);
+}
+
+// src/commands/zero/chat/chat-thread-cache.ts
+var CACHE_VERSION = 1;
+var MAX_EVENT_PAGES_PER_SYNC = 20;
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function parseCache(raw) {
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      return null;
+    }
+    throw error;
+  }
+  if (!isRecord(value) || value.version !== CACHE_VERSION || !isRecord(value.snapshot)) {
+    return null;
+  }
+  const chatThreads = chatThreadSnapshotProjectionSchema.array().safeParse(value.snapshot.chatThreads);
+  const events = chatThreadEventSchema.array().safeParse(value.events);
+  const latestEventId2 = value.snapshot.latestEventId;
+  if (!chatThreads.success || !events.success || latestEventId2 !== null && typeof latestEventId2 !== "string") {
+    return null;
+  }
+  return {
+    version: CACHE_VERSION,
+    snapshot: {
+      chatThreads: chatThreads.data,
+      latestEventId: latestEventId2
+    },
+    events: events.data
+  };
+}
+function cacheRoot() {
+  return process.env.XDG_CACHE_HOME?.trim() || join(homedir(), ".cache");
+}
+async function cachePath() {
+  const token = decodeZeroTokenPayload();
+  if (!token) {
+    throw new Error("ZERO_TOKEN does not contain a valid Zero cache scope");
+  }
+  const apiUrl = await getApiUrl();
+  const scope = createHash("sha256").update(`${apiUrl}\0${token.orgId}\0${token.userId}`).digest("hex");
+  return join(cacheRoot(), "vm0", "zero", "chat-threads", `${scope}.json`);
+}
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+async function readCache(path) {
+  let raw;
+  try {
+    raw = await readFile(path, "utf8");
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+  return parseCache(raw);
+}
+async function writeCache(path, cache) {
+  await mkdir(dirname(path), { recursive: true, mode: 448 });
+  const temporaryPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(temporaryPath, `${JSON.stringify(cache)}
+`, {
+      encoding: "utf8",
+      flag: "wx",
+      mode: 384
+    });
+    await rename(temporaryPath, path);
+  } finally {
+    await rm(temporaryPath, { force: true });
+  }
+}
+function mergeEvents(existing, incoming) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const event of existing) {
+    byId.set(event.id, event);
+  }
+  for (const event of incoming) {
+    byId.set(event.id, event);
+  }
+  return [...byId.values()].sort((left, right) => {
+    const timeCompare = left.createdAt.localeCompare(right.createdAt);
+    return timeCompare !== 0 ? timeCompare : left.id.localeCompare(right.id);
+  });
+}
+async function freshCache() {
+  return {
+    version: CACHE_VERSION,
+    snapshot: await getZeroChatThreadSnapshot(),
+    events: []
+  };
+}
+function latestEventId(cache) {
+  return cache.events.at(-1)?.id ?? cache.snapshot.latestEventId ?? void 0;
+}
+async function syncCachedChatThreads() {
+  const path = await cachePath();
+  let cache = await readCache(path) ?? await freshCache();
+  let cursor = latestEventId(cache);
+  for (let page = 0; page < MAX_EVENT_PAGES_PER_SYNC; page++) {
+    const result = await listZeroChatThreadEvents({
+      sinceEventId: cursor
+    });
+    if (result.kind === "expired") {
+      cache = await freshCache();
+      cursor = latestEventId(cache);
+      continue;
+    }
+    if (result.events.length > 0) {
+      cache = {
+        ...cache,
+        events: mergeEvents(cache.events, result.events)
+      };
+      const lastEvent = result.events.at(-1);
+      if (lastEvent) {
+        cursor = lastEvent.id;
+      }
+    }
+    if (!result.hasMore || result.events.length === 0) {
+      break;
+    }
+  }
+  await writeCache(path, cache);
+  return replayChatThreadEvents(cache.snapshot.chatThreads, cache.events);
+}
+
+// src/commands/zero/chat/list.ts
+var DEFAULT_LIMIT = 20;
+var MAX_LIMIT = 100;
+function printUsageError2(message, hint) {
+  console.error(source_default.red(`\u2717 ${message}`));
+  console.error(source_default.dim(`  ${hint}`));
+  process.exit(1);
+}
+function resolveAgentId(flagAgentId) {
+  const agentId = flagAgentId?.trim() || process.env.ZERO_AGENT_ID?.trim();
+  if (!agentId) {
+    printUsageError2(
+      "ZERO_AGENT_ID is not set",
+      "Pass --agent <agent-id> or run inside an agent sandbox."
+    );
+  }
+  if (!isUuid(agentId)) {
+    printUsageError2(
+      `Invalid agent ID "${agentId}" \u2014 expected a UUID`,
+      "Pass a valid UUID with --agent <agent-id>."
+    );
+  }
+  return agentId;
+}
+function titleForDisplay(title) {
+  return (title ?? "(untitled)").replace(/\s+/g, " ");
+}
+var listCommand = new Command().name("list").alias("ls").description("List web chat threads for an agent").option("--agent <id>", "Filter by Zero agent ID (defaults to ZERO_AGENT_ID)").option(
+  "--limit <n>",
+  `Maximum number of threads to print (default: ${DEFAULT_LIMIT}, max: ${MAX_LIMIT})`
+).option("--json", "Print machine-readable JSON").addHelpText(
+  "after",
+  `
+Examples:
+  List this agent's chats:  zero chat list
+  List another agent:       zero chat list --agent <agent-id>
+  Limit the output:         zero chat list --limit 10
+  Print JSON:               zero chat list --json
+
+Notes:
+  - Defaults --agent to ZERO_AGENT_ID
+  - Authenticates via ZERO_TOKEN (requires chat-thread:read capability)
+  - Replays cached snapshot and incremental chat thread events`
+).action(
+  withErrorHandler(async (options) => {
+    const agentId = resolveAgentId(options.agent);
+    const limit = options.limit === void 0 ? DEFAULT_LIMIT : parseBoundedLogCount(options.limit, "--limit", 1, MAX_LIMIT);
+    const allThreads = await syncCachedChatThreads();
+    const matchingThreads = allThreads.filter((thread) => {
+      return thread.agentId === agentId;
+    });
+    const threads = matchingThreads.slice(0, limit);
+    if (options.json) {
+      console.log(
+        JSON.stringify({
+          agentId,
+          total: matchingThreads.length,
+          threads
+        })
+      );
+      return;
+    }
+    if (threads.length === 0) {
+      console.log(source_default.dim("No chat threads found"));
+      return;
+    }
+    const header = [
+      "THREAD ID".padEnd(38),
+      "SORTED".padEnd(20),
+      "PINNED".padEnd(6),
+      "TITLE"
+    ].join("  ");
+    console.log(source_default.dim(header));
+    for (const thread of threads) {
+      console.log(
+        [
+          thread.id.padEnd(38),
+          formatIsoTimestamp(thread.sortAt).padEnd(20),
+          (thread.pinnedAt === null ? "-" : "yes").padEnd(6),
+          titleForDisplay(thread.title)
+        ].join("  ")
+      );
+    }
+    if (threads.length < matchingThreads.length) {
+      console.log();
+      console.log(
+        source_default.dim(
+          `  Showing ${threads.length} of ${matchingThreads.length} threads. Use --limit to adjust.`
+        )
+      );
+    }
+  })
+);
+
+// src/commands/zero/chat/model.ts
+init_esm_shims();
+function getCurrentChatThreadId2() {
+  return process.env.ZERO_CHAT_THREAD_ID?.trim() || void 0;
+}
+function printUsageError3(message, hint) {
+  console.error(source_default.red(`\u2717 ${message}`));
+  console.error(source_default.dim(`  ${hint}`));
+  process.exit(1);
+}
+function switchablePolicies(policies) {
+  return policies.filter((policy) => {
+    return policy.routeStatus === "valid";
+  });
+}
+function formatModelName(policy) {
+  return `${policy.modelLabel} ${source_default.dim(`(${policy.model})`)}`;
+}
+function printSwitchableModels(policies) {
+  const switchable = switchablePolicies(policies);
+  if (switchable.length === 0) {
+    console.log(source_default.dim("No switchable models are available for this user"));
+    return;
+  }
+  for (const policy of switchable) {
+    const defaultMarker = policy.isDefault ? source_default.dim(" (default)") : "";
+    console.log(`  - ${formatModelName(policy)}${defaultMarker}`);
+    console.log(`    provider: ${formatModelProviderRoute(policy)}`);
+  }
+}
+function printCurrentModel(thread) {
+  console.log(source_default.green("\u2713 Chat thread loaded"));
+  console.log(source_default.dim(`  Thread: ${thread.id}`));
+  console.log(source_default.dim(`  Title:  ${thread.title ?? "(untitled)"}`));
+  console.log(source_default.dim(`  Model:  ${thread.selectedModel ?? "(default)"}`));
+}
+async function printModelHelp(command) {
+  const result = await listZeroModelPolicies();
+  console.log(command.helpInformation().trimEnd());
+  console.log();
+  console.log(source_default.bold("Switchable models:"));
+  printSwitchableModels(result.policies);
+  console.log();
+  console.log("Use the model id in parentheses:");
+  console.log(source_default.cyan("  zero chat model <model>"));
+}
+async function printCurrentModelAndChoices(threadId) {
+  const [thread, result] = await Promise.all([
+    getZeroChatThread({ threadId }),
+    listZeroModelPolicies()
+  ]);
+  printCurrentModel(thread);
+  console.log();
+  console.log(source_default.bold("Switchable models:"));
+  printSwitchableModels(result.policies);
+  console.log();
+  console.log("Switch models:");
+  console.log(source_default.cyan("  zero chat model <model>"));
+}
+async function switchModel(threadId, model) {
+  const result = await listZeroModelPolicies();
+  const policy = result.policies.find((candidate) => {
+    return candidate.model === model;
+  });
+  if (!policy) {
+    printUsageError3(`Unknown model: ${model}`, "Run: zero chat model --help");
+  }
+  if (policy.routeStatus !== "valid") {
+    const reason = policy.routeStatusReason ? ` (${policy.routeStatusReason})` : "";
+    printUsageError3(
+      `Model is not switchable: ${model}${reason}`,
+      "Run: zero chat model --help"
+    );
+  }
+  const updated = await updateZeroChatThreadModelSelection({
+    threadId,
+    model
+  });
+  console.log(source_default.green("\u2713 Chat model updated"));
+  console.log(source_default.dim(`  Thread: ${updated.threadId}`));
+  console.log(source_default.dim(`  Model:  ${policy.modelLabel} (${model})`));
+}
+var modelCommand = new Command().name("model").description("Show or switch the current web chat thread model").argument("[model]", "Model id to use for this chat thread").helpOption(false).option("-h, --help", "Show help with switchable models").addHelpText(
+  "after",
+  `
+Examples:
+  Show this chat model:  zero chat model
+  Switch this model:    zero chat model claude-sonnet-5
+
+Notes:
+  - Uses ZERO_CHAT_THREAD_ID from the current web chat thread
+  - Authenticates via ZERO_TOKEN (requires chat-thread:write capability to switch)`
+).action(
+  withErrorHandler(
+    async (model, options) => {
+      if (options.help) {
+        await printModelHelp(modelCommand);
+        return;
+      }
+      const threadId = getCurrentChatThreadId2();
+      if (!threadId) {
+        printUsageError3(
+          "ZERO_CHAT_THREAD_ID is not set",
+          "Run this command from a Zero web chat thread."
+        );
+      }
+      if (!model) {
+        await printCurrentModelAndChoices(threadId);
+        return;
+      }
+      await switchModel(threadId, model);
+    }
+  )
+);
+
+// src/commands/zero/chat/rename.ts
+init_esm_shims();
+function getCurrentChatThreadId3() {
+  return process.env.ZERO_CHAT_THREAD_ID?.trim() || void 0;
+}
+function printUsageError4(message, hint) {
+  console.error(source_default.red(`\u2717 ${message}`));
+  console.error(source_default.dim(`  ${hint}`));
+  process.exit(1);
+}
+var renameCommand = new Command().name("rename").description("Rename a web chat thread").argument("<title...>", "New chat title").option("--thread <id>", "Chat thread ID (defaults to ZERO_CHAT_THREAD_ID)").option("--json", "Print machine-readable JSON").addHelpText(
+  "after",
+  `
+Examples:
+  Rename this chat:  zero chat rename "Launch plan"
+  Rename another:    zero chat rename --thread <thread-id> "Launch plan"
+
+Notes:
+  - Defaults --thread to ZERO_CHAT_THREAD_ID
+  - Authenticates via ZERO_TOKEN (requires chat-thread:write capability)`
+).action(
+  withErrorHandler(async (titleParts, options) => {
+    const title = titleParts.join(" ").trim();
+    if (!title) {
+      printUsageError4(
+        "Title is required",
+        'Run: zero chat rename "New title"'
+      );
+    }
+    const threadId = options.thread?.trim() || getCurrentChatThreadId3();
+    if (!threadId) {
+      printUsageError4(
+        "ZERO_CHAT_THREAD_ID is not set",
+        "Pass --thread <thread-id> or run inside a Zero web chat thread."
+      );
+    }
+    if (!isUuid(threadId)) {
+      printUsageError4(
+        `Invalid thread ID "${threadId}" \u2014 expected a UUID`,
+        "Pass a valid UUID with --thread <thread-id>."
+      );
+    }
+    const result = await renameZeroChatThread({ threadId, title });
+    if (options.json) {
+      console.log(JSON.stringify(result));
+      return;
+    }
+    console.log(source_default.green("\u2713 Chat title updated"));
+    console.log(source_default.dim(`  Thread: ${result.threadId}`));
+    console.log(source_default.dim(`  Title:  ${result.title}`));
+  })
+);
+
+// src/commands/zero/chat/index.ts
+var zeroChatCommand = new Command().name("chat").description("Manage web chat threads").addCommand(getCommand).addCommand(listCommand).addCommand(modelCommand).addCommand(renameCommand).addHelpText(
+  "after",
+  `
+Examples:
+  List agent chats:  zero chat list
+  Show this chat:    zero chat get
+  Switch model:      zero chat model claude-sonnet-5
+  Rename this chat:  zero chat rename "Launch plan"
+  Rename another:    zero chat rename --thread <thread-id> "Launch plan"`
+);
+export {
+  zeroChatCommand
+};
+//# sourceMappingURL=chat-YXUYGE6R.js.map