dsh-codex-oauth 0.2.8 → 0.3.0

package/lib/responses-request.js

@@ -0,0 +1,125 @@
+import { createHash } from "node:crypto";
+import { LlmError, fileHandleText, offloadedImageText, requestImageHandleText, requiredImageOffload } from "@deepseek-ai/dsh-llm";
+
+export const RESPONSES_REPLAY_PROTOCOL = "openai-responses-v1";
+export function wireToolName(name) {
+  return /^[A-Za-z0-9_-]{1,64}$/.test(name) ? name : `dsh_${createHash("sha256").update(name).digest("hex").slice(0,32)}`;
+}
+function wireCallId(id) {
+  if (typeof id !== "string" || !id) throw new LlmError("Tool call ID must be a non-empty string", "INVALID_REQUEST");
+  // Older adapters store composite IDs. Hash the whole ID to keep calls with a shared prefix distinct.
+  return /^[A-Za-z0-9_-]{1,64}$/.test(id) ? id : `call_dsh_${createHash("sha256").update(id).digest("hex").slice(0,40)}`;
+}
+export function toolMap(tools = []) {
+  const names = new Map();
+  for (const tool of tools) {
+    const wire = wireToolName(tool.name);
+    if (names.has(wire)) throw new LlmError("Duplicate or conflicting tool names", "INVALID_REQUEST");
+    names.set(wire, tool.name);
+  }
+  return names;
+}
+export const blockFingerprint = (block) => createHash("sha256").update(JSON.stringify(block)).digest("hex");
+
+function nativeReplay(block, metadata, binding, source) {
+  const state = source?.replayState;
+  if (state?.response?.protocol !== RESPONSES_REPLAY_PROTOCOL || state.response.clientId !== binding.clientId
+    || source.provider !== "openai-codex" || source.model !== binding.model || state.response.model !== binding.model
+    || metadata?.fingerprint !== blockFingerprint(block)) return undefined;
+  const item = metadata.item;
+  if (!item || typeof item !== "object" || !["message", "function_call", "reasoning"].includes(item.type)) return undefined;
+  if (block.type === "reasoning" && item.type !== "reasoning") return undefined;
+  if (block.type === "tool-call" && (item.type !== "function_call" || item.call_id !== String(block.id)
+    || item.name !== wireToolName(block.name) || item.arguments !== block.arguments)) return undefined;
+  if (block.type === "text" && (item.type !== "message" || item.content?.length !== 1
+    || (item.content[0].text ?? item.content[0].refusal) !== block.text)) return undefined;
+  return structuredClone(item);
+}
+
+function appendItem(input, item) {
+  const last = input.at(-1);
+  if (item.type === "message" && item.id && last?.type === "message" && last.id === item.id) last.content.push(...item.content);
+  else input.push(item);
+}
+
+export async function responsesRequest(options, binding, attachments, resolveAccess) {
+  // DSH's summarizer always supplies maxTokens. This route cannot enforce an
+  // output cap, so omit that internal budget rather than disabling compaction.
+  for (const key of ["temperature", "maxTokens", "stop"]) {
+    if (key === "maxTokens" && options.purpose === "compaction") continue;
+    if (options[key] !== undefined) throw new LlmError(`ChatGPT plan usage does not support ${key}; leave it unset`, "UNSUPPORTED_OPTION");
+  }
+  const names = toolMap(options.tools);
+  if (binding.info.reasoning?.efforts.length && options.reasoningEffort !== undefined
+    && !binding.info.reasoning.efforts.some((level) => level.id === options.reasoningEffort)) throw new LlmError("The selected model does not advertise that reasoning effort", "UNSUPPORTED_OPTION");
+  const versions = new Map();
+  for (const message of options.messages) for (const block of message.content) {
+    if (block.type !== "image" || block.offloaded) continue;
+    if (!attachments) throw new LlmError("Image input requires the DSH attachment service", "UNSUPPORTED_CONTENT");
+    if (binding.info.inputModalities && !binding.info.inputModalities.includes("image")) throw new LlmError("The selected model does not accept images", "UNSUPPORTED_CONTENT");
+    const ref = block.attachment;
+    if (!versions.has(ref.attachmentId)) {
+      const scale = Math.min(1, Math.sqrt(4_194_304 / (ref.width * ref.height)));
+      versions.set(ref.attachmentId, await attachments.readImageRequest(ref, { width: Math.max(1, Math.floor(ref.width * scale)), height: Math.max(1, Math.floor(ref.height * scale)), maxBytes: 1_048_576 }, options.signal));
+    }
+  }
+  const offloadImages = requiredImageOffload(options.messages, { representation: "base64", maxBytes: 32 * 1024 * 1024 }, (block) => versions.get(block.attachment.attachmentId)?.bytes ?? 0);
+  if (offloadImages > 0) throw new LlmError("Request images exceed the adapter's 32 MiB base64 budget", "IMAGE_OFFLOAD_REQUIRED", { offloadImages });
+  const textContent = async (blocks) => {
+    const content = [];
+    for (const block of blocks) {
+      if (block.type === "text") content.push({ type: "input_text", text: block.text });
+      else if (block.type === "image") {
+        const access = resolveAccess?.(block.attachment);
+        if (block.offloaded) content.push({ type: "input_text", text: offloadedImageText(block.attachment, access) });
+        else {
+          const version = versions.get(block.attachment.attachmentId);
+          content.push({ type: "input_text", text: requestImageHandleText(block.attachment, version, access) });
+          content.push({ type: "input_image", image_url: `data:${version.mediaType};base64,${Buffer.from(version.data).toString("base64")}`, detail: "auto" });
+        }
+      } else if (block.type === "file") {
+        const access = attachments?.fileHostPath?.(block.attachment);
+        content.push({ type: "input_text", text: fileHandleText(block.attachment, access ? resolveAccess?.(block.attachment, access)?.readonlyPath : undefined) });
+      } else if (!["tool-addition", "tool-removal"].includes(block.type)) throw new LlmError(`Unsupported ${block.type} in request content`, "UNSUPPORTED_CONTENT");
+    }
+    return content;
+  };
+  const input = [];
+  let instructions = options.system;
+  const messages = options.messages;
+  for (const [messageIndex, message] of messages.entries()) {
+    options.signal?.throwIfAborted();
+    if (!["assistant", "tool", "system", "developer", "user"].includes(message.role)) throw new LlmError("Unsupported message role", "UNSUPPORTED_CONTENT");
+    if (message.role === "assistant") {
+      for (const [index, block] of message.content.entries()) {
+        const metadata = message.source?.replayState?.blocks?.[index];
+        const native = nativeReplay(block, metadata, binding, message.source);
+        if (native) {
+          if (native.type === "function_call") native.call_id = wireCallId(native.call_id);
+          appendItem(input, native); continue;
+        }
+        if (block.type === "text") input.push({ role: "assistant", content: [{ type: "output_text", text: block.text, annotations: [] }] });
+        else if (block.type === "tool-call") input.push({ type: "function_call", call_id: wireCallId(block.id), name: wireToolName(block.name), namespace: "dsh", arguments: block.arguments });
+        else if (block.type !== "reasoning") throw new LlmError(`Unsupported assistant ${block.type}`, "UNSUPPORTED_CONTENT");
+      }
+    } else if (message.role === "tool") {
+      input.push({ type: "function_call_output", call_id: wireCallId(message.source?.callId), output: await textContent(message.content) });
+    } else if (message.role === "system" && messageIndex === 0 && instructions === undefined) {
+      instructions = (await textContent(message.content)).map((part) => part.text ?? "").join("\n");
+    } else {
+      const content = await textContent(message.content);
+      if (content.length) input.push({ role: ["system", "developer"].includes(message.role) ? "developer" : "user", content });
+    }
+  }
+  return {
+    body: {
+      model: binding.model, input, store: false, stream: true,
+      ...(instructions !== undefined ? { instructions } : {}),
+      ...(options.reasoningEffort !== undefined ? { reasoning: { effort: String(options.reasoningEffort), summary: "auto" } } : {}),
+      ...(names.size ? { tools: [{ type: "namespace", name: "dsh", description: "Tools executed by DeepSeek Harness", tools: options.tools.map((tool) => ({
+        type: "function", name: wireToolName(tool.name), description: tool.description, parameters: tool.parameters, strict: false,
+      })) }] } : {}),
+    },
+    names,
+  };
+}

package/lib/responses-stream.js

@@ -0,0 +1,197 @@
+import { LlmError } from "@deepseek-ai/dsh-llm";
+import { responseError } from "./openai-http.js";
+import { blockFingerprint, RESPONSES_REPLAY_PROTOCOL } from "./responses-request.js";
+
+export async function* readSSE(body, signal, activity = () => {}) {
+  if (!body) throw new LlmError("OpenAI returned no response stream", "INVALID_RESPONSE");
+  const reader = body.getReader();
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  let buffer = "";
+  const cancel = () => { reader.cancel(signal.reason).catch(() => {}); };
+  signal?.addEventListener("abort", cancel, { once: true });
+  function parse(packet) {
+    if (packet.length > 16 * 1024 * 1024) throw new LlmError("OpenAI stream event exceeds 16 MiB", "INVALID_RESPONSE");
+    const data = packet.split(/\r\n|\n|\r/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).replace(/^ /, "")).join("\n");
+    if (!data || data === "[DONE]") return undefined;
+    let event;
+    try { event = JSON.parse(data); } catch { throw new LlmError("OpenAI returned malformed stream data", "INVALID_RESPONSE"); }
+    if (!event || typeof event.type !== "string") throw new LlmError("OpenAI returned an invalid stream event", "INVALID_RESPONSE");
+    return event;
+  }
+  try {
+    while (true) {
+      signal?.throwIfAborted();
+      const { done, value } = await reader.read();
+      signal?.throwIfAborted();
+      if (done) { buffer += decoder.decode(); break; }
+      activity();
+      buffer += decoder.decode(value, { stream: true });
+      let match;
+      while ((match = /\r\n\r\n|\n\n|\r\r/.exec(buffer))) {
+        const packet = buffer.slice(0, match.index);
+        buffer = buffer.slice(match.index + match[0].length);
+        const event = parse(packet);
+        if (event) yield event;
+      }
+      if (buffer.length > 16 * 1024 * 1024) throw new LlmError("OpenAI stream event exceeds 16 MiB", "INVALID_RESPONSE");
+    }
+    const event = parse(buffer);
+    if (event) yield event;
+  } finally {
+    signal?.removeEventListener("abort", cancel);
+    await reader.cancel().catch(() => {});
+    reader.releaseLock();
+  }
+}
+
+function tokenUsage(usage) {
+  if (!usage) return undefined;
+  const input = usage.input_tokens, output = usage.output_tokens;
+  const cached = usage.input_tokens_details?.cached_tokens ?? 0;
+  if (![input, output, cached].every((value) => Number.isSafeInteger(value) && value >= 0) || cached > input) {
+    throw new LlmError("OpenAI returned invalid token usage", "INVALID_RESPONSE");
+  }
+  const reasoning = usage.output_tokens_details?.reasoning_tokens;
+  return { inputTokens: input - cached, outputTokens: output,
+    ...(Number.isSafeInteger(usage.total_tokens) && usage.total_tokens === input + output ? { totalTokens: usage.total_tokens } : {}),
+    ...(cached > 0 ? { cacheReadTokens: cached } : {}),
+    ...(Number.isSafeInteger(reasoning) && reasoning >= 0 && reasoning <= output ? { reasoningTokens: reasoning } : {}),
+  };
+}
+
+export async function* responsesStream(events, binding, names, headers) {
+  const items = new Map(), blocks = new Map(), order = [];
+  const invalid = (message) => { throw new LlmError(message, "INVALID_RESPONSE"); };
+  function* start(key, type, itemIndex, partIndex) {
+    if (blocks.has(key)) return blocks.get(key);
+    const block = { index: order.length, type, itemIndex, partIndex, text: "", arguments: "", closed: false };
+    blocks.set(key, block); order.push(block);
+    yield { type: "block-start", index: block.index, blockType: type };
+    return block;
+  }
+  function toolName(item) {
+    if (item.namespace && item.namespace !== "dsh") invalid("OpenAI returned a tool call in an unexpected namespace");
+    const name = names.get(item.name);
+    if (!name) invalid("OpenAI returned a tool call that was not offered");
+    return name;
+  }
+  function* added(item, index) {
+    items.set(index, item);
+    if (item.type === "reasoning") yield* start(`${index}:reasoning`, "reasoning", index);
+    else if (item.type === "function_call") {
+      if (typeof item.call_id !== "string" || !item.call_id) invalid("OpenAI returned a tool call without a call ID");
+      const block = yield* start(`${index}:function`, "tool-call", index);
+      block.id = item.call_id; block.name = toolName(item);
+      if (!block.announced) {
+        block.announced = true;
+        block.arguments = typeof item.arguments === "string" ? item.arguments : "";
+        yield { type: "tool-call-delta", index: block.index, id: block.id, name: block.name, argumentsDelta: block.arguments };
+      }
+    } else if (item.type !== "message") invalid(`Unsupported OpenAI output item: ${item.type}`);
+  }
+  function* text(key, type, itemIndex, partIndex, delta) {
+    if (typeof delta !== "string") invalid("OpenAI returned a non-text delta");
+    const block = yield* start(key, type, itemIndex, partIndex);
+    if (block.closed) invalid("OpenAI sent a delta after a completed block");
+    block.text += delta;
+    yield { type: type === "text" ? "text-delta" : "reasoning-delta", index: block.index, text: delta };
+  }
+  function* close(block, item, part) {
+    if (block.closed) return;
+    let content, native;
+    if (block.type === "tool-call") {
+      const args = item.arguments;
+      if (typeof args !== "string" || !args.startsWith(block.arguments)) invalid("OpenAI returned inconsistent tool-call arguments");
+      const rest = args.slice(block.arguments.length);
+      if (rest) yield { type: "tool-call-delta", index: block.index, id: block.id, argumentsDelta: rest };
+      try { const parsed = JSON.parse(args); if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error(); }
+      catch { invalid("OpenAI returned invalid tool-call arguments"); }
+      content = { type: "tool-call", id: block.id, name: block.name, arguments: args };
+      native = { ...item, namespace: "dsh" };
+    } else {
+      const final = block.type === "reasoning" ? (item.summary ?? []).map((part) => part.text ?? "").join("\n\n") : part?.text ?? part?.refusal ?? "";
+      if (!final.startsWith(block.text)) invalid("OpenAI returned inconsistent response text");
+      const rest = final.slice(block.text.length);
+      if (rest) yield { type: block.type === "text" ? "text-delta" : "reasoning-delta", index: block.index, text: rest };
+      content = { type: block.type, text: final };
+      native = block.type === "reasoning" ? item : { ...item, content: [part] };
+    }
+    block.closed = true; block.content = content;
+    block.replay = { fingerprint: blockFingerprint(content), item: structuredClone(native) };
+    yield { type: "block-end", index: block.index, block: content };
+  }
+  function* done(item, index) {
+    if (!items.has(index)) yield* added(item, index);
+    items.set(index, item);
+    if (item.type === "message") {
+      if (!Array.isArray(item.content)) invalid("OpenAI returned a message without content");
+      for (const [partIndex, part] of item.content.entries()) {
+        if (!["output_text", "refusal"].includes(part.type)) invalid(`Unsupported OpenAI message content: ${part.type}`);
+        const block = yield* start(`${index}:text:${partIndex}`, "text", index, partIndex);
+        yield* close(block, item, part);
+      }
+    } else {
+      const block = blocks.get(`${index}:${item.type === "reasoning" ? "reasoning" : "function"}`);
+      if (!block) invalid("OpenAI returned inconsistent output item types");
+      yield* close(block, item);
+    }
+  }
+  for await (const event of events) {
+    const index = event.output_index;
+    if ((event.type.startsWith("response.output_item.") || ["response.content_part.added", "response.output_text.delta", "response.refusal.delta", "response.reasoning_summary_text.delta", "response.function_call_arguments.delta"].includes(event.type))
+      && (!Number.isSafeInteger(index) || index < 0)) invalid("OpenAI returned an invalid output index");
+    if (["response.content_part.added", "response.output_text.delta", "response.refusal.delta"].includes(event.type)
+      && (!Number.isSafeInteger(event.content_index) || event.content_index < 0)) invalid("OpenAI returned an invalid content index");
+    switch (event.type) {
+      case "response.output_item.added": yield* added(event.item, index); break;
+      case "response.output_item.done": yield* done(event.item, index); break;
+      case "response.content_part.added":
+        if (["output_text", "refusal"].includes(event.part?.type)) yield* start(`${index}:text:${event.content_index}`, "text", index, event.content_index);
+        break;
+      case "response.output_text.delta":
+      case "response.refusal.delta": yield* text(`${index}:text:${event.content_index}`, "text", index, event.content_index, event.delta); break;
+      case "response.reasoning_summary_text.delta": {
+        const block = yield* start(`${index}:reasoning`, "reasoning", index);
+        if (block.lastSummaryIndex !== undefined && block.lastSummaryIndex !== event.summary_index) yield* text(`${index}:reasoning`, "reasoning", index, undefined, "\n\n");
+        block.lastSummaryIndex = event.summary_index;
+        yield* text(`${index}:reasoning`, "reasoning", index, undefined, event.delta);
+        break;
+      }
+      case "response.function_call_arguments.delta": {
+        const block = blocks.get(`${index}:function`);
+        if (!block || block.closed || typeof event.delta !== "string") invalid("OpenAI returned an invalid tool-call delta");
+        block.arguments += event.delta;
+        yield { type: "tool-call-delta", index: block.index, id: block.id, argumentsDelta: event.delta };
+        break;
+      }
+      case "response.failed": {
+        const usage = tokenUsage(event.response?.usage);
+        if (usage) yield { type: "usage", usage };
+        throw responseError({ error: event.response?.error }, undefined, headers);
+      }
+      case "error": throw responseError({ error: event }, undefined, headers);
+      case "response.incomplete": {
+        const usage = tokenUsage(event.response?.usage);
+        if (usage) yield { type: "usage", usage };
+        if (event.response?.incomplete_details?.reason !== "max_output_tokens") throw new LlmError("OpenAI response ended incomplete", "INCOMPLETE_RESPONSE", { requestId: headers?.get("x-request-id") ?? undefined });
+        yield { type: "finish", reason: { kind: "max-tokens" } };
+        return;
+      }
+      case "response.completed": {
+        const response = event.response;
+        if (!response || (response.status && response.status !== "completed") || !Array.isArray(response.output)) invalid("OpenAI returned an invalid completed response");
+        for (const [itemIndex, item] of response.output.entries()) yield* done(item, itemIndex);
+        if (order.some((block) => !block.closed)) invalid("OpenAI completed a response with unfinished blocks");
+        const usage = tokenUsage(response.usage);
+        if (usage) yield { type: "usage", usage };
+        if (!order.some((block) => block.type === "tool-call" || (block.type === "text" && block.content.text.trim()))) throw new LlmError("OpenAI completed a response without visible content or tool calls", "EMPTY_RESPONSE");
+        yield { type: "finish", reason: { kind: order.some((block) => block.type === "tool-call") ? "tool-calls" : "stop" }, replayState: {
+          response: { protocol: RESPONSES_REPLAY_PROTOCOL, clientId: binding.clientId, model: binding.model, id: response.id },
+          blocks: order.map((block) => block.replay),
+        } };
+        return;
+      }
+    }
+  }
+  throw new LlmError("OpenAI stream ended without a terminal response event", "TRANSPORT", { requestId: headers?.get("x-request-id") ?? undefined });
+}

package/lib/safe-message.js

@@ -1,7 +1,7 @@
 export function safeMessage(error) {
   return String(error?.message ?? error)
     .replace(/\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/gu, "[redacted token]")
-    .replace(/([?&](?:code|token|refresh_token|access_token|id_token)=)[^&#\s]+/giu, "$1[redacted]")
+    .replace(/([?&](?:code|token|refresh_token|access_token|id_token|id_token_hint)=)[^&#\s]+/giu, "$1[redacted]")
     .replace(/(["']?(?:access_token|refresh_token|id_token|authorization_code|code_verifier|token|code)["']?\s*[:=]\s*)("[^"]*"|'[^']*'|[^,}\s]+)/giu, "$1[redacted]")
     .replace(/(\bBearer\s+)[^\s,]+/giu, "$1[redacted]")
     .slice(0, 500);

package/lib/store.js

@@ -1,15 +1,16 @@
+import { randomUUID } from "node:crypto";
 import { chmod, lstat, mkdir, readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { withFileLock, writeFileAtomic } from "@deepseek-ai/dsh-atomic-write";
 
 export const OPENAI_CODEX_PROVIDER = "openai-codex";
-export const OPENAI_CODEX_AUTH_FILE = ".openai-codex-auth.json";
+export const OPENAI_CODEX_AUTH_FILE = ".openai-codex-auth.v2.json";
+const CREDENTIAL_LOCK_WAIT_MS = 60_000;
 export function authPath(home = process.env.DSH_HOME || join(homedir(), ".dsh")) {
   return resolve(join(home, OPENAI_CODEX_AUTH_FILE));
 }
 
-function clone(value) { return value === undefined ? undefined : structuredClone(value); }
 async function privateDirectory(filename) {
   const directory = dirname(filename);
   await mkdir(directory, { recursive: true, mode: 0o700 });
@@ -27,47 +28,99 @@ async function ownerOnly(filename) {
     } catch (error) { if (error?.code !== "ENOENT") throw error; }
   }
 }
-function parse(text, filename) {
-  let value;
-  try { value = JSON.parse(text); } catch { throw new Error(`${filename} is not valid JSON`); }
-  const credential = value?.credential;
-  if (value?.version !== 1 || !credential || credential.type !== "oauth") throw new Error(`${filename} has an invalid auth format`);
-  for (const key of ["access", "refresh", "accountId"])
-    if (typeof credential[key] !== "string" || credential[key].length === 0) throw new Error(`${filename} credential is invalid`);
-  if (!Number.isFinite(credential.expires) || credential.expires <= 0) throw new Error(`${filename} expiry is invalid`);
-  return clone(credential);
+function nonempty(value) { return typeof value === "string" && value.length > 0; }
+function validate(value, filename) {
+  const invalid = () => { throw new Error(`${filename} has an invalid auth format`); };
+  if (value?.version !== 2 || !/^urn:uuid:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value.hostId) || !Array.isArray(value.registrations)
+    || (value.generation !== undefined && (!Number.isSafeInteger(value.generation) || value.generation < 0))) invalid();
+  const ids = new Set();
+  for (const registration of value.registrations) {
+    if (!nonempty(registration.clientId) || registration.clientId === "dynamic_agent_client" || ids.has(registration.clientId)
+      || !nonempty(registration.subject) || registration.issuer !== "https://auth.openai.com") invalid();
+    ids.add(registration.clientId);
+    if (registration.access !== undefined && (!nonempty(registration.access) || !nonempty(registration.idToken)
+      || !Number.isFinite(registration.expires) || registration.expires <= 0 || !Array.isArray(registration.scopes)
+      || registration.scopes.some((scope) => !nonempty(scope)))) invalid();
+    if (registration.refresh !== undefined && !nonempty(registration.refresh)) invalid();
+  }
+  if (value.activeClientId !== undefined && !ids.has(value.activeClientId)) invalid();
+  return value;
+}
+
+export function activeRegistration(document) {
+  return document?.registrations.find((registration) => registration.clientId === document.activeClientId);
+}
+export function clearTokens(registration) {
+  for (const key of ["access", "refresh", "idToken", "expires", "scopes", "earliestRefreshAt"]) delete registration[key];
 }
 
 export class CodexCredentialStore {
+  #listeners = new Set();
   constructor(filename = authPath()) { this.filename = filename; }
-  async readCurrent() {
+  async readDocument() {
     await privateDirectory(this.filename);
     await ownerOnly(this.filename);
-    try { return parse(await readFile(this.filename, "utf8"), this.filename); }
-    catch (error) { if (error?.code === "ENOENT") return undefined; throw error; }
+    try {
+      const text = await readFile(this.filename, "utf8");
+      let document;
+      try { document = JSON.parse(text); } catch { throw new Error(`${this.filename} is not valid JSON`); }
+      return validate(document, this.filename);
+    } catch (error) { if (error?.code === "ENOENT") return undefined; throw error; }
   }
-  async read(providerId) { return providerId === OPENAI_CODEX_PROVIDER ? this.readCurrent() : undefined; }
-  async list() { return (await this.readCurrent()) ? [{ providerId: OPENAI_CODEX_PROVIDER, type: "oauth" }] : []; }
-  async modify(providerId, fn) {
-    if (providerId !== OPENAI_CODEX_PROVIDER) throw new Error(`credential store does not own ${providerId}`);
+  async initialize() { return this.transaction((document) => structuredClone(document)); }
+  async read(providerId) {
+    if (providerId !== OPENAI_CODEX_PROVIDER) return undefined;
+    const registration = activeRegistration(await this.readDocument());
+    return registration?.access ? registration : undefined;
+  }
+  async list() { return await this.read(OPENAI_CODEX_PROVIDER) ? [{ providerId: OPENAI_CODEX_PROVIDER, type: "oauth" }] : []; }
+  subscribe(listener) { this.#listeners.add(listener); return () => this.#listeners.delete(listener); }
+  async transaction(fn) {
     await privateDirectory(this.filename);
     return withFileLock(this.filename, async () => {
-      const current = await this.readCurrent();
-      const next = await fn(clone(current));
+      const saved = await this.readDocument();
+      const document = saved ?? { version: 2, hostId: `urn:uuid:${randomUUID()}`, registrations: [] };
+      const before = JSON.stringify(document);
+      const result = await fn(document);
+      validate(document, this.filename);
+      if (!saved || before !== JSON.stringify(document)) {
+        await writeFileAtomic(this.filename, `${JSON.stringify(document, null, 2)}\n`, { mode: 0o600, dirMode: 0o700 });
+        const registration = activeRegistration(document);
+        for (const listener of this.#listeners) {
+          try { listener({ clientId: document.activeClientId, authenticated: !!registration?.access }); } catch { /* Observers cannot undo a saved credential. */ }
+        }
+      }
+      return structuredClone(result);
+    }, { waitMs: CREDENTIAL_LOCK_WAIT_MS });
+  }
+  async modify(providerId, fn) {
+    if (providerId !== OPENAI_CODEX_PROVIDER) throw new Error(`credential store does not own ${providerId}`);
+    return this.transaction(async (document) => {
+      const current = activeRegistration(document);
+      const next = await fn(current ? structuredClone(current) : undefined);
       if (next === undefined) return current;
-      const document = { version: 1, credential: next };
-      parse(JSON.stringify(document), this.filename);
-      await writeFileAtomic(this.filename, `${JSON.stringify(document, null, 2)}\n`, { mode: 0o600, dirMode: 0o700 });
-      return clone(next);
+      const existing = document.registrations.find((registration) => registration.clientId === next.clientId);
+      if (existing && existing.subject !== next.subject) throw new Error("OAuth registration identity changed");
+      if (existing) Object.assign(existing, next);
+      else document.registrations.push(next);
+      if (document.activeClientId !== next.clientId) document.generation = (document.generation ?? 0) + 1;
+      document.activeClientId = next.clientId;
+      return next;
+    });
+  }
+  async select(clientId) {
+    return this.transaction((document) => {
+      if (!document.registrations.some((registration) => registration.clientId === clientId)) throw new Error("Unknown ChatGPT account registration");
+      document.activeClientId = clientId;
+      document.generation = (document.generation ?? 0) + 1;
     });
   }
   async delete(providerId) {
     if (providerId !== OPENAI_CODEX_PROVIDER) return;
-    await privateDirectory(this.filename);
-    await withFileLock(this.filename, async () => {
-      await ownerOnly(this.filename);
-      const { rm } = await import("node:fs/promises");
-      await rm(this.filename, { force: true });
+    await this.transaction((document) => {
+      const registration = activeRegistration(document);
+      if (registration) clearTokens(registration);
+      document.generation = (document.generation ?? 0) + 1;
     });
   }
 }

package/lib/web-auth.js

@@ -1,59 +1,63 @@
-import { login, logout, status } from "./auth.js";
+import { accounts, login, logout, status } from "./auth.js";
 import { safeMessage } from "./safe-message.js";
 
 export const AUTH_STATUS_PATH = "/plugins/dsh-codex-oauth/auth/status";
 export const AUTH_LOGIN_PATH = "/plugins/dsh-codex-oauth/auth/login";
 export const AUTH_LOGOUT_PATH = "/plugins/dsh-codex-oauth/auth/logout";
+export const AUTH_ACCOUNT_PATH = "/plugins/dsh-codex-oauth/auth/account";
+export const AUTH_MODELS_PATH = "/plugins/dsh-codex-oauth/auth/models";
 
+const LOOPBACK_HOSTS = new Set(["localhost", "127.0.0.1", "[::1]"]);
 function trusted(req) {
   const remote = req.socket.remoteAddress;
   if (!["127.0.0.1", "::1", "::ffff:127.0.0.1"].includes(remote)) return false;
   if (req.headers["sec-fetch-site"] === "cross-site") return false;
   if (!req.headers.host) return false;
-  if (!req.headers.origin) return true;
-  try { return new URL(req.headers.origin).host === new URL(`http://${req.headers.host}`).host; }
-  catch { return false; }
+  try {
+    const target = new URL(`http://${req.headers.host}`);
+    if (!LOOPBACK_HOSTS.has(target.hostname)) return false;
+    if (!req.headers.origin) return true;
+    return new URL(req.headers.origin).host === target.host;
+  } catch { return false; }
 }
 function json(res, statusCode, value) {
   res.writeHead(statusCode, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store", "x-content-type-options": "nosniff" });
   res.end(JSON.stringify(value));
 }
 
-export function registerWebAuth(ctx, store) {
-  let operation;
-  let cancellation;
-  let challenge;
+export function registerWebAuth(ctx, store, options = {}) {
+  let operation, cancellation, challenge;
   let state = { status: "signed-out" };
-  const update = async () => {
+  const snapshot = async () => {
     const value = await status(store);
-    state = value.authenticated ? { status: "signed-in" } : { status: "signed-out" };
-    return state;
+    return { ...value, accounts: await accounts(store), quota: options.adapter?.quotaSnapshot ? await options.adapter.quotaSnapshot() : { available: false, buckets: [] }, status: value.authenticated ? value.planUsage ? "signed-in" : "plan-disabled" : "signed-out" };
   };
-  const start = () => {
+  const update = async () => { state = await snapshot(); return state; };
+  const start = (newAccount) => {
     if (operation) return;
     const controller = new AbortController();
     cancellation = controller;
-    state = { status: "signing-in" };
+    state = { ...state, status: "signing-in" };
     challenge = undefined;
     operation = (async () => {
       try {
         await login(store, {
           signal: controller.signal,
-          prompt: async (prompt) => prompt.type === "select"
-            ? "browser"
-            : new Promise((_resolve, reject) => controller.signal.addEventListener("abort", () => reject(controller.signal.reason), { once: true })),
           notify: (event) => {
             if (event.type !== "auth_url") return;
             try {
               const url = new URL(event.url);
-              if (url.protocol !== "https:") throw new Error("OAuth URL must use HTTPS");
+              if (url.origin !== "https://auth.openai.com") throw new Error("Unexpected OAuth endpoint");
+              // Account selection still works without sending a retained ID token to the UI.
+              url.searchParams.delete("id_token_hint");
               challenge = { url: url.href };
             } catch (error) { controller.abort(error); }
           },
-        });
+        }, { ...options.auth, newAccount });
         await update();
       } catch (error) {
-        state = controller.signal.aborted ? { status: "signed-out" } : { status: "error", message: safeMessage(error) };
+        const current = await snapshot().catch(() => ({ authenticated: false }));
+        state = controller.signal.aborted ? current : { ...current, status: "error", message: safeMessage(error) };
       } finally {
         if (cancellation === controller) cancellation = undefined;
         operation = undefined;
@@ -61,33 +65,43 @@ export function registerWebAuth(ctx, store) {
     })();
   };
   ctx.inject(["webServer"], (web) => ctx.effect(() => {
+    const guarded = (method, handler) => async (req, res) => {
+      if (req.method !== method || !trusted(req)) return json(res, req.method === method ? 403 : 405, { error: "forbidden" });
+      try { await handler(req, res); } catch (error) { json(res, 500, { error: safeMessage(error) }); }
+    };
+    const query = (req) => new URL(req.url ?? "/", "http://127.0.0.1").searchParams;
     const routes = [
-      web.webServer.register({ kind: "exact", path: AUTH_STATUS_PATH, handler: async (req, res) => {
-        if (req.method !== "GET" || !trusted(req)) return json(res, req.method === "GET" ? 403 : 405, { error: "forbidden" });
-        try {
-          if (!operation) await update();
-          json(res, 200, state);
-        } catch (error) { json(res, 500, { error: safeMessage(error) }); }
-      }}),
-      web.webServer.register({ kind: "exact", path: AUTH_LOGIN_PATH, handler: async (req, res) => {
-        if (req.method !== "POST" || !trusted(req)) return json(res, req.method === "POST" ? 403 : 405, { error: "forbidden" });
-        try {
-          start();
-          for (let i = 0; i < 50 && !challenge && operation; i++) await new Promise((resolve) => setTimeout(resolve, 100));
-          if (!challenge) throw new Error("OAuth URL was not created");
-          json(res, 200, challenge);
-        } catch (error) { json(res, 500, { error: safeMessage(error) }); }
-      }}),
-      web.webServer.register({ kind: "exact", path: AUTH_LOGOUT_PATH, handler: async (req, res) => {
-        if (req.method !== "POST" || !trusted(req)) return json(res, req.method === "POST" ? 403 : 405, { error: "forbidden" });
-        try {
-          cancellation?.abort(new Error("sign-in cancelled"));
-          await operation?.catch(() => {});
-          await logout(store);
-          state = { status: "signed-out" };
-          json(res, 200, { ok: true });
-        } catch (error) { json(res, 500, { error: safeMessage(error) }); }
-      }}),
+      web.webServer.register({ kind: "exact", path: AUTH_STATUS_PATH, handler: guarded("GET", async (_req, res) => {
+        if (!operation && state.status !== "error") await update();
+        json(res, 200, state);
+      }) }),
+      web.webServer.register({ kind: "exact", path: AUTH_LOGIN_PATH, handler: guarded("POST", async (req, res) => {
+        start(query(req).get("new_account") === "1");
+        for (let i = 0; i < 50 && !challenge && operation; i++) await new Promise((resolve) => setTimeout(resolve, 100));
+        if (!challenge) throw new Error("OAuth URL was not created");
+        json(res, 200, challenge);
+      }) }),
+      web.webServer.register({ kind: "exact", path: AUTH_LOGOUT_PATH, handler: guarded("POST", async (_req, res) => {
+        const signingIn = !!operation;
+        cancellation?.abort(new Error("sign-in cancelled"));
+        await operation?.catch(() => {});
+        // Cancelling a new sign-in must not revoke the previously active account.
+        const result = signingIn ? { remoteRevoked: true } : await logout(store, options.auth);
+        await update();
+        json(res, 200, { ok: true, ...result });
+      }) }),
+      web.webServer.register({ kind: "exact", path: AUTH_ACCOUNT_PATH, handler: guarded("POST", async (req, res) => {
+        cancellation?.abort(new Error("account changed"));
+        await operation?.catch(() => {});
+        await store.select(query(req).get("client_id"));
+        json(res, 200, await update());
+      }) }),
+      web.webServer.register({ kind: "exact", path: AUTH_MODELS_PATH, handler: guarded("POST", async (_req, res) => {
+        if (!options.adapter) throw new Error("Model adapter is unavailable");
+        const models = await options.adapter.listModels("openai-codex", { refresh: true });
+        options.adapter.options.onModelsChanged?.();
+        json(res, 200, { models });
+      }) }),
     ];
     return async () => {
       cancellation?.abort(new Error("plugin disposed"));