@thinkingai/ae-cli 6.1.18 → 6.1.20

package/dist/sync-YV3E66IF.js

@@ -0,0 +1,520 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  SKILL_MANIFEST_FILE,
+  assertValidMcpName,
+  assertValidSkillSlug,
+  describeSource,
+  getCurrentWorkspace,
+  readSkillManifestEntries,
+  scanMcps,
+  scanSkills,
+  splitPushableMcps,
+  writeSkillManifestEntries
+} from "./chunk-JQ3ENZZH.js";
+import {
+  MultiselectCancelled,
+  promptMultiselect,
+  promptSingleSelect
+} from "./chunk-7K24F7T2.js";
+import {
+  assertSkillDocumentSize
+} from "./chunk-T6OSFQZD.js";
+import {
+  require_lib
+} from "./chunk-I4WQAEYB.js";
+import {
+  TeAgentApiError,
+  TeAgentCredentialsError,
+  getSandboxSyncPullCandidates,
+  postSandboxSyncPull,
+  postToMainApp,
+  uploadToMainApp
+} from "./chunk-BBEFP4SB.js";
+import {
+  printError
+} from "./chunk-CZU3V3DQ.js";
+import "./chunk-Y74WTIKJ.js";
+import "./chunk-ATSM5XAW.js";
+import "./chunk-WZ6YVQSF.js";
+import {
+  __toESM
+} from "./chunk-4P355ZWB.js";
+
+// src/commands/sync/index.ts
+var import_jszip = __toESM(require_lib(), 1);
+import Table from "cli-table3";
+import { lstatSync, readFileSync as readFileSync2, readdirSync } from "fs";
+import { join, relative } from "path";
+
+// src/commands/sync/local-copy.ts
+import { existsSync, readFileSync, statSync, writeFileSync } from "fs";
+import path from "path";
+var MCP_MANIFEST_FILE = ".mcp-manifest.json";
+function isMcpScope(value) {
+  return value === "personal" || value === "company" || value === "system";
+}
+function uniqueMcpEntries(entries) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const entry of entries) {
+    if (seen.has(entry.name)) continue;
+    seen.add(entry.name);
+    out.push(entry);
+  }
+  return out;
+}
+function readMcpManifestEntries(manifestPath) {
+  if (!existsSync(manifestPath)) return [];
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(manifestPath, "utf8"));
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(parsed)) return [];
+  const entries = [];
+  for (const item of parsed) {
+    if (!item || typeof item !== "object") continue;
+    const entry = item;
+    if (typeof entry.name !== "string" || !isMcpScope(entry.scope)) continue;
+    entries.push({ name: entry.name, scope: entry.scope });
+  }
+  return uniqueMcpEntries(entries);
+}
+function writeMcpManifestEntries(manifestPath, entries) {
+  writeFileSync(
+    manifestPath,
+    JSON.stringify(uniqueMcpEntries(entries), null, 2) + "\n",
+    "utf8"
+  );
+}
+function updateSkillManifestForSource(sourceDir, slug) {
+  assertValidSkillSlug(slug);
+  const sourceAbs = path.resolve(sourceDir);
+  if (!statSync(sourceAbs).isDirectory()) {
+    throw new Error(`Skill source path is not a directory: ${sourceDir}`);
+  }
+  const manifestPath = path.join(path.dirname(sourceAbs), SKILL_MANIFEST_FILE);
+  const manifest = readSkillManifestEntries(manifestPath);
+  const nextEntry = { dirName: slug, scope: "personal" };
+  const existingIndex = manifest.findIndex((entry) => entry.dirName === slug);
+  if (existingIndex >= 0 && manifest[existingIndex].scope === nextEntry.scope) {
+    return { manifestPath, changed: false };
+  }
+  const nextManifest = manifest.slice();
+  if (existingIndex >= 0) {
+    nextManifest[existingIndex] = nextEntry;
+  } else {
+    nextManifest.push(nextEntry);
+  }
+  writeSkillManifestEntries(manifestPath, nextManifest);
+  return { manifestPath, changed: true };
+}
+function updateMcpManifestForProjectSource(workspaceDir, name) {
+  assertValidMcpName(name);
+  const workspaceAbs = path.resolve(workspaceDir);
+  if (!statSync(workspaceAbs).isDirectory()) {
+    throw new Error(`MCP workspace path is not a directory: ${workspaceDir}`);
+  }
+  const manifestPath = path.join(workspaceAbs, MCP_MANIFEST_FILE);
+  const manifest = readMcpManifestEntries(manifestPath);
+  const nextEntry = { name, scope: "personal" };
+  const existingIndex = manifest.findIndex((entry) => entry.name === name);
+  if (existingIndex >= 0 && manifest[existingIndex].scope === nextEntry.scope) {
+    return { manifestPath, changed: false };
+  }
+  const nextManifest = manifest.slice();
+  if (existingIndex >= 0) {
+    nextManifest[existingIndex] = nextEntry;
+  } else {
+    nextManifest.push(nextEntry);
+  }
+  writeMcpManifestEntries(manifestPath, nextManifest);
+  return { manifestPath, changed: true };
+}
+
+// src/commands/sync/index.ts
+function redactEnv(env) {
+  if (!env) return void 0;
+  const out = {};
+  for (const [k, v] of Object.entries(env)) {
+    if (/TOKEN|SECRET|KEY|PASSWORD/i.test(k)) {
+      out[k] = "***";
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+var SOURCE_ORDER = {
+  global: 0,
+  workspace: 1,
+  project: 0,
+  local: 1,
+  user: 2
+};
+function skillToItem(s) {
+  return {
+    kind: "skill",
+    slug: s.slug,
+    scope: "personal",
+    source: s.source,
+    workspacePath: s.workspacePath,
+    event: "upsert",
+    dirPath: s.dirPath,
+    content: s.content,
+    checksum: s.checksum,
+    mtime: s.mtime
+  };
+}
+function mcpToItem(m, includeSecrets) {
+  return {
+    kind: "mcp",
+    slug: m.slug,
+    scope: "personal",
+    source: m.source,
+    workspacePath: m.workspacePath,
+    workspaceDir: m.workspaceDir,
+    event: "upsert",
+    transport: m.transport,
+    url: m.url,
+    command: m.command,
+    args: m.args,
+    env: includeSecrets ? m.env : redactEnv(m.env),
+    headers: m.headers
+  };
+}
+async function selectSkills() {
+  const all = scanSkills();
+  if (all.length === 0) {
+    process.stderr.write("No Skills found (scanned current workspace .claude/skills)\n");
+    return [];
+  }
+  all.sort((a, b) => {
+    if (a.source !== b.source) return SOURCE_ORDER[a.source] - SOURCE_ORDER[b.source];
+    return a.slug.localeCompare(b.slug);
+  });
+  const items = all.map((s) => ({
+    value: s,
+    label: s.slug,
+    group: describeSource(s),
+    hint: s.isSymlink ? "(symlink)" : void 0
+  }));
+  const picked = await promptMultiselect({
+    title: "Select Skills to push to the main app",
+    items
+  });
+  return picked.map(skillToItem);
+}
+async function selectMcps(includeSecrets) {
+  const all = scanMcps();
+  if (all.length === 0) {
+    process.stderr.write(
+      "No MCPs found (scanned current workspace .mcp.json / .claude/.claude.json and global ~/.claude.json)\n"
+    );
+    return [];
+  }
+  const { supported, unsupportedStdio } = splitPushableMcps(all);
+  if (unsupportedStdio.length > 0) {
+    const names = unsupportedStdio.map((m) => m.slug).sort().join(", ");
+    process.stderr.write(`ae-cli sync push only supports http/sse MCPs; skipped stdio MCPs: ${names}
+`);
+  }
+  if (supported.length === 0) {
+    process.stderr.write("No syncable MCPs found. ae-cli sync push only supports http/sse.\n");
+    return [];
+  }
+  supported.sort((a, b) => {
+    if (a.source !== b.source) return SOURCE_ORDER[a.source] - SOURCE_ORDER[b.source];
+    return a.slug.localeCompare(b.slug);
+  });
+  const items = supported.map((m) => ({
+    value: m,
+    label: m.slug,
+    group: describeSource(m),
+    hint: m.hasSecrets && !includeSecrets ? "(env redacted)" : void 0
+  }));
+  const picked = await promptMultiselect({
+    title: "Select MCPs to push to the main app",
+    items
+  });
+  return picked.map((m) => mcpToItem(m, includeSecrets));
+}
+function renderResults(results) {
+  const table = new Table({
+    head: ["kind", "slug", "status", "message"],
+    wordWrap: true
+  });
+  for (const r of results) {
+    table.push([r.kind, r.slug, r.status, r.message ?? ""]);
+  }
+  process.stdout.write(table.toString() + "\n");
+  const failed = results.filter((r) => r.status === "failed").length;
+  if (failed > 0) {
+    process.stderr.write(`
+\u2717 ${failed} item(s) failed
+`);
+  }
+}
+async function selectPullResources(args) {
+  const all = args.candidates.filter((candidate) => candidate.selected).sort((a, b) => {
+    const scopeOrder = {
+      system: 0,
+      company: 1,
+      personal: 2
+    };
+    const scopeDiff = scopeOrder[a.scope] - scopeOrder[b.scope];
+    return scopeDiff !== 0 ? scopeDiff : a.name.localeCompare(b.name);
+  });
+  if (all.length === 0) {
+    process.stderr.write(`${args.title}: no candidates available to sync
+`);
+    return [];
+  }
+  const items = all.map((candidate) => ({
+    value: candidate,
+    label: `${candidate.name}  ${candidate.scope}`,
+    preselected: true
+  }));
+  return promptMultiselect({ title: args.title, items });
+}
+function toHttpItems(items) {
+  return items.map((item) => {
+    if (item.kind === "skill") {
+      const { kind: _kind2, dirPath: _dirPath, ...rest2 } = item;
+      return rest2;
+    }
+    const { kind: _kind, workspaceDir: _workspaceDir, ...rest } = item;
+    return rest;
+  });
+}
+async function pushItems(kind, items) {
+  if (items.length === 0) return { results: [] };
+  try {
+    const resp = await postToMainApp("/api/sandbox/sync/push", {
+      kind,
+      items: toHttpItems(items)
+    });
+    return { results: resp.results ?? [] };
+  } catch (err) {
+    if (err instanceof TeAgentApiError) {
+      return {
+        results: items.map((it) => ({
+          kind: it.kind,
+          slug: it.slug,
+          status: "failed",
+          message: `${err.code ?? err.status} ${err.message}`
+        }))
+      };
+    }
+    throw err;
+  }
+}
+function readSkillVersion(content) {
+  const frontmatter = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content)?.[1];
+  if (!frontmatter) return void 0;
+  const matches = [...frontmatter.matchAll(/^version\s*:\s*(.+?)\s*(?:#.*)?$/gm)];
+  if (matches.length !== 1) return void 0;
+  const value = matches[0][1].trim().replace(/^(['"])(.*)\1$/, "$2");
+  return /^(0|[1-9]\d*)\.(0|[1-9]\d*)$/.test(value) ? value : void 0;
+}
+async function buildSkillZip(dirPath) {
+  const zip = new import_jszip.default();
+  const visit = (dir) => {
+    for (const name of readdirSync(dir)) {
+      if (name === ".DS_Store") continue;
+      const absolute = join(dir, name);
+      const stat = lstatSync(absolute);
+      if (stat.isSymbolicLink()) {
+        throw new Error(`Skill package contains a symlink: ${relative(dirPath, absolute)}`);
+      }
+      if (stat.isDirectory()) visit(absolute);
+      else if (stat.isFile()) {
+        const content = readFileSync2(absolute);
+        if (relative(dirPath, absolute).replaceAll("\\", "/") === "SKILL.md") {
+          assertSkillDocumentSize(content);
+        }
+        zip.file(relative(dirPath, absolute).replaceAll("\\", "/"), content);
+      }
+    }
+  };
+  visit(dirPath);
+  return zip.generateAsync({ type: "nodebuffer", compression: "DEFLATE" });
+}
+var defaultPushSkillDependencies = {
+  upload: (path2, formData) => uploadToMainApp(path2, formData),
+  updateManifest: updateSkillManifestForSource
+};
+async function pushSkillItems(items, dependencies = defaultPushSkillDependencies) {
+  const results = [];
+  for (const item of items) {
+    try {
+      const buffer = await buildSkillZip(item.dirPath);
+      const formData = new FormData();
+      formData.append("file", new Blob([new Uint8Array(buffer)], { type: "application/zip" }), `${item.slug}.zip`);
+      formData.append("slug", item.slug);
+      formData.append("source", item.source);
+      if (item.workspacePath) formData.append("workspacePath", item.workspacePath);
+      const version = readSkillVersion(item.content);
+      if (version) formData.append("version", version);
+      const response = await dependencies.upload("/api/sandbox/sync/push/skill", formData);
+      dependencies.updateManifest(item.dirPath, item.slug);
+      results.push({
+        kind: "skill",
+        slug: item.slug,
+        status: "synced",
+        ...!response.workspaceEnabled && item.source === "workspace" ? {
+          message: "Skill synced, but it was not enabled in the current workspace"
+        } : {}
+      });
+    } catch (err) {
+      const message = err instanceof TeAgentApiError ? `${err.code ?? err.status} ${err.message}` : err?.message ?? String(err);
+      results.push({
+        kind: "skill",
+        slug: item.slug,
+        status: "failed",
+        message
+      });
+    }
+  }
+  return { results };
+}
+function updateSyncedProjectMcpManifest(mcpItems, resp) {
+  if (mcpItems.length === 0) return;
+  const bySlug = new Map(mcpItems.map((item) => [item.slug, item]));
+  for (const result of resp.results) {
+    if (result.kind !== "mcp" || result.status !== "synced") continue;
+    const item = bySlug.get(result.slug);
+    if (!item || item.source !== "project") continue;
+    if (!item.workspaceDir) {
+      result.status = "failed";
+      result.message = "Main app synced the MCP, but local MCP manifest update failed: missing workspaceDir";
+      continue;
+    }
+    try {
+      updateMcpManifestForProjectSource(item.workspaceDir, item.slug);
+    } catch (err) {
+      result.status = "failed";
+      result.message = `Main app synced the MCP, but local MCP manifest update failed: ${err?.message ?? String(err)}`;
+    }
+  }
+}
+async function selectDirection(optsDirection) {
+  if (optsDirection === "push" || optsDirection === "pull") return optsDirection;
+  if (optsDirection) {
+    throw new Error("--direction must be push or pull");
+  }
+  return promptSingleSelect({
+    title: "Sync direction?",
+    items: [
+      { value: "push", label: "Workspace -> Main app" },
+      { value: "pull", label: "Main app -> Workspace" }
+    ]
+  });
+}
+async function selectKind(optsKind) {
+  if (optsKind === "skill" || optsKind === "mcp" || optsKind === "both") return optsKind;
+  if (optsKind) {
+    throw new Error("--kind must be skill, mcp, or both");
+  }
+  return promptSingleSelect({
+    title: "Which resource type to sync?",
+    items: [
+      { value: "skill", label: "Skills" },
+      { value: "mcp", label: "MCPs" },
+      { value: "both", label: "Skills + MCPs" }
+    ]
+  });
+}
+async function runPush(kind, includeSecrets) {
+  const skillItems = kind !== "mcp" ? await selectSkills() : [];
+  const mcpItems = kind !== "skill" ? await selectMcps(includeSecrets) : [];
+  if (skillItems.length === 0 && mcpItems.length === 0) {
+    process.stderr.write("Nothing selected, exiting\n");
+    return;
+  }
+  process.stderr.write(`Pushing ${skillItems.length} Skill(s) / ${mcpItems.length} MCP(s) ...
+`);
+  const allResults = [];
+  if (skillItems.length > 0) {
+    const skillResp = await pushSkillItems(skillItems);
+    allResults.push(...skillResp.results);
+  }
+  if (mcpItems.length > 0) {
+    const mcpResp = await pushItems("mcp", mcpItems);
+    updateSyncedProjectMcpManifest(mcpItems, mcpResp);
+    allResults.push(...mcpResp.results);
+  }
+  renderResults(allResults);
+}
+function pullResultRows(resp) {
+  return (resp.results ?? []).map((result) => ({
+    kind: result.kind,
+    slug: result.name,
+    status: result.status,
+    message: result.message
+  }));
+}
+async function runPull(kind) {
+  const workspace = getCurrentWorkspace();
+  if (!workspace) {
+    throw new Error("Current workspace not recognized; please run from within /home/ta/workspaces/<workspace>");
+  }
+  const candidates = await getSandboxSyncPullCandidates({
+    workspacePath: workspace.name,
+    kind
+  });
+  const skillItems = kind !== "mcp" ? await selectPullResources({
+    title: "Select Skills to sync to workspace",
+    candidates: (candidates.skills ?? []).filter((candidate) => candidate.scope !== "system")
+  }) : [];
+  const mcpItems = kind !== "skill" ? await selectPullResources({
+    title: "Select MCPs to sync to workspace",
+    candidates: candidates.mcp ?? []
+  }) : [];
+  if (skillItems.length === 0 && mcpItems.length === 0) {
+    process.stderr.write("Nothing selected, exiting\n");
+    return;
+  }
+  process.stderr.write(`Syncing to workspace: ${skillItems.length} Skill(s) / ${mcpItems.length} MCP(s) ...
+`);
+  const resp = await postSandboxSyncPull({
+    workspacePath: workspace.name,
+    kind,
+    skills: skillItems.map((item) => item.id),
+    mcp: mcpItems.map((item) => item.id)
+  });
+  renderResults(pullResultRows(resp));
+}
+function registerSync(program) {
+  program.command("sync").description("Sync Skills / MCPs between current workspace and te-claude main app").option("--direction <direction>", "push | pull (skip interactive direction picker)").option("--include-secrets", "Include MCP env secrets (TOKEN/SECRET/KEY) in push", false).option("--kind <kind>", "skill | mcp | both (skip interactive picker)").action(async (opts) => {
+    try {
+      const direction = await selectDirection(opts.direction);
+      const kind = await selectKind(opts.kind);
+      if (direction === "push") await runPush(kind, !!opts.includeSecrets);
+      else await runPull(kind);
+    } catch (err) {
+      if (err instanceof MultiselectCancelled) {
+        process.stderr.write("Cancelled\n");
+        return;
+      }
+      if (err instanceof TeAgentCredentialsError) {
+        printError("config", err.message, err.hint);
+        process.exit(1);
+      }
+      if (err instanceof TeAgentApiError) {
+        printError("api", err.message, err.code);
+        process.exit(1);
+      }
+      const e = err;
+      printError("api", e?.message ?? String(err));
+      process.exit(1);
+    }
+  });
+}
+export {
+  buildSkillZip,
+  pushSkillItems,
+  readSkillVersion,
+  registerSync
+};