@coda-console/claude 0.0.0 → 1.4.0

package/agent/waits.mjs

@@ -0,0 +1,231 @@
+// What Claude Code keeps going beside a turn, told to Coda as waits of its own (docs/agent-protocol.md「_coda/wait」): its
+// background tasks and subagents as the SDK reports them, and the wakeups it scheduled as its Stop hook lists them. A
+// subagent's session is the tool call that launched it; continued (SendMessage), it is another run under the same session.
+// What a subagent launches (`parent_task_id`) is told in that subagent's session, once a wait has told Coda that session.
+// A task that ends while no turn goes will wake Claude for its result: until a turn takes it up, or the session says idle,
+// it is still waited on. A turn Claude begins on its own handles what woke it (`takeUp`): what its opening message names,
+// else the tasks that ended, else the one wakeup due, else a wait of the turn's own; what it handles ends with that turn.
+const FINAL = { completed: 'done', failed: 'failed', killed: 'cancelled', stopped: 'cancelled', ended: 'done' };
+const open = state => state === 'waiting' || state === 'handling';
+const cut = (value, limit) => typeof value === 'string' && value ? value.slice(0, limit) : undefined;
+
+export class ClaudeWaits {
+  // `say`: a wait's report, and its session when that is a subagent's; `going`: whether a turn goes; `registered`: a subagent's
+  // session is known.
+  constructor({ say, going = () => false, registered = () => {}, now = Date.now }) {
+    this.say = say; this.going = going; this.registered = registered; this.now = now;
+    this.tasks = new Map(); this.crons = new Map(); this.own = new Set(); this.turns = 0;
+    // Commands in the foreground, by task id: each is its own tool call, which the turn (or the subagent) blocks on.
+    this.foreground = new Map();
+    // What is known of a launching tool call before its task is: a subagent's model, a command's output file.
+    this.models = new Map(); this.outputs = new Map();
+  }
+  get handling() { return this.own.size > 0 || [...this.tasks.values(), ...this.crons.values()].some(w => w.state === 'handling'); }
+  // Whether anything is still waited on: what ends with the Claude process that runs it.
+  get pending() { return this.own.size > 0 || [...this.tasks.values(), ...this.crons.values()].some(w => open(w.state)); }
+  report(wait, state, fields = {}) {
+    wait.state = state;
+    const params = { waitId: wait.waitId, state, ...Object.fromEntries(Object.entries(fields).filter(([, value]) => value !== undefined)) };
+    // Kept while the session it is in is not yet told (`named`).
+    if (wait.held) wait.held.push(params); else this.say(params, wait.sessionId);
+  }
+  // A task begun (`task_started`, `start`), or listed among those in the background (`listed`).
+  started(native, { start = false, listed = false } = {}) {
+    if (native.ambient || typeof native.task_id !== 'string' || !native.task_id) return;
+    // A command in the foreground is not waited on until it is put in the background (`backgrounded`). A subagent in the
+    // foreground still is: its session is that card's.
+    if (native.is_backgrounded === false && native.task_type !== 'local_agent' && !this.tasks.has(native.task_id)) {
+      this.foreground.set(native.task_id, native);
+      return;
+    }
+    const known = this.tasks.get(native.task_id);
+    if (known) {
+      if (listed) known.listed = true;
+      // A snapshot names no tool call and may come before its run's start, even after its end: that start says the launching
+      // call, and with it a subagent's session. A start of the run already known is that run's, never another.
+      const sameRun = native.run_id && known.runId ? native.run_id === known.runId : !known.toolUseId;
+      if (start && sameRun && !known.toolUseId && native.tool_use_id) {
+        const toolUseId = cut(native.tool_use_id, 200), subagent = known.kind === 'subagent';
+        Object.assign(known, { toolUseId, runId: known.runId ?? native.run_id }, subagent ? { childSessionId: toolUseId } : {});
+        if (open(known.state)) this.report(known, known.state, { childSessionId: subagent ? toolUseId : undefined, toolCallId: toolUseId,
+          outputFile: subagent ? undefined : this.outputs.get(toolUseId), model: subagent ? this.models.get(toolUseId) : undefined });
+        if (subagent && !known.held) this.named(known);
+        // An end held for its session is told now while a turn goes, which takes it in.
+        if (known.final !== undefined && known.state === 'waiting' && this.going()) { this.report(known, known.final); known.final = undefined; }
+        return;
+      }
+      // Only a start of another run under another call brings a subagent that ended back; snapshots and repeats cannot.
+      if (!start || sameRun || known.kind !== 'subagent' || (open(known.state) && known.final === undefined) || !native.tool_use_id || native.tool_use_id === known.toolUseId) return;
+      // Its last run ends before the next begins; one the turn going handles leaves it to a wait of the turn's own.
+      if (known.state === 'handling' && this.own.size === 0) this.hold();
+      if (known.final !== undefined) { this.report(known, known.final); known.final = undefined; }
+      known.run++; Object.assign(known, { waitId: `${known.taskId}#${known.run}`, toolUseId: native.tool_use_id, runId: native.run_id });
+      this.report(known, 'waiting', { kind: 'subagent', title: cut(native.description, 500) ?? '子 Agent', childSessionId: known.childSessionId,
+        stoppable: true, model: this.models.get(known.childSessionId) });
+      return;
+    }
+    const subagent = native.task_type === 'local_agent', toolUseId = cut(native.tool_use_id, 200);
+    const task = { taskId: native.task_id, waitId: native.task_id.slice(0, 200), run: 1, kind: subagent ? 'subagent' : 'task', toolUseId, runId: native.run_id,
+      listed: listed || native.is_backgrounded === true, parentTaskId: native.parent_task_id, ...(subagent ? { childSessionId: toolUseId ?? native.task_id.slice(0, 200) } : {}) };
+    if (task.parentTaskId) {
+      const parent = this.tasks.get(task.parentTaskId);
+      if (parent?.toolUseId && !parent.held) task.sessionId = parent.childSessionId; else task.held = [];
+    }
+    this.tasks.set(task.taskId, task);
+    this.report(task, 'waiting', { kind: task.kind, title: cut(native.description, 500) ?? (subagent ? '子 Agent' : '后台任务'), stoppable: true,
+      childSessionId: task.childSessionId, toolCallId: toolUseId, outputFile: this.outputs.get(toolUseId),
+      model: subagent ? this.models.get(task.childSessionId) : undefined });
+    if (subagent && !task.held) this.named(task);
+  }
+  // A subagent's session told to Coda: what it said there comes after, and what it launched is told there, held reports first.
+  named(subagent) {
+    this.registered(subagent.childSessionId);
+    if (!subagent.toolUseId) return;
+    for (const task of this.tasks.values()) {
+      if (!task.held || task.parentTaskId !== subagent.taskId) continue;
+      const held = task.held;
+      task.held = undefined; task.sessionId = subagent.childSessionId;
+      for (const params of held) this.say(params, task.sessionId);
+      if (task.kind === 'subagent') this.named(task);
+    }
+  }
+  // A command in the foreground put in the background: from now on it is waited on, as begun there.
+  backgrounded(taskId) {
+    const native = this.foreground.get(taskId);
+    if (!native) return;
+    this.foreground.delete(taskId);
+    this.started({ ...native, is_backgrounded: true }, { start: true });
+  }
+  renamed(taskId, description) {
+    const task = this.tasks.get(taskId);
+    if (task && open(task.state) && cut(description, 500)) this.report(task, task.state, { title: cut(description, 500) });
+  }
+  // A task's end (`status` as the SDK says it; `ended` when it left the list without one): told now while a turn goes, which
+  // takes in its result; otherwise once a turn has taken it up.
+  ended(taskId, status, { outputFile } = {}) {
+    this.foreground.delete(taskId);
+    const task = this.tasks.get(taskId), final = FINAL[status];
+    if (!task || !final || !open(task.state)) return;
+    if (task.final !== undefined) { if (status !== 'ended') task.final = final; return; }
+    const fields = { outputFile: cut(outputFile, 4096) };
+    // A subagent whose session is not yet known ends once it is (`started`), or as the turn or the session settles.
+    if (task.state === 'handling' || !this.going() || (task.kind === 'subagent' && !task.toolUseId)) {
+      Object.assign(task, { final, endedAt: this.now() });
+      if (fields.outputFile) this.report(task, task.state, fields);
+    } else this.report(task, final, fields);
+  }
+  snapshot(list) {
+    const live = new Set(list.map(native => native.task_id));
+    for (const task of this.tasks.values()) if (task.listed && !live.has(task.taskId)) this.ended(task.taskId, 'ended');
+    for (const native of list) { this.backgrounded(native.task_id); this.started(native, { listed: true }); }
+  }
+  // The Stop hook's list of the wakeups the session has, complete each time.
+  scheduled(list) {
+    const listed = new Set();
+    for (const native of list) {
+      listed.add(native.id);
+      if (this.crons.has(native.id)) continue;
+      const cron = { waitId: native.id.slice(0, 200), schedule: native.schedule, recurring: native.recurring, prompt: native.prompt, at: nextRun(native.schedule, this.now()) };
+      this.crons.set(native.id, cron);
+      this.report(cron, 'waiting', { kind: 'timer', title: cut(native.prompt, 100) ?? cut(native.schedule, 500), detail: cut(native.schedule, 4000),
+        recurring: native.recurring, stoppable: false, at: cron.at === null ? undefined : new Date(cron.at).toISOString() });
+    }
+    for (const [id, cron] of this.crons) {
+      if (listed.has(id) || !open(cron.state)) continue;
+      if (cron.state === 'handling') cron.final = 'done'; else this.report(cron, 'done');
+    }
+  }
+  // The tasks that ended since the last turn: taken in by the turn that ended now, or not to wake Claude now it is idle.
+  settled() {
+    for (const task of this.tasks.values()) if (task.final !== undefined && task.state === 'waiting') { this.report(task, task.final); task.final = undefined; }
+  }
+  // A turn Claude began on its own: what it handles. `origin`, `text`: its opening message's, when that came first.
+  takeUp({ origin, text } = {}) {
+    const pending = [...this.tasks.values()].filter(task => task.final !== undefined && task.state === 'waiting');
+    const crons = [...this.crons.values()].filter(cron => open(cron.state));
+    let handled = [];
+    if (origin?.kind === 'task-notification') handled = origin.subkind === 'scheduled-trigger' ? crons.filter(cron => cron.prompt && cron.prompt === text)
+      : [...this.tasks.values()].filter(task => origin.runId && task.runId === origin.runId && open(task.state));
+    if (!handled.length) handled = pending.sort((a, b) => a.endedAt - b.endedAt);
+    if (!handled.length) {
+      // Which came due is not told: the one due, or else the only one there is.
+      const due = crons.filter(cron => cron.at !== null && cron.at <= this.now() + 60_000);
+      if ((due.length || crons.length) === 1) handled = due.length ? due : crons;
+    }
+    if (handled.length) for (const wait of handled) this.report(wait, 'handling');
+    else this.hold();
+  }
+  hold() {
+    const own = { waitId: `turn-${++this.turns}` };
+    this.own.add(own);
+    this.report(own, 'handling', { kind: 'task', title: 'Claude 自主继续', stoppable: false });
+  }
+  // That turn's end: what it handled ended with it, a recurring wakeup waits for its next time.
+  finished() {
+    for (const task of this.tasks.values()) if (task.state === 'handling') { this.report(task, task.final ?? 'done'); task.final = undefined; }
+    for (const cron of this.crons.values()) {
+      if (cron.state !== 'handling') continue;
+      if (cron.final !== undefined || !cron.recurring) { this.report(cron, 'done'); continue; }
+      cron.at = nextRun(cron.schedule, this.now());
+      this.report(cron, 'waiting', { at: cron.at === null ? undefined : new Date(cron.at).toISOString() });
+    }
+    for (const own of this.own) this.report(own, 'done');
+    this.own.clear();
+  }
+  // A stop Coda asks of a wait: the task to stop when it still goes (null: none). One that ended and is yet to be taken in is
+  // not waited for any more: it ends now ('').
+  stop(waitId) {
+    const task = [...this.tasks.values()].find(task => task.waitId === waitId && open(task.state));
+    if (!task) return null;
+    if (task.final === undefined) return task.taskId;
+    if (task.state === 'waiting') { this.report(task, task.final); task.final = undefined; }
+    return '';
+  }
+  childSession(agentId) { return typeof agentId === 'string' ? this.tasks.get(agentId)?.childSessionId ?? null : null; }
+  // A subagent's actual model, from its own replies (which can come before its task).
+  model(toolUseId, model) {
+    if (typeof model !== 'string' || !model.trim() || model === '<synthetic>') return;
+    this.models.set(toolUseId, model);
+    const task = [...this.tasks.values()].find(task => task.childSessionId === toolUseId && open(task.state));
+    if (task && task.model !== model) { task.model = model; this.report(task, task.state, { model: cut(model, 200) }); }
+  }
+  // Where a command put in the background writes, as its launch said.
+  outputFile(toolUseId, path) {
+    this.outputs.set(toolUseId, path);
+    const task = [...this.tasks.values()].find(task => task.toolUseId === toolUseId && task.kind === 'task' && open(task.state));
+    if (task) this.report(task, task.state, { outputFile: cut(path, 4096) });
+  }
+}
+
+// The next minute after `from` a five-field cron schedule matches, in local time (as Claude Code schedules); null when it
+// cannot be read or never matches within five years.
+export function nextRun(schedule, from = Date.now()) {
+  const fields = typeof schedule === 'string' ? schedule.trim().split(/\s+/) : [];
+  if (fields.length !== 5) return null;
+  const [minutes, hours, days, months, weekdays] = fields.map((field, i) => values(field, ...[[0, 59], [0, 23], [1, 31], [1, 12], [0, 7]][i]));
+  if (![minutes, hours, days, months, weekdays].every(Boolean)) return null;
+  if (weekdays.has(7)) weekdays.add(0);
+  // Both day fields restricted: either matches.
+  const day = date => fields[2] === '*' ? fields[4] === '*' || weekdays.has(date.getDay())
+    : fields[4] === '*' ? days.has(date.getDate()) : days.has(date.getDate()) || weekdays.has(date.getDay());
+  const t = new Date(from); t.setSeconds(0, 0); t.setMinutes(t.getMinutes() + 1);
+  for (const limit = from + 5 * 366 * 86_400_000; t.getTime() < limit;) {
+    if (!months.has(t.getMonth() + 1)) { t.setMonth(t.getMonth() + 1, 1); t.setHours(0, 0, 0, 0); }
+    else if (!day(t)) { t.setDate(t.getDate() + 1); t.setHours(0, 0, 0, 0); }
+    else if (!hours.has(t.getHours())) t.setHours(t.getHours() + 1, 0, 0, 0);
+    else if (!minutes.has(t.getMinutes())) t.setMinutes(t.getMinutes() + 1, 0, 0);
+    else return t.getTime();
+  }
+  return null;
+}
+function values(field, min, max) {
+  const set = new Set();
+  for (const part of field.split(',')) {
+    const m = /^(?:(\*)|(\d+)(?:-(\d+))?)(?:\/(\d+))?$/.exec(part);
+    if (!m) return null;
+    const low = m[1] ? min : Number(m[2]), high = m[1] ? max : m[3] !== undefined ? Number(m[3]) : m[4] ? max : low, step = m[4] ? Number(m[4]) : 1;
+    if (low < min || high > max || low > high || step < 1) return null;
+    for (let v = low; v <= high; v += step) set.add(v);
+  }
+  return set;
+}

package/icons/README.md

@@ -0,0 +1,15 @@
+# Claude 品牌图形
+
+仅用于标识会话所用的服务，不作为 Coda 自身标志。商标归各自权利人所有。
+
+- `claude.svg`：取自 [Claude 官网](https://claude.com/) 导航字标中的独立花形路径，保留官方 `#D97757` 色和几何形状；供 Claude SDK 使用。
+
+提取日期：2026-09-19。SVG 是可审阅的源文件，PDF 是由 CairoSVG 转换的等比矢量资源，清单的 `icon` 指向 PDF。重新生成 PDF（开发工具，不是构建或运行依赖）：
+
+```sh
+uv run --with cairosvg python - <<'PY'
+import cairosvg
+for name in ['claude']:
+    cairosvg.svg2pdf(url=f'{name}.svg', write_to=f'{name}.pdf')
+PY
+```

package/icons/claude.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="125" height="125" viewBox="0 0 125 125">
+<path d="M54.375 118.75L56.125 111L58.125 101L59.75 93L61.25 83.125L62.125 79.875L62 79.625L61.375 79.75L53.875 90L42.5 105.375L33.5 114.875L31.375 115.75L27.625 113.875L28 110.375L30.125 107.375L42.5 91.5L50 81.625L54.875 76L54.75 75.25H54.5L21.5 96.75L15.625 97.5L13 95.125L13.375 91.25L14.625 90L24.5 83.125L49.125 69.375L49.5 68.125L49.125 67.5H47.875L43.75 67.25L29.75 66.875L17.625 66.375L5.75 65.75L2.75 65.125L0 61.375L0.25 59.5L2.75 57.875L6.375 58.125L14.25 58.75L26.125 59.5L34.75 60L47.5 61.375H49.5L49.75 60.5L49.125 60L48.625 59.5L36.25 51.25L23 42.5L16 37.375L12.25 34.75L10.375 32.375L9.625 27.125L13 23.375L17.625 23.75L18.75 24L23.375 27.625L33.25 35.25L46.25 44.875L48.125 46.375L49 45.875V45.5L48.125 44.125L41.125 31.375L33.625 18.375L30.25 13L29.375 9.75C29.0417 8.625 28.875 7.375 28.875 6L32.75 0.750006L34.875 0L40.125 0.750006L42.25 2.625L45.5 10L50.625 21.625L58.75 37.375L61.125 42.125L62.375 46.375L62.875 47.75H63.75V47L64.375 38L65.625 27.125L66.875 13.125L67.25 9.125L69.25 4.375L73.125 1.87501L76.125 3.25L78.625 6.875L78.25 9.125L76.875 18.75L73.875 33.875L72 44.125H73.125L74.375 42.75L79.5 36L88.125 25.25L91.875 21L96.375 16.25L99.25 14H104.625L108.5 19.875L106.75 26L101.25 33L96.625 38.875L90 47.75L86 54.875L86.375 55.375H87.25L102.125 52.125L110.25 50.75L119.75 49.125L124.125 51.125L124.625 53.125L122.875 57.375L112.625 59.875L100.625 62.25L82.75 66.5L82.5 66.625L82.75 67L90.75 67.75L94.25 68H102.75L118.5 69.125L122.625 71.875L125 75.125L124.625 77.75L118.25 80.875L109.75 78.875L89.75 74.125L83 72.5H82V73L87.75 78.625L98.125 88L111.25 100.125L111.875 103.125L110.25 105.625L108.5 105.375L97 96.625L92.5 92.75L82.5 84.375H81.875V85.25L84.125 88.625L96.375 107L97 112.625L96.125 114.375L92.875 115.5L89.5 114.875L82.25 104.875L74.875 93.5L68.875 83.375L68.25 83.875L64.625 121.625L63 123.5L59.25 125L56.125 122.625L54.375 118.75Z" fill="#D97757"></path>
+</svg>

package/package.json

@@ -1,7 +1,63 @@
 {
   "name": "@coda-console/claude",
-  "version": "0.0.0",
-  "description": "Reserved for the first Coda plugin release.",
+  "id": "claude",
+  "displayName": "Claude",
+  "description": "Claude SDK Agent：Coda 基于 Claude Agent SDK 写的 ACP 入口，一个进程一个 SDK 会话；资源页的「Claude」面板显示会话报告的额度，可从 Coda 登录。",
+  "version": "1.4.0",
+  "dependencies": {
+    "@agentclientprotocol/sdk": "1.4.0",
+    "@anthropic-ai/claude-agent-sdk": "0.3.296"
+  },
+  "contributes": {
+    "agents": [
+      {
+        "id": "claude-sdk",
+        "displayName": "Claude SDK",
+        "icon": {
+          "light": "icons/claude.pdf"
+        },
+        "command": "exec \"$CODA_NODE\" \"$CODA_PLUGIN_PATH/agent/entry.mjs\"",
+        "modes": {
+          "title": "审批模式",
+          "unset": "人工审批",
+          "auto": "auto",
+          "full": "bypassPermissions"
+        },
+        "skillsDir": ".claude/skills",
+        "configFiles": [
+          "${CLAUDE_CONFIG_DIR:-~/.claude}/settings.json",
+          ".claude/settings.json",
+          ".claude/settings.local.json"
+        ],
+        "setupHint": "请在运行机配置 Claude SDK 认证；若指定了 token 文件，请检查路径和权限。"
+      }
+    ],
+    "configuration": {
+      "title": "Claude",
+      "properties": {
+        "claude.modelProvider": {
+          "type": "string",
+          "format": "coda-model-provider",
+          "title": "模型服务",
+          "order": 1,
+          "description": "选一个插件提供的模型服务（如 Magpie），它列出的模型和 Claude 自己的模型一起出现在会话的模型里；选中它的模型，那个会话就走这个服务，Claude 自己的模型照旧。只接 Anthropic 接口（anthropic-messages）的服务。"
+        }
+      }
+    },
+    "panels": [
+      {
+        "id": "limits",
+        "title": "Claude",
+        "command": "node \"$CODA_PLUGIN_PATH/scripts/panel.mjs\"",
+        "signIn": {
+          "command": "exec node \"$CODA_PLUGIN_PATH/scripts/login.mjs\"",
+          "installed": "node \"$CODA_PLUGIN_PATH/scripts/login.mjs\" --installed",
+          "input": "authorizationCode",
+          "note": "登录保存在这台机器上，供 Claude SDK 使用；额度在会话运行后出现。这台机器若已配置 OAuth token、API key 或云服务商，会话仍优先用那些配置。"
+        }
+      }
+    ]
+  },
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -10,5 +66,10 @@
   },
   "publishConfig": {
     "access": "public"
-  }
+  },
+  "files": [
+    "agent",
+    "scripts",
+    "icons"
+  ]
 }

package/scripts/login.mjs

@@ -0,0 +1,76 @@
+// The「Claude」panel's login (`signIn`): `claude auth login --claudeai` of the CLI that comes with the plugin's own Claude
+// SDK (the one its sessions run), never another on the PATH. Coda shows the authorization link this prints
+// and writes the code the page gave back to its input, once (docs/plugins.md「面板的登录」). Only the official link is
+// passed on, and only a code bound to it is handed to the CLI, which does the exchange, keeps and renews the credentials.
+// What the CLI says otherwise is not passed on: it may carry the code. `--installed` says whether that CLI is there.
+import { spawn } from 'node:child_process';
+import { createRequire } from 'node:module';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { stripVTControlCharacters } from 'node:util';
+
+// Resolved beside the SDK, as its query() resolves it.
+export function claudeBinary() {
+  const sdk = createRequire(createRequire(import.meta.url).resolve('@anthropic-ai/claude-agent-sdk'));
+  const platform = process.platform, arch = process.arch;
+  const musl = platform === 'linux' && !process.report.getReport().header.glibcVersionRuntime;
+  for (const suffix of platform === 'linux' ? (musl ? ['-musl', ''] : ['', '-musl']) : ['']) {
+    try { return sdk.resolve(`@anthropic-ai/claude-agent-sdk-${platform}-${arch}${suffix}/claude${platform === 'win32' ? '.exe' : ''}`); }
+    catch {}
+  }
+  return null;
+}
+// The official authorization link among whole lines of what the CLI printed, terminal hyperlinks included.
+export function authorization(output) {
+  const lines = stripVTControlCharacters(output.slice(0, output.lastIndexOf('\n') + 1));
+  for (const match of lines.matchAll(/https:\/\/[^\s]+/g)) {
+    try {
+      const url = new URL(match[0]);
+      if (((url.origin === 'https://claude.ai' && url.pathname === '/oauth/authorize') ||
+           (url.origin === 'https://claude.com' && url.pathname === '/cai/oauth/authorize')) &&
+          url.searchParams.get('state') && url.searchParams.get('code_challenge') && url.searchParams.get('response_type') === 'code') return url;
+    } catch {}
+  }
+  return null;
+}
+// The code the page gives is `<code>#<state>`: one for another login is not handed over.
+export const bound = (code, url) => /^[A-Za-z0-9_-]+#[A-Za-z0-9_-]+$/.test(code) && code.split('#')[1] === url.searchParams.get('state');
+
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  const binary = claudeBinary();
+  if (process.argv[2] === '--installed') process.exit(binary ? 0 : 1);
+  if (!binary) { console.error('找不到 Claude SDK 自带的 CLI'); process.exit(1); }
+  const env = { ...process.env, BROWSER: '/usr/bin/true', NO_COLOR: '1' };
+  // auth login otherwise silently imports this token instead of opening a fresh browser login.
+  delete env.CLAUDE_CODE_OAUTH_REFRESH_TOKEN; delete env.CLAUDE_CODE_OAUTH_SCOPES;
+  const child = spawn(binary, ['auth', 'login', '--claudeai'], { env, stdio: ['pipe', 'pipe', 'pipe'] });
+  child.stdin.on('error', () => {});
+  let output = '', url = null, failed = null;
+  const heard = chunk => {
+    if (url) return;
+    output += chunk;
+    url = authorization(output);
+    if (url) console.log(url.href);
+  };
+  child.stdout.on('data', heard); child.stderr.on('data', heard);
+  // Coda writes the code once, ending it with a newline.
+  let typed = '';
+  process.stdin.setEncoding('utf8').on('data', chunk => {
+    typed += chunk;
+    const end = typed.indexOf('\n');
+    if (end < 0) return;
+    const code = typed.slice(0, end).trim();
+    process.stdin.pause();
+    if (url && bound(code, url)) return child.stdin.write(`${code}\n`);
+    failed = '授权码不对：要贴这次登录的网页给出的完整授权码，请重新登录。';
+    child.kill();
+  });
+  child.on('error', () => { failed ??= 'Claude CLI 没能启动'; });
+  // Coda ends the whole group; one ended alone takes its CLI along.
+  for (const signal of ['SIGTERM', 'SIGINT']) process.on(signal, () => { child.kill(); process.exit(1); });
+  child.on('close', code => {
+    if (code === 0 && !failed) process.exit(0);
+    console.error(failed ?? 'Claude 登录没有完成，请重新登录。');
+    process.exit(1);
+  });
+}

package/scripts/panel.mjs

@@ -0,0 +1,6 @@
+// The「Claude」panel's reading, printed once as `{ items }`, from what the sessions wrote into this plugin's state.
+import { join } from 'node:path';
+import { ClaudeSessionLimits } from '../agent/limits.mjs';
+import { panel } from './quota.mjs';
+
+console.log(JSON.stringify(panel(new ClaudeSessionLimits({ path: process.env.CODA_PLUGIN_STATE ? join(process.env.CODA_PLUGIN_STATE, 'limits.json') : null }))));

package/scripts/quota.mjs

@@ -0,0 +1,11 @@
+// What the「Claude」panel shows (docs/plugins.md「内置插件：Claude」): the plan windows this machine's Claude sessions last
+// reported (agent/limits.mjs). Nothing reported yet shows nothing; the panel is then offered under「添加资源」 for signing in.
+export function panel(limits) {
+  if (!limits.known()) return { items: [] };
+  const windows = limits.quota();
+  // The account the windows are of, compared across machines by Coda's group view.
+  return { items: [{ type: 'card', title: 'Claude SDK', ...(limits.account ? { identity: `claude:${limits.account}` } : {}), items: windows.length
+    ? windows.map(w => ({ type: 'meter', label: w.label, value: `剩余 ${w.remainingPercent}%`, fraction: w.remainingPercent / 100, time: w.resetsAt, timeLabel: '重置' }))
+    // Past its reset a window is not known, neither full nor empty: what was used since is not seen from here.
+    : [{ type: 'error', text: '额度记录已过期，会话再运行后更新' }] }] };
+}

package/README.md

@@ -1,3 +0,0 @@
-# @coda-console/claude
-
-Bootstrap placeholder. The usable release will be published by coda-console/coda-plugins.