codexport 0.1.9 → 0.3.0

package/dist/index.js

@@ -11,7 +11,7 @@ import { homedir, platform } from "node:os";
 import path from "node:path";
 import { spawn } from "node:child_process";
 import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
-const VERSION = "0.1.9";
+const VERSION = "0.3.0";
 const DEFAULT_PORT = 17342;
 const DEFAULT_TIMEOUT_MS = 5_000;
 const CODEXPORT_DIR = ".codexport";
@@ -21,6 +21,8 @@ const MCPS_LOCAL_FILE = "mcps.local.toml";
 const LAST_BUNDLE_FILE = "last-bundle.json";
 const CACHE_BUNDLE_FILE = "bundle.json";
 const APPLIED_FILES_FILE = "applied-files.json";
+const MCP_MANIFEST_FILE = "mcp-manifest.json";
+const MANAGED_MCP_PACKAGE = "codexport@latest";
 const INCLUDE_ROOTS = [
     "AGENTS.md",
     "RTK.md",
@@ -50,6 +52,11 @@ const EXCLUDE_PARTS = new Set([
     ".sqlite",
     ".sqlite3"
 ]);
+const MCP_ENV_EXPORT_NAMES = [
+    "KAGI_API_KEY",
+    "KAGI_SESSION_TOKEN",
+    "KAGI_CLI_PROFILE"
+];
 class CliError extends Error {
     exitCode;
     details;
@@ -232,26 +239,37 @@ async function walkIncluded(root, absolute, files) {
         });
     }
 }
-function computeRevision(files) {
+function computeRevision(files, sourceEnv = {}) {
     const normalized = files.map((file) => ({
         path: file.path,
         mode: file.mode,
         kind: file.kind,
         contentHash: sha256(Buffer.from(file.content, "base64"))
     }));
-    return sha256(JSON.stringify(normalized));
+    return sha256(JSON.stringify({ files: normalized, sourceEnv }));
 }
 async function buildBundle(codexDir) {
     const files = await collectFiles(codexDir);
-    const revision = computeRevision(files);
+    const sourceEnv = collectSourceEnv();
+    const revision = computeRevision(files, sourceEnv);
     return {
         version: 1,
         builtAt: new Date().toISOString(),
         sourceRoot: codexDir,
         revision,
-        files
+        files,
+        sourceEnv
     };
 }
+function collectSourceEnv() {
+    const sourceEnv = {};
+    for (const name of MCP_ENV_EXPORT_NAMES) {
+        const value = process.env[name];
+        if (value)
+            sourceEnv[name] = value;
+    }
+    return sourceEnv;
+}
 async function saveMasterBundle(ctx, bundle) {
     await writeJsonAtomic(path.join(ctx.stateDir, LAST_BUNDLE_FILE), bundle);
 }
@@ -327,7 +345,7 @@ function verifyBundle(bundle) {
     if (bundle.version !== 1 || !Array.isArray(bundle.files)) {
         throw new CliError("Bundle has an unsupported format.", 1);
     }
-    const actualRevision = computeRevision(bundle.files);
+    const actualRevision = computeRevision(bundle.files, bundle.sourceEnv ?? {});
     if (bundle.revision !== actualRevision) {
         throw new CliError(`Bundle revision mismatch. Expected ${bundle.revision}, computed ${actualRevision}.`, 1);
     }
@@ -361,8 +379,8 @@ function extractTomlTableNames(text, prefix) {
     }
     return names;
 }
-function mergeTomlText(canonical, localMcpText, localConfig, sourceRoot) {
-    const expandedCanonical = expandPathVariables(rewritePortableConfig(canonical, sourceRoot), localConfig);
+function mergeTomlText(canonical, localMcpText, localConfig, sourceRoot, sourceEnv = {}) {
+    const expandedCanonical = expandPathVariables(rewritePortableConfig(canonical, sourceRoot, sourceEnv), localConfig);
     if (!localMcpText?.trim())
         return expandedCanonical;
     const canonicalMcps = extractTomlTableNames(canonical, "mcp_servers");
@@ -374,7 +392,7 @@ function mergeTomlText(canonical, localMcpText, localConfig, sourceRoot) {
     }
     return `${expandedCanonical.trimEnd()}\n\n# Follower-local MCP overlay from ~/.codexport/mcps.local.toml\n${localMcpText.trim()}\n`;
 }
-function rewritePortableConfig(canonical, sourceRoot) {
+function rewritePortableConfig(canonical, sourceRoot, sourceEnv = {}) {
     let parsed;
     try {
         parsed = parseTomlObject(canonical, "canonical config.toml");
@@ -393,10 +411,42 @@ function rewritePortableConfig(canonical, sourceRoot) {
         if (!rawServer || typeof rawServer !== "object" || Array.isArray(rawServer))
             continue;
         const server = rawServer;
-        rewritePortableMcpServer(name, server, sourceRoot, sourceHome);
+        mergeSourceEnvForMcp(name, server, sourceEnv);
+        rewriteManagedMcpServer(name, server, sourceRoot, sourceHome);
     }
     return stringifyToml(parsed);
 }
+function buildMcpManifest(canonical, sourceRoot, sourceEnv = {}) {
+    let parsed;
+    try {
+        parsed = parseTomlObject(canonical, "canonical config.toml");
+    }
+    catch {
+        return undefined;
+    }
+    const mcpServers = parsed.mcp_servers;
+    if (!mcpServers || typeof mcpServers !== "object" || Array.isArray(mcpServers))
+        return undefined;
+    const servers = {};
+    for (const [name, rawServer] of Object.entries(mcpServers)) {
+        if (!rawServer || typeof rawServer !== "object" || Array.isArray(rawServer))
+            continue;
+        const server = structuredClone(rawServer);
+        mergeSourceEnvForMcp(name, server, sourceEnv);
+        servers[name] = server;
+    }
+    return { version: 1, sourceRoot, sourceEnv, servers };
+}
+function mergeSourceEnvForMcp(name, server, sourceEnv) {
+    if (name !== "kagi-mcp")
+        return;
+    const env = server.env && typeof server.env === "object" && !Array.isArray(server.env) ? server.env : {};
+    for (const key of ["KAGI_API_KEY", "KAGI_SESSION_TOKEN", "KAGI_CLI_PROFILE"]) {
+        if (typeof env[key] !== "string" && sourceEnv[key])
+            env[key] = sourceEnv[key];
+    }
+    server.env = env;
+}
 function rewritePortableTableKeys(table, sourceRoot, sourceHome) {
     const rewritten = {};
     for (const [key, value] of Object.entries(table)) {
@@ -412,25 +462,12 @@ function rewritePortableTableKeys(table, sourceRoot, sourceHome) {
         table[key] = value;
     }
 }
-function rewritePortableMcpServer(_name, server, sourceRoot, sourceHome) {
+function rewriteManagedMcpServer(name, server, sourceRoot, sourceHome) {
     if (typeof server.url === "string")
         return;
-    const command = typeof server.command === "string" ? server.command : undefined;
     const args = Array.isArray(server.args) ? server.args : [];
-    const launcher = command && mcpHasRequiredPortableEnv(_name, command, server) ? portableMcpLauncher(_name, command, args, sourceHome) : undefined;
-    if (launcher) {
-        server.command = launcher.command;
-        server.args = launcher.args.map((arg) => rewritePortablePath(arg, sourceRoot, sourceHome));
-    }
-    else if (command && isAbsoluteAnyPlatform(command)) {
-        server.enabled = false;
-    }
-    else if (command) {
-        server.command = rewritePortableCommand(command, sourceRoot);
-    }
-    if (!launcher && args.length) {
-        server.args = args.map((arg) => typeof arg === "string" ? rewritePortablePath(arg, sourceRoot, sourceHome) : arg);
-    }
+    server.command = "npx";
+    server.args = ["-y", MANAGED_MCP_PACKAGE, "mcp", "run", name];
     if (server.env && typeof server.env === "object" && !Array.isArray(server.env)) {
         for (const [key, value] of Object.entries(server.env)) {
             if (typeof value === "string") {
@@ -442,11 +479,20 @@ function rewritePortableMcpServer(_name, server, sourceRoot, sourceHome) {
         ensurePortablePathEnv(server);
     }
 }
-function portableMcpLauncher(name, command, args, sourceHome) {
+function portableMcpLauncher(name, command, args, sourceHome, server) {
     const commandName = basenameAnyPlatform(command);
     if (commandName === "npx" || commandName === "bunx" || commandName === "uvx") {
         return allStrings(args) ? { command: commandName, args: args } : undefined;
     }
+    if (name === "kagi-mcp" || commandName === "kagi-mcp") {
+        const env = server.env && typeof server.env === "object" && !Array.isArray(server.env) ? server.env : {};
+        if (typeof env.KAGI_API_KEY === "string" && env.KAGI_API_KEY.length > 0) {
+            return { command: "npx", args: ["-y", "kagi-mcp"] };
+        }
+        if (typeof env.KAGI_SESSION_TOKEN === "string" && env.KAGI_SESSION_TOKEN.length > 0) {
+            return { command: "npx", args: ["-y", "kagi-cli", "mcp"] };
+        }
+    }
     const nodePackage = nodePackageFromServer(command, args) ?? workspacePackageFromServer(command, args, sourceHome);
     if (nodePackage) {
         return { command: "npx", args: ["-y", nodePackage.packageName, ...nodePackage.remainingArgs] };
@@ -462,7 +508,8 @@ function mcpHasRequiredPortableEnv(name, command, server) {
     if (name !== "kagi-mcp" && basenameAnyPlatform(command) !== "kagi-mcp")
         return true;
     const env = server.env && typeof server.env === "object" && !Array.isArray(server.env) ? server.env : undefined;
-    return typeof env?.KAGI_API_KEY === "string" && env.KAGI_API_KEY.length > 0;
+    return (typeof env?.KAGI_API_KEY === "string" && env.KAGI_API_KEY.length > 0)
+        || (typeof env?.KAGI_SESSION_TOKEN === "string" && env.KAGI_SESSION_TOKEN.length > 0);
 }
 function ensurePortablePathEnv(server) {
     const env = server.env && typeof server.env === "object" && !Array.isArray(server.env) ? server.env : {};
@@ -654,7 +701,11 @@ async function applyBundle(ctx, bundle) {
     if (configEntry) {
         const canonicalConfig = decodeFile(configEntry).toString("utf8");
         const localMcpText = await readTextIfExists(path.join(ctx.stateDir, MCPS_LOCAL_FILE));
-        const generated = mergeTomlText(canonicalConfig, localMcpText, { ...localConfig, codexDir: ctx.codexDir }, bundle.sourceRoot);
+        const manifest = buildMcpManifest(canonicalConfig, bundle.sourceRoot, bundle.sourceEnv);
+        if (manifest) {
+            await writeJsonAtomic(path.join(ctx.stateDir, MCP_MANIFEST_FILE), manifest);
+        }
+        const generated = mergeTomlText(canonicalConfig, localMcpText, { ...localConfig, codexDir: ctx.codexDir }, bundle.sourceRoot, bundle.sourceEnv);
         const configPath = path.join(ctx.codexDir, "config.toml");
         if (await pathExists(configPath)) {
             const backupPath = `${configPath}.codexport-backup-${new Date().toISOString().replace(/[:.]/g, "-")}`;
@@ -671,6 +722,43 @@ async function applyBundle(ctx, bundle) {
     await writeLocalConfig(ctx, { ...localConfig, lastRevision: bundle.revision, codexDir: ctx.codexDir });
     await writeJsonAtomic(path.join(ctx.stateDir, APPLIED_FILES_FILE), bundle.files.map((file) => file.path));
 }
+async function commandMcpRun(ctx, name) {
+    const manifest = await readJsonIfExists(path.join(ctx.stateDir, MCP_MANIFEST_FILE));
+    if (!manifest?.servers?.[name]) {
+        throw new CliError(`No managed MCP named ${name}. Run codexport sync --apply first.`, 1);
+    }
+    const localConfig = await readLocalConfig(ctx);
+    const sourceHome = inferHomeFromCodexDir(manifest.sourceRoot);
+    const server = structuredClone(manifest.servers[name]);
+    mergeSourceEnvForMcp(name, server, manifest.sourceEnv ?? {});
+    rewritePortableTableKeys(server, manifest.sourceRoot, sourceHome);
+    if (typeof server.url === "string") {
+        throw new CliError(`MCP ${name} is URL-based and should not be launched through codexport mcp run.`, 2);
+    }
+    const command = typeof server.command === "string" ? expandPathVariables(server.command, { ...localConfig, codexDir: ctx.codexDir }) : undefined;
+    const args = Array.isArray(server.args)
+        ? server.args.map((arg) => typeof arg === "string" ? expandPathVariables(rewritePortablePath(arg, manifest.sourceRoot, sourceHome), { ...localConfig, codexDir: ctx.codexDir }) : String(arg))
+        : [];
+    if (!command)
+        throw new CliError(`MCP ${name} has no command.`, 1);
+    const launcher = mcpHasRequiredPortableEnv(name, command, server)
+        ? portableMcpLauncher(name, command, args, sourceHome, server)
+        : undefined;
+    const runCommandName = launcher?.command ?? rewritePortableCommand(command, manifest.sourceRoot);
+    const runArgs = launcher?.args ?? args;
+    const childEnv = { ...process.env, ...portableServerEnv(server, manifest.sourceRoot, sourceHome, { ...localConfig, codexDir: ctx.codexDir }) };
+    await runCommandWithEnv(runCommandName, runArgs, childEnv);
+}
+function portableServerEnv(server, sourceRoot, sourceHome, localConfig) {
+    const env = server.env && typeof server.env === "object" && !Array.isArray(server.env) ? server.env : {};
+    const out = {};
+    for (const [key, value] of Object.entries(env)) {
+        if (typeof value === "string") {
+            out[key] = expandPathVariables(rewritePortablePath(value, sourceRoot, sourceHome), localConfig);
+        }
+    }
+    return out;
+}
 async function copyDirectory(source, target) {
     await ensureDir(target);
     for (const entry of await readdir(source, { withFileTypes: true })) {
@@ -712,6 +800,23 @@ function runCommand(command, args) {
         });
     });
 }
+function runCommandWithEnv(command, args, env) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, { stdio: "inherit", env });
+        child.on("error", (error) => {
+            const message = error.code === "ENOENT"
+                ? `MCP launcher program not found: ${command}. Install it on this follower or add it to PATH.`
+                : asError(error).message;
+            reject(new CliError(message, 1));
+        });
+        child.on("exit", (code) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new CliError(`${command} ${args.join(" ")} exited with ${code}`, code ?? 1));
+        });
+    });
+}
 async function installMasterService(ctx, port, dryRun) {
     const command = `${process.execPath} ${realpathSync(fileURLToPath(import.meta.url))} master serve --port ${port}`;
     if (platform() === "linux") {
@@ -979,6 +1084,10 @@ async function main(argv) {
     program.command("apply")
         .description("Apply the last staged bundle.")
         .action(async (_options, command) => commandApply(contextFromCommand(command)));
+    const mcp = program.command("mcp").description("Run managed follower MCP launchers.");
+    mcp.command("run <name>")
+        .description("Run a synced MCP through codexport's managed launcher.")
+        .action(async (name, _options, command) => commandMcpRun(contextFromCommand(command), name));
     const hook = program.command("hook").description("Manage follower Codex hooks.");
     hook.command("install")
         .description("Install a follower-only Codex SessionStart sync hook.")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codexport",
-  "version": "0.1.9",
+  "version": "0.3.0",
   "description": "sync a canonical Codex setup from one master machine to follower machines",
   "author": "Microck <contact@micr.dev>",
   "license": "MIT",