@yanzc/claude-pro 0.0.0-stage → 0.4.0

package/src/gateway.js

@@ -0,0 +1,110 @@
+// The codex-gateway provider: model requests go to a shared gateway (https://gw.predix.icu by default) with an
+// API key of the user's gateway account, which pays for them from its balance. /login gets that key the way
+// Claude Code logs in: a local callback server, the gateway's login page in the browser, and a one-time code
+// exchanged for a key of this machine's own (see handleCli in codex-gateway's server.mjs).
+
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import http from 'node:http';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { CONFIG_DIR, GATEWAY_DEFAULT_URL } from './config.js';
+
+export { GATEWAY_DEFAULT_URL };
+export const gatewayLoginFile = () => path.join(process.env.CLAUDE_PRO_CONFIG_DIR || CONFIG_DIR, 'gateway.json');
+const LOGIN_TIMEOUT_MS = 10 * 60_000;
+
+export const normalizeGatewayUrl = (url) => String(url || GATEWAY_DEFAULT_URL).trim().replace(/\/+$/, '');
+
+// {url, apiKey, account, savedAt}, or null when there is none for this gateway.
+export function readGatewayLogin(url) {
+  try {
+    const data = JSON.parse(fs.readFileSync(gatewayLoginFile(), 'utf8'));
+    if (!data?.apiKey || (url && normalizeGatewayUrl(data.url) !== normalizeGatewayUrl(url))) return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
+
+export function saveGatewayLogin(login) {
+  const file = gatewayLoginFile();
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify({ ...login, url: normalizeGatewayUrl(login.url), savedAt: new Date().toISOString() }, null, 2), { mode: 0o600 });
+  fs.renameSync(tmp, file);
+}
+
+export function clearGatewayLogin() {
+  try { fs.unlinkSync(gatewayLoginFile()); return true; } catch { return false; }
+}
+
+export function openBrowser(url) {
+  try {
+    const [cmd, args] = process.platform === 'win32'
+      ? ['rundll32', ['url.dll,FileProtocolHandler', url]]
+      : process.platform === 'darwin' ? ['open', [url]] : ['xdg-open', [url]];
+    const child = spawn(cmd, args, { stdio: 'ignore', detached: true, windowsHide: true });
+    child.on('error', () => {});
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function gatewayJson(url, init = {}, fetchImpl = globalThis.fetch) {
+  const res = await fetchImpl(url, { ...init, headers: { 'content-type': 'application/json', ...(init.headers || {}) } });
+  const body = await res.json().catch(() => ({}));
+  if (!res.ok) throw Object.assign(new Error(body?.error?.message || `HTTP ${res.status}`), { status: res.status });
+  return body;
+}
+
+// The account behind a key: balance, usage totals (GET /v1/account).
+export async function fetchGatewayAccount({ url, apiKey }, { fetchImpl = globalThis.fetch, signal } = {}) {
+  const body = await gatewayJson(`${normalizeGatewayUrl(url)}/v1/account`, { headers: { authorization: `Bearer ${apiKey}` }, signal }, fetchImpl);
+  return body.account;
+}
+
+const PAGE = (title, text) => `<!doctype html><meta charset="utf-8"><title>${title}</title><body style="font-family:system-ui,sans-serif;max-width:32rem;margin:4rem auto;line-height:1.6"><h2>${title}</h2><p>${text}</p></body>`;
+
+// Log in through the browser. `onUrl(url)` is told the login page's address (to show it, for when the browser
+// does not open by itself); `open` opens it. Resolves with the saved login once the key is in.
+export async function loginWithBrowser({ url = GATEWAY_DEFAULT_URL, onUrl = () => {}, open = openBrowser, signal, fetchImpl = globalThis.fetch, timeoutMs = LOGIN_TIMEOUT_MS } = {}) {
+  const base = normalizeGatewayUrl(url);
+  const state = crypto.randomBytes(24).toString('base64url');
+  let settle;
+  const result = new Promise((resolve, reject) => { settle = { resolve, reject }; });
+  const server = http.createServer((req, res) => {
+    const u = new URL(req.url, 'http://127.0.0.1');
+    if (u.pathname !== '/callback') { res.writeHead(404).end(); return; }
+    const ok = u.searchParams.get('state') === state && u.searchParams.get('code');
+    res.writeHead(ok ? 200 : 400, { 'content-type': 'text/html; charset=utf-8' });
+    res.end(ok ? PAGE('登录成功', '可以关掉这个页面，回到终端继续使用 claude-pro。') : PAGE('登录失败', '链接无效或已过期。请回到终端重新执行 /login。'));
+    if (ok) settle.resolve(u.searchParams.get('code'));
+  });
+  await new Promise((resolve, reject) => { server.once('error', reject); server.listen(0, '127.0.0.1', resolve); });
+  const timer = setTimeout(() => settle.reject(new Error('Login timed out: the browser did not come back within 10 minutes.')), timeoutMs);
+  const onAbort = () => settle.reject(Object.assign(new Error('Login cancelled'), { name: 'AbortError' }));
+  signal?.addEventListener('abort', onAbort, { once: true });
+  try {
+    const page = `${base}/cli/login?${new URLSearchParams({ port: String(server.address().port), state, client: 'claude-pro', device: os.hostname().slice(0, 60) })}`;
+    onUrl(page);
+    Promise.resolve().then(() => open(page)).catch((e) => settle.reject(e));
+    const code = await result;
+    const token = await gatewayJson(`${base}/cli/token`, { method: 'POST', body: JSON.stringify({ code, state }) }, fetchImpl);
+    const login = { url: base, apiKey: token.api_key, account: { id: token.account?.id, name: token.account?.name, email: token.account?.email } };
+    saveGatewayLogin(login);
+    return { ...login, balance: token.account };
+  } finally {
+    clearTimeout(timer);
+    signal?.removeEventListener('abort', onAbort);
+    server.close();
+  }
+}
+
+export const formatUsd = (value) => {
+  const n = Number(value);
+  return Number.isFinite(n) ? `$${n.toFixed(n !== 0 && Math.abs(n) < 0.01 ? 4 : 2)}` : '-';
+};

package/src/hooks.js

@@ -0,0 +1,81 @@
+// Hooks: user-defined shell commands that run around tool calls, in the same shape as
+// Claude Code's settings.json:
+//   "hooks": { "PreToolUse": [ { "matcher": "Bash|Edit", "hooks": [ { "type": "command", "command": "..." } ] } ],
+//              "PostToolUse": [...], "UserPromptSubmit": [...], "Stop": [...] }
+// The event payload is passed as JSON on stdin (like Claude Code) and in $CLAUDE_PRO_HOOK_INPUT; $CLAUDE_PROJECT_DIR is set too.
+// Exit code 0: fine (stdout is kept as extra context). Exit code 2: block, stderr goes to the model.
+// Any other non-zero exit code is reported as a warning and ignored.
+
+import { spawnShell, killTree, findShell, watchShell } from './utils/shell.js';
+import { stripAnsi } from './ui/ansi.js';
+
+const DEFAULT_TIMEOUT_MS = 60_000;
+
+function matches(matcher, name) {
+  if (!matcher || matcher === '*') return true;
+  try { return new RegExp(`^(?:${matcher})$`).test(name || ''); } catch { return matcher === name; }
+}
+
+function runCommand(shell, command, { cwd, payload, timeout, signal }) {
+  return new Promise((resolve) => {
+    let out = '', err = '', timedOut = false;
+    let child;
+    try {
+      const json = JSON.stringify(payload);
+      child = spawnShell(shell, command, {
+        cwd,
+        env: { ...process.env, CLAUDE_PRO_HOOK_INPUT: json, CLAUDE_PROJECT_DIR: cwd, CLAUDE_PRO: '1' },
+        stdin: json,
+      });
+    } catch (e) {
+      resolve({ code: 1, out: '', err: e.message });
+      return;
+    }
+    const timer = setTimeout(() => { timedOut = true; killTree(child); }, timeout);
+    const onAbort = () => killTree(child);
+    signal?.addEventListener('abort', onAbort, { once: true });
+    watchShell(child, {
+      onOutput: (text, stream) => { if (stream === 'stderr') err += text; else out += text; },
+      done: (code, error) => {
+        clearTimeout(timer);
+        signal?.removeEventListener('abort', onAbort);
+        if (error) err += error.message;
+        resolve({ code: timedOut || error ? 1 : code, out: stripAnsi(out).trim(), err: stripAnsi(err + (timedOut ? `\nhook timed out after ${timeout}ms` : '')).trim() });
+      },
+    });
+  });
+}
+
+export class HookRunner {
+  constructor(config) {
+    this.config = config;
+    this.shell = null;
+  }
+
+  has(event) { return (this.config.settings.hooks?.[event] || []).length > 0; }
+
+  // Returns {blocked, message, context: string[], warnings: string[]}.
+  async run(event, payload, { cwd, signal } = {}) {
+    const result = { blocked: false, message: '', context: [], warnings: [] };
+    const entries = this.config.settings.hooks?.[event] || [];
+    if (!entries.length) return result;
+    this.shell ||= findShell(this.config);
+    const full = { hook_event_name: event, cwd, ...payload };
+    for (const entry of entries) {
+      if (!matches(entry.matcher, payload.tool_name)) continue;
+      for (const h of entry.hooks || []) {
+        if (h.type && h.type !== 'command') continue;
+        if (!h.command) continue;
+        const r = await runCommand(this.shell, h.command, { cwd, payload: full, timeout: h.timeout ? h.timeout * 1000 : DEFAULT_TIMEOUT_MS, signal });
+        if (r.code === 2) {
+          result.blocked = true;
+          result.message = r.err || r.out || `Blocked by ${event} hook: ${h.command}`;
+          return result;
+        }
+        if (r.code !== 0) result.warnings.push(`${event} hook "${h.command}" exited with ${r.code}${r.err ? `: ${r.err.split('\n')[0]}` : ''}`);
+        else if (r.out) result.context.push(r.out);
+      }
+    }
+    return result;
+  }
+}

package/src/main.js

@@ -0,0 +1,193 @@
+import fs from 'node:fs';
+import { VERSION, KNOWN_KEYS, loadConfig, settingsFiles, updateSettingsFile, applyRememberedChoices } from './config.js';
+import { SessionStore } from './session.js';
+import { takeRestartState } from './restart.js';
+
+const HELP = `Usage: claude-pro [options] [prompt]
+
+A Claude Code style coding agent for APIs or existing local Claude Code OAuth credentials.
+Starts an interactive session by default; use -p for non-interactive output.
+
+Options:
+  -p, --print                      Print the response and exit (useful for pipes)
+  -c, --continue                   Continue the most recent conversation in this directory
+  -r, --resume [sessionId]         Resume a conversation (picker if no id given)
+  --provider <backend>            api (default) | claude-code (direct HTTP with existing local login)
+  --model <model>                  Model for this session (name or alias: opus, sonnet, haiku)
+  --effort <level>                 Reasoning effort: none|minimal|low|medium|high|xhigh|max
+  --plan                           Start in read-only plan mode (research first, then ExitPlanMode)
+  --output-format <format>         text | json | stream-json (with --print)
+  --verify <command>               After the agent edits files, run this (e.g. "npm test") and send failures back to fix
+  --append-system-prompt <text>    Append text to the system prompt
+  --system-prompt <text>           Replace the system prompt
+  --verbose                        Show thinking and full tool output
+  --no-mcp                         Do not start MCP servers
+  -v, --version                    Print version
+  -h, --help                       Show help
+
+There are no permission prompts: every tool runs immediately (full access). File edits are
+checkpointed per prompt, and /rewind in a session undoes them. The old flags
+--dangerously-skip-permissions, --permission-mode, --allowedTools and --disallowedTools
+are accepted and ignored (--permission-mode plan is the same as --plan).
+
+Commands:
+  claude-pro config list                  Show effective configuration and where each value comes from
+  claude-pro config set <KEY> <VALUE> [--project|--local]   Save a setting (default: ~/.claude-pro/settings.json)
+  claude-pro config unset <KEY> [--project|--local]
+`;
+
+function parseArgs(argv) {
+  const flags = {};
+  const positional = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    const next = () => argv[++i];
+    // Old permission flags take a list of rules (Tool, Tool(content), "A B(c)"); skip over them.
+    const RULES = /^\s*[\w-]+(\([^)]*\))?(\s*[,\s]\s*[\w-]+(\([^)]*\))?)*\s*$/;
+    const skipRules = () => {
+      while (i + 1 < argv.length && !argv[i + 1].startsWith('-') && RULES.test(argv[i + 1])) i++;
+    };
+    switch (a) {
+      case '-p': case '--print': flags.print = true; break;
+      case '-c': case '--continue': flags.continue = true; break;
+      case '-r': case '--resume':
+        flags.resume = true;
+        if (argv[i + 1] && !argv[i + 1].startsWith('-') && /^[0-9a-f-]{8,}$/i.test(argv[i + 1])) flags.resumeId = next();
+        break;
+      case '--model': flags.model = next(); break;
+      case '--provider': flags.provider = next(); break;
+      case '--effort': flags.effort = next(); break;
+      case '--plan': flags.plan = true; break;
+      case '--permission-mode': if (next() === 'plan') flags.plan = true; break;
+      case '--dangerously-skip-permissions': break; // nothing to skip: there are no prompts
+      case '--allowedTools': case '--allowed-tools': case '--disallowedTools': case '--disallowed-tools': skipRules(); break;
+      case '--output-format': flags.outputFormat = next(); break;
+      case '--verify': flags.verify = next(); break;
+      case '--append-system-prompt': flags.appendSystemPrompt = next(); break;
+      case '--system-prompt': flags.systemPrompt = next(); break;
+      case '--verbose': flags.verbose = true; break;
+      case '--no-mcp': flags.noMcp = true; break;
+      case '-v': case '--version': flags.version = true; break;
+      case '-h': case '--help': flags.help = true; break;
+      default:
+        if (a.startsWith('--') && a.includes('=')) { argv.splice(i + 1, 0, a.slice(a.indexOf('=') + 1)); argv[i] = a.slice(0, a.indexOf('=')); i--; break; }
+        if (a.startsWith('-') && a !== '-') { process.stderr.write(`Unknown option: ${a}\n`); process.exit(2); }
+        positional.push(a);
+    }
+  }
+  return { flags, positional };
+}
+
+function configCommand(args, cwd) {
+  const [sub, key, ...rest] = args;
+  const scopeFlag = rest.find((r) => r === '--project' || r === '--local') || (key === '--project' || key === '--local' ? key : null);
+  const files = settingsFiles(cwd);
+  const file = scopeFlag === '--project' ? files.project : scopeFlag === '--local' ? files.local : files.user;
+  if (!sub || sub === 'list' || sub === 'get') {
+    const cfg = loadConfig({ cwd });
+    const remembered = applyRememberedChoices(cfg);
+    const keys = sub === 'get' && key ? [key] : Object.keys(KNOWN_KEYS);
+    for (const k of keys) {
+      const v = cfg.display(k);
+      if (v === undefined && sub !== 'get') continue;
+      console.log(`${k}=${v ?? ''}${cfg.sources[k] ? `    # ${cfg.sources[k]}` : ''}`);
+    }
+    if (sub !== 'get') {
+      console.log(`\nprovider: ${cfg.provider} (${cfg.endpointLabel})`);
+      console.log(`main model: ${cfg.mainModel.label} (context ${cfg.mainModel.contextWindow.toLocaleString()})${cfg.effort ? `, effort ${cfg.effort}` : ''}`);
+      if (remembered.model || remembered.effort) {
+        const what = Object.entries(remembered).map(([k, v]) => `${k} ${v}`).join(', ');
+        console.log(`chosen with /model, /effort: ${what} (kept in ${files.user}; wins over the settings above, --model/--effort win over it)`);
+      }
+      console.log(`sub-agent model: ${cfg.subagentModel.label}; small model: ${cfg.smallModel.label}`);
+      console.log(`auto-compact at ${cfg.autoCompactThreshold().toLocaleString()} tokens (window ${cfg.compactWindow().toLocaleString()})`);
+    }
+    return 0;
+  }
+  if (sub === 'set') {
+    const value = rest.filter((r) => r !== '--project' && r !== '--local').join(' ');
+    if (!key || !value) { console.error('Usage: claude-pro config set <KEY> <VALUE> [--project|--local]'); return 2; }
+    if (!KNOWN_KEYS[key]) console.error(`note: ${key} is not a known key; saving anyway`);
+    updateSettingsFile(file, (json) => { json.env = { ...(json.env || {}), [key]: value }; });
+    console.log(`Set ${key} in ${file}`);
+    return 0;
+  }
+  if (sub === 'unset') {
+    updateSettingsFile(file, (json) => { if (json.env) delete json.env[key]; });
+    console.log(`Removed ${key} from ${file}`);
+    return 0;
+  }
+  console.error(`Unknown config command: ${sub}`);
+  return 2;
+}
+
+// Read piped stdin. When a prompt was given on the command line, stdin is optional: if
+// nothing arrives quickly (e.g. an inherited pipe that never closes) we carry on without it.
+function readStdin({ optional }) {
+  if (process.stdin.isTTY) return Promise.resolve('');
+  return new Promise((resolve) => {
+    const chunks = [];
+    let timer = null;
+    const done = () => {
+      clearTimeout(timer);
+      process.stdin.removeAllListeners('data');
+      process.stdin.removeAllListeners('end');
+      process.stdin.pause();
+      resolve(Buffer.concat(chunks).toString('utf8'));
+    };
+    if (optional) timer = setTimeout(done, 300);
+    process.stdin.on('data', (d) => { clearTimeout(timer); chunks.push(d); });
+    process.stdin.on('end', done);
+    process.stdin.on('error', done);
+  });
+}
+
+export async function main(argv) {
+  const cwd = process.cwd();
+  if (argv[0] === 'config') return configCommand(argv.slice(1), cwd);
+  if (argv[0] === '--self-check') return (await import('./selfcheck.js')).selfCheck(); // see restart.js
+  const { flags, positional } = parseArgs(argv);
+  if (flags.version) { console.log(`${VERSION} (claude-pro)`); return 0; }
+  if (flags.help) { process.stdout.write(HELP); return 0; }
+
+  let prompt = positional.join(' ');
+
+  // Started by a restart of a running session: that session is picked up again, whatever the command line
+  // that started the first one said (-c, --resume, a first prompt).
+  const interactive = !(flags.print || !process.stdout.isTTY || !process.stdin.isTTY);
+  const restart = interactive ? takeRestartState() : null;
+  if (restart) {
+    flags.restart = restart;
+    flags.continue = false;
+    flags.resume = false;
+    flags.resumeId = undefined;
+    prompt = '';
+  }
+
+  if (flags.continue || (flags.resume && flags.resumeId)) {
+    const sessions = SessionStore.list(cwd);
+    const found = flags.resumeId ? sessions.find((s) => s.id.startsWith(flags.resumeId)) : sessions[0];
+    if (!found) {
+      process.stderr.write(flags.resumeId ? `No conversation found with id ${flags.resumeId}\n` : 'No conversation found to continue\n');
+      return 1;
+    }
+    flags.resumeFile = found.file;
+    flags.resumeId = found.id;
+  }
+
+  // mintty (Git Bash's default window) connects programs through pipes, not a console.
+  if (!flags.print && !process.stdin.isTTY && process.env.TERM_PROGRAM === 'mintty') {
+    process.stderr.write('Interactive mode needs a real console. In mintty/Git Bash run `winpty claude-pro` (or `winpty node bin/claude-pro.js`), or use Windows Terminal. For scripts use `claude-pro -p`.\n');
+    return 1;
+  }
+  if (flags.print || !process.stdout.isTTY || !process.stdin.isTTY) {
+    const stdin = await readStdin({ optional: !!prompt.trim() });
+    if (stdin.trim()) prompt = prompt ? `${stdin.trimEnd()}\n\n${prompt}` : stdin;
+    if (!prompt.trim()) { process.stderr.write('Error: no prompt given. Usage: claude-pro -p "your prompt"\n'); return 2; }
+    const { runPrint } = await import('./print.js');
+    return await runPrint({ prompt, flags, cwd });
+  }
+  if (!fs.existsSync(cwd)) return 1;
+  const { runRepl } = await import('./ui/repl.js');
+  return await runRepl({ flags, cwd, initialPrompt: prompt });
+}

package/src/mcp.js

@@ -0,0 +1,290 @@
+// Minimal Model Context Protocol client. Supports stdio servers and streamable HTTP
+// servers configured like Claude Code (.mcp.json or "mcpServers" in settings.json):
+//   { "mcpServers": { "name": { "command": "npx", "args": [...], "env": {...} },
+//                     "remote": { "type": "http", "url": "https://...", "headers": {...} } } }
+
+import { spawn } from 'node:child_process';
+import { VERSION } from './config.js';
+import { killTree } from './utils/shell.js';
+
+const PROTOCOL_VERSION = '2025-06-18';
+const isWin = process.platform === 'win32';
+
+function quoteWinArg(a) {
+  if (a === '') return '""';
+  if (!/[\s"&|<>^()%!]/.test(a)) return a;
+  return '"' + a.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/, '$1$1') + '"';
+}
+
+function expandEnv(value) {
+  return String(value).replace(/\$\{(\w+)(?::-([^}]*))?\}/g, (m, name, def) => process.env[name] ?? def ?? '');
+}
+
+class StdioTransport {
+  constructor(name, cfg, cwd) {
+    this.name = name;
+    this.cfg = cfg;
+    this.cwd = cwd;
+    this.pending = new Map();
+    this.nextId = 1;
+    this.stderr = '';
+    this.closed = false;
+  }
+
+  async connect() {
+    const env = { ...process.env };
+    for (const [k, v] of Object.entries(this.cfg.env || {})) env[k] = expandEnv(v);
+    const command = expandEnv(this.cfg.command);
+    const args = (this.cfg.args || []).map(expandEnv);
+    if (isWin) {
+      const line = [command, ...args].map(quoteWinArg).join(' ');
+      this.child = spawn(process.env.ComSpec || 'cmd.exe', ['/d', '/s', '/c', `"${line}"`], { env, cwd: this.cwd, windowsHide: true, windowsVerbatimArguments: true, stdio: ['pipe', 'pipe', 'pipe'] });
+    } else {
+      this.child = spawn(command, args, { env, cwd: this.cwd, stdio: ['pipe', 'pipe', 'pipe'] });
+    }
+    let buf = '';
+    // Decode as a stream: a multi-byte character (CJK text) can be split between two chunks.
+    this.child.stdout.setEncoding('utf8');
+    this.child.stderr.setEncoding('utf8');
+    this.child.stdout.on('data', (d) => {
+      buf += d;
+      let i;
+      while ((i = buf.indexOf('\n')) >= 0) {
+        const line = buf.slice(0, i).trim();
+        buf = buf.slice(i + 1);
+        if (!line) continue;
+        let msg;
+        try { msg = JSON.parse(line); } catch { continue; }
+        this.onMessage(msg);
+      }
+    });
+    this.child.stderr.on('data', (d) => { this.stderr = (this.stderr + d).slice(-4000); });
+    const failAll = (err) => {
+      this.closed = true;
+      for (const p of this.pending.values()) p.reject(err);
+      this.pending.clear();
+    };
+    this.child.on('error', (e) => failAll(e));
+    this.child.on('close', (code) => failAll(new Error(`MCP server "${this.name}" exited (code ${code}). ${this.stderr.trim().split('\n').slice(-3).join(' ')}`)));
+    this.child.stdin.on('error', () => {});
+  }
+
+  onMessage(msg) {
+    if (msg.id !== undefined && (msg.result !== undefined || msg.error !== undefined)) {
+      const p = this.pending.get(msg.id);
+      if (!p) return;
+      this.pending.delete(msg.id);
+      if (msg.error) p.reject(new Error(msg.error.message || JSON.stringify(msg.error)));
+      else p.resolve(msg.result);
+      return;
+    }
+    // Server -> client requests we don't support get a polite error; pings get an answer.
+    if (msg.id !== undefined && msg.method) {
+      const reply = msg.method === 'ping'
+        ? { jsonrpc: '2.0', id: msg.id, result: {} }
+        : { jsonrpc: '2.0', id: msg.id, error: { code: -32601, message: 'Method not supported by client' } };
+      this.send(reply);
+    }
+  }
+
+  send(obj) {
+    if (!this.closed) this.child.stdin.write(JSON.stringify(obj) + '\n');
+  }
+
+  request(method, params, { timeout = 60_000, signal } = {}) {
+    if (this.closed) return Promise.reject(new Error(`MCP server "${this.name}" is not running`));
+    const aborted = () => Object.assign(new Error('aborted'), { name: 'AbortError' });
+    if (signal?.aborted) return Promise.reject(aborted());
+    const id = this.nextId++;
+    return new Promise((resolve, reject) => {
+      // The abort listener must go as soon as the request is over: left in place it would send a
+      // cancellation for a request that already finished when the signal is aborted later.
+      const onAbort = () => {
+        this.pending.delete(id);
+        cleanup();
+        this.send({ jsonrpc: '2.0', method: 'notifications/cancelled', params: { requestId: id, reason: 'User interrupted' } });
+        reject(aborted());
+      };
+      const timer = setTimeout(() => { this.pending.delete(id); cleanup(); reject(new Error(`MCP request ${method} timed out after ${timeout}ms`)); }, timeout);
+      const cleanup = () => { clearTimeout(timer); signal?.removeEventListener('abort', onAbort); };
+      this.pending.set(id, { resolve: (v) => { cleanup(); resolve(v); }, reject: (e) => { cleanup(); reject(e); } });
+      signal?.addEventListener('abort', onAbort, { once: true });
+      this.send({ jsonrpc: '2.0', id, method, params });
+    });
+  }
+
+  notify(method, params) { this.send({ jsonrpc: '2.0', method, params }); }
+  close() { this.closed = true; killTree(this.child); }
+}
+
+class HttpTransport {
+  constructor(name, cfg) {
+    this.name = name;
+    this.url = expandEnv(cfg.url);
+    this.headers = Object.fromEntries(Object.entries(cfg.headers || {}).map(([k, v]) => [k, expandEnv(v)]));
+    this.nextId = 1;
+    this.sessionId = null;
+  }
+
+  async connect() {}
+
+  async post(body, signal, timeout) {
+    const ctrl = new AbortController();
+    // A timeout must not look like the user's interrupt: both abort the fetch, and an AbortError
+    // would end the whole agent turn as "interrupted by user".
+    let timedOut = false;
+    const timer = setTimeout(() => { timedOut = true; ctrl.abort(); }, timeout);
+    const onAbort = () => ctrl.abort();
+    if (signal?.aborted) ctrl.abort();
+    else signal?.addEventListener('abort', onAbort, { once: true });
+    try {
+      const res = await fetch(this.url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Accept: 'application/json, text/event-stream',
+          'MCP-Protocol-Version': PROTOCOL_VERSION,
+          ...(this.sessionId ? { 'Mcp-Session-Id': this.sessionId } : {}),
+          ...this.headers,
+        },
+        body: JSON.stringify(body),
+        signal: ctrl.signal,
+      });
+      this.sessionId = res.headers.get('mcp-session-id') || this.sessionId;
+      if (!res.ok && res.status !== 202) throw new Error(`HTTP ${res.status}: ${(await res.text()).slice(0, 300)}`);
+      if (body.id === undefined) return null;
+      const type = res.headers.get('content-type') || '';
+      const text = await res.text();
+      if (type.includes('text/event-stream')) {
+        for (const event of text.split(/\r?\n\r?\n/)) {
+          const data = event.split(/\r?\n/).filter((l) => l.startsWith('data:')).map((l) => l.slice(5).trim()).join('\n');
+          if (!data) continue;
+          try {
+            const msg = JSON.parse(data);
+            if (msg.id === body.id) return msg;
+          } catch { /* skip */ }
+        }
+        throw new Error('No response in event stream');
+      }
+      return JSON.parse(text);
+    } catch (e) {
+      if (timedOut && !signal?.aborted) throw new Error(`MCP request ${body.method} timed out after ${timeout}ms`);
+      throw e;
+    } finally {
+      clearTimeout(timer);
+      signal?.removeEventListener('abort', onAbort);
+    }
+  }
+
+  async request(method, params, { timeout = 60_000, signal } = {}) {
+    const msg = await this.post({ jsonrpc: '2.0', id: this.nextId++, method, params }, signal, timeout);
+    if (msg.error) throw new Error(msg.error.message || JSON.stringify(msg.error));
+    return msg.result;
+  }
+
+  // Returns a promise that never rejects, so callers can wait until the server has taken the notification.
+  notify(method, params) { return this.post({ jsonrpc: '2.0', method, params }, null, 10_000).catch(() => {}); }
+  close() {}
+}
+
+const sanitize = (s) => String(s).replace(/[^a-zA-Z0-9_-]/g, '_');
+
+function convertContent(result) {
+  const blocks = [];
+  for (const c of result.content || []) {
+    if (c.type === 'text') blocks.push({ type: 'text', text: c.text });
+    else if (c.type === 'image') blocks.push({ type: 'image', source: { type: 'base64', media_type: c.mimeType, data: c.data } });
+    else if (c.type === 'resource') blocks.push({ type: 'text', text: c.resource?.text ?? `[resource ${c.resource?.uri}]` });
+    else if (c.type === 'resource_link') blocks.push({ type: 'text', text: `[resource ${c.name || ''} ${c.uri}]` });
+    else blocks.push({ type: 'text', text: JSON.stringify(c) });
+  }
+  if (!blocks.length && result.structuredContent) blocks.push({ type: 'text', text: JSON.stringify(result.structuredContent, null, 2) });
+  if (!blocks.length) blocks.push({ type: 'text', text: '(no content)' });
+  return blocks.every((b) => b.type === 'text') ? blocks.map((b) => b.text).join('\n') : blocks;
+}
+
+export class McpManager {
+  constructor(servers = {}, { cwd }) {
+    this.servers = servers;
+    this.cwd = cwd;
+    this.clients = new Map(); // name -> {transport, tools, status, error}
+  }
+
+  async connectOne(name, cfg) {
+    const entry = { status: 'connecting', tools: [], error: null, config: cfg };
+    this.clients.set(name, entry);
+    try {
+      const type = cfg.type || (cfg.url ? 'http' : 'stdio');
+      if (type === 'sse') throw new Error('legacy SSE transport is not supported; use "type": "http"');
+      const transport = type === 'http' ? new HttpTransport(name, cfg) : new StdioTransport(name, cfg, this.cwd);
+      entry.transport = transport;
+      await transport.connect();
+      const timeout = parseInt(process.env.MCP_TIMEOUT, 10) || 30_000;
+      const init = await transport.request('initialize', {
+        protocolVersion: PROTOCOL_VERSION,
+        capabilities: {},
+        clientInfo: { name: 'claude-pro', version: VERSION },
+      }, { timeout });
+      entry.serverInfo = init?.serverInfo;
+      entry.instructions = init?.instructions;
+      // Over HTTP the notification is a request of its own: tools/list must not overtake it, or a
+      // server that insists on a finished handshake answers "not initialized".
+      await transport.notify('notifications/initialized', {});
+      const tools = [];
+      let cursor;
+      do {
+        const page = await transport.request('tools/list', cursor ? { cursor } : {}, { timeout });
+        tools.push(...(page?.tools || []));
+        cursor = page?.nextCursor;
+      } while (cursor);
+      entry.tools = tools;
+      entry.status = 'connected';
+    } catch (e) {
+      entry.status = 'failed';
+      entry.error = e.message;
+      entry.transport?.close();
+    }
+  }
+
+  async start(onWarn) {
+    const names = Object.keys(this.servers || {});
+    if (!names.length) return;
+    await Promise.all(names.map((n) => this.connectOne(n, this.servers[n])));
+    for (const [name, e] of this.clients) if (e.status === 'failed') onWarn?.(`MCP server "${name}" failed to connect: ${e.error}`);
+  }
+
+  tools() {
+    const out = [];
+    const toolTimeout = parseInt(process.env.MCP_TOOL_TIMEOUT, 10) || 600_000;
+    for (const [server, entry] of this.clients) {
+      if (entry.status !== 'connected') continue;
+      for (const t of entry.tools) {
+        const name = `mcp__${sanitize(server)}__${sanitize(t.name)}`.slice(0, 64);
+        out.push({
+          name,
+          mcp: { server, tool: t.name },
+          description: (t.description || `${t.name} (MCP tool from ${server})`).slice(0, 4000),
+          input_schema: t.inputSchema && t.inputSchema.type === 'object' ? t.inputSchema : { type: 'object', properties: {} },
+          summarize(input) {
+            const s = JSON.stringify(input);
+            return s.length > 80 ? s.slice(0, 80) + '…' : s;
+          },
+          label() { return `${server} - ${t.title || t.name} (MCP)`; },
+          async call(input, ctx) {
+            const result = await entry.transport.request('tools/call', { name: t.name, arguments: input }, { timeout: toolTimeout, signal: ctx.signal });
+            return { content: convertContent(result || {}), isError: !!result?.isError };
+          },
+        });
+      }
+    }
+    return out;
+  }
+
+  status() {
+    return [...this.clients.entries()].map(([name, e]) => ({ name, status: e.status, tools: e.tools.length, error: e.error, serverInfo: e.serverInfo }));
+  }
+
+  close() {
+    for (const e of this.clients.values()) e.transport?.close();
+  }
+}