@shareai-lab/kode 1.1.12 → 1.1.13

package/dist/entrypoints/cli.js

@@ -0,0 +1,1101 @@
+#!/usr/bin/env -S node --no-warnings=ExperimentalWarning --enable-source-maps
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { initSentry } from "../services/sentry.js";
+import { PRODUCT_COMMAND, PRODUCT_NAME } from "../constants/product.js";
+initSentry();
+try {
+  if (!process.env.YOGA_WASM_PATH) {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const devCandidate = join(__dirname, "../../yoga.wasm");
+    const distCandidate = join(__dirname, "./yoga.wasm");
+    const resolved = existsSync(distCandidate) ? distCandidate : existsSync(devCandidate) ? devCandidate : void 0;
+    if (resolved) {
+      process.env.YOGA_WASM_PATH = resolved;
+    }
+  }
+} catch {
+}
+import * as dontcare from "@anthropic-ai/sdk/shims/node";
+Object.keys(dontcare);
+import React from "react";
+import { ReadStream } from "tty";
+import { openSync, existsSync } from "fs";
+import { addToHistory } from "../history.js";
+import { getContext, setContext, removeContext } from "../context.js";
+import { Command } from "@commander-js/extra-typings";
+import { ask } from "../utils/ask.js";
+import { hasPermissionsToUseTool } from "../permissions.js";
+import { getTools } from "../tools.js";
+import {
+  getGlobalConfig,
+  getCurrentProjectConfig,
+  saveGlobalConfig,
+  saveCurrentProjectConfig,
+  setConfigForCLI,
+  deleteConfigForCLI,
+  getConfigForCLI,
+  listConfigForCLI,
+  enableConfigs,
+  validateAndRepairAllGPT5Profiles
+} from "../utils/config.js";
+import { cwd } from "process";
+import { dateToFilename, logError, parseLogFilename } from "../utils/log.js";
+import { initDebugLogger } from "../utils/debugLogger.js";
+import { Onboarding } from "../components/Onboarding.js";
+import { Doctor } from "../screens/Doctor.js";
+import { TrustDialog } from "../components/TrustDialog.js";
+import { checkHasTrustDialogAccepted } from "../utils/config.js";
+import { isDefaultSlowAndCapableModel } from "../utils/model.js";
+import { LogList } from "../screens/LogList.js";
+import { ResumeConversation } from "../screens/ResumeConversation.js";
+import { startMCPServer } from "./mcp.js";
+import { getCwd, setCwd, setOriginalCwd } from "../utils/state.js";
+import { omit } from "lodash-es";
+import { getCommands } from "../commands.js";
+import { getNextAvailableLogForkNumber, loadLogList } from "../utils/log.js";
+import { loadMessagesFromLog } from "../utils/conversationRecovery.js";
+import { cleanupOldMessageFilesInBackground } from "../utils/cleanup.js";
+import {
+  handleListApprovedTools,
+  handleRemoveApprovedTool
+} from "../commands/approvedTools.js";
+import {
+  addMcpServer,
+  getMcpServer,
+  listMCPServers,
+  parseEnvVars,
+  removeMcpServer,
+  getClients,
+  ensureConfigScope
+} from "../services/mcpClient.js";
+import { handleMcprcServerApprovals } from "../services/mcpServerApproval.js";
+import { logEvent } from "../services/statsig.js";
+import { cursorShow } from "ansi-escapes";
+import {
+  getLatestVersion,
+  assertMinVersion,
+  getUpdateCommandSuggestions
+} from "../utils/autoUpdater.js";
+import { gt } from "semver";
+import { CACHE_PATHS } from "../utils/log.js";
+import { PersistentShell } from "../utils/PersistentShell.js";
+import { clearTerminal } from "../utils/terminal.js";
+import { showInvalidConfigDialog } from "../components/InvalidConfigDialog.js";
+import { ConfigParseError } from "../utils/errors.js";
+import { grantReadPermissionForOriginalDir } from "../utils/permissions/filesystem.js";
+import { MACRO } from "../constants/macros.js";
+function completeOnboarding() {
+  const config = getGlobalConfig();
+  saveGlobalConfig({
+    ...config,
+    hasCompletedOnboarding: true,
+    lastOnboardingVersion: MACRO.VERSION
+  });
+}
+async function showSetupScreens(safeMode, print) {
+  if (process.env.NODE_ENV === "test") {
+    return;
+  }
+  const config = getGlobalConfig();
+  if (!config.theme || !config.hasCompletedOnboarding) {
+    await clearTerminal();
+    const { render: render2 } = await import("ink");
+    await new Promise((resolve) => {
+      render2(
+        /* @__PURE__ */ React.createElement(
+          Onboarding,
+          {
+            onDone: async () => {
+              completeOnboarding();
+              await clearTerminal();
+              resolve();
+            }
+          }
+        ),
+        {
+          exitOnCtrlC: false
+        }
+      );
+    });
+  }
+  if (!print && safeMode) {
+    if (!checkHasTrustDialogAccepted()) {
+      await new Promise((resolve) => {
+        const onDone = () => {
+          grantReadPermissionForOriginalDir();
+          resolve();
+        };
+        render(/* @__PURE__ */ React.createElement(TrustDialog, { onDone }), {
+          exitOnCtrlC: false
+        });
+      });
+    }
+    if (process.env.USER_TYPE === "ant") {
+      await handleMcprcServerApprovals();
+    }
+  }
+}
+function logStartup() {
+  const config = getGlobalConfig();
+  saveGlobalConfig({
+    ...config,
+    numStartups: (config.numStartups ?? 0) + 1
+  });
+}
+async function setup(cwd2, safeMode) {
+  if (cwd2 !== process.cwd()) {
+    setOriginalCwd(cwd2);
+  }
+  await setCwd(cwd2);
+  grantReadPermissionForOriginalDir();
+  let agentLoader;
+  try {
+    agentLoader = await import("../utils/agentLoader.js");
+  } catch {
+    agentLoader = await import("../utils/agentLoader.js");
+  }
+  const { startAgentWatcher, clearAgentCache } = agentLoader;
+  await startAgentWatcher(() => {
+    console.log("\u2705 Agent configurations hot-reloaded");
+  });
+  if (safeMode) {
+    if (process.platform !== "win32" && typeof process.getuid === "function" && process.getuid() === 0) {
+      console.error(
+        `--safe mode cannot be used with root/sudo privileges for security reasons`
+      );
+      process.exit(1);
+    }
+  }
+  if (process.env.NODE_ENV === "test") {
+    return;
+  }
+  cleanupOldMessageFilesInBackground();
+  getContext();
+  const globalConfig = getGlobalConfig();
+  if (globalConfig.iterm2KeyBindingInstalled === true && globalConfig.shiftEnterKeyBindingInstalled !== true) {
+    const updatedConfig = {
+      ...globalConfig,
+      shiftEnterKeyBindingInstalled: true
+    };
+    delete updatedConfig.iterm2KeyBindingInstalled;
+    saveGlobalConfig(updatedConfig);
+  }
+  const projectConfig = getCurrentProjectConfig();
+  if (projectConfig.lastCost !== void 0 && projectConfig.lastDuration !== void 0) {
+    logEvent("tengu_exit", {
+      last_session_cost: String(projectConfig.lastCost),
+      last_session_api_duration: String(projectConfig.lastAPIDuration),
+      last_session_duration: String(projectConfig.lastDuration),
+      last_session_id: projectConfig.lastSessionId
+    });
+  }
+  const autoUpdaterStatus = globalConfig.autoUpdaterStatus ?? "not_configured";
+  if (autoUpdaterStatus === "not_configured") {
+    logEvent("tengu_setup_auto_updater_not_configured", {});
+    await new Promise((resolve) => {
+      render(/* @__PURE__ */ React.createElement(Doctor, { onDone: () => resolve() }));
+    });
+  }
+}
+async function main() {
+  initDebugLogger();
+  try {
+    enableConfigs();
+    try {
+      const repairResult = validateAndRepairAllGPT5Profiles();
+      if (repairResult.repaired > 0) {
+        console.log(`\u{1F527} Auto-repaired ${repairResult.repaired} GPT-5 model configurations`);
+      }
+    } catch (repairError) {
+      console.warn("\u26A0\uFE0F GPT-5 configuration validation failed:", repairError);
+    }
+  } catch (error) {
+    if (error instanceof ConfigParseError) {
+      await showInvalidConfigDialog({ error });
+      return;
+    }
+  }
+  let inputPrompt = "";
+  let renderContext = {
+    exitOnCtrlC: false,
+    onFlicker() {
+      logEvent("tengu_flicker", {});
+    }
+  };
+  if (!process.stdin.isTTY && !process.env.CI && // Input hijacking breaks MCP.
+  !process.argv.includes("mcp")) {
+    inputPrompt = await stdin();
+    if (process.platform !== "win32") {
+      try {
+        const ttyFd = openSync("/dev/tty", "r");
+        renderContext = { ...renderContext, stdin: new ReadStream(ttyFd) };
+      } catch (err) {
+        logError(`Could not open /dev/tty: ${err}`);
+      }
+    }
+  }
+  await parseArgs(inputPrompt, renderContext);
+}
+async function parseArgs(stdinContent, renderContext) {
+  const program = new Command();
+  const renderContextWithExitOnCtrlC = {
+    ...renderContext,
+    exitOnCtrlC: true
+  };
+  const commands = await getCommands();
+  const commandList = commands.filter((cmd) => !cmd.isHidden).map((cmd) => `/${cmd.name} - ${cmd.description}`).join("\n");
+  program.name(PRODUCT_COMMAND).description(
+    `${PRODUCT_NAME} - starts an interactive session by default, use -p/--print for non-interactive output
+
+Slash commands available during an interactive session:
+${commandList}`
+  ).argument("[prompt]", "Your prompt", String).option("-c, --cwd <cwd>", "The current working directory", String, cwd()).option("-d, --debug", "Enable debug mode", () => true).option(
+    "--debug-verbose",
+    "Enable verbose debug terminal output",
+    () => true
+  ).option(
+    "--verbose",
+    "Override verbose mode setting from config",
+    () => true
+  ).option("-e, --enable-architect", "Enable the Architect tool", () => true).option(
+    "-p, --print",
+    "Print response and exit (useful for pipes)",
+    () => true
+  ).option(
+    "--safe",
+    "Enable strict permission checking mode (default is permissive)",
+    () => true
+  ).action(
+    async (prompt, { cwd: cwd2, debug, verbose, enableArchitect, print, safe }) => {
+      await showSetupScreens(safe, print);
+      logEvent("tengu_init", {
+        entrypoint: PRODUCT_COMMAND,
+        hasInitialPrompt: Boolean(prompt).toString(),
+        hasStdin: Boolean(stdinContent).toString(),
+        enableArchitect: enableArchitect?.toString() ?? "false",
+        verbose: verbose?.toString() ?? "false",
+        debug: debug?.toString() ?? "false",
+        print: print?.toString() ?? "false"
+      });
+      await setup(cwd2, safe);
+      assertMinVersion();
+      const [tools, mcpClients] = await Promise.all([
+        getTools(
+          enableArchitect ?? getCurrentProjectConfig().enableArchitectTool
+        ),
+        getClients()
+      ]);
+      const inputPrompt = [prompt, stdinContent].filter(Boolean).join("\n");
+      if (print) {
+        if (!inputPrompt) {
+          console.error(
+            "Error: Input must be provided either through stdin or as a prompt argument when using --print"
+          );
+          process.exit(1);
+        }
+        addToHistory(inputPrompt);
+        const { resultText: response } = await ask({
+          commands,
+          hasPermissionsToUseTool,
+          messageLogName: dateToFilename(/* @__PURE__ */ new Date()),
+          prompt: inputPrompt,
+          cwd: cwd2,
+          tools,
+          safeMode: safe
+        });
+        console.log(response);
+        process.exit(0);
+      } else {
+        const isDefaultModel = await isDefaultSlowAndCapableModel();
+        const updateInfo = await (async () => {
+          try {
+            const latest = await getLatestVersion();
+            if (latest && gt(latest, MACRO.VERSION)) {
+              const cmds = await getUpdateCommandSuggestions();
+              return { version: latest, commands: cmds };
+            }
+          } catch {
+          }
+          return { version: null, commands: null };
+        })();
+        {
+          const { render: render2 } = await import("ink");
+          const { REPL } = await import("../screens/REPL.js");
+          render2(
+            /* @__PURE__ */ React.createElement(
+              REPL,
+              {
+                commands,
+                debug,
+                initialPrompt: inputPrompt,
+                messageLogName: dateToFilename(/* @__PURE__ */ new Date()),
+                shouldShowPromptInput: true,
+                verbose,
+                tools,
+                safeMode: safe,
+                mcpClients,
+                isDefaultModel,
+                initialUpdateVersion: updateInfo.version,
+                initialUpdateCommands: updateInfo.commands
+              }
+            ),
+            renderContext
+          );
+        }
+      }
+    }
+  ).version(MACRO.VERSION, "-v, --version");
+  const config = program.command("config").description(
+    `Manage configuration (eg. ${PRODUCT_COMMAND} config set -g theme dark)`
+  );
+  config.command("get <key>").description("Get a config value").option("-c, --cwd <cwd>", "The current working directory", String, cwd()).option("-g, --global", "Use global config").action(async (key, { cwd: cwd2, global }) => {
+    await setup(cwd2, false);
+    console.log(getConfigForCLI(key, global ?? false));
+    process.exit(0);
+  });
+  config.command("set <key> <value>").description("Set a config value").option("-c, --cwd <cwd>", "The current working directory", String, cwd()).option("-g, --global", "Use global config").action(async (key, value, { cwd: cwd2, global }) => {
+    await setup(cwd2, false);
+    setConfigForCLI(key, value, global ?? false);
+    console.log(`Set ${key} to ${value}`);
+    process.exit(0);
+  });
+  config.command("remove <key>").description("Remove a config value").option("-c, --cwd <cwd>", "The current working directory", String, cwd()).option("-g, --global", "Use global config").action(async (key, { cwd: cwd2, global }) => {
+    await setup(cwd2, false);
+    deleteConfigForCLI(key, global ?? false);
+    console.log(`Removed ${key}`);
+    process.exit(0);
+  });
+  config.command("list").description("List all config values").option("-c, --cwd <cwd>", "The current working directory", String, cwd()).option("-g, --global", "Use global config", false).action(async ({ cwd: cwd2, global }) => {
+    await setup(cwd2, false);
+    console.log(
+      JSON.stringify(global ? listConfigForCLI(true) : listConfigForCLI(false), null, 2)
+    );
+    process.exit(0);
+  });
+  const allowedTools = program.command("approved-tools").description("Manage approved tools");
+  allowedTools.command("list").description("List all approved tools").action(async () => {
+    const result = handleListApprovedTools(getCwd());
+    console.log(result);
+    process.exit(0);
+  });
+  allowedTools.command("remove <tool>").description("Remove a tool from the list of approved tools").action(async (tool) => {
+    const result = handleRemoveApprovedTool(tool);
+    logEvent("tengu_approved_tool_remove", {
+      tool,
+      success: String(result.success)
+    });
+    console.log(result.message);
+    process.exit(result.success ? 0 : 1);
+  });
+  const mcp = program.command("mcp").description("Configure and manage MCP servers");
+  mcp.command("serve").description(`Start the ${PRODUCT_NAME} MCP server`).action(async () => {
+    const providedCwd = program.opts().cwd ?? cwd();
+    logEvent("tengu_mcp_start", { providedCwd });
+    if (!existsSync(providedCwd)) {
+      console.error(`Error: Directory ${providedCwd} does not exist`);
+      process.exit(1);
+    }
+    try {
+      await setup(providedCwd, false);
+      await startMCPServer(providedCwd);
+    } catch (error) {
+      console.error("Error: Failed to start MCP server:", error);
+      process.exit(1);
+    }
+  });
+  mcp.command("add-sse <name> <url>").description("Add an SSE server").option(
+    "-s, --scope <scope>",
+    "Configuration scope (project or global)",
+    "project"
+  ).action(async (name, url, options) => {
+    try {
+      const scope = ensureConfigScope(options.scope);
+      logEvent("tengu_mcp_add", { name, type: "sse", scope });
+      addMcpServer(name, { type: "sse", url }, scope);
+      console.log(
+        `Added SSE MCP server ${name} with URL ${url} to ${scope} config`
+      );
+      process.exit(0);
+    } catch (error) {
+      console.error(error.message);
+      process.exit(1);
+    }
+  });
+  mcp.command("add [name] [commandOrUrl] [args...]").description("Add a server (run without arguments for interactive wizard)").option(
+    "-s, --scope <scope>",
+    "Configuration scope (project or global)",
+    "project"
+  ).option(
+    "-e, --env <env...>",
+    "Set environment variables (e.g. -e KEY=value)"
+  ).action(async (name, commandOrUrl, args, options) => {
+    try {
+      if (!name) {
+        console.log("Interactive wizard mode: Enter the server details");
+        const { createInterface } = await import("readline");
+        const rl = createInterface({
+          input: process.stdin,
+          output: process.stdout
+        });
+        const question = (query) => new Promise((resolve) => rl.question(query, resolve));
+        const serverName = await question("Server name: ");
+        if (!serverName) {
+          console.error("Error: Server name is required");
+          rl.close();
+          process.exit(1);
+        }
+        const serverType = await question(
+          "Server type (stdio or sse) [stdio]: "
+        );
+        const type = serverType && ["stdio", "sse"].includes(serverType) ? serverType : "stdio";
+        const prompt = type === "stdio" ? "Command: " : "URL: ";
+        const commandOrUrlValue = await question(prompt);
+        if (!commandOrUrlValue) {
+          console.error(
+            `Error: ${type === "stdio" ? "Command" : "URL"} is required`
+          );
+          rl.close();
+          process.exit(1);
+        }
+        let serverArgs = [];
+        let serverEnv = {};
+        if (type === "stdio") {
+          const argsStr = await question(
+            "Command arguments (space-separated): "
+          );
+          serverArgs = argsStr ? argsStr.split(" ").filter(Boolean) : [];
+          const envStr = await question(
+            "Environment variables (format: KEY1=value1,KEY2=value2): "
+          );
+          if (envStr) {
+            const envPairs = envStr.split(",").map((pair) => pair.trim());
+            serverEnv = parseEnvVars(envPairs.map((pair) => pair));
+          }
+        }
+        const scopeStr = await question(
+          "Configuration scope (project or global) [project]: "
+        );
+        const serverScope = ensureConfigScope(scopeStr || "project");
+        rl.close();
+        if (type === "sse") {
+          logEvent("tengu_mcp_add", {
+            name: serverName,
+            type: "sse",
+            scope: serverScope
+          });
+          addMcpServer(
+            serverName,
+            { type: "sse", url: commandOrUrlValue },
+            serverScope
+          );
+          console.log(
+            `Added SSE MCP server ${serverName} with URL ${commandOrUrlValue} to ${serverScope} config`
+          );
+        } else {
+          logEvent("tengu_mcp_add", {
+            name: serverName,
+            type: "stdio",
+            scope: serverScope
+          });
+          addMcpServer(
+            serverName,
+            {
+              type: "stdio",
+              command: commandOrUrlValue,
+              args: serverArgs,
+              env: serverEnv
+            },
+            serverScope
+          );
+          console.log(
+            `Added stdio MCP server ${serverName} with command: ${commandOrUrlValue} ${serverArgs.join(" ")} to ${serverScope} config`
+          );
+        }
+      } else if (name && commandOrUrl) {
+        const scope = ensureConfigScope(options.scope);
+        if (commandOrUrl.match(/^https?:\/\//)) {
+          logEvent("tengu_mcp_add", { name, type: "sse", scope });
+          addMcpServer(name, { type: "sse", url: commandOrUrl }, scope);
+          console.log(
+            `Added SSE MCP server ${name} with URL ${commandOrUrl} to ${scope} config`
+          );
+        } else {
+          logEvent("tengu_mcp_add", { name, type: "stdio", scope });
+          const env2 = parseEnvVars(options.env);
+          addMcpServer(
+            name,
+            { type: "stdio", command: commandOrUrl, args: args || [], env: env2 },
+            scope
+          );
+          console.log(
+            `Added stdio MCP server ${name} with command: ${commandOrUrl} ${(args || []).join(" ")} to ${scope} config`
+          );
+        }
+      } else {
+        console.error(
+          "Error: Missing required arguments. Either provide no arguments for interactive mode or specify name and command/URL."
+        );
+        process.exit(1);
+      }
+      process.exit(0);
+    } catch (error) {
+      console.error(error.message);
+      process.exit(1);
+    }
+  });
+  mcp.command("remove <name>").description("Remove an MCP server").option(
+    "-s, --scope <scope>",
+    "Configuration scope (project, global, or mcprc)",
+    "project"
+  ).action(async (name, options) => {
+    try {
+      const scope = ensureConfigScope(options.scope);
+      logEvent("tengu_mcp_delete", { name, scope });
+      removeMcpServer(name, scope);
+      console.log(`Removed MCP server ${name} from ${scope} config`);
+      process.exit(0);
+    } catch (error) {
+      console.error(error.message);
+      process.exit(1);
+    }
+  });
+  mcp.command("list").description("List configured MCP servers").action(() => {
+    logEvent("tengu_mcp_list", {});
+    const servers = listMCPServers();
+    if (Object.keys(servers).length === 0) {
+      console.log(
+        `No MCP servers configured. Use \`${PRODUCT_COMMAND} mcp add\` to add a server.`
+      );
+    } else {
+      for (const [name, server] of Object.entries(servers)) {
+        if (server.type === "sse") {
+          console.log(`${name}: ${server.url} (SSE)`);
+        } else {
+          console.log(`${name}: ${server.command} ${server.args.join(" ")}`);
+        }
+      }
+    }
+    process.exit(0);
+  });
+  mcp.command("add-json <name> <json>").description("Add an MCP server (stdio or SSE) with a JSON string").option(
+    "-s, --scope <scope>",
+    "Configuration scope (project or global)",
+    "project"
+  ).action(async (name, jsonStr, options) => {
+    try {
+      const scope = ensureConfigScope(options.scope);
+      let serverConfig;
+      try {
+        serverConfig = JSON.parse(jsonStr);
+      } catch (e) {
+        console.error("Error: Invalid JSON string");
+        process.exit(1);
+      }
+      if (!serverConfig.type || !["stdio", "sse"].includes(serverConfig.type)) {
+        console.error('Error: Server type must be "stdio" or "sse"');
+        process.exit(1);
+      }
+      if (serverConfig.type === "sse" && !serverConfig.url) {
+        console.error("Error: SSE server must have a URL");
+        process.exit(1);
+      }
+      if (serverConfig.type === "stdio" && !serverConfig.command) {
+        console.error("Error: stdio server must have a command");
+        process.exit(1);
+      }
+      logEvent("tengu_mcp_add_json", { name, type: serverConfig.type, scope });
+      addMcpServer(name, serverConfig, scope);
+      if (serverConfig.type === "sse") {
+        console.log(
+          `Added SSE MCP server ${name} with URL ${serverConfig.url} to ${scope} config`
+        );
+      } else {
+        console.log(
+          `Added stdio MCP server ${name} with command: ${serverConfig.command} ${(serverConfig.args || []).join(" ")} to ${scope} config`
+        );
+      }
+      process.exit(0);
+    } catch (error) {
+      console.error(error.message);
+      process.exit(1);
+    }
+  });
+  mcp.command("get <name>").description("Get details about an MCP server").action((name) => {
+    logEvent("tengu_mcp_get", { name });
+    const server = getMcpServer(name);
+    if (!server) {
+      console.error(`No MCP server found with name: ${name}`);
+      process.exit(1);
+    }
+    console.log(`${name}:`);
+    console.log(`  Scope: ${server.scope}`);
+    if (server.type === "sse") {
+      console.log(`  Type: sse`);
+      console.log(`  URL: ${server.url}`);
+    } else {
+      console.log(`  Type: stdio`);
+      console.log(`  Command: ${server.command}`);
+      console.log(`  Args: ${server.args.join(" ")}`);
+      if (server.env) {
+        console.log("  Environment:");
+        for (const [key, value] of Object.entries(server.env)) {
+          console.log(`    ${key}=${value}`);
+        }
+      }
+    }
+    process.exit(0);
+  });
+  mcp.command("add-from-claude-desktop").description(
+    "Import MCP servers from Claude Desktop (Mac, Windows and WSL)"
+  ).option(
+    "-s, --scope <scope>",
+    "Configuration scope (project or global)",
+    "project"
+  ).action(async (options) => {
+    try {
+      const scope = ensureConfigScope(options.scope);
+      const platform = process.platform;
+      const { existsSync: existsSync2, readFileSync } = await import("fs");
+      const { join: join2 } = await import("path");
+      const { exec } = await import("child_process");
+      const isWSL = platform === "linux" && existsSync2("/proc/version") && readFileSync("/proc/version", "utf-8").toLowerCase().includes("microsoft");
+      if (platform !== "darwin" && platform !== "win32" && !isWSL) {
+        console.error(
+          "Error: This command is only supported on macOS, Windows, and WSL"
+        );
+        process.exit(1);
+      }
+      let configPath;
+      if (platform === "darwin") {
+        configPath = join2(
+          process.env.HOME || "~",
+          "Library/Application Support/Claude/claude_desktop_config.json"
+        );
+      } else if (platform === "win32") {
+        configPath = join2(
+          process.env.APPDATA || "",
+          "Claude/claude_desktop_config.json"
+        );
+      } else if (isWSL) {
+        const whoamiCommand = await new Promise((resolve, reject) => {
+          exec(
+            'powershell.exe -Command "whoami"',
+            (err, stdout) => {
+              if (err) reject(err);
+              else resolve(stdout.trim().split("\\").pop() || "");
+            }
+          );
+        });
+        configPath = `/mnt/c/Users/${whoamiCommand}/AppData/Roaming/Claude/claude_desktop_config.json`;
+      }
+      if (!existsSync2(configPath)) {
+        console.error(
+          `Error: Claude Desktop config file not found at ${configPath}`
+        );
+        process.exit(1);
+      }
+      let config2;
+      try {
+        const configContent = readFileSync(configPath, "utf-8");
+        config2 = JSON.parse(configContent);
+      } catch (err) {
+        console.error(`Error reading config file: ${err}`);
+        process.exit(1);
+      }
+      const mcpServers = config2.mcpServers || {};
+      const serverNames = Object.keys(mcpServers);
+      const numServers = serverNames.length;
+      if (numServers === 0) {
+        console.log("No MCP servers found in Claude Desktop config");
+        process.exit(0);
+      }
+      const serversInfo = serverNames.map((name) => {
+        const server = mcpServers[name];
+        let description = "";
+        if (server.type === "sse") {
+          description = `SSE: ${server.url}`;
+        } else {
+          description = `stdio: ${server.command} ${(server.args || []).join(" ")}`;
+        }
+        return { name, description, server };
+      });
+      const ink = await import("ink");
+      const reactModule = await import("react");
+      const inkjsui = await import("@inkjs/ui");
+      const utilsTheme = await import("../utils/theme.js");
+      const { render: render2 } = ink;
+      const React2 = reactModule;
+      const { MultiSelect } = inkjsui;
+      const { Box, Text } = ink;
+      const { getTheme } = utilsTheme;
+      await new Promise((resolve) => {
+        function ClaudeDesktopImport() {
+          const { useState } = reactModule;
+          const [isFinished, setIsFinished] = useState(false);
+          const [importResults, setImportResults] = useState([]);
+          const [isImporting, setIsImporting] = useState(false);
+          const theme = getTheme();
+          const importServers = async (selectedServers) => {
+            setIsImporting(true);
+            const results = [];
+            for (const name of selectedServers) {
+              try {
+                const server = mcpServers[name];
+                const existingServer = getMcpServer(name);
+                if (existingServer) {
+                  continue;
+                }
+                addMcpServer(name, server, scope);
+                results.push({ name, success: true });
+              } catch (err) {
+                results.push({ name, success: false });
+              }
+            }
+            setImportResults(results);
+            setIsImporting(false);
+            setIsFinished(true);
+            setTimeout(() => {
+              resolve();
+            }, 1e3);
+          };
+          const handleConfirm = async (selectedServers) => {
+            const existingServers = selectedServers.filter(
+              (name) => getMcpServer(name)
+            );
+            if (existingServers.length > 0) {
+              const results = [];
+              const newServers = selectedServers.filter(
+                (name) => !getMcpServer(name)
+              );
+              for (const name of newServers) {
+                try {
+                  const server = mcpServers[name];
+                  addMcpServer(name, server, scope);
+                  results.push({ name, success: true });
+                } catch (err) {
+                  results.push({ name, success: false });
+                }
+              }
+              for (const name of existingServers) {
+                try {
+                  const server = mcpServers[name];
+                  addMcpServer(name, server, scope);
+                  results.push({ name, success: true });
+                } catch (err) {
+                  results.push({ name, success: false });
+                }
+              }
+              setImportResults(results);
+              setIsImporting(false);
+              setIsFinished(true);
+              setTimeout(() => {
+                resolve();
+              }, 1e3);
+            } else {
+              await importServers(selectedServers);
+            }
+          };
+          return /* @__PURE__ */ React2.createElement(Box, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React2.createElement(
+            Box,
+            {
+              flexDirection: "column",
+              borderStyle: "round",
+              borderColor: theme.kode,
+              padding: 1,
+              width: "100%"
+            },
+            /* @__PURE__ */ React2.createElement(Text, { bold: true, color: theme.kode }, "Import MCP Servers from Claude Desktop"),
+            /* @__PURE__ */ React2.createElement(Box, { marginY: 1 }, /* @__PURE__ */ React2.createElement(Text, null, "Found ", numServers, " MCP servers in Claude Desktop.")),
+            /* @__PURE__ */ React2.createElement(Text, null, "Please select the servers you want to import:"),
+            /* @__PURE__ */ React2.createElement(Box, { marginTop: 1 }, /* @__PURE__ */ React2.createElement(
+              MultiSelect,
+              {
+                options: serverNames.map((name) => ({
+                  label: name,
+                  value: name
+                })),
+                defaultValue: serverNames,
+                onSubmit: handleConfirm
+              }
+            ))
+          ), /* @__PURE__ */ React2.createElement(Box, { marginTop: 0, marginLeft: 3 }, /* @__PURE__ */ React2.createElement(Text, { dimColor: true }, "Space to select \xB7 Enter to confirm \xB7 Esc to cancel")), isFinished && /* @__PURE__ */ React2.createElement(Box, { marginTop: 1 }, /* @__PURE__ */ React2.createElement(Text, { color: theme.success }, "Successfully imported", " ", importResults.filter((r) => r.success).length, " MCP server to local config.")));
+        }
+        const { unmount } = render2(/* @__PURE__ */ React2.createElement(ClaudeDesktopImport, null));
+        setTimeout(() => {
+          unmount();
+          resolve();
+        }, 3e4);
+      });
+      process.exit(0);
+    } catch (error) {
+      console.error(`Error: ${error.message}`);
+      process.exit(1);
+    }
+  });
+  const resetMcpChoices = () => {
+    const config2 = getCurrentProjectConfig();
+    saveCurrentProjectConfig({
+      ...config2,
+      approvedMcprcServers: [],
+      rejectedMcprcServers: []
+    });
+    console.log("All .mcprc server approvals and rejections have been reset.");
+    console.log(
+      `You will be prompted for approval next time you start ${PRODUCT_NAME}.`
+    );
+    process.exit(0);
+  };
+  mcp.command("reset-project-choices").description(
+    "Reset all approved and rejected project-scoped (.mcp.json) servers within this project"
+  ).action(() => {
+    logEvent("tengu_mcp_reset_project_choices", {});
+    resetMcpChoices();
+  });
+  if (process.env.USER_TYPE === "ant") {
+    mcp.command("reset-mcprc-choices").description(
+      "Reset all approved and rejected .mcprc servers for this project"
+    ).action(() => {
+      logEvent("tengu_mcp_reset_mcprc_choices", {});
+      resetMcpChoices();
+    });
+  }
+  program.command("doctor").description(`Check the health of your ${PRODUCT_NAME} auto-updater`).action(async () => {
+    logEvent("tengu_doctor_command", {});
+    await new Promise((resolve) => {
+      render(/* @__PURE__ */ React.createElement(Doctor, { onDone: () => resolve(), doctorMode: true }));
+    });
+    process.exit(0);
+  });
+  program.command("update").description("Show manual upgrade commands (no auto-install)").action(async () => {
+    logEvent("tengu_update_check", {});
+    console.log(`Current version: ${MACRO.VERSION}`);
+    console.log("Checking for updates...");
+    const latestVersion = await getLatestVersion();
+    if (!latestVersion) {
+      console.error("Failed to check for updates");
+      process.exit(1);
+    }
+    if (latestVersion === MACRO.VERSION) {
+      console.log(`${PRODUCT_NAME} is up to date`);
+      process.exit(0);
+    }
+    console.log(`New version available: ${latestVersion}`);
+    const { getUpdateCommandSuggestions: getUpdateCommandSuggestions2 } = await import("../utils/autoUpdater.js");
+    const cmds = await getUpdateCommandSuggestions2();
+    console.log("\nRun one of the following commands to update:");
+    for (const c of cmds) console.log(`  ${c}`);
+    if (process.platform !== "win32") {
+      console.log('\nNote: you may need to prefix with "sudo" on macOS/Linux.');
+    }
+    process.exit(0);
+  });
+  program.command("log").description("Manage conversation logs.").argument(
+    "[number]",
+    "A number (0, 1, 2, etc.) to display a specific log",
+    parseInt
+  ).option("-c, --cwd <cwd>", "The current working directory", String, cwd()).action(async (number, { cwd: cwd2 }) => {
+    await setup(cwd2, false);
+    logEvent("tengu_view_logs", { number: number?.toString() ?? "" });
+    const context2 = {};
+    const { unmount } = render(
+      /* @__PURE__ */ React.createElement(LogList, { context: context2, type: "messages", logNumber: number }),
+      renderContextWithExitOnCtrlC
+    );
+    context2.unmount = unmount;
+  });
+  program.command("resume").description(
+    "Resume a previous conversation. Optionally provide a number (0, 1, 2, etc.) or file path to resume a specific conversation."
+  ).argument(
+    "[identifier]",
+    "A number (0, 1, 2, etc.) or file path to resume a specific conversation"
+  ).option("-c, --cwd <cwd>", "The current working directory", String, cwd()).option("-e, --enable-architect", "Enable the Architect tool", () => true).option("-v, --verbose", "Do not truncate message output", () => true).option(
+    "--safe",
+    "Enable strict permission checking mode (default is permissive)",
+    () => true
+  ).action(async (identifier, { cwd: cwd2, enableArchitect, safe, verbose }) => {
+    await setup(cwd2, safe);
+    assertMinVersion();
+    const [tools, commands2, logs, mcpClients] = await Promise.all([
+      getTools(
+        enableArchitect ?? getCurrentProjectConfig().enableArchitectTool
+      ),
+      getCommands(),
+      loadLogList(CACHE_PATHS.messages()),
+      getClients()
+    ]);
+    if (identifier !== void 0) {
+      const number = Math.abs(parseInt(identifier));
+      const isNumber = !isNaN(number);
+      let messages, date, forkNumber;
+      try {
+        if (isNumber) {
+          logEvent("tengu_resume", { number: number.toString() });
+          const log = logs[number];
+          if (!log) {
+            console.error("No conversation found at index", number);
+            process.exit(1);
+          }
+          messages = await loadMessagesFromLog(log.fullPath, tools);
+          ({ date, forkNumber } = log);
+        } else {
+          logEvent("tengu_resume", { filePath: identifier });
+          if (!existsSync(identifier)) {
+            console.error("File does not exist:", identifier);
+            process.exit(1);
+          }
+          messages = await loadMessagesFromLog(identifier, tools);
+          const pathSegments = identifier.split("/");
+          const filename = pathSegments[pathSegments.length - 1] ?? "unknown";
+          ({ date, forkNumber } = parseLogFilename(filename));
+        }
+        const fork = getNextAvailableLogForkNumber(date, forkNumber ?? 1, 0);
+        const isDefaultModel = await isDefaultSlowAndCapableModel();
+        {
+          const { render: render2 } = await import("ink");
+          const { REPL } = await import("../screens/REPL.js");
+          render2(
+            /* @__PURE__ */ React.createElement(
+              REPL,
+              {
+                initialPrompt: "",
+                messageLogName: date,
+                initialForkNumber: fork,
+                shouldShowPromptInput: true,
+                verbose,
+                commands: commands2,
+                tools,
+                safeMode: safe,
+                initialMessages: messages,
+                mcpClients,
+                isDefaultModel
+              }
+            ),
+            { exitOnCtrlC: false }
+          );
+        }
+      } catch (error) {
+        logError(`Failed to load conversation: ${error}`);
+        process.exit(1);
+      }
+    } else {
+      const context2 = {};
+      const { unmount } = render(
+        /* @__PURE__ */ React.createElement(
+          ResumeConversation,
+          {
+            context: context2,
+            commands: commands2,
+            logs,
+            tools,
+            verbose
+          }
+        ),
+        renderContextWithExitOnCtrlC
+      );
+      context2.unmount = unmount;
+    }
+  });
+  program.command("error").description(
+    "View error logs. Optionally provide a number (0, -1, -2, etc.) to display a specific log."
+  ).argument(
+    "[number]",
+    "A number (0, 1, 2, etc.) to display a specific log",
+    parseInt
+  ).option("-c, --cwd <cwd>", "The current working directory", String, cwd()).action(async (number, { cwd: cwd2 }) => {
+    await setup(cwd2, false);
+    logEvent("tengu_view_errors", { number: number?.toString() ?? "" });
+    const context2 = {};
+    const { unmount } = render(
+      /* @__PURE__ */ React.createElement(LogList, { context: context2, type: "errors", logNumber: number }),
+      renderContextWithExitOnCtrlC
+    );
+    context2.unmount = unmount;
+  });
+  const context = program.command("context").description(
+    `Set static context (eg. ${PRODUCT_COMMAND} context add-file ./src/*.py)`
+  );
+  context.command("get <key>").option("-c, --cwd <cwd>", "The current working directory", String, cwd()).description("Get a value from context").action(async (key, { cwd: cwd2 }) => {
+    await setup(cwd2, false);
+    logEvent("tengu_context_get", { key });
+    const context2 = omit(
+      await getContext(),
+      "codeStyle",
+      "directoryStructure"
+    );
+    console.log(context2[key]);
+    process.exit(0);
+  });
+  context.command("set <key> <value>").description("Set a value in context").option("-c, --cwd <cwd>", "The current working directory", String, cwd()).action(async (key, value, { cwd: cwd2 }) => {
+    await setup(cwd2, false);
+    logEvent("tengu_context_set", { key });
+    setContext(key, value);
+    console.log(`Set context.${key} to "${value}"`);
+    process.exit(0);
+  });
+  context.command("list").description("List all context values").option("-c, --cwd <cwd>", "The current working directory", String, cwd()).action(async ({ cwd: cwd2 }) => {
+    await setup(cwd2, false);
+    logEvent("tengu_context_list", {});
+    const context2 = omit(
+      await getContext(),
+      "codeStyle",
+      "directoryStructure",
+      "gitStatus"
+    );
+    console.log(JSON.stringify(context2, null, 2));
+    process.exit(0);
+  });
+  context.command("remove <key>").description("Remove a value from context").option("-c, --cwd <cwd>", "The current working directory", String, cwd()).action(async (key, { cwd: cwd2 }) => {
+    await setup(cwd2, false);
+    logEvent("tengu_context_delete", { key });
+    removeContext(key);
+    console.log(`Removed context.${key}`);
+    process.exit(0);
+  });
+  await program.parseAsync(process.argv);
+  return program;
+}
+async function stdin() {
+  if (process.stdin.isTTY) {
+    return "";
+  }
+  let data = "";
+  for await (const chunk of process.stdin) data += chunk;
+  return data;
+}
+process.on("exit", () => {
+  resetCursor();
+  PersistentShell.getInstance().close();
+});
+function gracefulExit(code = 0) {
+  try {
+    resetCursor();
+  } catch {
+  }
+  try {
+    PersistentShell.getInstance().close();
+  } catch {
+  }
+  process.exit(code);
+}
+process.on("SIGINT", () => gracefulExit(0));
+process.on("SIGTERM", () => gracefulExit(0));
+process.on("SIGBREAK", () => gracefulExit(0));
+process.on("unhandledRejection", (err) => {
+  console.error("Unhandled rejection:", err);
+  gracefulExit(1);
+});
+process.on("uncaughtException", (err) => {
+  console.error("Uncaught exception:", err);
+  gracefulExit(1);
+});
+function resetCursor() {
+  const terminal = process.stderr.isTTY ? process.stderr : process.stdout.isTTY ? process.stdout : void 0;
+  terminal?.write(`\x1B[?25h${cursorShow}`);
+}
+main();
+export {
+  completeOnboarding
+};
+//# sourceMappingURL=cli.js.map