cortex-sync 0.2.0 → 0.4.0

package/README.md

@@ -8,6 +8,8 @@ Claude Code stores your session history in `~/.claude/projects/` using absolute
 npm install -g cortex-sync
 ```
 
+![cortex demo](demo/demo.gif)
+
 ---
 
 ## How it works
@@ -59,20 +61,28 @@ Open any project on Machine B — Claude Code shows your full session history.
 | `cortex pull` | Download, decrypt, remap paths |
 | `cortex status` | Show what's out of sync (no download) |
 | `cortex convert <file> --to <target>` | Convert a Claude Code skill |
+| `cortex setup-mcp` | Register cortex as a Claude Code MCP server |
 
 ---
 
 ## Claude Code MCP integration
 
-Install cortex as a Claude Code MCP server to use `sync`, `pull`, `status`, `convert`, and `init` directly from the chat:
+Use `sync`, `pull`, `status`, `convert`, and `init` directly from the Claude Code chat — one command does everything:
 
 ```bash
 npm install -g cortex-sync
-cortex init                           # configure once from terminal
-export CORTEX_PASSPHRASE="..."        # add to ~/.zshrc
-claude mcp add cortex -- cortex mcp  # register in Claude Code
+cortex init       # configure storage and passphrase
+cortex setup-mcp  # registers cortex in Claude Code automatically
 ```
 
+That's it. Restart Claude Code and you're done.
+
+### What setup-mcp does
+
+`cortex setup-mcp` detects the binary path, prompts for your passphrase once, and runs `claude mcp add` with the correct arguments — no manual PATH configuration needed.
+
+### Available MCP tools
+
 | Tool | What it does |
 |---|---|
 | `sync` | Encrypt and upload `~/.claude/` |
@@ -81,7 +91,7 @@ claude mcp add cortex -- cortex mcp  # register in Claude Code
 | `convert` | Convert a skill to Antigravity or Cursor |
 | `init` | Configure storage (non-interactive) |
 
-**Environment variables used by the MCP server:**
+### Environment variables (advanced / manual setup)
 
 | Variable | Required for |
 |---|---|

package/dist/cli.js

@@ -788,9 +788,9 @@ function remapLine(parsed, oldPath, newPath) {
     const content = msg["content"];
     if (Array.isArray(content)) {
       for (const item of content) {
-        const input3 = item["input"];
-        if (input3 !== null && typeof input3 === "object") {
-          const inp = input3;
+        const input4 = item["input"];
+        if (input4 !== null && typeof input4 === "object") {
+          const inp = input4;
           if ("file_path" in inp) {
             inp["file_path"] = remapPath(inp["file_path"], oldPath, newPath);
           }
@@ -799,22 +799,22 @@ function remapLine(parsed, oldPath, newPath) {
     }
   }
 }
-function remapJsonlBuffer(input3, oldPath, newPath) {
-  if (oldPath === newPath) return input3;
+function remapJsonlBuffer(input4, oldPath, newPath) {
+  if (oldPath === newPath) return input4;
   const parts = [];
   let lineStart = 0;
-  for (let i = 0; i <= input3.length; i++) {
-    const atEnd = i === input3.length;
-    const byte = atEnd ? void 0 : input3[i];
+  for (let i = 0; i <= input4.length; i++) {
+    const atEnd = i === input4.length;
+    const byte = atEnd ? void 0 : input4[i];
     const isLF = byte === 10;
     if (!isLF && !atEnd) continue;
     const lineEnd = i;
     let contentEnd = lineEnd;
-    if (contentEnd > lineStart && input3[contentEnd - 1] === 13) {
+    if (contentEnd > lineStart && input4[contentEnd - 1] === 13) {
       contentEnd--;
     }
-    const lineBytes = input3.slice(lineStart, contentEnd);
-    const eolBytes = input3.slice(contentEnd, isLF ? lineEnd + 1 : lineEnd);
+    const lineBytes = input4.slice(lineStart, contentEnd);
+    const eolBytes = input4.slice(contentEnd, isLF ? lineEnd + 1 : lineEnd);
     const lineStr = lineBytes.toString("utf-8").trim();
     if (lineStr.length > 0) {
       try {
@@ -832,8 +832,8 @@ function remapJsonlBuffer(input3, oldPath, newPath) {
   }
   return Buffer.concat(parts);
 }
-function extractCwdFromJsonl(input3) {
-  const text = input3.toString("utf-8");
+function extractCwdFromJsonl(input4) {
+  const text = input4.toString("utf-8");
   for (const line of text.split("\n")) {
     const trimmed = line.trim();
     if (!trimmed) continue;
@@ -1302,6 +1302,402 @@ ${lines.join("\n")}`
   });
 }
 
+// src/commands/setup-mcp.ts
+import { password as password4 } from "@inquirer/prompts";
+import { existsSync as existsSync7 } from "fs";
+import { spawnSync } from "child_process";
+import { dirname as dirname6, join as join11 } from "path";
+async function setupMcpCommand() {
+  const cortexBin = join11(dirname6(process.execPath), "cortex");
+  if (!existsSync7(cortexBin)) {
+    throw new Error(
+      `cortex binary not found at ${cortexBin}.
+Make sure cortex-sync is installed globally: npm install -g cortex-sync`
+    );
+  }
+  console.log(`Found cortex at: ${cortexBin}`);
+  const passphrase = await password4({
+    message: "Encryption passphrase (same one used in cortex init):",
+    mask: "*",
+    validate: (v) => v.length >= 12 || "Minimum 12 characters"
+  });
+  const result = spawnSync(
+    "claude",
+    ["mcp", "add", "cortex", "-e", `CORTEX_PASSPHRASE=${passphrase}`, "--", cortexBin, "mcp"],
+    { stdio: "inherit" }
+  );
+  if (result.error) {
+    throw new Error(
+      `Failed to run "claude" CLI: ${result.error.message}
+Make sure Claude Code CLI is installed and "claude" is in your PATH.`
+    );
+  }
+  if (result.status !== 0) {
+    throw new Error('"claude mcp add" failed. Check the output above for details.');
+  }
+  console.log("\n\u2713 cortex MCP server registered in Claude Code.");
+  console.log("Restart Claude Code (or open a new session) to activate it.");
+  console.log("\nTo verify: claude mcp list");
+}
+
+// src/commands/team/init.ts
+import { input as input3 } from "@inquirer/prompts";
+import { readFile as readFile12, writeFile as writeFile10, mkdir as mkdir10 } from "fs/promises";
+import { join as join15 } from "path";
+
+// src/lib/team-repo.ts
+import { access as access3, mkdir as mkdir8, rm } from "fs/promises";
+import { join as join12 } from "path";
+import { spawnSync as spawnSync2 } from "child_process";
+var TEAM_DIR = join12(CORTEX_DIR, "team");
+function authUrl(repoUrl, token) {
+  return repoUrl.replace("https://", `https://${token}@`);
+}
+async function hasLocalClone(dir = TEAM_DIR) {
+  try {
+    await access3(join12(dir, ".git"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function cloneTeamRepo(repoUrl, token) {
+  await rm(TEAM_DIR, { recursive: true, force: true });
+  await mkdir8(CORTEX_DIR, { recursive: true });
+  const result = spawnSync2(
+    "git",
+    ["clone", authUrl(repoUrl, token), TEAM_DIR],
+    { stdio: "pipe", env: { ...process.env, GIT_TERMINAL_PROMPT: "0" } }
+  );
+  if (result.status !== 0) {
+    throw new Error(`git clone failed: ${result.stderr?.toString().trim()}`);
+  }
+}
+function configureGitUser(dir = TEAM_DIR) {
+  spawnSync2("git", ["-C", dir, "config", "user.email", "cortex@local"], { stdio: "pipe" });
+  spawnSync2("git", ["-C", dir, "config", "user.name", "cortex"], { stdio: "pipe" });
+}
+function pullTeamRepo(dir = TEAM_DIR) {
+  const result = spawnSync2("git", ["-C", dir, "pull", "--ff-only"], {
+    stdio: "pipe",
+    env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+  });
+  if (result.status !== 0) {
+    throw new Error(`git pull failed: ${result.stderr?.toString().trim()}`);
+  }
+}
+function hasPendingChanges(dir = TEAM_DIR) {
+  const result = spawnSync2("git", ["-C", dir, "status", "--porcelain"], { stdio: "pipe" });
+  return (result.stdout?.toString().trim() ?? "") !== "";
+}
+function commitAndPush(repoUrl, token, message, dir = TEAM_DIR) {
+  configureGitUser(dir);
+  spawnSync2("git", ["-C", dir, "add", "-A"], { stdio: "pipe" });
+  if (!hasPendingChanges(dir)) {
+    console.log("Nothing to push \u2014 team repo is already up to date.");
+    return;
+  }
+  const commit = spawnSync2("git", ["-C", dir, "commit", "-m", message], { stdio: "pipe" });
+  if (commit.status !== 0) throw new Error("git commit failed");
+  const push = spawnSync2("git", ["-C", dir, "push", authUrl(repoUrl, token)], {
+    stdio: "pipe",
+    env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+  });
+  if (push.status !== 0) {
+    throw new Error(`git push failed: ${push.stderr?.toString().trim()}`);
+  }
+}
+
+// src/lib/claude-skills.ts
+import { readdir as readdir3, readFile as readFile10, mkdir as mkdir9, writeFile as writeFile9 } from "fs/promises";
+import { homedir as homedir4 } from "os";
+import { join as join13, dirname as dirname7 } from "path";
+var LOCAL_SKILLS_DIR = join13(homedir4(), ".claude", "skills");
+var LOCAL_CLAUDE_MD = join13(homedir4(), ".claude", "CLAUDE.md");
+async function readSkillsFromDir(dir) {
+  const map = /* @__PURE__ */ new Map();
+  let entries;
+  try {
+    entries = await readdir3(dir, { withFileTypes: true });
+  } catch {
+    return map;
+  }
+  for (const e of entries) {
+    if (e.isFile() && e.name.endsWith(".md")) {
+      const content = await readFile10(join13(dir, e.name), "utf-8");
+      map.set(e.name, content);
+    }
+  }
+  return map;
+}
+async function writeSkillToDir(dir, filename, content) {
+  await mkdir9(dir, { recursive: true });
+  await writeFile9(join13(dir, filename), content, "utf-8");
+}
+async function readFileFromPath(filePath) {
+  try {
+    return await readFile10(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+async function writeFileToPath(filePath, content) {
+  await mkdir9(dirname7(filePath), { recursive: true });
+  await writeFile9(filePath, content, "utf-8");
+}
+
+// src/lib/claude-plugins.ts
+import { readFile as readFile11 } from "fs/promises";
+import { homedir as homedir5 } from "os";
+import { join as join14 } from "path";
+import { spawnSync as spawnSync3 } from "child_process";
+var INSTALLED_PLUGINS_PATH = join14(homedir5(), ".claude", "plugins", "installed_plugins.json");
+function parseInstalledPlugins(data) {
+  return Object.keys(data.plugins);
+}
+async function getInstalledPluginIds() {
+  try {
+    const buf = await readFile11(INSTALLED_PLUGINS_PATH, "utf-8");
+    return parseInstalledPlugins(JSON.parse(buf));
+  } catch {
+    return [];
+  }
+}
+function installPlugin(pluginId) {
+  console.log(`Installing plugin: ${pluginId}`);
+  const result = spawnSync3("claude", ["plugin", "install", pluginId], { stdio: "inherit" });
+  if (result.error) throw new Error(`Failed to run claude: ${result.error.message}`);
+  if (result.status !== 0) throw new Error(`Plugin install failed for ${pluginId}`);
+}
+
+// src/commands/team/init.ts
+async function teamInitCommand(opts) {
+  const config = await loadConfig();
+  const repoUrl = opts.repo ?? await input3({
+    message: "Team config repo URL (https://github.com/user/claude-config):",
+    validate: (v) => v.startsWith("https://") || "Must be an https URL"
+  });
+  const token = config.githubToken;
+  if (!token) throw new Error('No GitHub token found. Run "cortex init" first with GitHub storage.');
+  console.log(`
+Cloning ${repoUrl} \u2192 ~/.cortex/team/`);
+  await cloneTeamRepo(repoUrl, token);
+  const skills = await readSkillsFromDir(LOCAL_SKILLS_DIR);
+  if (skills.size > 0) {
+    await mkdir10(join15(TEAM_DIR, "skills"), { recursive: true });
+    for (const [filename, content] of skills) {
+      await writeFile10(join15(TEAM_DIR, "skills", filename), content, "utf-8");
+    }
+    console.log(`  Copied ${skills.size} skills`);
+  }
+  const claudeMd = await readFileFromPath(LOCAL_CLAUDE_MD);
+  if (claudeMd) {
+    await writeFile10(join15(TEAM_DIR, "CLAUDE.md"), claudeMd, "utf-8");
+    console.log("  Copied CLAUDE.md");
+  }
+  const plugins = await getInstalledPluginIds();
+  const cortexJson = { version: "1", plugins };
+  await writeFile10(join15(TEAM_DIR, "cortex.json"), JSON.stringify(cortexJson, null, 2), "utf-8");
+  console.log(`  Generated cortex.json (${plugins.length} plugins)`);
+  commitAndPush(repoUrl, token, "feat: initial team Claude Code context");
+  const raw = JSON.parse(await readFile12(CONFIG_PATH, "utf-8"));
+  raw.teamRepo = repoUrl;
+  await writeFile10(CONFIG_PATH, JSON.stringify(raw, null, 2), "utf-8");
+  console.log("\n\u2713 Team repo initialized and pushed.");
+  console.log(`  Devs can now run: cortex install --repo ${repoUrl}`);
+}
+
+// src/commands/team/push.ts
+import { writeFile as writeFile11, mkdir as mkdir11 } from "fs/promises";
+import { join as join16 } from "path";
+async function teamPushCommand() {
+  const config = await loadConfig();
+  const repoUrl = config.teamRepo;
+  const token = config.githubToken;
+  if (!repoUrl) throw new Error('No team repo configured. Run "cortex team init --repo <url>" first.');
+  if (!token) throw new Error('No GitHub token found. Run "cortex init" first.');
+  if (!await hasLocalClone()) throw new Error('No local team clone found. Run "cortex team init" first.');
+  console.log("Pulling latest from team repo\u2026");
+  pullTeamRepo();
+  const skills = await readSkillsFromDir(LOCAL_SKILLS_DIR);
+  if (skills.size > 0) {
+    await mkdir11(join16(TEAM_DIR, "skills"), { recursive: true });
+    for (const [filename, content] of skills) {
+      await writeFile11(join16(TEAM_DIR, "skills", filename), content, "utf-8");
+    }
+  }
+  const claudeMd = await readFileFromPath(LOCAL_CLAUDE_MD);
+  if (claudeMd) {
+    await writeFile11(join16(TEAM_DIR, "CLAUDE.md"), claudeMd, "utf-8");
+  }
+  const plugins = await getInstalledPluginIds();
+  await writeFile11(
+    join16(TEAM_DIR, "cortex.json"),
+    JSON.stringify({ version: "1", plugins }, null, 2),
+    "utf-8"
+  );
+  commitAndPush(repoUrl, token, "chore: update team Claude Code context");
+  console.log("\n\u2713 Pushed to team repo.");
+}
+
+// src/commands/team/pull.ts
+import { readFile as readFile13 } from "fs/promises";
+import { join as join17 } from "path";
+
+// src/lib/conflict.ts
+import { select as select2 } from "@inquirer/prompts";
+function hasConflict(local, remote) {
+  return local.trim() !== remote.trim();
+}
+function buildDiffLines(local, remote) {
+  const localLines = local.split("\n");
+  const remoteLines = remote.split("\n");
+  const localSet = new Set(localLines);
+  const remoteSet = new Set(remoteLines);
+  const all = [.../* @__PURE__ */ new Set([...localLines, ...remoteLines])];
+  return all.map((line) => ({
+    type: localSet.has(line) && remoteSet.has(line) ? "same" : localSet.has(line) ? "local" : "remote",
+    line
+  }));
+}
+function mergeContent(local, remote) {
+  const localSet = new Set(local.split("\n"));
+  const additions = remote.split("\n").filter((l) => !localSet.has(l) && l.trim() !== "");
+  if (additions.length === 0) return local;
+  return local.trimEnd() + "\n\n" + additions.join("\n");
+}
+function displayDiff(filename, local, remote) {
+  const diff = buildDiffLines(local, remote);
+  console.log(`
+\u26A0  Conflict: ${filename}`);
+  console.log("\u2500".repeat(50));
+  for (const d of diff) {
+    if (d.type === "local") console.log(`  - ${d.line}`);
+    else if (d.type === "remote") console.log(`  + ${d.line}`);
+  }
+  console.log("\u2500".repeat(50));
+}
+async function promptConflict(filename, local, remote) {
+  displayDiff(filename, local, remote);
+  return select2({
+    message: "How to resolve?",
+    choices: [
+      { name: "[M] Merge \u2014 keep both versions", value: "merge" },
+      { name: "[O] Overwrite \u2014 use team version", value: "overwrite" },
+      { name: "[S] Skip \u2014 keep local version", value: "skip" }
+    ]
+  });
+}
+
+// src/commands/team/pull.ts
+async function teamPullCommand() {
+  const config = await loadConfig();
+  const repoUrl = config.teamRepo;
+  if (!repoUrl) throw new Error('No team repo configured. Run "cortex team init --repo <url>" first.');
+  if (!await hasLocalClone()) throw new Error('No local team clone found. Run "cortex install" first.');
+  console.log("Pulling from team repo\u2026");
+  pullTeamRepo();
+  const remoteSkills = await readSkillsFromDir(join17(TEAM_DIR, "skills"));
+  const localSkills = await readSkillsFromDir(LOCAL_SKILLS_DIR);
+  for (const [filename, remoteContent] of remoteSkills) {
+    const localContent = localSkills.get(filename) ?? null;
+    if (!localContent) {
+      await writeSkillToDir(LOCAL_SKILLS_DIR, filename, remoteContent);
+      console.log(`  + ${filename} (new)`);
+      continue;
+    }
+    if (!hasConflict(localContent, remoteContent)) continue;
+    const resolution = await promptConflict(filename, localContent, remoteContent);
+    if (resolution === "overwrite") {
+      await writeSkillToDir(LOCAL_SKILLS_DIR, filename, remoteContent);
+      console.log(`  \u2713 ${filename} overwritten`);
+    } else if (resolution === "merge") {
+      await writeSkillToDir(LOCAL_SKILLS_DIR, filename, mergeContent(localContent, remoteContent));
+      console.log(`  \u2713 ${filename} merged`);
+    } else {
+      console.log(`  ~ ${filename} skipped`);
+    }
+  }
+  const remoteMd = await readFileFromPath(join17(TEAM_DIR, "CLAUDE.md"));
+  if (remoteMd) {
+    const localMd = await readFileFromPath(LOCAL_CLAUDE_MD);
+    if (!localMd) {
+      await writeFileToPath(LOCAL_CLAUDE_MD, remoteMd);
+      console.log("  + CLAUDE.md (new)");
+    } else if (hasConflict(localMd, remoteMd)) {
+      const resolution = await promptConflict("CLAUDE.md", localMd, remoteMd);
+      if (resolution === "overwrite") {
+        await writeFileToPath(LOCAL_CLAUDE_MD, remoteMd);
+        console.log("  \u2713 CLAUDE.md overwritten");
+      } else if (resolution === "merge") {
+        await writeFileToPath(LOCAL_CLAUDE_MD, mergeContent(localMd, remoteMd));
+        console.log("  \u2713 CLAUDE.md merged");
+      } else {
+        console.log("  ~ CLAUDE.md skipped");
+      }
+    }
+  }
+  let cortexJson = {};
+  try {
+    cortexJson = JSON.parse(await readFile13(join17(TEAM_DIR, "cortex.json"), "utf-8"));
+  } catch {
+  }
+  for (const pluginId of cortexJson.plugins ?? []) {
+    try {
+      installPlugin(pluginId);
+    } catch (e) {
+      console.warn(`  \u26A0 Could not install ${pluginId}: ${e.message}`);
+    }
+  }
+  console.log("\n\u2713 Team context applied.");
+}
+
+// src/commands/install.ts
+import { readFile as readFile14, writeFile as writeFile13 } from "fs/promises";
+import { join as join18 } from "path";
+async function installCommand(opts) {
+  let config;
+  try {
+    config = await loadConfig();
+  } catch {
+    throw new Error('Run "cortex init" first to configure your GitHub token.');
+  }
+  const repoUrl = opts.repo ?? config.teamRepo;
+  if (!repoUrl) {
+    throw new Error('No team repo URL. Pass --repo <url> or run "cortex team init" first.');
+  }
+  const token = config.githubToken;
+  if (!token) throw new Error('No GitHub token found. Run "cortex init" first.');
+  console.log(`Installing from ${repoUrl}\u2026`);
+  await cloneTeamRepo(repoUrl, token);
+  const skills = await readSkillsFromDir(join18(TEAM_DIR, "skills"));
+  for (const [filename, content] of skills) {
+    await writeSkillToDir(LOCAL_SKILLS_DIR, filename, content);
+    console.log(`  + ${filename}`);
+  }
+  const claudeMd = await readFileFromPath(join18(TEAM_DIR, "CLAUDE.md"));
+  if (claudeMd) {
+    await writeFileToPath(LOCAL_CLAUDE_MD, claudeMd);
+    console.log("  + CLAUDE.md");
+  }
+  let cortexJson = {};
+  try {
+    cortexJson = JSON.parse(await readFile14(join18(TEAM_DIR, "cortex.json"), "utf-8"));
+  } catch {
+  }
+  for (const pluginId of cortexJson.plugins ?? []) {
+    try {
+      installPlugin(pluginId);
+    } catch (e) {
+      console.warn(`  \u26A0 Could not install ${pluginId}: ${e.message}`);
+    }
+  }
+  const raw = JSON.parse(await readFile14(CONFIG_PATH, "utf-8"));
+  raw.teamRepo = repoUrl;
+  await writeFile13(CONFIG_PATH, JSON.stringify(raw, null, 2), "utf-8");
+  console.log("\n\u2713 Team context installed. Restart Claude Code to activate new skills and plugins.");
+}
+
 // src/cli.ts
 var require2 = createRequire(import.meta.url);
 var { version } = require2("../package.json");
@@ -1320,4 +1716,10 @@ program.command("convert <skill-file>").description("Convert a Claude Code skill
   return convertCommand(skillFile, { to: opts.to, outputDir: opts.outputDir });
 });
 program.command("mcp").description("Start the MCP server (for use with claude mcp add cortex -- cortex mcp)").action(mcpCommand);
+program.command("setup-mcp").description("Register cortex as a Claude Code MCP server automatically").action(setupMcpCommand);
+var team = program.command("team").description("Share Claude Code context with your team");
+team.command("init").description("Publish your Claude setup to a shared GitHub repo").option("--repo <url>", "Team config repo URL (https://github.com/user/claude-config)").action((opts) => void teamInitCommand(opts));
+team.command("push").description("Push local skill/CLAUDE.md/plugin changes to the team repo").action(() => void teamPushCommand());
+team.command("pull").description("Pull team context updates and install with conflict resolution").action(() => void teamPullCommand());
+program.command("install").description("First-time install of team Claude context from shared repo").option("--repo <url>", "Team config repo URL (overrides stored config)").action((opts) => void installCommand(opts));
 await program.parseAsync(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cortex-sync",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Sync Claude Code sessions between machines with automatic path remapping and skill conversion",
   "license": "AGPL-3.0",
   "type": "module",