copillm 0.1.4 → 0.2.0

package/README.md

@@ -1,7 +1,7 @@
 # copillm
 
 [![PR gate](https://github.com/jcjc-dev/copillm/actions/workflows/pr-gate.yml/badge.svg?branch=main)](https://github.com/jcjc-dev/copillm/actions/workflows/pr-gate.yml)
-[![Release gate](https://github.com/jcjc-dev/copillm/actions/workflows/release-gate.yml/badge.svg?branch=main&event=schedule)](https://github.com/jcjc-dev/copillm/actions/workflows/release-gate.yml)
+[![Upstream e2e (nightly)](https://github.com/jcjc-dev/copillm/actions/workflows/upstream-e2e.yml/badge.svg?branch=main&event=schedule)](https://github.com/jcjc-dev/copillm/actions/workflows/upstream-e2e.yml)
 [![npm version](https://img.shields.io/npm/v/copillm.svg)](https://www.npmjs.com/package/copillm)
 [![Node.js version](https://img.shields.io/node/v/copillm.svg)](https://www.npmjs.com/package/copillm)
 

package/dist/agentconfig/render.js

@@ -1,6 +1,7 @@
-import path from "node:path";
 import fs from "node:fs";
-import { stringify as stringifyToml } from "smol-toml";
+import os from "node:os";
+import path from "node:path";
+import { parse as parseToml, stringify as stringifyToml, TomlError } from "smol-toml";
 import { AgentConfigError } from "./load.js";
 import { getCopillmHome } from "../config/home.js";
 import { HASH_COMMENT, HTML_COMMENT, upsertManagedBlock } from "./markerBlock.js";
@@ -8,27 +9,35 @@ import { HASH_COMMENT, HTML_COMMENT, upsertManagedBlock } from "./markerBlock.js
 export function renderCodex(input) {
     const writes = [];
     const notes = [];
-    // 1. MCP block inside <CODEX_HOME>/config.toml. The file is generated by
-    //    src/codex/init.ts and ends with a blank line; we append the marker
-    //    section after it.
     const codexConfigPath = path.join(input.codexHomeDir, "config.toml");
-    const mcpToml = renderCodexMcpToml(input.resolved.mcpServers);
-    if (fs.existsSync(codexConfigPath)) {
-        const existing = fs.readFileSync(codexConfigPath, "utf8");
-        const next = upsertManagedBlock(existing, mcpToml, HASH_COMMENT);
-        if (next !== existing) {
-            writes.push({
-                path: codexConfigPath,
-                content: next,
-                mode: 0o600,
-                description: "Codex config.toml MCP block"
-            });
+    const existing = fs.existsSync(codexConfigPath) ? fs.readFileSync(codexConfigPath, "utf8") : "";
+    let next = existing;
+    if (input.codexBaseConfigSourcePath) {
+        if (fs.existsSync(input.codexBaseConfigSourcePath)) {
+            const source = fs.readFileSync(input.codexBaseConfigSourcePath, "utf8");
+            next = mergeCodexBaseConfig(next, source, codexConfigPath, input.codexBaseConfigSourcePath);
+        }
+        else {
+            notes.push(`Codex source config not found at ${input.codexBaseConfigSourcePath}; ` +
+                `run \`copillm start\` or \`copillm codex\` once first.`);
         }
     }
-    else {
+    const mcpToml = renderCodexMcpToml(input.resolved.mcpServers);
+    if (next.length === 0 && mcpToml.length > 0) {
         notes.push(`Codex config not found at ${codexConfigPath}; skipping MCP injection. ` +
             `Run \`copillm start\` first.`);
     }
+    else {
+        next = upsertManagedBlock(next, mcpToml, HASH_COMMENT);
+    }
+    if (next !== existing) {
+        writes.push({
+            path: codexConfigPath,
+            content: next,
+            mode: 0o600,
+            description: "Codex config.toml"
+        });
+    }
     // 2. AGENTS.md instruction block.
     if (input.resolved.instructions) {
         const agentsPath = path.join(input.codexHomeDir, "AGENTS.md");
@@ -45,6 +54,53 @@ export function renderCodex(input) {
     }
     return { writes, envOverlay: {}, cliArgs: [], notes };
 }
+function mergeCodexBaseConfig(targetRaw, sourceRaw, targetPath, sourcePath) {
+    const targetDoc = parseCodexToml(targetRaw, targetPath);
+    const sourceDoc = parseCodexToml(sourceRaw, sourcePath);
+    const providerId = getStringField(sourceDoc, "model_provider");
+    if (!providerId) {
+        throw new AgentConfigError(`Codex source config at ${sourcePath} is missing model_provider.`);
+    }
+    for (const key of ["model", "model_provider", "model_reasoning_effort", "approvals_reviewer"]) {
+        if (key in sourceDoc) {
+            targetDoc[key] = sourceDoc[key];
+        }
+    }
+    const sourceProviders = asRecord(sourceDoc.model_providers);
+    const selectedProvider = asRecord(sourceProviders?.[providerId]);
+    if (!selectedProvider) {
+        throw new AgentConfigError(`Codex source config at ${sourcePath} is missing [model_providers.${providerId}].`);
+    }
+    const targetProviders = asRecord(targetDoc.model_providers) ?? {};
+    targetProviders[providerId] = selectedProvider;
+    targetDoc.model_providers = targetProviders;
+    return `${stringifyToml(targetDoc).trimEnd()}\n`;
+}
+function parseCodexToml(raw, filePath) {
+    if (raw.trim().length === 0) {
+        return {};
+    }
+    try {
+        const parsed = parseToml(raw);
+        return asRecord(parsed) ?? {};
+    }
+    catch (error) {
+        if (error instanceof TomlError) {
+            throw new AgentConfigError(`Failed to parse ${filePath}: ${error.message}`);
+        }
+        throw error;
+    }
+}
+function asRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    return value;
+}
+function getStringField(doc, key) {
+    const value = doc[key];
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
 function renderCodexMcpToml(servers) {
     if (Object.keys(servers).length === 0)
         return "";
@@ -82,17 +138,23 @@ function isValidTomlIdent(name) {
 }
 // ─── Claude Code ──────────────────────────────────────────────────────────
 /**
- * copillm writes Claude's MCP config to ~/.copillm/claude/mcp.json (a
- * copillm-owned location) and injects `--mcp-config <path>` into the launch
- * argv. This is purely additive: Claude continues to read its own project
- * (./.mcp.json) and user (~/.claude.json) scopes, and copillm never touches
- * cwd. Instructions fan-out is not supported for Claude — put project
- * guidance in your own CLAUDE.md and global guidance in ~/.claude/CLAUDE.md.
+ * Launcher mode writes a copillm-owned MCP config and returns --mcp-config.
+ * Native sync mode writes the user-level Claude config that Claude reads
+ * without a copillm wrapper.
  */
 export function renderClaude(input) {
     const writes = [];
     const notes = [];
     const cliArgs = [];
+    if (input.nativeSync) {
+        writes.push(...renderClaudeNativeWrites(input));
+        if (input.resolved.instructions) {
+            notes.push("Claude: instructions fan-out is unsupported (Claude has no out-of-tree " +
+                "instructions hook). Move guidance to ~/.claude/CLAUDE.md or your " +
+                "project's CLAUDE.md manually.");
+        }
+        return { writes, envOverlay: {}, cliArgs, notes };
+    }
     const claudeDir = path.join(getCopillmHome(), "claude");
     const mcpJsonPath = path.join(claudeDir, "mcp.json");
     const serverCount = Object.keys(input.resolved.mcpServers).length;
@@ -122,6 +184,80 @@ export function renderClaude(input) {
     }
     return { writes, envOverlay: {}, cliArgs, notes };
 }
+function renderClaudeNativeWrites(input) {
+    const writes = [];
+    const homeDir = userHomeDir();
+    const userConfigPath = path.join(homeDir, ".claude.json");
+    const settingsPath = path.join(homeDir, ".claude", "settings.json");
+    const manifestPath = path.join(getCopillmHome(), "claude", "native-mcp-manifest.json");
+    const serverNames = Object.keys(input.resolved.mcpServers);
+    const previousServerNames = readClaudeNativeManifest(manifestPath);
+    if (serverNames.length > 0 || previousServerNames.length > 0) {
+        const existing = readJsonObject(userConfigPath);
+        const mcpServers = asRecord(existing.mcpServers) ?? {};
+        for (const name of previousServerNames) {
+            if (!serverNames.includes(name)) {
+                delete mcpServers[name];
+            }
+        }
+        for (const [name, server] of Object.entries(input.resolved.mcpServers)) {
+            mcpServers[name] = serverToClaudeShape(server);
+        }
+        if (Object.keys(mcpServers).length > 0) {
+            existing.mcpServers = mcpServers;
+        }
+        else {
+            delete existing.mcpServers;
+        }
+        writes.push({
+            path: userConfigPath,
+            content: `${JSON.stringify(existing, null, 2)}\n`,
+            mode: 0o600,
+            description: "Claude Code user MCP config"
+        });
+        writes.push({
+            path: manifestPath,
+            content: `${JSON.stringify({ servers: serverNames }, null, 2)}\n`,
+            mode: 0o600,
+            description: "Claude Code native MCP manifest"
+        });
+    }
+    if (input.env && Object.keys(input.env).length > 0) {
+        const settings = readJsonObject(settingsPath);
+        const env = asRecord(settings.env) ?? {};
+        settings.env = { ...env, ...input.env };
+        writes.push({
+            path: settingsPath,
+            content: `${JSON.stringify(settings, null, 2)}\n`,
+            mode: 0o600,
+            description: "Claude Code settings.json env block"
+        });
+    }
+    return writes;
+}
+function userHomeDir() {
+    return process.env.HOME ?? os.homedir();
+}
+function readClaudeNativeManifest(filePath) {
+    const doc = readJsonObject(filePath);
+    const servers = doc.servers;
+    if (!Array.isArray(servers)) {
+        return [];
+    }
+    return servers.filter((server) => typeof server === "string");
+}
+function readJsonObject(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+        return asRecord(parsed) ?? {};
+    }
+    catch (error) {
+        throw new AgentConfigError(`Failed to parse ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
 function renderClaudeMcp(servers) {
     const out = {};
     for (const [name, server] of Object.entries(servers)) {
@@ -267,10 +403,18 @@ export function planRender(opts, load) {
             if (!opts.codexHomeDir) {
                 throw new AgentConfigError("renderCodex requires codexHomeDir");
             }
-            return renderCodex({ ...baseInput, codexHomeDir: opts.codexHomeDir });
+            return renderCodex({
+                ...baseInput,
+                codexHomeDir: opts.codexHomeDir,
+                codexBaseConfigSourcePath: opts.codexBaseConfigSourcePath
+            });
         }
         case "claude":
-            return renderClaude(baseInput);
+            return renderClaude({
+                ...baseInput,
+                nativeSync: opts.claudeNativeSync,
+                env: opts.claudeEnv
+            });
         case "pi":
             return renderPi(baseInput);
         case "copilot":

package/dist/cli/configCommands.js

@@ -1,10 +1,13 @@
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
 import { getCopillmHome } from "../config/home.js";
 import { ensureSecureDirectory, writeFileSecureAtomic } from "../config/fsSecurity.js";
+import { loadConfig } from "../config/config.js";
 import { AgentConfigError, loadAgentConfig } from "../agentconfig/load.js";
 import { applyAgentConfig, formatApplyNotes } from "../agentconfig/apply.js";
+import { buildClaudeEnvBundle } from "./agentEnv.js";
 const SCAFFOLD_TOML = `# copillm agent config — one source of truth for instructions and MCP servers
 # fanned out to each coding agent on \`copillm <agent>\` launch.
 # See: https://github.com/jcjc-dev/copillm (plans/unified-booping-mango.md)
@@ -112,7 +115,7 @@ export function registerConfigCommands(program) {
     });
     config
         .command("sync")
-        .description("Run fan-out without launching an agent (debug aid)")
+        .description("Sync resolved config to the agent's native paths without launching")
         .requiredOption("--agent <kind>", "codex | claude | pi | copilot")
         .option("--profile <name>", "Override active profile for this run")
         .action((opts) => {
@@ -122,11 +125,21 @@ export function registerConfigCommands(program) {
             process.exit(1);
         }
         try {
+            const claudeEnv = agent === "claude"
+                ? buildClaudeEnvBundle({
+                    port: loadConfig().preferredPort,
+                    callerSecret: null,
+                    enableGatewayDiscovery: true
+                }).env
+                : undefined;
             const result = applyAgentConfig({
                 agent,
                 cwd: process.cwd(),
                 profileOverride: opts.profile ?? null,
-                codexHomeDir: agent === "codex" ? path.join(getCopillmHome(), "codex") : undefined
+                codexHomeDir: agent === "codex" ? path.join(os.homedir(), ".codex") : undefined,
+                codexBaseConfigSourcePath: agent === "codex" ? path.join(getCopillmHome(), "codex", "config.toml") : undefined,
+                claudeNativeSync: agent === "claude",
+                claudeEnv
             });
             for (const line of formatApplyNotes(result, agent)) {
                 process.stdout.write(`${line}\n`);

package/dist/cli/launchAgent.js

@@ -52,6 +52,14 @@ function installHint(agent) {
             "    npm i -g @earendil-works/pi-coding-agent"
         ].join("\n");
     }
+    if (agent === "copilot") {
+        return [
+            "Hint: install GitHub Copilot CLI manually with one of:",
+            "    brew install --cask github-copilot-cli",
+            "    npm i -g @github/copilot",
+            "    https://github.com/github/copilot-cli"
+        ].join("\n");
+    }
     return [
         "Hint: install Claude Code manually with:",
         "    npm i -g @anthropic-ai/claude-code"

package/dist/cli/processSafetyNet.js

@@ -0,0 +1,52 @@
+import { isBenignSocketError } from "../server/requestLifecycle.js";
+/**
+ * Install a process-level safety net for the daemon. When an unexpected
+ * `uncaughtException` or `unhandledRejection` escapes the per-request error
+ * handling, we log it loudly and keep the process alive. A daemon dying on
+ * a per-request bug is strictly worse than continuing to serve the next
+ * request: clients (Codex, Claude Code, pi) lose ALL in-flight streams when
+ * the process exits, and the user has to manually `copillm start` again.
+ *
+ * Benign socket errors (ECONNRESET / EPIPE / ERR_STREAM_DESTROYED / aborted
+ * fetches) are downgraded to debug — they're a normal part of SSE life and
+ * would otherwise spam the logs.
+ *
+ * Returns a disposer that uninstalls the handlers (used by tests).
+ */
+export function installProcessSafetyNet(logger) {
+    const onUncaught = (error) => {
+        if (isBenignSocketError(error)) {
+            logger.debug({ event: "process_safety_net", kind: "uncaught_exception", err: toErrLike(error) }, "swallowed benign socket error at process level");
+            return;
+        }
+        logger.error({ event: "process_safety_net", kind: "uncaught_exception", err: toErrLike(error) }, "uncaught exception in daemon — keeping process alive");
+    };
+    const onUnhandled = (reason) => {
+        if (isBenignSocketError(reason)) {
+            logger.debug({ event: "process_safety_net", kind: "unhandled_rejection", err: toErrLike(reason) }, "swallowed benign socket rejection at process level");
+            return;
+        }
+        logger.error({ event: "process_safety_net", kind: "unhandled_rejection", err: toErrLike(reason) }, "unhandled promise rejection in daemon — keeping process alive");
+    };
+    process.on("uncaughtException", onUncaught);
+    process.on("unhandledRejection", onUnhandled);
+    return () => {
+        process.off("uncaughtException", onUncaught);
+        process.off("unhandledRejection", onUnhandled);
+    };
+}
+function toErrLike(value) {
+    if (value instanceof Error) {
+        const out = {
+            type: value.name,
+            message: value.message
+        };
+        if (value.stack)
+            out.stack = value.stack;
+        const code = value.code;
+        if (typeof code === "string")
+            out.code = code;
+        return out;
+    }
+    return { type: typeof value, message: String(value) };
+}

package/dist/cli/resolveAgent.js

@@ -6,12 +6,14 @@ import { getCopillmHome } from "../config/home.js";
 const NPM_PACKAGES = {
     codex: "@openai/codex",
     claude: "@anthropic-ai/claude-code",
-    pi: "@earendil-works/pi-coding-agent"
+    pi: "@earendil-works/pi-coding-agent",
+    copilot: "@github/copilot"
 };
 const BIN_NAMES = {
     codex: "codex",
     claude: "claude",
-    pi: "pi"
+    pi: "pi",
+    copilot: "copilot"
 };
 export function packageNameFor(agent) {
     return NPM_PACKAGES[agent];