@thinkingai/ae-cli 1.0.22 → 1.0.27

package/dist/chunk-6T7245YE.js

@@ -0,0 +1,478 @@
+// src/core/multiselect.ts
+var MultiselectCancelled = class extends Error {
+  constructor() {
+    super("\u7528\u6237\u53D6\u6D88\u9009\u62E9");
+    this.name = "MultiselectCancelled";
+  }
+};
+function buildRows(items) {
+  const rows = [];
+  let lastGroup;
+  for (let i = 0; i < items.length; i++) {
+    const it = items[i];
+    if (it.group && it.group !== lastGroup) {
+      rows.push({ kind: "header", groupLabel: it.group });
+      lastGroup = it.group;
+    }
+    rows.push({ kind: "item", itemIndex: i, item: it });
+  }
+  return rows;
+}
+function promptMultiselect(opts) {
+  const { title, items } = opts;
+  if (items.length === 0) {
+    return Promise.resolve([]);
+  }
+  const stderr = process.stderr;
+  const stdin = process.stdin;
+  if (!stdin.isTTY) {
+    return Promise.reject(
+      new Error("ae-cli sync \u9700\u8981 TTY \u624D\u80FD\u8FDB\u884C\u591A\u9009\uFF1B\u8BF7\u5728\u4EA4\u4E92\u5F0F\u7EC8\u7AEF\u4E2D\u8FD0\u884C")
+    );
+  }
+  const rows = buildRows(items);
+  const itemRowIndices = [];
+  rows.forEach((r, idx) => {
+    if (r.kind === "item") itemRowIndices.push(idx);
+  });
+  const selected = /* @__PURE__ */ new Set();
+  items.forEach((it, idx) => {
+    if (it.preselected) selected.add(idx);
+  });
+  let cursorRowIdx = itemRowIndices[0];
+  let renderCount = 0;
+  function totalLines() {
+    return rows.length + 2;
+  }
+  function render() {
+    if (renderCount > 0) {
+      stderr.write(`\x1B[${totalLines()}A`);
+    }
+    stderr.write(`${title}  (space \u9009\u62E9 \xB7 a \u5168\u9009/\u5168\u4E0D\u9009 \xB7 enter \u786E\u8BA4 \xB7 q \u53D6\u6D88)\x1B[K
+`);
+    stderr.write(`\x1B[K
+`);
+    rows.forEach((row, ridx) => {
+      if (row.kind === "header") {
+        stderr.write(`  \x1B[90m\u2500\u2500 ${row.groupLabel} \u2500\u2500\x1B[0m\x1B[K
+`);
+        return;
+      }
+      const isCursor = ridx === cursorRowIdx;
+      const isSelected = selected.has(row.itemIndex);
+      const pointer = isCursor ? "\x1B[36m\u276F\x1B[0m" : " ";
+      const checkbox = isSelected ? "\x1B[32m[x]\x1B[0m" : "[ ]";
+      const label = row.item.label;
+      const hint = row.item.hint ? ` \x1B[90m${row.item.hint}\x1B[0m` : "";
+      stderr.write(`${pointer} ${checkbox} ${label}${hint}\x1B[K
+`);
+    });
+    renderCount++;
+  }
+  return new Promise((resolve, reject) => {
+    stderr.write("\x1B[?25l");
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    function cleanup() {
+      stdin.setRawMode(false);
+      stdin.pause();
+      stdin.removeListener("data", onData);
+      stderr.write("\x1B[?25h");
+    }
+    function moveCursor(direction) {
+      const cur = itemRowIndices.indexOf(cursorRowIdx);
+      const next = (cur + direction + itemRowIndices.length) % itemRowIndices.length;
+      cursorRowIdx = itemRowIndices[next];
+      render();
+    }
+    function toggleAll() {
+      if (selected.size === items.length) {
+        selected.clear();
+      } else {
+        items.forEach((_, idx) => selected.add(idx));
+      }
+      render();
+    }
+    function onData(key) {
+      if (key === "\x1B[A" || key === "k") {
+        moveCursor(-1);
+      } else if (key === "\x1B[B" || key === "j") {
+        moveCursor(1);
+      } else if (key === " ") {
+        const row = rows[cursorRowIdx];
+        if (row.kind === "item") {
+          const idx = row.itemIndex;
+          if (selected.has(idx)) selected.delete(idx);
+          else selected.add(idx);
+          render();
+        }
+      } else if (key === "a" || key === "A") {
+        toggleAll();
+      } else if (key === "\r" || key === "\n") {
+        if (selected.size === 0) {
+          stderr.write("\x07");
+          return;
+        }
+        cleanup();
+        const result = Array.from(selected).map((i) => items[i].value);
+        resolve(result);
+      } else if (key === "q" || key === "Q" || key === "\x1B" || key === "") {
+        cleanup();
+        reject(new MultiselectCancelled());
+      }
+    }
+    stdin.on("data", onData);
+    render();
+  });
+}
+function promptSingleCheckboxSelect(opts) {
+  const { title, items } = opts;
+  if (items.length === 0) return Promise.reject(new Error("\u65E0\u53EF\u9009\u9879"));
+  const stderr = process.stderr;
+  const stdin = process.stdin;
+  if (!stdin.isTTY) return Promise.reject(new Error("\u9700\u8981 TTY \u624D\u80FD\u8FDB\u884C\u5355\u9009"));
+  const preselectedIndex = items.findIndex((item) => item.preselected);
+  let cursor = preselectedIndex >= 0 ? preselectedIndex : 0;
+  let selected = preselectedIndex >= 0 ? preselectedIndex : null;
+  let renderCount = 0;
+  const lines = items.length + 2;
+  function render() {
+    if (renderCount > 0) stderr.write(`\x1B[${lines}A`);
+    stderr.write(`${title}  (space \u9009\u62E9 \xB7 enter \u786E\u8BA4 \xB7 q \u53D6\u6D88)\x1B[K
+`);
+    stderr.write(`\x1B[K
+`);
+    items.forEach((it, idx) => {
+      const pointer = idx === cursor ? "\x1B[36m\u276F\x1B[0m" : " ";
+      const checkbox = selected === idx ? "\x1B[32m[x]\x1B[0m" : "[ ]";
+      const hint = it.hint ? ` \x1B[90m${it.hint}\x1B[0m` : "";
+      stderr.write(`${pointer} ${checkbox} ${it.label}${hint}\x1B[K
+`);
+    });
+    renderCount++;
+  }
+  return new Promise((resolve, reject) => {
+    stderr.write("\x1B[?25l");
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    function cleanup() {
+      stdin.setRawMode(false);
+      stdin.pause();
+      stdin.removeListener("data", onData);
+      stderr.write("\x1B[?25h");
+    }
+    function moveCursor(direction) {
+      cursor = (cursor + direction + items.length) % items.length;
+      render();
+    }
+    function onData(key) {
+      if (key === "\x1B[A" || key === "k") {
+        moveCursor(-1);
+      } else if (key === "\x1B[B" || key === "j") {
+        moveCursor(1);
+      } else if (key === " ") {
+        selected = cursor;
+        render();
+      } else if (key === "\r" || key === "\n") {
+        if (selected === null) {
+          stderr.write("\x07");
+          return;
+        }
+        cleanup();
+        resolve(items[selected].value);
+      } else if (key === "q" || key === "Q" || key === "\x1B" || key === "") {
+        cleanup();
+        reject(new MultiselectCancelled());
+      }
+    }
+    stdin.on("data", onData);
+    render();
+  });
+}
+function promptSingleSelect(opts) {
+  const { title, items } = opts;
+  if (items.length === 0) return Promise.reject(new Error("\u65E0\u53EF\u9009\u9879"));
+  const stderr = process.stderr;
+  const stdin = process.stdin;
+  if (!stdin.isTTY) return Promise.reject(new Error("\u9700\u8981 TTY \u624D\u80FD\u8FDB\u884C\u5355\u9009"));
+  let cursor = 0;
+  let renderCount = 0;
+  const lines = items.length + 1;
+  function render() {
+    if (renderCount > 0) stderr.write(`\x1B[${lines}A`);
+    stderr.write(`${title}\x1B[K
+`);
+    items.forEach((it, idx) => {
+      const pointer = idx === cursor ? "\x1B[36m\u276F\x1B[0m" : " ";
+      stderr.write(`${pointer} ${it.label}\x1B[K
+`);
+    });
+    renderCount++;
+  }
+  return new Promise((resolve, reject) => {
+    stderr.write("\x1B[?25l");
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    function cleanup() {
+      stdin.setRawMode(false);
+      stdin.pause();
+      stdin.removeListener("data", onData);
+      stderr.write("\x1B[?25h");
+    }
+    function onData(key) {
+      if (key === "\x1B[A" || key === "k") {
+        cursor = (cursor - 1 + items.length) % items.length;
+        render();
+      } else if (key === "\x1B[B" || key === "j") {
+        cursor = (cursor + 1) % items.length;
+        render();
+      } else if (key === "\r" || key === "\n") {
+        cleanup();
+        resolve(items[cursor].value);
+      } else if (key === "q" || key === "Q" || key === "\x1B" || key === "") {
+        cleanup();
+        reject(new MultiselectCancelled());
+      }
+    }
+    stdin.on("data", onData);
+    render();
+  });
+}
+
+// src/commands/sync/scanners.ts
+import { createHash } from "crypto";
+import { readdirSync, readFileSync as readFileSync2, statSync, lstatSync, existsSync as existsSync2, realpathSync } from "fs";
+import { homedir } from "os";
+import { basename, join, relative, sep } from "path";
+
+// src/commands/sync/skill-manifest.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+var SKILL_MANIFEST_FILE = ".skill-manifest.json";
+function isSkillScope(value) {
+  return value === "personal" || value === "company" || value === "system";
+}
+function uniqueEntries(entries) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const entry of entries) {
+    if (seen.has(entry.dirName)) continue;
+    seen.add(entry.dirName);
+    out.push(entry);
+  }
+  return out;
+}
+function readSkillManifestEntries(manifestPath) {
+  if (!existsSync(manifestPath)) return [];
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(manifestPath, "utf8"));
+  } catch {
+    return [];
+  }
+  if (Array.isArray(parsed)) {
+    const entries = [];
+    for (const item of parsed) {
+      if (!item || typeof item !== "object") continue;
+      const entry = item;
+      if (typeof entry.dirName !== "string" || !isSkillScope(entry.scope))
+        continue;
+      entries.push({ dirName: entry.dirName, scope: entry.scope });
+    }
+    return uniqueEntries(entries);
+  }
+  return [];
+}
+function writeSkillManifestEntries(manifestPath, entries) {
+  writeFileSync(
+    manifestPath,
+    JSON.stringify(uniqueEntries(entries), null, 2) + "\n",
+    "utf8"
+  );
+}
+
+// src/commands/sync/scanners.ts
+var SECRET_PATTERN = /TOKEN|SECRET|KEY|PASSWORD/i;
+function safeLstat(p) {
+  try {
+    return lstatSync(p);
+  } catch {
+    return null;
+  }
+}
+function safeReaddir(p) {
+  try {
+    return readdirSync(p);
+  } catch {
+    return [];
+  }
+}
+function readSkillFile(filePath) {
+  try {
+    const content = readFileSync2(filePath, "utf8");
+    const stat = statSync(filePath);
+    return { content, mtime: stat.mtime };
+  } catch {
+    return null;
+  }
+}
+function sha256(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+function getCurrentWorkspace(home = process.env.HOME || homedir()) {
+  const cwd = process.cwd();
+  const wsRoot = join(home, "workspaces");
+  const rel = relative(wsRoot, cwd);
+  if (rel !== "" && !rel.startsWith("..") && !rel.startsWith(sep)) {
+    const name = rel.split(sep)[0];
+    return { dir: join(wsRoot, name), name };
+  }
+  if (existsSync2(join(cwd, ".claude"))) {
+    return { dir: cwd, name: basename(cwd) };
+  }
+  return null;
+}
+function readSkillScopeIndex(skillsRoot) {
+  const entries = readSkillManifestEntries(join(skillsRoot, SKILL_MANIFEST_FILE));
+  return new Map(entries.map((entry) => [entry.dirName, entry.scope]));
+}
+function scanSkillsInDir(dir, source, workspacePath) {
+  if (!existsSync2(dir)) return [];
+  const out = [];
+  const scopeIndex = readSkillScopeIndex(dir);
+  for (const slug of safeReaddir(dir)) {
+    const scope = scopeIndex.get(slug);
+    if (scope === "system" || scope === "company") continue;
+    const slugDir = join(dir, slug);
+    const lst = safeLstat(slugDir);
+    if (!lst) continue;
+    const isSymlink = lst.isSymbolicLink();
+    let isDir = lst.isDirectory();
+    if (isSymlink) {
+      try {
+        isDir = statSync(slugDir).isDirectory();
+      } catch {
+        continue;
+      }
+    }
+    if (!isDir) continue;
+    const filePath = join(slugDir, "SKILL.md");
+    if (!existsSync2(filePath)) continue;
+    const file = readSkillFile(filePath);
+    if (!file) continue;
+    out.push({
+      slug,
+      source,
+      workspacePath,
+      dirPath: slugDir,
+      filePath,
+      content: file.content,
+      checksum: sha256(file.content),
+      mtime: file.mtime.toISOString(),
+      isSymlink
+    });
+  }
+  return out;
+}
+function scanSkills() {
+  const home = process.env.HOME || homedir();
+  const workspace = getCurrentWorkspace(home);
+  if (!workspace) return [];
+  return scanSkillsInDir(join(workspace.dir, ".claude", "skills"), "workspace", workspace.name);
+}
+function readJsonSafe(p) {
+  try {
+    return JSON.parse(readFileSync2(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function detectSecrets(env) {
+  if (!env) return false;
+  return Object.keys(env).some((k) => SECRET_PATTERN.test(k));
+}
+function parseMcpServers(servers, source, workspacePath, options = { filterScope: true }) {
+  if (!servers || typeof servers !== "object") return [];
+  const out = [];
+  for (const [slug, raw] of Object.entries(servers)) {
+    if (!raw || typeof raw !== "object") continue;
+    if (options.filterScope && (raw._scope === "system" || raw._scope === "company")) continue;
+    const transport = raw.type === "http" || raw.transport === "http" || typeof raw.url === "string" ? "http" : "stdio";
+    const env = raw.env && typeof raw.env === "object" ? raw.env : void 0;
+    const headers = raw.headers && typeof raw.headers === "object" ? raw.headers : void 0;
+    out.push({
+      slug,
+      source,
+      workspacePath,
+      transport,
+      url: typeof raw.url === "string" ? raw.url : void 0,
+      command: typeof raw.command === "string" ? raw.command : void 0,
+      args: Array.isArray(raw.args) ? raw.args.map(String) : void 0,
+      env,
+      headers,
+      hasSecrets: detectSecrets(env)
+    });
+  }
+  return out;
+}
+function normalizeProjectPath(p) {
+  const trimmed = p.replace(/\/+$/, "");
+  try {
+    return statSync(trimmed).isDirectory() ? realpathSync(trimmed).replace(/\/+$/, "") : trimmed;
+  } catch {
+    return trimmed;
+  }
+}
+function projectMcpServers(data, workspaceDir) {
+  const projects = data?.projects;
+  if (!projects || typeof projects !== "object") return void 0;
+  const normalizedWorkspaceDir = workspaceDir.replace(/\/+$/, "");
+  const project = projects[normalizedWorkspaceDir] || projects[`${normalizedWorkspaceDir}/`] || projects[process.cwd()] || projects[process.cwd().replace(/\/+$/, "")];
+  if (project && typeof project === "object") return project.mcpServers;
+  const realWorkspaceDir = normalizeProjectPath(workspaceDir);
+  for (const [projectPath, projectConfig] of Object.entries(projects)) {
+    if (normalizeProjectPath(projectPath) !== realWorkspaceDir) continue;
+    return projectConfig && typeof projectConfig === "object" ? projectConfig.mcpServers : void 0;
+  }
+  return void 0;
+}
+function scanMcps() {
+  const home = process.env.HOME || homedir();
+  const workspace = getCurrentWorkspace(home);
+  if (!workspace) return [];
+  const out = [];
+  const scopedMcpJson = readJsonSafe(join(workspace.dir, ".mcp.json"));
+  out.push(...parseMcpServers(scopedMcpJson?.mcpServers, "workspace", workspace.name, { filterScope: true }));
+  const workspaceClaudeJson = readJsonSafe(join(workspace.dir, ".claude", ".claude.json"));
+  out.push(
+    ...parseMcpServers(projectMcpServers(workspaceClaudeJson, workspace.dir), "workspace", workspace.name, {
+      filterScope: false
+    })
+  );
+  const globalClaudeJson = readJsonSafe(join(home, ".claude.json"));
+  out.push(
+    ...parseMcpServers(projectMcpServers(globalClaudeJson, workspace.dir), "global", void 0, {
+      filterScope: false
+    })
+  );
+  return out;
+}
+function describeSource(_c) {
+  return void 0;
+}
+
+export {
+  MultiselectCancelled,
+  promptMultiselect,
+  promptSingleCheckboxSelect,
+  promptSingleSelect,
+  SKILL_MANIFEST_FILE,
+  readSkillManifestEntries,
+  writeSkillManifestEntries,
+  getCurrentWorkspace,
+  scanSkills,
+  scanMcps,
+  describeSource
+};

package/dist/{chunk-KM57HI5B.js → chunk-B4UL2VIJ.js}

@@ -1,3 +1,7 @@
+import {
+  logger
+} from "./chunk-MNHE6SSI.js";
+
 // src/framework/output.ts
 import Table from "cli-table3";
 var KNOWN_ARRAY_FIELDS = [
@@ -95,7 +99,9 @@ function formatError(type, message, hint, code) {
   return JSON.stringify(envelope, null, 2);
 }
 function printError(type, message, hint, code) {
-  process.stderr.write(formatError(type, message, hint, code) + "\n");
+  const formatted = formatError(type, message, hint, code);
+  process.stderr.write(formatted + "\n");
+  logger.error(`[${type}] ${message}${hint ? " | " + hint : ""}`);
 }
 function printOutput(data, format, jqExpr) {
   process.stdout.write(formatOutput(data, format, jqExpr) + "\n");

package/dist/{chunk-TMMUBSKW.js → chunk-BI5ZVD6T.js}

@@ -1,3 +1,7 @@
+import {
+  logger
+} from "./chunk-MNHE6SSI.js";
+
 // src/core/json-utils.ts
 import fs from "fs";
 import { createRequire } from "module";
@@ -18,7 +22,7 @@ import path from "path";
 var CONFIG_DIR = path.join(process.env.HOME || "", ".ae-cli");
 var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
 var MCP_TOKENS_FILE = path.join(CONFIG_DIR, "mcp-tokens.json");
-var FALLBACK_MCP_TOKEN_FILE = "/data/app/te_agent_ta/.ae-config/mcp-token.json";
+var FALLBACK_MCP_TOKEN_FILE = "/home/ta/te_agent_ta/.ae-config/mcp-token.json";
 function ensureDir() {
   if (!fs2.existsSync(CONFIG_DIR)) fs2.mkdirSync(CONFIG_DIR, { recursive: true });
 }
@@ -78,11 +82,13 @@ function loadConfig() {
 `);
       process.stderr.write(`[ae-cli] MCP tokens migrated from ${FALLBACK_MCP_TOKEN_FILE}
 `);
+      logger.info(`MCP tokens migrated from fallback: activeHost=${activeHost}, hosts=${Object.keys(hosts).length}`);
       const config = { activeHost, hosts };
       saveConfig(config);
       return config;
     }
   } catch (err) {
+    logger.error(`Error loading config: ${err.message}`);
     console.error(`Error loading config: ${err.message}`);
   }
   return { activeHost: "", hosts: {} };
@@ -105,6 +111,7 @@ function migrateConfig(old) {
 function saveConfig(config) {
   ensureDir();
   fs2.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+  logger.info(`Config saved: activeHost=${config.activeHost}, hosts=${Object.keys(config.hosts).length}`);
 }
 function getActiveHost() {
   const config = loadConfig();

package/dist/chunk-MNHE6SSI.js

@@ -0,0 +1,79 @@
+// src/core/logger.ts
+import fs from "fs";
+import path from "path";
+var LOG_DIR = path.join(process.env.HOME || "", ".ae-cli", "log");
+var Logger = class {
+  logDir;
+  date;
+  constructor() {
+    this.logDir = LOG_DIR;
+    this.date = this.today();
+    this.ensureDir();
+  }
+  today() {
+    const d = /* @__PURE__ */ new Date();
+    return `${d.getFullYear()}${String(d.getMonth() + 1).padStart(2, "0")}${String(d.getDate()).padStart(2, "0")}`;
+  }
+  timestamp() {
+    return (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").split(".")[0];
+  }
+  ensureDir() {
+    if (!fs.existsSync(this.logDir)) {
+      fs.mkdirSync(this.logDir, { recursive: true });
+    }
+  }
+  filePath(level) {
+    const today = this.today();
+    if (today !== this.date) {
+      this.date = today;
+    }
+    return path.join(this.logDir, `${this.date}_${level}.log`);
+  }
+  /**
+   * 写入日志到文件（不输出到控制台，控制台由现有 process.stderr.write 负责）
+   */
+  write(level, message) {
+    const ts = this.timestamp();
+    const line = `[${ts}] ${message}
+`;
+    try {
+      fs.appendFileSync(this.filePath(level), line);
+    } catch {
+    }
+  }
+  /** 常规操作日志 */
+  info(message) {
+    this.write("info", message);
+  }
+  /** 警告日志 */
+  warn(message) {
+    this.write("warning", message);
+  }
+  /** 错误日志 */
+  error(message) {
+    this.write("error", message);
+  }
+  /** 记录 HTTP API 请求详情 */
+  api(method, url, status, reqBody, respBody) {
+    const parts = [`API ${method} ${url} \u2192 HTTP ${status}`];
+    if (reqBody !== void 0 && reqBody !== null) {
+      const s = typeof reqBody === "string" ? reqBody : JSON.stringify(reqBody);
+      parts.push(`REQ: ${s.slice(0, 500)}`);
+    }
+    if (respBody !== void 0 && respBody !== null) {
+      const s = typeof respBody === "string" ? respBody : JSON.stringify(respBody);
+      parts.push(`RESP: ${s.slice(0, 500)}`);
+    }
+    this.info(parts.join(" | "));
+  }
+  /** 记录命令执行 */
+  command(name, args) {
+    const filtered = Object.entries(args).filter(([, v]) => v !== void 0 && v !== null && v !== "").map(([k, v]) => `--${k}=${JSON.stringify(v)}`).join(" ");
+    this.info(`CMD ${name}${filtered ? " " + filtered : ""}`);
+  }
+};
+var logger = new Logger();
+
+export {
+  logger
+};