codexport 0.1.4 → 0.1.6

package/dist/index.js

@@ -3,7 +3,7 @@ import { Command, Option } from "commander";
 import chokidar from "chokidar";
 import { createHash, randomBytes } from "node:crypto";
 import { createServer, request } from "node:http";
-import { lstat, mkdir, readFile, readdir, readlink, rename, rm, stat, symlink, writeFile } from "node:fs/promises";
+import { chmod, lstat, mkdir, readFile, readdir, readlink, rename, rm, stat, symlink, writeFile } from "node:fs/promises";
 import { existsSync } from "node:fs";
 import { realpathSync } from "node:fs";
 import { fileURLToPath } from "node:url";
@@ -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.4";
+const VERSION = "0.1.6";
 const DEFAULT_PORT = 17342;
 const DEFAULT_TIMEOUT_MS = 5_000;
 const CODEXPORT_DIR = ".codexport";
@@ -114,6 +114,31 @@ async function writeJsonAtomic(filePath, value) {
     await writeFile(tmpPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
     await rename(tmpPath, filePath);
 }
+async function writeFileReplacingExisting(filePath, content, options) {
+    try {
+        await writeFile(filePath, content, options);
+        return;
+    }
+    catch (error) {
+        if (!isPermissionError(error))
+            throw error;
+    }
+    if (await pathExists(filePath)) {
+        try {
+            await chmod(filePath, 0o666);
+        }
+        catch (error) {
+            if (!isPermissionError(error))
+                throw error;
+        }
+        await rm(filePath, { force: true });
+    }
+    await writeFile(filePath, content, options);
+}
+function isPermissionError(error) {
+    const code = error.code;
+    return code === "EACCES" || code === "EPERM";
+}
 function parseTomlObject(text, filePath) {
     try {
         const parsed = parseToml(text);
@@ -336,8 +361,8 @@ function extractTomlTableNames(text, prefix) {
     }
     return names;
 }
-function mergeTomlText(canonical, localMcpText, localConfig) {
-    const expandedCanonical = expandPathVariables(canonical, localConfig);
+function mergeTomlText(canonical, localMcpText, localConfig, sourceRoot) {
+    const expandedCanonical = expandPathVariables(rewritePortableConfig(canonical, sourceRoot), localConfig);
     if (!localMcpText?.trim())
         return expandedCanonical;
     const canonicalMcps = extractTomlTableNames(canonical, "mcp_servers");
@@ -349,10 +374,171 @@ function mergeTomlText(canonical, localMcpText, localConfig) {
     }
     return `${expandedCanonical.trimEnd()}\n\n# Follower-local MCP overlay from ~/.codexport/mcps.local.toml\n${localMcpText.trim()}\n`;
 }
+function rewritePortableConfig(canonical, sourceRoot) {
+    let parsed;
+    try {
+        parsed = parseTomlObject(canonical, "canonical config.toml");
+    }
+    catch {
+        return canonical;
+    }
+    const sourceHome = inferHomeFromCodexDir(sourceRoot);
+    const mcpServers = parsed.mcp_servers;
+    if (!mcpServers || typeof mcpServers !== "object" || Array.isArray(mcpServers)) {
+        rewritePortableTableKeys(parsed, sourceRoot, sourceHome);
+        return stringifyToml(parsed);
+    }
+    rewritePortableTableKeys(parsed, sourceRoot, sourceHome);
+    for (const [name, rawServer] of Object.entries(mcpServers)) {
+        if (!rawServer || typeof rawServer !== "object" || Array.isArray(rawServer))
+            continue;
+        const server = rawServer;
+        rewritePortableMcpServer(name, server, sourceRoot, sourceHome);
+    }
+    return stringifyToml(parsed);
+}
+function rewritePortableTableKeys(table, sourceRoot, sourceHome) {
+    const rewritten = {};
+    for (const [key, value] of Object.entries(table)) {
+        if (value && typeof value === "object" && !Array.isArray(value)) {
+            rewritePortableTableKeys(value, sourceRoot, sourceHome);
+        }
+        rewritten[rewritePortablePath(key, sourceRoot, sourceHome)] = value;
+    }
+    for (const key of Object.keys(table)) {
+        delete table[key];
+    }
+    for (const [key, value] of Object.entries(rewritten)) {
+        table[key] = value;
+    }
+}
+function rewritePortableMcpServer(_name, server, sourceRoot, sourceHome) {
+    if (typeof server.url === "string")
+        return;
+    if (typeof server.command === "string" && Array.isArray(server.args)) {
+        const nodePackage = nodePackageFromServer(server.command, server.args);
+        if (nodePackage) {
+            server.command = "npx";
+            server.args = ["-y", nodePackage.packageName, ...nodePackage.remainingArgs.map((arg) => rewritePortablePath(arg, sourceRoot, sourceHome))];
+            return;
+        }
+    }
+    if (typeof server.command === "string") {
+        server.command = rewritePortableCommand(server.command, sourceRoot);
+    }
+    if (Array.isArray(server.args)) {
+        server.args = server.args.map((arg) => typeof arg === "string" ? rewritePortablePath(arg, sourceRoot, sourceHome) : arg);
+    }
+    if (server.env && typeof server.env === "object" && !Array.isArray(server.env)) {
+        for (const [key, value] of Object.entries(server.env)) {
+            if (typeof value === "string") {
+                server.env[key] = rewritePortablePath(value, sourceRoot, sourceHome);
+            }
+        }
+    }
+}
+function rewritePortableCommand(command, sourceRoot) {
+    const sourceRelative = rewriteSourceRootPath(command, sourceRoot);
+    if (sourceRelative !== command)
+        return sourceRelative;
+    if (!isAbsoluteAnyPlatform(command))
+        return command;
+    return basenameAnyPlatform(command);
+}
+function rewritePortablePath(value, sourceRoot, sourceHome) {
+    const sourceRootPath = rewriteSourceRootPath(value, sourceRoot);
+    if (sourceRootPath !== value)
+        return sourceRootPath;
+    return rewriteSourceHomePath(value, sourceHome);
+}
+function nodePackageFromServer(command, args) {
+    if (basenameAnyPlatform(command) !== "node")
+        return undefined;
+    const [entrypoint, ...remainingArgs] = args;
+    if (typeof entrypoint !== "string" || !isAbsoluteAnyPlatform(entrypoint))
+        return undefined;
+    if (!remainingArgs.every((arg) => typeof arg === "string"))
+        return undefined;
+    const packageName = packageNameFromNodeModulesPath(entrypoint);
+    if (!packageName)
+        return undefined;
+    return { packageName, remainingArgs: remainingArgs };
+}
+function packageNameFromNodeModulesPath(value) {
+    const parts = normalizePathForCompare(value).split("/");
+    const nodeModulesIndex = parts.lastIndexOf("node_modules");
+    if (nodeModulesIndex === -1)
+        return undefined;
+    const first = parts[nodeModulesIndex + 1];
+    if (!first)
+        return undefined;
+    if (first.startsWith("@")) {
+        const second = parts[nodeModulesIndex + 2];
+        return second ? `${first}/${second}` : undefined;
+    }
+    return first;
+}
+function inferHomeFromCodexDir(sourceRoot) {
+    if (!sourceRoot || basenameAnyPlatform(sourceRoot) !== ".codex")
+        return undefined;
+    const normalized = normalizePathForCompare(sourceRoot);
+    return normalized.slice(0, -"/.codex".length);
+}
+function rewriteSourceRootPath(value, sourceRoot) {
+    if (!sourceRoot || !isAbsoluteAnyPlatform(value))
+        return value;
+    const normalizedSourceRoot = normalizePathForCompare(sourceRoot);
+    const normalizedValue = normalizePathForCompare(value);
+    if (normalizedValue === normalizedSourceRoot)
+        return "${codexDir}";
+    if (!normalizedValue.startsWith(`${normalizedSourceRoot}/`))
+        return value;
+    const relative = normalizedValue.slice(normalizedSourceRoot.length + 1);
+    return `\${codexDir}/${relative}`;
+}
+function rewriteSourceHomePath(value, sourceHome) {
+    if (!sourceHome || !isAbsoluteAnyPlatform(value))
+        return value;
+    const normalizedSourceHome = normalizePathForCompare(sourceHome);
+    const normalizedValue = normalizePathForCompare(value);
+    if (normalizedValue === normalizedSourceHome)
+        return "${home}";
+    if (!normalizedValue.startsWith(`${normalizedSourceHome}/`))
+        return value;
+    const relative = normalizedValue.slice(normalizedSourceHome.length + 1);
+    return `\${home}/${relative}`;
+}
+function isAbsoluteAnyPlatform(value) {
+    return path.posix.isAbsolute(value) || path.win32.isAbsolute(value);
+}
+function basenameAnyPlatform(value) {
+    return value.includes("\\") ? path.win32.basename(value) : path.posix.basename(value);
+}
+function dirnameAnyPlatform(value) {
+    return value.includes("\\") || /^[A-Za-z]:\//.test(value) ? path.win32.dirname(value) : path.posix.dirname(value);
+}
+function normalizePathForCompare(value) {
+    return value.replace(/\\/g, "/").replace(/\/+$/g, "");
+}
+async function bundleForCurrentRevision(ctx, local, meta, timeoutMs) {
+    const cached = await readJsonIfExists(path.join(ctx.stateDir, CACHE_BUNDLE_FILE));
+    if (cached?.revision === meta.revision) {
+        verifyBundle(cached);
+        return cached;
+    }
+    if (!local.masterUrl)
+        throw new CliError("This machine is not enrolled. Run codexport follower join first.", 1);
+    const bundle = await fetchBundle(local.masterUrl, timeoutMs);
+    if (bundle.revision !== meta.revision)
+        throw new CliError("Master changed revision during sync. Retry.", 1);
+    await writeCachedBundle(ctx, bundle);
+    return bundle;
+}
 function expandPathVariables(text, localConfig) {
+    const configuredCodexDir = localConfig.codexDir ?? path.join(homedir(), ".codex");
     const variables = {
-        home: homedir(),
-        codexDir: localConfig.codexDir ?? path.join(homedir(), ".codex"),
+        home: basenameAnyPlatform(configuredCodexDir) === ".codex" ? dirnameAnyPlatform(configuredCodexDir) : homedir(),
+        codexDir: configuredCodexDir,
         ...(localConfig.pathVariables ?? {})
     };
     return text.replace(/\$\{([A-Za-z0-9_]+)\}/g, (match, name) => {
@@ -395,19 +581,19 @@ async function applyBundle(ctx, bundle) {
         await ensureDir(path.dirname(target));
         if (file.path === "config.toml")
             continue;
-        await writeFile(target, decodeFile(file), { mode: file.mode });
+        await writeFileReplacingExisting(target, decodeFile(file), { mode: file.mode });
     }
     const configEntry = bundle.files.find((file) => file.path === "config.toml");
     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);
+        const generated = mergeTomlText(canonicalConfig, localMcpText, { ...localConfig, codexDir: ctx.codexDir }, bundle.sourceRoot);
         const configPath = path.join(ctx.codexDir, "config.toml");
         if (await pathExists(configPath)) {
             const backupPath = `${configPath}.codexport-backup-${new Date().toISOString().replace(/[:.]/g, "-")}`;
             await writeFile(backupPath, await readFile(configPath));
         }
-        await writeFile(configPath, generated, "utf8");
+        await writeFileReplacingExisting(configPath, generated, "utf8");
     }
     const localSkillsDir = path.join(ctx.stateDir, "skills");
     if (await pathExists(localSkillsDir)) {
@@ -428,7 +614,7 @@ async function copyDirectory(source, target) {
         }
         else if (entry.isFile()) {
             await ensureDir(path.dirname(targetPath));
-            await writeFile(targetPath, await readFile(sourcePath));
+            await writeFileReplacingExisting(targetPath, await readFile(sourcePath));
         }
         else if (entry.isSymbolicLink()) {
             const linkTarget = await readlink(sourcePath);
@@ -618,12 +804,16 @@ async function commandSync(ctx, options) {
         throw new CliError("Stored master fingerprint does not match the reachable master. Refusing to sync; re-enroll or reset trust explicitly.", 1);
     }
     if (local.lastRevision === meta.revision) {
+        if (options.apply) {
+            const bundle = await bundleForCurrentRevision(ctx, local, meta, options.timeoutMs);
+            await applyBundle(ctx, bundle);
+            print(ctx, { status: "applied", revision: bundle.revision, files: bundle.files.length });
+            return;
+        }
         print(ctx, { status: "current", revision: meta.revision });
         return;
     }
-    const bundle = await fetchBundle(local.masterUrl, options.timeoutMs);
-    if (bundle.revision !== meta.revision)
-        throw new CliError("Master changed revision during sync. Retry.", 1);
+    const bundle = await bundleForCurrentRevision(ctx, local, meta, options.timeoutMs);
     await writeCachedBundle(ctx, bundle);
     if (options.apply) {
         await applyBundle(ctx, bundle);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codexport",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "sync a canonical Codex setup from one master machine to follower machines",
   "author": "Microck <contact@micr.dev>",
   "license": "MIT",
@@ -24,7 +24,7 @@
     "automation"
   ],
   "bin": {
-    "codexport": "./dist/index.js"
+    "codexport": "dist/index.js"
   },
   "files": [
     "dist",