copillm 0.2.6 → 0.2.8

package/dist/agentconfig/render.js

@@ -384,18 +384,67 @@ export default function activate(pi: PiApi): void {
   }
 }
 `;
-// ─── Copilot CLI (stub) ───────────────────────────────────────────────────
-export function renderCopilot(_input) {
+// ─── Copilot CLI ──────────────────────────────────────────────────────────
+export function renderCopilot(input) {
+    const writes = [];
+    const notes = [];
+    const cliArgs = [];
+    const mcpConfigPath = path.join(getCopillmHome(), "copilot", "mcp-config.json");
+    const serverCount = Object.keys(input.resolved.mcpServers).length;
+    if (serverCount > 0) {
+        const content = renderCopilotMcp(input.resolved.mcpServers);
+        const existing = fs.existsSync(mcpConfigPath) ? fs.readFileSync(mcpConfigPath, "utf8") : null;
+        if (existing !== content) {
+            writes.push({
+                path: mcpConfigPath,
+                content,
+                mode: 0o600,
+                description: "Copilot CLI MCP config (copillm-managed)"
+            });
+        }
+        cliArgs.push("--additional-mcp-config", `@${mcpConfigPath}`);
+    }
+    else if (fs.existsSync(mcpConfigPath)) {
+        fs.rmSync(mcpConfigPath, { force: true });
+        notes.push(`Removed stale ${mcpConfigPath} (no MCP servers in active profile).`);
+    }
     return {
-        writes: [],
+        writes,
         envOverlay: {},
-        cliArgs: [],
-        notes: [
-            "Copilot CLI: native MCP config format is not yet documented publicly. " +
-                "Skipping fan-out. Track upstream and remove this stub when the path is known."
-        ]
+        cliArgs,
+        notes
     };
 }
+function renderCopilotMcp(servers) {
+    const out = {};
+    for (const [name, server] of Object.entries(servers)) {
+        if (server.transport === "stdio") {
+            const entry = {
+                type: "local",
+                command: server.command,
+                tools: ["*"]
+            };
+            if (server.args)
+                entry.args = server.args;
+            if (server.env)
+                entry.env = server.env;
+            if (server.cwd)
+                entry.cwd = server.cwd;
+            out[name] = entry;
+        }
+        else {
+            const entry = {
+                type: server.transport,
+                url: server.url,
+                tools: ["*"]
+            };
+            if (server.headers)
+                entry.headers = server.headers;
+            out[name] = entry;
+        }
+    }
+    return `${JSON.stringify({ mcpServers: out }, null, 2)}\n`;
+}
 export function planRender(opts, load) {
     const baseInput = { resolved: load.resolved, cwd: opts.cwd };
     switch (opts.agent) {

package/dist/cli/packageInfo.js

@@ -1,7 +1,7 @@
 import { createRequire } from "node:module";
 const FALLBACK_PACKAGE_INFO = {
     name: "copillm",
-    version: "0.2.6"
+    version: "0.2.8"
 };
 export function getPackageInfo() {
     const envName = cleanPackageValue(process.env.COPILLM_PACKAGE_NAME);

package/dist/cli/resolveAgent.js

@@ -59,16 +59,25 @@ export async function resolveAgent(agent, opts = {}) {
             };
         }
     }
-    // 2. Determine target version
+    // 2. Determine target version. If we can reach npm we ask for `latest`;
+    // otherwise we fall through to whatever's already cached so the user can
+    // keep working when the registry is unreachable (corp proxy, npm outage,
+    // airplane mode, etc.).
     let target = pin.version;
+    let viewError = null;
     if (!target && !opts.offline) {
-        target = npmViewLatest(npmExe, pkg);
+        try {
+            target = npmViewLatest(npmExe, pkg);
+        }
+        catch (err) {
+            viewError = err instanceof Error ? err : new Error(String(err));
+        }
     }
     // 3. Cache lookup
     if (target) {
         const cachedDir = path.join(agentRoot, target);
-        const cachedBin = binPathInPrefix(cachedDir, binName);
-        if (cachedBin && fs.existsSync(cachedBin)) {
+        const cachedBin = findReadyCachedBin(cachedDir, binName);
+        if (cachedBin) {
             return {
                 source: "cache",
                 binPath: cachedBin,
@@ -81,8 +90,13 @@ export async function resolveAgent(agent, opts = {}) {
         }
     }
     else {
+        // Either --offline or we couldn't reach npm to ask "what's latest?".
+        // Use the newest known-good install on disk.
         const last = pickLastCached(agentRoot, binName);
         if (last) {
+            if (viewError) {
+                log(`\u26a0 could not reach npm registry to check for updates (${viewError.message}); using cached ${binName} v${last.version}`);
+            }
             return {
                 source: "cache",
                 binPath: last.binPath,
@@ -93,12 +107,22 @@ export async function resolveAgent(agent, opts = {}) {
                 displayLine: `\u2192 ${binName} (cached fallback, ${displayPath(last.dir)}, v${last.version})`
             };
         }
+        if (viewError) {
+            throw new Error(`${binName} not installed and could not reach npm registry to download it: ${viewError.message}`);
+        }
         throw new Error(`${binName} not installed and no cache available (offline).`);
     }
     if (opts.offline) {
         throw new Error(`${binName}@${target} not in cache and --offline is set.`);
     }
-    // 4. Install
+    // 4. Install. We install *directly* into the canonical version directory
+    // and write `version.txt` LAST as the "install complete" marker.
+    // findReadyCachedBin requires both the bin and the marker, so any crash
+    // before the marker is written leaves the tree visible as incomplete and
+    // the next run cleans it up + re-installs. Avoids the older staging+rename
+    // pattern, which had to retry rename-of-directory on Windows when AV or
+    // npm post-install workers transiently held handles on freshly-written
+    // files.
     log(`\u2192 ${binName} (installing ${pkg}@${target} into ${displayPath(agentRoot)} \u2026)`);
     fs.mkdirSync(agentRoot, { recursive: true });
     const lockFile = path.join(agentRoot, ".lock");
@@ -106,8 +130,8 @@ export async function resolveAgent(agent, opts = {}) {
     try {
         // Re-check after acquiring lock — another invocation may have just installed it.
         const finalDir = path.join(agentRoot, target);
-        const recheckBin = binPathInPrefix(finalDir, binName);
-        if (recheckBin && fs.existsSync(recheckBin)) {
+        const recheckBin = findReadyCachedBin(finalDir, binName);
+        if (recheckBin) {
             return {
                 source: "cache",
                 binPath: recheckBin,
@@ -118,40 +142,37 @@ export async function resolveAgent(agent, opts = {}) {
                 displayLine: `\u2192 ${binName} (cached, ${displayPath(finalDir)}, v${target})`
             };
         }
-        const stagingDir = path.join(agentRoot, `.staging-${sanitize(target)}-${process.pid}`);
-        if (fs.existsSync(stagingDir)) {
-            fs.rmSync(stagingDir, { recursive: true, force: true });
+        // Wipe any partial state (missing marker means a previous attempt was
+        // interrupted) before we re-run npm into the same prefix.
+        if (fs.existsSync(finalDir)) {
+            fs.rmSync(finalDir, { recursive: true, force: true });
         }
-        fs.mkdirSync(stagingDir, { recursive: true });
+        fs.mkdirSync(finalDir, { recursive: true });
         const spec = `${pkg}@${target}`;
-        const installResult = spawnSync(npmExe, ["install", "--prefix", stagingDir, "--no-audit", "--no-fund", "--omit=dev", spec], {
+        const installResult = spawnSync(npmExe, ["install", "--prefix", finalDir, "--no-audit", "--no-fund", "--omit=dev", spec], {
             stdio: ["ignore", "inherit", "inherit"],
             shell: process.platform === "win32"
         });
         if (installResult.status !== 0) {
+            cleanupFailedInstall(finalDir);
             const msg = installResult.error ? `: ${installResult.error.message}` : "";
             throw new Error(`npm install ${spec} failed (exit ${installResult.status})${msg}`);
         }
-        const stagedBin = binPathInPrefix(stagingDir, binName);
-        if (!stagedBin || !fs.existsSync(stagedBin)) {
-            throw new Error(`Installed package did not produce a ${binName} bin at ${stagingDir}`);
-        }
-        if (probeVersion(stagedBin) === null) {
-            throw new Error(`Smoke test failed: ${stagedBin} --version did not exit 0`);
+        const installedBin = binPathInPrefix(finalDir, binName);
+        if (!installedBin || !fs.existsSync(installedBin)) {
+            cleanupFailedInstall(finalDir);
+            throw new Error(`Installed package did not produce a ${binName} bin at ${finalDir}`);
         }
-        if (fs.existsSync(finalDir)) {
-            fs.rmSync(finalDir, { recursive: true, force: true });
+        if (probeVersion(installedBin) === null) {
+            cleanupFailedInstall(finalDir);
+            throw new Error(`Smoke test failed: ${installedBin} --version did not exit 0`);
         }
-        fs.renameSync(stagingDir, finalDir);
+        // Marker file: MUST be the last write. Cache-hit checks key off this.
         fs.writeFileSync(path.join(finalDir, "version.txt"), `${target}\n`);
         const pruned = pruneSiblings(agentRoot, target);
-        const finalBin = binPathInPrefix(finalDir, binName);
-        if (!finalBin) {
-            throw new Error(`Final install missing bin at ${finalDir}`);
-        }
         return {
             source: "installed",
-            binPath: finalBin,
+            binPath: installedBin,
             version: target,
             packageName: pkg,
             cacheDir: finalDir,
@@ -163,6 +184,26 @@ export async function resolveAgent(agent, opts = {}) {
         releaseFileLock(lockFile);
     }
 }
+function cleanupFailedInstall(dir) {
+    try {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+    catch {
+        // Best-effort: a stuck handle here means the next run will retry the
+        // cleanup before reinstalling. Worst case the user gets a clearer
+        // "rmSync failed" error on the next attempt.
+    }
+}
+function findReadyCachedBin(dir, binName) {
+    const bin = binPathInPrefix(dir, binName);
+    if (!bin || !fs.existsSync(bin))
+        return null;
+    // version.txt is written LAST, after the smoke test passes. Missing
+    // marker = partial/aborted install; do not treat as a cache hit.
+    if (!fs.existsSync(path.join(dir, "version.txt")))
+        return null;
+    return bin;
+}
 function defaultNpmExecutable() {
     return process.env.COPILLM_NPM_EXECUTABLE && process.env.COPILLM_NPM_EXECUTABLE.trim().length > 0
         ? process.env.COPILLM_NPM_EXECUTABLE
@@ -245,7 +286,7 @@ function pickLastCached(agentRoot, binName) {
         .sort((a, b) => compareVersionsDescending(a, b));
     for (const v of versions) {
         const dir = path.join(agentRoot, v);
-        const bin = binPathInPrefix(dir, binName);
+        const bin = findReadyCachedBin(dir, binName);
         if (bin)
             return { dir, binPath: bin, version: v };
     }
@@ -351,6 +392,3 @@ function displayPath(p) {
     }
     return p;
 }
-function sanitize(s) {
-    return s.replace(/[^A-Za-z0-9._-]/g, "_");
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "copillm",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "description": "Local Copilot proxy CLI (OpenAI/Anthropic-compatible)",
   "license": "MIT",
   "type": "module",