chatccc 0.2.191 → 0.2.193

package/src/__tests__/session.test.ts

@@ -942,19 +942,29 @@ describe("getSessionStatus", () => {
     expect(status!.model).toBe(UNKNOWN_MODEL_PLACEHOLDER);
   });
 
-  it("Cursor 会话：adapter.getSessionInfo 抛错时降级为占位符（不阻塞 /state）", async () => {
-    mockSessionInfo("chat-cursor", { sessionId: "sid-cur", tool: "cursor" });
-    _setAdapterForToolForTest(
-      "cursor",
-      mockAdapter(() => {
-        throw new Error("simulated adapter failure");
-      }),
-    );
-    const status = await getSessionStatus("chat-cursor");
-    expect(status!.model).toBe(UNKNOWN_MODEL_PLACEHOLDER);
-    expect(status!.effort).toBeNull();
-  });
-});
+  it("Cursor 会话：adapter.getSessionInfo 抛错时降级为占位符（不阻塞 /state）", async () => {
+    mockSessionInfo("chat-cursor", { sessionId: "sid-cur", tool: "cursor" });
+    _setAdapterForToolForTest(
+      "cursor",
+      mockAdapter(() => {
+        throw new Error("simulated adapter failure");
+      }),
+    );
+    const status = await getSessionStatus("chat-cursor");
+    expect(status!.model).toBe(UNKNOWN_MODEL_PLACEHOLDER);
+    expect(status!.effort).toBeNull();
+  });
+
+  it("CCC Agent 会话：model 来自 ccc 配置且 effort 恒为 null", async () => {
+    mockSessionInfo("chat-ccc", { sessionId: "session-ccc", tool: "ccc" });
+
+    const status = await getSessionStatus("chat-ccc");
+
+    expect(status!.model).toBeTruthy();
+    expect(status!.model).not.toBe(UNKNOWN_MODEL_PLACEHOLDER);
+    expect(status!.effort).toBeNull();
+  });
+});
 
 describe("getAllSessionsStatus", () => {
   let registryFile = "";

package/src/__tests__/sim-platform.test.ts

@@ -62,16 +62,21 @@ describe("SimulatedPlatform", () => {
     await expect(SimulatedPlatform.setChatAvatar("t", "ch1", "claude", "busy")).resolves.toBeUndefined();
   });
 
-  it("纯函数 extractSessionInfo 正常工作", () => {
-    const result = SimulatedPlatform.extractSessionInfo("Claude Code Session: a1b2c3d4-e5f6-7890-abcd-ef1234567890");
-    expect(result).toEqual({ sessionId: "a1b2c3d4-e5f6-7890-abcd-ef1234567890", tool: "claude" });
-  });
-
-  it("纯函数 formatDelayNotice 正常工作", () => {
+  it("纯函数 extractSessionInfo 正常工作", () => {
+    const result = SimulatedPlatform.extractSessionInfo("Claude Code Session: a1b2c3d4-e5f6-7890-abcd-ef1234567890");
+    expect(result).toEqual({ sessionId: "a1b2c3d4-e5f6-7890-abcd-ef1234567890", tool: "claude" });
+  });
+
+  it("pure extractSessionInfo recognizes ccc session ids", () => {
+    const result = SimulatedPlatform.extractSessionInfo("CCC Session: session-20260702-121530-a1b2c3");
+    expect(result).toEqual({ sessionId: "session-20260702-121530-a1b2c3", tool: "ccc" });
+  });
+
+  it("纯函数 formatDelayNotice 正常工作", () => {
     const notice = SimulatedPlatform.formatDelayNotice(Date.now() - 20 * 60 * 1000, "测试消息");
     expect(notice).toBeDefined();
     expect(notice).toContain("延迟送达");
     // 近期消息不触发
     expect(SimulatedPlatform.formatDelayNotice(Date.now(), "test")).toBeNull();
   });
-});
+});

package/src/adapters/ccc-adapter.ts

@@ -0,0 +1,99 @@
+import { ChatSession, type ChatSessionConfig, type ChatSessionOptions } from "../builtin/index.ts";
+import {
+  getBuiltinContextSession,
+  newBuiltinSessionId,
+  normalizeBuiltinSessionId,
+} from "../builtin/context.ts";
+import { config, CCC_SESSION_PREFIX } from "../config.ts";
+import type {
+  CreateSessionResult,
+  SessionInfo,
+  ToolAdapter,
+  ToolPromptOptions,
+  UnifiedStreamMessage,
+} from "./adapter-interface.ts";
+
+export interface CccAdapterOptions extends ChatSessionConfig {
+  contextDir?: string;
+  compactAtTokens?: number;
+  keepRecentMessages?: number;
+}
+
+function toChatSessionOptions(
+  sessionId: string,
+  cwd: string,
+  options: CccAdapterOptions,
+): ChatSessionOptions {
+  return {
+    cwd,
+    persist: true,
+    sessionId,
+    contextDir: options.contextDir,
+    compactAtTokens: options.compactAtTokens,
+    keepRecentMessages: options.keepRecentMessages,
+  };
+}
+
+export function createCccAdapter(options: CccAdapterOptions = {}): ToolAdapter {
+  const chatConfig: ChatSessionConfig = {
+    ...(options.apiKey !== undefined ? { apiKey: options.apiKey } : {}),
+    ...(options.baseURL !== undefined ? { baseURL: options.baseURL } : {}),
+    ...(options.model !== undefined ? { model: options.model } : {}),
+  };
+
+  return {
+    displayName: "CCC Agent",
+    sessionDescPrefix: CCC_SESSION_PREFIX,
+
+    async createSession(cwd: string): Promise<CreateSessionResult> {
+      const sessionId = newBuiltinSessionId();
+      const session = new ChatSession(
+        chatConfig,
+        toChatSessionOptions(sessionId, cwd, options),
+      );
+      session.reset();
+      return { sessionId };
+    },
+
+    async *prompt(
+      sessionId: string,
+      userText: string,
+      cwd: string,
+      signal?: AbortSignal,
+      _promptOptions?: ToolPromptOptions,
+    ): AsyncIterable<UnifiedStreamMessage> {
+      const normalizedSessionId = normalizeBuiltinSessionId(sessionId);
+      const session = new ChatSession(
+        chatConfig,
+        toChatSessionOptions(normalizedSessionId, cwd, options),
+      );
+
+      for await (const event of session.chat(userText, signal)) {
+        if (event.type === "text") {
+          yield {
+            type: "assistant",
+            blocks: [{ type: "text", text: event.text }],
+          };
+        } else if (event.type === "error") {
+          throw new Error(event.message);
+        }
+      }
+    },
+
+    async getSessionInfo(sessionId: string): Promise<SessionInfo | undefined> {
+      const normalizedSessionId = normalizeBuiltinSessionId(sessionId);
+      const info = getBuiltinContextSession(normalizedSessionId, options.contextDir);
+      if (!info) return undefined;
+      return {
+        sessionId: info.sessionId,
+        cwd: info.cwd,
+        lastModified: info.updatedAt,
+        model: options.model ?? config.ccc.model,
+      };
+    },
+
+    async closeSession(_sessionId: string): Promise<void> {
+      // ChatSession uses one request-scoped stream per prompt. AbortSignal handles cancellation.
+    },
+  };
+}

package/src/builtin/cli.ts

@@ -1,101 +1,305 @@
 /**
- * builtin/cli.ts — ChatCCC 内置 Agent 终端 REPL
+ * ChatCCC builtin Agent terminal REPL and JSONL streaming entrypoint.
  *
- * 用法:
+ * Usage:
  *   npx tsx src/builtin/cli.ts
- *   npx tsx src/builtin/cli.ts --model deepseek-chat
- *   npx tsx src/builtin/cli.ts --cwd /path/to/project
+ *   npx tsx src/builtin/cli.ts --model deepseek-v4-pro
+ *   npx tsx src/builtin/cli.ts --stream-json --prompt "hello"
  */
 
 import * as readline from "node:readline";
 import * as process from "node:process";
-import { config as appConfig } from "../config.ts";
-import { ChatSession, type ChatSessionConfig, type ChatSessionOptions } from "./index.js";
+import { resolve as resolvePath } from "node:path";
+import { fileURLToPath } from "node:url";
 
-// ---------------------------------------------------------------------------
-// 命令行参数解析
-// ---------------------------------------------------------------------------
+import { listBuiltinContextSessions } from "./context.js";
+import { resolveBuiltinSession, type BuiltinResumeRequest } from "./session-select.js";
+import { createCtrlCState } from "./sigint.js";
+import type { ChatEvent, ChatSessionConfig, ChatSessionOptions } from "./index.js";
 
-function parseArgs(): { config: ChatSessionConfig; options: ChatSessionOptions } {
-  const args = process.argv.slice(2);
+interface ParsedArgs {
+  config: ChatSessionConfig;
+  options: ChatSessionOptions;
+  listSessions: boolean;
+  resume: BuiltinResumeRequest;
+  help: boolean;
+  streamJson: boolean;
+  prompt: string | null;
+}
+
+interface RuntimeDeps {
+  ChatSession: typeof import("./index.js").ChatSession;
+  appConfig: typeof import("../config.ts").config;
+}
+
+interface JsonLine {
+  type: string;
+  [key: string]: unknown;
+}
+
+function parseArgs(argv = process.argv.slice(2)): ParsedArgs {
   const config: ChatSessionConfig = {};
   const options: ChatSessionOptions = {};
+  let listSessions = false;
+  let resume: BuiltinResumeRequest;
+  let help = false;
+  let streamJson = false;
+  let prompt: string | null = null;
 
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    const next = args[i + 1];
-    if (arg === "--model" && next) {
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    const next = argv[i + 1];
+    if (arg === "--model" && next !== undefined) {
       config.model = next;
       i++;
-    } else if (arg === "--base-url" && next) {
+    } else if (arg === "--base-url" && next !== undefined) {
       config.baseURL = next;
       i++;
-    } else if (arg === "--api-key" && next) {
+    } else if (arg === "--api-key" && next !== undefined) {
       config.apiKey = next;
       i++;
-    } else if (arg === "--cwd" && next) {
+    } else if (arg === "--cwd" && next !== undefined) {
       options.cwd = next;
       i++;
+    } else if (arg === "--resume") {
+      if (next !== undefined && !next.startsWith("--")) {
+        resume = next;
+        i++;
+      } else {
+        resume = true;
+      }
+    } else if (arg === "--list-sessions") {
+      listSessions = true;
+    } else if (arg === "--stream-json") {
+      streamJson = true;
+    } else if (arg === "--prompt" && next !== undefined) {
+      prompt = next;
+      i++;
     } else if (arg === "--help" || arg === "-h") {
-      printHelp();
-      process.exit(0);
+      help = true;
     }
   }
 
-  return { config, options };
+  return { config, options, listSessions, resume, help, streamJson, prompt };
 }
 
-function printHelp(): void {
+async function loadRuntime(): Promise<RuntimeDeps> {
+  const [{ ChatSession }, { config: appConfig }] = await Promise.all([
+    import("./index.js"),
+    import("../config.ts"),
+  ]);
+  return { ChatSession, appConfig };
+}
+
+function printHelp(appConfig: RuntimeDeps["appConfig"]): void {
   console.log([
-    "ChatCCC 内置 Agent 终端 REPL",
+    "ChatCCC builtin Agent terminal REPL",
     "",
-    "用法: npx tsx src/builtin/cli.ts [选项]",
+    "Usage: npx tsx src/builtin/cli.ts [options]",
     "",
-    "选项:",
-    `  --model <name>   模型名称（覆盖 config.ccc.model，当前默认 ${appConfig.ccc.model}）`,
-    `  --base-url <url> API 地址（覆盖 config.ccc.DEEPSEEK_BASE_URL，当前默认 ${appConfig.ccc.DEEPSEEK_BASE_URL}）`,
-    "  --api-key <key>  API Key（覆盖 config.ccc.DEEPSEEK_API_KEY）",
-    "  --cwd <path>     工作目录",
-    "  --help, -h       显示帮助",
+    "Options:",
+    `  --model <name>       Model name (overrides config.ccc.model, current default ${appConfig.ccc.model})`,
+    `  --base-url <url>     API base URL (current default ${appConfig.ccc.DEEPSEEK_BASE_URL})`,
+    "  --api-key <key>      API key (overrides config.ccc.DEEPSEEK_API_KEY)",
+    "  --cwd <path>         Working directory",
+    "  --resume [id]        Resume latest cwd session, or the explicit session id",
+    "  --list-sessions      List saved ccc sessions and exit",
+    "  --stream-json        One-shot mode: write JSONL events to stdout",
+    "  --prompt <text>      Prompt text for --stream-json",
+    "  --help, -h           Show help",
     "",
-    "默认配置来源:",
-    "  ~/.chatccc/config.json 的 ccc.DEEPSEEK_API_KEY / ccc.DEEPSEEK_BASE_URL / ccc.model",
+    "Default config source:",
+    "  ~/.chatccc/config.json ccc.DEEPSEEK_API_KEY / ccc.DEEPSEEK_BASE_URL / ccc.model",
     "",
   ].join("\n"));
 }
 
-// ---------------------------------------------------------------------------
-// ANSI 颜色
-// ---------------------------------------------------------------------------
+function formatTime(ms: number): string {
+  return new Date(ms).toLocaleString();
+}
+
+function printSessions(streamJson = false): void {
+  const sessions = listBuiltinContextSessions();
+  if (streamJson) {
+    writeJsonLine({
+      type: "sessions",
+      sessions: sessions.map((session) => ({
+        session_id: session.sessionId,
+        turns: session.totalMessages,
+        compacted_messages: session.compactedMessages,
+        has_summary: session.hasSummary,
+        updated_at: session.updatedAt,
+        cwd: session.cwd,
+      })),
+    });
+    return;
+  }
+
+  if (sessions.length === 0) {
+    console.log("No saved ccc sessions");
+    return;
+  }
+
+  for (const session of sessions) {
+    const summary = session.hasSummary ? " summary=yes" : "";
+    const cwd = session.cwd ? ` cwd=${session.cwd}` : "";
+    console.log(`${session.sessionId}  turns=${session.totalMessages} compacted=${session.compactedMessages}${summary} updated=${formatTime(session.updatedAt)}${cwd}`);
+  }
+}
+
+function stringifyConsoleArg(value: unknown): string {
+  if (typeof value === "string") return value;
+  if (value instanceof Error) return value.stack ?? value.message;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+
+function redirectConsoleLogsToStderr(): void {
+  const write = (...args: unknown[]) => {
+    process.stderr.write(`${args.map(stringifyConsoleArg).join(" ")}\n`);
+  };
+  console.log = write;
+  console.info = write;
+  console.warn = write;
+}
+
+function writeJsonLine(event: JsonLine): void {
+  process.stdout.write(`${JSON.stringify(event)}\n`);
+}
+
+function streamJsonEvent(event: ChatEvent): void {
+  if (event.type === "text") {
+    writeJsonLine({
+      type: "text_delta",
+      text: event.text,
+      accumulated: event.accumulated,
+    });
+  } else if (event.type === "compact") {
+    writeJsonLine({
+      type: "compact",
+      compacted_messages: event.compactedMessages,
+    });
+  } else if (event.type === "done") {
+    writeJsonLine({
+      type: "done",
+      text: event.text,
+    });
+  } else if (event.type === "error") {
+    writeJsonLine({
+      type: "error",
+      message: event.message,
+    });
+  }
+}
+
+async function readPromptFromStdin(): Promise<string> {
+  const chunks: Buffer[] = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+
+async function runStreamJson(args: ParsedArgs): Promise<number> {
+  redirectConsoleLogsToStderr();
+
+  if (args.listSessions) {
+    printSessions(true);
+    return 0;
+  }
+
+  const prompt = args.prompt ?? (!process.stdin.isTTY ? await readPromptFromStdin() : "");
+  if (!prompt.trim()) {
+    writeJsonLine({ type: "error", message: "--stream-json requires --prompt <text> or stdin input" });
+    return 1;
+  }
+
+  let runtime: RuntimeDeps;
+  try {
+    runtime = await loadRuntime();
+  } catch (err) {
+    writeJsonLine({ type: "error", message: (err as Error).message });
+    return 1;
+  }
+
+  const cwd = resolvePath(args.options.cwd ?? process.cwd());
+  let resolvedSession;
+  try {
+    resolvedSession = resolveBuiltinSession({ cwd, resume: args.resume });
+  } catch (err) {
+    writeJsonLine({ type: "error", message: (err as Error).message });
+    return 1;
+  }
+
+  let session: InstanceType<RuntimeDeps["ChatSession"]>;
+  try {
+    session = new runtime.ChatSession(args.config, {
+      ...args.options,
+      cwd,
+      persist: true,
+      sessionId: resolvedSession.sessionId,
+    });
+  } catch (err) {
+    writeJsonLine({ type: "error", message: (err as Error).message });
+    return 1;
+  }
+
+  writeJsonLine({
+    type: "start",
+    session_id: resolvedSession.sessionId,
+    mode: resolvedSession.mode,
+    cwd,
+    model: args.config.model ?? runtime.appConfig.ccc.model,
+  });
+
+  try {
+    for await (const event of session.chat(prompt)) {
+      streamJsonEvent(event);
+    }
+    return 0;
+  } catch (err) {
+    writeJsonLine({ type: "error", message: (err as Error).message });
+    return 1;
+  }
+}
 
 const C = {
   reset: "\x1b[0m",
   dim: "\x1b[2m",
   green: "\x1b[32m",
-  cyan: "\x1b[36m",
   yellow: "\x1b[33m",
 };
 
-const DOUBLE_CTRL_C_EXIT_WINDOW_MS = 2000;
-
-// ---------------------------------------------------------------------------
-// 主程序
-// ---------------------------------------------------------------------------
+async function runRepl(args: ParsedArgs): Promise<void> {
+  const { ChatSession, appConfig } = await loadRuntime();
 
-async function main(): Promise<void> {
-  const { config, options } = parseArgs();
-
-  console.log(`${C.dim}ChatCCC 内置 Agent 原型${C.reset}`);
-  console.log(`${C.dim}模型: ${config.model ?? appConfig.ccc.model}${C.reset}`);
-  if (options.cwd) {
-    console.log(`${C.dim}目录: ${options.cwd}${C.reset}`);
+  const cwd = resolvePath(args.options.cwd ?? process.cwd());
+  let resolvedSession;
+  try {
+    resolvedSession = resolveBuiltinSession({ cwd, resume: args.resume });
+  } catch (err) {
+    console.error(`${C.yellow}${(err as Error).message}${C.reset}`);
+    process.exit(1);
   }
-  console.log(`${C.dim}输入消息开始对话，Ctrl+C 中断当前回复，exit 退出${C.reset}`);
+
+  console.log(`${C.dim}ChatCCC builtin Agent${C.reset}`);
+  console.log(`${C.dim}Model: ${args.config.model ?? appConfig.ccc.model}${C.reset}`);
+  console.log(`${C.dim}Directory: ${cwd}${C.reset}`);
+  console.log(`${C.dim}Session: ${resolvedSession.sessionId} (${resolvedSession.mode === "new" ? "new" : "resumed"})${C.reset}`);
+  console.log(`${C.dim}Type a message to chat. Double Ctrl+C interrupts generation or exits. Type exit to quit.${C.reset}`);
   console.log("");
 
-  let session: ChatSession;
+  let session: InstanceType<typeof ChatSession>;
   try {
-    session = new ChatSession(config, options);
+    session = new ChatSession(args.config, {
+      ...args.options,
+      cwd,
+      persist: true,
+      sessionId: resolvedSession.sessionId,
+    });
   } catch (err) {
     console.error(`${C.yellow}${(err as Error).message}${C.reset}`);
     process.exit(1);
@@ -107,41 +311,38 @@ async function main(): Promise<void> {
     prompt: `${C.green}>${C.reset} `,
   });
 
-  // 用于中断当前 LLM 调用的 AbortController
   let currentAbort: AbortController | null = null;
-  let lastCtrlCAt = 0;
+  const ctrlCState = createCtrlCState();
 
   rl.prompt();
 
   rl.on("line", async (line: string) => {
-    lastCtrlCAt = 0;
+    ctrlCState.reset();
     const input = line.trim();
     if (!input) {
       rl.prompt();
       return;
     }
 
-    // 特殊命令
     if (input === "exit") {
-      console.log(`${C.dim}再见${C.reset}`);
+      console.log(`${C.dim}bye${C.reset}`);
       rl.close();
       return;
     }
 
     if (input === "/clear") {
       session.reset();
-      console.log(`${C.dim}会话已重置${C.reset}`);
+      console.log(`${C.dim}session cleared${C.reset}`);
       rl.prompt();
       return;
     }
 
     if (input === "/history") {
-      console.log(`${C.dim}共 ${session.turnCount} 轮对话${C.reset}`);
+      console.log(`${C.dim}${session.turnCount} conversation turns${C.reset}`);
       rl.prompt();
       return;
     }
 
-    // 发送消息
     currentAbort = new AbortController();
     const signal = currentAbort.signal;
 
@@ -149,45 +350,51 @@ async function main(): Promise<void> {
       let lastAccumulated = "";
       for await (const event of session.chat(input, signal)) {
         if (event.type === "text") {
-          // 增量输出（仅在首次和行首时不换行）
           const newText = event.accumulated.slice(lastAccumulated.length);
           process.stdout.write(newText);
           lastAccumulated = event.accumulated;
         } else if (event.type === "done") {
           if (lastAccumulated) console.log("");
-          console.log(`${C.dim}[完成]${C.reset}`);
+          console.log(`${C.dim}[done]${C.reset}`);
+        } else if (event.type === "compact") {
+          console.log(`${C.dim}[context compacted: ${event.compactedMessages} old messages]${C.reset}`);
         } else if (event.type === "error") {
-          console.log(`\n${C.yellow}[错误] ${event.message}${C.reset}`);
+          console.log(`\n${C.yellow}[error] ${event.message}${C.reset}`);
         }
       }
     } catch (err) {
-      console.log(`\n${C.yellow}[错误] ${(err as Error).message}${C.reset}`);
+      console.log(`\n${C.yellow}[error] ${(err as Error).message}${C.reset}`);
     } finally {
       currentAbort = null;
+      ctrlCState.reset();
     }
 
     rl.prompt();
   });
 
-  // Ctrl+C → 生成中中断；空闲或连续按下时退出
   rl.on("SIGINT", () => {
-    const now = Date.now();
-    const shouldExit = now - lastCtrlCAt <= DOUBLE_CTRL_C_EXIT_WINDOW_MS;
+    const action = ctrlCState.press(currentAbort !== null);
 
-    if (shouldExit) {
-      console.log(`\n${C.dim}再见${C.reset}`);
+    if (action === "exit") {
+      console.log(`\n${C.dim}bye${C.reset}`);
       rl.close();
       return;
     }
 
-    lastCtrlCAt = now;
-
-    if (currentAbort) {
-      console.log(`\n${C.yellow}[中断中...]${C.reset} ${C.dim}再次 Ctrl+C 退出${C.reset}`);
-      currentAbort.abort();
+    if (action === "interrupt") {
+      console.log(`\n${C.yellow}[interrupting...]${C.reset}`);
+      currentAbort?.abort();
       currentAbort = null;
-    } else {
-      console.log(`\n${C.dim}再次 Ctrl+C 退出，或输入 exit 退出${C.reset}`);
+      return;
+    }
+
+    if (action === "arm-interrupt") {
+      console.log(`\n${C.dim}Press Ctrl+C again to interrupt current response${C.reset}`);
+      return;
+    }
+
+    if (action === "arm-exit") {
+      console.log(`\n${C.dim}Press Ctrl+C again to exit, or type exit${C.reset}`);
       rl.prompt();
     }
   });
@@ -198,7 +405,37 @@ async function main(): Promise<void> {
   });
 }
 
-main().catch((err) => {
-  console.error(`${C.yellow}启动失败: ${(err as Error).message}${C.reset}`);
-  process.exit(1);
-});
+async function main(): Promise<void> {
+  const args = parseArgs();
+
+  if (args.streamJson) {
+    const code = await runStreamJson(args);
+    process.exit(code);
+  }
+
+  if (args.help) {
+    const { appConfig } = await loadRuntime();
+    printHelp(appConfig);
+    return;
+  }
+
+  if (args.listSessions) {
+    printSessions();
+    return;
+  }
+
+  await runRepl(args);
+}
+
+function isDirectCliInvocation(): boolean {
+  const current = resolvePath(fileURLToPath(import.meta.url));
+  const invoked = process.argv[1] ? resolvePath(process.argv[1]) : "";
+  return current === invoked;
+}
+
+if (isDirectCliInvocation()) {
+  main().catch((err) => {
+    console.error(`${C.yellow}startup failed: ${(err as Error).message}${C.reset}`);
+    process.exit(1);
+  });
+}