im-agent 0.0.0-stage → 0.1.0

package/src/agents/codex/account.ts

@@ -0,0 +1,92 @@
+// 账号额度：Codex 的 5 小时 / 7 天用量窗口。
+//
+// 这块是补一个认知落差：Codex 自己的 TUI 里 `/status` 会显示剩余额度，
+// 而im-agent的 `/status` 是另一条命令（同名而已），本来只报会话和目录。
+// 用的人不会关心这个区别，他只知道「同样敲 /status，这边少了额度」。
+// 与其解释，不如把它显示出来 —— app-server 本来就给了。
+import { appServer } from "./app-server.js";
+
+type UsageWindow = {
+  usedPercent: number;
+  /** 窗口长度（分钟）。300 = 5 小时，10080 = 7 天 */
+  windowDurationMins: number;
+  /** 重置时刻，Unix 秒 */
+  resetsAt: number;
+};
+
+type RateLimits = {
+  planType?: string | null;
+  primary?: UsageWindow | null;
+  secondary?: UsageWindow | null;
+  credits?: { hasCredits?: boolean; unlimited?: boolean; balance?: string } | null;
+  /** 非空表示已经撞上限了 */
+  rateLimitReachedType?: string | null;
+};
+
+/**
+ * 额度是会变的，但 /status 也可能被连敲几次，缓存一小会儿。
+ * 60 秒足够挡住手抖，又不至于让人看到明显过期的数字。
+ */
+const CACHE_MS = 60_000;
+let cache: { at: number; value: RateLimits | null } | null = null;
+
+export async function readRateLimits(): Promise<RateLimits | null> {
+  if (cache && Date.now() - cache.at < CACHE_MS) return cache.value;
+  try {
+    const res = await appServer.call<{ rateLimits?: RateLimits }>(
+      "account/rateLimits/read",
+      {},
+    );
+    cache = { at: Date.now(), value: res.rateLimits ?? null };
+  } catch (err) {
+    // 读不到额度不该让整条 /status 失败 —— 它只是其中一行
+    console.error("[额度] 读取失败:", err instanceof Error ? err.message : err);
+    cache = { at: Date.now(), value: null };
+  }
+  return cache.value;
+}
+
+/** 300 → 「5 小时」，10080 → 「7 天」，45 → 「45 分钟」 */
+function windowName(mins: number): string {
+  if (mins % (60 * 24) === 0) return `${mins / (60 * 24)} 天`;
+  if (mins % 60 === 0) return `${mins / 60} 小时`;
+  return `${mins} 分钟`;
+}
+
+/** 距离重置还有多久。已经过了就说「即将重置」，不显示负数。 */
+function untilReset(resetsAt: number, now = Date.now()): string {
+  const seconds = resetsAt - Math.floor(now / 1000);
+  if (seconds <= 0) return "即将重置";
+  const days = Math.floor(seconds / 86400);
+  const hours = Math.floor((seconds % 86400) / 3600);
+  const minutes = Math.floor((seconds % 3600) / 60);
+  if (days > 0) return `${days} 天 ${hours} 小时后重置`;
+  if (hours > 0) return `${hours} 小时 ${minutes} 分后重置`;
+  return `${minutes} 分钟后重置`;
+}
+
+function line(label: string, w: UsageWindow): string {
+  return `  ${label}　已用 ${w.usedPercent}%　${untilReset(w.resetsAt)}`;
+}
+
+/**
+ * 渲染成 /status 里的几行。没有可显示的就返回空数组，让调用方自然略过
+ * —— 与其印一行「额度：未知」，不如什么都不印。
+ */
+export function describeRateLimits(limits: RateLimits | null): string[] {
+  if (!limits) return [];
+  const rows: string[] = [];
+  if (limits.primary) rows.push(line(windowName(limits.primary.windowDurationMins), limits.primary));
+  if (limits.secondary) {
+    rows.push(line(windowName(limits.secondary.windowDurationMins), limits.secondary));
+  }
+  if (rows.length === 0) return [];
+
+  const credits = limits.credits;
+  if (credits?.unlimited) rows.push("  额度包　无限");
+  else if (credits?.hasCredits && credits.balance) rows.push(`  额度包　余 ${credits.balance}`);
+
+  if (limits.rateLimitReachedType) rows.push("  ⚠️ 已达上限，等窗口重置后才能继续");
+
+  return [`额度${limits.planType ? `（${limits.planType}）` : ""}`, ...rows];
+}

package/src/agents/codex/app-server.ts

@@ -0,0 +1,346 @@
+// 与 `codex app-server` 的 JSON-RPC 连接：一个进程，多条 thread。
+//
+// 这是整个im-agent的地基。
+//
+// 为什么不用官方的 @openai/codex-sdk：它是 `codex exec --json` 的薄封装，
+// 事件流够用，但**没有任何审批回调** —— approvalPolicy 只是个启动参数，
+// 没有地方接住「Codex 想跑这条命令，准不准」。用它做出来的东西没有卡片授权。
+// app-server 才是 Codex 桌面版和 IDE 插件走的那条路：服务端能反过来向我们
+// 发起请求，审批和提问都从那儿来。
+//
+// 为什么一个进程带多条 thread：app-server 的每条消息都带 threadId，天然是
+// 多路复用的。给每条飞书会话各拉一个进程也能跑，但那样一个群开几个话题就是
+// 几个常驻进程；共用一个进程只需要自己按 threadId 分发，便宜得多。
+// 代价是单点故障，由下面的自动重连 + onRestart 兜住。
+import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
+import readline from "node:readline";
+import { config } from "../../core/config.js";
+import { agentEnvironment } from "../../core/agent-env.js";
+import type { Incoming, InitializeResult, RequestId } from "./protocol.js";
+import { UnsupportedRequest } from "./refusals.js";
+
+/** 服务端反过来向我们发起的请求。返回值会作为 result 回给它。 */
+export type ServerRequestHandler = (
+  method: string,
+  params: unknown,
+) => Promise<unknown>;
+
+export type NotificationHandler = (method: string, params: unknown) => void;
+
+/** 连接被重建时通知上层：挂着的 thread 需要重新 resume。 */
+export type RestartHandler = (reason: string) => void;
+
+const CLIENT_INFO = {
+  name: "im-agent",
+  title: "im-agent",
+  version: "0.1.0",
+};
+
+/** stderr 只留最后这么多行，用来给错误诊断当线索，不无限占内存。 */
+const STDERR_KEEP = 40;
+
+export class AppServer {
+  private child: ChildProcessWithoutNullStreams | null = null;
+  private nextId = 0;
+  private readonly pending = new Map<
+    RequestId,
+    { resolve: (value: unknown) => void; reject: (err: Error) => void }
+  >();
+  private readonly notificationHandlers = new Set<NotificationHandler>();
+  private readonly restartHandlers = new Set<RestartHandler>();
+  private serverRequestHandler: ServerRequestHandler | null = null;
+  private ready: Promise<InitializeResult> | null = null;
+  private recentStderr: string[] = [];
+  private stopping = false;
+  /** 连续拉起失败的次数，用来退避，避免 codex 装坏时疯狂重启刷屏。 */
+  private consecutiveFailures = 0;
+
+  onNotification(handler: NotificationHandler): () => void {
+    this.notificationHandlers.add(handler);
+    return () => this.notificationHandlers.delete(handler);
+  }
+
+  /** 进程一退出就通知（不等重连成功）：在途的轮次得立刻收尾，不能一直显示忙 */
+  private readonly exitHandlers = new Set<(reason: string) => void>();
+
+  onExit(handler: (reason: string) => void): () => void {
+    this.exitHandlers.add(handler);
+    return () => this.exitHandlers.delete(handler);
+  }
+
+  onRestart(handler: RestartHandler): () => void {
+    this.restartHandlers.add(handler);
+    return () => this.restartHandlers.delete(handler);
+  }
+
+  /** 只能有一个：审批和提问都从这儿进来，分发由上层按 threadId 做。 */
+  setServerRequestHandler(handler: ServerRequestHandler): void {
+    this.serverRequestHandler = handler;
+  }
+
+  /** 最近的 stderr，出错时拿去做诊断。 */
+  stderrTail(): string {
+    return this.recentStderr.join("\n");
+  }
+
+  /** 拉起并完成握手。重复调用返回同一个 promise。 */
+  start(): Promise<InitializeResult> {
+    this.ready ??= this.spawnAndInitialize().catch((err) => {
+      // 握手失败要把 promise 清掉，否则这个连接永远是坏的，重试也拿到同一个 rejected
+      this.ready = null;
+      throw err;
+    });
+    return this.ready;
+  }
+
+  private async spawnAndInitialize(): Promise<InitializeResult> {
+    const child = spawn(config().agents.codex.path, ["app-server"], {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: {
+        ...agentEnvironment(),
+        ...((config().agents.codex.home || undefined) ? { CODEX_HOME: (config().agents.codex.home || undefined) } : {}),
+      },
+    });
+    this.child = child;
+    this.recentStderr = [];
+
+    // 逐行读 JSONL。app-server 的一帧可能很大（整个 turn 的 items），
+    // readline 没有行长上限，够用。
+    readline.createInterface({ input: child.stdout }).on("line", (line) => {
+      this.handleLine(line);
+    });
+
+    readline.createInterface({ input: child.stderr }).on("line", (line) => {
+      this.recentStderr.push(line);
+      if (this.recentStderr.length > STDERR_KEEP) this.recentStderr.shift();
+      // codex 自己的 tracing 日志噪音很大，只把明显的错误抬到我们的日志里
+      if (/\bERROR\b|^Error:/.test(line)) console.error(`[codex] ${line}`);
+    });
+
+    child.on("exit", (code, signal) => this.handleExit(code, signal));
+    child.on("error", (err) => {
+      // spawn 本身失败（找不到 codex）：这条路径上 exit 不一定会来
+      this.failAllPending(new Error(`无法启动 ${config().agents.codex.path}: ${err.message}`));
+    });
+
+    const result = (await this.request("initialize", {
+      clientInfo: CLIENT_INFO,
+      capabilities: null,
+    })) as InitializeResult;
+
+    // 握手的第二拍。少了它，服务端会一直当我们还没准备好。
+    this.notify("initialized", {});
+    this.consecutiveFailures = 0;
+    return result;
+  }
+
+  private handleLine(line: string): void {
+    let frame: Incoming;
+    try {
+      frame = JSON.parse(line) as Incoming;
+    } catch {
+      // 不是 JSON 的行只可能是 codex 往 stdout 漏的东西，忽略但留个痕
+      console.warn(`[codex] stdout 收到非 JSON 行: ${line.slice(0, 200)}`);
+      return;
+    }
+
+    // 三种帧靠 id / method 的有无区分：
+    //   有 id 有 method → 服务端向我们发起的请求（审批、提问）
+    //   有 id 无 method → 对我们某个请求的响应
+    //   无 id 有 method → 通知
+    if (frame.id !== undefined && frame.method) {
+      void this.handleServerRequest(frame.id, frame.method, frame.params);
+      return;
+    }
+    if (frame.id !== undefined) {
+      const waiter = this.pending.get(frame.id);
+      if (!waiter) return;
+      this.pending.delete(frame.id);
+      if (frame.error) waiter.reject(new Error(frame.error.message));
+      else waiter.resolve(frame.result);
+      return;
+    }
+    if (frame.method) {
+      for (const handler of this.notificationHandlers) {
+        try {
+          handler(frame.method, frame.params);
+        } catch (err) {
+          console.error("[codex] 通知处理出错:", err);
+        }
+      }
+    }
+  }
+
+  /**
+   * 服务端请求必须**永远**回一帧。
+   *
+   * 漏回一次，Codex 那一轮就永远卡在等待上 —— 表现是聊天这边彻底没反应，而且
+   * 看不出哪儿坏了。所以无论如何都要应答。
+   *
+   * 但「随便回点什么」也不行：每种请求的响应结构不一样（审批要 `decision`，
+   * MCP 的 elicitation 要 `action`），回错结构等于没回。所以答不上来的时候走
+   * JSON-RPC 的 error 通道 —— 明确说不支持，好过编一个形状让对端去猜。
+   */
+  private async handleServerRequest(
+    id: RequestId,
+    method: string,
+    params: unknown,
+  ): Promise<void> {
+    if (!this.serverRequestHandler) {
+      console.warn(`[codex] 没有处理器，自动拒绝服务端请求 ${method}`);
+      this.sendError(id, -32601, `im-agent未就绪，无法处理 ${method}`);
+      return;
+    }
+    try {
+      const result = await this.serverRequestHandler(method, params);
+      this.send({ jsonrpc: "2.0", id, result });
+    } catch (err) {
+      const unsupported = err instanceof UnsupportedRequest;
+      if (!unsupported) {
+        console.error(`[codex] 处理服务端请求 ${method} 出错:`, err);
+      }
+      this.sendError(
+        id,
+        unsupported ? -32601 : -32603,
+        err instanceof Error ? err.message : String(err),
+      );
+    }
+  }
+
+  private sendError(id: RequestId, code: number, message: string): void {
+    try {
+      this.send({ jsonrpc: "2.0", id, error: { code, message } });
+    } catch (err) {
+      console.error("[codex] 连错误响应都发不出去:", err);
+    }
+  }
+
+  private handleExit(code: number | null, signal: NodeJS.Signals | null): void {
+    const why = `codex app-server 退出（code=${code ?? "null"} signal=${signal ?? "null"}）`;
+    this.child = null;
+    this.ready = null;
+    this.failAllPending(new Error(why));
+    for (const handler of this.exitHandlers) {
+      try {
+        handler(why);
+      } catch (err) {
+        console.error("[codex] 退出回调出错:", err);
+      }
+    }
+
+    if (this.stopping) return;
+
+    this.consecutiveFailures += 1;
+    // 退避到最多 30 秒：codex 装坏时（比如二进制缺失）无脑重启只会刷屏
+    const delay = Math.min(1000 * 2 ** (this.consecutiveFailures - 1), 30_000);
+    console.error(`[codex] ${why}，${delay / 1000}s 后重连`);
+    const timer = setTimeout(() => {
+      this.start()
+        .then(() => {
+          console.log("[codex] app-server 已重新拉起");
+          for (const handler of this.restartHandlers) handler(why);
+        })
+        .catch((err) => console.error("[codex] 重连失败:", err));
+    }, delay);
+    timer.unref?.();
+  }
+
+  private failAllPending(err: Error): void {
+    for (const waiter of this.pending.values()) waiter.reject(err);
+    this.pending.clear();
+  }
+
+  private send(frame: unknown): void {
+    const child = this.child;
+    if (!child?.stdin.writable) {
+      throw new Error("codex app-server 未运行");
+    }
+    child.stdin.write(`${JSON.stringify(frame)}\n`);
+  }
+
+  /**
+   * 发一个请求并等响应。
+   *
+   * 带超时：进程活着却不响应时，不能让调用方（以及排在它后面的整条会话操作队列）
+   * 永远等下去。turn/start 的响应只是「轮次已开始」，同样很快返回，不需要例外。
+   */
+  request(method: string, params?: unknown, timeoutMs = 60_000): Promise<unknown> {
+    const id = ++this.nextId;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        if (!this.pending.delete(id)) return;
+        reject(new Error(`codex app-server 在 ${timeoutMs / 1000} 秒内没有响应 ${method}`));
+      }, timeoutMs);
+      timer.unref?.();
+      const done = <A extends unknown[]>(fn: (...args: A) => void) => (...args: A) => {
+        clearTimeout(timer);
+        fn(...args);
+      };
+      this.pending.set(id, { resolve: done(resolve), reject: done(reject) });
+      try {
+        this.send({ jsonrpc: "2.0", id, method, params });
+      } catch (err) {
+        clearTimeout(timer);
+        this.pending.delete(id);
+        reject(err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+  }
+
+  notify(method: string, params?: unknown): void {
+    try {
+      this.send({ jsonrpc: "2.0", method, params });
+    } catch (err) {
+      console.error(`[codex] 通知 ${method} 发送失败:`, err);
+    }
+  }
+
+  /** 确保连接可用后再发请求。 */
+  async call<T>(method: string, params?: unknown): Promise<T> {
+    await this.start();
+    return (await this.request(method, params)) as T;
+  }
+
+  async stop(): Promise<void> {
+    this.stopping = true;
+    this.child?.kill();
+    this.child = null;
+    this.ready = null;
+  }
+
+  /** 配置（codex 路径 / CODEX_HOME）变了：杀掉重拉，挂着的 thread 通过 onRestart 重新 resume。 */
+  async restart(reason: string): Promise<void> {
+    this.stopping = true;
+    const child = this.child;
+    this.child = null;
+    this.ready = null;
+    // 旧进程的 exit 不能再触发自动重连，否则会把新拉起的连接冲掉
+    child?.removeAllListeners("exit");
+    child?.kill();
+    this.failAllPending(new Error(reason));
+    // 主动重启同样是「旧连接失效」：在途轮次要收尾、thread 要标记为待恢复
+    for (const handler of this.exitHandlers) {
+      try {
+        handler(reason);
+      } catch (err) {
+        console.error("[codex] 退出回调出错:", err);
+      }
+    }
+    this.stopping = false;
+    await this.start();
+    for (const handler of this.restartHandlers) handler(reason);
+  }
+
+  get running(): boolean {
+    return !!this.child;
+  }
+}
+
+/**
+ * 全局唯一的连接。
+ *
+ * 所有会话共用它，thread 之间靠 threadId 区分。单点故障由上面的自动重连
+ * 和 onRestart 兜住：thread 是落在 ~/.codex/sessions 里的，重连后 resume 回来
+ * 就行，上下文不丢。
+ */
+export const appServer = new AppServer();

package/src/agents/codex/driver.ts

@@ -0,0 +1,183 @@
+// Codex 驱动：官方 `codex app-server`（Codex 桌面版和 IDE 插件走的那条路）。
+//
+// 不用 @openai/codex-sdk：它是 `codex exec --json` 的薄封装，没有任何审批回调。
+import { appServer } from "./app-server.js";
+import { describeRateLimits, readRateLimits } from "./account.js";
+import { diagnose } from "./errors.js";
+import { CodexSession, summarize } from "./session.js";
+import { config, onConfigChange } from "../../core/config.js";
+import type {
+  AgentDriver,
+  AgentEvents,
+  AgentSession,
+  HistoryMessage,
+  InteractionHost,
+  ModelInfo,
+  RuntimeInfo,
+  SessionOptions,
+  SessionSummary,
+} from "../../core/types.js";
+import type { ModelListResponse, Thread, ThreadListResponse } from "./protocol.js";
+
+function titleOf(thread: Thread): string {
+  const name = thread.name?.trim();
+  if (name) return name;
+  const preview = thread.preview?.replace(/\s+/g, " ").trim();
+  if (!preview) return "(无标题)";
+  return preview.length > 60 ? `${preview.slice(0, 60)}…` : preview;
+}
+
+type HistoryItem = {
+  type: string;
+  text?: string;
+  phase?: string | null;
+  command?: string;
+  content?: { type: string; text?: string; path?: string }[];
+  changes?: { path: string }[];
+  server?: string;
+  tool?: string;
+  query?: string;
+  summary?: string[];
+};
+
+export class CodexDriver implements AgentDriver {
+  readonly id = "codex";
+  readonly label = "Codex";
+  readonly capabilities = { effort: true, fork: true, cost: false, streaming: true };
+  private unsubscribe: (() => void) | null = null;
+
+  async start(): Promise<void> {
+    const info = await appServer.start();
+    console.log(`[codex] app-server 就绪，CODEX_HOME=${info.codexHome ?? "(默认)"}`);
+    // 换了 codex 路径或 CODEX_HOME 就重拉 app-server
+    this.unsubscribe = onConfigChange((next, prev) => {
+      const a = next.agents.codex;
+      const b = prev.agents.codex;
+      if (a.path === b.path && a.home === b.home) return;
+      if (!a.enabled) return;
+      void appServer
+        .restart("codex 配置已变更")
+        .then(() => console.log("[codex] 配置变更，app-server 已重启"))
+        .catch((err) => console.error("[codex] 重启 app-server 失败:", err));
+    });
+  }
+
+  async stop(): Promise<void> {
+    this.unsubscribe?.();
+    await appServer.stop();
+  }
+
+  createSession(opts: SessionOptions, events: AgentEvents, host: InteractionHost): AgentSession {
+    return new CodexSession(opts, events, host);
+  }
+
+  async listSessions(cwd: string | undefined, limit = 10): Promise<SessionSummary[]> {
+    try {
+      const res = await appServer.call<ThreadListResponse>("thread/list", {
+        ...(cwd ? { cwd } : {}),
+        limit,
+        sortKey: "updated_at",
+        sortDirection: "desc",
+      });
+      return (res.data ?? []).map((thread) => ({
+        id: thread.id,
+        title: titleOf(thread),
+        ...(thread.cwd ? { cwd: thread.cwd } : {}),
+        updatedAt: ((thread.updatedAt ?? thread.createdAt) || 0) * 1000,
+      }));
+    } catch (err) {
+      console.error("[codex] 读取会话列表失败:", err);
+      return [];
+    }
+  }
+
+  async sessionExists(id: string): Promise<boolean> {
+    try {
+      await appServer.call("thread/read", { threadId: id, includeTurns: false });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async readHistory(id: string): Promise<HistoryMessage[]> {
+    const res = await appServer.call<{ thread: { turns?: { items?: HistoryItem[]; startedAt?: number | null }[] } }>(
+      "thread/read",
+      { threadId: id, includeTurns: true },
+    );
+    const out: HistoryMessage[] = [];
+    for (const turn of res.thread.turns ?? []) {
+      let assistant: HistoryMessage | null = null;
+      const ts = turn.startedAt ? turn.startedAt * 1000 : undefined;
+      for (const item of turn.items ?? []) {
+        if (item.type === "userMessage") {
+          const text = (item.content ?? [])
+            .map((c) => (c.type === "text" ? (c.text ?? "") : c.type === "localImage" ? "📎 图片" : ""))
+            .filter(Boolean)
+            .join("\n");
+          const cut = text.indexOf("[用户");
+          out.push({ role: "user", text: cut > 0 ? text.slice(0, cut).trim() || text : text, ...(ts ? { ts } : {}) });
+          continue;
+        }
+        assistant ??= { role: "assistant", text: "", steps: [] };
+        if (item.type === "agentMessage" && item.text?.trim()) {
+          if (item.phase === "commentary") assistant.steps!.push(`💬 ${summarize(item.text)}`);
+          else assistant.text += (assistant.text ? "\n\n" : "") + item.text;
+        } else if (item.type === "commandExecution" && item.command) {
+          assistant.steps!.push(`🔧 ${summarize(item.command, 70)}`);
+        } else if (item.type === "fileChange" && item.changes?.length) {
+          assistant.steps!.push(`📝 ${summarize(item.changes.map((c) => c.path).join("、"), 90)}`);
+        } else if (item.type === "mcpToolCall") {
+          assistant.steps!.push(`🔌 ${item.server}.${item.tool}`);
+        } else if (item.type === "webSearch") {
+          assistant.steps!.push(`🔍 ${summarize(item.query ?? "", 60)}`);
+        } else if (item.type === "reasoning" && item.summary?.length) {
+          assistant.steps!.push(`💭 ${summarize(item.summary.join(" "))}`);
+        }
+      }
+      if (assistant && (assistant.text || assistant.steps?.length)) out.push(assistant);
+    }
+    return out;
+  }
+
+  async listModels(): Promise<ModelInfo[]> {
+    const res = await appServer.call<ModelListResponse>("model/list", {});
+    return (res.data ?? [])
+      .filter((m) => !m.hidden)
+      .map((m) => ({
+        id: m.model,
+        label: m.displayName || m.model,
+        ...(m.description ? { description: m.description } : {}),
+        ...(m.supportedReasoningEfforts?.length
+          ? { efforts: m.supportedReasoningEfforts.map((e) => e.reasoningEffort) }
+          : {}),
+        ...(m.isDefault ? { isDefault: true } : {}),
+      }));
+  }
+
+  /** config.toml 里的默认值（config/read），不需要为此建 thread。 */
+  async defaults(): Promise<RuntimeInfo> {
+    const c = config().agents.codex;
+    try {
+      const res = await appServer.call<{
+        config?: { model?: string | null; model_reasoning_effort?: string | null };
+      }>("config/read", {});
+      const fromToml = res.config ?? {};
+      const model = c.defaultModel || fromToml.model || undefined;
+      const effort = c.defaultEffort || fromToml.model_reasoning_effort || undefined;
+      return { ...(model ? { model } : {}), ...(effort ? { effort } : {}) };
+    } catch (err) {
+      console.error("[codex] 读取默认配置失败:", err);
+      return {};
+    }
+  }
+
+  async statusLines(): Promise<string[]> {
+    const quota = describeRateLimits(await readRateLimits());
+    return [`沙箱：${config().agents.codex.sandbox}`, ...(quota.length > 0 ? ["", ...quota] : [])];
+  }
+
+  diagnose(err: unknown) {
+    return diagnose(err);
+  }
+}