dsh-llm-local-token 1.3.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 bigborad
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,153 @@
+# dsh-llm-local-token
+
+A [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) plugin that serves LLM
+calls with the OAuth tokens your **local CLIs already hold** — no separate API key, no extra
+login. If you are signed in to the Codex CLI or to Claude Code, those subscriptions become
+usable model routes inside DSH.
+
+| Provider route | Credential source | Endpoint |
+| --- | --- | --- |
+| `openai-codex` | `~/.codex/auth.json` (ChatGPT OAuth, shared with the `codex` CLI) | `https://chatgpt.com/backend-api` |
+| `anthropic` | `~/.claude/.credentials.json`, else the macOS Keychain item `Claude Code-credentials` | `https://api.anthropic.com` |
+
+Both routes appear in the model picker as soon as the plugin loads. A route whose credential is
+missing is skipped instead of failing the boot.
+
+<table>
+<tr>
+<td align="center" width="50%"><sub>Both subscriptions as routes in the model picker</sub><br><img src="https://raw.githubusercontent.com/tianxia--/dsh-llm-local-token/main/docs/model-routes.png" alt="The DSH model picker listing OpenAI Codex (local token) and Claude (local token) groups" width="330"></td>
+<td align="center" width="50%"><sub>Subscription usage, read from provider rate-limit headers</sub><br><img src="https://raw.githubusercontent.com/tianxia--/dsh-llm-local-token/main/docs/subscription-usage.png" alt="Subscription usage popover showing Claude and OpenAI Codex quota windows" width="400"></td>
+</tr>
+</table>
+
+## Why it exists
+
+DSH resolves a provider's key through its credential seam, which expects an API key. Personal
+Codex / Claude subscriptions are OAuth-only, so the keys simply do not exist. This plugin
+resolves the token per request from the file the CLI maintains, refreshes it when it is close to
+expiry, and hands it to the pi-ai engine that DSH already ships.
+
+## Install
+
+```bash
+dsh plugin --profile web add dsh-llm-local-token
+
+# or straight from git
+dsh plugin --profile web add https://github.com/tianxia--/dsh-llm-local-token.git
+```
+
+Then restart `dsh` — that is the whole install. The package declares a profile
+bundle (`dsh.bundle.patch` → [`cordis.patch.yml`](cordis.patch.yml)), so DSH
+inserts the loader row for you; you do **not** have to hand-edit the profile's
+own `cordis.patch.yml`.
+
+<details>
+<summary>Enabling it by hand instead</summary>
+
+If you vendored the plugin, or you want to pin its `config` in your own patch
+layer, append the row yourself to `~/.dsh/profiles/web/cordis.patch.yml`. Your
+profile's layer is applied after every bundle layer, so restating the id here
+also lets you override the bundle's defaults:
+
+```yaml
+- insert:
+    - id: llm-local-token
+      name: dsh-llm-local-token
+```
+
+</details>
+
+To make it the default model:
+
+```yaml
+# ~/.dsh/settings.yaml
+agent-default-model:
+  provider: openai-codex
+  model: gpt-5.6-terra
+  reasoningEffort: medium
+```
+
+## Configuration
+
+All keys are optional; the defaults match a stock CLI install.
+
+| Key | Default | Meaning |
+| --- | --- | --- |
+| `codexAuthPath` | `$CODEX_HOME/auth.json`, else `~/.codex/auth.json` | Codex credential file |
+| `claudeAuthPath` | `~/.claude/.credentials.json` | Legacy Claude Code credential file |
+| `claudeKeychainService` | `Claude Code-credentials` | macOS Keychain service holding the Claude OAuth payload |
+| `requireClaude` | `false` | Fail activation when no Claude credential is found, instead of skipping the route |
+| `codexTransport` | `"sse"` | Streaming transport for the Codex route: `sse` / `websocket` / `websocket-cached` / `auto`. **The quota badge depends on `sse`**: pi-ai's default `auto` streams over WebSocket, and the `x-codex-*` quota headers exist only on the SSE response, so the badge stays empty under WS. Set `auto` to prefer WebSocket and accept no Codex quota data. |
+
+## Subscription usage badge
+
+Both providers return their quota state in response headers, so the plugin reads it for free —
+no polling, no extra endpoint hits. A badge appears in the composer bar next to the context
+ring; click it for the breakdown.
+
+| Provider | Headers read | Shown |
+| --- | --- | --- |
+| `openai-codex` | `x-codex-primary-*`, `x-codex-secondary-*`, `x-codex-plan-type`, `x-codex-credits-balance` | plan, used % per window, reset countdown, credit balance |
+| `anthropic` | `anthropic-ratelimit-unified-{5h,7d}-{utilization,reset,status}` | used % for the 5-hour and 7-day windows, reset countdown |
+
+The badge is green under 60%, amber under 85%, red above. Usage is whatever the **last real
+request** reported, so a freshly started host shows "no data yet" until you send one message.
+The browser half polls `GET /llm-local-token/usage` every 15s; that route only reads the
+in-memory snapshot.
+
+The badge shows **only the provider serving the currently selected model**: pick Codex and you see
+Codex's windows, switch to Claude and it swaps — the two are never mixed into one number. When the
+selected model belongs to another adapter (a plain API key, another plugin) the badge hides itself,
+because that quota is not this plugin's to report. The popover still lists every route, with the
+active one first and marked "current" and the rest dimmed. The selection comes from
+`ctx.modelDirectories`; a composition without that service (non-Web) falls back to the previous
+union-of-all-routes view.
+
+## Requirements
+
+- Node.js **22.13+** (DSH's own floor; `--use-system-ca` needs it too)
+- `dsh-base` in the profile — it already provides `@deepseek-ai/dsh-llm-pi-ai` and `@earendil-works/pi-ai`
+- A signed-in CLI: `codex login` for the Codex route; Claude Code for the Anthropic route
+- The Claude Keychain lookup is macOS-only. On Linux/Windows only the file store is consulted.
+
+## Token handling
+
+- Read per request, never cached in memory beyond the call
+- Refreshed when less than 5 minutes of life remain, then **written back to the same file** the
+  CLI reads, so the CLI stays logged in (single-flight: concurrent requests trigger one refresh)
+- Written atomically with `0600` permissions
+- Never logged, never sent anywhere except the provider endpoint
+
+## Troubleshooting
+
+### `UNABLE_TO_GET_ISSUER_CERT_LOCALLY`
+
+Your traffic goes through a TLS-inspecting proxy (Zscaler, Netskope, corporate MITM). Node does
+not trust its root CA even when the OS does. Start DSH with either:
+
+```bash
+node --use-system-ca …                          # trust the OS store (Node 22.13+)
+NODE_EXTRA_CA_CERTS=/path/to/root-ca.pem dsh …  # or point at the proxy's root cert
+```
+
+### `Provider is not configured: openai-codex`
+
+Means the pi-ai provider refused an API-key override. This plugin already attaches an api-key
+auth method to the OAuth-only Codex provider; seeing this error again implies a pi-ai version
+whose `resolveProviderAuth` changed — open an issue with your `@earendil-works/pi-ai` version.
+
+### The model list shows no Codex/Claude entries
+
+Check the boot log for `llm-local-token: registered …`. If it names only `openai-codex`, no
+Claude credential was found (expected when Claude Code was never used on this machine).
+
+## Caveats
+
+- Uses your **personal subscription quota** (ChatGPT Plus/Pro, Claude Pro/Max). Respect the
+  provider's terms; this is not a way to share one seat across a team.
+- `chatgpt.com/backend-api` is the Codex client's own endpoint, not a documented public API. It
+  can change without notice; pin the pi-ai version if you need stability.
+
+## License
+
+MIT

package/README.zh.md

@@ -0,0 +1,141 @@
+# dsh-llm-local-token
+
+一个 [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) 插件：让 DSH 的 LLM 请求
+直接复用你**本机 CLI 已有的 OAuth 登录态**，不需要另配 API key，也不用重新登录。只要你登录过
+Codex CLI 或 Claude Code，这些订阅就会变成 DSH 里可选的模型路由。
+
+| Provider 路由 | 凭据来源 | 端点 |
+| --- | --- | --- |
+| `openai-codex` | `~/.codex/auth.json`（ChatGPT OAuth，与 `codex` CLI 共用） | `https://chatgpt.com/backend-api` |
+| `anthropic` | `~/.claude/.credentials.json`，否则读 macOS Keychain 的 `Claude Code-credentials` | `https://api.anthropic.com` |
+
+插件加载后模型直接出现在模型选择器里。缺少凭据的路由会被跳过，不会导致启动失败。
+
+<table>
+<tr>
+<td align="center" width="50%"><sub>两份订阅都成了模型选择器里的路由</sub><br><img src="https://raw.githubusercontent.com/tianxia--/dsh-llm-local-token/main/docs/model-routes.png" alt="DSH 模型选择器中的 OpenAI Codex (local token) 与 Claude (local token) 分组" width="330"></td>
+<td align="center" width="50%"><sub>订阅用量，来自 provider 的 rate-limit 响应头</sub><br><img src="https://raw.githubusercontent.com/tianxia--/dsh-llm-local-token/main/docs/subscription-usage.png" alt="订阅用量弹层，显示 Claude 与 OpenAI Codex 的配额窗口" width="400"></td>
+</tr>
+</table>
+
+## 为什么需要它
+
+DSH 通过凭据服务解析 provider 的 key，而个人版 Codex / Claude 订阅是 OAuth-only 的，根本没有
+API key。这个插件在每次请求时从 CLI 维护的文件里解析 token，临近过期自动刷新，然后交给 DSH 自带
+的 pi-ai 引擎发请求。
+
+## 安装
+
+```bash
+dsh plugin --profile web add dsh-llm-local-token
+
+# 或直接从 git 安装
+dsh plugin --profile web add https://github.com/tianxia--/dsh-llm-local-token.git
+```
+
+然后重启 `dsh`——安装就到这里。本包声明了 profile bundle（`dsh.bundle.patch` →
+[`cordis.patch.yml`](cordis.patch.yml)），DSH 会替你插入那条 loader 行，**不需要**
+手工编辑 profile 自己的 `cordis.patch.yml`。
+
+<details>
+<summary>改为手工启用</summary>
+
+如果你是把插件源码复制进来用，或者想在自己的补丁层里固定它的 `config`，那就自己往
+`~/.dsh/profiles/web/cordis.patch.yml` 追加这一行。profile 自己的补丁层在所有 bundle
+层之后生效，所以在这里重述同一个 id 也可以覆盖 bundle 的默认值：
+
+```yaml
+- insert:
+    - id: llm-local-token
+      name: dsh-llm-local-token
+```
+
+</details>
+
+想设为默认模型：
+
+```yaml
+# ~/.dsh/settings.yaml
+agent-default-model:
+  provider: openai-codex
+  model: gpt-5.6-terra
+  reasoningEffort: medium
+```
+
+## 配置项
+
+全部可选，默认值对应标准 CLI 安装。
+
+| 键 | 默认 | 说明 |
+| --- | --- | --- |
+| `codexAuthPath` | `$CODEX_HOME/auth.json`，否则 `~/.codex/auth.json` | Codex 凭据文件 |
+| `claudeAuthPath` | `~/.claude/.credentials.json` | 旧版 Claude Code 凭据文件 |
+| `claudeKeychainService` | `Claude Code-credentials` | 存放 Claude OAuth 数据的 Keychain 服务名 |
+| `requireClaude` | `false` | 为 `true` 时找不到 Claude 凭据就启动失败（而不是跳过） |
+| `codexTransport` | `"sse"` | Codex 路由的流式通道：`sse` / `websocket` / `websocket-cached` / `auto`。**额度徽标依赖 `sse`**：pi-ai 默认的 `auto` 会走 WebSocket，而 `x-codex-*` 额度响应头只存在于 SSE 响应上，走 WS 时徽标永远是「暂无数据」。想要 WebSocket 就设成 `auto`，代价是没有 Codex 额度数据。 |
+
+## 订阅用量徽标
+
+两家 provider 都在响应头里返回额度状态，插件顺带读取即可 —— 不轮询、不额外调接口。输入框工具条上
+（上下文圆环旁边）会出现一个徽标，点开看明细。
+
+| Provider | 读取的响应头 | 展示内容 |
+| --- | --- | --- |
+| `openai-codex` | `x-codex-primary-*`、`x-codex-secondary-*`、`x-codex-plan-type`、`x-codex-credits-balance` | 套餐、各窗口已用百分比、重置倒计时、点数余额 |
+| `anthropic` | `anthropic-ratelimit-unified-{5h,7d}-{utilization,reset,status}` | 5 小时与 7 天窗口的已用百分比、重置倒计时 |
+
+低于 60% 显示绿色，低于 85% 琥珀色，更高显示红色。数值来自**最近一次真实请求**，所以刚启动时会显示
+「暂无数据」，发一条消息即可。浏览器端每 15 秒轮询 `GET /llm-local-token/usage`，该路由只读内存快照。
+
+徽标**只显示当前选中模型所属 provider** 的用量：选 Codex 就是 Codex 的窗口，切到 Claude 就换成
+Claude 的，不会把两家的数字混在一起。选中的模型由别的 adapter 提供（普通 API key、其他插件）时徽标
+直接隐藏 —— 那份额度不属于本插件。展开的弹层仍列出所有路由，当前那条排在最前并标注「当前」，其余淡显。
+当前选中项来自 `ctx.modelDirectories`；组合里没有该服务时（非 Web）退回旧的「全部路由合并」显示。
+
+## 环境要求
+
+- Node.js **22.13+**（DSH 本身的底线，`--use-system-ca` 也需要）
+- profile 里有 `dsh-base`（它已自带 `dsh-llm-pi-ai` 与 `@earendil-works/pi-ai`）
+- 已登录的 CLI：Codex 路由需 `codex login`；Anthropic 路由需用过 Claude Code
+- Claude 的 Keychain 读取仅限 macOS；其它系统只查文件
+
+## token 处理
+
+- 每次请求实时读取，不在内存中长期保留
+- 剩余有效期不足 5 分钟时自动刷新，并**写回 CLI 读取的同一文件**，因此不会破坏 CLI 的登录态
+  （单飞机制：并发请求只触发一次刷新）
+- 原子写入，权限 `0600`
+- 不打日志、不上传，只发往对应的 provider 端点
+
+## 故障排查
+
+### `UNABLE_TO_GET_ISSUER_CERT_LOCALLY`
+
+说明你的流量经过 TLS 解密代理（Zscaler、Netskope 等企业 MITM）。即使系统信任其根证书，Node 也不
+信任。启动 DSH 时二选一：
+
+```bash
+node --use-system-ca …                          # 信任系统证书库（Node 22.13+）
+NODE_EXTRA_CA_CERTS=/path/to/root-ca.pem dsh …  # 或直接指向代理根证书
+```
+
+### `Provider is not configured: openai-codex`
+
+pi-ai 拒绝了 apiKey 覆盖。本插件已为 OAuth-only 的 Codex provider 附加了 api-key 认证方法；若仍
+报此错，说明 pi-ai 的 `resolveProviderAuth` 行为有变——请附上 `@earendil-works/pi-ai` 版本反馈。
+
+### 模型列表里看不到 Codex / Claude
+
+看启动日志里的 `llm-local-token: registered …`。如果只列出 `openai-codex`，说明没找到 Claude
+凭据（这台机器没用过 Claude Code 时属正常）。
+
+## 注意事项
+
+- 消耗的是你**个人订阅额度**（ChatGPT Plus/Pro、Claude Pro/Max），请遵守服务条款，不要用它把一个
+  账号共享给整个团队。
+- `chatgpt.com/backend-api` 是 Codex 客户端自用端点，不是公开 API，可能随时变化；需要稳定性就锁
+  定 pi-ai 版本。
+
+## 许可
+
+MIT

package/cordis.patch.yml

@@ -0,0 +1,16 @@
+# The dsh-llm-local-token bundle patch.
+#
+# DSH resolves this file through the `dsh.bundle.patch` manifest field in
+# package.json, never through code. Declaring it makes this package a profile
+# bundle, so `dsh plugin add dsh-llm-local-token` is enough to enable the
+# plugin: the row below is inserted for you and no hand-editing of the
+# profile's own cordis.patch.yml is required.
+#
+# The row carries no `config`, so every option keeps the default documented in
+# the README. A patch replaces a row's whole `config` rather than merging into
+# it, so your profile's cordis.patch.yml can restate this id to configure the
+# plugin, and that later layer wins.
+
+- insert:
+    - id: llm-local-token
+      name: dsh-llm-local-token

package/lib/claude-keychain.js

@@ -0,0 +1,93 @@
+import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { homedir, userInfo } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+/** The Keychain path exists on macOS only; other platforms use the file store. */
+const HAS_KEYCHAIN = process.platform === "darwin";
+const SERVICE = "Claude Code-credentials";
+const TOKEN_URL = "https://platform.claude.com/v1/oauth/token";
+const CLIENT_ID = Buffer.from("OWQxYzI1MGEtZTYxYi00NGQ5LTg4ZWQtNTk0NGQxOTYyZjVl", "base64").toString("utf8");
+const REFRESH_SKEW_MS = 5 * 60 * 1000;
+
+export const defaultClaudeAuthPath = () => join(homedir(), ".claude", ".credentials.json");
+
+function parseSecurityPassword(stdout, stderr) {
+  const combined = [stdout, stderr].filter(Boolean).join("\n");
+  const line = combined.split("\n").find((entry) => entry.startsWith("password: "));
+  if (!line) throw new Error("security output did not contain a password line");
+  let raw = line.slice("password: ".length);
+  if (raw.startsWith('"') && raw.endsWith('"')) raw = raw.slice(1, -1);
+  return raw;
+}
+
+async function readKeychainJson(service = SERVICE) {
+  const { stdout, stderr } = await execFileAsync("security", ["find-generic-password", "-s", service, "-g"], { maxBuffer: 1024 * 1024 });
+  return JSON.parse(parseSecurityPassword(stdout, stderr));
+}
+
+async function writeKeychainJson(data, service = SERVICE, account = userInfo().username) {
+  await execFileAsync("security", ["add-generic-password", "-U", "-a", account, "-s", service, "-w", JSON.stringify(data)], { maxBuffer: 1024 * 1024 });
+}
+
+async function refreshClaudeKeychainToken(data, options = {}) {
+  const current = data?.claudeAiOauth;
+  const refreshToken = current?.refreshToken;
+  if (!refreshToken) throw new Error("Claude Keychain entry has no claudeAiOauth.refreshToken");
+  const response = await fetch(TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ grant_type: "refresh_token", client_id: CLIENT_ID, refresh_token: refreshToken }),
+  });
+  const text = await response.text();
+  if (!response.ok) throw new Error(`Claude token refresh failed (${response.status}): ${text.slice(0, 300)}`);
+  const json = JSON.parse(text);
+  const next = {
+    ...data,
+    claudeAiOauth: {
+      ...current,
+      accessToken: json.access_token,
+      refreshToken: json.refresh_token ?? current.refreshToken,
+      expiresAt: Date.now() + (json.expires_in ?? 3600) * 1000 - REFRESH_SKEW_MS,
+    },
+  };
+  await writeKeychainJson(next, options.service, options.account);
+  return next.claudeAiOauth.accessToken;
+}
+
+async function readLegacyClaudeCredentialsFile(path) {
+  const raw = await readFile(path, "utf8");
+  const creds = JSON.parse(raw);
+  const first = creds?.tokens?.[0];
+  const token = first?.accessToken ?? first?.authToken ?? creds?.accessToken;
+  return typeof token === "string" && token.length > 0 ? token : undefined;
+}
+
+export async function resolveClaudeAccessToken(options = {}) {
+  // Old Claude Code builds wrote ~/.claude/.credentials.json. Prefer it when present.
+  const filePath = options.filePath ?? defaultClaudeAuthPath();
+  try {
+    const token = await readLegacyClaudeCredentialsFile(filePath);
+    if (token) return token;
+  } catch (error) {
+    if (error?.code !== "ENOENT") throw error;
+  }
+
+  // New Claude Code builds store the account OAuth payload in macOS Keychain.
+  // Elsewhere the file above is the only store, so say so plainly rather than
+  // shelling out to a tool that does not exist.
+  if (!HAS_KEYCHAIN) {
+    throw new Error(`llm-local-token: no Claude credentials at ${filePath} (Keychain lookup is macOS-only on ${process.platform})`);
+  }
+  const service = options.service ?? SERVICE;
+  const data = await readKeychainJson(service);
+  const oauth = data?.claudeAiOauth;
+  const token = oauth?.accessToken;
+  if (typeof token !== "string" || token.length === 0) throw new Error(`Claude Keychain service "${service}" has no claudeAiOauth.accessToken`);
+  if (typeof oauth.expiresAt === "number" && oauth.expiresAt - Date.now() <= REFRESH_SKEW_MS) {
+    return refreshClaudeKeychainToken(data, { service, account: options.account });
+  }
+  return token;
+}

package/lib/client.js

@@ -0,0 +1,347 @@
+window.__ModuleLoader__.load({
+	id: "dsh-llm-local-token",
+	factory: (require) => {
+		var module = { exports: {} };
+		var exports = module.exports;
+		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+		const jsxRuntime = require("react/jsx-runtime");
+		const react = require("react");
+		const runtime = require("@deepseek-ai/dsh-client-runtime/client");
+		const jsx = jsxRuntime.jsx;
+		const jsxs = jsxRuntime.jsxs;
+
+		const NS = "llm.localToken";
+		const ROUTE = "/llm-local-token/usage";
+		/** Poll cadence while the composer is mounted. Usage only moves on requests. */
+		const POLL_MS = 15000;
+
+		const CSS = ".ltk_wrap{position:relative;display:inline-flex}" +
+			".ltk_btn{display:inline-flex;align-items:center;gap:5px;height:24px;padding:0 8px;font:inherit;font-size:11px;font-variant-numeric:tabular-nums;border-radius:999px;border:1px solid var(--dsw-alias-border-l2);background:transparent;color:var(--dsw-alias-label-secondary);cursor:pointer}" +
+			".ltk_btn:hover{color:var(--dsw-alias-label-primary);background:var(--dsw-alias-bg-layer-3)}" +
+			".ltk_dot{width:6px;height:6px;border-radius:50%;flex:none}" +
+			".ltk_pop{position:fixed;z-index:220;width:280px;max-width:calc(100vw - 32px);padding:12px;border:1px solid var(--dsw-alias-border-l2);border-radius:12px;background:var(--dsw-specific-menu,var(--dsw-alias-bg-layer-2));box-shadow:0 12px 32px rgba(0,0,0,.28)}" +
+			".ltk_title{margin:0 0 8px;font-size:12px;font-weight:600;color:var(--dsw-alias-label-primary)}" +
+			".ltk_prov{padding-top:8px;margin-top:8px;border-top:1px solid var(--dsw-alias-border-l2)}" +
+			".ltk_prov:first-of-type{padding-top:0;margin-top:0;border-top:none}" +
+			".ltk_provDim{opacity:.5}" +
+			".ltk_cur{padding:0 6px;border-radius:999px;font-size:10px;line-height:16px;background:var(--dsw-alias-button-contrast-fill,var(--dsw-alias-bg-module-platform));color:var(--dsw-alias-label-primary-inverted)}" +
+			".ltk_provHead{display:flex;align-items:center;gap:6px;margin-bottom:6px}" +
+			".ltk_provName{flex:1;font-size:12px;font-weight:600;color:var(--dsw-alias-label-primary)}" +
+			".ltk_plan{padding:0 6px;border-radius:999px;font-size:10px;line-height:16px;background:var(--dsw-alias-bg-module-platform);color:var(--dsw-alias-label-secondary)}" +
+			".ltk_row{margin-top:6px}" +
+			".ltk_rowTop{display:flex;align-items:baseline;gap:6px;font-size:11px;color:var(--dsw-alias-label-tertiary)}" +
+			".ltk_rowLabel{flex:1}" +
+			".ltk_pct{font-variant-numeric:tabular-nums;font-weight:600;color:var(--dsw-alias-label-primary)}" +
+			".ltk_bar{height:4px;margin-top:3px;border-radius:999px;background:var(--dsw-alias-bg-module-platform);overflow:hidden}" +
+			".ltk_fill{height:100%;border-radius:999px}" +
+			".ltk_hint{margin:8px 0 0;font-size:11px;color:var(--dsw-alias-label-tertiary);line-height:1.5}";
+
+		if (typeof document !== "undefined" && document.querySelector('style[data-plugin-css="dsh-llm-local-token"]') === null) {
+			const tag = document.createElement("style");
+			tag.dataset.plugin = "dsh-llm-local-token";
+			tag.dataset.pluginCss = "dsh-llm-local-token";
+			tag.textContent = CSS;
+			document.head.appendChild(tag);
+		}
+
+		const en = {
+			label: "Quota", title: "Subscription usage",
+			"window.primary": "Primary", "window.secondary": "Secondary",
+			"window.5h": "5 hours", "window.7d": "7 days",
+			empty: "No data yet — send one message to read your quota.",
+			resets: "resets {when}", credits: "credits: {balance}",
+			current: "current",
+			"unit.d": "{n} days", "unit.h": "{n} hours", "unit.m": "{n} min",
+		};
+		const zh = {
+			label: "额度", title: "订阅用量",
+			"window.primary": "主窗口", "window.secondary": "次窗口",
+			"window.5h": "5 小时", "window.7d": "7 天",
+			empty: "暂无数据 —— 发一条消息即可读取额度。",
+			resets: "{when}重置", credits: "点数余额：{balance}",
+			current: "当前",
+			"unit.d": "{n} 天", "unit.h": "{n} 小时", "unit.m": "{n} 分钟",
+		};
+
+		/** Green under 60%, amber under 85%, red above. */
+		function tone(used) {
+			if (used >= 0.85) return "hsl(4 72% 55%)";
+			if (used >= 0.6) return "hsl(38 85% 52%)";
+			return "hsl(150 55% 45%)";
+		}
+
+		/**
+		 * Name one window by its length, so "10080 minutes" reads as "7 天".
+		 *
+		 * The duration is the fact a reader acts on and the only one comparable
+		 * across providers; Codex's `primary`/`secondary` is opaque vendor
+		 * vocabulary that hides a length the response already stated. So the
+		 * provider's own label survives only as the fallback for a window that
+		 * reports no length at all.
+		 */
+		function windowLabel(t, entry) {
+			const minutes = entry.windowMinutes ?? 0;
+			if (minutes >= 1440) return t("unit.d", { n: String(Math.round(minutes / 1440)) });
+			if (minutes >= 60) return t("unit.h", { n: String(Math.round(minutes / 60)) });
+			if (minutes > 0) return t("unit.m", { n: String(minutes) });
+			const known = t("window." + entry.label);
+			return known === "window." + entry.label ? entry.label : known;
+		}
+
+		/** Compact relative time for a reset instant. */
+		function resetIn(iso) {
+			const at = Date.parse(iso ?? "");
+			if (!Number.isFinite(at)) return "";
+			const seconds = Math.max(0, Math.round((at - Date.now()) / 1000));
+			if (seconds < 3600) return String(Math.round(seconds / 60)) + "m";
+			if (seconds < 86400) return String(Math.round(seconds / 3600)) + "h";
+			return String(Math.round(seconds / 86400)) + "d";
+		}
+
+		function UsageRow({ t, entry }) {
+			const percent = Math.round(entry.used * 100);
+			return jsxs("div", {
+				className: "ltk_row",
+				children: [
+					jsxs("div", {
+						className: "ltk_rowTop",
+						children: [
+							jsx("span", { className: "ltk_rowLabel", children: windowLabel(t, entry) }),
+							jsx("span", { className: "ltk_pct", children: percent + "%" }),
+							entry.resetAt === undefined ? null : jsx("span", { children: t("resets", { when: resetIn(entry.resetAt) }) }),
+						],
+					}),
+					jsx("div", {
+						className: "ltk_bar",
+						children: jsx("div", { className: "ltk_fill", style: { width: Math.max(2, percent) + "%", background: tone(entry.used) } }),
+					}),
+				],
+			});
+		}
+
+		/** The quota badge that sits beside the composer's context ring. */
+		function UsageBadge(props) {
+			const { t } = props;
+			const state = props.useLocalTokenUsage((snapshot) => snapshot);
+			// The provider of the model this session will actually use. The hook only
+			// exists when the host composed model selection (Web); its presence is
+			// fixed at registration time, so this call order never changes at runtime.
+			const activeProvider = typeof props.useModelSelection === "function"
+				? props.useModelSelection((snapshot) => snapshot.current?.provider ?? null)
+				: null;
+			const wrapRef = react.useRef(null);
+			const [pos, setPos] = react.useState(null);
+			react.useEffect(() => {
+				props.start();
+				props.ensureSelection();
+				return () => props.stop();
+			}, []);
+			react.useEffect(() => {
+				if (!state.open) return undefined;
+				const measure = () => {
+					const rect = wrapRef.current?.getBoundingClientRect();
+					if (rect === undefined) return;
+					const margin = 16;
+					const width = Math.min(280, window.innerWidth - margin * 2);
+					setPos({
+						left: Math.max(margin, Math.min(Math.round(rect.left), window.innerWidth - width - margin)),
+						top: Math.max(margin, Math.round(rect.top) - 12),
+						width,
+						transform: "translateY(-100%)",
+					});
+				};
+				measure();
+				const closeOutside = (event) => {
+					if (event.target instanceof Node && wrapRef.current?.contains(event.target) !== true) props.toggle();
+				};
+				const closeOnEscape = (event) => { if (event.key === "Escape") props.toggle(); };
+				window.addEventListener("resize", measure);
+				window.addEventListener("scroll", measure, true);
+				document.addEventListener("pointerdown", closeOutside);
+				document.addEventListener("keydown", closeOnEscape);
+				return () => {
+					window.removeEventListener("resize", measure);
+					window.removeEventListener("scroll", measure, true);
+					document.removeEventListener("pointerdown", closeOutside);
+					document.removeEventListener("keydown", closeOnEscape);
+				};
+			}, [state.open]);
+
+			const withData = state.providers.filter((entry) => entry.usage !== null);
+			/** The route serving the selected model, when this plugin owns it. */
+			const active = activeProvider === null
+				? undefined
+				: state.providers.find((entry) => entry.provider === activeProvider);
+			/**
+			 * The selected model belongs to some other adapter (a plain API key, a
+			 * different plugin): this badge owns no quota fact about it, so it says
+			 * nothing rather than showing a number from an unrelated subscription.
+			 * Before the first poll the route list is empty, which is "not known yet".
+			 */
+			const foreign = activeProvider !== null && state.providers.length > 0 && active === undefined;
+			// Selection unknown (no model-selection service): fall back to every route.
+			const windows = active !== undefined
+				? (active.usage === null ? [] : active.usage.windows)
+				: withData.flatMap((entry) => entry.usage.windows);
+			const headline = windows.map((w) => Math.round(w.used * 100)).slice(0, 2);
+			const worst = windows.reduce((max, w) => Math.max(max, w.used), 0);
+			// Active route first; the others stay visible but recede.
+			const ordered = active === undefined
+				? state.providers
+				: [active, ...state.providers.filter((entry) => entry !== active)];
+
+			// No local-token route at all (also the render before the first poll
+			// answers): the badge has nothing to say, so it does not exist.
+			if (state.providers.length === 0 || foreign) return null;
+
+			return jsxs("span", {
+				ref: wrapRef,
+				className: "ltk_wrap",
+				children: [
+					jsxs("button", {
+						type: "button",
+						className: "ltk_btn",
+						title: state.diag === undefined
+							? t("title")
+							: t("title") + " — pid " + state.diag.pid + ", observed " + state.diag.observed,
+						onClick: () => props.toggle(),
+						children: [
+							jsx("span", { className: "ltk_dot", style: { background: windows.length === 0 ? "var(--dsw-alias-label-tertiary)" : tone(worst) } }),
+							jsx("span", { children: headline.length === 0 ? t("label") : headline.map((p) => p + "%").join(" · ") }),
+						],
+					}),
+					!state.open ? null : jsxs("div", {
+						className: "ltk_pop",
+						style: pos === null ? { left: "16px", bottom: "72px" } : { left: pos.left + "px", top: pos.top + "px", width: pos.width + "px", transform: pos.transform },
+						children: [
+							jsx("p", { className: "ltk_title", children: t("title") }),
+							...ordered.map((entry) => jsxs("div", {
+								className: activeProvider !== null && entry.provider !== activeProvider ? "ltk_prov ltk_provDim" : "ltk_prov",
+								children: [
+									jsxs("div", {
+										className: "ltk_provHead",
+										children: [
+											jsx("span", { className: "ltk_provName", children: entry.displayName }),
+											entry.provider !== activeProvider ? null : jsx("span", { className: "ltk_cur", children: t("current") }),
+											entry.usage?.plan === undefined ? null : jsx("span", { className: "ltk_plan", children: entry.usage.plan }),
+										],
+									}),
+									entry.usage === null
+										? jsx("p", { className: "ltk_hint", children: t("empty") })
+										: jsxs("div", {
+											children: [
+												...entry.usage.windows.map((w) => jsx(UsageRow, { t, entry: w }, w.label)),
+												entry.usage.credits === undefined || entry.usage.creditsUnlimited === true
+													? null
+													: jsx("p", { className: "ltk_hint", children: t("credits", { balance: String(entry.usage.credits) }) }),
+											],
+										}),
+								],
+							}, entry.provider)),
+						],
+					}),
+				],
+			});
+		}
+
+		/** Polls the host route; the snapshot only changes when a request happened. */
+		class UsageController {
+			/** @param directories - `ctx.modelDirectories`, or undefined off Web. */
+			constructor(directories) {
+				this.directories = directories;
+				this.state = { open: false, providers: [], diag: undefined };
+				this.store = runtime.createSnapshotStore({ ...this.state });
+				this.timer = undefined;
+				this.started = false;
+			}
+
+			publish(patch) {
+				this.state = { ...this.state, ...patch };
+				this.store.set({ ...this.state });
+			}
+
+			async poll() {
+				try {
+					const response = await fetch(ROUTE, { headers: { Accept: "application/json" } });
+					if (!response.ok) return;
+					const body = await response.json();
+					this.publish({ providers: body.providers ?? [], diag: body.diag });
+				} catch (_failure) {
+					// Route absent (plugin not loaded on this host): stay silent.
+				}
+			}
+
+			/**
+			 * The session's shared model-selection store, or undefined when the host
+			 * composed no model selection or does not know this session. Both cases
+			 * degrade to the every-route view rather than failing the registration.
+			 */
+			directoryFor(sessionId) {
+				if (this.directories === undefined || sessionId === undefined) return undefined;
+				try {
+					return this.directories.directoryFor(sessionId);
+				} catch (_unknownSession) {
+					return undefined;
+				}
+			}
+
+			inject(sessionId) {
+				const directory = this.directoryFor(sessionId);
+				return {
+					hooks: directory === undefined
+						? { localTokenUsage: this.store }
+						: { localTokenUsage: this.store, modelSelection: directory.store },
+					/**
+					 * `current` is null until something loads the directory. The composer
+					 * model seat normally does, but ask once so a fresh session shows the
+					 * right route instead of the union view.
+					 */
+					ensureSelection: () => {
+						if (directory === undefined) return;
+						if (directory.store.getSnapshot().current !== null) return;
+						directory.load().catch(() => {});
+					},
+					start: () => {
+						if (this.started) return;
+						this.started = true;
+						this.poll();
+						this.timer = setInterval(() => this.poll(), POLL_MS);
+					},
+					stop: () => {
+						if (this.timer !== undefined) clearInterval(this.timer);
+						this.timer = undefined;
+						this.started = false;
+					},
+					toggle: () => {
+						const open = !this.state.open;
+						this.publish({ open });
+						if (open) this.poll();
+					},
+				};
+			}
+		}
+
+		const inject = ["slots", "locale"];
+
+		function apply(ctx) {
+			ctx.effect(() => ctx.locale.register(NS, { zh, en }), "llm-local-token: dictionaries");
+			// Optional on purpose: read the service rather than declaring it in
+			// `inject`, so a composition without model selection still loads this
+			// plugin (the badge then reports every route, as it always did).
+			const controller = new UsageController(ctx.get("modelDirectories"));
+			// The quota badge is a clickable control, so it belongs in the input
+			// tool row (a list slot), beside the send button.
+			ctx.slots.inject("conversation.input.right", () => ctx.slots.register({
+				name: "conversation.input.right",
+				id: "local-token-usage",
+				order: 60,
+				locale: NS,
+				inject: (sessionId) => controller.inject(sessionId),
+			}, UsageBadge));
+		}
+
+		exports.apply = apply;
+		exports.inject = inject;
+		return module.exports;
+	}
+});

package/lib/index.js

@@ -0,0 +1,188 @@
+// DSH (DeepSeek Harness) plugin: serve LLM calls through the OAuth tokens
+// your local CLIs already hold, instead of a separately configured API key.
+//
+//   - openai-codex  -> reads ~/.codex/auth.json (ChatGPT/Codex OAuth), refreshes
+//                      the access token automatically, and streams against
+//                      https://chatgpt.com/backend-api via the pi-ai engine.
+//   - anthropic     -> reads Claude Code OAuth from ~/.claude/.credentials.json
+//                      (legacy) or macOS Keychain service Claude Code-credentials
+//                      (current), then streams against https://api.anthropic.com.
+//
+// Both providers appear in the model picker once this plugin is loaded.
+import { LlmError } from "@deepseek-ai/dsh-llm";
+import { PiAiAdapter } from "@deepseek-ai/dsh-llm-pi-ai";
+import { anthropicProvider } from "@earendil-works/pi-ai/providers/anthropic";
+import { openaiCodexProvider } from "@earendil-works/pi-ai/providers/openai-codex";
+import { defaultCodexAuthPath, resolveCodexAccessToken } from "./token-store.js";
+import { defaultClaudeAuthPath, resolveClaudeAccessToken } from "./claude-keychain.js";
+import { withUsageProbe } from "./usage.js";
+
+/** Plugin identity used by the cordis loader entry. */
+export const name = "llm-local-token";
+/** Register only after the llm service exists. */
+export const inject = ["llm"];
+/** Route prefix serving the quota snapshots to the browser. */
+const USAGE_PREFIX = "/llm-local-token";
+
+function sendJson(res, status, value) {
+  const body = JSON.stringify(value);
+  res.writeHead(status, {
+    "Content-Type": "application/json; charset=utf-8",
+    "Cache-Control": "no-store",
+    "Content-Length": Buffer.byteLength(body),
+  });
+  res.end(body);
+}
+
+/**
+ * Attach an api-key auth method to a provider that pi-ai ships as OAuth-only
+ * (the openai-codex provider). pi-ai's `resolveProviderAuth` honours an
+ * `apiKey` override only when `provider.auth.apiKey` exists; without it the
+ * request dies with "Provider is not configured". The harness resolves the
+ * local token itself and hands it over as the request's apiKey, so this method
+ * only needs to pass that key through to the wire.
+ */
+function withApiKeyAuth(provider, name) {
+  return {
+    ...provider,
+    auth: {
+      ...provider.auth,
+      apiKey: {
+        name,
+        resolve: async ({ credential }) => ({
+          auth: credential?.key === void 0 ? {} : { apiKey: credential.key },
+          source: name,
+        }),
+      },
+    },
+  };
+}
+
+/** Transport values pi-ai's profile vocabulary accepts. */
+const TRANSPORTS = ["sse", "websocket", "websocket-cached", "auto"];
+
+/**
+ * Build one adapter profile in the shape PiAiAdapter expects.
+ * @param transport - optional streaming transport preference; undefined leaves
+ * pi-ai's own default ("auto") in charge.
+ */
+function profileOf(provider, displayName, piProvider, transport) {
+  return {
+    provider,
+    displayName,
+    piProvider,
+    retryPolicy: undefined,
+    streamIdleTimeoutMs: 300_000,
+    configuredMaxTokens: new Map(),
+    ...(transport === undefined ? {} : { transport }),
+  };
+}
+
+/**
+ * Plugin entry. Builds the local-token routes, registers one pi-ai adapter
+ * serving them, and exposes the providers to the model picker.
+ */
+export async function apply(ctx, config = {}) {
+  const routes = [];
+  /** Latest quota snapshot per provider id, replaced on every observed response. */
+  const usage = new Map();
+  /**
+   * Diagnostics for "the badge shows no numbers": which process/apply owns this
+   * route, how many responses the probe observed, and when the last one landed.
+   * Cheap to keep and the only way to tell a stale host from a broken probe.
+   */
+  const diag = { pid: process.pid, appliedAt: new Date().toISOString(), observed: 0, lastAt: null, lastProvider: null };
+  const record = (snapshot) => {
+    usage.set(snapshot.provider, snapshot);
+    diag.observed += 1;
+    diag.lastAt = snapshot.at;
+    diag.lastProvider = snapshot.provider;
+  };
+
+  // ── Codex route: local ~/.codex/auth.json (ChatGPT OAuth) ────────────────
+  //
+  // Transport matters for the quota badge. Under pi-ai's default "auto" the
+  // Codex provider streams over WebSocket, and the `x-codex-*` quota headers
+  // exist only on the SSE response — so the usage probe observes nothing and the
+  // badge stays empty forever. "sse" keeps it as fresh as the Claude route; set
+  // `codexTransport: "auto"` to prefer WebSocket and accept no quota data.
+  const codexAuthPath = config.codexAuthPath ?? defaultCodexAuthPath();
+  const requestedTransport = config.codexTransport ?? "sse";
+  const codexTransport = TRANSPORTS.includes(requestedTransport) ? requestedTransport : "sse";
+  if (codexTransport !== requestedTransport) {
+    ctx.logger.info(`llm-local-token: ignoring unknown codexTransport "${requestedTransport}"; using "sse"`);
+  }
+  routes.push({
+    provider: "openai-codex",
+    displayName: "OpenAI Codex (local token)",
+    piProvider: withUsageProbe(withApiKeyAuth(openaiCodexProvider(), "Codex local token"), record),
+    resolveApiKey: async () => resolveCodexAccessToken(codexAuthPath),
+    transport: codexTransport,
+  });
+
+  // ── Claude route: local Claude Code credentials (legacy file or Keychain) ─
+  const claudeAuthPath = config.claudeAuthPath ?? defaultClaudeAuthPath();
+  const claudeKeychainService = config.claudeKeychainService ?? "Claude Code-credentials";
+  try {
+    // Resolve once at startup to decide whether to register the route. Requests
+    // resolve again so token refreshes/Keychain updates are observed.
+    await resolveClaudeAccessToken({ filePath: claudeAuthPath, service: claudeKeychainService, account: config.claudeKeychainAccount });
+    routes.push({
+      provider: "anthropic",
+      displayName: "Claude (local token)",
+      piProvider: withUsageProbe(anthropicProvider(), record),
+      resolveApiKey: async () => resolveClaudeAccessToken({ filePath: claudeAuthPath, service: claudeKeychainService, account: config.claudeKeychainAccount }),
+    });
+  } catch (error) {
+    if (config.requireClaude === true) throw error;
+    ctx.logger.info(`llm-local-token: Claude local token not usable (${String(error?.message ?? error).slice(0, 160)}); skipping Claude provider`);
+  }
+
+  const profiles = () => new Map(routes.map((route) => [
+    route.provider,
+    profileOf(route.provider, route.displayName, route.piProvider, route.transport),
+  ]));
+
+  const adapter = new PiAiAdapter({
+    profiles,
+    resolveApiKey: async (provider) => {
+      const route = routes.find((entry) => entry.provider === provider);
+      if (route === void 0) {
+        throw new LlmError(`llm-local-token does not own provider "${provider}"`, "NO_ADAPTER");
+      }
+      try {
+        return await route.resolveApiKey();
+      } catch (error) {
+        throw new LlmError(error?.message ?? String(error), "MISSING_CREDENTIAL", { cause: error });
+      }
+    },
+    resolveAttachments: () => ctx.get("attachments"),
+  });
+
+  ctx.llm.registerAdapter(routes.map((route) => route.provider), adapter);
+
+  // Quota snapshots observed on real responses, newest per provider.
+  ctx.inject(["webServer"], (wctx) => {
+    wctx.effect(() => wctx.webServer.register({
+      kind: "prefix",
+      path: USAGE_PREFIX,
+      handler: (req, res) => {
+        const path = new URL(req.url ?? "/", "http://localhost").pathname.slice(USAGE_PREFIX.length).replace(/^\/+/, "");
+        if (req.method !== "GET" || (path !== "usage" && path !== "")) {
+          return sendJson(res, 404, { error: `unknown route "${path}"` });
+        }
+        return sendJson(res, 200, {
+          providers: routes.map((route) => ({
+            provider: route.provider,
+            displayName: route.displayName,
+            usage: usage.get(route.provider) ?? null,
+          })),
+          diag,
+          fetchedAt: new Date().toISOString(),
+        });
+      },
+    }), "llm-local-token: usage route");
+    wctx.logger.info(`llm-local-token: usage route mounted at ${USAGE_PREFIX}/usage`);
+  });
+  ctx.logger.info(`llm-local-token: registered ${routes.map((route) => route.provider).join(", ")} (codex auth: ${codexAuthPath}, codex transport: ${codexTransport})`);
+}

package/lib/token-store.js

@@ -0,0 +1,127 @@
+// Codex / ChatGPT OAuth token store backed by the Codex CLI's local
+// credential file (~/.codex/auth.json). The same file the `codex` CLI
+// maintains, so a token refreshed here stays valid for the CLI and vice versa.
+import { readFile, rename, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+/** The public Codex OAuth client id (matches the pi-ai engine and the CLI). */
+const CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+const TOKEN_URL = "https://auth.openai.com/oauth/token";
+/** Refresh when the access token has less than this much life left. */
+const REFRESH_SKEW_MS = 5 * 60 * 1000;
+/** In-flight refresh promise, shared by concurrent callers. */
+let refreshing = null;
+
+/** Resolve the Codex credential file path honouring $CODEX_HOME. */
+export function defaultCodexAuthPath() {
+  return process.env.CODEX_HOME
+    ? join(process.env.CODEX_HOME, "auth.json")
+    : join(homedir(), ".codex", "auth.json");
+}
+
+/** Decode a JWT's `exp` claim in milliseconds, or undefined. */
+function jwtExpMs(token) {
+  try {
+    const payload = JSON.parse(Buffer.from(token.split(".")[1], "base64url").toString("utf8"));
+    return typeof payload.exp === "number" ? payload.exp * 1000 : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function isFresh(token) {
+  const exp = jwtExpMs(token);
+  return exp === undefined || exp - Date.now() > REFRESH_SKEW_MS;
+}
+
+/**
+ * Read the current Codex auth document.
+ * @param path - credential file path.
+ * @returns the parsed JSON document.
+ */
+export async function readCodexAuth(path = defaultCodexAuthPath()) {
+  const raw = await readFile(path, "utf8");
+  return JSON.parse(raw);
+}
+
+/**
+ * Atomically persist a refreshed auth document, preserving the original
+ * file's permission bits where possible (the file holds secrets).
+ */
+async function writeCodexAuth(path, next) {
+  const tmp = `${path}.dsh-${process.pid}-${Date.now()}.tmp`;
+  await writeFile(tmp, JSON.stringify(next, null, 2) + "\n", { mode: 0o600 });
+  try {
+    await rename(tmp, path);
+  } catch (error) {
+    try {
+      await import("node:fs/promises").then(({ unlink }) => unlink(tmp));
+    } catch {}
+    throw error;
+  }
+}
+
+/**
+ * Refresh the ChatGPT OAuth token pair and persist it back to the Codex
+ * credential file. Refreshing shares one in-flight promise so concurrent LLM
+ * requests trigger a single refresh.
+ * @param path - credential file path.
+ * @returns the fresh access token.
+ */
+export async function refreshCodexToken(path = defaultCodexAuthPath()) {
+  if (refreshing) return refreshing;
+  refreshing = (async () => {
+    const data = await readCodexAuth(path);
+    const refreshToken = data?.tokens?.refresh_token;
+    if (!refreshToken) {
+      throw new Error(`local-token: no tokens.refresh_token in ${path} — re-login with the Codex CLI (` + 'codex login' + `)`);
+    }
+    const response = await fetch(TOKEN_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({
+        grant_type: "refresh_token",
+        refresh_token: refreshToken,
+        client_id: CLIENT_ID,
+      }),
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      throw new Error(`local-token: token refresh failed (${response.status}) ${text.slice(0, 200)}`);
+    }
+    const json = await response.json();
+    const next = {
+      ...data,
+      tokens: {
+        id_token: json.id_token ?? data.tokens.id_token,
+        access_token: json.access_token,
+        refresh_token: json.refresh_token ?? data.tokens.refresh_token,
+        account_id: data.tokens.account_id,
+      },
+      last_refresh: new Date().toISOString(),
+    };
+    await writeCodexAuth(path, next);
+    return next.tokens.access_token;
+  })().finally(() => {
+    refreshing = null;
+  });
+  return refreshing;
+}
+
+/**
+ * Resolve the access token for an LLM request, refreshing when it is close to
+ * expiry. Throws when no credential exists so the caller reports a clear
+ * MISSING_CREDENTIAL-style failure instead of sending an unauthenticated call.
+ * @param path - credential file path.
+ * @returns the bearer access token.
+ */
+export async function resolveCodexAccessToken(path = defaultCodexAuthPath()) {
+  const data = await readCodexAuth(path);
+  const token = data?.tokens?.access_token;
+  if (!token) {
+    throw new Error(`local-token: no tokens.access_token in ${path} — run the Codex CLI (` + 'codex login' + `) to sign in first`);
+  }
+  if (isFresh(token)) return token;
+  return refreshCodexToken(path);
+}

package/lib/usage.js

@@ -0,0 +1,137 @@
+// Live quota snapshots, read from the rate-limit headers each provider already
+// returns. Nothing is polled: a snapshot is whatever the most recent real
+// request reported, which is also the only moment the numbers can change.
+
+/** Parse a numeric header, or undefined when absent/unparsable. */
+function num(headers, name) {
+  const raw = headers?.[name];
+  if (raw === undefined || raw === null || String(raw).trim().length === 0) return undefined;
+  const value = Number(raw);
+  return Number.isFinite(value) ? value : undefined;
+}
+
+function str(headers, name) {
+  const raw = headers?.[name];
+  return raw === undefined || raw === null ? undefined : String(raw).trim() || undefined;
+}
+
+/** Lower-case every header name so lookups do not depend on the transport. */
+export function normalizeHeaders(headers) {
+  const flat = {};
+  if (headers === undefined || headers === null) return flat;
+  const entries = typeof headers.entries === "function" ? [...headers.entries()] : Object.entries(headers);
+  for (const [key, value] of entries) flat[String(key).toLowerCase()] = Array.isArray(value) ? value.join(", ") : value;
+  return flat;
+}
+
+/**
+ * One usage window in the shape the panel renders: a 0..1 fraction, the window
+ * length, and when it resets.
+ */
+function window_(label, usedPercent, windowMinutes, resetAt, status) {
+  if (usedPercent === undefined) return undefined;
+  return {
+    label,
+    used: Math.max(0, Math.min(usedPercent / 100, 1)),
+    ...(windowMinutes === undefined ? {} : { windowMinutes }),
+    ...(resetAt === undefined ? {} : { resetAt: new Date(resetAt * 1000).toISOString() }),
+    ...(status === undefined ? {} : { status }),
+  };
+}
+
+/**
+ * Read the Codex/ChatGPT quota headers (`x-codex-*`).
+ * @param headers - normalized response headers.
+ * @returns the snapshot, or undefined when this response carried no quota data.
+ */
+export function codexUsage(headers) {
+  const primary = window_(
+    "primary",
+    num(headers, "x-codex-primary-used-percent"),
+    num(headers, "x-codex-primary-window-minutes"),
+    num(headers, "x-codex-primary-reset-at"),
+  );
+  const secondary = window_(
+    "secondary",
+    num(headers, "x-codex-secondary-used-percent"),
+    num(headers, "x-codex-secondary-window-minutes"),
+    num(headers, "x-codex-secondary-reset-at"),
+  );
+  if (primary === undefined && secondary === undefined) return undefined;
+  const credits = num(headers, "x-codex-credits-balance");
+  return {
+    provider: "openai-codex",
+    plan: str(headers, "x-codex-plan-type"),
+    activeLimit: str(headers, "x-codex-active-limit"),
+    windows: [primary, secondary].filter((entry) => entry !== undefined && (entry.windowMinutes ?? 0) > 0),
+    ...(credits === undefined ? {} : { credits, creditsUnlimited: str(headers, "x-codex-credits-unlimited") === "True" }),
+    at: new Date().toISOString(),
+  };
+}
+
+/**
+ * Read the Anthropic unified rate-limit headers (`anthropic-ratelimit-unified-*`).
+ * Utilization arrives as a 0..1 fraction there, unlike Codex's percent.
+ * @param headers - normalized response headers.
+ * @returns the snapshot, or undefined when this response carried no quota data.
+ */
+export function anthropicUsage(headers) {
+  const windows = [];
+  for (const [name, minutes] of [["5h", 300], ["7d", 10080]]) {
+    const used = num(headers, `anthropic-ratelimit-unified-${name}-utilization`);
+    if (used === undefined) continue;
+    windows.push({
+      label: name,
+      used: Math.max(0, Math.min(used, 1)),
+      windowMinutes: minutes,
+      ...(num(headers, `anthropic-ratelimit-unified-${name}-reset`) === undefined
+        ? {}
+        : { resetAt: new Date(num(headers, `anthropic-ratelimit-unified-${name}-reset`) * 1000).toISOString() }),
+      ...(str(headers, `anthropic-ratelimit-unified-${name}-status`) === undefined
+        ? {}
+        : { status: str(headers, `anthropic-ratelimit-unified-${name}-status`) }),
+    });
+  }
+  if (windows.length === 0) return undefined;
+  return {
+    provider: "anthropic",
+    ...(str(headers, "anthropic-ratelimit-unified-status") === undefined ? {} : { activeLimit: str(headers, "anthropic-ratelimit-unified-status") }),
+    windows,
+    at: new Date().toISOString(),
+  };
+}
+
+/** Provider id to header reader. */
+const READERS = { "openai-codex": codexUsage, anthropic: anthropicUsage };
+
+/**
+ * Wrap a pi-ai provider so every response's quota headers reach `record`.
+ *
+ * The engine calls `onResponse` with the raw status and headers before the
+ * stream is consumed, and a caller-supplied hook is preserved, so this is a
+ * pure observation: no request shape changes and no failure path is added.
+ * @param provider - the pi-ai provider to wrap.
+ * @param record - receives one parsed snapshot per response that carries quota headers.
+ * @returns the wrapped provider.
+ */
+export function withUsageProbe(provider, record) {
+  const read = READERS[provider.id];
+  if (read === undefined) return provider;
+  const observe = (options) => ({
+    ...options,
+    onResponse: async (response, model) => {
+      try {
+        const snapshot = read(normalizeHeaders(response?.headers));
+        if (snapshot !== undefined) record(snapshot);
+      } catch {
+        // Usage reporting must never break a model call.
+      }
+      return options?.onResponse?.(response, model);
+    },
+  });
+  return {
+    ...provider,
+    stream: (model, context, options) => provider.stream(model, context, observe(options)),
+    streamSimple: (model, context, options) => provider.streamSimple(model, context, observe(options)),
+  };
+}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "dsh-llm-local-token",
+  "version": "1.3.1",
+  "description": "DeepSeek Harness plugin: serve LLM calls with the OAuth tokens your local Codex CLI and Claude Code already hold, instead of a separately configured API key.",
+  "keywords": [
+    "deepseek-harness",
+    "dsh",
+    "dsh-plugin",
+    "cordis",
+    "llm",
+    "codex",
+    "claude",
+    "oauth"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./package.json": "./package.json",
+    "./client": "./lib/client.js",
+    "./cordis.patch.yml": "./cordis.patch.yml"
+  },
+  "files": [
+    "lib/",
+    "cordis.patch.yml",
+    "README.md",
+    "README.zh.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=22.13.0"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-llm": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-llm-pi-ai": "^0.1.0-rc.6",
+    "@deepseek-ai/schemastery": "^3.18.1",
+    "@earendil-works/pi-ai": "^0.82.1"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/cordis": {
+      "optional": true
+    },
+    "@deepseek-ai/schemastery": {
+      "optional": true
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tianxia--/dsh-llm-local-token.git"
+  },
+  "bugs": {
+    "url": "https://github.com/tianxia--/dsh-llm-local-token/issues"
+  },
+  "homepage": "https://github.com/tianxia--/dsh-llm-local-token#readme",
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "slots",
+        "locale"
+      ],
+      "platform": "web"
+    }
+  }
+}