chatccc 0.2.245 → 0.2.246

package/deepccc-agent/src/__tests__/config.test.ts

@@ -1,26 +1,34 @@
-import { afterEach, describe, expect, it } from "vitest";
-
-import { ChatSession } from "../index.js";
-import { config } from "../config.js";
-
-const originalDeepSeekApiKey = process.env.DEEPSEEK_API_KEY;
-const originalDeepCccApiKey = config.apiKey;
-
-afterEach(() => {
-  if (originalDeepSeekApiKey === undefined) {
-    delete process.env.DEEPSEEK_API_KEY;
-  } else {
-    process.env.DEEPSEEK_API_KEY = originalDeepSeekApiKey;
-  }
-  config.apiKey = originalDeepCccApiKey;
-});
-
-describe("builtin ChatSession config", () => {
-  it("uses the builtin ~/.deepccc config when no apiKey is passed", () => {
-    expect(() => new ChatSession()).not.toThrow();
-  });
-
-  it("allows constructor parameters to override config defaults", () => {
-    expect(() => new ChatSession({ apiKey: "sk-test" })).not.toThrow();
-  });
-});
+import { afterEach, describe, expect, it } from "vitest";
+
+import { ChatSession } from "../index.js";
+import { config, normalizeDeepCccProvider } from "../config.js";
+
+const originalDeepSeekApiKey = process.env.DEEPSEEK_API_KEY;
+const originalDeepCccApiKey = config.apiKey;
+
+afterEach(() => {
+  if (originalDeepSeekApiKey === undefined) {
+    delete process.env.DEEPSEEK_API_KEY;
+  } else {
+    process.env.DEEPSEEK_API_KEY = originalDeepSeekApiKey;
+  }
+  config.apiKey = originalDeepCccApiKey;
+});
+
+describe("builtin ChatSession config", () => {
+  it("defaults provider selection to openai and accepts anthropic case-insensitively", () => {
+    expect(normalizeDeepCccProvider(undefined)).toBe("openai");
+    expect(normalizeDeepCccProvider("")).toBe("openai");
+    expect(normalizeDeepCccProvider("OPENAI")).toBe("openai");
+    expect(normalizeDeepCccProvider("Anthropic")).toBe("anthropic");
+    expect(() => normalizeDeepCccProvider("antropic")).toThrow(/openai.*anthropic/i);
+  });
+
+  it("uses the builtin ~/.deepccc config when no apiKey is passed", () => {
+    expect(() => new ChatSession()).not.toThrow();
+  });
+
+  it("allows constructor parameters to override config defaults", () => {
+    expect(() => new ChatSession({ apiKey: "sk-test" })).not.toThrow();
+  });
+});

package/deepccc-agent/src/__tests__/permissions.test.ts

@@ -1,195 +1,199 @@
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-const testHome = vi.hoisted(() => ({ dir: "" }));
-
-const aiMocks = vi.hoisted(() => ({
-  streamText: vi.fn(),
-  generateText: vi.fn(),
-}));
-
-vi.mock("node:os", async () => {
-  const actual = await vi.importActual<typeof import("node:os")>("node:os");
-  const [{ mkdtempSync }, { join }] = await Promise.all([import("node:fs"), import("node:path")]);
-  testHome.dir = mkdtempSync(join(actual.tmpdir(), "chatccc-builtin-perm-"));
-  return { ...actual, homedir: () => testHome.dir };
-});
-
-vi.mock("@ai-sdk/openai-compatible", () => ({
-  createOpenAICompatible: vi.fn(() => (modelId: string) => ({ modelId })),
-}));
-
-vi.mock("ai", () => ({
-  streamText: aiMocks.streamText,
-  generateText: aiMocks.generateText,
-  isLoopFinished: vi.fn(() => ({ loopFinished: true })),
-  stepCountIs: vi.fn((count: number) => ({ count })),
-  jsonSchema: vi.fn((schema: unknown) => schema),
-  tool: vi.fn((definition: unknown) => definition),
-}));
-
-vi.mock("../raw-stream-log.js", () => ({
-  createRawStreamLog: vi.fn().mockResolvedValue(null),
-}));
-
-import {
-  PermissionGate,
-  getAllowRules,
-  isDangerousCommand,
-  matchRule,
-  reloadAllowRules,
-} from "../permissions.js";
-import { createBuiltinFileTools } from "../file-tools.js";
-import { ChatSession } from "../index.js";
-
-const streamTextMock = aiMocks.streamText;
-const generateTextMock = aiMocks.generateText;
-
-const ALLOW_FILE = () => join(testHome.dir, ".deepccc", "allow.json");
-
-async function collect(iterable: AsyncIterable<unknown>): Promise<unknown[]> {
-  const events: unknown[] = [];
-  for await (const event of iterable) events.push(event);
-  return events;
-}
-
-async function* textStream(...chunks: string[]): AsyncIterable<string> {
-  for (const chunk of chunks) yield chunk;
-}
-
-function lastRunCommandExecute(): (input: { command: string }, opts?: unknown) => Promise<unknown> {
-  const call = streamTextMock.mock.calls.at(-1)?.[0] as { tools?: Record<string, { execute?: unknown }> };
-  const execute = call?.tools?.run_command?.execute as ((input: { command: string }, opts?: unknown) => Promise<unknown>) | undefined;
-  if (!execute) throw new Error("streamText was not called with tools.run_command.execute");
-  return execute;
-}
-
-afterEach(() => {
-  try {
-    rmSync(ALLOW_FILE(), { force: true });
-  } catch {}
-  reloadAllowRules();
-  streamTextMock.mockReset();
-  generateTextMock.mockReset();
-});
-
-beforeEach(() => {
-  try {
-    rmSync(join(testHome.dir, ".deepccc"), { recursive: true, force: true });
-  } catch {}
-  mkdirSync(join(testHome.dir, ".deepccc"), { recursive: true });
-  reloadAllowRules();
-});
-
-describe("builtin permissions module", () => {
-  it("flags destructive commands and ignores normal ones", () => {
-    expect(isDangerousCommand("rm -rf node_modules")).toBe(true);
-    expect(isDangerousCommand("git push --force origin main")).toBe(true);
-    expect(isDangerousCommand("git status")).toBe(false);
-    expect(isDangerousCommand("npm test")).toBe(false);
-  });
-
-  it("matches allow/deny rules with wildcards and relative paths", () => {
-    expect(matchRule("run_command:git status*", "run_command:git status --short")).toBe(true);
-    expect(matchRule("edit_file:node_modules/**", "edit_file:node_modules/a/b.js")).toBe(true);
-    expect(matchRule("run_command:npm test", "run_command:npm test extra")).toBe(false);
-  });
-
-  it("returns empty rules when allow.json is missing", () => {
-    expect(getAllowRules()).toEqual({ allow: [], deny: [] });
-  });
-
-  it("loads rules from ~/.deepccc/allow.json", () => {
-    writeFileSync(ALLOW_FILE(), JSON.stringify({ deny: ["run_command:npm publish*"] }), "utf-8");
-    reloadAllowRules();
-    expect(getAllowRules().deny).toEqual(["run_command:npm publish*"]);
-  });
-});
-
-describe("builtin PermissionGate", () => {
-  it("bypass mode allows everything", async () => {
-    const gate = new PermissionGate("bypass");
-    expect(await gate.check({ tool: "run_command", action: "rm -rf /", reason: "high-risk", detail: "x" })).toBe("allow");
-  });
-
-  it("ask mode denies high-risk without resolver", async () => {
-    const gate = new PermissionGate("ask");
-    expect(await gate.check({ tool: "run_command", action: "rm -rf x", reason: "high-risk", detail: "x" })).toBe("deny");
-  });
-
-  it("ask mode allows non-high-risk operations without asking", async () => {
-    const resolver = vi.fn();
-    const gate = new PermissionGate("ask", resolver as never);
-    expect(await gate.check({ tool: "run_command", action: "npm test", reason: "rule", detail: "x" })).toBe("allow");
-    expect(await gate.check({ tool: "edit_file", action: "src/a.ts", reason: "rule", detail: "x" })).toBe("allow");
-    expect(resolver).not.toHaveBeenCalled();
-  });
-
-  it("follows resolver answer", async () => {
-    let answer: "allow" | "deny" = "allow";
-    const gate = new PermissionGate("ask", async () => answer);
-    expect(await gate.check({ tool: "run_command", action: "rm -rf x", reason: "high-risk", detail: "x" })).toBe("allow");
-    answer = "deny";
-    expect(await gate.check({ tool: "run_command", action: "rm -rf x", reason: "high-risk", detail: "x" })).toBe("deny");
-  });
-
-  it("deny rule wins over allow rule", async () => {
-    writeFileSync(
-      ALLOW_FILE(),
-      JSON.stringify({ allow: ["run_command:rm -rf /tmp*"], deny: ["run_command:rm -rf /tmp/forbidden*"] }),
-      "utf-8",
-    );
-    reloadAllowRules();
-    const gate = new PermissionGate("ask");
-    expect(await gate.check({ tool: "run_command", action: "rm -rf /tmp/forbidden/x", reason: "high-risk", detail: "x" })).toBe("deny");
-  });
-});
-
-describe("builtin file-tools permission integration", () => {
-  it("run_command high-risk is denied by default gate", async () => {
-    const tools = createBuiltinFileTools(testHome.dir, { permissionGate: new PermissionGate("ask") });
-    const tool = tools.run_command as unknown as {
-      execute: (input: { command: string }, opts?: unknown) => Promise<unknown>;
-    };
-    await expect(tool.execute({ command: "rm -rf node_modules" }, { abortSignal: undefined })).rejects.toThrow(/权限拒绝/);
-  });
-
-  it("no gate keeps original behavior", async () => {
-    const tools = createBuiltinFileTools(testHome.dir);
-    const tool = tools.run_command as unknown as {
-      execute: (input: { command: string }, opts?: unknown) => Promise<{ exitCode: number | null }>;
-    };
-    const result = await tool.execute({ command: "node -e \"console.log('ok')\"" }, { abortSignal: undefined });
-    expect(result.exitCode).toBe(0);
-  });
-});
-
-describe("builtin ChatSession permission integration", () => {
-  it("permissionMode bypass lets high-risk run_command execute", async () => {
-    const session = new ChatSession(
-      { apiKey: "sk-test" },
-      { sessionId: "perm-bypass", permissionMode: "bypass" },
-    );
-    streamTextMock.mockReturnValueOnce({ textStream: textStream("hi") });
-    await collect(session.chat("hi"));
-
-    const result = (await lastRunCommandExecute()({ command: "node -e \"console.log('ok')\"" }, { abortSignal: undefined })) as { exitCode: number };
-    expect(result.exitCode).toBe(0);
-  });
-
-  it("default ask mode without resolver denies high-risk run_command", async () => {
-    const session = new ChatSession(
-      { apiKey: "sk-test" },
-      { sessionId: "perm-ask" },
-    );
-    streamTextMock.mockReturnValueOnce({ textStream: textStream("hi") });
-    await collect(session.chat("hi"));
-
-    await expect(
-      lastRunCommandExecute()({ command: "rm -rf node_modules" }, { abortSignal: undefined }),
-    ).rejects.toThrow(/权限拒绝/);
-  });
-});
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const testHome = vi.hoisted(() => ({ dir: "" }));
+
+const aiMocks = vi.hoisted(() => ({
+  streamText: vi.fn(),
+  generateText: vi.fn(),
+}));
+
+vi.mock("node:os", async () => {
+  const actual = await vi.importActual<typeof import("node:os")>("node:os");
+  const [{ mkdtempSync }, { join }] = await Promise.all([import("node:fs"), import("node:path")]);
+  testHome.dir = mkdtempSync(join(actual.tmpdir(), "chatccc-builtin-perm-"));
+  return { ...actual, homedir: () => testHome.dir };
+});
+
+vi.mock("@ai-sdk/openai-compatible", () => ({
+  createOpenAICompatible: vi.fn(() => (modelId: string) => ({ modelId })),
+}));
+
+vi.mock("@ai-sdk/anthropic", () => ({
+  createAnthropic: vi.fn(() => (modelId: string) => ({ modelId })),
+}));
+
+vi.mock("ai", () => ({
+  streamText: aiMocks.streamText,
+  generateText: aiMocks.generateText,
+  isLoopFinished: vi.fn(() => ({ loopFinished: true })),
+  stepCountIs: vi.fn((count: number) => ({ count })),
+  jsonSchema: vi.fn((schema: unknown) => schema),
+  tool: vi.fn((definition: unknown) => definition),
+}));
+
+vi.mock("../raw-stream-log.js", () => ({
+  createRawStreamLog: vi.fn().mockResolvedValue(null),
+}));
+
+import {
+  PermissionGate,
+  getAllowRules,
+  isDangerousCommand,
+  matchRule,
+  reloadAllowRules,
+} from "../permissions.js";
+import { createBuiltinFileTools } from "../file-tools.js";
+import { ChatSession } from "../index.js";
+
+const streamTextMock = aiMocks.streamText;
+const generateTextMock = aiMocks.generateText;
+
+const ALLOW_FILE = () => join(testHome.dir, ".deepccc", "allow.json");
+
+async function collect(iterable: AsyncIterable<unknown>): Promise<unknown[]> {
+  const events: unknown[] = [];
+  for await (const event of iterable) events.push(event);
+  return events;
+}
+
+async function* textStream(...chunks: string[]): AsyncIterable<string> {
+  for (const chunk of chunks) yield chunk;
+}
+
+function lastRunCommandExecute(): (input: { command: string }, opts?: unknown) => Promise<unknown> {
+  const call = streamTextMock.mock.calls.at(-1)?.[0] as { tools?: Record<string, { execute?: unknown }> };
+  const execute = call?.tools?.run_command?.execute as ((input: { command: string }, opts?: unknown) => Promise<unknown>) | undefined;
+  if (!execute) throw new Error("streamText was not called with tools.run_command.execute");
+  return execute;
+}
+
+afterEach(() => {
+  try {
+    rmSync(ALLOW_FILE(), { force: true });
+  } catch {}
+  reloadAllowRules();
+  streamTextMock.mockReset();
+  generateTextMock.mockReset();
+});
+
+beforeEach(() => {
+  try {
+    rmSync(join(testHome.dir, ".deepccc"), { recursive: true, force: true });
+  } catch {}
+  mkdirSync(join(testHome.dir, ".deepccc"), { recursive: true });
+  reloadAllowRules();
+});
+
+describe("builtin permissions module", () => {
+  it("flags destructive commands and ignores normal ones", () => {
+    expect(isDangerousCommand("rm -rf node_modules")).toBe(true);
+    expect(isDangerousCommand("git push --force origin main")).toBe(true);
+    expect(isDangerousCommand("git status")).toBe(false);
+    expect(isDangerousCommand("npm test")).toBe(false);
+  });
+
+  it("matches allow/deny rules with wildcards and relative paths", () => {
+    expect(matchRule("run_command:git status*", "run_command:git status --short")).toBe(true);
+    expect(matchRule("edit_file:node_modules/**", "edit_file:node_modules/a/b.js")).toBe(true);
+    expect(matchRule("run_command:npm test", "run_command:npm test extra")).toBe(false);
+  });
+
+  it("returns empty rules when allow.json is missing", () => {
+    expect(getAllowRules()).toEqual({ allow: [], deny: [] });
+  });
+
+  it("loads rules from ~/.deepccc/allow.json", () => {
+    writeFileSync(ALLOW_FILE(), JSON.stringify({ deny: ["run_command:npm publish*"] }), "utf-8");
+    reloadAllowRules();
+    expect(getAllowRules().deny).toEqual(["run_command:npm publish*"]);
+  });
+});
+
+describe("builtin PermissionGate", () => {
+  it("bypass mode allows everything", async () => {
+    const gate = new PermissionGate("bypass");
+    expect(await gate.check({ tool: "run_command", action: "rm -rf /", reason: "high-risk", detail: "x" })).toBe("allow");
+  });
+
+  it("ask mode denies high-risk without resolver", async () => {
+    const gate = new PermissionGate("ask");
+    expect(await gate.check({ tool: "run_command", action: "rm -rf x", reason: "high-risk", detail: "x" })).toBe("deny");
+  });
+
+  it("ask mode allows non-high-risk operations without asking", async () => {
+    const resolver = vi.fn();
+    const gate = new PermissionGate("ask", resolver as never);
+    expect(await gate.check({ tool: "run_command", action: "npm test", reason: "rule", detail: "x" })).toBe("allow");
+    expect(await gate.check({ tool: "edit_file", action: "src/a.ts", reason: "rule", detail: "x" })).toBe("allow");
+    expect(resolver).not.toHaveBeenCalled();
+  });
+
+  it("follows resolver answer", async () => {
+    let answer: "allow" | "deny" = "allow";
+    const gate = new PermissionGate("ask", async () => answer);
+    expect(await gate.check({ tool: "run_command", action: "rm -rf x", reason: "high-risk", detail: "x" })).toBe("allow");
+    answer = "deny";
+    expect(await gate.check({ tool: "run_command", action: "rm -rf x", reason: "high-risk", detail: "x" })).toBe("deny");
+  });
+
+  it("deny rule wins over allow rule", async () => {
+    writeFileSync(
+      ALLOW_FILE(),
+      JSON.stringify({ allow: ["run_command:rm -rf /tmp*"], deny: ["run_command:rm -rf /tmp/forbidden*"] }),
+      "utf-8",
+    );
+    reloadAllowRules();
+    const gate = new PermissionGate("ask");
+    expect(await gate.check({ tool: "run_command", action: "rm -rf /tmp/forbidden/x", reason: "high-risk", detail: "x" })).toBe("deny");
+  });
+});
+
+describe("builtin file-tools permission integration", () => {
+  it("run_command high-risk is denied by default gate", async () => {
+    const tools = createBuiltinFileTools(testHome.dir, { permissionGate: new PermissionGate("ask") });
+    const tool = tools.run_command as unknown as {
+      execute: (input: { command: string }, opts?: unknown) => Promise<unknown>;
+    };
+    await expect(tool.execute({ command: "rm -rf node_modules" }, { abortSignal: undefined })).rejects.toThrow(/权限拒绝/);
+  });
+
+  it("no gate keeps original behavior", async () => {
+    const tools = createBuiltinFileTools(testHome.dir);
+    const tool = tools.run_command as unknown as {
+      execute: (input: { command: string }, opts?: unknown) => Promise<{ exitCode: number | null }>;
+    };
+    const result = await tool.execute({ command: "node -e \"console.log('ok')\"" }, { abortSignal: undefined });
+    expect(result.exitCode).toBe(0);
+  });
+});
+
+describe("builtin ChatSession permission integration", () => {
+  it("permissionMode bypass lets high-risk run_command execute", async () => {
+    const session = new ChatSession(
+      { apiKey: "sk-test" },
+      { sessionId: "perm-bypass", permissionMode: "bypass" },
+    );
+    streamTextMock.mockReturnValueOnce({ textStream: textStream("hi") });
+    await collect(session.chat("hi"));
+
+    const result = (await lastRunCommandExecute()({ command: "node -e \"console.log('ok')\"" }, { abortSignal: undefined })) as { exitCode: number };
+    expect(result.exitCode).toBe(0);
+  });
+
+  it("default ask mode without resolver denies high-risk run_command", async () => {
+    const session = new ChatSession(
+      { apiKey: "sk-test" },
+      { sessionId: "perm-ask" },
+    );
+    streamTextMock.mockReturnValueOnce({ textStream: textStream("hi") });
+    await collect(session.chat("hi"));
+
+    await expect(
+      lastRunCommandExecute()({ command: "rm -rf node_modules" }, { abortSignal: undefined }),
+    ).rejects.toThrow(/权限拒绝/);
+  });
+});

package/deepccc-agent/src/__tests__/privacy.test.ts

@@ -29,6 +29,10 @@ vi.mock("@ai-sdk/openai-compatible", () => ({
   createOpenAICompatible: vi.fn(() => (modelId: string) => ({ modelId })),
 }));
 
+vi.mock("@ai-sdk/anthropic", () => ({
+  createAnthropic: vi.fn(() => (modelId: string) => ({ modelId })),
+}));
+
 vi.mock("ai", () => ({
   streamText: aiMocks.streamText,
   generateText: aiMocks.generateText,
@@ -55,8 +59,8 @@ import { ChatSession } from "../index.js";
 const streamTextMock = aiMocks.streamText;
 const generateTextMock = aiMocks.generateText;
 
-const originalRawStreamLogs = structuredClone(config.rawStreamLogs);
-const originalStreaming = config.streaming;
+const originalRawStreamLogs = structuredClone(config.rawStreamLogs);
+const originalStreaming = config.streaming;
 const PRIVACY_FILE = join(privacyState.dir, "privacy.json");
 
 function writePrivacy(content: string): void {
@@ -79,18 +83,18 @@ beforeEach(() => {
   } catch {}
   reloadPrivacyRules();
   streamTextMock.mockReset();
-  generateTextMock.mockReset();
-  config.rawStreamLogs = structuredClone(originalRawStreamLogs);
-  config.streaming = true;
+  generateTextMock.mockReset();
+  config.rawStreamLogs = structuredClone(originalRawStreamLogs);
+  config.streaming = true;
 });
 
 afterEach(() => {
   try {
     rmSync(PRIVACY_FILE, { force: true });
   } catch {}
-  reloadPrivacyRules();
-  config.streaming = originalStreaming;
-});
+  reloadPrivacyRules();
+  config.streaming = originalStreaming;
+});
 
 afterAll(() => {
   try {

package/deepccc-agent/src/cli.ts

@@ -11,8 +11,8 @@
  * 非 TTY（管道/CI）或 --plain 回退为纯文本流式输出；--stream-json 机器接口不变。
  */
 
-import * as readline from "node:readline";
-import process from "node:process";
+import * as readline from "node:readline";
+import process from "node:process";
 import { appendFileSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, resolve as resolvePath } from "node:path";
@@ -59,6 +59,12 @@ function parsePositiveIntegerOption(name: string, value: string): number {
   return parsed;
 }
 
+function parseProviderOption(value: string): "openai" | "anthropic" {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "openai" || normalized === "anthropic") return normalized;
+  throw new Error(`--provider must be "openai" or "anthropic", received: ${value}`);
+}
+
 function parseArgs(argv = process.argv.slice(2)): ParsedArgs {
   const config: ChatSessionConfig = {};
   const options: ChatSessionOptions = {};
@@ -72,7 +78,10 @@ function parseArgs(argv = process.argv.slice(2)): ParsedArgs {
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
     const next = argv[i + 1];
-    if (arg === "--model" && next !== undefined) {
+    if (arg === "--provider" && next !== undefined) {
+      config.provider = parseProviderOption(next);
+      i++;
+    } else if (arg === "--model" && next !== undefined) {
       config.model = next;
       i++;
     } else if (arg === "--effort" && next !== undefined) {
@@ -132,9 +141,10 @@ function printHelp(appConfig: RuntimeDeps["appConfig"]): void {
     "Usage: deepccc [options]",
     "",
     "Options:",
+    `  --provider <name>    API protocol: openai or anthropic (current default ${appConfig.provider})`,
     `  --model <name>       Model name (current default ${appConfig.model})`,
     `  --effort <level>     Reasoning effort: none/minimal/low/medium/high/xhigh/max (overrides config.effort)`,
-    `  --base-url <url>     OpenAI-compatible API base URL (current default ${appConfig.baseURL})`,
+    `  --base-url <url>     Provider API base URL (current default ${appConfig.baseURL})`,
     "  --api-key <key>      API key",
     "  --cwd <path>         Working directory",
     "  --max-steps <n>      Optional tool-step limit. Omit for no step limit",
@@ -375,6 +385,7 @@ async function runRepl(args: ParsedArgs): Promise<void> {
   }
 
   console.log(`${C.dim}DeepCCC agent${C.reset}`);
+  console.log(`${C.dim}Provider: ${args.config.provider ?? appConfig.provider}${C.reset}`);
   console.log(`${C.dim}Model: ${args.config.model ?? appConfig.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}`);
@@ -637,11 +648,11 @@ async function main(): Promise<void> {
 
   const args = parseArgs();
 
-  if (args.streamJson) {
-    const code = await runStreamJson(args);
-    process.exitCode = code;
-    return;
-  }
+  if (args.streamJson) {
+    const code = await runStreamJson(args);
+    process.exitCode = code;
+    return;
+  }
 
   if (args.help) {
     const { appConfig } = await loadRuntime();