copillm 0.1.0

package/README.md

@@ -0,0 +1,52 @@
+# copillm
+
+> **Unofficial proxy to make your Copilot CLI seat power everything.**
+
+[![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 (nightly + on release)](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)
+
+A local proxy that exposes OpenAI- and Anthropic-compatible HTTP endpoints backed by your GitHub Copilot subscription. One login — point Codex CLI, Claude Code, or any compatible tool at it and go.
+
+> ⚠️ **Experimental / research tool.** Independent, unofficial client of GitHub Copilot's private API. Not affiliated with GitHub, Microsoft, OpenAI, or Anthropic. The upstream API can change without notice. Use at your own risk.
+
+---
+
+## Quick start
+
+```bash
+# 1. one-time login (GitHub device flow)
+npx copillm login
+
+# 2. launch your agent — copillm auto-starts the daemon, installs the agent if needed,
+#    and wires up all env vars for you
+npx copillm claude    # Claude Code, preconfigured
+npx copillm codex     # Codex CLI, preconfigured
+```
+
+Requires Node.js ≥ 20. That's it — no global install, no config files, no API keys to juggle.
+
+Pass extra args through with `--`:
+
+```bash
+copillm claude -- --model opus
+copillm codex  -- --help
+```
+
+---
+
+## Documentation
+
+Full docs live at **[jcjc-dev.github.io/copillm](https://jcjc-dev.github.io/copillm/)**:
+
+- **[Getting started](https://jcjc-dev.github.io/copillm/getting-started/)** — install, login, first run
+- **[CLI reference](https://jcjc-dev.github.io/copillm/cli-reference/)** — every command and flag
+- **[Using with Claude Code](https://jcjc-dev.github.io/copillm/claude-code/)** — env wiring, gateway discovery, the `[1m]` 1M-context alias
+- **[Using with Codex CLI](https://jcjc-dev.github.io/copillm/codex/)** — env wiring, `config.toml` generation
+- **[HTTP API reference](https://jcjc-dev.github.io/copillm/http-api/)** — endpoints, translation caveats
+- **[Building from source & CI](https://jcjc-dev.github.io/copillm/development/)** — for contributors
+
+---
+
+## Contributing
+
+Issues and PRs welcome — see the [development guide](https://jcjc-dev.github.io/copillm/development/).

package/dist/agentconfig/apply.js

@@ -0,0 +1,53 @@
+import { writeFileSecureAtomic } from "../config/fsSecurity.js";
+import { loadAgentConfig } from "./load.js";
+import { planRender } from "./render.js";
+import { backupIfMismatch } from "./markerBlock.js";
+/**
+ * Load the resolved profile and compute every FileWrite for the target agent
+ * BEFORE touching disk. Any validation error throws before a single byte is
+ * written, so a botched config never leaves the filesystem half-updated.
+ *
+ * Returns `{ active: null }` and zero writes when no agent.toml exists
+ * anywhere — callers should treat this as a clean no-op.
+ */
+export function applyAgentConfig(opts) {
+    if (opts.skip) {
+        return { active: null, writes: [], envOverlay: {}, cliArgs: [], notes: [], sources: [] };
+    }
+    const load = loadAgentConfig({
+        cwd: opts.cwd,
+        profileOverride: opts.profileOverride ?? null
+    });
+    if (!load) {
+        return { active: null, writes: [], envOverlay: {}, cliArgs: [], notes: [], sources: [] };
+    }
+    const rendered = planRender(opts, load);
+    // Phase 2: write. By this point all validation passed and the renderer
+    // produced complete file bodies — failures here are IO errors, not user
+    // input problems.
+    for (const write of rendered.writes) {
+        backupIfMismatch(write.path, write.content);
+        writeFileSecureAtomic(write.path, write.content, write.mode);
+    }
+    return {
+        active: load.active,
+        writes: rendered.writes,
+        envOverlay: rendered.envOverlay,
+        cliArgs: rendered.cliArgs,
+        notes: rendered.notes,
+        sources: load.sources
+    };
+}
+export function formatApplyNotes(result, agent) {
+    if (result.active === null)
+        return [];
+    const lines = [];
+    lines.push(`copillm config: applied profile "${result.active}" to ${agent}`);
+    for (const write of result.writes) {
+        lines.push(`  → wrote ${write.path} (${write.description})`);
+    }
+    for (const note of result.notes) {
+        lines.push(`  • ${note}`);
+    }
+    return lines;
+}

package/dist/agentconfig/load.js

@@ -0,0 +1,163 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parse as parseToml, TomlError } from "smol-toml";
+import { ZodError } from "zod";
+import { getCopillmHome } from "../config/home.js";
+import { AgentTomlSchema, UNSET_SENTINEL } from "./schema.js";
+export class AgentConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "AgentConfigError";
+    }
+}
+/**
+ * Returns null when no agent.toml exists anywhere. Callers should treat this
+ * as a clean no-op and skip fan-out entirely.
+ */
+export function loadAgentConfig(options) {
+    const globalPath = path.join(getCopillmHome(), "agent.toml");
+    const projectPath = path.join(options.cwd, ".copillm", "agent.toml");
+    const globalDoc = readDocument(globalPath, "global");
+    const projectDoc = readDocument(projectPath, "project");
+    if (!globalDoc && !projectDoc) {
+        return null;
+    }
+    const active = options.profileOverride ??
+        projectDoc?.parsed.active_profile ??
+        globalDoc?.parsed.active_profile ??
+        "default";
+    const resolved = mergeAndResolve({ globalDoc, projectDoc, profileName: active });
+    const sources = [];
+    if (globalDoc)
+        sources.push({ path: globalDoc.filePath, scope: "global" });
+    if (projectDoc)
+        sources.push({ path: projectDoc.filePath, scope: "project" });
+    return { active, resolved, sources };
+}
+function readDocument(filePath, scope) {
+    if (!fs.existsSync(filePath)) {
+        return null;
+    }
+    const raw = fs.readFileSync(filePath, "utf8");
+    let parsed;
+    try {
+        parsed = parseToml(raw);
+    }
+    catch (error) {
+        if (error instanceof TomlError) {
+            const where = `line ${error.line} col ${error.column}`;
+            throw new AgentConfigError(`Failed to parse ${filePath}: ${error.message} (at ${where}). ` +
+                `TOML duplicate keys and syntax errors are not auto-corrected — fix the file and re-run.`);
+        }
+        throw error;
+    }
+    let validated;
+    try {
+        validated = AgentTomlSchema.parse(parsed);
+    }
+    catch (error) {
+        if (error instanceof ZodError) {
+            const issues = error.issues
+                .map((issue) => `  • ${issue.path.join(".") || "<root>"}: ${issue.message}`)
+                .join("\n");
+            throw new AgentConfigError(`${filePath} does not match the expected schema:\n${issues}`);
+        }
+        throw error;
+    }
+    return { filePath, scope, parsed: validated };
+}
+function mergeAndResolve(input) {
+    const layers = [];
+    if (input.globalDoc?.parsed.defaults)
+        layers.push(input.globalDoc.parsed.defaults);
+    if (input.globalDoc?.parsed.profiles?.[input.profileName]) {
+        layers.push(input.globalDoc.parsed.profiles[input.profileName]);
+    }
+    if (input.projectDoc?.parsed.defaults)
+        layers.push(input.projectDoc.parsed.defaults);
+    if (input.projectDoc?.parsed.profiles?.[input.profileName]) {
+        layers.push(input.projectDoc.parsed.profiles[input.profileName]);
+    }
+    if (layers.length === 0) {
+        const where = [];
+        if (input.globalDoc)
+            where.push(input.globalDoc.filePath);
+        if (input.projectDoc)
+            where.push(input.projectDoc.filePath);
+        throw new AgentConfigError(`No profile "${input.profileName}" found in ${where.join(" or ")}. ` +
+            `Add [profiles.${input.profileName}] or set active_profile.`);
+    }
+    // Merge instructions: later layers overwrite (typically the project tail).
+    let instructionsBody = null;
+    for (const layer of layers) {
+        if (layer.instructions?.body !== undefined) {
+            instructionsBody = layer.instructions.body;
+        }
+    }
+    const instructions = instructionsBody !== null && instructionsBody.trim().length > 0
+        ? { body: instructionsBody }
+        : null;
+    // Merge mcp.servers map; later layers replace earlier same-named entries;
+    // `inherit = "@unset"` removes an inherited entry.
+    const servers = {};
+    for (const layer of layers) {
+        const layerServers = layer.mcp?.servers ?? {};
+        for (const [name, value] of Object.entries(layerServers)) {
+            if ("inherit" in value && value.inherit === UNSET_SENTINEL) {
+                delete servers[name];
+                continue;
+            }
+            servers[name] = expandEnv(value);
+        }
+    }
+    const reserved = {
+        skills: mergeRecord(layers, "skills"),
+        agents: mergeRecord(layers, "agents"),
+        hooks: mergeRecord(layers, "hooks"),
+        permissions: mergeRecord(layers, "permissions")
+    };
+    return { instructions, mcpServers: servers, reserved };
+}
+function mergeRecord(layers, key) {
+    const out = {};
+    for (const layer of layers) {
+        const sub = layer[key];
+        if (sub)
+            Object.assign(out, sub);
+    }
+    return out;
+}
+/** Expand `${VAR}` and `${VAR:-default}` in url/command/args/env/headers. */
+function expandEnv(entry) {
+    const expand = (value) => expandString(value);
+    if (entry.transport === "stdio") {
+        return {
+            ...entry,
+            command: expand(entry.command),
+            args: entry.args?.map(expand),
+            env: entry.env ? expandRecord(entry.env) : undefined
+        };
+    }
+    return {
+        ...entry,
+        url: expand(entry.url),
+        headers: entry.headers ? expandRecord(entry.headers) : undefined
+    };
+}
+function expandRecord(rec) {
+    const out = {};
+    for (const [k, v] of Object.entries(rec))
+        out[k] = expandString(v);
+    return out;
+}
+const ENV_PATTERN = /\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-([^}]*))?\}/g;
+export function expandString(value) {
+    return value.replace(ENV_PATTERN, (_match, name, fallback) => {
+        const fromEnv = process.env[name];
+        if (fromEnv !== undefined && fromEnv !== "")
+            return fromEnv;
+        if (fallback !== undefined)
+            return fallback;
+        throw new AgentConfigError(`Required env var "${name}" is not set and no default was provided in the agent.toml expansion.`);
+    });
+}

package/dist/agentconfig/markerBlock.js

@@ -0,0 +1,76 @@
+import fs from "node:fs";
+import { AgentConfigError } from "./load.js";
+export const HTML_COMMENT = { commentStart: "<!--", commentEnd: " -->" };
+export const HASH_COMMENT = { commentStart: "#", commentEnd: "" };
+const MARKER_ID = "copillm:managed";
+function begin(style, id) {
+    return `${style.commentStart} ${id} begin${style.commentEnd}`;
+}
+function end(style, id) {
+    return `${style.commentStart} ${id} end${style.commentEnd}`;
+}
+export function upsertManagedBlock(existing, body, style = HTML_COMMENT, id = MARKER_ID) {
+    const beginLine = begin(style, id);
+    const endLine = end(style, id);
+    const trimmedBody = body.replace(/^\s+|\s+$/g, "");
+    const block = trimmedBody.length > 0 ? `${beginLine}\n${trimmedBody}\n${endLine}` : "";
+    const beginIdx = existing.indexOf(beginLine);
+    const endIdx = existing.indexOf(endLine);
+    if (beginIdx !== -1 && endIdx !== -1 && endIdx > beginIdx) {
+        // Replace in place. Strip the existing block + its surrounding newlines so
+        // we don't accumulate blank lines on repeated runs.
+        const before = existing.slice(0, beginIdx).replace(/\s+$/, "");
+        const after = existing.slice(endIdx + endLine.length).replace(/^\s+/, "");
+        if (block.length === 0) {
+            return ensureTrailingNewline(joinWithBlank(before, after));
+        }
+        return ensureTrailingNewline(joinWithBlank(before, block, after));
+    }
+    if (beginIdx !== -1 || endIdx !== -1) {
+        throw new AgentConfigError(`Found a partial copillm-managed marker block; refusing to write. ` +
+            `Restore both "${beginLine}" and "${endLine}" or remove them entirely.`);
+    }
+    if (block.length === 0) {
+        return existing;
+    }
+    if (existing.length === 0) {
+        return `${block}\n`;
+    }
+    return ensureTrailingNewline(joinWithBlank(existing.replace(/\s+$/, ""), block));
+}
+function ensureTrailingNewline(s) {
+    return s.endsWith("\n") ? s : s + "\n";
+}
+function joinWithBlank(...parts) {
+    return parts.filter((p) => p.length > 0).join("\n\n");
+}
+/**
+ * If `target` exists and its current content (outside any managed block)
+ * differs from `lastWritten`, copy aside to a timestamped `.bak` so the
+ * user's edits aren't silently overwritten. Lifted from `src/pi/init.ts`.
+ *
+ * Best-effort: backup failures don't block the write — preferable to abort
+ * the user's launch over a backup error.
+ */
+export function backupIfMismatch(target, newContent) {
+    let existing;
+    try {
+        existing = fs.readFileSync(target, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        return null;
+    }
+    if (existing === newContent)
+        return null;
+    const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const backupPath = `${target}.copillm-backup-${stamp}.bak`;
+    try {
+        fs.copyFileSync(target, backupPath);
+        return backupPath;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/agentconfig/render.js

@@ -0,0 +1,317 @@
+import path from "node:path";
+import fs from "node:fs";
+import { stringify as stringifyToml } from "smol-toml";
+import { AgentConfigError } from "./load.js";
+import { HASH_COMMENT, HTML_COMMENT, upsertManagedBlock } from "./markerBlock.js";
+// ─── Codex ────────────────────────────────────────────────────────────────
+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"
+            });
+        }
+    }
+    else {
+        notes.push(`Codex config not found at ${codexConfigPath}; skipping MCP injection. ` +
+            `Run \`copillm start\` first.`);
+    }
+    // 2. AGENTS.md instruction block.
+    if (input.resolved.instructions) {
+        const agentsPath = path.join(input.codexHomeDir, "AGENTS.md");
+        const existing = fs.existsSync(agentsPath) ? fs.readFileSync(agentsPath, "utf8") : "";
+        const next = upsertManagedBlock(existing, input.resolved.instructions.body, HTML_COMMENT);
+        if (next !== existing) {
+            writes.push({
+                path: agentsPath,
+                content: next,
+                mode: 0o600,
+                description: "Codex AGENTS.md instructions block"
+            });
+        }
+    }
+    return { writes, envOverlay: {}, cliArgs: [], notes };
+}
+function renderCodexMcpToml(servers) {
+    if (Object.keys(servers).length === 0)
+        return "";
+    // Build a single TOML document `{ mcp_servers: { name: {...} } }` and feed
+    // smol-toml's stringify so nested maps (env, http_headers) emit valid TOML
+    // inline-table syntax instead of being half-stripped by ad-hoc post-processing.
+    const out = { mcp_servers: {} };
+    for (const [name, server] of Object.entries(servers)) {
+        if (!isValidTomlIdent(name)) {
+            throw new AgentConfigError(`MCP server name "${name}" is not a valid TOML identifier; ` +
+                `use only letters, digits, dashes, and underscores.`);
+        }
+        if (server.transport === "stdio") {
+            const entry = { command: server.command };
+            if (server.args)
+                entry.args = server.args;
+            if (server.env)
+                entry.env = server.env;
+            if (server.cwd)
+                entry.cwd = server.cwd;
+            out.mcp_servers[name] = entry;
+        }
+        else {
+            const entry = { url: server.url };
+            if (server.headers)
+                entry.http_headers = server.headers;
+            out.mcp_servers[name] = entry;
+        }
+    }
+    return stringifyToml(out).trimEnd();
+}
+const TOML_IDENT = /^[A-Za-z0-9_-]+$/;
+function isValidTomlIdent(name) {
+    return TOML_IDENT.test(name);
+}
+export function renderClaude(input) {
+    const writes = [];
+    const notes = [];
+    // 1. .mcp.json (project scope) — preserve user entries.
+    const mcpJsonPath = path.join(input.cwd, ".mcp.json");
+    const claudeMcp = renderClaudeMcp(mcpJsonPath, input.resolved.mcpServers);
+    if (claudeMcp) {
+        writes.push({
+            path: mcpJsonPath,
+            content: claudeMcp,
+            mode: 0o600,
+            description: "Claude Code .mcp.json"
+        });
+    }
+    // 2. CLAUDE.md instruction block.
+    if (input.resolved.instructions) {
+        const claudeMdPath = path.join(input.cwd, "CLAUDE.md");
+        const existing = fs.existsSync(claudeMdPath) ? fs.readFileSync(claudeMdPath, "utf8") : "";
+        const next = upsertManagedBlock(existing, input.resolved.instructions.body, HTML_COMMENT);
+        if (next !== existing) {
+            writes.push({
+                path: claudeMdPath,
+                content: next,
+                mode: 0o600,
+                description: "CLAUDE.md instructions block"
+            });
+        }
+    }
+    return { writes, envOverlay: {}, cliArgs: [], notes };
+}
+function renderClaudeMcp(mcpJsonPath, servers) {
+    let existing = {};
+    if (fs.existsSync(mcpJsonPath)) {
+        try {
+            existing = JSON.parse(fs.readFileSync(mcpJsonPath, "utf8"));
+            if (typeof existing !== "object" || existing === null) {
+                throw new Error("not an object");
+            }
+        }
+        catch (error) {
+            throw new AgentConfigError(`Failed to parse ${mcpJsonPath}: ${error.message}. ` +
+                `Fix or remove the file and re-run.`);
+        }
+    }
+    const managed = new Set(existing._copillmManaged ?? []);
+    const userOwned = new Set(Object.keys(existing.mcpServers ?? {}).filter((n) => !managed.has(n)));
+    // Detect conflicts: a copillm-managed name collides with a user-owned name.
+    const newNames = Object.keys(servers);
+    for (const name of newNames) {
+        if (userOwned.has(name)) {
+            throw new AgentConfigError(`MCP server name "${name}" already exists in ${mcpJsonPath} and is owned by the user ` +
+                `(not previously managed by copillm). Rename one side, or move the user's entry ` +
+                `into agent.toml so copillm can manage it.`);
+        }
+    }
+    // Strip previously-managed entries from the user's file before adding ours.
+    const nextServers = {};
+    for (const [name, value] of Object.entries(existing.mcpServers ?? {})) {
+        if (!managed.has(name))
+            nextServers[name] = value;
+    }
+    for (const [name, server] of Object.entries(servers)) {
+        nextServers[name] = serverToClaudeShape(server);
+    }
+    const nextFile = { ...existing };
+    if (Object.keys(nextServers).length > 0) {
+        nextFile.mcpServers = nextServers;
+    }
+    else {
+        delete nextFile.mcpServers;
+    }
+    if (newNames.length > 0) {
+        nextFile._copillmManaged = newNames;
+    }
+    else {
+        delete nextFile._copillmManaged;
+    }
+    const serialized = `${JSON.stringify(nextFile, null, 2)}\n`;
+    // Avoid pointless writes when state is unchanged.
+    if (fs.existsSync(mcpJsonPath) && fs.readFileSync(mcpJsonPath, "utf8") === serialized) {
+        return null;
+    }
+    // If we'd produce an empty file (no servers, no other keys), skip writing.
+    if (Object.keys(nextFile).length === 0 && !fs.existsSync(mcpJsonPath)) {
+        return null;
+    }
+    return serialized;
+}
+function serverToClaudeShape(server) {
+    if (server.transport === "stdio") {
+        const out = {
+            type: "stdio",
+            command: server.command
+        };
+        if (server.args)
+            out.args = server.args;
+        if (server.env)
+            out.env = server.env;
+        if (server.cwd)
+            out.cwd = server.cwd;
+        return out;
+    }
+    const out = {
+        type: server.transport,
+        url: server.url
+    };
+    if (server.headers)
+        out.headers = server.headers;
+    return out;
+}
+// ─── pi ───────────────────────────────────────────────────────────────────
+const PI_EXTENSION_DIRNAME = "copillm-mcp";
+export function renderPi(input) {
+    const writes = [];
+    const notes = [];
+    const piHome = path.join(process.env.HOME ?? "", ".pi");
+    const extensionDir = path.join(piHome, "agent", "extensions", PI_EXTENSION_DIRNAME);
+    // 1. servers.json — the resolved server list the extension reads at startup.
+    const serversJson = renderPiServersJson(input.resolved.mcpServers);
+    writes.push({
+        path: path.join(extensionDir, "servers.json"),
+        content: serversJson,
+        mode: 0o600,
+        description: "pi MCP extension servers.json"
+    });
+    // 2. index.ts — the extension template (constant — see piExtensionTemplate.ts).
+    writes.push({
+        path: path.join(extensionDir, "index.ts"),
+        content: PI_EXTENSION_INDEX_TS,
+        mode: 0o600,
+        description: "pi MCP extension index.ts"
+    });
+    // 3. instructions prompt registered by the extension on session_start.
+    if (input.resolved.instructions) {
+        const promptPath = path.join(piHome, "agent", "prompts", "copillm-profile.md");
+        writes.push({
+            path: promptPath,
+            content: `${input.resolved.instructions.body.trim()}\n`,
+            mode: 0o600,
+            description: "pi profile prompt"
+        });
+    }
+    if (Object.keys(input.resolved.mcpServers).length === 0 && !input.resolved.instructions) {
+        notes.push("pi: no MCP servers or instructions in active profile; extension still written as a no-op.");
+    }
+    return { writes, envOverlay: {}, cliArgs: [], notes };
+}
+function renderPiServersJson(servers) {
+    const out = {};
+    for (const [name, server] of Object.entries(servers)) {
+        out[name] = serverToClaudeShape(server); // same wire shape works
+    }
+    return `${JSON.stringify({ servers: out }, null, 2)}\n`;
+}
+// Template for the pi extension. Kept inline (small) so a single commit ships
+// both the renderer and the runtime side-by-side. The extension is
+// deliberately conservative: it logs what it sees and registers a placeholder
+// tool per server. Wiring real MCP stdio/http transport is left for a follow-up
+// PR — this lands the plumbing without claiming working tool-calls.
+const PI_EXTENSION_INDEX_TS = `// Generated by copillm. Do not edit by hand.
+// Source of truth: ~/.copillm/agent.toml
+//
+// This extension is registered automatically by copillm whenever you run
+// \`copillm pi\`. It loads the resolved MCP server list from the sibling
+// servers.json and exposes each entry to pi. v1 only registers the servers
+// and surfaces them via a slash command; real MCP transport wiring lands in
+// a follow-up.
+
+import fs from "node:fs";
+import path from "node:path";
+
+interface PiApi {
+  registerCommand: (name: string, handler: () => Promise<string> | string) => void;
+  on?: (event: string, handler: (...args: unknown[]) => void) => void;
+}
+
+export default function activate(pi: PiApi): void {
+  const serversPath = path.join(__dirname, "servers.json");
+  let servers: Record<string, unknown> = {};
+  try {
+    const raw = JSON.parse(fs.readFileSync(serversPath, "utf8")) as { servers?: Record<string, unknown> };
+    servers = raw.servers ?? {};
+  } catch {
+    servers = {};
+  }
+
+  pi.registerCommand("copillm-mcp", () => {
+    const names = Object.keys(servers);
+    if (names.length === 0) return "No MCP servers configured via copillm.";
+    return "copillm-managed MCP servers:\\n" + names.map((n) => "  - " + n).join("\\n");
+  });
+
+  const promptPath = path.join(process.env.HOME ?? "", ".pi", "agent", "prompts", "copillm-profile.md");
+  if (fs.existsSync(promptPath) && typeof pi.on === "function") {
+    pi.on("session_start", () => {
+      try {
+        const body = fs.readFileSync(promptPath, "utf8");
+        // pi swallows return values from event handlers; logging the body
+        // suffices for the v1 plumbing — instruction injection lands in v2.
+        console.log("[copillm] loaded profile prompt (" + body.length + " bytes)");
+      } catch {
+        /* swallow */
+      }
+    });
+  }
+}
+`;
+// ─── Copilot CLI (stub) ───────────────────────────────────────────────────
+export function renderCopilot(_input) {
+    return {
+        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."
+        ]
+    };
+}
+export function planRender(opts, load) {
+    const baseInput = { resolved: load.resolved, cwd: opts.cwd };
+    switch (opts.agent) {
+        case "codex": {
+            if (!opts.codexHomeDir) {
+                throw new AgentConfigError("renderCodex requires codexHomeDir");
+            }
+            return renderCodex({ ...baseInput, codexHomeDir: opts.codexHomeDir });
+        }
+        case "claude":
+            return renderClaude(baseInput);
+        case "pi":
+            return renderPi(baseInput);
+        case "copilot":
+            return renderCopilot(baseInput);
+    }
+}