@yanzc/claude-pro 0.0.0-stage → 0.4.1

package/src/gateway.js

@@ -0,0 +1,143 @@
+// 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;
+}
+
+// The models the gateway serves (GET /v1/models), fetched once per gateway and key. The reasoning fields are
+// optional so older gateways still work; when present they are kept with the model for /effort and requests.
+const modelLists = new Map();
+export async function fetchGatewayModels({ url, apiKey }, { fetchImpl = globalThis.fetch, signal } = {}) {
+  const key = `${normalizeGatewayUrl(url)}\n${apiKey}`;
+  if (modelLists.has(key)) return modelLists.get(key);
+  const body = await gatewayJson(`${normalizeGatewayUrl(url)}/v1/models`, { headers: { authorization: `Bearer ${apiKey}` }, signal }, fetchImpl);
+  const list = (body.data || []).filter((m) => typeof m?.id === 'string').map((m) => ({
+    ...m,
+    supported_reasoning_levels: (Array.isArray(m.supported_reasoning_levels) ? m.supported_reasoning_levels : Array.isArray(m.reasoning_levels) ? m.reasoning_levels : [])
+      .map((r) => typeof r === 'string' ? r : r?.effort || r?.name).filter(Boolean),
+    default_reasoning_level: typeof m.default_reasoning_level === 'string' ? m.default_reasoning_level
+      : m.default_reasoning_level?.effort || m.default_effort || null,
+  }));
+  modelLists.set(key, list);
+  return list;
+}
+
+export function cachedGatewayModel(login, modelId) {
+  if (!login?.url || !login?.apiKey) return null;
+  return modelLists.get(`${normalizeGatewayUrl(login.url)}\n${login.apiKey}`)?.find((m) => m.id === modelId) || null;
+}
+
+const EFFORT_ORDER = ['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra'];
+export function gatewayEfforts(model) { return model?.supported_reasoning_levels || []; }
+export function gatewayDefaultEffort(model) { return model?.default_reasoning_level || null; }
+export function gatewayEffort(model, effort) {
+  const supported = gatewayEfforts(model);
+  if (!effort || !supported.length || supported.includes(effort)) return effort;
+  const want = EFFORT_ORDER.indexOf(effort);
+  return supported.reduce((best, item) => (Math.abs(EFFORT_ORDER.indexOf(item) - want) < Math.abs(EFFORT_ORDER.indexOf(best) - want) ? item : best), supported[0]);
+}
+
+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 });
+}