glm-mcp-copilot 1.0.0 → 1.2.0

package/README.md

@@ -4,7 +4,7 @@ Use the **GLM** model (Zhipu / Z.ai) as a **~10× cheaper delegate** inside **Gi
 Chat** (VS Code agent mode). It's the **same GLM MCP server** used by the Claude Code version — Copilot
 calls `glm_agent` / `glm_delegate` / `glm_recommend` / `glm_status` to offload work to GLM.
 
-> Sibling package: **[glm-mcp-claude](../README.md)** (the Claude Code version). Same server, different host.
+> Sibling package: **[glm-mcp-claude](../claude/README.md)** (the Claude Code version). Same server, different host.
 
 ## What you get
 - The **glm MCP server** registered in VS Code (agent mode) — tools:
@@ -12,7 +12,9 @@ calls `glm_agent` / `glm_delegate` / `glm_recommend` / `glm_status` to offload w
   - **`glm_delegate`** — GLM drafts text you place.
   - **`glm_recommend`** — free advisory: GLM vs the default model.
   - **`glm_status`** — usage ledger (proof of GLM tokens spent) + config.
-- A **`.github/copilot-instructions.md`** delegation policy so Copilot offloads to GLM automatically.
+- A **`GLM` custom agent (subagent)** — restricted to the `glm` tools, so it *must* delegate to GLM
+  (the Copilot analog of the Claude `glm` subagent). Pick it from the chat mode dropdown or hand off to it.
+- A **delegation-policy instructions file** so Copilot offloads to GLM automatically.
 
 ## Prerequisites
 - **VS Code** with **GitHub Copilot + Copilot Chat**, and **Agent mode** available (MCP support).
@@ -32,16 +34,37 @@ Run it **from your project folder** (it sets up that workspace). It:
 1. installs the GLM MCP server to `~/.glm-mcp/glm-mcp/` and runs `npm install`,
 2. writes your key to that server's `.env`,
 3. registers the server in `.vscode/mcp.json` (VS Code's `servers` format),
-4. writes `.github/copilot-instructions.md` (the delegation policy).
+4. installs the **`GLM` custom agent** → `.github/agents/glm.agent.md`,
+5. writes `.github/copilot-instructions.md` (the delegation policy).
+
+### Global (all projects)
+Set it up once for **every** workspace with `--global`:
+```bash
+npx glm-mcp-copilot --global --key YOUR_ZAI_API_KEY
+```
+Global mode writes to VS Code's **user config** instead of one workspace:
+- the `glm` server → the **user `mcp.json`** (all workspaces),
+- the **`GLM` custom agent** → `~/.copilot/agents/glm.agent.md`,
+- the delegation policy → `~/.copilot/instructions/glm.instructions.md` (with `applyTo: '**'`),
+- and it registers those locations + enables agent mode in **user `settings.json`**
+  (`chat.agentFilesLocations`, `chat.instructionsFilesLocations`, `chat.agent.enabled`).
+
+> Uses the current (non-deprecated) instructions mechanism — `.instructions.md` files, **not** the old
+> `codeGeneration.instructions` settings array (deprecated in VS Code 1.102; the installer migrates off it).
+> Use `--vscode-user-dir PATH` if your VS Code User folder isn't auto-detected (Insiders/VSCodium/portable).
 
 Then in VS Code: **Reload Window → open Copilot Chat → Agent mode → start the `glm` server** (`MCP: List
 Servers`). Ask Copilot to do a coding task; it will call `glm_agent`.
 
 ## How it differs from the Claude Code version
-Copilot doesn't have Claude Code's *subagents* or *PreToolUse hooks*, so there's no auto-routing hook or
-`glm` subagent. Instead:
-- **MCP tools** (`glm_*`) are available in **agent mode** and Copilot calls them.
-- **`.github/copilot-instructions.md`** steers Copilot to delegate to GLM (the CLAUDE.md equivalent).
+Near-parity — Copilot **does** have subagents (custom agents):
+- **`glm_*` MCP tools** in **agent mode** (same server as the Claude edition).
+- A **`GLM` custom agent (subagent)** restricted to the `glm` tools — the analog of the Claude `glm`
+  subagent (forced to delegate to GLM). Invoke it from the mode dropdown or via an agent handoff.
+- **Instructions files** steer delegation (the CLAUDE.md equivalent).
+
+The only thing Copilot lacks is Claude Code's **PreToolUse hook** (auto-routing on every subagent
+spawn) — so in Copilot, delegation is driven by the subagent + instructions rather than a hook.
 
 Everything else — the GLM agent loop, peak-aware model pick, cost bias, token cap, usage ledger,
 `dry_run` oversight — is the **same server**, so it behaves identically once a tool is called.

package/glm.agent.md

@@ -0,0 +1,22 @@
+---
+name: GLM
+description: Cheap GLM delegate — offloads coding/edit/refactor/test/docs work to the GLM model (~10x cheaper than the default) via the glm MCP server. Use for well-specified, self-contained tasks; keep sensitive/vision/parallel/huge-context/heavy-tool-loop work on the default model.
+tools: ['glm/*']
+user-invocable: true
+---
+
+You are the **GLM delegate**. You have ONLY the `glm` MCP server's tools — **you cannot edit files or
+run commands yourself**, so you must route all real work through GLM (this keeps the work, and the
+tokens, on GLM — ~10× cheaper than the default model).
+
+## How you work
+1. **Do the work via GLM.** For any coding / edit / refactor / test / docs task, call **`glm/glm_agent`**
+   with the goal + the **absolute repo path** (`workdir`). GLM reads, writes, edits, and runs the files
+   itself, end-to-end. For pure text, use **`glm/glm_delegate`**.
+2. **Check fit when unsure.** Call **`glm/glm_recommend`**; if it says the task should stay on the
+   default model (sensitive, vision, parallel, >128K context, heavy dependent tool-loops), say so and stop.
+3. **Report the GLM stats.** Surface the `=== GLM STATS ===` block `glm_agent` returns (model + tokens
+   delegated + cost) so it's clear GLM did the work and how much it spent. Run **`glm/glm_status`** for
+   the cumulative usage ledger.
+
+Never claim to have done work you didn't route through GLM — you have no other tools.

package/glm.instructions.md

@@ -0,0 +1,18 @@
+---
+applyTo: '**'
+---
+
+# GLM delegation
+
+The **glm** MCP server is available in agent mode (`glm_agent`, `glm_delegate`, `glm_recommend`,
+`glm_status`). GLM (Zhipu/Z.ai) is **~10× cheaper** than the default model — offload work to it.
+
+- For any implementation / codegen / edit / refactor / test / docs task, call **`glm_agent`** with the
+  goal + the absolute repo path (`workdir`) so GLM does it end-to-end on **GLM tokens** — or hand it to
+  the **GLM** custom agent (subagent). Prefer this over doing the file work yourself.
+- Use **`glm_delegate`** for pure text.
+- **To actually spend GLM tokens (not the default model's), call the glm tools — don't do the work
+  inline yourself.**
+- Keep on the default model: sensitive/secret code, vision/images, parallel work, very large context
+  (>128K), and heavy dependent tool-loops. Unsure? call **`glm_recommend`**.
+- `glm_status` shows the GLM usage ledger — proof of GLM tokens spent.

package/install-copilot.mjs

@@ -6,8 +6,10 @@
 //
 // Usage:
 //   node install-copilot.mjs --key YOUR_ZAI_KEY          # set up in the current workspace
-//   node install-copilot.mjs --workspace PATH            # target another project folder
+//   node install-copilot.mjs --global --key YOUR_ZAI_KEY # set up for ALL workspaces (VS Code user config)
+//   node install-copilot.mjs --workspace PATH            # target another project folder (workspace mode)
 //   node install-copilot.mjs --server-dir PATH           # where to install the server (default ~/.glm-mcp)
+//   node install-copilot.mjs --vscode-user-dir PATH      # override VS Code User dir (for --global)
 //   node install-copilot.mjs --skip-npm
 
 import { cpSync, mkdirSync, existsSync, readFileSync, writeFileSync, copyFileSync } from "node:fs";
@@ -25,13 +27,30 @@ const SERVER_HOME = getOpt("--server-dir") || join(homedir(), ".glm-mcp");
 const WORKSPACE = getOpt("--workspace") || process.cwd();
 const KEY = getOpt("--key") || process.env.GLM_API_KEY || "";
 const SKIP_NPM = getFlag("--skip-npm");
+const GLOBAL = getFlag("--global");
 
 const log = (s) => console.log(s);
 const step = (s) => console.log("\n→ " + s);
 
-log("GLM-for-Copilot installer");
+// Resolve the VS Code User config dir (for --global). Prefers stable "Code", falls back to Insiders.
+function vscodeUserDir() {
+  const override = getOpt("--vscode-user-dir");
+  if (override) return override;
+  const home = homedir();
+  const roots =
+    process.platform === "win32"
+      ? [process.env.APPDATA || join(home, "AppData", "Roaming")]
+      : process.platform === "darwin"
+      ? [join(home, "Library", "Application Support")]
+      : [join(home, ".config")];
+  const cands = [];
+  for (const r of roots) for (const app of ["Code", "Code - Insiders", "VSCodium"]) cands.push(join(r, app, "User"));
+  return cands.find(existsSync) || cands[0];
+}
+
+log("GLM-for-Copilot installer" + (GLOBAL ? " (GLOBAL — all workspaces)" : ""));
 log("  server    : " + join(SERVER_HOME, "glm-mcp"));
-log("  workspace : " + WORKSPACE);
+log(GLOBAL ? "  scope     : all VS Code workspaces (user config)" : "  workspace : " + WORKSPACE);
 
 // 1. Install the shared MCP server (skip node_modules/.env/usage.jsonl).
 step("Installing the GLM MCP server");
@@ -63,40 +82,91 @@ if (!SKIP_NPM) {
   execSync("npm install --no-audit --no-fund", { cwd: join(SERVER_HOME, "glm-mcp"), stdio: "inherit" });
 }
 
-// 4. Register the server in VS Code (workspace .vscode/mcp.json). VS Code uses the "servers" key.
-step("Registering the glm server in VS Code (.vscode/mcp.json)");
+// 4-6. Register the server, the `glm` custom agent (subagent), and the delegation policy —
+// globally (all workspaces) or in this workspace.
 const idx = join(SERVER_HOME, "glm-mcp", "src", "index.js").replace(/\\/g, "/");
-const vscodeDir = join(WORKSPACE, ".vscode");
-mkdirSync(vscodeDir, { recursive: true });
-const mcpPath = join(vscodeDir, "mcp.json");
-let mcp = {};
-if (existsSync(mcpPath)) {
-  try { mcp = JSON.parse(readFileSync(mcpPath, "utf8")); } catch { mcp = {}; }
-  writeFileSync(mcpPath + ".bak-" + Date.now(), readFileSync(mcpPath));
+const AGENTS_HOME = join(homedir(), ".copilot", "agents"); // global custom-agent location
+const INSTR_HOME = join(homedir(), ".copilot", "instructions"); // global instructions location
+
+function mergeMcp(mcpPath) {
+  mkdirSync(dirname(mcpPath), { recursive: true });
+  let mcp = {};
+  if (existsSync(mcpPath)) {
+    try { mcp = JSON.parse(readFileSync(mcpPath, "utf8")); } catch { mcp = {}; }
+    writeFileSync(mcpPath + ".bak-" + Date.now(), readFileSync(mcpPath));
+  }
+  mcp.servers ||= {};
+  mcp.servers.glm = { type: "stdio", command: "node", args: [idx] };
+  writeFileSync(mcpPath, JSON.stringify(mcp, null, 2) + "\n");
+  return mcpPath;
 }
-mcp.servers ||= {};
-mcp.servers.glm = { type: "stdio", command: "node", args: [idx] };
-writeFileSync(mcpPath, JSON.stringify(mcp, null, 2) + "\n");
-log("  " + mcpPath);
-
-// 5. Copilot instructions (workspace .github/copilot-instructions.md).
-step("Adding delegation policy (.github/copilot-instructions.md)");
-const ghDir = join(WORKSPACE, ".github");
-mkdirSync(ghDir, { recursive: true });
-const ciPath = join(ghDir, "copilot-instructions.md");
-const policy = readFileSync(join(SELF, "copilot-instructions.md"), "utf8");
-const existing = existsSync(ciPath) ? readFileSync(ciPath, "utf8") : "";
-if (!existing.includes("glm_agent")) {
-  writeFileSync(ciPath, existing + (existing ? "\n\n" : "") + policy);
-  log("  " + ciPath);
+function copyInto(dir, srcFile) {
+  mkdirSync(dir, { recursive: true });
+  const dest = join(dir, srcFile);
+  copyFileSync(join(SELF, srcFile), dest);
+  return dest;
+}
+
+if (GLOBAL) {
+  const userDir = vscodeUserDir();
+  step("Registering glm GLOBALLY (VS Code user mcp.json) -> " + userDir);
+  log("  " + mergeMcp(join(userDir, "mcp.json")));
+
+  step("Installing the GLM custom agent (subagent) -> " + AGENTS_HOME);
+  log("  " + copyInto(AGENTS_HOME, "glm.agent.md"));
+
+  step("Installing GLOBAL Copilot instructions -> " + INSTR_HOME);
+  log("  " + copyInto(INSTR_HOME, "glm.instructions.md"));
+
+  step("Updating VS Code user settings.json (locations + toggles)");
+  const setPath = join(userDir, "settings.json");
+  let settings = {};
+  if (existsSync(setPath)) {
+    try { settings = JSON.parse(readFileSync(setPath, "utf8")); } catch { settings = {}; }
+    writeFileSync(setPath + ".bak-" + Date.now(), readFileSync(setPath));
+  }
+  const agentsGlob = AGENTS_HOME.replace(/\\/g, "/");
+  const instrGlob = INSTR_HOME.replace(/\\/g, "/");
+  settings["chat.agentFilesLocations"] = { ...(settings["chat.agentFilesLocations"] || {}), [agentsGlob]: true };
+  settings["chat.instructionsFilesLocations"] = { ...(settings["chat.instructionsFilesLocations"] || {}), [instrGlob]: true };
+  settings["github.copilot.chat.codeGeneration.useInstructionFiles"] = true;
+  settings["chat.agent.enabled"] = true;
+  // Migrate off the deprecated inline-instructions setting (remove our old entry if present).
+  const DEP = "github.copilot.chat.codeGeneration.instructions";
+  if (Array.isArray(settings[DEP])) {
+    settings[DEP] = settings[DEP].filter((e) => !(e && typeof e.text === "string" && e.text.includes("glm_agent")));
+    if (settings[DEP].length === 0) delete settings[DEP];
+  }
+  writeFileSync(setPath, JSON.stringify(settings, null, 2) + "\n");
+  log("  " + setPath);
 } else {
-  log("  policy already present (left as-is)");
+  step("Registering the glm server in VS Code (workspace .vscode/mcp.json)");
+  log("  " + mergeMcp(join(WORKSPACE, ".vscode", "mcp.json")));
+
+  step("Installing the GLM custom agent (subagent) -> .github/agents/");
+  log("  " + copyInto(join(WORKSPACE, ".github", "agents"), "glm.agent.md"));
+
+  step("Adding delegation policy (workspace .github/copilot-instructions.md)");
+  const ciPath = join(WORKSPACE, ".github", "copilot-instructions.md");
+  mkdirSync(dirname(ciPath), { recursive: true });
+  const policy = readFileSync(join(SELF, "copilot-instructions.md"), "utf8");
+  const existing = existsSync(ciPath) ? readFileSync(ciPath, "utf8") : "";
+  if (!existing.includes("glm_agent")) {
+    writeFileSync(ciPath, existing + (existing ? "\n\n" : "") + policy);
+    log("  " + ciPath);
+  } else {
+    log("  copilot-instructions.md already has the policy");
+  }
 }
 
 log("\n✅ Done. Next steps:");
 log("  1. Ensure GLM_API_KEY is set in " + envPath);
 log("  2. In VS Code: Reload Window, open Copilot Chat, switch to Agent mode.");
 log("  3. Start the 'glm' server: run 'MCP: List Servers' (or VS Code will offer to start it).");
-log("  4. Ask Copilot to do a coding task — it will call glm_agent. Run glm_status for the GLM usage ledger.");
-log("\nNote: this sets up the CURRENT workspace. For all projects, run 'MCP: Open User Configuration' in");
-log("VS Code and add the same 'glm' server block (see mcp.json.example).");
+log("  4. Use it: pick the 'GLM' agent in the chat mode dropdown, or ask the main agent to");
+log("     'use glm_agent to …'. Run glm_status for the GLM usage ledger.");
+log(
+  GLOBAL
+    ? "\nGLOBAL mode: the glm server, GLM subagent, and delegation policy now apply to ALL your VS Code workspaces."
+    : "\nWorkspace mode: current project only. Re-run with --global to apply to every project."
+);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "glm-mcp-copilot",
-  "version": "1.0.0",
-  "description": "GLM (Zhipu/Z.ai) as a cheap delegate for GitHub Copilot / Copilot Chat in VS Code — the same GLM MCP tools (glm_agent/glm_delegate/glm_recommend/glm_status) wired into VS Code agent mode.",
+  "version": "1.2.0",
+  "description": "GLM (Zhipu/Z.ai) as a cheap delegate for GitHub Copilot / Copilot Chat in VS Code — the same GLM MCP tools (glm_agent/glm_delegate/glm_recommend/glm_status) plus a GLM custom agent (subagent), wired into VS Code agent mode, installable globally.",
   "type": "module",
   "bin": {
     "glm-mcp-copilot": "install-copilot.mjs"
@@ -9,6 +9,8 @@
   "files": [
     "glm-mcp/",
     "install-copilot.mjs",
+    "glm.agent.md",
+    "glm.instructions.md",
     "copilot-instructions.md",
     "mcp.json.example",
     "README.md",