@aipack-ai/cli 0.0.1

package/dist/chunk-DWPSBSRO.js

@@ -0,0 +1,1402 @@
+// src/cli.ts
+import chalk7 from "chalk";
+
+// src/commands/approvals.ts
+import path2 from "path";
+import chalk from "chalk";
+import { FileApprovalStore, createApprovalManager } from "@aipack-ai/agent";
+
+// src/version.ts
+import os from "os";
+import path from "path";
+
+// package.json
+var package_default = {
+  name: "@aipack-ai/cli",
+  version: "0.0.1",
+  description: "aipack CLI - \u57FA\u4E8E @aipack-ai/agent \u7684\u7EC8\u7AEF AI \u52A9\u624B",
+  type: "module",
+  main: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  bin: {
+    aipack: "dist/cli.js"
+  },
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  files: [
+    "dist"
+  ],
+  scripts: {
+    build: "tsup",
+    prebuild: "pnpm --filter @aipack-ai/agent build",
+    typecheck: "tsc --noEmit",
+    dev: "tsx src/cli.ts"
+  },
+  keywords: [
+    "cli",
+    "ai",
+    "agent",
+    "llm",
+    "aipack"
+  ],
+  license: "MIT",
+  engines: {
+    node: ">=18.19.0"
+  },
+  dependencies: {
+    "@aipack-ai/agent": "workspace:*",
+    chalk: "^5.3.0"
+  },
+  devDependencies: {
+    "@types/node": "^20.12.0",
+    tsup: "^8.5.1",
+    tsx: "^4.16.0",
+    typescript: "^5.5.0"
+  }
+};
+
+// src/version.ts
+var APP_NAME = package_default.name.replace(/^@[^/]+\//, "");
+var VERSION = package_default.version;
+function defaultConfigDir() {
+  return process.env.AIPACK_CONFIG_DIR ?? path.join(os.homedir(), ".aipack");
+}
+function defaultSessionDir(cwd) {
+  return path.join(defaultConfigDir(), "cli-sessions", encodeDir(cwd));
+}
+function encodeDir(p) {
+  return p.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+
+// src/commands/approvals.ts
+function createStore() {
+  return new FileApprovalStore({
+    baseDir: path2.join(defaultConfigDir(), "approvals")
+  });
+}
+async function handleApprovalsCommand(args) {
+  const [sub, ...rest] = args;
+  if (!sub || sub === "help" || sub === "--help") {
+    printUsage();
+    return 0;
+  }
+  const store = createStore();
+  if (sub === "list") {
+    const pending = await store.load();
+    if (pending.length === 0) {
+      console.log(chalk.dim("\uFF08\u65E0\u672A\u51B3\u5BA1\u6279\u5355\uFF09"));
+      return 0;
+    }
+    for (const p of pending) {
+      printApproval(p);
+    }
+    return 0;
+  }
+  if (sub === "approve" || sub === "deny") {
+    const id = rest[0];
+    if (!id) {
+      console.error(chalk.red(`\u7528\u6CD5: aipack approvals ${sub} <id>`));
+      return 1;
+    }
+    const manager = createApprovalManager({ store });
+    await manager.restore();
+    const ok = manager.resolve(id, sub === "approve");
+    manager.close();
+    if (!ok) {
+      console.error(chalk.yellow(`\u5BA1\u6279\u5355 ${id} \u4E0D\u5B58\u5728\u6216\u5DF2\u7ED3\u7B97`));
+      return 1;
+    }
+    console.log(chalk.green(`\u5DF2${sub === "approve" ? "\u6279\u51C6" : "\u9A73\u56DE"} ${id}`));
+    return 0;
+  }
+  printUsage();
+  console.error(chalk.red(`\u672A\u77E5\u5B50\u547D\u4EE4: ${sub}`));
+  return 1;
+}
+function printApproval(p) {
+  const created = new Date(p.createdAt).toLocaleString();
+  const expires = p.expiresAt ? chalk.dim(` \u8FC7\u671F ${new Date(p.expiresAt).toLocaleTimeString()}`) : "";
+  console.log(`${chalk.cyan(p.id)}  ${chalk.bold(p.toolName)}  ${chalk.dim(created)}${expires}`);
+  if (p.permissions.length > 0) {
+    console.log(chalk.dim(`  \u80FD\u529B: ${p.permissions.join(", ")}`));
+  }
+  const argsStr = JSON.stringify(p.args);
+  if (argsStr && argsStr !== "{}") {
+    console.log(chalk.dim(`  \u53C2\u6570: ${argsStr.length > 120 ? `${argsStr.slice(0, 120)}\u2026` : argsStr}`));
+  }
+}
+function printUsage() {
+  console.log(`\u7528\u6CD5:
+  aipack approvals list              \u5217\u51FA\u672A\u51B3\u5BA1\u6279\u5355
+  aipack approvals approve <id>      \u6279\u51C6
+  aipack approvals deny <id>         \u9A73\u56DE`);
+}
+
+// src/commands/models.ts
+import chalk2 from "chalk";
+import { getBuiltinProviders, getBuiltinModels, hasProviderConfigured } from "@aipack-ai/agent";
+function listModels(search) {
+  const term = typeof search === "string" ? search.toLowerCase() : void 0;
+  let total = 0;
+  for (const provider of getBuiltinProviders()) {
+    const models = getBuiltinModels(provider.id);
+    const matched = term ? models.filter((m) => m.id.toLowerCase().includes(term) || m.name.toLowerCase().includes(term) || provider.id.includes(term)) : models;
+    if (matched.length === 0) continue;
+    const configured = hasProviderConfigured(provider.id);
+    const badge = configured ? chalk2.green("\u2713") : chalk2.dim("\xB7");
+    console.log(`${badge} ${chalk2.bold(provider.name)} ${chalk2.dim(`(${provider.id})`)}`);
+    for (const m of matched) {
+      const flags = [
+        m.reasoning ? chalk2.dim("\u63A8\u7406") : null,
+        `${m.contextWindow / 1e3 | 0}k`
+      ].filter(Boolean).join(" ");
+      console.log(`    ${m.id.padEnd(44)} ${chalk2.dim(flags)}`);
+      total++;
+    }
+  }
+  console.log(chalk2.dim(`
+\u5171 ${total} \u4E2A\u6A21\u578B\u3002\u2713 = \u5DF2\u914D\u7F6E API Key\uFF08${getEnvHint()}\uFF09`));
+  return 0;
+}
+function getEnvHint() {
+  const provider = getBuiltinProviders().find((p) => hasProviderConfigured(p.id));
+  return provider ? `${provider.envVar} \u5DF2\u8BBE\u7F6E` : "\u672A\u68C0\u6D4B\u5230\u4EFB\u4F55 API Key";
+}
+
+// src/args.ts
+var VALID_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "max"];
+function isValidThinkingLevel(level) {
+  return VALID_THINKING_LEVELS.includes(level);
+}
+function parseArgs(args) {
+  const result = {
+    messages: [],
+    fileArgs: [],
+    diagnostics: []
+  };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--help" || arg === "-h") {
+      result.help = true;
+    } else if (arg === "--version" || arg === "-v") {
+      result.version = true;
+    } else if (arg === "--mode" && i + 1 < args.length) {
+      const mode = args[++i];
+      if (mode === "text" || mode === "json") {
+        result.mode = mode;
+      } else {
+        result.diagnostics.push({ type: "error", message: `\u65E0\u6548\u7684 mode: ${mode}\uFF08\u53EF\u9009 text / json\uFF09` });
+      }
+    } else if (arg === "--continue" || arg === "-c") {
+      result.continue = true;
+    } else if (arg === "--resume" || arg === "-r") {
+      result.resume = true;
+    } else if (arg === "--provider" && i + 1 < args.length) {
+      result.provider = args[++i];
+    } else if (arg === "--model" && i + 1 < args.length) {
+      result.model = args[++i];
+    } else if (arg === "--api-key" && i + 1 < args.length) {
+      result.apiKey = args[++i];
+    } else if (arg === "--system-prompt" && i + 1 < args.length) {
+      result.systemPrompt = args[++i];
+    } else if (arg === "--append-system-prompt" && i + 1 < args.length) {
+      result.appendSystemPrompt = result.appendSystemPrompt ?? [];
+      result.appendSystemPrompt.push(args[++i]);
+    } else if (arg === "--thinking" && i + 1 < args.length) {
+      const level = args[++i];
+      if (isValidThinkingLevel(level)) {
+        result.thinking = level;
+      } else {
+        result.diagnostics.push({
+          type: "warning",
+          message: `\u65E0\u6548\u7684\u601D\u8003\u7EA7\u522B "${level}"\u3002\u53EF\u9009: ${VALID_THINKING_LEVELS.join(", ")}`
+        });
+      }
+    } else if (arg === "--name" || arg === "-n") {
+      if (i + 1 < args.length) {
+        result.name = args[++i];
+      } else {
+        result.diagnostics.push({ type: "error", message: "--name \u9700\u8981\u4E00\u4E2A\u503C" });
+      }
+    } else if (arg === "--no-session") {
+      result.noSession = true;
+    } else if (arg === "--session" && i + 1 < args.length) {
+      result.session = args[++i];
+    } else if (arg === "--session-dir" && i + 1 < args.length) {
+      result.sessionDir = args[++i];
+    } else if ((arg === "--tools" || arg === "-t") && i + 1 < args.length) {
+      result.tools = args[++i].split(",").map((s) => s.trim()).filter(Boolean);
+    } else if ((arg === "--exclude-tools" || arg === "-xt") && i + 1 < args.length) {
+      result.excludeTools = args[++i].split(",").map((s) => s.trim()).filter(Boolean);
+    } else if (arg === "--no-tools" || arg === "-nt") {
+      result.noTools = true;
+    } else if (arg === "--safe") {
+      result.safe = true;
+    } else if (arg === "--print" || arg === "-p") {
+      result.print = true;
+      const next = args[i + 1];
+      if (next !== void 0 && !next.startsWith("@") && !next.startsWith("-")) {
+        result.messages.push(next);
+        i++;
+      }
+    } else if (arg === "--list-models") {
+      const next = args[i + 1];
+      if (next !== void 0 && !next.startsWith("-") && !next.startsWith("@")) {
+        result.listModels = next;
+        i++;
+      } else {
+        result.listModels = true;
+      }
+    } else if (arg.startsWith("@")) {
+      result.fileArgs.push(arg.slice(1));
+    } else if (arg.startsWith("--")) {
+      result.diagnostics.push({ type: "error", message: `\u672A\u77E5\u9009\u9879: ${arg}` });
+    } else if (arg.startsWith("-") && arg !== "-") {
+      result.diagnostics.push({ type: "error", message: `\u672A\u77E5\u9009\u9879: ${arg}` });
+    } else {
+      result.messages.push(arg);
+    }
+  }
+  return result;
+}
+function printHelp() {
+  console.log(`${APP_NAME} ${VERSION} - \u57FA\u4E8E @aipack-ai/agent \u7684\u7EC8\u7AEF AI \u52A9\u624B
+
+${"\u7528\u6CD5:"}
+  ${APP_NAME} [\u9009\u9879] [@\u6587\u4EF6...] [\u6D88\u606F...]
+
+${"\u5B50\u547D\u4EE4:"}
+  ${APP_NAME} approvals list              \u5217\u51FA\u672A\u51B3\u5BA1\u6279\u5355
+  ${APP_NAME} approvals approve <id>      \u6279\u51C6\u5BA1\u6279\u5355
+  ${APP_NAME} approvals deny <id>         \u9A73\u56DE\u5BA1\u6279\u5355
+  ${APP_NAME} --list-models [\u641C\u7D22]        \u5217\u51FA\u53EF\u7528\u6A21\u578B
+
+${"\u6A21\u5F0F:"}
+  (\u9ED8\u8BA4)                                \u4EA4\u4E92\u6A21\u5F0F\uFF08REPL\uFF09
+  --print, -p [\u6D88\u606F]                    \u975E\u4EA4\u4E92\uFF1A\u5904\u7406\u4E00\u6B21\u63D0\u793A\u540E\u9000\u51FA\uFF08\u652F\u6301\u7BA1\u9053 stdin\uFF09
+  --mode json                           \u4EE5 JSON \u884C\u8F93\u51FA\u5168\u90E8\u6D41\u5F0F\u4E8B\u4EF6
+
+${"\u6A21\u578B\u9009\u9879:"}
+  --provider <\u540D\u79F0>                     \u63D0\u4F9B\u5546\uFF08openai/deepseek/anthropic/google...\uFF09
+  --model <id>                          \u6A21\u578B ID\uFF0C\u652F\u6301 provider/id \u7EC4\u5408\u5199\u6CD5
+  --api-key <key>                       API Key\uFF08\u8986\u76D6\u73AF\u5883\u53D8\u91CF\uFF09
+  --thinking <\u7EA7\u522B>                     \u601D\u8003\u7EA7\u522B: off/minimal/low/medium/high/max
+
+${"\u4F1A\u8BDD\u9009\u9879:"}
+  --continue, -c                        \u7EE7\u7EED\u5F53\u524D\u76EE\u5F55\u6700\u8FD1\u7684\u4F1A\u8BDD
+  --resume, -r                          \u6D4F\u89C8\u5E76\u9009\u62E9\u5386\u53F2\u4F1A\u8BDD
+  --session <\u540D\u79F0>                      \u4F7F\u7528\u6307\u5B9A\u4F1A\u8BDD
+  --name, -n <\u540D\u79F0>                     \u4E3A\u65B0\u4F1A\u8BDD\u547D\u540D
+  --session-dir <\u76EE\u5F55>                  \u81EA\u5B9A\u4E49\u4F1A\u8BDD\u5B58\u50A8\u76EE\u5F55
+  --no-session                          \u4E34\u65F6\u4F1A\u8BDD\uFF08\u4E0D\u6301\u4E45\u5316\uFF09
+
+${"\u5DE5\u5177\u9009\u9879:"}
+  --tools, -t <\u5217\u8868>                    \u5DE5\u5177\u767D\u540D\u5355\uFF08\u9017\u53F7\u5206\u9694\uFF09
+  --exclude-tools, -xt <\u5217\u8868>           \u5DE5\u5177\u9ED1\u540D\u5355\uFF08\u9017\u53F7\u5206\u9694\uFF09
+  --no-tools, -nt                       \u7981\u7528\u5168\u90E8\u5DE5\u5177
+  --safe                                \u4FDD\u5B88\u6A21\u5F0F\uFF1A\u5199\u6587\u4EF6/shell \u5168\u90E8\u4EBA\u5DE5\u786E\u8BA4
+
+  \u5185\u7F6E\u5DE5\u5177: read, write, edit, bash
+  \u9ED8\u8BA4\u6743\u9650: \u8BFB\u5199\u6587\u4EF6\u9759\u9ED8\u653E\u884C\uFF08\u5DE5\u4F5C\u533A\u8303\u56F4\u5185\uFF09\uFF1Bbash \u4EC5\u5371\u9669\u547D\u4EE4
+            \uFF08sudo\u3001rm -rf ~\u3001\u78C1\u76D8\u5199\u5165\u3001\u8FDC\u7A0B\u811A\u672C\u7BA1\u9053\u7B49\uFF09\u9700\u786E\u8BA4
+
+${"\u5176\u4ED6:"}
+  --system-prompt <\u6587\u672C>                \u66FF\u6362\u9ED8\u8BA4\u7CFB\u7EDF\u63D0\u793A\u8BCD
+  --append-system-prompt <\u6587\u672C>         \u8FFD\u52A0\u7CFB\u7EDF\u63D0\u793A\u8BCD\uFF08\u53EF\u591A\u6B21\uFF09
+  --help, -h                            \u663E\u793A\u5E2E\u52A9
+  --version, -v                         \u663E\u793A\u7248\u672C
+
+${"\u793A\u4F8B:"}
+  # \u4EA4\u4E92\u6A21\u5F0F
+  ${APP_NAME}
+
+  # \u975E\u4EA4\u4E92\u5355\u6B21\u63D0\u95EE\uFF08\u652F\u6301\u7BA1\u9053\uFF09
+  cat README.md | ${APP_NAME} -p "\u603B\u7ED3\u8FD9\u6BB5\u6587\u672C"
+
+  # \u6307\u5B9A\u6A21\u578B
+  ${APP_NAME} --provider deepseek --model deepseek-chat "\u4F60\u597D"
+
+  # provider/id \u7EC4\u5408\u5199\u6CD5
+  ${APP_NAME} --model anthropic/claude-sonnet-4-20250514 "\u5E2E\u6211\u91CD\u6784\u4EE3\u7801"
+
+  # \u9644\u5E26\u6587\u4EF6\u4E0A\u4E0B\u6587
+  ${APP_NAME} @package.json "\u5206\u6790\u8FD9\u4E2A\u6587\u4EF6\u7684\u4F9D\u8D56"
+
+  # \u7EE7\u7EED\u4E0A\u6B21\u4F1A\u8BDD
+  ${APP_NAME} -c "\u6211\u4EEC\u521A\u624D\u804A\u5230\u54EA\u91CC\u4E86\uFF1F"
+
+  # \u53EA\u8BFB\u6A21\u5F0F
+  ${APP_NAME} --tools read -p "\u5BA1\u67E5 src/ \u4E0B\u7684\u4EE3\u7801"
+
+${"\u73AF\u5883\u53D8\u91CF:"}
+  OPENAI_API_KEY / DEEPSEEK_API_KEY / ANTHROPIC_API_KEY / GOOGLE_API_KEY ...
+  AIPACK_CONFIG_DIR                       \u914D\u7F6E\u76EE\u5F55\uFF08\u9ED8\u8BA4 ~/.aipack\uFF09
+`);
+}
+
+// src/builder.ts
+import fs2 from "fs/promises";
+import path4 from "path";
+import { pathToFileURL } from "url";
+import {
+  createRuntime,
+  adaptAiModel,
+  createStreamFnFromAi,
+  getBuiltinModel,
+  getBuiltinModels as getBuiltinModels2,
+  getBuiltinProviders as getBuiltinProviders2,
+  BUILTIN_PROVIDERS,
+  hasProviderConfigured as hasProviderConfigured2,
+  createFileSessionStorage,
+  createPermissionPolicy,
+  createApprovalManager as createApprovalManager2,
+  FileApprovalStore as FileApprovalStore2
+} from "@aipack-ai/agent";
+
+// src/tools.ts
+import fs from "fs/promises";
+import path3 from "path";
+import { spawn } from "child_process";
+var workspaceRoot = process.cwd();
+function resolveInWorkspace(p) {
+  const abs = path3.resolve(workspaceRoot, p);
+  if (!abs.startsWith(workspaceRoot)) {
+    throw new Error(`\u8DEF\u5F84\u8D8A\u754C\uFF1A${p}\uFF08\u5DE5\u4F5C\u533A\uFF1A${workspaceRoot}\uFF09`);
+  }
+  return abs;
+}
+function textResult(text, details) {
+  return { content: [{ type: "text", text }], details: details ?? {} };
+}
+function errorResult(message) {
+  return {
+    content: [{ type: "text", text: `\u9519\u8BEF: ${message}` }],
+    details: { error: message }
+  };
+}
+var MAX_READ_CHARS = 1e5;
+var readTool = {
+  name: "read",
+  description: "\u8BFB\u53D6\u6587\u4EF6\u5185\u5BB9\u3002\u8FD4\u56DE\u6587\u672C\u5185\u5BB9\uFF0C\u8D85\u957F\u81EA\u52A8\u622A\u65AD\u3002",
+  parameters: {
+    type: "object",
+    properties: {
+      file: { type: "string", description: "\u6587\u4EF6\u8DEF\u5F84\uFF08\u76F8\u5BF9\u5DE5\u4F5C\u533A\uFF09" },
+      offset: { type: "number", description: "\u8D77\u59CB\u884C\u53F7\uFF08\u4ECE 1 \u5F00\u59CB\uFF0C\u53EF\u9009\uFF09" },
+      limit: { type: "number", description: "\u8BFB\u53D6\u884C\u6570\uFF08\u53EF\u9009\uFF09" }
+    },
+    required: ["file"]
+  },
+  permissions: ["fs:read"],
+  async execute(_id, rawArgs) {
+    const args = rawArgs;
+    try {
+      const abs = resolveInWorkspace(args.file);
+      let content = await fs.readFile(abs, "utf8");
+      if (args.offset !== void 0 || args.limit !== void 0) {
+        const lines = content.split("\n");
+        const start = Math.max(0, (args.offset ?? 1) - 1);
+        const end = args.limit !== void 0 ? start + args.limit : lines.length;
+        content = lines.slice(start, end).join("\n");
+      }
+      if (content.length > MAX_READ_CHARS) {
+        content = content.slice(0, MAX_READ_CHARS) + `
+...[\u622A\u65AD\uFF0C\u5171 ${content.length} \u5B57\u7B26]`;
+      }
+      return textResult(content, { file: args.file, truncated: content.length >= MAX_READ_CHARS });
+    } catch (err) {
+      return errorResult(String(err instanceof Error ? err.message : err));
+    }
+  }
+};
+var writeTool = {
+  name: "write",
+  description: "\u5199\u5165\u6587\u4EF6\uFF08\u521B\u5EFA\u6216\u8986\u76D6\uFF09\u3002\u81EA\u52A8\u521B\u5EFA\u7236\u76EE\u5F55\u3002",
+  parameters: {
+    type: "object",
+    properties: {
+      file: { type: "string", description: "\u6587\u4EF6\u8DEF\u5F84\uFF08\u76F8\u5BF9\u5DE5\u4F5C\u533A\uFF09" },
+      content: { type: "string", description: "\u5B8C\u6574\u6587\u4EF6\u5185\u5BB9" }
+    },
+    required: ["file", "content"]
+  },
+  permissions: ["fs:write"],
+  async execute(_id, rawArgs) {
+    const args = rawArgs;
+    try {
+      const abs = resolveInWorkspace(args.file);
+      await fs.mkdir(path3.dirname(abs), { recursive: true });
+      await fs.writeFile(abs, args.content, "utf8");
+      return textResult(`\u5DF2\u5199\u5165 ${args.file}\uFF08${args.content.length} \u5B57\u7B26\uFF09`, { file: args.file });
+    } catch (err) {
+      return errorResult(String(err instanceof Error ? err.message : err));
+    }
+  }
+};
+var editTool = {
+  name: "edit",
+  description: "\u7F16\u8F91\u6587\u4EF6\uFF1A\u5C06 oldString \u7684\u9996\u6B21\u51FA\u73B0\u66FF\u6362\u4E3A newString\u3002oldString \u5FC5\u987B\u552F\u4E00\u5339\u914D\u3002",
+  parameters: {
+    type: "object",
+    properties: {
+      file: { type: "string", description: "\u6587\u4EF6\u8DEF\u5F84\uFF08\u76F8\u5BF9\u5DE5\u4F5C\u533A\uFF09" },
+      oldString: { type: "string", description: "\u88AB\u66FF\u6362\u7684\u6587\u672C\uFF08\u987B\u5728\u6587\u4EF6\u4E2D\u552F\u4E00\uFF09" },
+      newString: { type: "string", description: "\u66FF\u6362\u540E\u7684\u6587\u672C" }
+    },
+    required: ["file", "oldString", "newString"]
+  },
+  permissions: ["fs:write"],
+  async execute(_id, rawArgs) {
+    const args = rawArgs;
+    try {
+      const abs = resolveInWorkspace(args.file);
+      const content = await fs.readFile(abs, "utf8");
+      const first = content.indexOf(args.oldString);
+      if (first === -1) {
+        return errorResult(`\u5728 ${args.file} \u4E2D\u672A\u627E\u5230 oldString`);
+      }
+      if (content.indexOf(args.oldString, first + 1) !== -1) {
+        return errorResult(`oldString \u5728 ${args.file} \u4E2D\u51FA\u73B0\u591A\u6B21\uFF0C\u8BF7\u63D0\u4F9B\u66F4\u957F\u7684\u4E0A\u4E0B\u6587\u4F7F\u5176\u552F\u4E00`);
+      }
+      const updated = content.slice(0, first) + args.newString + content.slice(first + args.oldString.length);
+      await fs.writeFile(abs, updated, "utf8");
+      return textResult(`\u5DF2\u7F16\u8F91 ${args.file}`, { file: args.file });
+    } catch (err) {
+      return errorResult(String(err instanceof Error ? err.message : err));
+    }
+  }
+};
+function runShell(command, timeoutMs) {
+  return new Promise((resolve) => {
+    const child = spawn(command, {
+      shell: process.env.SHELL ?? "/bin/bash",
+      cwd: workspaceRoot,
+      env: { ...process.env, AIPACK_CLI: "true" },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (!settled) {
+        settled = true;
+        child.kill("SIGKILL");
+        resolve({ stdout, stderr: stderr + `
+[\u547D\u4EE4\u8D85\u65F6\uFF08${timeoutMs}ms\uFF09\u88AB\u7EC8\u6B62]`, code: 124 });
+      }
+    }, timeoutMs);
+    child.stdout.on("data", (d) => {
+      stdout += d.toString();
+    });
+    child.stderr.on("data", (d) => {
+      stderr += d.toString();
+    });
+    child.on("close", (code) => {
+      if (!settled) {
+        settled = true;
+        clearTimeout(timer);
+        resolve({ stdout, stderr, code: code ?? 0 });
+      }
+    });
+    child.on("error", (err) => {
+      if (!settled) {
+        settled = true;
+        clearTimeout(timer);
+        resolve({ stdout, stderr: String(err), code: -1 });
+      }
+    });
+  });
+}
+var bashTool = {
+  name: "bash",
+  description: "\u5728\u5DE5\u4F5C\u533A\u6267\u884C shell \u5757\u547D\u4EE4\u5E76\u8FD4\u56DE\u8F93\u51FA\u3002\u9002\u7528\u4E8E\u6587\u4EF6\u641C\u7D22\u3001\u6784\u5EFA\u3001\u6D4B\u8BD5\u7B49\u64CD\u4F5C\u3002",
+  parameters: {
+    type: "object",
+    properties: {
+      command: { type: "string", description: "\u8981\u6267\u884C\u7684\u547D\u4EE4" },
+      timeoutMs: { type: "number", description: "\u8D85\u65F6\u6BEB\u79D2\u6570\uFF08\u9ED8\u8BA4 60000\uFF09" }
+    },
+    required: ["command"]
+  },
+  permissions: ["shell:exec"],
+  async execute(_id, rawArgs) {
+    const args = rawArgs;
+    const timeout = args.timeoutMs ?? 6e4;
+    try {
+      const { stdout, stderr, code } = await runShell(args.command, timeout);
+      const parts = [];
+      if (stdout.trim()) parts.push(`[stdout]
+${stdout.slice(0, MAX_READ_CHARS)}`);
+      if (stderr.trim()) parts.push(`[stderr]
+${stderr.slice(0, MAX_READ_CHARS)}`);
+      parts.push(`[\u9000\u51FA\u7801 ${code}]`);
+      return textResult(parts.join("\n"), { command: args.command, code });
+    } catch (err) {
+      return errorResult(String(err instanceof Error ? err.message : err));
+    }
+  }
+};
+var BUILTIN_TOOLS = [readTool, writeTool, editTool, bashTool];
+function selectTools(options) {
+  if (options.noTools) return [];
+  let selected = [...BUILTIN_TOOLS];
+  if (options.tools && options.tools.length > 0) {
+    const allow = new Set(options.tools);
+    selected = selected.filter((t) => allow.has(t.name));
+  }
+  if (options.excludeTools && options.excludeTools.length > 0) {
+    const deny = new Set(options.excludeTools);
+    selected = selected.filter((t) => !deny.has(t.name));
+  }
+  return selected;
+}
+
+// src/builder.ts
+async function loadConfig(cwd) {
+  for (const file of ["aipack.config.js", "aipack.config.mjs"]) {
+    const full = path4.join(cwd, file);
+    try {
+      await fs2.access(full);
+      const mod = await import(pathToFileURL(full).href);
+      const config = mod.default ?? mod;
+      return config ?? {};
+    } catch {
+    }
+  }
+  return {};
+}
+function splitModelSpec(args) {
+  if (args.model && args.model.includes("/")) {
+    const idx = args.model.indexOf("/");
+    return { provider: args.model.slice(0, idx), modelId: args.model.slice(idx + 1) };
+  }
+  return { provider: args.provider, modelId: args.model };
+}
+function detectDefaultProvider() {
+  for (const p of getBuiltinProviders2()) {
+    if (hasProviderConfigured2(p.id)) {
+      const models = getBuiltinModels2(p.id);
+      if (models.length > 0) return { id: p.id, modelId: models[0].id };
+    }
+  }
+  return { id: "openai", modelId: "gpt-4o-mini" };
+}
+function buildCustomModel(providerId, modelId) {
+  const meta = BUILTIN_PROVIDERS.find((p) => p.id === providerId);
+  const api = providerId === "anthropic" ? "anthropic-messages" : "openai-completions";
+  return {
+    id: modelId,
+    name: modelId,
+    provider: providerId,
+    api,
+    baseUrl: meta?.baseUrl,
+    reasoning: false,
+    input: ["text"],
+    contextWindow: 128e3,
+    maxTokens: 16384
+  };
+}
+function resolveModel(args) {
+  const spec = splitModelSpec(args);
+  const fallback = detectDefaultProvider();
+  const providerId = spec.provider ?? fallback.id;
+  const modelId = spec.modelId ?? fallback.modelId;
+  const builtin = getBuiltinModel(providerId, modelId);
+  if (builtin) return { aiModel: builtin, custom: false };
+  return { aiModel: buildCustomModel(providerId, modelId), custom: true };
+}
+async function listSessionsByRecency(storage) {
+  const keys = await storage.list();
+  const entries = await Promise.all(
+    keys.slice(0, 200).map(async (key) => {
+      const s = await storage.load(key);
+      return { key, updatedAt: s?.updatedAt ?? "" };
+    })
+  );
+  return entries.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt)).map((e) => e.key);
+}
+async function resolveSessionKey(args, storage) {
+  if (args.noSession) return { sessionKey: `ephemeral-${Date.now().toString(36)}`, resumed: false };
+  if (args.session) return { sessionKey: sanitizeKey(args.session), resumed: true };
+  if (args.name) return { sessionKey: sanitizeKey(args.name), resumed: false };
+  if (args.continue && storage) {
+    const recent = await listSessionsByRecency(storage);
+    if (recent.length > 0) return { sessionKey: recent[0], resumed: true };
+  }
+  return { sessionKey: `s-${Date.now().toString(36)}`, resumed: false };
+}
+function sanitizeKey(name) {
+  return name.replace(/[^a-zA-Z0-9_\-:.]/g, "_");
+}
+var DEFAULT_APPROVAL_CAPABILITIES = ["fs:write", "shell:exec"];
+async function buildRuntime(options) {
+  const { args, cwd } = options;
+  const config = await loadConfig(cwd);
+  const model = resolveModel(args);
+  const streamFn = createStreamFnFromAi(model.aiModel, {
+    apiKey: args.apiKey
+  });
+  const tools = selectTools({
+    tools: args.tools,
+    excludeTools: args.excludeTools,
+    noTools: args.noTools
+  });
+  const storage = args.noSession ? void 0 : createFileSessionStorage({
+    baseDir: args.sessionDir ?? defaultSessionDir(cwd)
+  });
+  const session = await resolveSessionKey(args, storage);
+  const approvalsEnabled = options.approvalsEnabled ?? config.approvals?.enabled === true;
+  const approvalCaps = new Set(config.approvals?.capabilities ?? DEFAULT_APPROVAL_CAPABILITIES);
+  let approvalManager;
+  if (approvalsEnabled) {
+    approvalManager = createApprovalManager2({
+      store: new FileApprovalStore2({
+        baseDir: path4.join(defaultConfigDir(), "approvals")
+      })
+    });
+    await approvalManager.restore();
+  }
+  const policy = buildPermissionPolicy({
+    config,
+    approvalCaps,
+    approvalsEnabled,
+    safe: args.safe === true,
+    confirmFn: options.confirmFn
+  });
+  const systemPrompt = buildSystemPrompt(args);
+  const runtime = await createRuntime({
+    model: adaptAiModel(model.aiModel),
+    streamFn,
+    systemPrompt,
+    tools,
+    workspace: cwd,
+    config: { cli: true, version: VERSION, cwd },
+    sessionStorage: storage,
+    thinkingLevel: args.thinking,
+    permissionPolicy: policy,
+    approvals: approvalManager,
+    maxTurns: 50,
+    compaction: { enabled: true }
+  });
+  return {
+    runtime,
+    sessionKey: session.sessionKey,
+    storage,
+    approvalManager,
+    model,
+    config
+  };
+}
+function buildPermissionPolicy(opts) {
+  const { config, approvalCaps, approvalsEnabled, safe, confirmFn } = opts;
+  const customRules = (config.permissionRules ?? []).map((r) => ({
+    name: `config:${r.permission ?? r.toolName ?? "*"}`,
+    toolName: r.toolName ? new RegExp(`^${r.toolName}$`) : void 0,
+    permission: r.permission,
+    decision: r.decision
+  }));
+  const highRiskRules = [...approvalCaps].flatMap((cap) => {
+    let decision;
+    if (approvalsEnabled) decision = "pending";
+    else if (safe) decision = "confirm";
+    else decision = cap === "fs:write" ? "allow" : "confirm";
+    return [{ name: `builtin:${cap}:${decision}`, permission: cap, decision }];
+  });
+  return createPermissionPolicy({
+    rules: [
+      ...customRules,
+      ...highRiskRules,
+      { name: "builtin:read", permission: "fs:read", decision: "allow" },
+      // 未声明 permissions 的安全工具放行
+      { name: "builtin:safe-tools", decision: "allow" }
+    ],
+    confirmFn,
+    defaultDecision: "deny"
+  });
+}
+function buildSystemPrompt(args) {
+  const base = args.systemPrompt ?? [
+    "\u4F60\u662F aipack\uFF0C\u4E00\u4E2A\u7EC8\u7AEF\u91CC\u7684 AI \u7F16\u7A0B\u52A9\u624B\u3002",
+    "\u4F60\u53EF\u4EE5\u4F7F\u7528\u5DE5\u5177\u8BFB\u5199\u6587\u4EF6\u3001\u6267\u884C\u547D\u4EE4\u6765\u5B8C\u6210\u7528\u6237\u7684\u4EFB\u52A1\u3002",
+    "\u56DE\u7B54\u4FDD\u6301\u7B80\u6D01\u3001\u6280\u672F\u5316\uFF0C\u4F7F\u7528\u4E0E\u7528\u6237\u76F8\u540C\u7684\u8BED\u8A00\u3002"
+  ].join("\n");
+  const appended = args.appendSystemPrompt ?? [];
+  return [base, ...appended].join("\n\n");
+}
+
+// src/initial-message.ts
+import fs3 from "fs/promises";
+import path5 from "path";
+var IMAGE_EXT = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp"]);
+async function buildInitialMessage(messages, fileArgs, stdinText) {
+  const parts = [];
+  const media = [];
+  for (const file of fileArgs) {
+    const abs = path5.resolve(process.cwd(), file);
+    const ext = path5.extname(abs).toLowerCase();
+    try {
+      if (IMAGE_EXT.has(ext)) {
+        const buf = await fs3.readFile(abs);
+        media.push(`data:image/${ext.slice(1)};base64,${buf.toString("base64")}`);
+      } else {
+        const content = await fs3.readFile(abs, "utf8");
+        parts.push(`--- \u6587\u4EF6: ${file} ---
+${content}
+--- \u7ED3\u675F ---`);
+      }
+    } catch (err) {
+      parts.push(`[\u6587\u4EF6 ${file} \u8BFB\u53D6\u5931\u8D25: ${err instanceof Error ? err.message : err}]`);
+    }
+  }
+  if (stdinText && stdinText.trim()) {
+    parts.push(`--- stdin ---
+${stdinText.trim()}
+--- \u7ED3\u675F ---`);
+  }
+  if (messages.length > 0) {
+    parts.unshift(messages.join("\n"));
+  }
+  return { text: parts.join("\n\n"), media };
+}
+
+// src/modes/print.ts
+import chalk4 from "chalk";
+
+// src/modes/render.ts
+import chalk3 from "chalk";
+var ChunkRenderer = class {
+  constructor(opts = {}) {
+    this.opts = opts;
+  }
+  opts;
+  thinkingShown = false;
+  inTool = false;
+  render(chunk) {
+    const err = this.opts.toolStream ?? process.stdout;
+    switch (chunk.type) {
+      case "text":
+        if (chunk.content) process.stdout.write(chunk.content);
+        break;
+      case "thinking": {
+        if (this.opts.showThinking && chunk.content) {
+          process.stdout.write(chalk3.dim(chunk.content));
+        } else if (!this.thinkingShown) {
+          this.thinkingShown = true;
+          err.write(chalk3.dim("  (\u601D\u8003\u4E2D...)\n"));
+        }
+        break;
+      }
+      case "tool_start":
+        this.inTool = true;
+        err.write(chalk3.cyan(`
+\u2699 ${chunk.toolName} `));
+        break;
+      case "tool_end":
+        if (this.inTool) {
+          err.write(chunk.isError ? chalk3.red(" \u2717\n") : chalk3.green(" \u2713\n"));
+          this.inTool = false;
+        }
+        break;
+      case "error":
+        err.write(chalk3.red(`
+\u9519\u8BEF: ${chunk.content ?? "\u672A\u77E5\u9519\u8BEF"}
+`));
+        break;
+      case "done":
+        process.stdout.write("\n");
+        break;
+    }
+  }
+  reset() {
+    this.thinkingShown = false;
+    this.inTool = false;
+  }
+};
+
+// src/modes/print.ts
+async function runPrintMode(runtime, request) {
+  const renderer = new ChunkRenderer({ toolStream: process.stderr });
+  let error;
+  try {
+    for await (const chunk of runtime.stream(request)) {
+      if (chunk.type === "error") error = chunk.content;
+      renderer.render(chunk);
+    }
+  } catch (err) {
+    process.stderr.write(chalk4.red(`\u9519\u8BEF: ${err instanceof Error ? err.message : String(err)}
+`));
+    process.exitCode = 1;
+    return;
+  }
+  if (error) process.exitCode = 1;
+}
+
+// src/modes/json.ts
+async function runJsonMode(runtime, request) {
+  let sawError = false;
+  try {
+    for await (const chunk of runtime.stream(request)) {
+      if (chunk.type === "error") sawError = true;
+      const line = JSON.stringify({
+        type: chunk.type,
+        content: chunk.content,
+        toolName: chunk.toolName,
+        toolCallId: chunk.toolCallId,
+        isError: chunk.isError,
+        timestamp: Date.now()
+      });
+      process.stdout.write(`${line}
+`);
+    }
+    if (sawError) process.exitCode = 1;
+  } catch (err) {
+    process.stdout.write(`${JSON.stringify({
+      type: "error",
+      content: err instanceof Error ? err.message : String(err),
+      timestamp: Date.now()
+    })}
+`);
+    process.exitCode = 1;
+  }
+}
+
+// src/modes/interactive.ts
+import readline2 from "readline";
+import chalk5 from "chalk";
+import {
+  getBuiltinModels as getBuiltinModels3,
+  adaptAiModel as adaptAiModel2
+} from "@aipack-ai/agent";
+
+// src/prompt.ts
+import readline from "readline";
+function ask(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+function readStreamAll(stream) {
+  return new Promise((resolve) => {
+    let data = "";
+    stream.setEncoding?.("utf8");
+    stream.on("data", (chunk) => {
+      data += chunk;
+    });
+    stream.on("end", () => resolve(data));
+    stream.on("error", () => resolve(data));
+  });
+}
+
+// src/modes/interactive.ts
+var VALID_THINKING = /* @__PURE__ */ new Set(["off", "minimal", "low", "medium", "high", "max"]);
+async function runInteractiveMode(opts) {
+  const { runtime, sessionKey, model, args, storage, approvalManager } = opts;
+  let activeKey = sessionKey;
+  if (args.resume && storage) {
+    const picked = await pickSessionInteractively(storage, sessionKey);
+    if (picked) activeKey = picked;
+  }
+  const renderer = new ChunkRenderer();
+  let busy = false;
+  let sigintCount = 0;
+  let finish;
+  const finished = new Promise((resolve) => {
+    finish = resolve;
+  });
+  function cleanup() {
+    finish();
+  }
+  let rl;
+  let recreating = false;
+  function setupRl() {
+    rl = readline2.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      prompt: chalk5.blue("aipack> ")
+    });
+    rl.on("SIGINT", () => {
+      if (busy) {
+        console.log(chalk5.yellow("\n\u4E2D\u65AD\u5F53\u524D\u8FD0\u884C..."));
+        runtime.abort(activeKey);
+        return;
+      }
+      sigintCount++;
+      if (sigintCount >= 2) {
+        console.log(chalk5.dim("\n\u518D\u89C1"));
+        rl.close();
+      } else {
+        console.log(chalk5.dim("\uFF08\u518D\u6309\u4E00\u6B21 Ctrl+C \u9000\u51FA\uFF09"));
+        rl.prompt();
+        setTimeout(() => {
+          sigintCount = 0;
+        }, 1500);
+      }
+    });
+    rl.on("close", () => {
+      if (!recreating) cleanup();
+    });
+    rl.on("line", onLine);
+    rl.prompt();
+  }
+  async function send(text) {
+    if (!text.trim()) return;
+    busy = true;
+    sigintCount = 0;
+    renderer.reset();
+    const request = {
+      message: text,
+      type: "message",
+      channel: "cli",
+      sessionKey: activeKey,
+      ephemeral: args.noSession
+    };
+    try {
+      for await (const chunk of runtime.stream(request)) {
+        renderer.render(chunk);
+      }
+    } catch (err) {
+      console.log(chalk5.red(`\u9519\u8BEF: ${err instanceof Error ? err.message : String(err)}`));
+    } finally {
+      busy = false;
+      rl.prompt();
+    }
+  }
+  async function handleCommand(line) {
+    const spaceIdx = line.indexOf(" ");
+    const cmd = (spaceIdx === -1 ? line : line.slice(0, spaceIdx)).toLowerCase();
+    const rest = spaceIdx === -1 ? "" : line.slice(spaceIdx + 1).trim();
+    switch (cmd) {
+      case "/help":
+        printSlashHelp();
+        break;
+      case "/quit":
+      case "/exit":
+        rl.close();
+        return;
+      case "/model": {
+        if (!rest) {
+          console.log(chalk5.dim(`\u5F53\u524D\u6A21\u578B: ${model.aiModel.provider}/${model.aiModel.id}`));
+          console.log(chalk5.dim("\u7528\u6CD5: /model provider/model-id\uFF08\u5982 /model deepseek/deepseek-chat\uFF09"));
+          break;
+        }
+        const slash = rest.indexOf("/");
+        const provider = slash === -1 ? model.aiModel.provider : rest.slice(0, slash);
+        const id = slash === -1 ? rest : rest.slice(slash + 1);
+        const found = getBuiltinModels3(provider).find((m) => m.id === id);
+        if (!found) {
+          console.log(chalk5.yellow(`\u672A\u627E\u5230\u5185\u7F6E\u6A21\u578B ${provider}/${id}\uFF0C\u53EF\u7528:`));
+          console.log(getBuiltinModels3(provider).map((m) => `  ${m.id}`).join("\n") || "  (\u65E0)");
+          break;
+        }
+        runtime.setModel(adaptAiModel2(found));
+        model.aiModel = found;
+        model.custom = false;
+        console.log(chalk5.green(`\u5DF2\u5207\u6362\u5230 ${provider}/${id}`));
+        break;
+      }
+      case "/thinking": {
+        if (!VALID_THINKING.has(rest)) {
+          console.log(chalk5.dim("\u7528\u6CD5: /thinking <off|minimal|low|medium|high|max>"));
+          break;
+        }
+        runtime.setThinkingLevel(rest);
+        console.log(chalk5.green(`\u601D\u8003\u7EA7\u522B: ${rest}`));
+        break;
+      }
+      case "/system": {
+        if (!rest) {
+          console.log(chalk5.dim("\u7528\u6CD5: /system <\u65B0\u7684\u7CFB\u7EDF\u63D0\u793A\u8BCD>"));
+          break;
+        }
+        runtime.setSystemPrompt(rest);
+        console.log(chalk5.green("\u7CFB\u7EDF\u63D0\u793A\u8BCD\u5DF2\u66F4\u65B0"));
+        break;
+      }
+      case "/session":
+        console.log(`\u4F1A\u8BDD key: ${chalk5.cyan(activeKey)}`);
+        console.log(`\u6D88\u606F\u6570: ${runtime.getMessages(activeKey).length}`);
+        console.log(`\u6301\u4E45\u5316: ${args.noSession ? chalk5.yellow("\u5426\uFF08--no-session\uFF09") : chalk5.green(storage ? "\u662F" : "\u5426\uFF08\u65E0\u5B58\u50A8\uFF09")}`);
+        break;
+      case "/sessions": {
+        if (!storage) {
+          console.log(chalk5.yellow("\u5F53\u524D\u4E3A\u4E34\u65F6\u4F1A\u8BDD\uFF0C\u65E0\u6301\u4E45\u5316\u5B58\u50A8"));
+          break;
+        }
+        const sessions = await listSessionsByRecency(storage);
+        if (sessions.length === 0) {
+          console.log(chalk5.dim("\uFF08\u65E0\u5386\u53F2\u4F1A\u8BDD\uFF09"));
+          break;
+        }
+        console.log(sessions.slice(0, 10).map((s, i) => `${s === activeKey ? chalk5.green("\u25B8 ") : "  "}${i + 1}. ${s}`).join("\n"));
+        console.log(chalk5.dim("\u5207\u6362: \u9000\u51FA\u540E\u7528 aipack --session <key> \u6062\u590D"));
+        break;
+      }
+      case "/clear":
+        runtime.clearSession(activeKey);
+        console.log(chalk5.green("\u4F1A\u8BDD\u5DF2\u6E05\u7A7A\uFF08\u4EC5\u5185\u5B58\uFF09"));
+        break;
+      case "/tools":
+        console.log(chalk5.dim("\u5185\u7F6E\u5DE5\u5177\u901A\u8FC7 --tools/--exclude-tools \u914D\u7F6E\uFF1B\u5F53\u524D\u8FD0\u884C\u65F6\u672A\u63D0\u4F9B\u5217\u4E3E\u63A5\u53E3"));
+        break;
+      case "/approvals": {
+        if (!approvalManager) {
+          console.log(chalk5.yellow("\u5BA1\u6279\u672A\u542F\u7528\uFF08\u5728 aipack.config.js \u4E2D\u914D\u7F6E approvals.enabled: true\uFF09"));
+          break;
+        }
+        const pending = approvalManager.list();
+        if (pending.length === 0) {
+          console.log(chalk5.dim("\uFF08\u65E0\u672A\u51B3\u5BA1\u6279\uFF09"));
+          break;
+        }
+        for (const p of pending) {
+          console.log(`${chalk5.cyan(p.id)}  ${p.request.toolName}  ${chalk5.dim(new Date(p.createdAt).toLocaleString())}${p.restored ? chalk5.yellow(" (\u5B64\u513F)") : ""}`);
+        }
+        break;
+      }
+      case "/approve":
+      case "/deny": {
+        if (!approvalManager) {
+          console.log(chalk5.yellow("\u5BA1\u6279\u672A\u542F\u7528"));
+          break;
+        }
+        if (!rest) {
+          console.log(chalk5.dim(`\u7528\u6CD5: ${cmd} <\u5BA1\u6279\u5355 id>`));
+          break;
+        }
+        const ok = approvalManager.resolve(rest, cmd === "/approve");
+        console.log(ok ? chalk5.green("\u5DF2\u751F\u6548") : chalk5.yellow("\u5BA1\u6279\u5355\u4E0D\u5B58\u5728\u6216\u5DF2\u7ED3\u7B97"));
+        break;
+      }
+      default:
+        console.log(chalk5.yellow(`\u672A\u77E5\u547D\u4EE4: ${cmd}\uFF08/help \u67E5\u770B\u5168\u90E8\uFF09`));
+    }
+  }
+  function printSlashHelp() {
+    console.log(`${chalk5.bold("\u547D\u4EE4:")}
+  /model [provider/id]    \u5207\u6362\u6A21\u578B\uFF08\u65E0\u53C2\u663E\u793A\u5F53\u524D\uFF09
+  /thinking <\u7EA7\u522B>        off/minimal/low/medium/high/max
+  /system <\u6587\u672C>          \u66FF\u6362\u7CFB\u7EDF\u63D0\u793A\u8BCD
+  /session                \u5F53\u524D\u4F1A\u8BDD\u4FE1\u606F
+  /sessions               \u5217\u51FA\u5386\u53F2\u4F1A\u8BDD
+  /clear                  \u6E05\u7A7A\u5F53\u524D\u4F1A\u8BDD\uFF08\u4EC5\u5185\u5B58\uFF09
+  /approvals              \u672A\u51B3\u5BA1\u6279\u5355
+  /approve <id>           \u6279\u51C6
+  /deny <id>              \u9A73\u56DE
+  /quit                   \u9000\u51FA\uFF08Ctrl+C \u53CC\u51FB\uFF09`);
+  }
+  async function onLine(line) {
+    const text = line.trim();
+    if (!text) {
+      rl.prompt();
+      return;
+    }
+    if (busy) {
+      console.log(chalk5.dim("\uFF08\u8FD0\u884C\u4E2D\uFF0C\u8F93\u5165\u88AB\u5FFD\u7565\uFF1BCtrl+C \u4E2D\u65AD\uFF09"));
+      rl.prompt();
+      return;
+    }
+    if (text.startsWith("/")) {
+      await handleCommand(text);
+      rl.prompt();
+      return;
+    }
+    await send(text);
+  }
+  if (opts.confirmRef) {
+    opts.confirmRef.fn = async (req) => {
+      recreating = true;
+      rl.close();
+      try {
+        return await opts.baseConfirm(req);
+      } finally {
+        recreating = false;
+        setupRl();
+      }
+    };
+  }
+  const modelLabel = `${model.aiModel.provider}/${model.aiModel.id}${model.custom ? chalk5.yellow(" (\u81EA\u5B9A\u4E49)") : ""}`;
+  console.log(chalk5.bold(`${APP_NAME} ${VERSION}`) + chalk5.dim(`  \u4F1A\u8BDD: ${activeKey}${args.noSession ? " (\u4E34\u65F6)" : ""}`));
+  console.log(chalk5.dim(`\u6A21\u578B: ${modelLabel}`));
+  console.log(chalk5.dim("\u8F93\u5165 /help \u67E5\u770B\u547D\u4EE4\uFF0CCtrl+C \u4E2D\u65AD\u8FD0\u884C\uFF0C\u8FDE\u6309\u4E24\u6B21\u9000\u51FA\n"));
+  setupRl();
+  if (opts.initialMessages && opts.initialMessages.length > 0) {
+    await send(opts.initialMessages.join("\n"));
+  }
+  await finished;
+}
+async function pickSessionInteractively(storage, currentKey) {
+  const sessions = await listSessionsByRecency(storage);
+  if (sessions.length === 0) {
+    console.log(chalk5.dim("\uFF08\u65E0\u5386\u53F2\u4F1A\u8BDD\uFF0C\u5C06\u65B0\u5EFA\uFF09"));
+    return void 0;
+  }
+  console.log(chalk5.bold("\u9009\u62E9\u4F1A\u8BDD:"));
+  sessions.slice(0, 15).forEach((s, i) => {
+    console.log(`${s === currentKey ? chalk5.green("\u25B8 ") : "  "}${i + 1}. ${s}`);
+  });
+  console.log(chalk5.dim("  n. \u65B0\u4F1A\u8BDD"));
+  const answer = await ask("\u7F16\u53F7: ");
+  if (answer === "" || answer.toLowerCase() === "n") return void 0;
+  const idx = Number.parseInt(answer, 10);
+  if (Number.isInteger(idx) && idx >= 1 && idx <= Math.min(sessions.length, 15)) {
+    return sessions[idx - 1];
+  }
+  return void 0;
+}
+
+// src/select.ts
+import chalk6 from "chalk";
+async function select(question, options, defaultIndex = 0) {
+  const stdin = process.stdin;
+  const out = process.stdout;
+  if (!stdin.isTTY || options.length === 0) return null;
+  return new Promise((resolve) => {
+    let selected = Math.min(Math.max(defaultIndex, 0), options.length - 1);
+    const prevRaw = stdin.isRaw ?? false;
+    stdin.setRawMode(true);
+    stdin.setEncoding("utf8");
+    stdin.resume();
+    function render() {
+      for (let i = 0; i < options.length; i++) {
+        const opt = options[i];
+        const line = i === selected ? `${chalk6.cyan("\u276F ")}${chalk6.bold(opt.label)}` : `  ${opt.label}`;
+        out.write(`\x1B[2K\r${line}
+`);
+      }
+      out.write(`\x1B[${options.length}A`);
+    }
+    function finish(value) {
+      stdin.removeListener("data", onData);
+      try {
+        stdin.setRawMode(prevRaw);
+      } catch {
+      }
+      if (!prevRaw) stdin.pause();
+      for (let i = 0; i < options.length; i++) out.write("\x1B[2K\r\n");
+      out.write(`\x1B[${options.length}A`);
+      const chosen = options.find((o) => o.value === value);
+      const summary = chosen ? chalk6.green(`\u2713 ${chosen.label}`) : chalk6.dim("\u5DF2\u53D6\u6D88");
+      out.write(`\x1B[2K\r  ${summary}
+`);
+      resolve(value);
+    }
+    function onData(chunk) {
+      if (chunk.startsWith("\x1B[A") || chunk === "k") {
+        selected = (selected - 1 + options.length) % options.length;
+      } else if (chunk.startsWith("\x1B[B") || chunk === "j") {
+        selected = (selected + 1) % options.length;
+      } else if (chunk === "\r" || chunk === "\n") {
+        finish(options[selected].value);
+        return;
+      } else if (chunk === "\x1B" || chunk === "\x1B\x1B" || chunk === "q" || chunk === "") {
+        finish(null);
+        return;
+      } else if (/^[1-9]$/.test(chunk)) {
+        const idx = Number(chunk) - 1;
+        if (idx < options.length) {
+          finish(options[idx].value);
+          return;
+        }
+        return;
+      } else {
+        return;
+      }
+      render();
+    }
+    out.write(`${chalk6.yellow("?")} ${chalk6.bold(question)}
+`);
+    render();
+    stdin.on("data", onData);
+  });
+}
+
+// src/confirm.ts
+var DANGEROUS_PATTERNS = [
+  // 递归删除根/家目录（rm -rf /、rm -rf ~、rm -rf /* 等；正常子目录不受影响）
+  [/rm\s+[^;|&]*[rf][^;|&]*\s+(\/|~|\$HOME)(\/?\*|\s|$)/, "\u9012\u5F52\u5220\u9664\u6839/\u5BB6\u76EE\u5F55"],
+  [/\bsudo(\s|$)/, "\u63D0\u6743\u6267\u884C"],
+  [/\bmkfs(\s|\.)/, "\u683C\u5F0F\u5316\u78C1\u76D8"],
+  [/\bdd\s+[^;|]*of=\/dev\//, "\u5199\u5165\u78C1\u76D8\u8BBE\u5907"],
+  [/>\s*\/dev\/(sd|disk|nvme)/, "\u8986\u5199\u78C1\u76D8\u8BBE\u5907"],
+  [/(curl|wget)[^|;]*\|\s*(sudo\s+)?(ba|z)?sh/, "\u7BA1\u9053\u6267\u884C\u8FDC\u7A0B\u811A\u672C"],
+  [/chmod\s+-R\s+777\s+\/(\s|$)/, "\u6839\u76EE\u5F55\u5F00\u653E\u5168\u90E8\u6743\u9650"],
+  [/\b(shutdown|reboot|halt|poweroff)\b/, "\u5173\u673A/\u91CD\u542F"],
+  [/:\s*\(\)\s*\{[^}]*\}\s*;\s*:/, "fork \u70B8\u5F39"]
+];
+function isDangerousCommand(command) {
+  for (const [pattern, reason] of DANGEROUS_PATTERNS) {
+    if (pattern.test(command)) return reason;
+  }
+  return null;
+}
+function summarizeArgs(req) {
+  const args = req.args;
+  if (!args || typeof args !== "object") return "";
+  const cmd = args.command;
+  if (typeof cmd === "string") return cmd.length > 60 ? `${cmd.slice(0, 60)}\u2026` : cmd;
+  const file = args.file ?? args.path;
+  if (typeof file === "string") return file;
+  return "";
+}
+function createToolConfirmHandler(options = {}) {
+  const autoApproveSafe = options.autoApproveSafe ?? true;
+  const alwaysAllowed = /* @__PURE__ */ new Set();
+  return async (req) => {
+    if (!process.stdin.isTTY) return false;
+    const key = req.permissions.length > 0 ? [...req.permissions].sort().join(",") : `tool:${req.toolName}`;
+    if (alwaysAllowed.has(key)) return true;
+    const args = req.args;
+    const command = typeof args?.command === "string" ? args.command : "";
+    if (autoApproveSafe && command && !isDangerousCommand(command)) {
+      return true;
+    }
+    const dangerReason = command ? isDangerousCommand(command) : null;
+    const summary = command || summarizeArgs(req);
+    const question = dangerReason ? `\u5371\u9669\u547D\u4EE4\uFF08${dangerReason}\uFF09\uFF1A${summary}` : summary ? `\u5141\u8BB8\u6267\u884C ${req.toolName}\uFF1A${summary}` : `\u5141\u8BB8\u6267\u884C ${req.toolName}`;
+    const choice = await select(question, [
+      { label: "\u5141\u8BB8", value: "once" },
+      { label: "\u603B\u662F\u5141\u8BB8\uFF08\u672C\u4F1A\u8BDD\uFF09", value: "always" },
+      { label: "\u62D2\u7EDD", value: "deny" }
+    ]);
+    if (choice === "always") {
+      alwaysAllowed.add(key);
+      return true;
+    }
+    return choice === "once";
+  };
+}
+
+// src/cli.ts
+import { createRequest } from "@aipack-ai/agent";
+async function main(argv) {
+  if (argv[0] === "approvals" || argv[0] === "approval") {
+    return handleApprovalsCommand(argv.slice(1));
+  }
+  const args = parseArgs(argv);
+  if (args.help) {
+    printHelp();
+    return 0;
+  }
+  if (args.version) {
+    console.log(VERSION);
+    return 0;
+  }
+  const errors = args.diagnostics.filter((d) => d.type === "error");
+  if (errors.length > 0) {
+    for (const e of errors) console.error(chalk7.red(e.message));
+    printHelp();
+    return 1;
+  }
+  for (const w of args.diagnostics.filter((d) => d.type === "warning")) {
+    console.error(chalk7.yellow(w.message));
+  }
+  if (args.listModels !== void 0) {
+    return listModels(args.listModels);
+  }
+  let stdinText;
+  if ((args.print || args.mode === "json") && !process.stdin.isTTY) {
+    stdinText = await readStreamAll(process.stdin);
+  }
+  const initial = await buildInitialMessage(args.messages, args.fileArgs, stdinText);
+  const isNonInteractive = args.print || args.mode === "json";
+  if (isNonInteractive && !initial.text.trim() && initial.media.length === 0) {
+    console.error(chalk7.red("\u975E\u4EA4\u4E92\u6A21\u5F0F\u9700\u8981\u63D0\u4F9B\u6D88\u606F\uFF08\u4F4D\u7F6E\u53C2\u6570\u3001@\u6587\u4EF6\u6216\u7BA1\u9053 stdin\uFF09"));
+    return 1;
+  }
+  const toolConfirm = createToolConfirmHandler({ autoApproveSafe: !args.safe });
+  const confirmRef = {
+    fn: (req) => toolConfirm(req)
+  };
+  let built;
+  try {
+    built = await buildRuntime({
+      args,
+      cwd: process.cwd(),
+      confirmFn: (req) => confirmRef.fn(req)
+    });
+  } catch (err) {
+    console.error(chalk7.red(`\u521D\u59CB\u5316\u5931\u8D25: ${err instanceof Error ? err.message : String(err)}`));
+    return 1;
+  }
+  try {
+    if (args.mode === "json") {
+      const request = createRequest(initial.text || "(\u7A7A)", {
+        channel: "cli",
+        sessionKey: built.sessionKey,
+        ephemeral: args.noSession,
+        media: initial.media
+      });
+      await runJsonMode(built.runtime, request);
+    } else if (args.print) {
+      const request = createRequest(initial.text || "(\u7A7A)", {
+        channel: "cli",
+        sessionKey: built.sessionKey,
+        ephemeral: args.noSession,
+        media: initial.media
+      });
+      await runPrintMode(built.runtime, request);
+    } else {
+      await runInteractiveMode({
+        runtime: built.runtime,
+        sessionKey: built.sessionKey,
+        model: built.model,
+        args,
+        storage: built.storage,
+        approvalManager: built.approvalManager,
+        initialMessages: args.messages.length > 0 ? [initial.text] : [],
+        confirmRef,
+        baseConfirm: toolConfirm
+      });
+    }
+  } finally {
+    built.approvalManager?.close();
+    await built.runtime.close();
+  }
+  return process.exitCode === 1 ? 1 : 0;
+}
+if (process.argv[1] && /cli\.(js|mjs|ts)$/.test(process.argv[1])) {
+  main(process.argv.slice(2)).then((code) => process.exit(code)).catch((err) => {
+    console.error(chalk7.red(`\u81F4\u547D\u9519\u8BEF: ${err instanceof Error ? err.stack ?? err.message : String(err)}`));
+    process.exit(1);
+  });
+}
+
+export {
+  APP_NAME,
+  VERSION,
+  defaultConfigDir,
+  defaultSessionDir,
+  isValidThinkingLevel,
+  parseArgs,
+  printHelp,
+  readTool,
+  writeTool,
+  editTool,
+  bashTool,
+  BUILTIN_TOOLS,
+  selectTools,
+  loadConfig,
+  resolveModel,
+  listSessionsByRecency,
+  resolveSessionKey,
+  buildRuntime,
+  buildInitialMessage,
+  runPrintMode,
+  runJsonMode,
+  runInteractiveMode,
+  pickSessionInteractively,
+  select,
+  isDangerousCommand,
+  createToolConfirmHandler,
+  main
+};
+//# sourceMappingURL=chunk-DWPSBSRO.js.map