@nema-project/nema 0.0.0-stage → 0.1.4

package/dist/daemon/connection.js

@@ -0,0 +1,166 @@
+import {
+  parseHubToDaemon
+} from "../chunks/chunk-HEIQINX3.js";
+
+// daemon/connection.js
+import WebSocket from "ws";
+import { cliVersion } from "../direct/siwc.js";
+import { reportTokenHash } from "../report/token.js";
+import { reconcileWorkspaceDirs, removeWorkspaceDir } from "./cleanup.js";
+var VERSION_SKEW_ERROR = "hub \u4E0E nema CLI \u7248\u672C\u4E0D\u4E00\u81F4\uFF0C\u8BF7\u540C\u65F6\u66F4\u65B0\uFF08\u91CD\u65B0\u6784\u5EFA compose \u5E76\u91CD\u542F nema daemon\uFF09";
+function skewGuidance(message) {
+  if (!message.includes("\u7248\u672C\u4E0D\u4E00\u81F4"))
+    return null;
+  const match = /@nema-project\/nema@(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)/.exec(message);
+  if (match)
+    return `run: npm i -g @nema-project/nema@${match[1]}`;
+  return "run: npm i -g @nema-project/nema@<hub \u7248\u672C>\n\u8BF7\u5148\u67E5\u770B\u6B63\u5728\u8FD0\u884C\u7684 hub \u7684\u7248\u672C";
+}
+function connectDaemon(opts) {
+  const reconnectMs = opts.reconnectMs ?? 3e3;
+  const url = opts.hubUrl.replace(/^http/, "ws").replace(/\/+$/, "") + "/daemon";
+  let ws = null;
+  let timer = null;
+  let closed = false;
+  let stop = false;
+  let closePromise;
+  const rpcInflight = /* @__PURE__ */ new Set();
+  const open = () => {
+    if (closed)
+      return;
+    const sock = new WebSocket(url);
+    ws = sock;
+    const send = (m) => {
+      if (closed)
+        return false;
+      if (sock.readyState !== WebSocket.OPEN)
+        return false;
+      try {
+        sock.send(JSON.stringify(m));
+        return true;
+      } catch {
+        return false;
+      }
+    };
+    sock.on("open", () => {
+      if (closed)
+        return;
+      opts.bindSend?.(send);
+      let hash = null;
+      try {
+        const tokenHome = opts.reportTokenHome ?? opts.nemaHome;
+        hash = tokenHome ? reportTokenHash(tokenHome) : null;
+      } catch (e) {
+        console.error(`[nema] report token not sent: ${e instanceof Error ? e.message : String(e)}`);
+      }
+      send({
+        type: "hello",
+        token: opts.token,
+        version: opts.version ?? cliVersion(),
+        adapters: opts.runner.adapterNames,
+        ...hash ? { reportTokenHash: hash } : {}
+      });
+    });
+    sock.on("message", (d) => {
+      if (closed)
+        return;
+      let m;
+      let rawMsg;
+      try {
+        rawMsg = JSON.parse(String(d));
+        m = parseHubToDaemon(rawMsg);
+      } catch (e) {
+        const r = rawMsg;
+        if (r && typeof r === "object" && r.type === "task.assign" && typeof r.taskId === "string") {
+          console.error(`[nema] cannot parse task.assign ${r.taskId}: ${e instanceof Error ? e.message : String(e)}`);
+          send({ type: "task.finished", taskId: r.taskId, ok: false, error: VERSION_SKEW_ERROR });
+        } else {
+          console.error("[nema] ignoring unparseable hub message:", e instanceof Error ? e.message : String(e));
+        }
+        return;
+      }
+      const nemaHome = opts.nemaHome;
+      if (m.type === "error") {
+        console.error(`[nema] hub: ${m.message}`);
+        const guidance = skewGuidance(m.message);
+        if (guidance) {
+          console.error(guidance);
+          stop = true;
+        }
+      } else if (m.type === "welcome") {
+        console.log(`[nema] daemon connected to ${opts.hubUrl}`);
+        const ids = m.workspaceIds;
+        if (nemaHome && ids) {
+          void opts.runner.exclusive(async () => {
+            try {
+              const removed = await reconcileWorkspaceDirs(nemaHome, ids);
+              if (removed.length > 0)
+                console.log(`[nema] removed isolation dirs of deleted workspaces: ${removed.join(", ")}`);
+            } catch (e) {
+              console.error("[nema] isolation dir cleanup failed", e);
+            }
+          });
+        }
+      } else if (m.type === "workspace.deleted") {
+        const id = m.workspaceId;
+        if (nemaHome) {
+          void opts.runner.exclusive(async () => {
+            try {
+              await removeWorkspaceDir(nemaHome, id);
+            } catch (e) {
+              console.error(`[nema] failed to remove isolation dir of ${id}`, e);
+            }
+          });
+        }
+      } else if (m.type === "task.assign") {
+        const taskId = m.taskId;
+        opts.runner.enqueue(m, (event) => send({ type: "task.event", taskId, event }), (r) => send(r.ok ? { type: "task.finished", taskId, ok: true, reply: r.reply } : { type: "task.finished", taskId, ok: false, error: r.error }));
+      } else if (m.type === "rpc.request" && opts.rpc) {
+        const router = opts.rpc;
+        const request = router.handle(m).then((res) => {
+          if (!closed)
+            send(res);
+        });
+        rpcInflight.add(request);
+        void request.then(() => rpcInflight.delete(request), () => rpcInflight.delete(request));
+      }
+    });
+    sock.on("error", () => {
+    });
+    sock.on("close", () => {
+      if (ws === sock) {
+        ws = null;
+        opts.bindSend?.(null);
+      }
+      if (!closed && !stop)
+        timer = setTimeout(open, reconnectMs);
+    });
+  };
+  open();
+  return {
+    close() {
+      if (closePromise)
+        return closePromise;
+      closed = true;
+      if (timer)
+        clearTimeout(timer);
+      opts.bindSend?.(null);
+      const socket = ws;
+      const socketClosed = !socket || socket.readyState === WebSocket.CLOSED ? Promise.resolve() : new Promise((resolve) => {
+        socket.once("close", () => resolve());
+        try {
+          socket.terminate();
+        } catch {
+          resolve();
+        }
+      });
+      closePromise = Promise.all([...rpcInflight, socketClosed]).then(() => {
+      });
+      return closePromise;
+    }
+  };
+}
+export {
+  VERSION_SKEW_ERROR,
+  connectDaemon
+};

package/dist/daemon/rpc.d.ts

@@ -0,0 +1,14 @@
+import type { DaemonToHub, HubToDaemon } from "@nema/shared";
+export type RpcHandler = (params: unknown) => Promise<unknown>;
+type RpcRequest = Extract<HubToDaemon, {
+    type: "rpc.request";
+}>;
+type RpcResponse = Extract<DaemonToHub, {
+    type: "rpc.response";
+}>;
+export declare class RpcRouter {
+    private readonly handlers;
+    register(method: string, h: RpcHandler): void;
+    handle(req: RpcRequest): Promise<RpcResponse>;
+}
+export {};

package/dist/daemon/rpc.js

@@ -0,0 +1,20 @@
+// daemon/rpc.js
+var RpcRouter = class {
+  handlers = /* @__PURE__ */ new Map();
+  register(method, h) {
+    this.handlers.set(method, h);
+  }
+  async handle(req) {
+    const handler = this.handlers.get(req.method);
+    if (!handler)
+      return { type: "rpc.response", id: req.id, ok: false, error: `\u672A\u77E5\u65B9\u6CD5 ${req.method}` };
+    try {
+      return { type: "rpc.response", id: req.id, ok: true, result: await handler(req.params) };
+    } catch (e) {
+      return { type: "rpc.response", id: req.id, ok: false, error: e instanceof Error ? e.message : String(e) };
+    }
+  }
+};
+export {
+  RpcRouter
+};

package/dist/daemon/runner.d.ts

@@ -0,0 +1,34 @@
+import type { TaskAssign, TaskEvent } from "@nema/shared";
+import { type NemaConfig } from "../config.js";
+export type AgentResult = {
+    ok: true;
+    reply: string;
+} | {
+    ok: false;
+    error: string;
+};
+export interface AgentAdapter {
+    name: string;
+    run(task: TaskAssign, onEvent: (e: TaskEvent) => void, signal?: AbortSignal): Promise<AgentResult>;
+}
+/** "auto" -> the configured adapter. "codex" and "codex-cli" are the retired CLI names; both run codex-direct. */
+export declare function resolveAdapterName(requested: string, config: NemaConfig): string;
+/** Runs tasks one at a time, globally, in enqueue order. */
+export declare class Runner {
+    private readonly adapters;
+    private readonly getConfig;
+    private chain;
+    private stopped;
+    private stopping?;
+    private activeController?;
+    constructor(adapters: AgentAdapter[], getConfig?: () => NemaConfig);
+    get adapterNames(): string[];
+    /**
+     * Runs `job` in the same queue as tasks, so it never overlaps a running agent (e.g. removing a
+     * workspace's isolation dir while Codex is still using it). Failures are swallowed.
+     */
+    exclusive(job: () => Promise<void>): Promise<void>;
+    enqueue(task: TaskAssign, onEvent: (e: TaskEvent) => void, onDone: (r: AgentResult) => void): void;
+    /** Permanently stop accepting work and wait until active adapter cleanup has finished. */
+    stop(): Promise<void>;
+}

package/dist/daemon/runner.js

@@ -0,0 +1,94 @@
+// daemon/runner.js
+import { configErrorMessage, DEFAULT_CONFIG } from "../config.js";
+function resolveAdapterName(requested, config) {
+  if (requested === "auto")
+    return config.adapter;
+  if (requested === "codex" || requested === "codex-cli")
+    return "codex-direct";
+  return requested;
+}
+var Runner = class {
+  adapters;
+  getConfig;
+  chain = Promise.resolve();
+  stopped = false;
+  stopping;
+  activeController;
+  constructor(adapters, getConfig = () => ({ ...DEFAULT_CONFIG })) {
+    this.adapters = adapters;
+    this.getConfig = getConfig;
+  }
+  get adapterNames() {
+    return this.adapters.map((a) => a.name);
+  }
+  /**
+   * Runs `job` in the same queue as tasks, so it never overlaps a running agent (e.g. removing a
+   * workspace's isolation dir while Codex is still using it). Failures are swallowed.
+   */
+  exclusive(job) {
+    if (this.stopped)
+      return this.stopping ?? Promise.resolve();
+    const run = this.chain.then(async () => {
+      if (!this.stopped)
+        await job();
+    }).catch(() => {
+    });
+    this.chain = run;
+    return run;
+  }
+  enqueue(task, onEvent, onDone) {
+    if (this.stopped)
+      return;
+    this.chain = this.chain.then(async () => {
+      if (this.stopped)
+        return;
+      let result;
+      let name;
+      try {
+        name = resolveAdapterName(task.adapter, this.getConfig());
+      } catch (e) {
+        result = { ok: false, error: configErrorMessage(e) };
+      }
+      if (name !== void 0) {
+        const adapter = this.adapters.find((a) => a.name === name);
+        if (!adapter) {
+          result = { ok: false, error: `adapter ${name} \u4E0D\u53EF\u7528` };
+        } else {
+          const controller = new AbortController();
+          this.activeController = controller;
+          try {
+            result = await adapter.run(task, (event) => {
+              if (!this.stopped)
+                onEvent(event);
+            }, controller.signal);
+          } catch (e) {
+            result = { ok: false, error: e instanceof Error ? e.message : String(e) };
+          } finally {
+            if (this.activeController === controller)
+              this.activeController = void 0;
+          }
+        }
+      }
+      if (this.stopped)
+        return;
+      try {
+        onDone(result);
+      } catch {
+      }
+    });
+  }
+  /** Permanently stop accepting work and wait until active adapter cleanup has finished. */
+  stop() {
+    if (this.stopping)
+      return this.stopping;
+    this.stopped = true;
+    this.activeController?.abort(new Error("runner stopped"));
+    this.stopping = this.chain.then(() => {
+    });
+    return this.stopping;
+  }
+};
+export {
+  Runner,
+  resolveAdapterName
+};

package/dist/daemon/setup.d.ts

@@ -0,0 +1,39 @@
+import { type NemaConfig } from "../config.js";
+import { type GithubReader } from "../github/gh.js";
+import type { GraphifyOpts } from "../repos/graphify.js";
+import { RepoWatcher } from "../repos/watcher.js";
+import { Runner } from "./runner.js";
+import type { OwnedHelperScope } from "@nema/shared/ownedHelper";
+export type RunnerSetup = {
+    nemaHome: string;
+    userCodexHome: string;
+    version: string;
+    getConfig?: () => NemaConfig;
+    cliEntry: string;
+    execPath?: string;
+    ownedHelpers?: OwnedHelperScope;
+};
+/** The daemon's runner. Codex stays on the direct adapter; Claude Code is selected only when config.adapter is claude-code. */
+export declare function createRunner(o: RunnerSetup): Runner;
+export type DaemonStart = {
+    hubUrl: string;
+    token: string;
+    nemaHome: string;
+    userCodexHome: string;
+    version: string;
+    getConfig?: () => NemaConfig;
+    cliEntry: string;
+    execPath?: string;
+    /** For tests: production passes the packaged `tools/graphify` binary, not a PATH lookup. */
+    graphify?: GraphifyOpts;
+    /** Explicit provider injection for tests or callers; production uses the signed-in `gh` CLI. */
+    github?: GithubReader;
+    /** Where the report token the hub should accept lives; defaults to `nemaHome`. */
+    reportTokenHome?: string;
+    ownedHelpers?: OwnedHelperScope;
+};
+/** Connects the daemon and answers repo RPC plus `plugin.call` and `plugins.status`. */
+export declare function startDaemon(o: DaemonStart): {
+    close(): Promise<void>;
+    watcher: RepoWatcher;
+};

package/dist/daemon/setup.js

@@ -0,0 +1,95 @@
+// daemon/setup.js
+import { ClaudeCodeAdapter } from "../claude/adapter.js";
+import { loadConfig } from "../config.js";
+import { CodexDirectAdapter } from "../direct/adapter.js";
+import { GithubGh } from "../github/gh.js";
+import { registerExtensionHandlers } from "../extensions/handlers.js";
+import { registerRepoHandlers } from "../repos/handlers.js";
+import { parseReposSync, RepoWatcher } from "../repos/watcher.js";
+import { connectDaemon } from "./connection.js";
+import { RpcRouter } from "./rpc.js";
+import { Runner } from "./runner.js";
+function createRunner(o) {
+  if (!o.cliEntry)
+    throw new Error("cliEntry is required");
+  const direct = new CodexDirectAdapter({ nemaHome: o.nemaHome, version: o.version, codexHome: o.userCodexHome });
+  const claude = new ClaudeCodeAdapter({ nemaHome: o.nemaHome, cliEntry: o.cliEntry, execPath: o.execPath ?? process.execPath, ownedHelpers: o.ownedHelpers });
+  return new Runner([direct, claude], o.getConfig ?? (() => loadConfig(o.nemaHome)));
+}
+function startDaemon(o) {
+  const runner = createRunner(o);
+  const rpc = new RpcRouter();
+  const graphify = { ...o.graphify, ownedHelpers: o.ownedHelpers };
+  const github = o.github ?? new GithubGh({ ownedHelpers: o.ownedHelpers });
+  registerExtensionHandlers(rpc, o.nemaHome);
+  let sendMessage = null;
+  const watcher = new RepoWatcher({
+    nemaHome: o.nemaHome,
+    graphify,
+    onMoved: (move) => {
+      if (!sendMessage)
+        return false;
+      return sendMessage({ type: "repo.moved", repoId: move.repoId, mainRef: move.mainRef, from: move.from, to: move.to });
+    },
+    onFetch: (report) => {
+      const message = {
+        type: "repo.fetched",
+        repoId: report.repoId,
+        ok: report.ok,
+        at: report.at
+      };
+      if (report.error !== void 0)
+        message.error = report.error;
+      sendMessage?.(message);
+    }
+  });
+  registerRepoHandlers(rpc, {
+    nemaHome: o.nemaHome,
+    graphify,
+    github,
+    ownedHelpers: o.ownedHelpers,
+    prepareRepo: (repoId, taskId) => watcher.prepare(repoId, taskId)
+  });
+  rpc.register("repos.sync", async (params) => {
+    watcher.setRepos(parseReposSync(params));
+    return { ok: true };
+  });
+  rpc.register("repo.tick", async (params) => {
+    const repoId = params?.repoId;
+    if (typeof repoId !== "string" || repoId === "")
+      throw new Error("invalid repo params");
+    void watcher.tickRepo(repoId).catch((error) => {
+      console.error("[nema] repo tick failed", error);
+    });
+    return { ok: true };
+  });
+  watcher.start();
+  const connection = connectDaemon({
+    hubUrl: o.hubUrl,
+    token: o.token,
+    runner,
+    nemaHome: o.nemaHome,
+    ...o.reportTokenHome ? { reportTokenHome: o.reportTokenHome } : {},
+    version: o.version,
+    rpc,
+    bindSend: (send) => {
+      sendMessage = send;
+    }
+  });
+  let closing;
+  return {
+    watcher,
+    close() {
+      if (closing)
+        return closing;
+      const tasks = [runner.stop(), watcher.stop(), connection.close(), github.close()];
+      closing = Promise.all(tasks).then(() => {
+      });
+      return closing;
+    }
+  };
+}
+export {
+  createRunner,
+  startDaemon
+};

package/dist/direct/adapter.d.ts

@@ -0,0 +1,30 @@
+import type { TaskAssign, TaskEvent } from "@nema/shared";
+import type { AgentAdapter, AgentResult } from "../daemon/runner.js";
+import { type Refresher } from "./authStore.js";
+import { type TransportProfile } from "./transport.js";
+export declare const NOT_LOGGED_IN = "\u672A\u767B\u5F55\u76F4\u8FDE Codex\uFF0C\u8BF7\u5728\u7EC8\u7AEF\u8FD0\u884C nema auth login";
+export declare const RUN_TIMEOUT_MESSAGE = "Codex \u76F4\u8FDE\u8FD0\u884C\u8D85\u65F6";
+export declare const DIRECT_USER_TEXT = "\u8BF7\u6309\u4E0A\u9762\u7684\u6307\u4EE4\u5904\u7406\u672C\u6B21\u7528\u6237\u6D88\u606F\uFF0C\u5E76\u53EA\u901A\u8FC7\u63D0\u4F9B\u7684\u51FD\u6570\u8BFB\u5199\u9879\u76EE\u77E5\u8BC6\u3002";
+export declare const FALLBACK_MODEL = "gpt-5.5";
+export type CodexDirectAdapterOptions = {
+    nemaHome: string;
+    version: string;
+    profile?: TransportProfile;
+    timeoutMs?: number;
+    now?: () => number;
+    /** Token refresher (defaults to SIWC). Unused when authMode is compat or byok. */
+    refresher?: Refresher;
+    /** Codex CLI home whose auth.json compat mode reads. Defaults to $CODEX_HOME or ~/.codex. */
+    codexHome?: string;
+};
+/** Local time as `YYYY-MM-DD HH:mm`. */
+export declare function formatLocalTime(ms: number): string;
+export declare class CodexDirectAdapter implements AgentAdapter {
+    private readonly opts;
+    readonly name = "codex-direct";
+    constructor(opts: CodexDirectAdapterOptions);
+    run(task: TaskAssign, onEvent: (e: TaskEvent) => void, ownerSignal?: AbortSignal): Promise<AgentResult>;
+    private execute;
+    /** First listed model; the fallback only when the list is unavailable (API error) or empty. */
+    private defaultModel;
+}

package/dist/direct/adapter.js

@@ -0,0 +1,190 @@
+// direct/adapter.js
+import { randomUUID } from "node:crypto";
+import { configErrorMessage, DEFAULT_BYOK_BASE_URL, loadConfig } from "../config.js";
+import { RoomClient } from "../room/client.js";
+import { AuthStore, ReloginRequiredError, UNUSABLE_FILE_MESSAGE } from "./authStore.js";
+import { ByokTokenSource } from "./byok.js";
+import { CodexFileTokenSource, defaultCodexHome } from "./codexLogin.js";
+import { DEFAULT_LIMITS, runToolLoop } from "./loop.js";
+import { siwcRefresher } from "./siwc.js";
+import { roomTools } from "./tools.js";
+import { BYOK_PROFILE, ByokRejectedError, COMPAT_PROFILE, listModels, ModelApiError, ModelQuotaError, SIWC_PROFILE, streamResponse } from "./transport.js";
+var NOT_LOGGED_IN = "\u672A\u767B\u5F55\u76F4\u8FDE Codex\uFF0C\u8BF7\u5728\u7EC8\u7AEF\u8FD0\u884C nema auth login";
+var RUN_TIMEOUT_MESSAGE = "Codex \u76F4\u8FDE\u8FD0\u884C\u8D85\u65F6";
+var DIRECT_USER_TEXT = "\u8BF7\u6309\u4E0A\u9762\u7684\u6307\u4EE4\u5904\u7406\u672C\u6B21\u7528\u6237\u6D88\u606F\uFF0C\u5E76\u53EA\u901A\u8FC7\u63D0\u4F9B\u7684\u51FD\u6570\u8BFB\u5199\u9879\u76EE\u77E5\u8BC6\u3002";
+var FALLBACK_MODEL = "gpt-5.5";
+var DEFAULT_TIMEOUT_MS = 6e5;
+var PROGRESS_INTERVAL_MS = 500;
+var PROGRESS_MAX_CHARS = 2e3;
+var RunTimeoutError = class extends Error {
+  constructor() {
+    super(RUN_TIMEOUT_MESSAGE);
+    this.name = "RunTimeoutError";
+  }
+};
+var pad = (n) => String(n).padStart(2, "0");
+function formatLocalTime(ms) {
+  const d = new Date(ms);
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
+}
+function errorMessage(e) {
+  if (e instanceof RunTimeoutError || e instanceof ReloginRequiredError || e instanceof ByokRejectedError)
+    return e.message;
+  if (e instanceof ModelQuotaError) {
+    if (e.code === "subscription_sharing_usage_unavailable")
+      return "\u8BA2\u9605\u989D\u5EA6\u6682\u65F6\u4E0D\u53EF\u7528\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5";
+    if (e.code === "usage_not_included")
+      return "\u5F53\u524D\u8BA2\u9605\u4E0D\u5305\u542B\u6B64\u7528\u91CF";
+    return "\u8BA2\u9605\u989D\u5EA6\u5DF2\u7528\u5B8C" + (e.resetsAt !== void 0 ? `\uFF0C\u9884\u8BA1 ${formatLocalTime(e.resetsAt)} \u6062\u590D` : "");
+  }
+  if (e instanceof ModelApiError)
+    return "\u6A21\u578B\u63A5\u53E3\u9519\u8BEF\uFF1A" + e.message;
+  return e instanceof Error ? e.message : String(e);
+}
+var CodexDirectAdapter = class {
+  opts;
+  name = "codex-direct";
+  constructor(opts) {
+    this.opts = opts;
+  }
+  async run(task, onEvent, ownerSignal) {
+    if (ownerSignal?.aborted)
+      return { ok: false, error: "Codex \u76F4\u8FDE\u8FD0\u884C\u5DF2\u4E2D\u6B62" };
+    let config;
+    try {
+      config = loadConfig(this.opts.nemaHome);
+    } catch (e) {
+      return { ok: false, error: configErrorMessage(e) };
+    }
+    let source;
+    let profile;
+    let configuredModel;
+    if (config.authMode === "compat") {
+      source = new CodexFileTokenSource(this.opts.codexHome ?? defaultCodexHome(), this.opts.now);
+      profile = this.opts.profile ?? COMPAT_PROFILE;
+      try {
+        await source.getAccessToken();
+      } catch (e) {
+        return { ok: false, error: errorMessage(e) };
+      }
+      if (ownerSignal?.aborted)
+        return { ok: false, error: "Codex \u76F4\u8FDE\u8FD0\u884C\u5DF2\u4E2D\u6B62" };
+    } else if (config.authMode === "byok") {
+      if (!config.model)
+        return { ok: false, error: "BYOK \u9700\u8981\u6307\u5B9A\u6A21\u578B\uFF0C\u8BF7\u8FD0\u884C nema config set model <\u540D\u79F0>" };
+      source = new ByokTokenSource(this.opts.nemaHome);
+      profile = { ...BYOK_PROFILE, baseUrl: config.byokBaseUrl ?? DEFAULT_BYOK_BASE_URL };
+      configuredModel = config.model;
+      try {
+        await source.getAccessToken();
+      } catch (e) {
+        return { ok: false, error: errorMessage(e) };
+      }
+      if (ownerSignal?.aborted)
+        return { ok: false, error: "Codex \u76F4\u8FDE\u8FD0\u884C\u5DF2\u4E2D\u6B62" };
+    } else {
+      const store = new AuthStore(this.opts.nemaHome, this.opts.refresher ?? siwcRefresher);
+      const { auth, reason } = store.inspect();
+      if (!auth)
+        return { ok: false, error: reason === "unusable" ? UNUSABLE_FILE_MESSAGE : NOT_LOGGED_IN };
+      source = store;
+      profile = this.opts.profile ?? SIWC_PROFILE;
+    }
+    const ac = new AbortController();
+    const abortFromOwner = () => ac.abort(ownerSignal?.reason ?? new Error("run stopped"));
+    ownerSignal?.addEventListener("abort", abortFromOwner, { once: true });
+    if (ownerSignal?.aborted)
+      abortFromOwner();
+    const timeout = new Promise((_, reject) => {
+      ac.signal.addEventListener("abort", () => reject(ac.signal.reason), { once: true });
+    });
+    timeout.catch(() => {
+    });
+    const timer = setTimeout(() => ac.abort(new RunTimeoutError()), task.limits?.timeoutMs ?? this.opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    const execution = this.execute(task, onEvent, source, profile, ac.signal, configuredModel);
+    try {
+      return await Promise.race([execution, timeout]);
+    } catch (e) {
+      return { ok: false, error: errorMessage(ac.signal.reason instanceof RunTimeoutError ? ac.signal.reason : e) };
+    } finally {
+      clearTimeout(timer);
+      if (!ac.signal.aborted)
+        ac.abort(new Error("run finished"));
+      ownerSignal?.removeEventListener("abort", abortFromOwner);
+      if (ownerSignal)
+        await execution.catch(() => {
+        });
+    }
+  }
+  async execute(task, rawOnEvent, source, profile, signal, configuredModel) {
+    const onEvent = (e) => {
+      if (!signal.aborted)
+        rawOnEvent(e);
+    };
+    let config;
+    try {
+      config = loadConfig(this.opts.nemaHome);
+    } catch (e) {
+      throw new Error(configErrorMessage(e), { cause: e });
+    }
+    const ctx = { auth: source, profile, version: this.opts.version, signal };
+    const model = configuredModel ?? config.model ?? await this.defaultModel(ctx);
+    const room = new RoomClient(task.hubUrl, task.runToken, signal);
+    const sessionId = randomUUID();
+    const now = this.opts.now ?? Date.now;
+    const tools = roomTools(task.pluginTools);
+    const { reply } = await runToolLoop({
+      instructions: task.prompt,
+      userText: DIRECT_USER_TEXT,
+      room,
+      pluginTools: task.pluginTools,
+      signal,
+      ...task.limits ? { limits: { ...DEFAULT_LIMITS, maxModelCalls: task.limits.maxModelCalls, maxToolCalls: task.limits.maxToolCalls } } : {},
+      onProgress: (text) => onEvent({ type: "tool_call", text }),
+      call: async (input) => {
+        let text = "";
+        let sent = "";
+        let lastAt = -Infinity;
+        const flush = () => {
+          if (text === sent)
+            return;
+          sent = text;
+          lastAt = now();
+          onEvent({ type: "agent_message", text: text.slice(-PROGRESS_MAX_CHARS) });
+        };
+        try {
+          return await streamResponse({ model, instructions: task.prompt, input, tools, reasoning: { effort: config.reasoningEffort, summary: "auto" }, sessionId }, {
+            ...ctx,
+            onTextDelta: (d) => {
+              text += d;
+              if (now() - lastAt >= PROGRESS_INTERVAL_MS)
+                flush();
+            }
+          });
+        } finally {
+          if (!signal.aborted)
+            flush();
+        }
+      }
+    });
+    return { ok: true, reply };
+  }
+  /** First listed model; the fallback only when the list is unavailable (API error) or empty. */
+  async defaultModel(ctx) {
+    try {
+      return (await listModels(ctx))[0] ?? FALLBACK_MODEL;
+    } catch (e) {
+      if (e instanceof ModelApiError)
+        return FALLBACK_MODEL;
+      throw e;
+    }
+  }
+};
+export {
+  CodexDirectAdapter,
+  DIRECT_USER_TEXT,
+  FALLBACK_MODEL,
+  NOT_LOGGED_IN,
+  RUN_TIMEOUT_MESSAGE,
+  formatLocalTime
+};