iwebgenics-ai 1.0.0

package/package.json

@@ -0,0 +1,110 @@
+{
+"name": "iwebgenics-ai",
+  "version": "1.0.0",
+  "description": "Iwebgenics Code CLI is a command-line interface tool that provides developers with a powerful and efficient way to interact with the Iwebgenics Code platform. It allows users to manage their projects, run code, and access various features of the Iwebgenics Code ecosystem directly from the terminal.",
+  "license": "LICENSED",
+  "private": false,
+  "type": "module",
+  "main": "src/entrypoints/cli.tsx",
+  "bin": {
+  "iwebgenics-ai": "dist/cli.mjs"
+},
+"files": ["dist/cli.mjs"],
+  "scripts": {
+    "build": "bun scripts/build-bundle.ts",
+    "build:watch": "bun scripts/build-bundle.ts --watch",
+    "build:prod": "bun scripts/build-bundle.ts --minify",
+    "build:web": "bun scripts/build-web.ts",
+    "build:web:watch": "bun scripts/build-web.ts --watch",
+    "build:web:prod": "bun scripts/build-web.ts --minify",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check src/",
+    "lint:fix": "biome check --write src/",
+    "format": "biome format --write src/",
+    "check": "biome check src/ && tsc --noEmit"
+  },
+  "dependencies": {
+    "@alcalzone/ansi-tokenize": "^0.3.0",
+    "@anthropic-ai/sdk": "^0.39.0",
+    "@commander-js/extra-typings": "^13.1.0",
+    "@growthbook/growthbook": "^1.4.0",
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/api-logs": "^0.57.0",
+    "@opentelemetry/core": "^1.30.0",
+    "@opentelemetry/resources": "^2.7.1",
+    "@opentelemetry/sdk-logs": "^0.57.0",
+    "@opentelemetry/sdk-metrics": "^1.30.0",
+    "@opentelemetry/sdk-trace-base": "^1.30.0",
+    "@xterm/addon-fit": "^0.10.0",
+    "@xterm/addon-search": "^0.15.0",
+    "@xterm/addon-unicode11": "^0.8.0",
+    "@xterm/addon-web-links": "^0.11.0",
+    "@xterm/addon-webgl": "^0.18.0",
+    "@xterm/xterm": "^5.5.0",
+    "asciichart": "^1.5.25",
+    "auto-bind": "^5.0.1",
+    "axios": "^1.7.0",
+    "bidi-js": "^1.0.3",
+    "chalk": "^5.4.0",
+    "chokidar": "^4.0.0",
+    "cli-boxes": "^3.0.0",
+    "code-excerpt": "^4.0.0",
+    "diff": "^7.0.0",
+    "env-paths": "^4.0.0",
+    "execa": "^9.5.0",
+    "fflate": "^0.8.2",
+    "figures": "^6.1.0",
+    "fuse.js": "^7.0.0",
+    "highlight.js": "^11.11.0",
+    "https-proxy-agent": "^9.0.0",
+    "ignore": "^6.0.0",
+    "indent-string": "^5.0.0",
+    "jsonc-parser": "^3.3.1",
+    "lodash-es": "^4.17.21",
+    "lru-cache": "^11.3.5",
+    "marked": "^15.0.0",
+    "node-pty": "^1.1.0",
+    "p-map": "^7.0.0",
+    "picomatch": "^4.0.0",
+    "proper-lockfile": "^4.1.2",
+    "qrcode": "^1.5.0",
+    "react": "^19.2.5",
+    "react-dom": "^19.2.5",
+    "react-reconciler": "^0.33.0",
+    "semver": "^7.6.0",
+    "shell-quote": "^1.8.3",
+    "stack-utils": "^2.0.6",
+    "strip-ansi": "^7.1.0",
+    "supports-hyperlinks": "^3.1.0",
+    "tree-kill": "^1.2.2",
+    "turndown": "^7.2.4",
+    "type-fest": "^4.30.0",
+    "undici": "^7.3.0",
+    "usehooks-ts": "^3.1.0",
+    "vscode-jsonrpc": "^8.2.1",
+    "wrap-ansi": "^9.0.0",
+    "ws": "^8.18.0",
+    "xss": "^1.0.15",
+    "yaml": "^2.6.0",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.0",
+    "@types/diff": "^7.0.0",
+    "@types/lodash-es": "^4.17.12",
+    "@types/node": "^22.10.0",
+    "@types/picomatch": "^3.0.0",
+    "@types/proper-lockfile": "^4.1.4",
+    "@types/react": "^19.0.0",
+    "@types/semver": "^7.5.8",
+    "@types/stack-utils": "^2.0.3",
+    "@types/ws": "^8.5.0",
+    "esbuild": "^0.25.0",
+    "typescript": "^5.7.0"
+  },
+  "engines": {
+    "bun": ">=1.1.0"
+  },
+  "packageManager": "bun@1.1.0"
+}

package/src/entrypoints/cli.tsx

@@ -0,0 +1,313 @@
+// @ts-nocheck
+globalThis.MACRO = {
+  VERSION: "1.0.24",
+  BUILD_TIME: new Date().toISOString(),
+  FEEDBACK_CHANNEL: "",
+  ISSUES_EXPLAINER: "",
+  NATIVE_PACKAGE_URL: "",
+  PACKAGE_URL: "",
+  VERSION_CHANGELOG: "",
+};
+import { feature } from 'bun:bundle';
+
+// Bugfix for corepack auto-pinning, which adds yarnpkg to peoples' package.jsons
+// eslint-disable-next-line custom-rules/no-top-level-side-effects
+process.env.COREPACK_ENABLE_AUTO_PIN = '0';
+
+// Set max heap size for child processes in CCR environments (containers have 16GB)
+// eslint-disable-next-line custom-rules/no-top-level-side-effects, custom-rules/no-process-env-top-level, custom-rules/safe-env-boolean-check
+if (process.env.CLAUDE_CODE_REMOTE === 'true') {
+  // eslint-disable-next-line custom-rules/no-top-level-side-effects, custom-rules/no-process-env-top-level
+  const existing = process.env.NODE_OPTIONS || '';
+  // eslint-disable-next-line custom-rules/no-top-level-side-effects, custom-rules/no-process-env-top-level
+  process.env.NODE_OPTIONS = existing ? `${existing} --max-old-space-size=8192` : '--max-old-space-size=8192';
+}
+
+// Harness-science L0 ablation baseline. Inlined here (not init.ts) because
+// BashTool/AgentTool/PowerShellTool capture DISABLE_BACKGROUND_TASKS into
+// module-level consts at import time — init() runs too late. feature() gate
+// DCEs this entire block from external builds.
+// eslint-disable-next-line custom-rules/no-top-level-side-effects, custom-rules/no-process-env-top-level
+if (feature('ABLATION_BASELINE') && process.env.CLAUDE_CODE_ABLATION_BASELINE) {
+  for (const k of ['CLAUDE_CODE_SIMPLE', 'CLAUDE_CODE_DISABLE_THINKING', 'DISABLE_INTERLEAVED_THINKING', 'DISABLE_COMPACT', 'DISABLE_AUTO_COMPACT', 'CLAUDE_CODE_DISABLE_AUTO_MEMORY', 'CLAUDE_CODE_DISABLE_BACKGROUND_TASKS']) {
+    // eslint-disable-next-line custom-rules/no-top-level-side-effects, custom-rules/no-process-env-top-level
+    process.env[k] ??= '1';
+  }
+}
+
+/**
+ * Bootstrap entrypoint - checks for special flags before loading the full CLI.
+ * All imports are dynamic to minimize module evaluation for fast paths.
+ * Fast-path for --version has zero imports beyond this file.
+ */
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+
+  // Fast-path for --version/-v: zero module loading needed
+  if (args.length === 1 && (args[0] === '--version' || args[0] === '-v' || args[0] === '-V')) {
+    // MACRO.VERSION is inlined at build time
+    // biome-ignore lint/suspicious/noConsole:: intentional console output
+    console.log(`${MACRO.VERSION} (Claude Code)`);
+    return;
+  }
+
+  // For all other paths, load the startup profiler
+  const {
+    profileCheckpoint
+  } = await import('../utils/startupProfiler.js');
+  profileCheckpoint('cli_entry');
+
+  // Fast-path for --dump-system-prompt: output the rendered system prompt and exit.
+  // Used by prompt sensitivity evals to extract the system prompt at a specific commit.
+  // Ant-only: eliminated from external builds via feature flag.
+  if (feature('DUMP_SYSTEM_PROMPT') && args[0] === '--dump-system-prompt') {
+    profileCheckpoint('cli_dump_system_prompt_path');
+    const {
+      enableConfigs
+    } = await import('../utils/config.js');
+    enableConfigs();
+    const {
+      getMainLoopModel
+    } = await import('../utils/model/model.js');
+    const modelIdx = args.indexOf('--model');
+    const model = modelIdx !== -1 && args[modelIdx + 1] || getMainLoopModel();
+    const {
+      getSystemPrompt
+    } = await import('../constants/prompts.js');
+    const prompt = await getSystemPrompt([], model);
+    // biome-ignore lint/suspicious/noConsole:: intentional console output
+    console.log(prompt.join('\n'));
+    return;
+  }
+  if (process.argv[2] === '--claude-in-chrome-mcp') {
+    profileCheckpoint('cli_claude_in_chrome_mcp_path');
+    const {
+      runClaudeInChromeMcpServer
+    } = await import('../utils/claudeInChrome/mcpServer.js');
+    await runClaudeInChromeMcpServer();
+    return;
+  } else if (process.argv[2] === '--chrome-native-host') {
+    profileCheckpoint('cli_chrome_native_host_path');
+    const {
+      runChromeNativeHost
+    } = await import('../utils/claudeInChrome/chromeNativeHost.js');
+    await runChromeNativeHost();
+    return;
+  } else if (feature('CHICAGO_MCP') && process.argv[2] === '--computer-use-mcp') {
+    profileCheckpoint('cli_computer_use_mcp_path');
+    const {
+      runComputerUseMcpServer
+    } = await import('../utils/computerUse/mcpServer.js');
+    await runComputerUseMcpServer();
+    return;
+  }
+
+  // Fast-path for `--daemon-worker=<kind>` (internal — supervisor spawns this).
+  // Must come before the daemon subcommand check: spawned per-worker, so
+  // perf-sensitive. No enableConfigs(), no analytics sinks at this layer —
+  // workers are lean. If a worker kind needs configs/auth (assistant will),
+  // it calls them inside its run() fn.
+  if (feature('DAEMON') && args[0] === '--daemon-worker') {
+    const {
+      runDaemonWorker
+    } = await import('../daemon/workerRegistry.js');
+    await runDaemonWorker(args[1]);
+    return;
+  }
+
+  // Fast-path for `claude remote-control` (also accepts legacy `claude remote` / `claude sync` / `claude bridge`):
+  // serve local machine as bridge environment.
+  // feature() must stay inline for build-time dead code elimination;
+  // isBridgeEnabled() checks the runtime GrowthBook gate.
+  if (feature('BRIDGE_MODE') && (args[0] === 'remote-control' || args[0] === 'rc' || args[0] === 'remote' || args[0] === 'sync' || args[0] === 'bridge')) {
+    profileCheckpoint('cli_bridge_path');
+    const {
+      enableConfigs
+    } = await import('../utils/config.js');
+    enableConfigs();
+    const {
+      getBridgeDisabledReason,
+      checkBridgeMinVersion
+    } = await import('../bridge/bridgeEnabled.js');
+    const {
+      BRIDGE_LOGIN_ERROR
+    } = await import('../bridge/types.js');
+    const {
+      bridgeMain
+    } = await import('../bridge/bridgeMain.js');
+    const {
+      exitWithError
+    } = await import('../utils/process.js');
+
+    // Auth check must come before the GrowthBook gate check — without auth,
+    // GrowthBook has no user context and would return a stale/default false.
+    // getBridgeDisabledReason awaits GB init, so the returned value is fresh
+    // (not the stale disk cache), but init still needs auth headers to work.
+    const {
+      getClaudeAIOAuthTokens
+    } = await import('../utils/auth.js');
+    if (!getClaudeAIOAuthTokens()?.accessToken) {
+      exitWithError(BRIDGE_LOGIN_ERROR);
+    }
+    const disabledReason = await getBridgeDisabledReason();
+    if (disabledReason) {
+      exitWithError(`Error: ${disabledReason}`);
+    }
+    const versionError = checkBridgeMinVersion();
+    if (versionError) {
+      exitWithError(versionError);
+    }
+
+    // Bridge is a remote control feature - check policy limits
+    const {
+      waitForPolicyLimitsToLoad,
+      isPolicyAllowed
+    } = await import('../services/policyLimits/index.js');
+    await waitForPolicyLimitsToLoad();
+    if (!isPolicyAllowed('allow_remote_control')) {
+      exitWithError("Error: Remote Control is disabled by your organization's policy.");
+    }
+    await bridgeMain(args.slice(1));
+    return;
+  }
+
+  // Fast-path for `claude daemon [subcommand]`: long-running supervisor.
+  if (feature('DAEMON') && args[0] === 'daemon') {
+    profileCheckpoint('cli_daemon_path');
+    const {
+      enableConfigs
+    } = await import('../utils/config.js');
+    enableConfigs();
+    const {
+      initSinks
+    } = await import('../utils/sinks.js');
+    initSinks();
+    const {
+      daemonMain
+    } = await import('../daemon/main.js');
+    await daemonMain(args.slice(1));
+    return;
+  }
+
+  // Fast-path for `claude ps|logs|attach|kill` and `--bg`/`--background`.
+  // Session management against the ~/.claude/sessions/ registry. Flag
+  // literals are inlined so bg.js only loads when actually dispatching.
+  if (feature('BG_SESSIONS') && (args[0] === 'ps' || args[0] === 'logs' || args[0] === 'attach' || args[0] === 'kill' || args.includes('--bg') || args.includes('--background'))) {
+    profileCheckpoint('cli_bg_path');
+    const {
+      enableConfigs
+    } = await import('../utils/config.js');
+    enableConfigs();
+    const bg = await import('../cli/bg.js');
+    switch (args[0]) {
+      case 'ps':
+        await bg.psHandler(args.slice(1));
+        break;
+      case 'logs':
+        await bg.logsHandler(args[1]);
+        break;
+      case 'attach':
+        await bg.attachHandler(args[1]);
+        break;
+      case 'kill':
+        await bg.killHandler(args[1]);
+        break;
+      default:
+        await bg.handleBgFlag(args);
+    }
+    return;
+  }
+
+  // Fast-path for template job commands.
+  if (feature('TEMPLATES') && (args[0] === 'new' || args[0] === 'list' || args[0] === 'reply')) {
+    profileCheckpoint('cli_templates_path');
+    const {
+      templatesMain
+    } = await import('../cli/handlers/templateJobs.js');
+    await templatesMain(args);
+    // process.exit (not return) — mountFleetView's Ink TUI can leave event
+    // loop handles that prevent natural exit.
+    // eslint-disable-next-line custom-rules/no-process-exit
+    process.exit(0);
+  }
+
+  // Fast-path for `claude environment-runner`: headless BYOC runner.
+  // feature() must stay inline for build-time dead code elimination.
+  if (feature('BYOC_ENVIRONMENT_RUNNER') && args[0] === 'environment-runner') {
+    profileCheckpoint('cli_environment_runner_path');
+    const {
+      environmentRunnerMain
+    } = await import('../environment-runner/main.js');
+    await environmentRunnerMain(args.slice(1));
+    return;
+  }
+
+  // Fast-path for `claude self-hosted-runner`: headless self-hosted-runner
+  // targeting the SelfHostedRunnerWorkerService API (register + poll; poll IS
+  // heartbeat). feature() must stay inline for build-time dead code elimination.
+  if (feature('SELF_HOSTED_RUNNER') && args[0] === 'self-hosted-runner') {
+    profileCheckpoint('cli_self_hosted_runner_path');
+    const {
+      selfHostedRunnerMain
+    } = await import('../self-hosted-runner/main.js');
+    await selfHostedRunnerMain(args.slice(1));
+    return;
+  }
+
+  // Fast-path for --worktree --tmux: exec into tmux before loading full CLI
+  const hasTmuxFlag = args.includes('--tmux') || args.includes('--tmux=classic');
+  if (hasTmuxFlag && (args.includes('-w') || args.includes('--worktree') || args.some(a => a.startsWith('--worktree=')))) {
+    profileCheckpoint('cli_tmux_worktree_fast_path');
+    const {
+      enableConfigs
+    } = await import('../utils/config.js');
+    enableConfigs();
+    const {
+      isWorktreeModeEnabled
+    } = await import('../utils/worktreeModeEnabled.js');
+    if (isWorktreeModeEnabled()) {
+      const {
+        execIntoTmuxWorktree
+      } = await import('../utils/worktree.js');
+      const result = await execIntoTmuxWorktree(args);
+      if (result.handled) {
+        return;
+      }
+      // If not handled (e.g., error), fall through to normal CLI
+      if (result.error) {
+        const {
+          exitWithError
+        } = await import('../utils/process.js');
+        exitWithError(result.error);
+      }
+    }
+  }
+
+  // Redirect common update flag mistakes to the update subcommand
+  if (args.length === 1 && (args[0] === '--update' || args[0] === '--upgrade')) {
+    process.argv = [process.argv[0]!, process.argv[1]!, 'update'];
+  }
+
+  // --bare: set SIMPLE early so gates fire during module eval / commander
+  // option building (not just inside the action handler).
+  if (args.includes('--bare')) {
+    process.env.CLAUDE_CODE_SIMPLE = '1';
+  }
+
+  // No special flags detected, load and run the full CLI
+  const {
+    startCapturingEarlyInput
+  } = await import('../utils/earlyInput.js');
+  startCapturingEarlyInput();
+  profileCheckpoint('cli_before_main_import');
+  const {
+    main: cliMain
+  } = await import('../main.js');
+  profileCheckpoint('cli_after_main_import');
+  await cliMain();
+  profileCheckpoint('cli_after_main_complete');
+}
+
+// eslint-disable-next-line custom-rules/no-top-level-side-effects
+void main();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["feature","process","env","COREPACK_ENABLE_AUTO_PIN","CLAUDE_CODE_REMOTE","existing","NODE_OPTIONS","CLAUDE_CODE_ABLATION_BASELINE","k","main","Promise","args","argv","slice","length","console","log","MACRO","VERSION","profileCheckpoint","enableConfigs","getMainLoopModel","modelIdx","indexOf","model","getSystemPrompt","prompt","join","runClaudeInChromeMcpServer","runChromeNativeHost","runComputerUseMcpServer","runDaemonWorker","getBridgeDisabledReason","checkBridgeMinVersion","BRIDGE_LOGIN_ERROR","bridgeMain","exitWithError","getClaudeAIOAuthTokens","accessToken","disabledReason","versionError","waitForPolicyLimitsToLoad","isPolicyAllowed","initSinks","daemonMain","includes","bg","psHandler","logsHandler","attachHandler","killHandler","handleBgFlag","templatesMain","exit","environmentRunnerMain","selfHostedRunnerMain","hasTmuxFlag","some","a","startsWith","isWorktreeModeEnabled","execIntoTmuxWorktree","result","handled","error","CLAUDE_CODE_SIMPLE","startCapturingEarlyInput","cliMain"],"sources":["cli.tsx"],"sourcesContent":["import { feature } from 'bun:bundle'\n\n// Bugfix for corepack auto-pinning, which adds yarnpkg to peoples' package.jsons\n// eslint-disable-next-line custom-rules/no-top-level-side-effects\nprocess.env.COREPACK_ENABLE_AUTO_PIN = '0'\n\n// Set max heap size for child processes in CCR environments (containers have 16GB)\n// eslint-disable-next-line custom-rules/no-top-level-side-effects, custom-rules/no-process-env-top-level, custom-rules/safe-env-boolean-check\nif (process.env.CLAUDE_CODE_REMOTE === 'true') {\n  // eslint-disable-next-line custom-rules/no-top-level-side-effects, custom-rules/no-process-env-top-level\n  const existing = process.env.NODE_OPTIONS || ''\n  // eslint-disable-next-line custom-rules/no-top-level-side-effects, custom-rules/no-process-env-top-level\n  process.env.NODE_OPTIONS = existing\n    ? `${existing} --max-old-space-size=8192`\n    : '--max-old-space-size=8192'\n}\n\n// Harness-science L0 ablation baseline. Inlined here (not init.ts) because\n// BashTool/AgentTool/PowerShellTool capture DISABLE_BACKGROUND_TASKS into\n// module-level consts at import time — init() runs too late. feature() gate\n// DCEs this entire block from external builds.\n// eslint-disable-next-line custom-rules/no-top-level-side-effects, custom-rules/no-process-env-top-level\nif (feature('ABLATION_BASELINE') && process.env.CLAUDE_CODE_ABLATION_BASELINE) {\n  for (const k of [\n    'CLAUDE_CODE_SIMPLE',\n    'CLAUDE_CODE_DISABLE_THINKING',\n    'DISABLE_INTERLEAVED_THINKING',\n    'DISABLE_COMPACT',\n    'DISABLE_AUTO_COMPACT',\n    'CLAUDE_CODE_DISABLE_AUTO_MEMORY',\n    'CLAUDE_CODE_DISABLE_BACKGROUND_TASKS',\n  ]) {\n    // eslint-disable-next-line custom-rules/no-top-level-side-effects, custom-rules/no-process-env-top-level\n    process.env[k] ??= '1'\n  }\n}\n\n/**\n * Bootstrap entrypoint - checks for special flags before loading the full CLI.\n * All imports are dynamic to minimize module evaluation for fast paths.\n * Fast-path for --version has zero imports beyond this file.\n */\nasync function main(): Promise<void> {\n  const args = process.argv.slice(2)\n\n  // Fast-path for --version/-v: zero module loading needed\n  if (\n    args.length === 1 &&\n    (args[0] === '--version' || args[0] === '-v' || args[0] === '-V')\n  ) {\n    // MACRO.VERSION is inlined at build time\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(`${MACRO.VERSION} (Claude Code)`)\n    return\n  }\n\n  // For all other paths, load the startup profiler\n  const { profileCheckpoint } = await import('../utils/startupProfiler.js')\n  profileCheckpoint('cli_entry')\n\n  // Fast-path for --dump-system-prompt: output the rendered system prompt and exit.\n  // Used by prompt sensitivity evals to extract the system prompt at a specific commit.\n  // Ant-only: eliminated from external builds via feature flag.\n  if (feature('DUMP_SYSTEM_PROMPT') && args[0] === '--dump-system-prompt') {\n    profileCheckpoint('cli_dump_system_prompt_path')\n    const { enableConfigs } = await import('../utils/config.js')\n    enableConfigs()\n    const { getMainLoopModel } = await import('../utils/model/model.js')\n    const modelIdx = args.indexOf('--model')\n    const model = (modelIdx !== -1 && args[modelIdx + 1]) || getMainLoopModel()\n    const { getSystemPrompt } = await import('../constants/prompts.js')\n    const prompt = await getSystemPrompt([], model)\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(prompt.join('\\n'))\n    return\n  }\n\n  if (process.argv[2] === '--claude-in-chrome-mcp') {\n    profileCheckpoint('cli_claude_in_chrome_mcp_path')\n    const { runClaudeInChromeMcpServer } = await import(\n      '../utils/claudeInChrome/mcpServer.js'\n    )\n    await runClaudeInChromeMcpServer()\n    return\n  } else if (process.argv[2] === '--chrome-native-host') {\n    profileCheckpoint('cli_chrome_native_host_path')\n    const { runChromeNativeHost } = await import(\n      '../utils/claudeInChrome/chromeNativeHost.js'\n    )\n    await runChromeNativeHost()\n    return\n  } else if (\n    feature('CHICAGO_MCP') &&\n    process.argv[2] === '--computer-use-mcp'\n  ) {\n    profileCheckpoint('cli_computer_use_mcp_path')\n    const { runComputerUseMcpServer } = await import(\n      '../utils/computerUse/mcpServer.js'\n    )\n    await runComputerUseMcpServer()\n    return\n  }\n\n  // Fast-path for `--daemon-worker=<kind>` (internal — supervisor spawns this).\n  // Must come before the daemon subcommand check: spawned per-worker, so\n  // perf-sensitive. No enableConfigs(), no analytics sinks at this layer —\n  // workers are lean. If a worker kind needs configs/auth (assistant will),\n  // it calls them inside its run() fn.\n  if (feature('DAEMON') && args[0] === '--daemon-worker') {\n    const { runDaemonWorker } = await import('../daemon/workerRegistry.js')\n    await runDaemonWorker(args[1])\n    return\n  }\n\n  // Fast-path for `claude remote-control` (also accepts legacy `claude remote` / `claude sync` / `claude bridge`):\n  // serve local machine as bridge environment.\n  // feature() must stay inline for build-time dead code elimination;\n  // isBridgeEnabled() checks the runtime GrowthBook gate.\n  if (\n    feature('BRIDGE_MODE') &&\n    (args[0] === 'remote-control' ||\n      args[0] === 'rc' ||\n      args[0] === 'remote' ||\n      args[0] === 'sync' ||\n      args[0] === 'bridge')\n  ) {\n    profileCheckpoint('cli_bridge_path')\n    const { enableConfigs } = await import('../utils/config.js')\n    enableConfigs()\n\n    const { getBridgeDisabledReason, checkBridgeMinVersion } = await import(\n      '../bridge/bridgeEnabled.js'\n    )\n    const { BRIDGE_LOGIN_ERROR } = await import('../bridge/types.js')\n    const { bridgeMain } = await import('../bridge/bridgeMain.js')\n    const { exitWithError } = await import('../utils/process.js')\n\n    // Auth check must come before the GrowthBook gate check — without auth,\n    // GrowthBook has no user context and would return a stale/default false.\n    // getBridgeDisabledReason awaits GB init, so the returned value is fresh\n    // (not the stale disk cache), but init still needs auth headers to work.\n    const { getClaudeAIOAuthTokens } = await import('../utils/auth.js')\n    if (!getClaudeAIOAuthTokens()?.accessToken) {\n      exitWithError(BRIDGE_LOGIN_ERROR)\n    }\n    const disabledReason = await getBridgeDisabledReason()\n    if (disabledReason) {\n      exitWithError(`Error: ${disabledReason}`)\n    }\n    const versionError = checkBridgeMinVersion()\n    if (versionError) {\n      exitWithError(versionError)\n    }\n\n    // Bridge is a remote control feature - check policy limits\n    const { waitForPolicyLimitsToLoad, isPolicyAllowed } = await import(\n      '../services/policyLimits/index.js'\n    )\n    await waitForPolicyLimitsToLoad()\n    if (!isPolicyAllowed('allow_remote_control')) {\n      exitWithError(\n        \"Error: Remote Control is disabled by your organization's policy.\",\n      )\n    }\n\n    await bridgeMain(args.slice(1))\n    return\n  }\n\n  // Fast-path for `claude daemon [subcommand]`: long-running supervisor.\n  if (feature('DAEMON') && args[0] === 'daemon') {\n    profileCheckpoint('cli_daemon_path')\n    const { enableConfigs } = await import('../utils/config.js')\n    enableConfigs()\n    const { initSinks } = await import('../utils/sinks.js')\n    initSinks()\n    const { daemonMain } = await import('../daemon/main.js')\n    await daemonMain(args.slice(1))\n    return\n  }\n\n  // Fast-path for `claude ps|logs|attach|kill` and `--bg`/`--background`.\n  // Session management against the ~/.claude/sessions/ registry. Flag\n  // literals are inlined so bg.js only loads when actually dispatching.\n  if (\n    feature('BG_SESSIONS') &&\n    (args[0] === 'ps' ||\n      args[0] === 'logs' ||\n      args[0] === 'attach' ||\n      args[0] === 'kill' ||\n      args.includes('--bg') ||\n      args.includes('--background'))\n  ) {\n    profileCheckpoint('cli_bg_path')\n    const { enableConfigs } = await import('../utils/config.js')\n    enableConfigs()\n    const bg = await import('../cli/bg.js')\n    switch (args[0]) {\n      case 'ps':\n        await bg.psHandler(args.slice(1))\n        break\n      case 'logs':\n        await bg.logsHandler(args[1])\n        break\n      case 'attach':\n        await bg.attachHandler(args[1])\n        break\n      case 'kill':\n        await bg.killHandler(args[1])\n        break\n      default:\n        await bg.handleBgFlag(args)\n    }\n    return\n  }\n\n  // Fast-path for template job commands.\n  if (\n    feature('TEMPLATES') &&\n    (args[0] === 'new' || args[0] === 'list' || args[0] === 'reply')\n  ) {\n    profileCheckpoint('cli_templates_path')\n    const { templatesMain } = await import('../cli/handlers/templateJobs.js')\n    await templatesMain(args)\n    // process.exit (not return) — mountFleetView's Ink TUI can leave event\n    // loop handles that prevent natural exit.\n    // eslint-disable-next-line custom-rules/no-process-exit\n    process.exit(0)\n  }\n\n  // Fast-path for `claude environment-runner`: headless BYOC runner.\n  // feature() must stay inline for build-time dead code elimination.\n  if (feature('BYOC_ENVIRONMENT_RUNNER') && args[0] === 'environment-runner') {\n    profileCheckpoint('cli_environment_runner_path')\n    const { environmentRunnerMain } = await import(\n      '../environment-runner/main.js'\n    )\n    await environmentRunnerMain(args.slice(1))\n    return\n  }\n\n  // Fast-path for `claude self-hosted-runner`: headless self-hosted-runner\n  // targeting the SelfHostedRunnerWorkerService API (register + poll; poll IS\n  // heartbeat). feature() must stay inline for build-time dead code elimination.\n  if (feature('SELF_HOSTED_RUNNER') && args[0] === 'self-hosted-runner') {\n    profileCheckpoint('cli_self_hosted_runner_path')\n    const { selfHostedRunnerMain } = await import(\n      '../self-hosted-runner/main.js'\n    )\n    await selfHostedRunnerMain(args.slice(1))\n    return\n  }\n\n  // Fast-path for --worktree --tmux: exec into tmux before loading full CLI\n  const hasTmuxFlag = args.includes('--tmux') || args.includes('--tmux=classic')\n  if (\n    hasTmuxFlag &&\n    (args.includes('-w') ||\n      args.includes('--worktree') ||\n      args.some(a => a.startsWith('--worktree=')))\n  ) {\n    profileCheckpoint('cli_tmux_worktree_fast_path')\n    const { enableConfigs } = await import('../utils/config.js')\n    enableConfigs()\n    const { isWorktreeModeEnabled } = await import(\n      '../utils/worktreeModeEnabled.js'\n    )\n    if (isWorktreeModeEnabled()) {\n      const { execIntoTmuxWorktree } = await import('../utils/worktree.js')\n      const result = await execIntoTmuxWorktree(args)\n      if (result.handled) {\n        return\n      }\n      // If not handled (e.g., error), fall through to normal CLI\n      if (result.error) {\n        const { exitWithError } = await import('../utils/process.js')\n        exitWithError(result.error)\n      }\n    }\n  }\n\n  // Redirect common update flag mistakes to the update subcommand\n  if (\n    args.length === 1 &&\n    (args[0] === '--update' || args[0] === '--upgrade')\n  ) {\n    process.argv = [process.argv[0]!, process.argv[1]!, 'update']\n  }\n\n  // --bare: set SIMPLE early so gates fire during module eval / commander\n  // option building (not just inside the action handler).\n  if (args.includes('--bare')) {\n    process.env.CLAUDE_CODE_SIMPLE = '1'\n  }\n\n  // No special flags detected, load and run the full CLI\n  const { startCapturingEarlyInput } = await import('../utils/earlyInput.js')\n  startCapturingEarlyInput()\n  profileCheckpoint('cli_before_main_import')\n  const { main: cliMain } = await import('../main.js')\n  profileCheckpoint('cli_after_main_import')\n  await cliMain()\n  profileCheckpoint('cli_after_main_complete')\n}\n\n// eslint-disable-next-line custom-rules/no-top-level-side-effects\nvoid main()\n"],"mappings":"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","ignoreList":[]}