inspiration-agent 0.0.1

package/dist/cli.js

@@ -0,0 +1,659 @@
+#!/usr/bin/env node
+
+const { spawn, exec, fork } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const readline = require("readline");
+const net = require("net");
+
+const PACKAGE_JSON = require("../package.json");
+const PID_FILE = path.join(__dirname, "..", "inspiration.pid");
+const CONFIG_DIR = path.join(os.homedir(), ".inspiration");
+const ENV_FILE = path.join(CONFIG_DIR, ".env");
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const command = args[0] || "help";
+  const flags = {};
+
+  for (let i = 1; i < args.length; i++) {
+    if (args[i].startsWith("-")) {
+      const flag = args[i].replace(/^-+/, "");
+      if (args[i + 1] && !args[i + 1].startsWith("-")) {
+        flags[flag] = args[i + 1];
+        i++;
+      } else {
+        flags[flag] = true;
+      }
+    }
+  }
+
+  return { command, flags, args };
+}
+
+function ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+
+function getPid() {
+  if (fs.existsSync(PID_FILE)) {
+    const pid = parseInt(fs.readFileSync(PID_FILE, "utf-8").trim(), 10);
+    if (Number.isInteger(pid)) {
+      try {
+        process.kill(pid, 0);
+        return pid;
+      } catch (e) {
+        fs.unlinkSync(PID_FILE);
+        return null;
+      }
+    }
+  }
+  return null;
+}
+
+function removePid() {
+  if (fs.existsSync(PID_FILE)) {
+    fs.unlinkSync(PID_FILE);
+  }
+}
+
+function isRunning() {
+  return getPid() !== null;
+}
+
+function getEnvPath() {
+  if (fs.existsSync(ENV_FILE)) {
+    return ENV_FILE;
+  }
+  const localEnv = path.join(process.cwd(), ".env");
+  if (fs.existsSync(localEnv)) {
+    return localEnv;
+  }
+  return null;
+}
+
+function startDaemon() {
+  return new Promise((resolve, reject) => {
+    const indexPath = path.join(__dirname, "index.js");
+    const envPath = getEnvPath();
+    const logDir = path.join(__dirname, "..", "logs");
+
+    if (!fs.existsSync(logDir)) {
+      fs.mkdirSync(logDir, { recursive: true });
+    }
+
+    const logFile = path.join(logDir, "daemon.log");
+    const logFd = fs.openSync(logFile, "a");
+
+    const env = { ...process.env };
+    if (envPath) {
+      env.DOTENV_CONFIG_PATH = envPath;
+    }
+
+    const child = spawn(process.execPath, [indexPath], {
+      detached: true,
+      stdio: ["ignore", logFd, logFd],
+      env: env,
+    });
+
+    child.unref();
+
+    child.on("error", (err) => {
+      reject(err);
+    });
+
+    const startTime = Date.now();
+    const timeout = 10000;
+
+    const checkPid = () => {
+      const pid = getPid();
+      if (pid) {
+        resolve(pid);
+      } else if (Date.now() - startTime > timeout) {
+        reject(new Error(`启动超时，请检查日志: ${logFile}`));
+      } else {
+        setTimeout(checkPid, 100);
+      }
+    };
+
+    setTimeout(checkPid, 300);
+  });
+}
+
+function startForeground() {
+  return new Promise((resolve, reject) => {
+    const indexPath = path.join(__dirname, "index.js");
+    const envPath = getEnvPath();
+
+    const env = { ...process.env };
+    if (envPath) {
+      env.DOTENV_CONFIG_PATH = envPath;
+    }
+
+    const child = spawn(process.execPath, [indexPath], {
+      stdio: "inherit",
+      env: env,
+    });
+
+    child.on("error", (err) => {
+      reject(err);
+    });
+
+    child.on("exit", (code) => {
+      resolve(code);
+    });
+  });
+}
+
+function stopProcess() {
+  return new Promise((resolve) => {
+    const pid = getPid();
+    if (!pid) {
+      resolve(false);
+      return;
+    }
+
+    try {
+      process.kill(pid, "SIGTERM");
+
+      let attempts = 0;
+      const checkStopped = () => {
+        try {
+          process.kill(pid, 0);
+          attempts++;
+          if (attempts > 20) {
+            process.kill(pid, "SIGKILL");
+            removePid();
+            resolve(true);
+          } else {
+            setTimeout(checkStopped, 100);
+          }
+        } catch (e) {
+          removePid();
+          resolve(true);
+        }
+      };
+      setTimeout(checkStopped, 100);
+    } catch (e) {
+      removePid();
+      resolve(false);
+    }
+  });
+}
+
+function showHelp() {
+  console.log(`
+\x1b[1minspiration-agent\x1b[0m - Personal AI Assistant
+
+\x1b[1m用法:\x1b[0m
+  inspiration <command> [options]
+
+\x1b[1m命令:\x1b[0m
+  start         启动服务
+    -d, --daemon  后台运行
+  stop          停止服务
+  restart       重启服务
+  status        查看服务状态
+  version       查看版本号
+  onboard       配置向导
+  cli           打开命令行交互（需要服务运行中）
+  help          显示帮助信息
+
+\x1b[1m示例:\x1b[0m
+  inspiration start          # 前台启动
+  inspiration start -d       # 后台启动
+  inspiration onboard        # 运行配置向导
+  inspiration status         # 查看状态
+  inspiration cli            # 进入交互模式
+
+\x1b[1m配置文件:\x1b[0m
+  ${ENV_FILE}
+
+\x1b[1m更多信息:\x1b[0m
+  https://github.com/your-repo/inspiration-agent
+`);
+}
+
+function showVersion() {
+  console.log(`inspiration-agent v${PACKAGE_JSON.version}`);
+}
+
+function showStatus() {
+  const pid = getPid();
+  if (pid) {
+    console.log(`\n✅ inspiration-agent 运行中 (PID: ${pid})\n`);
+  } else {
+    console.log("\n❌ inspiration-agent 未运行");
+    console.log("   使用 'inspiration start' 启动服务\n");
+  }
+}
+
+async function runOnboard() {
+  console.log("\n\x1b[1m🔧 inspiration-agent 配置向导\x1b[0m\n");
+
+  ensureConfigDir();
+
+  const existingEnv = fs.existsSync(ENV_FILE)
+    ? fs.readFileSync(ENV_FILE, "utf-8")
+    : "";
+
+  const getExistingValue = (key) => {
+    const match = existingEnv.match(new RegExp(`^${key}=(.*)$`, "m"));
+    return match ? match[1] : "";
+  };
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  const question = (prompt, defaultValue = "", required = false) => {
+    return new Promise((resolve) => {
+      const displayPrompt = defaultValue
+        ? `${prompt} [${defaultValue}]: `
+        : required
+          ? `${prompt} (必填): `
+          : `${prompt}: `;
+      rl.question(displayPrompt, (answer) => {
+        const trimmed = answer.trim();
+        if (required && !trimmed && !defaultValue) {
+          console.log("此项为必填项，请输入有效值");
+          question(prompt, defaultValue, required).then(resolve);
+        } else {
+          resolve(trimmed || defaultValue);
+        }
+      });
+    });
+  };
+
+  let envContent = "";
+
+  try {
+    console.log("\x1b[1m========== LLM 提供商配置 ==========\x1b[0m\n");
+
+    const validProviders = ["deepseek", "kimi", "zhipu", "minimax"];
+    let llmProvider = await question(
+      "LLM 提供商 (deepseek/kimi/zhipu/minimax)",
+      getExistingValue("LLM_PROVIDER") || "deepseek",
+      true
+    );
+    while (!validProviders.includes(llmProvider.toLowerCase())) {
+      console.log("无效的提供商，请选择: deepseek, kimi, zhipu, minimax");
+      llmProvider = await question(
+        "LLM 提供商 (deepseek/kimi/zhipu/minimax)",
+        getExistingValue("LLM_PROVIDER") || "deepseek",
+        true
+      );
+    }
+    envContent += `LLM_PROVIDER=${llmProvider}\n\n`;
+
+    if (llmProvider === "deepseek") {
+      console.log("\n\x1b[36mDeepSeek 配置:\x1b[0m");
+      const apiKey = await question(
+        "API Key",
+        getExistingValue("DEEPSEEK_API_KEY"),
+        true
+      );
+      const apiUrl = await question(
+        "API URL",
+        getExistingValue("DEEPSEEK_API_URL") || "https://api.deepseek.com/v1/chat/completions"
+      );
+      const model = await question(
+        "模型名称",
+        getExistingValue("DEEPSEEK_MODEL") || "deepseek-chat"
+      );
+      envContent += `DEEPSEEK_API_KEY=${apiKey}\n`;
+      envContent += `DEEPSEEK_API_URL=${apiUrl}\n`;
+      envContent += `DEEPSEEK_MODEL=${model}\n\n`;
+    } else if (llmProvider === "kimi") {
+      console.log("\n\x1b[36mKimi (月之暗面) 配置:\x1b[0m");
+      const apiKey = await question(
+        "API Key",
+        getExistingValue("KIMI_API_KEY"),
+        true
+      );
+      const apiUrl = await question(
+        "API URL",
+        getExistingValue("KIMI_API_URL") || "https://api.moonshot.cn/v1/chat/completions"
+      );
+      const model = await question(
+        "模型名称",
+        getExistingValue("KIMI_MODEL") || "moonshot-v1-8k"
+      );
+      envContent += `KIMI_API_KEY=${apiKey}\n`;
+      envContent += `KIMI_API_URL=${apiUrl}\n`;
+      envContent += `KIMI_MODEL=${model}\n\n`;
+    } else if (llmProvider === "zhipu") {
+      console.log("\n\x1b[36m智谱 GLM 配置:\x1b[0m");
+      const apiKey = await question(
+        "API Key",
+        getExistingValue("ZHIPU_API_KEY"),
+        true
+      );
+      const apiUrl = await question(
+        "API URL",
+        getExistingValue("ZHIPU_API_URL") || "https://open.bigmodel.cn/api/paas/v4/chat/completions"
+      );
+      const model = await question(
+        "模型名称",
+        getExistingValue("ZHIPU_MODEL") || "glm-4-flash"
+      );
+      envContent += `ZHIPU_API_KEY=${apiKey}\n`;
+      envContent += `ZHIPU_API_URL=${apiUrl}\n`;
+      envContent += `ZHIPU_MODEL=${model}\n\n`;
+    } else if (llmProvider === "minimax") {
+      console.log("\n\x1b[36mMiniMax 配置:\x1b[0m");
+      const apiKey = await question(
+        "API Key",
+        getExistingValue("MINIMAX_API_KEY"),
+        true
+      );
+      const groupId = await question(
+        "Group ID",
+        getExistingValue("MINIMAX_GROUP_ID"),
+        true
+      );
+      const apiUrl = await question(
+        "API URL",
+        getExistingValue("MINIMAX_API_URL") || "https://api.minimax.chat/v1/chat/completions"
+      );
+      const model = await question(
+        "模型名称",
+        getExistingValue("MINIMAX_MODEL") || "abab6.5s-chat"
+      );
+      envContent += `MINIMAX_API_KEY=${apiKey}\n`;
+      envContent += `MINIMAX_GROUP_ID=${groupId}\n`;
+      envContent += `MINIMAX_API_URL=${apiUrl}\n`;
+      envContent += `MINIMAX_MODEL=${model}\n\n`;
+    }
+
+    console.log("\x1b[1m========== 飞书应用配置 ==========\x1b[0m\n");
+
+    const feishuAppId = await question(
+      "飞书 App ID",
+      getExistingValue("FEISHU_APP_ID"),
+      true
+    );
+    const feishuAppSecret = await question(
+      "飞书 App Secret",
+      getExistingValue("FEISHU_APP_SECRET"),
+      true
+    );
+    const feishuVerificationToken = await question(
+      "飞书 Verification Token",
+      getExistingValue("FEISHU_VERIFICATION_TOKEN"),
+      true
+    );
+    const feishuEncryptKey = await question(
+      "飞书 Encrypt Key (可选)",
+      getExistingValue("FEISHU_ENCRYPT_KEY")
+    );
+    const feishuDefaultChatId = await question(
+      "飞书默认 Chat ID (可选)",
+      getExistingValue("FEISHU_DEFAULT_CHAT_ID")
+    );
+
+    envContent += `FEISHU_APP_ID=${feishuAppId}\n`;
+    envContent += `FEISHU_APP_SECRET=${feishuAppSecret}\n`;
+    envContent += `FEISHU_VERIFICATION_TOKEN=${feishuVerificationToken}\n`;
+    if (feishuEncryptKey) envContent += `FEISHU_ENCRYPT_KEY=${feishuEncryptKey}\n`;
+    if (feishuDefaultChatId) envContent += `FEISHU_DEFAULT_CHAT_ID=${feishuDefaultChatId}\n\n`;
+
+    console.log("\x1b[1m========== 服务配置 ==========\x1b[0m\n");
+
+    const port = await question(
+      "服务端口",
+      getExistingValue("PORT") || "3000"
+    );
+    let enableStream = await question(
+      "启用流式输出 (true/false)",
+      getExistingValue("ENABLE_STREAM") || "true"
+    );
+    while (!["true", "false"].includes(enableStream.toLowerCase())) {
+      console.log("请输入 true 或 false");
+      enableStream = await question(
+        "启用流式输出 (true/false)",
+        getExistingValue("ENABLE_STREAM") || "true"
+      );
+    }
+
+    envContent += `PORT=${port}\n`;
+    envContent += `ENABLE_STREAM=${enableStream}\n\n`;
+
+    console.log("\x1b[1m========== 命令安全配置 ==========\x1b[0m\n");
+
+    let whitelistEnabled = await question(
+      "启用命令白名单 (true/false)",
+      getExistingValue("COMMAND_WHITELIST_ENABLED") || "true"
+    );
+    while (!["true", "false"].includes(whitelistEnabled.toLowerCase())) {
+      console.log("请输入 true 或 false");
+      whitelistEnabled = await question(
+        "启用命令白名单 (true/false)",
+        getExistingValue("COMMAND_WHITELIST_ENABLED") || "true"
+      );
+    }
+    envContent += `COMMAND_WHITELIST_ENABLED=${whitelistEnabled}\n`;
+    envContent += "\n";
+
+    console.log("\x1b[1m========== 数据库配置 ==========\x1b[0m\n");
+
+    const databasePath = await question(
+      "数据库路径",
+      getExistingValue("DATABASE_PATH") || "./data/ai_agent.db"
+    );
+    envContent += `DATABASE_PATH=${databasePath}\n`;
+
+    fs.writeFileSync(ENV_FILE, envContent);
+
+    console.log("\n\x1b[32m✅ 配置已保存到:\x1b[0m", ENV_FILE);
+    console.log("\n现在可以使用 'inspiration start' 启动服务\n");
+  } finally {
+    rl.close();
+  }
+}
+
+const SOCKET_FILE = path.join(__dirname, "..", "inspiration.sock");
+
+function sendIPC(request) {
+  return new Promise((resolve, reject) => {
+    if (!fs.existsSync(SOCKET_FILE)) {
+      reject(new Error("服务未运行"));
+      return;
+    }
+
+    const client = net.createConnection(SOCKET_FILE, () => {
+      client.write(JSON.stringify(request) + "\n");
+    });
+
+    let response = "";
+    let resolved = false;
+
+    const timeout = setTimeout(() => {
+      if (!resolved) {
+        client.destroy();
+        reject(new Error("连接超时"));
+      }
+    }, 300000);
+
+    client.on("data", (data) => {
+      response += data.toString();
+    });
+
+    client.on("end", () => {
+      resolved = true;
+      clearTimeout(timeout);
+      try {
+        const result = JSON.parse(response.trim());
+        resolve(result);
+      } catch (e) {
+        reject(new Error("解析响应失败"));
+      }
+    });
+
+    client.on("error", (err) => {
+      resolved = true;
+      clearTimeout(timeout);
+      reject(new Error(`连接失败: ${err.message}`));
+    });
+  });
+}
+
+async function runCli() {
+  const pid = getPid();
+  if (!pid) {
+    console.log("\n❌ inspiration-agent 未运行");
+    console.log("   请先使用 'inspiration start' 启动服务\n");
+    return;
+  }
+
+  console.log("\n\x1b[1m💬 inspiration-agent 命令行交互\x1b[0m");
+  console.log("输入消息与 AI 交互，输入 'exit' 或 'quit' 退出\n");
+
+  const TerminalMarkdownRenderer = require("./utils/markdown-renderer");
+  const markdownRenderer = new TerminalMarkdownRenderer();
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  const question = (prompt) => {
+    return new Promise((resolve) => {
+      rl.question(prompt, resolve);
+    });
+  };
+
+  try {
+    while (true) {
+      const input = await question("你: ");
+      if (!input.trim()) continue;
+      if (input.toLowerCase() === "exit" || input.toLowerCase() === "quit") {
+        console.log("\n再见！\n");
+        break;
+      }
+
+      if (input.startsWith("/")) {
+        try {
+          const result = await sendIPC({ type: "command", content: input });
+
+          if (result.type === "response") {
+            if (typeof result.content === "object") {
+              console.log("\n" + JSON.stringify(result.content, null, 2) + "\n");
+            } else {
+              console.log(`\n${result.content}\n`);
+            }
+
+            if (input.trim().toLowerCase() === "/shutdown") {
+              console.log("CLI 已关闭\n");
+              rl.close();
+              process.exit(0);
+            }
+          } else if (result.type === "error") {
+            console.error(`\n错误: ${result.message}\n`);
+          }
+        } catch (error) {
+          console.error(`\n错误: ${error.message}\n`);
+        }
+        continue;
+      }
+
+      try {
+        const result = await sendIPC({ type: "message", content: input });
+
+        if (result.type === "response") {
+          const rendered = markdownRenderer.render(result.content);
+          console.log(`\nAI:\n${rendered}\n`);
+        } else if (result.type === "error") {
+          console.error(`\n错误: ${result.message}\n`);
+        }
+      } catch (error) {
+        console.error(`\n错误: ${error.message}\n`);
+      }
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+async function main() {
+  const { command, flags } = parseArgs();
+
+  switch (command) {
+    case "start":
+      if (isRunning()) {
+        console.log("\n⚠️  inspiration-agent 已在运行中");
+        console.log(`   使用 'inspiration status' 查看状态\n`);
+        break;
+      }
+
+      if (flags.d || flags.daemon) {
+        console.log("\n🚀 启动 inspiration-agent (后台模式)...");
+        try {
+          const pid = await startDaemon();
+          console.log(`✅ 服务已启动 (PID: ${pid})\n`);
+        } catch (err) {
+          console.error(`❌ 启动失败: ${err.message}\n`);
+          process.exit(1);
+        }
+      } else {
+        console.log("\n🚀 启动 inspiration-agent...\n");
+        await startForeground();
+      }
+      break;
+
+    case "stop":
+      if (await stopProcess()) {
+        console.log("\n✅ inspiration-agent 已停止\n");
+      } else {
+        console.log("\n⚠️  inspiration-agent 未运行\n");
+      }
+      break;
+
+    case "restart":
+      console.log("\n🔄 重启 inspiration-agent...");
+      await stopProcess();
+      await new Promise((r) => setTimeout(r, 1000));
+      if (flags.d || flags.daemon) {
+        const pid = await startDaemon();
+        console.log(`✅ 服务已重启 (PID: ${pid})\n`);
+      } else {
+        await startForeground();
+      }
+      break;
+
+    case "status":
+      showStatus();
+      console.log();
+      break;
+
+    case "version":
+    case "-v":
+    case "--version":
+      showVersion();
+      break;
+
+    case "onboard":
+      await runOnboard();
+      break;
+
+    case "cli":
+      await runCli();
+      break;
+
+    case "help":
+    case "-h":
+    case "--help":
+    default:
+      showHelp();
+      break;
+  }
+}
+
+main().catch((err) => {
+  console.error(`错误: ${err.message}`);
+  process.exit(1);
+});