@thinkingai/ae-cli 1.0.24 → 1.0.28

package/dist/chunk-IMBKVXKY.js

@@ -0,0 +1,478 @@
+// src/core/multiselect.ts
+var MultiselectCancelled = class extends Error {
+  constructor() {
+    super("Selection cancelled by user");
+    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 requires a TTY for multi-select; please run in an interactive terminal")
+    );
+  }
+  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: select \xB7 a: select all/none \xB7 enter: confirm \xB7 q: cancel)\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("No items to select"));
+  const stderr = process.stderr;
+  const stdin = process.stdin;
+  if (!stdin.isTTY) return Promise.reject(new Error("A TTY is required for single-select"));
+  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: select \xB7 enter: confirm \xB7 q: cancel)\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("No items to select"));
+  const stderr = process.stderr;
+  const stdin = process.stdin;
+  if (!stdin.isTTY) return Promise.reject(new Error("A TTY is required for single-select"));
+  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-KAEZTSXN.js

@@ -0,0 +1,99 @@
+import {
+  getSandboxRuntimeRoot
+} from "./chunk-SRJIAOBN.js";
+
+// src/core/te-agent-credentials.ts
+import { readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function getCredentialsPath() {
+  return join(process.env.HOME || homedir(), ".te-agent", "credentials.json");
+}
+function getPersistentEnvPath() {
+  return join(getSandboxRuntimeRoot(), ".env");
+}
+function parseDotEnv(raw) {
+  const result = {};
+  for (const line of raw.split("\n")) {
+    if (/^\s*#/.test(line) || line.trim() === "") continue;
+    const match = /^\s*([^=]+)=(.*)$/.exec(line);
+    if (!match) continue;
+    const key = match[1].trim();
+    let value = match[2].trim();
+    if (value.startsWith('"') && value.endsWith('"')) {
+      value = value.slice(1, -1).replace(/\\"/g, '"');
+    }
+    if (value !== "") result[key] = value;
+  }
+  return result;
+}
+function readPersistentEnv() {
+  const envPath = getPersistentEnvPath();
+  try {
+    const raw = readFileSync(envPath, "utf8");
+    return parseDotEnv(raw);
+  } catch (err) {
+    if (err?.code === "ENOENT") return null;
+    throw new TeAgentCredentialsError(
+      `Failed to read ${envPath}: ${err?.message ?? err}`,
+      "Check file permissions, or inject runtime credentials via TE_CLAUDE_BASE_URL / SANDBOX_ID / SECRET_KEY"
+    );
+  }
+}
+var TeAgentCredentialsError = class extends Error {
+  constructor(message, hint) {
+    super(message);
+    this.hint = hint;
+    this.name = "TeAgentCredentialsError";
+  }
+  hint;
+};
+function readLegacyCredentials() {
+  const credPath = getCredentialsPath();
+  try {
+    const raw = readFileSync(credPath, "utf8");
+    const parsed = JSON.parse(raw);
+    const main = parsed?.mainApp;
+    return main && typeof main === "object" ? main : null;
+  } catch (err) {
+    if (err?.code === "ENOENT") return null;
+    if (err instanceof SyntaxError) {
+      throw new TeAgentCredentialsError(
+        `Failed to parse ${credPath}: ${err.message}`,
+        "The credentials file may be corrupted; alternatively inject runtime credentials via TE_CLAUDE_BASE_URL / SANDBOX_ID / SECRET_KEY"
+      );
+    }
+    throw new TeAgentCredentialsError(
+      `Failed to read ${credPath}: ${err?.message ?? err}`,
+      "Check file permissions, or inject runtime credentials via TE_CLAUDE_BASE_URL / SANDBOX_ID / SECRET_KEY"
+    );
+  }
+}
+function tryLoadTeAgentSandboxCredentials() {
+  const legacy = readLegacyCredentials();
+  const persistent = readPersistentEnv();
+  const url = process.env.TE_CLAUDE_BASE_URL || persistent?.TE_CLAUDE_BASE_URL || legacy?.url;
+  if (typeof url !== "string" || !url) {
+    return null;
+  }
+  const sandboxId = process.env.SANDBOX_ID || persistent?.SANDBOX_ID || legacy?.sandboxId || null;
+  const sandboxSecretKey = process.env.SECRET_KEY || process.env.SANDBOX_SECRET_KEY || persistent?.SECRET_KEY || persistent?.SANDBOX_SECRET_KEY || legacy?.sandboxSecretKey || legacy?.secretKey || null;
+  return {
+    url,
+    sandboxId: typeof sandboxId === "string" ? sandboxId : null,
+    sandboxSecretKey: typeof sandboxSecretKey === "string" ? sandboxSecretKey : null
+  };
+}
+function getClaudeConfigDir() {
+  const fromEnv = process.env.CLAUDE_CONFIG_DIR;
+  if (typeof fromEnv === "string" && fromEnv.length > 0) {
+    return fromEnv;
+  }
+  return join(homedir(), ".claude");
+}
+
+export {
+  TeAgentCredentialsError,
+  tryLoadTeAgentSandboxCredentials,
+  getClaudeConfigDir
+};

package/dist/{chunk-MZW6NOVS.js → chunk-LU7SXK4Q.js}

@@ -1,12 +1,13 @@
 import {
+  SecureStoreAuthError,
   clearToken,
   getToken,
   resolveHost
-} from "./chunk-47MTN54I.js";
+} from "./chunk-CAQYQA4R.js";
 import {
   logger,
   safeJsonParse
-} from "./chunk-DC66L5AM.js";
+} from "./chunk-SRJIAOBN.js";
 
 // src/core/client.ts
 import WebSocket from "ws";
@@ -43,9 +44,16 @@ async function request(method, modulePath, params = {}, body = null, retry = tru
   const text = await resp.text();
   const data = safeJsonParse(text);
   logger.api(method, url, resp.status, body, data);
-  if ((resp.status === 401 || resp.status === 403) && retry) {
-    clearToken(resolvedHost);
-    return request(method, modulePath, params, body, false, resolvedHost);
+  if (resp.status === 401) {
+    if (retry) {
+      clearToken(resolvedHost);
+      return request(method, modulePath, params, body, false, resolvedHost);
+    }
+    throw new SecureStoreAuthError(`Session expired or unauthorized for ${resolvedHost}. Please run: ae-cli auth login`);
+  }
+  if (resp.status === 403) {
+    const m = data && typeof data === "object" && typeof data.error === "string" ? data.error : "Permission denied";
+    throw new Error(m);
   }
   if (data.return_code === -1001 && retry) {
     clearToken(resolvedHost);
@@ -62,6 +70,9 @@ async function httpGet(modulePath, params = {}, hostUrl) {
 async function httpPost(modulePath, params = {}, body, hostUrl) {
   return request("POST", modulePath, params, body ?? {}, true, hostUrl);
 }
+async function httpRequest(method, modulePath, params = {}, body, hostUrl) {
+  return request(method.toUpperCase(), modulePath, params, body ?? {}, true, hostUrl);
+}
 async function httpDelete(modulePath, params = {}, body, hostUrl) {
   return request("DELETE", modulePath, params, body ?? null, true, hostUrl);
 }
@@ -76,9 +87,16 @@ async function uploadRequest(modulePath, form, params = {}, retry = true, hostUr
   const text = await resp.text();
   const data = safeJsonParse(text);
   logger.api("POST", url, resp.status, { upload: true }, data);
-  if ((resp.status === 401 || resp.status === 403) && retry) {
-    clearToken(resolvedHost);
-    return uploadRequest(modulePath, form, params, false, resolvedHost);
+  if (resp.status === 401) {
+    if (retry) {
+      clearToken(resolvedHost);
+      return uploadRequest(modulePath, form, params, false, resolvedHost);
+    }
+    throw new SecureStoreAuthError(`Session expired or unauthorized for ${resolvedHost}. Please run: ae-cli auth login`);
+  }
+  if (resp.status === 403) {
+    const m = data && typeof data === "object" && typeof data.error === "string" ? data.error : "Permission denied";
+    throw new Error(m);
   }
   if (data.return_code === -1001 && retry) {
     clearToken(resolvedHost);
@@ -175,6 +193,7 @@ async function queryReportData(projectId, reportId, qp, eventModel, options = {}
 export {
   httpGet,
   httpPost,
+  httpRequest,
   httpDelete,
   httpUpload,
   wsQuery,