@wlv-zedd/dsh-chatgpt-web 1.0.0

package/src/cli.ts

@@ -0,0 +1,568 @@
+#!/usr/bin/env bun
+import { createInterface } from "node:readline/promises";
+import { Writable } from "node:stream";
+import { timingSafeEqual } from "node:crypto";
+import { existsSync, rmSync } from "node:fs";
+import { isAbsolute } from "node:path";
+import { stdin, stdout } from "node:process";
+import { captureSystemBrowserLoginToFile, checkBrowserEngine, loginToChatGpt } from "./browser-login";
+import { CHATGPT_CONNECTOR_NAME, defaultConfig, getConfigDir, getConfigPath, loadConfig, loadConfigForSetup } from "./config";
+import {
+  inspectLauncherBrowserHost,
+  inspectLauncherBrowserHostLiveness,
+  readLauncherBrowserHostDescriptor,
+} from "./launcher-browser-host";
+import {
+  activateCodexIntegration,
+  deactivateCodexIntegration,
+  inspectCodexIntegration,
+  readCodexSubagentProtocol,
+  setCodexSubagentProtocol,
+  uninstallCodexIntegration,
+} from "./codex-integration";
+import { formatDoctorReport, runDoctor } from "./doctor";
+import { runChatGptMcpMain } from "./adapters/chatgpt-web/mcp-main";
+import { runCommand } from "./process";
+import { startServer } from "./server";
+import { assertServiceIdle, cancelActiveTurns, getServiceStatus, installService, interruptActiveTurn, restartService, startService, stopService, uninstallService } from "./service";
+import { existingFullSetupCredentials, preflightSetup, setup, type SetupOptions } from "./setup";
+import { installRuntimeKeyBytes, managedRuntimeKeyPath, stopTunnel, tunnelStatus, waitForTunnelReady } from "./tunnel";
+import { getTunnelServiceStatus, restartTunnelService, startTunnelService, stopTunnelService, uninstallTunnelService } from "./tunnel-service";
+import { VERSION } from "./version";
+import { runDevCommand } from "./dev-chat/cli";
+
+const HELP = `dsh-chatgpt-web ${VERSION}
+
+DeepSeek Harness bridge & Cordis plugin for free ChatGPT Web (GPT 5.6 Luna) pure chat and zero API fees.
+
+Usage:
+  dsh-chatgpt-web setup [options]
+  dsh-chatgpt-web login
+  dsh-chatgpt-web doctor [--json]
+  dsh-chatgpt-web serve
+  dsh-chatgpt-web browser check
+  dsh-chatgpt-web uninstall --yes
+
+Options:
+  --host HOST                  Host to bind (default: 127.0.0.1)
+  --port PORT                  Port to listen on (default: 17841)
+  --chrome PATH                Path to Chrome/Chromium executable
+  --home PATH                  Override config storage path (default: ~/.dsh/storages/chatgpt-web)
+  --login                      Trigger interactive browser login
+  -h, --help                   Show this help message
+  -v, --version                Show version
+`;
+
+function takeOption(args: string[], name: string): string | undefined {
+  const index = args.indexOf(name);
+  if (index < 0) return undefined;
+  const value = args[index + 1];
+  if (!value || value.startsWith("--")) throw new Error(`${name} requires a value`);
+  args.splice(index, 2);
+  return value;
+}
+
+function takeFlag(args: string[], name: string): boolean {
+  const index = args.indexOf(name);
+  if (index < 0) return false;
+  args.splice(index, 1);
+  return true;
+}
+
+async function confirm(question: string): Promise<boolean> {
+  if (!stdin.isTTY || !stdout.isTTY) return false;
+  const reader = createInterface({ input: stdin, output: stdout });
+  try {
+    const answer = (await reader.question(`${question} [y/N] `)).trim().toLowerCase();
+    return answer === "y" || answer === "yes";
+  } finally {
+    reader.close();
+  }
+}
+
+async function prompt(question: string): Promise<string> {
+  if (!stdin.isTTY || !stdout.isTTY) return "";
+  const reader = createInterface({ input: stdin, output: stdout });
+  try { return (await reader.question(question)).trim(); }
+  finally { reader.close(); }
+}
+
+async function secretPrompt(question: string): Promise<string> {
+  if (!stdin.isTTY || !stdout.isTTY) return "";
+  stdout.write(question);
+  const muted = new Writable({ write(_chunk, _encoding, callback) { callback(); } });
+  const reader = createInterface({ input: stdin, output: muted, terminal: true });
+  try { return (await reader.question("")).trim(); }
+  finally {
+    reader.close();
+    stdout.write("\n");
+  }
+}
+
+function assertNoArgs(args: string[]): void {
+  if (args.length > 0) throw new Error(`Unknown arguments: ${args.join(" ")}`);
+}
+
+function authorizeLauncherControl(operation: string): void {
+  const descriptorPath = process.env.DSH_CHATGPT_FREE_BROWSER_HOST_DESCRIPTOR?.trim();
+  const supplied = process.env.DSH_CHATGPT_FREE_LAUNCHER_CONTROL_TOKEN?.trim();
+  delete process.env.DSH_CHATGPT_FREE_LAUNCHER_CONTROL_TOKEN;
+  if (!descriptorPath || !supplied) {
+    throw new Error(`Launcher-controlled ${operation} requires a live launcher authorization`);
+  }
+  const descriptor = readLauncherBrowserHostDescriptor(descriptorPath);
+  const expectedBytes = Buffer.from(descriptor.control.token);
+  const suppliedBytes = Buffer.from(supplied);
+  if (expectedBytes.length !== suppliedBytes.length || !timingSafeEqual(expectedBytes, suppliedBytes)) {
+    throw new Error(`Launcher-controlled ${operation} authorization is invalid`);
+  }
+}
+
+function launcherLoginContinuation(): { promise: Promise<void>; close: () => void } {
+  const maxBytes = 1_024;
+  let buffered = "";
+  let bytes = 0;
+  let settled = false;
+  let resolveContinuation!: () => void;
+  let rejectContinuation!: (error: Error) => void;
+  const promise = new Promise<void>((resolve, reject) => {
+    resolveContinuation = resolve;
+    rejectContinuation = reject;
+  });
+  const cleanup = () => {
+    stdin.off("data", onData);
+    stdin.off("end", onEnd);
+    stdin.pause();
+  };
+  const fail = (message: string) => {
+    if (settled) return;
+    settled = true;
+    cleanup();
+    rejectContinuation(new Error(message));
+  };
+  const onData = (chunk: Buffer | string) => {
+    if (settled) return;
+    const data = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    bytes += data.length;
+    if (bytes > maxBytes) {
+      fail("Launcher passkey control message is too large");
+      return;
+    }
+    buffered += data.toString("utf8");
+    const newline = buffered.indexOf("\n");
+    if (newline < 0) return;
+    const line = buffered.slice(0, newline);
+    if (buffered.slice(newline + 1).trim()) {
+      fail("Launcher passkey control sent unexpected trailing data");
+      return;
+    }
+    let message: unknown;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      fail("Launcher passkey control sent invalid JSON");
+      return;
+    }
+    if (!message || typeof message !== "object"
+      || (message as { version?: unknown }).version !== 1
+      || (message as { type?: unknown }).type !== "passkey-login-continue") {
+      fail("Launcher passkey control sent an invalid continuation message");
+      return;
+    }
+    settled = true;
+    cleanup();
+    resolveContinuation();
+  };
+  const onEnd = () => fail("Launcher closed the passkey control channel before Continue");
+  stdin.on("data", onData);
+  stdin.once("end", onEnd);
+  stdin.resume();
+  return {
+    promise,
+    close: () => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+    },
+  };
+}
+
+async function loginCommand(args: string[]): Promise<void> {
+  const launcherControl = takeFlag(args, "--launcher-control");
+  if (!launcherControl) {
+    assertNoArgs(args);
+    const config = loadConfig();
+    if (config.browserHost === "launcher") {
+      throw new Error("ChatGPT login is owned by the launcher; open Codex Web GPT and use its Sign in step");
+    }
+    const result = await loginToChatGpt(config);
+    stdout.write(`ChatGPT login stored at ${result.storageStatePath}\n`);
+    return;
+  }
+
+  const chromeExecutablePath = takeOption(args, "--chrome");
+  const storageStatePath = takeOption(args, "--storage-state");
+  assertNoArgs(args);
+  authorizeLauncherControl("passkey login");
+  if (process.platform !== "darwin") throw new Error("Passkey sign-in is currently supported only on macOS");
+  if (!chromeExecutablePath || !isAbsolute(chromeExecutablePath)) {
+    throw new Error("Launcher passkey sign-in requires --chrome with an absolute path");
+  }
+  if (!storageStatePath || !isAbsolute(storageStatePath)) {
+    throw new Error("Launcher passkey sign-in requires --storage-state with an absolute path");
+  }
+  const continuation = launcherLoginContinuation();
+  try {
+    await captureSystemBrowserLoginToFile({
+      ...defaultConfig(),
+      chromeExecutablePath,
+      storageStatePath,
+    }, { continuation: continuation.promise });
+  } finally {
+    continuation.close();
+  }
+  stdout.write("Passkey session captured for Launcher verification.\n");
+}
+
+async function setupCommand(args: string[]): Promise<void> {
+  const preflightOnly = takeFlag(args, "--preflight-only");
+  const browserOnly = takeFlag(args, "--browser-only");
+  const full = takeFlag(args, "--full");
+  if (browserOnly && full) throw new Error("Choose at most one setup mode: --browser-only or --full");
+  const portRaw = takeOption(args, "--port");
+  let acknowledged = takeFlag(args, "--acknowledge-unofficial");
+  const options: SetupOptions = {
+    mode: full ? "full" : "browser-only",
+    ...(portRaw ? { port: Number(portRaw) } : {}),
+  };
+  const automaticBrowserInteraction = takeFlag(args, "--automatic-browser-interaction");
+  const manualBrowserInteraction = takeFlag(args, "--zero-risk-browser-interaction");
+  if (automaticBrowserInteraction && manualBrowserInteraction) {
+    throw new Error(
+      "Choose at most one browser interaction mode: --automatic-browser-interaction or --zero-risk-browser-interaction",
+    );
+  }
+  if (automaticBrowserInteraction || manualBrowserInteraction) {
+    options.browserInteractionMode = manualBrowserInteraction ? "manual" : "automatic";
+  }
+  const subagentProtocol = takeOption(args, "--subagent-protocol");
+  if (subagentProtocol !== undefined) {
+    if (subagentProtocol !== "compatibility-v1" && subagentProtocol !== "native") {
+      throw new Error("--subagent-protocol must be compatibility-v1 or native");
+    }
+    options.subagentProtocol = subagentProtocol;
+  }
+  const appName = takeOption(args, "--app-name");
+  const tunnelId = takeOption(args, "--tunnel-id");
+  const runtimeKeyFile = takeOption(args, "--runtime-key-file");
+  const chrome = takeOption(args, "--chrome");
+  const browserHostDescriptorPath = takeOption(args, "--browser-host-descriptor");
+  if (chrome) options.chromeExecutablePath = chrome;
+  if (browserHostDescriptorPath) options.browserHostDescriptorPath = browserHostDescriptorPath;
+  options.refreshAccountCapabilities = takeFlag(args, "--refresh-account-capabilities");
+  if (appName) options.appName = appName;
+  if (tunnelId) options.tunnelId = tunnelId;
+  if (runtimeKeyFile) options.runtimeKeyFile = runtimeKeyFile;
+  options.forceLogin = takeFlag(args, "--login");
+  options.autoApproveToolCalls = takeFlag(args, "--auto-approve-tool-calls");
+  const biggerContext = takeFlag(args, "--bigger-context");
+  const standardContext = takeFlag(args, "--standard-context");
+  if (biggerContext && standardContext) {
+    throw new Error("Choose at most one context mode: --bigger-context or --standard-context");
+  }
+  if (biggerContext || standardContext) options.experimentalBiggerContext = biggerContext;
+  const zeroRiskPro = takeFlag(args, "--zero-risk-pro");
+  const zeroRiskDefault = takeFlag(args, "--zero-risk-default");
+  if (zeroRiskPro && zeroRiskDefault) {
+    throw new Error("Choose at most one Zero Risk model profile: --zero-risk-pro or --zero-risk-default");
+  }
+  if (zeroRiskPro || zeroRiskDefault) options.zeroRiskProEnabled = zeroRiskPro;
+  options.replaceCodexRoute = takeFlag(args, "--replace-codex-route");
+  options.restartService = takeFlag(args, "--restart-service");
+  assertNoArgs(args);
+
+  if (!acknowledged) {
+    stdout.write(
+      "This is independent, unofficial software. It automates your ChatGPT web session, can break when the UI changes, "
+      + "and must not be used to evade usage limits or access controls.\n",
+    );
+    acknowledged = await confirm("Continue and store this acknowledgement?");
+  }
+  if (!acknowledged) throw new Error("Setup cancelled: acknowledgement was not provided");
+  options.acknowledgedUnofficial = true;
+
+  if (preflightOnly) {
+    preflightSetup(options);
+    stdout.write("Setup preflight complete.\n");
+    return;
+  }
+
+  const existing = existsSync(getConfigPath()) ? loadConfigForSetup() : undefined;
+  const interactionMode = options.browserInteractionMode ?? existing?.browserInteractionMode ?? "automatic";
+  const reusableCredentials = existingFullSetupCredentials(existing, interactionMode);
+  const needsTunnelId = !options.tunnelId && !reusableCredentials.tunnelId;
+  const needsRuntimeKey = !options.runtimeKeyFile
+    && !reusableCredentials.runtimeKey
+    && !existsSync(managedRuntimeKeyPath(interactionMode));
+
+  if (full && (needsTunnelId || needsRuntimeKey) && stdin.isTTY) {
+    stdout.write("Full mode needs an OpenAI tunnel and a runtime key with Tunnels Read + Use.\n");
+    stdout.write("Tunnels: https://platform.openai.com/settings/organization/tunnels\n");
+    stdout.write("Runtime keys: https://platform.openai.com/settings/organization/api-keys\n");
+    if (needsTunnelId) options.tunnelId = await prompt("Tunnel id: ");
+    if (needsRuntimeKey) {
+      options.runtimeKeyValue = await secretPrompt("Runtime key (hidden): ");
+    }
+  }
+
+  const result = await setup(options);
+  stdout.write(`\n✓ DSH ChatGPT Free setup complete (${result.mode})!\n`);
+  stdout.write(`Config: ${result.configPath}\n`);
+  stdout.write("\nTo use with DeepSeek Harness, ensure your ~/.dsh/settings.yaml includes:\n\n");
+  stdout.write("  providers:\n    chatgpt-web:\n      displayName: \"ChatGPT Web (Free)\"\n      api: openai-responses\n      baseURL: http://127.0.0.1:17841/v1\n      headers:\n        Authorization: \"Bearer chatgpt-web-free\"\n      models:\n        - id: chatgpt-web/luna\n          name: \"ChatGPT Web — Luna (Free)\"\n          contextWindow: 1050000\n          maxTokens: 32768\n\n");
+}
+
+async function doctorCommand(args: string[]): Promise<void> {
+  const json = takeFlag(args, "--json");
+  assertNoArgs(args);
+  const report = await runDoctor();
+  stdout.write(json ? `${JSON.stringify(report, null, 2)}\n` : formatDoctorReport(report));
+  if (!report.ok) process.exitCode = 1;
+}
+
+async function routeCommand(args: string[]): Promise<void> {
+  const action = args.shift() ?? "status";
+  assertNoArgs(args);
+  const result = action === "status"
+    ? (() => {
+        const status = inspectCodexIntegration();
+        return {
+          installed: status.installed,
+          active: status.active,
+          ...(status.routeUrl ? { routeUrl: status.routeUrl } : {}),
+          errors: status.errors,
+        };
+      })()
+    : action === "connect"
+      ? activateCodexIntegration()
+      : action === "disconnect"
+        ? deactivateCodexIntegration()
+        : undefined;
+  if (!result) throw new Error(`Unknown route action: ${action}`);
+  stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+}
+
+async function subagentsCommand(args: string[]): Promise<void> {
+  const action = args.shift() ?? "status";
+  assertNoArgs(args);
+  const config = loadConfig();
+  if (config.purpose === "dev-harness") {
+    throw new Error("The isolated DEV harness has no Codex subagent protocol to configure");
+  }
+  if (action === "status") {
+    const integration = inspectCodexIntegration();
+    stdout.write(`${JSON.stringify({
+      protocol: readCodexSubagentProtocol(config.subagentProtocol),
+      installed: integration.installed,
+      active: integration.active,
+    }, null, 2)}\n`);
+    return;
+  }
+  if (action !== "compatibility-v1" && action !== "native") {
+    throw new Error("Subagent protocol must be one of: status, compatibility-v1, native");
+  }
+  const journal = setCodexSubagentProtocol(config, action);
+  stdout.write(`${JSON.stringify({
+    protocol: journal.installed.subagent_protocol,
+    codexRestartRequired: true,
+    launcherRestartRequired: true,
+  }, null, 2)}\n`);
+}
+
+async function serviceCommand(args: string[]): Promise<void> {
+  const action = args.shift() ?? "status";
+  assertNoArgs(args);
+  const config = action === "status" ? undefined : loadConfig();
+  if (action === "cancel-turns") {
+    stdout.write(`${JSON.stringify(await cancelActiveTurns(config!), null, 2)}\n`);
+    return;
+  }
+  const status = action === "status" ? getServiceStatus()
+    : action === "install" ? installService(config!)
+      : action === "start" ? startService()
+        : action === "restart" ? await restartService(config!)
+          : action === "stop" ? await stopService(config!)
+            : undefined;
+  if (!status) throw new Error(`Unknown service action: ${action}`);
+  stdout.write(`${JSON.stringify(status, null, 2)}\n`);
+}
+
+async function interruptHookCommand(args: string[]): Promise<void> {
+  assertNoArgs(args);
+  const chunks: Buffer[] = [];
+  let bytes = 0;
+  for await (const chunk of stdin) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    bytes += buffer.byteLength;
+    if (bytes > 32 * 1024) throw new Error("Codex Interrupt hook payload is too large");
+    chunks.push(buffer);
+  }
+  let payload: { hook_event_name?: unknown; session_id?: unknown; turn_id?: unknown };
+  try {
+    payload = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  } catch {
+    throw new Error("Codex Interrupt hook payload is not valid JSON");
+  }
+  const threadId = typeof payload.session_id === "string" ? payload.session_id.trim() : "";
+  const turnId = typeof payload.turn_id === "string" ? payload.turn_id.trim() : "";
+  if (payload.hook_event_name !== "Interrupt"
+    || !/^[A-Za-z0-9_-]{6,128}$/.test(threadId)
+    || !/^[A-Za-z0-9_-]{6,128}$/.test(turnId)) {
+    throw new Error("Codex Interrupt hook payload has no valid session_id or turn_id");
+  }
+  await interruptActiveTurn(loadConfig(), { threadId, turnId });
+}
+
+async function tunnelCommand(args: string[]): Promise<void> {
+  const action = args.shift() ?? "status";
+  assertNoArgs(args);
+  if (action === "key-import") {
+    const key = await secretPrompt("Runtime key (hidden): ");
+    if (!key) throw new Error("A non-empty runtime key is required");
+    installRuntimeKeyBytes(key);
+    stdout.write(`Runtime key stored privately at ${managedRuntimeKeyPath()}\n`);
+    return;
+  }
+  const config = loadConfig();
+  if (action === "start") startTunnelService();
+  else if (action === "restart") {
+    await assertServiceIdle(config);
+    await restartTunnelService();
+  }
+  else if (action === "stop") {
+    await assertServiceIdle(config);
+    await stopTunnelService();
+    stopTunnel(config);
+  }
+  else if (action !== "status") throw new Error(`Unknown tunnel action: ${action}`);
+  const status = action === "start" || action === "restart"
+    ? await waitForTunnelReady(config)
+    : tunnelStatus(config);
+  const service = getTunnelServiceStatus();
+  stdout.write(`${JSON.stringify({ service, runtime: status }, null, 2)}\n`);
+  if (action !== "stop" && (!service.running || !status.ok)) process.exitCode = 1;
+}
+
+async function openCommand(args: string[]): Promise<void> {
+  const target = args.shift();
+  assertNoArgs(args);
+  const urls: Record<string, string> = {
+    tunnels: "https://platform.openai.com/settings/organization/tunnels",
+    "runtime-keys": "https://platform.openai.com/settings/organization/api-keys",
+    connectors: "https://chatgpt.com/#settings/Plugins",
+  };
+  const url = target ? urls[target] : undefined;
+  if (!url) throw new Error("Choose one of: tunnels, runtime-keys, connectors");
+  if (process.platform === "darwin") {
+    const result = runCommand("open", [url]);
+    if (result.status !== 0) throw new Error(result.stderr.trim() || `Could not open ${url}`);
+  } else {
+    stdout.write(`${url}\n`);
+  }
+}
+
+async function uninstallCommand(args: string[]): Promise<void> {
+  const yes = takeFlag(args, "--yes");
+  const keepData = takeFlag(args, "--keep-data");
+  const launcherControl = takeFlag(args, "--launcher-control");
+  assertNoArgs(args);
+  if (launcherControl) authorizeLauncherControl("uninstall");
+  if (!yes && !await confirm("Restore Codex config, stop services, and remove this installation?")) {
+    throw new Error("Uninstall cancelled");
+  }
+  const config = existsSync(getConfigPath()) ? loadConfig() : undefined;
+  if (config?.browserHost === "launcher" && !launcherControl) {
+    throw new Error(
+      "Launcher-owned integration must be removed from Codex Web GPT Settings so the active runtime can be drained safely.",
+    );
+  }
+  if (!config && process.platform === "darwin" && getServiceStatus().installed) {
+    throw new Error("Service exists but configuration is missing; refusing an unverifiable uninstall");
+  }
+  const launcherRuntimeStopped = config?.browserHost === "launcher" && launcherControl;
+  if (config && process.platform === "darwin" && !launcherRuntimeStopped) await assertServiceIdle(config);
+  if (config?.mode === "full" && !launcherRuntimeStopped) {
+    if (process.platform === "darwin") await uninstallTunnelService();
+    stopTunnel(config);
+  }
+  if (config && process.platform === "darwin" && !launcherRuntimeStopped) await uninstallService(config);
+  uninstallCodexIntegration();
+  if (!keepData) rmSync(getConfigDir(), { recursive: true, force: true });
+  stdout.write(keepData ? "Uninstalled; private application data was preserved.\n" : "Uninstalled and removed private application data.\n");
+}
+
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+  const home = takeOption(args, "--home");
+  if (home) {
+    process.env.DSH_CHATGPT_FREE_HOME = home;
+  }
+  if (takeFlag(args, "--help") || takeFlag(args, "-h")) {
+    stdout.write(HELP);
+    return;
+  }
+  if (takeFlag(args, "--version") || takeFlag(args, "-v")) {
+    stdout.write(`${VERSION}\n`);
+    return;
+  }
+  const command = args.shift() ?? "help";
+  if (command === "dev" && home) {
+    throw new Error("--home does not apply to DEV mode; use DSH_CHATGPT_FREE_DEV_HOME for an explicit isolated DEV profile");
+  }
+  if (command === "help") stdout.write(HELP);
+  else if (command === "setup") await setupCommand(args);
+  else if (command === "login") await loginCommand(args);
+  else if (command === "doctor" || command === "status") await doctorCommand(args);
+  else if (command === "route") await routeCommand(args);
+  else if (command === "subagents") await subagentsCommand(args);
+  else if (command === "browser") {
+    const action = args.shift();
+    assertNoArgs(args);
+    if (action !== "check") throw new Error("Browser command must be: browser check");
+    const config = loadConfig();
+    if (config.browserHost === "launcher") {
+      if (config.browserInteractionMode === "manual") {
+        await inspectLauncherBrowserHostLiveness(config.browserHostDescriptorPath!);
+        stdout.write("The launcher browser is reachable; ChatGPT DOM inspection is intentionally disabled in Zero Risk.\n");
+      } else {
+        await inspectLauncherBrowserHost(config.browserHostDescriptorPath!);
+        stdout.write("Playwright can reach the authenticated ChatGPT surface embedded in the launcher.\n");
+      }
+    } else {
+      await checkBrowserEngine(config);
+      stdout.write("Playwright can launch the configured Chrome executable.\n");
+    }
+  } else if (command === "serve") {
+    assertNoArgs(args);
+    const config = loadConfig();
+    const server = startServer(config);
+    stdout.write(`dsh-chatgpt-web ${VERSION} listening on http://${config.host}:${server.port}/v1 (${config.mode})\n`);
+    await new Promise<void>(() => {});
+  } else if (command === "dev") await runDevCommand(args);
+  else if (command === "mcp") await runChatGptMcpMain(args);
+  else if (command === "service") await serviceCommand(args);
+  else if (command === "hook") {
+    const action = args.shift();
+    if (action !== "interrupt") throw new Error("Hook command must be: hook interrupt");
+    await interruptHookCommand(args);
+  }
+  else if (command === "tunnel") await tunnelCommand(args);
+  else if (command === "open") await openCommand(args);
+  else if (command === "uninstall") await uninstallCommand(args);
+  else throw new Error(`Unknown command: ${command}\n\n${HELP}`);
+}
+
+main().catch(error => {
+  process.stderr.write(`dsh-chatgpt-web: ${error instanceof Error ? error.message : String(error)}\n`);
+  process.exitCode = 1;
+});