@linzumi/cli 0.0.20-beta → 0.0.22-beta

package/src/agentBootstrap.ts

@@ -1,872 +0,0 @@
-/*
-- Date: 2026-05-02
-  Spec: plans/2026-05-02-agent-first-zero-to-codex-launch-plan.md
-  Relationship: Implements the CLI side of the agent-first bootstrap contract:
-  signup, claim, thread creation, progress, inbox, and done messages against
-  the external /agent/* machine API.
-*/
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { homedir } from "node:os";
-import { type JsonObject, type JsonValue, isJsonObject } from "./protocol";
-import { arrayValue, objectValue, stringValue } from "./json";
-
-const defaultApiUrl = "https://serve.linzumi.com";
-
-type AgentCommand =
-  | { readonly kind: "help" }
-  | {
-      readonly kind: "signup";
-      readonly apiUrl: string;
-      readonly email: string;
-      readonly agentName: string;
-    }
-  | {
-      readonly kind: "claim";
-      readonly apiUrl: string;
-      readonly pendingId: string;
-      readonly code: string;
-      readonly tokenFile: string;
-    }
-  | {
-      readonly kind: "threadNew";
-      readonly apiUrl: string;
-      readonly title: string;
-      readonly message: string;
-      readonly tokenFile: string;
-    }
-  | {
-      readonly kind: "channelPost";
-      readonly apiUrl: string;
-      readonly channelId: string;
-      readonly body: string;
-      readonly tokenFile: string;
-    }
-  | {
-      readonly kind: "post";
-      readonly apiUrl: string;
-      readonly threadId: string;
-      readonly body: string;
-      readonly messageKind: "progress" | "question";
-      readonly tokenFile: string;
-    }
-  | {
-      readonly kind: "inbox";
-      readonly apiUrl: string;
-      readonly threadId: string;
-      readonly sinceLast: boolean;
-      readonly tokenFile: string;
-    }
-  | {
-      readonly kind: "done";
-      readonly apiUrl: string;
-      readonly threadId: string;
-      readonly message: string;
-      readonly tokenFile: string;
-    }
-  | {
-      readonly kind: "codexStart";
-      readonly apiUrl: string;
-      readonly threadId: string;
-      readonly runnerId: string;
-      readonly cwd: string;
-      readonly workDescription: string;
-      readonly model: string | undefined;
-      readonly reasoningEffort: string | undefined;
-      readonly approvalPolicy: string | undefined;
-      readonly sandbox: string | undefined;
-      readonly fast: boolean;
-      readonly tokenFile: string;
-    }
-  | {
-      readonly kind: "editorOpen";
-      readonly apiUrl: string;
-      readonly threadId: string;
-      readonly runnerId: string;
-      readonly cwd: string;
-      readonly tokenFile: string;
-    };
-
-export type AgentTokenFile = {
-  readonly apiUrl: string;
-  readonly agentToken: string;
-  readonly agentId: string;
-  readonly workspaceId: string;
-  readonly channelId: string | undefined;
-  readonly ownerUsername: string | undefined;
-  readonly channelUrl: string;
-  readonly loginUrl: string;
-  readonly supportChannelId: string;
-  readonly supportChannelUrl: string | undefined;
-  readonly savedAt: string;
-  readonly cursors: Record<string, string>;
-};
-
-type AgentCliDeps = {
-  readonly fetchImpl: typeof fetch;
-  readonly stdout: Pick<typeof process.stdout, "write">;
-  readonly readTextFile: (path: string) => string | undefined;
-  readonly writeTextFile: (path: string, content: string) => void;
-};
-
-export async function runAgentCliCommand(
-  args: readonly string[],
-  deps: AgentCliDeps = {
-    fetchImpl: fetch,
-    stdout: process.stdout,
-    readTextFile: readOptionalTextFile,
-    writeTextFile,
-  },
-): Promise<void> {
-  const command = parseAgentCommand(args);
-
-  switch (command.kind) {
-    case "help":
-      deps.stdout.write(agentHelpText());
-      return;
-    case "signup":
-      await runSignup(command, deps);
-      return;
-    case "claim":
-      await runClaim(command, deps);
-      return;
-    case "threadNew":
-      await runThreadNew(command, deps);
-      return;
-    case "channelPost":
-      await runChannelPost(command, deps);
-      return;
-    case "post":
-      await runPost(command, deps);
-      return;
-    case "inbox":
-      await runInbox(command, deps);
-      return;
-    case "done":
-      await runDone(command, deps);
-      return;
-    case "codexStart":
-      await runCodexStart(command, deps);
-      return;
-    case "editorOpen":
-      await runEditorOpen(command, deps);
-      return;
-  }
-}
-
-function parseAgentCommand(args: readonly string[]): AgentCommand {
-  const [first, ...rest] = args;
-
-  switch (first) {
-    case undefined:
-    case "--help":
-    case "-h":
-    case "help":
-      return { kind: "help" };
-    case "signup": {
-      const parsed = parseAgentArgs(rest);
-      return {
-        kind: "signup",
-        apiUrl: agentApiUrl(parsed.flags),
-        email: requiredFlag(parsed.flags, "email"),
-        agentName: requiredFlag(parsed.flags, "agent-name"),
-      };
-    }
-    case "claim": {
-      const parsed = parseAgentArgs(rest);
-      return {
-        kind: "claim",
-        apiUrl: agentApiUrl(parsed.flags),
-        pendingId: requiredFlag(parsed.flags, "pending"),
-        code: requiredFlag(parsed.flags, "code"),
-        tokenFile: agentTokenFile(parsed.flags),
-      };
-    }
-    case "thread": {
-      const [subcommand, ...subcommandArgs] = rest;
-
-      if (subcommand !== "new") {
-        throw new Error("linzumi thread supports: new");
-      }
-
-      const parsed = parseAgentArgs(subcommandArgs);
-      const [title, ...extra] = parsed.positionals;
-
-      if (title === undefined || title.trim() === "") {
-        throw new Error("missing thread title");
-      }
-
-      if (extra.length > 0) {
-        throw new Error("linzumi thread new accepts one title");
-      }
-
-      return {
-        kind: "threadNew",
-        apiUrl: agentApiUrl(parsed.flags),
-        title,
-        message: requiredFlag(parsed.flags, "message"),
-        tokenFile: agentTokenFile(parsed.flags),
-      };
-    }
-    case "channel": {
-      const [subcommand, ...subcommandArgs] = rest;
-
-      if (subcommand !== "post") {
-        throw new Error("linzumi channel supports: post");
-      }
-
-      const parsed = parseAgentArgs(subcommandArgs);
-      const [channelId, body, ...extra] = parsed.positionals;
-
-      if (channelId === undefined || channelId.trim() === "") {
-        throw new Error("missing channel id");
-      }
-
-      if (body === undefined || body.trim() === "") {
-        throw new Error("missing message body");
-      }
-
-      if (extra.length > 0) {
-        throw new Error("linzumi channel post accepts channel id and one message body");
-      }
-
-      return {
-        kind: "channelPost",
-        apiUrl: agentApiUrl(parsed.flags),
-        channelId,
-        body,
-        tokenFile: agentTokenFile(parsed.flags),
-      };
-    }
-    case "post": {
-      const parsed = parseAgentArgs(rest);
-      const [threadId, body, ...extra] = parsed.positionals;
-
-      if (threadId === undefined || threadId.trim() === "") {
-        throw new Error("missing thread id");
-      }
-
-      if (body === undefined || body.trim() === "") {
-        throw new Error("missing message body");
-      }
-
-      if (extra.length > 0) {
-        throw new Error("linzumi post accepts thread id and one message body");
-      }
-
-      return {
-        kind: "post",
-        apiUrl: agentApiUrl(parsed.flags),
-        threadId,
-        body,
-        messageKind: parsePostKind(parsed.flags.get("kind")),
-        tokenFile: agentTokenFile(parsed.flags),
-      };
-    }
-    case "inbox": {
-      const parsed = parseAgentArgs(rest);
-      const [threadId, ...extra] = parsed.positionals;
-
-      if (threadId === undefined || threadId.trim() === "") {
-        throw new Error("missing thread id");
-      }
-
-      if (extra.length > 0) {
-        throw new Error("linzumi inbox accepts one thread id");
-      }
-
-      return {
-        kind: "inbox",
-        apiUrl: agentApiUrl(parsed.flags),
-        threadId,
-        sinceLast: parsed.flags.get("since-last") === "true",
-        tokenFile: agentTokenFile(parsed.flags),
-      };
-    }
-    case "done": {
-      const parsed = parseAgentArgs(rest);
-      const [threadId, ...extra] = parsed.positionals;
-
-      if (threadId === undefined || threadId.trim() === "") {
-        throw new Error("missing thread id");
-      }
-
-      if (extra.length > 0) {
-        throw new Error("linzumi done accepts one thread id");
-      }
-
-      return {
-        kind: "done",
-        apiUrl: agentApiUrl(parsed.flags),
-        threadId,
-        message: requiredFlag(parsed.flags, "message"),
-        tokenFile: agentTokenFile(parsed.flags),
-      };
-    }
-    case "codex": {
-      const [subcommand, ...subcommandArgs] = rest;
-
-      if (subcommand !== "start") {
-        throw new Error("linzumi codex supports: start");
-      }
-
-      const parsed = parseAgentArgs(subcommandArgs);
-      const [threadId, ...extra] = parsed.positionals;
-
-      if (threadId === undefined || threadId.trim() === "") {
-        throw new Error("missing thread id");
-      }
-
-      if (extra.length > 0) {
-        throw new Error("linzumi codex start accepts one thread id");
-      }
-
-      return {
-        kind: "codexStart",
-        apiUrl: agentApiUrl(parsed.flags),
-        threadId,
-        runnerId: requiredFlag(parsed.flags, "runner"),
-        cwd: requiredFlag(parsed.flags, "cwd"),
-        workDescription: requiredFlag(parsed.flags, "work-description"),
-        model: optionalFlag(parsed.flags, "model"),
-        reasoningEffort: optionalFlag(parsed.flags, "reasoning-effort"),
-        approvalPolicy: optionalFlag(parsed.flags, "approval-policy"),
-        sandbox: optionalFlag(parsed.flags, "sandbox"),
-        fast: parsed.flags.get("fast") === "true",
-        tokenFile: agentTokenFile(parsed.flags),
-      };
-    }
-    case "editor": {
-      const [subcommand, ...subcommandArgs] = rest;
-
-      if (subcommand !== "open") {
-        throw new Error("linzumi editor supports: open");
-      }
-
-      const parsed = parseAgentArgs(subcommandArgs);
-      const [threadId, ...extra] = parsed.positionals;
-
-      if (threadId === undefined || threadId.trim() === "") {
-        throw new Error("missing thread id");
-      }
-
-      if (extra.length > 0) {
-        throw new Error("linzumi editor open accepts one thread id");
-      }
-
-      return {
-        kind: "editorOpen",
-        apiUrl: agentApiUrl(parsed.flags),
-        threadId,
-        runnerId: requiredFlag(parsed.flags, "runner"),
-        cwd: requiredFlag(parsed.flags, "cwd"),
-        tokenFile: agentTokenFile(parsed.flags),
-      };
-    }
-    default:
-      throw new Error(`invalid agent command: ${first}`);
-  }
-}
-
-function parseAgentArgs(args: readonly string[]): {
-  readonly flags: Map<string, string>;
-  readonly positionals: readonly string[];
-} {
-  const flags = new Map<string, string>();
-  const positionals: string[] = [];
-
-  for (let index = 0; index < args.length; index += 1) {
-    const arg = args[index];
-
-    if (arg === undefined) {
-      continue;
-    }
-
-    if (!arg.startsWith("--")) {
-      positionals.push(arg);
-      continue;
-    }
-
-    const key = arg.slice(2);
-
-    if (key === "since-last" || key === "fast") {
-      flags.set(key, "true");
-      continue;
-    }
-
-    const next = args[index + 1];
-
-    if (next === undefined || next.startsWith("--")) {
-      throw new Error(`missing value for --${key}`);
-    }
-
-    flags.set(key, next);
-    index += 1;
-  }
-
-  return { flags, positionals };
-}
-
-function parsePostKind(value: string | undefined): "progress" | "question" {
-  switch (value) {
-    case undefined:
-    case "progress":
-      return "progress";
-    case "question":
-      return "question";
-    case "done":
-      throw new Error("use linzumi done for done messages");
-    default:
-      throw new Error("--kind must be progress or question");
-  }
-}
-
-async function runSignup(
-  command: Extract<AgentCommand, { readonly kind: "signup" }>,
-  deps: AgentCliDeps,
-): Promise<void> {
-  const response = await postJson(
-    command.apiUrl,
-    "/agent/signup",
-    {
-      email: command.email,
-      agent_name: command.agentName,
-    },
-    undefined,
-    deps.fetchImpl,
-  );
-  const pendingId = requiredString(response, "pending_id");
-  const expiresInSeconds = numberValue(response.expires_in_seconds) ?? 600;
-  const codeFormatHint = stringValue(response.code_format_hint) ?? "XXXX-XXXX";
-
-  deps.stdout.write(`pending_id: ${pendingId}\n`);
-  deps.stdout.write(
-    `Code emailed to ${command.email} (format ${codeFormatHint}, expires in ${Math.ceil(
-      expiresInSeconds / 60,
-    )}m)\n`,
-  );
-}
-
-async function runClaim(
-  command: Extract<AgentCommand, { readonly kind: "claim" }>,
-  deps: AgentCliDeps,
-): Promise<void> {
-  const response = await postJson(
-    command.apiUrl,
-    "/agent/claim",
-    {
-      pending_id: command.pendingId,
-      code: command.code,
-    },
-    undefined,
-    deps.fetchImpl,
-  );
-  const tokenFile: AgentTokenFile = {
-    apiUrl: command.apiUrl,
-    agentToken: requiredString(response, "agent_token"),
-    agentId: requiredString(response, "agent_id"),
-    workspaceId: requiredString(response, "workspace_id"),
-    channelId: stringValue(response.channel_id),
-    ownerUsername: stringValue(response.owner_username),
-    channelUrl: requiredString(response, "channel_url"),
-    loginUrl: requiredString(response, "login_url"),
-    supportChannelId: requiredString(response, "support_channel_id"),
-    supportChannelUrl: requiredString(response, "support_channel_url"),
-    savedAt: new Date().toISOString(),
-    cursors: {},
-  };
-
-  writeTokenFile(command.tokenFile, tokenFile, deps.writeTextFile);
-  deps.stdout.write(`Logged in as agent ${tokenFile.agentId}\n`);
-  deps.stdout.write(`login_url: ${tokenFile.loginUrl}\n`);
-  deps.stdout.write(`channel_url: ${tokenFile.channelUrl}\n`);
-  deps.stdout.write(`support_channel_id: ${tokenFile.supportChannelId}\n`);
-  deps.stdout.write(`support_channel_url: ${tokenFile.supportChannelUrl}\n`);
-}
-
-async function runThreadNew(
-  command: Extract<AgentCommand, { readonly kind: "threadNew" }>,
-  deps: AgentCliDeps,
-): Promise<void> {
-  const tokenFile = readTokenFile(command.tokenFile, deps.readTextFile);
-  const response = await postJson(
-    command.apiUrl,
-    "/agent/threads",
-    {
-      title: command.title,
-      first_message: command.message,
-    },
-    tokenFile.agentToken,
-    deps.fetchImpl,
-  );
-
-  deps.stdout.write(`thread_id: ${requiredString(response, "thread_id")}\n`);
-  deps.stdout.write(`thread_url: ${requiredString(response, "thread_url")}\n`);
-}
-
-async function runChannelPost(
-  command: Extract<AgentCommand, { readonly kind: "channelPost" }>,
-  deps: AgentCliDeps,
-): Promise<void> {
-  const tokenFile = readTokenFile(command.tokenFile, deps.readTextFile);
-  const response = await postJson(
-    command.apiUrl,
-    `/agent/channels/${encodeURIComponent(command.channelId)}/messages`,
-    { body: command.body },
-    tokenFile.agentToken,
-    deps.fetchImpl,
-  );
-
-  deps.stdout.write(`message_id: ${requiredString(response, "message_id")}\n`);
-}
-
-async function runPost(
-  command: Extract<AgentCommand, { readonly kind: "post" }>,
-  deps: AgentCliDeps,
-): Promise<void> {
-  const response = await createThreadMessage(
-    command.apiUrl,
-    command.tokenFile,
-    command.threadId,
-    command.body,
-    command.messageKind,
-    deps,
-  );
-
-  deps.stdout.write(`message_id: ${requiredString(response, "message_id")}\n`);
-}
-
-async function runDone(
-  command: Extract<AgentCommand, { readonly kind: "done" }>,
-  deps: AgentCliDeps,
-): Promise<void> {
-  const response = await createThreadMessage(
-    command.apiUrl,
-    command.tokenFile,
-    command.threadId,
-    command.message,
-    "done",
-    deps,
-  );
-
-  deps.stdout.write(`message_id: ${requiredString(response, "message_id")}\n`);
-}
-
-async function runCodexStart(
-  command: Extract<AgentCommand, { readonly kind: "codexStart" }>,
-  deps: AgentCliDeps,
-): Promise<void> {
-  const tokenFile = readTokenFile(command.tokenFile, deps.readTextFile);
-  const body: JsonObject = {
-    runner_id: command.runnerId,
-    cwd: command.cwd,
-    work_description: command.workDescription,
-  };
-
-  putOptional(body, "model", command.model);
-  putOptional(body, "reasoning_effort", command.reasoningEffort);
-  putOptional(body, "approval_policy", command.approvalPolicy);
-  putOptional(body, "sandbox", command.sandbox);
-
-  if (command.fast) {
-    body.fast = true;
-  }
-
-  const response = await postJson(
-    command.apiUrl,
-    `/agent/threads/${encodeURIComponent(command.threadId)}/codex/start`,
-    body,
-    tokenFile.agentToken,
-    deps.fetchImpl,
-  );
-
-  deps.stdout.write(`codex_status: ${requiredString(response, "status")}\n`);
-  deps.stdout.write(`runner_id: ${requiredString(response, "runner_id")}\n`);
-}
-
-async function runEditorOpen(
-  command: Extract<AgentCommand, { readonly kind: "editorOpen" }>,
-  deps: AgentCliDeps,
-): Promise<void> {
-  const tokenFile = readTokenFile(command.tokenFile, deps.readTextFile);
-  const response = await postJson(
-    command.apiUrl,
-    `/agent/threads/${encodeURIComponent(command.threadId)}/editor/open`,
-    {
-      runner_id: command.runnerId,
-      cwd: command.cwd,
-    },
-    tokenFile.agentToken,
-    deps.fetchImpl,
-  );
-
-  deps.stdout.write(`editor_status: ${requiredString(response, "status")}\n`);
-  deps.stdout.write(`editor_url: ${requiredString(response, "editor_url")}\n`);
-}
-
-async function createThreadMessage(
-  apiUrl: string,
-  tokenFilePath: string,
-  threadId: string,
-  body: string,
-  kind: "progress" | "question" | "done",
-  deps: AgentCliDeps,
-): Promise<JsonObject> {
-  const tokenFile = readTokenFile(tokenFilePath, deps.readTextFile);
-
-  return await postJson(
-    apiUrl,
-    `/agent/threads/${encodeURIComponent(threadId)}/messages`,
-    { body, kind },
-    tokenFile.agentToken,
-    deps.fetchImpl,
-  );
-}
-
-async function runInbox(
-  command: Extract<AgentCommand, { readonly kind: "inbox" }>,
-  deps: AgentCliDeps,
-): Promise<void> {
-  const tokenFile = readTokenFile(command.tokenFile, deps.readTextFile);
-  const previousCursor = command.sinceLast
-    ? tokenFile.cursors[command.threadId]
-    : undefined;
-  const url = new URL(
-    `/agent/threads/${encodeURIComponent(command.threadId)}/messages`,
-    normalizedApiUrl(command.apiUrl),
-  );
-
-  if (previousCursor !== undefined) {
-    url.searchParams.set("since", previousCursor);
-  }
-
-  const response = await fetchJson(url, {
-    method: "GET",
-    headers: authorizationHeaders(tokenFile.agentToken),
-  }, deps.fetchImpl);
-  const messages = arrayValue(response.messages) ?? [];
-  const cursor = stringValue(response.cursor);
-
-  messages.forEach((entry) => {
-    const message = objectValue(entry);
-    const author = objectValue(message?.author);
-    const displayName =
-      stringValue(author?.display_name) ?? stringValue(author?.kind) ?? "unknown";
-    const body = stringValue(message?.body) ?? "";
-
-    deps.stdout.write(`[${displayName}] ${body}\n`);
-  });
-
-  if (cursor !== undefined) {
-    writeTokenFile(
-      command.tokenFile,
-      {
-        ...tokenFile,
-        cursors: {
-          ...tokenFile.cursors,
-          [command.threadId]: cursor,
-        },
-      },
-      deps.writeTextFile,
-    );
-  }
-}
-
-async function postJson(
-  apiUrl: string,
-  path: string,
-  body: JsonObject,
-  token: string | undefined,
-  fetchImpl: typeof fetch,
-): Promise<JsonObject> {
-  const url = new URL(path, normalizedApiUrl(apiUrl));
-  const headers =
-    token === undefined
-      ? { "content-type": "application/json" }
-      : { ...authorizationHeaders(token), "content-type": "application/json" };
-
-  return await fetchJson(
-    url,
-    {
-      method: "POST",
-      headers,
-      body: JSON.stringify(body),
-    },
-    fetchImpl,
-  );
-}
-
-async function fetchJson(
-  url: URL,
-  init: RequestInit,
-  fetchImpl: typeof fetch,
-): Promise<JsonObject> {
-  const response = await fetchImpl(url, init);
-  const text = await response.text();
-  const payload = parseJsonObject(text);
-
-  if (!response.ok) {
-    const error = objectValue(payload.error);
-    const code = stringValue(error?.code) ?? `http_${response.status}`;
-    const message = stringValue(error?.message) ?? response.statusText;
-    throw new Error(`${code}: ${message}`);
-  }
-
-  return payload;
-}
-
-function parseJsonObject(text: string): JsonObject {
-  try {
-    const parsed: unknown = JSON.parse(text);
-
-    if (isJsonObject(parsed)) {
-      return parsed;
-    }
-  } catch (_error) {
-    throw new Error("expected JSON object response");
-  }
-
-  throw new Error("expected JSON object response");
-}
-
-function requiredFlag(flags: Map<string, string>, key: string): string {
-  const value = flags.get(key);
-
-  if (value === undefined || value.trim() === "") {
-    throw new Error(`missing --${key}`);
-  }
-
-  return value.trim();
-}
-
-function optionalFlag(flags: Map<string, string>, key: string): string | undefined {
-  const value = flags.get(key);
-  return value === undefined || value.trim() === "" ? undefined : value.trim();
-}
-
-function putOptional(object: JsonObject, key: string, value: string | undefined): void {
-  if (value !== undefined) {
-    object[key] = value;
-  }
-}
-
-function requiredString(object: JsonObject, key: string): string {
-  const value = stringValue(object[key]);
-
-  if (value === undefined) {
-    throw new Error(`missing ${key} in response`);
-  }
-
-  return value;
-}
-
-function numberValue(value: JsonValue | undefined): number | undefined {
-  return typeof value === "number" && Number.isFinite(value)
-    ? value
-    : undefined;
-}
-
-function agentApiUrl(flags: Map<string, string>): string {
-  return flags.get("api-url") ?? defaultApiUrl;
-}
-
-function agentTokenFile(flags: Map<string, string>): string {
-  return flags.get("agent-token-file") ?? defaultAgentTokenFilePath();
-}
-
-export function defaultAgentTokenFilePath(): string {
-  return join(homedir(), ".linzumi", "agent-token.json");
-}
-
-function normalizedApiUrl(apiUrl: string): string {
-  return apiUrl.endsWith("/") ? apiUrl : `${apiUrl}/`;
-}
-
-function authorizationHeaders(token: string): HeadersInit {
-  return { authorization: `Bearer ${token}` };
-}
-
-function readOptionalTextFile(path: string): string | undefined {
-  return existsSync(path) ? readFileSync(path, "utf8") : undefined;
-}
-
-function writeTextFile(path: string, content: string): void {
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, content);
-}
-
-export function readStoredAgentTokenFile(
-  path: string,
-  readTextFile: AgentCliDeps["readTextFile"] = readOptionalTextFile,
-): AgentTokenFile {
-  const content = readTextFile(path);
-
-  if (content === undefined) {
-    throw new Error(`missing agent token file: ${path}`);
-  }
-
-  const parsed = parseJsonObject(content);
-  const cursorsValue = objectValue(parsed.cursors);
-  const cursors =
-    cursorsValue === undefined
-      ? {}
-      : Object.fromEntries(
-          Object.entries(cursorsValue).flatMap(([key, value]) => {
-            const cursor = stringValue(value);
-            return cursor === undefined ? [] : [[key, cursor]];
-          }),
-        );
-
-  return {
-    apiUrl: requiredString(parsed, "apiUrl"),
-    agentToken: requiredString(parsed, "agentToken"),
-    agentId: requiredString(parsed, "agentId"),
-    workspaceId: requiredString(parsed, "workspaceId"),
-    channelId: stringValue(parsed.channelId),
-    ownerUsername: stringValue(parsed.ownerUsername),
-    channelUrl: requiredString(parsed, "channelUrl"),
-    loginUrl: requiredString(parsed, "loginUrl"),
-    supportChannelId: requiredString(parsed, "supportChannelId"),
-    supportChannelUrl: stringValue(parsed.supportChannelUrl),
-    savedAt: requiredString(parsed, "savedAt"),
-    cursors,
-  };
-}
-
-function readTokenFile(
-  path: string,
-  readTextFile: AgentCliDeps["readTextFile"],
-): AgentTokenFile {
-  return readStoredAgentTokenFile(path, readTextFile);
-}
-
-function writeTokenFile(
-  path: string,
-  tokenFile: AgentTokenFile,
-  writeTextFile: AgentCliDeps["writeTextFile"],
-): void {
-  writeTextFile(path, `${JSON.stringify(tokenFile, null, 2)}\n`);
-}
-
-function agentHelpText(): string {
-  return `Linzumi agent bootstrap
-
-Usage:
-  linzumi signup --email <email> --agent-name <name> [--api-url <url>]
-  linzumi claim --pending <pending_id> --code <XXXX-XXXX> [--api-url <url>]
-  linzumi thread new <title> --message <message> [--api-url <url>]
-  linzumi channel post <channel_id> <message> [--api-url <url>]
-  linzumi post <thread_id> <message> [--kind progress|question]
-  linzumi inbox <thread_id> --since-last
-  linzumi done <thread_id> --message <message>
-  linzumi codex start <thread_id> --runner <runner_id> --cwd <path> --work-description <text>
-  linzumi editor open <thread_id> --runner <runner_id> --cwd <path>
-
-Options:
-  --api-url <url>             Agent API origin, default ${defaultApiUrl}
-  --agent-token-file <path>   Token cache path, default ~/.linzumi/agent-token.json
-
-Launch target:
-  zero-to-hello-world-pr+editor in under 3 minutes.
-`;
-}