@thinkingai/ae-cli 1.0.24 → 1.0.28

package/dist/sync-NRODEVNH.js

@@ -0,0 +1,385 @@
+import {
+  MultiselectCancelled,
+  SKILL_MANIFEST_FILE,
+  describeSource,
+  getCurrentWorkspace,
+  promptMultiselect,
+  promptSingleSelect,
+  readSkillManifestEntries,
+  scanMcps,
+  scanSkills,
+  writeSkillManifestEntries
+} from "./chunk-IMBKVXKY.js";
+import {
+  TeAgentApiError,
+  getSandboxSyncPullCandidates,
+  postSandboxSyncPull,
+  postToMainApp
+} from "./chunk-AD5V3ZPJ.js";
+import {
+  TeAgentCredentialsError
+} from "./chunk-KAEZTSXN.js";
+import {
+  printError
+} from "./chunk-CLJF7MQA.js";
+import "./chunk-SRJIAOBN.js";
+
+// src/commands/sync/index.ts
+import Table from "cli-table3";
+
+// src/commands/sync/local-copy.ts
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  realpathSync,
+  rmSync,
+  statSync
+} from "fs";
+import path from "path";
+var SKILL_SLUG_RE = /^[a-z0-9-]+$/;
+function updateSkillManifestForSource(sourceDir, slug) {
+  if (!SKILL_SLUG_RE.test(slug)) {
+    throw new Error(`Invalid Skill slug: ${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 copySkillPackageToTarget(args) {
+  if (!SKILL_SLUG_RE.test(args.slug)) {
+    throw new Error(`Invalid Skill slug: ${args.slug}`);
+  }
+  if (!path.isAbsolute(args.targetRoot)) {
+    throw new Error(`skillTargetRoot must be an absolute path: ${args.targetRoot}`);
+  }
+  const sourceReal = realpathSync(args.sourceDir);
+  if (!statSync(sourceReal).isDirectory()) {
+    throw new Error(`Skill source path is not a directory: ${args.sourceDir}`);
+  }
+  const targetDir = path.join(args.targetRoot, args.slug);
+  const targetAbs = path.resolve(targetDir);
+  if (targetAbs === sourceReal || targetAbs.startsWith(`${sourceReal}${path.sep}`)) {
+    return { targetDir, skipped: true };
+  }
+  if (existsSync(targetDir)) {
+    const targetReal = realpathSync(targetDir);
+    if (targetReal === sourceReal) {
+      return { targetDir, skipped: true };
+    }
+    rmSync(targetDir, { recursive: true, force: true });
+  }
+  mkdirSync(args.targetRoot, { recursive: true });
+  cpSync(sourceReal, targetDir, { recursive: true, dereference: true });
+  return { targetDir, skipped: false };
+}
+
+// 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;
+}
+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,
+    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 a.source === "global" ? -1 : 1;
+    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 [];
+  }
+  all.sort((a, b) => {
+    if (a.source !== b.source) return a.source === "global" ? -1 : 1;
+    return a.slug.localeCompare(b.slug);
+  });
+  const items = all.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, ...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 { skillTargetRoot: resp.skillTargetRoot, 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 copySyncedSkillPackages(skillItems, resp) {
+  if (skillItems.length === 0) return;
+  const bySlug = new Map(skillItems.map((item) => [item.slug, item]));
+  for (const result of resp.results) {
+    if (result.kind !== "skill" || result.status !== "synced") continue;
+    const item = bySlug.get(result.slug);
+    if (!item) continue;
+    if (!resp.skillTargetRoot) {
+      result.status = "failed";
+      result.message = "Main app response is missing skillTargetRoot; cannot copy Skill package";
+      continue;
+    }
+    try {
+      const copied = copySkillPackageToTarget({
+        sourceDir: item.dirPath,
+        targetRoot: resp.skillTargetRoot,
+        slug: item.slug
+      });
+      updateSkillManifestForSource(item.dirPath, item.slug);
+      if (copied.skipped) {
+        result.message = "Source directory is already the target directory; local copy skipped";
+      }
+    } catch (err) {
+      result.status = "failed";
+      result.message = `Local copy 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 pushItems("skill", skillItems);
+    copySyncedSkillPackages(skillItems, skillResp);
+    allResults.push(...skillResp.results);
+  }
+  if (mcpItems.length > 0) {
+    const mcpResp = await pushItems("mcp", mcpItems);
+    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 ?? []
+  }) : [];
+  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),
+    ifUnmodifiedSince: candidates.mtime
+  });
+  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 {
+  registerSync
+};