@nema-project/nema 0.0.0-stage → 0.1.3

package/dist/direct/authStore.js

@@ -0,0 +1,351 @@
+// direct/authStore.js
+import { randomUUID } from "node:crypto";
+import { closeSync, constants, fstatSync, fsyncSync, ftruncateSync, lstatSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeSync } from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+import { jwtExp } from "./jwt.js";
+import { LockTimeoutError, withFileLock } from "./lock.js";
+import { openPrivateFile, privateModeMatches, protectPrivatePath } from "../secrets/permissions.js";
+var REFRESH_SKEW_MS = 12e4;
+var TERMINAL_CODES = [
+  "invalid_grant",
+  "invalid_client",
+  "invalid_token",
+  "refresh_token_reused",
+  "refresh_token_expired",
+  "refresh_token_invalidated"
+];
+var RELOGIN_MESSAGE = "\u76F4\u8FDE\u767B\u5F55\u5DF2\u5931\u6548\uFF0C\u8BF7\u5728\u7EC8\u7AEF\u8FD0\u884C nema auth login";
+var UNUSABLE_FILE_MESSAGE = "\u51ED\u8BC1\u6587\u4EF6\u4E0D\u53EF\u7528\uFF08\u6743\u9650/\u7B26\u53F7\u94FE\u63A5/\u635F\u574F\uFF09\uFF0C\u8BF7\u91CD\u65B0\u8FD0\u884C nema auth login";
+var StoredAuthSchema = z.object({
+  version: z.literal(1),
+  mode: z.enum(["siwc", "compat"]),
+  clientId: z.string(),
+  tokens: z.object({ access_token: z.string(), refresh_token: z.string(), id_token: z.string().optional() }),
+  accountId: z.string().optional(),
+  lastRefresh: z.string(),
+  lastAuthError: z.object({ code: z.string(), message: z.string(), at: z.string() }).optional()
+});
+var REFRESH_TIMEOUT_MS = 2e4;
+function isTrustedAuthStat(st, uid = process.getuid?.() ?? null, platform = process.platform) {
+  return st.isFile() && privateModeMatches(st, platform) && (uid === null || st.uid === uid);
+}
+var RefreshError = class extends Error {
+  status;
+  code;
+  retryAfterS;
+  constructor(status, opts = {}) {
+    super(opts.message ?? `Token refresh failed: HTTP ${status}${opts.code ? ` (${opts.code})` : ""}`);
+    this.status = status;
+    this.name = "RefreshError";
+    this.code = opts.code;
+    this.retryAfterS = opts.retryAfterS;
+  }
+};
+var ReloginRequiredError = class extends Error {
+  code;
+  constructor(code, options) {
+    super(RELOGIN_MESSAGE, options);
+    this.code = code;
+    this.name = "ReloginRequiredError";
+  }
+};
+var AuthRateLimitedError = class extends Error {
+  retryAfterS;
+  constructor(retryAfterS, options) {
+    super(`\u76F4\u8FDE\u767B\u5F55\u5237\u65B0\u88AB\u9650\u6D41${retryAfterS !== void 0 ? `\uFF0C\u8BF7\u7EA6 ${retryAfterS} \u79D2\u540E\u91CD\u8BD5` : "\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5"}`, options);
+    this.retryAfterS = retryAfterS;
+    this.name = "AuthRateLimitedError";
+  }
+};
+var TransientAuthError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "TransientAuthError";
+  }
+};
+var result = (auth) => ({ accessToken: auth.tokens.access_token, auth });
+var hasRefreshToken = (a) => !!a && a.tokens.refresh_token !== "";
+var errMessage = (e) => e instanceof Error ? e.message : String(e);
+var AuthStore = class {
+  nemaHome;
+  refresher;
+  now;
+  opts;
+  file;
+  lockPath;
+  constructor(nemaHome, refresher, now = Date.now, opts = {}) {
+    this.nemaHome = nemaHome;
+    this.refresher = refresher;
+    this.now = now;
+    this.opts = opts;
+    this.file = path.join(nemaHome, "auth.json");
+    this.lockPath = path.join(nemaHome, "auth.lock");
+  }
+  /** The stored login, or null if missing, a symlink, not a regular file, not 0600, not ours, or malformed. */
+  read() {
+    return this.inspect().auth;
+  }
+  /** Like read(), but says why there is no login: "missing" (no file) or "unusable" (present but untrusted/corrupt). */
+  inspect() {
+    try {
+      if (!isTrustedAuthStat(lstatSync(this.file)))
+        return { auth: null, reason: "unusable" };
+      const fd = openPrivateFile(this.file);
+      let raw;
+      try {
+        if (!isTrustedAuthStat(fstatSync(fd)))
+          return { auth: null, reason: "unusable" };
+        raw = readFileSync(fd, "utf8");
+      } finally {
+        closeSync(fd);
+      }
+      const parsed = StoredAuthSchema.safeParse(JSON.parse(raw));
+      return parsed.success ? { auth: parsed.data } : { auth: null, reason: "unusable" };
+    } catch (e) {
+      return { auth: null, reason: e.code === "ENOENT" ? "missing" : "unusable" };
+    }
+  }
+  /**
+   * Records an auth problem in the file WITHOUT clearing the tokens (used when the model API rejects a token
+   * that refreshing could not fix). Best effort: only if the file still holds the same refresh token.
+   */
+  async recordAuthError(reason, forAuth) {
+    try {
+      await withFileLock(this.lockPath, async () => {
+        const cur = this.read();
+        if (!cur || cur.tokens.refresh_token !== forAuth.tokens.refresh_token)
+          return;
+        this.save({ ...cur, lastAuthError: { code: reason.code, message: reason.message, at: new Date(this.now()).toISOString() } });
+      }, { timeoutMs: 5e3, ...this.opts.lock });
+    } catch {
+    }
+  }
+  /** Atomic write (exclusive 0600 temp file + fsync + rename) under a 0700 directory. */
+  save(auth) {
+    mkdirSync(this.nemaHome, { recursive: true, mode: 448 });
+    protectPrivatePath(this.nemaHome, 448);
+    const tmp = `${this.file}.${process.pid}.${randomUUID()}.tmp`;
+    const fd = openSync(tmp, "wx", 384);
+    try {
+      try {
+        writeSync(fd, JSON.stringify(auth, null, 2) + "\n");
+        fsyncSync(fd);
+      } finally {
+        closeSync(fd);
+      }
+      protectPrivatePath(tmp, 384);
+      renameSync(tmp, this.file);
+    } catch (e) {
+      try {
+        unlinkSync(tmp);
+      } catch {
+      }
+      throw e;
+    }
+    try {
+      const dfd = openSync(this.nemaHome, "r");
+      try {
+        fsyncSync(dfd);
+      } finally {
+        closeSync(dfd);
+      }
+    } catch {
+    }
+  }
+  /** Without a reason: log out (delete the file). With a reason: drop the tokens and record lastAuthError. */
+  clear(reason) {
+    if (!reason) {
+      try {
+        unlinkSync(this.file);
+      } catch (e) {
+        if (e.code !== "ENOENT")
+          throw e;
+      }
+      return;
+    }
+    const base = this.read();
+    if (base)
+      this.save(this.cleared(base, reason));
+  }
+  /**
+   * A valid access token, refreshing under auth.lock when it is within 120 s of expiry or when forced.
+   * Pass the token the server just rejected as `rejectedAccessToken` with `force`: if a peer has already
+   * replaced it on disk, that token is returned without a refresh POST.
+   */
+  async getAccessToken(opts = {}) {
+    opts.signal?.throwIfAborted();
+    const held = this.read();
+    if (!hasRefreshToken(held))
+      throw new ReloginRequiredError();
+    const req = { force: !!opts.force, rejected: opts.rejectedAccessToken };
+    if (this.usableWithoutRefresh(held, held, req))
+      return result(held);
+    const refreshTimeoutMs = this.opts.refreshTimeoutMs ?? REFRESH_TIMEOUT_MS;
+    const lockOpts = { timeoutMs: Math.max(15e3, refreshTimeoutMs + 5e3), ...this.opts.lock };
+    try {
+      return await withFileLock(this.lockPath, () => this.refreshLocked(held, req, opts.signal), lockOpts);
+    } catch (e) {
+      if (e instanceof LockTimeoutError)
+        throw new TransientAuthError("\u7B49\u5F85\u76F4\u8FDE\u767B\u5F55\u51ED\u8BC1\u9501\u8D85\u65F6\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5", { cause: e });
+      throw e;
+    }
+  }
+  expiring(auth) {
+    const exp = jwtExp(auth.tokens.access_token);
+    return exp === null || exp * 1e3 - this.now() < REFRESH_SKEW_MS;
+  }
+  // The normal refresh decision: an expiring token is never usable; otherwise usable unless forced, and a
+  // forced call still takes a token that a peer has rotated in (new refresh token or a different access token
+  // than the one rejected).
+  usableWithoutRefresh(auth, held, req) {
+    if (this.expiring(auth))
+      return false;
+    if (!req.force)
+      return true;
+    if (auth.tokens.refresh_token !== held.tokens.refresh_token)
+      return true;
+    return req.rejected !== void 0 && auth.tokens.access_token !== req.rejected;
+  }
+  cleared(base, reason) {
+    return {
+      ...base,
+      tokens: { access_token: "", refresh_token: "" },
+      lastAuthError: { code: reason.code, message: reason.message, at: new Date(this.now()).toISOString() }
+    };
+  }
+  // Runs with auth.lock held: re-read, adopt a peer's rotation, else refresh and persist before unlocking.
+  async refreshLocked(held, req, signal) {
+    signal?.throwIfAborted();
+    const disk = this.read();
+    if (!hasRefreshToken(disk))
+      throw new ReloginRequiredError();
+    if (this.usableWithoutRefresh(disk, held, req))
+      return result(disk);
+    return this.refreshWith(disk, 1, signal);
+  }
+  async callRefresher(auth, ownerSignal) {
+    const ms = this.opts.refreshTimeoutMs ?? REFRESH_TIMEOUT_MS;
+    const ac = new AbortController();
+    let timer;
+    const deadline = new Promise((_, reject) => {
+      timer = setTimeout(() => {
+        ac.abort();
+        reject(new TransientAuthError(`\u5237\u65B0\u76F4\u8FDE\u767B\u5F55\u8D85\u65F6\uFF08${Math.round(ms / 1e3)} \u79D2\uFF09\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5`));
+      }, ms);
+    });
+    try {
+      if (ownerSignal?.aborted)
+        ac.abort(ownerSignal.reason);
+      const abortFromOwner = () => ac.abort(ownerSignal?.reason);
+      ownerSignal?.addEventListener("abort", abortFromOwner, { once: true });
+      try {
+        return await Promise.race([this.refresher(auth, ac.signal), deadline]);
+      } finally {
+        ownerSignal?.removeEventListener("abort", abortFromOwner);
+      }
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async refreshWith(disk, retries, signal) {
+    let res;
+    try {
+      res = await this.callRefresher(disk, signal);
+    } catch (e) {
+      if (signal?.aborted)
+        throw signal.reason ?? e;
+      return this.onRefreshFailure(disk, e, retries);
+    }
+    if (!res || typeof res.access_token !== "string" || res.access_token === "") {
+      throw new TransientAuthError("\u5237\u65B0\u54CD\u5E94\u7F3A\u5C11 access_token");
+    }
+    const idToken = res.id_token || disk.tokens.id_token;
+    const next = {
+      ...disk,
+      tokens: {
+        access_token: res.access_token,
+        refresh_token: res.refresh_token || disk.tokens.refresh_token,
+        ...idToken ? { id_token: idToken } : {}
+      },
+      lastRefresh: new Date(this.now()).toISOString()
+    };
+    delete next.lastAuthError;
+    try {
+      this.save(next);
+    } catch (e) {
+      const current = this.read();
+      if (current && current.tokens.refresh_token === disk.tokens.refresh_token) {
+        this.overwriteInPlace(this.cleared(current, { code: "credential_persist_failed", message: errMessage(e) }));
+      }
+      throw new ReloginRequiredError("credential_persist_failed", { cause: e });
+    }
+    signal?.throwIfAborted();
+    return result(next);
+  }
+  async onRefreshFailure(failed, e, retries) {
+    if (e instanceof AuthRateLimitedError || e instanceof TransientAuthError)
+      throw e;
+    if (e instanceof RefreshError && e.status === 429)
+      throw new AuthRateLimitedError(e.retryAfterS, { cause: e });
+    const terminal = e instanceof ReloginRequiredError || e instanceof RefreshError && (e.status === 401 || e.status === 403 || TERMINAL_CODES.includes(e.code ?? ""));
+    if (!terminal) {
+      if (e instanceof RefreshError) {
+        throw new TransientAuthError(`\u5237\u65B0\u76F4\u8FDE\u767B\u5F55\u5931\u8D25\uFF08HTTP ${e.status}\uFF09\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5`, { cause: e });
+      }
+      throw new TransientAuthError(`\u5237\u65B0\u76F4\u8FDE\u767B\u5F55\u5931\u8D25\uFF1A${errMessage(e)}`, { cause: e });
+    }
+    const code = e instanceof ReloginRequiredError ? e.code ?? "relogin_required" : `${e.code ?? `http_${e.status}`}`;
+    const relogin = e instanceof ReloginRequiredError ? e : new ReloginRequiredError(code, { cause: e });
+    const current = this.read();
+    if (hasRefreshToken(current) && current.tokens.refresh_token !== failed.tokens.refresh_token) {
+      if (!this.expiring(current))
+        return result(current);
+      if (retries > 0)
+        return this.refreshWith(current, retries - 1);
+      throw relogin;
+    }
+    if (current && current.tokens.refresh_token === failed.tokens.refresh_token) {
+      const next = this.cleared(current, { code, message: errMessage(e) });
+      try {
+        this.save(next);
+      } catch {
+        this.overwriteInPlace(next);
+      }
+    }
+    throw relogin;
+  }
+  // Last-resort, non-atomic write into the existing regular file (no symlink following). Best effort.
+  overwriteInPlace(auth) {
+    try {
+      const before = lstatSync(this.file);
+      if (!before.isFile() || before.isSymbolicLink())
+        return;
+      const fd = openSync(this.file, constants.O_WRONLY | constants.O_NOFOLLOW);
+      try {
+        const opened = fstatSync(fd);
+        if (!isTrustedAuthStat(opened) || opened.dev !== before.dev || opened.ino !== before.ino)
+          return;
+        ftruncateSync(fd, 0);
+        writeSync(fd, JSON.stringify(auth, null, 2) + "\n");
+        fsyncSync(fd);
+      } finally {
+        closeSync(fd);
+      }
+    } catch {
+    }
+  }
+};
+export {
+  AuthRateLimitedError,
+  AuthStore,
+  REFRESH_SKEW_MS,
+  REFRESH_TIMEOUT_MS,
+  RELOGIN_MESSAGE,
+  RefreshError,
+  ReloginRequiredError,
+  TERMINAL_CODES,
+  TransientAuthError,
+  UNUSABLE_FILE_MESSAGE,
+  isTrustedAuthStat
+};

package/dist/direct/byok.d.ts

@@ -0,0 +1,27 @@
+import type { Out } from "./authCommands.js";
+import type { StoredAuth } from "./authStore.js";
+import type { TokenSource } from "./transport.js";
+export declare const byokKeyPath: (nemaHome: string) => string;
+export declare function saveByokKey(nemaHome: string, key: string): void;
+export declare function readByokKey(nemaHome: string): string;
+export declare class ByokTokenSource implements TokenSource {
+    private readonly nemaHome;
+    constructor(nemaHome: string);
+    getAccessToken(_opts?: {
+        force?: boolean;
+        rejectedAccessToken?: string;
+        signal?: AbortSignal;
+    }): Promise<{
+        accessToken: string;
+        auth: StoredAuth;
+    }>;
+    recordAuthError(_reason: {
+        code: string;
+        message: string;
+    }, _forAuth: StoredAuth): Promise<void>;
+}
+export declare function authByok(o: {
+    nemaHome: string;
+    out: Out;
+    stdin: NodeJS.ReadableStream;
+}): Promise<number>;

package/dist/direct/byok.js

@@ -0,0 +1,67 @@
+// direct/byok.js
+import path from "node:path";
+import { readSecretLine, readStdinLine, saveSecretLine, SecretFileError } from "../secrets/file.js";
+var INVALID_KEY = "key \u5FC5\u987B\u662F\u4E00\u884C\u975E\u7A7A\u6587\u672C";
+var SYMLINK_KEY = "BYOK key \u6587\u4EF6\u662F\u7B26\u53F7\u94FE\u63A5\uFF0C\u5DF2\u62D2\u7EDD\u3002";
+var MISSING_KEY = "\u6CA1\u6709 BYOK API key\u3002\u8BF7\u628A\u94A5\u5319\u4ECE\u6807\u51C6\u8F93\u5165\u4EA4\u7ED9 nema auth byok\u3002";
+var KEY_MODE = "BYOK key \u6587\u4EF6\u6743\u9650\u5FC5\u987B\u662F 0600";
+var INVALID_STORED_KEY = "BYOK key \u6587\u4EF6\u5185\u5BB9\u65E0\u6548\u3002\u8BF7\u91CD\u65B0\u628A\u94A5\u5319\u4ECE\u6807\u51C6\u8F93\u5165\u4EA4\u7ED9 nema auth byok\u3002";
+function byokError(e) {
+  if (!(e instanceof SecretFileError))
+    return e;
+  return new Error(e.kind === "invalid" ? INVALID_KEY : e.kind === "symlink" ? SYMLINK_KEY : KEY_MODE);
+}
+var byokKeyPath = (nemaHome) => path.join(nemaHome, "byok-key");
+function saveByokKey(nemaHome, key) {
+  try {
+    saveSecretLine(byokKeyPath(nemaHome), key);
+  } catch (e) {
+    throw byokError(e);
+  }
+}
+function readByokKey(nemaHome) {
+  try {
+    return readSecretLine(byokKeyPath(nemaHome), MISSING_KEY, INVALID_STORED_KEY);
+  } catch (e) {
+    throw byokError(e);
+  }
+}
+var ByokTokenSource = class {
+  nemaHome;
+  constructor(nemaHome) {
+    this.nemaHome = nemaHome;
+  }
+  async getAccessToken(_opts = {}) {
+    const accessToken = readByokKey(this.nemaHome);
+    return {
+      accessToken,
+      auth: {
+        version: 1,
+        mode: "byok",
+        clientId: "",
+        tokens: { access_token: accessToken, refresh_token: "" },
+        lastRefresh: ""
+      }
+    };
+  }
+  async recordAuthError(_reason, _forAuth) {
+  }
+};
+async function authByok(o) {
+  const key = await readStdinLine(o.stdin);
+  try {
+    saveByokKey(o.nemaHome, key);
+    o.out.log("\u5DF2\u4FDD\u5B58 BYOK API key");
+    return 0;
+  } catch (e) {
+    o.out.error(e instanceof Error ? e.message : String(e));
+    return 1;
+  }
+}
+export {
+  ByokTokenSource,
+  authByok,
+  byokKeyPath,
+  readByokKey,
+  saveByokKey
+};

package/dist/direct/codexLogin.d.ts

@@ -0,0 +1,34 @@
+import type { StoredAuth } from "./authStore.js";
+export declare const CODEX_AUTH_CLAIM = "https://api.openai.com/auth";
+export declare class CodexLoginError extends Error {
+    constructor(message: string);
+}
+export declare function defaultCodexHome(env?: NodeJS.ProcessEnv): string;
+/** Account headers Hermes sends on chatgpt.com/backend-api/codex. A malformed token yields none. */
+export declare function codexAccountHeaders(accessToken: string): Record<string, string>;
+export type CodexCliTokens = {
+    accessToken: string;
+    refreshToken: string;
+    accountId?: string;
+    exp: number | null;
+};
+/** Read the Codex CLI login. Throws CodexLoginError when it cannot be used. Does not write the file. */
+export declare function readCodexCliTokens(codexHome: string, now?: number): CodexCliTokens;
+/**
+ * Token source for authMode=compat. Re-reads the Codex file on every call, including after a 401,
+ * so a token Codex itself rotated is picked up. Never refreshes and never writes the file.
+ */
+export declare class CodexFileTokenSource {
+    private readonly codexHome;
+    private readonly now;
+    constructor(codexHome: string, now?: () => number);
+    getAccessToken(opts?: {
+        force?: boolean;
+        rejectedAccessToken?: string;
+        signal?: AbortSignal;
+    }): Promise<{
+        accessToken: string;
+        auth: StoredAuth;
+    }>;
+    recordAuthError(): Promise<void>;
+}

package/dist/direct/codexLogin.js

@@ -0,0 +1,93 @@
+// direct/codexLogin.js
+import { readFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { checkCodexAuth } from "../codex/isolation.js";
+import { decodeJwtPayload, jwtExp } from "./jwt.js";
+var CODEX_AUTH_CLAIM = "https://api.openai.com/auth";
+var CodexLoginError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CodexLoginError";
+  }
+};
+function defaultCodexHome(env = process.env) {
+  const raw = env.CODEX_HOME?.trim();
+  return raw ? raw : path.join(os.homedir(), ".codex");
+}
+function authClaim(accessToken) {
+  try {
+    const claim = decodeJwtPayload(accessToken)[CODEX_AUTH_CLAIM];
+    return claim && typeof claim === "object" && !Array.isArray(claim) ? claim : {};
+  } catch {
+    return {};
+  }
+}
+function codexAccountHeaders(accessToken) {
+  const headers = {};
+  const claim = authClaim(accessToken);
+  if (typeof claim.chatgpt_account_id === "string" && claim.chatgpt_account_id !== "") {
+    headers["ChatGPT-Account-ID"] = claim.chatgpt_account_id;
+  }
+  const residency = claim.chatgpt_data_residency ?? claim.chatgpt_compute_residency;
+  if (typeof residency === "string" && residency.trim() !== "")
+    headers["x-openai-internal-codex-residency"] = residency.trim();
+  return headers;
+}
+function readCodexCliTokens(codexHome, now = Date.now()) {
+  const checked = checkCodexAuth(codexHome);
+  if (!checked.ok)
+    throw new CodexLoginError(checked.error);
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(checked.authPath, "utf8"));
+  } catch (e) {
+    throw new CodexLoginError(`\u65E0\u6CD5\u8BFB\u53D6 Codex \u767B\u5F55\u6587\u4EF6 ${checked.authPath}\uFF1A${e instanceof Error ? e.message : String(e)}`);
+  }
+  const tokens = parsed && typeof parsed === "object" ? parsed.tokens : void 0;
+  const access = tokens && typeof tokens === "object" ? tokens.access_token : void 0;
+  const refresh = tokens && typeof tokens === "object" ? tokens.refresh_token : void 0;
+  if (typeof access !== "string" || access === "" || typeof refresh !== "string" || refresh === "") {
+    throw new CodexLoginError(`Codex \u767B\u5F55\u6587\u4EF6 ${checked.authPath} \u91CC\u6CA1\u6709\u53EF\u7528\u7684 access_token \u548C refresh_token\u3002\u8BF7\u91CD\u65B0\u8FD0\u884C codex login\u3002`);
+  }
+  const exp = jwtExp(access);
+  if (exp !== null && exp * 1e3 <= now) {
+    throw new CodexLoginError(`Codex \u7684 access token \u5DF2\u8FC7\u671F\uFF08${checked.authPath}\uFF09\u3002\u8BF7\u6253\u5F00\u4E00\u6B21 Codex \u8BA9\u5B83\u5237\u65B0\u767B\u5F55\u3002Nema \u53EA\u8BFB\u53D6\u8BE5\u6587\u4EF6\uFF0C\u4E0D\u4F1A\u5237\u65B0\uFF0C\u4EE5\u514D\u4F5C\u5E9F Codex \u81EA\u5DF1\u7684\u767B\u5F55\u3002`);
+  }
+  const accountId = authClaim(access).chatgpt_account_id;
+  return { accessToken: access, refreshToken: refresh, accountId: typeof accountId === "string" && accountId !== "" ? accountId : void 0, exp };
+}
+var CodexFileTokenSource = class {
+  codexHome;
+  now;
+  constructor(codexHome, now = Date.now) {
+    this.codexHome = codexHome;
+    this.now = now;
+  }
+  async getAccessToken(opts = {}) {
+    opts.signal?.throwIfAborted();
+    const t = readCodexCliTokens(this.codexHome, this.now());
+    if (opts.rejectedAccessToken !== void 0 && t.accessToken === opts.rejectedAccessToken) {
+      throw new CodexLoginError("\u6A21\u578B\u63A5\u53E3\u62D2\u7EDD\u4E86\u5F53\u524D\u7684 Codex \u767B\u5F55\u3002Nema \u4E0D\u4F1A\u5237\u65B0 ~/.codex/auth.json\u3002\u8BF7\u5728 Codex \u91CC\u91CD\u65B0\u767B\u5F55\u540E\u518D\u8BD5\u3002");
+    }
+    const auth = {
+      version: 1,
+      mode: "compat",
+      clientId: "codex-cli-file",
+      tokens: { access_token: t.accessToken, refresh_token: t.refreshToken },
+      accountId: t.accountId,
+      lastRefresh: new Date(this.now()).toISOString()
+    };
+    return { accessToken: t.accessToken, auth };
+  }
+  async recordAuthError() {
+  }
+};
+export {
+  CODEX_AUTH_CLAIM,
+  CodexFileTokenSource,
+  CodexLoginError,
+  codexAccountHeaders,
+  defaultCodexHome,
+  readCodexCliTokens
+};

package/dist/direct/jwt.d.ts

@@ -0,0 +1,4 @@
+/** Decode a JWT payload without verifying the signature. Throws on malformed input. */
+export declare function decodeJwtPayload(token: string): Record<string, unknown>;
+/** The `exp` claim in seconds since the epoch, or null when absent or undecodable. */
+export declare function jwtExp(token: string): number | null;

package/dist/direct/jwt.js

@@ -0,0 +1,22 @@
+// direct/jwt.js
+function decodeJwtPayload(token) {
+  const parts = token.split(".");
+  if (parts.length !== 3 || !parts[1])
+    throw new Error("Malformed JWT");
+  const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString("utf8"));
+  if (!payload || typeof payload !== "object" || Array.isArray(payload))
+    throw new Error("Malformed JWT payload");
+  return payload;
+}
+function jwtExp(token) {
+  try {
+    const exp = decodeJwtPayload(token).exp;
+    return typeof exp === "number" && Number.isFinite(exp) ? exp : null;
+  } catch {
+    return null;
+  }
+}
+export {
+  decodeJwtPayload,
+  jwtExp
+};

package/dist/direct/lock.d.ts

@@ -0,0 +1,16 @@
+export declare class LockTimeoutError extends Error {
+    readonly lockPath: string;
+    readonly timeoutMs: number;
+    constructor(lockPath: string, timeoutMs: number);
+}
+export type LockOptions = {
+    timeoutMs?: number;
+    pollMs?: number;
+    staleMs?: number;
+};
+/**
+ * Cross-process mutual exclusion via an exclusively created lock file holding `{pid, at, token}`.
+ * A lock whose holder pid is gone is taken over. `staleMs` controls the heartbeat interval and
+ * age-based recovery of malformed partial lock records; it never overrides a live holder pid.
+ */
+export declare function withFileLock<T>(lockPath: string, fn: () => Promise<T>, opts?: LockOptions): Promise<T>;