@wlv-zedd/dsh-chatgpt-web 1.0.0 → 1.0.2

package/src/adapters/chatgpt-web/compaction-transaction.ts

@@ -1,142 +1,142 @@
-import { randomBytes } from "node:crypto";
-
-export interface CompactionTransactionHandle {
-  token: string;
-  handoffId: string;
-}
-
-interface TransactionWaiter {
-  resolve: (summary: string) => void;
-  reject: (error: Error) => void;
-  signal?: AbortSignal;
-  onAbort?: () => void;
-}
-
-interface CompactionTransaction extends CompactionTransactionHandle {
-  traceId: string;
-  summary?: string;
-  waiter?: TransactionWaiter;
-  timer?: ReturnType<typeof setTimeout>;
-}
-
-function opaqueId(prefix: "control" | "handoff"): string {
-  return `${prefix}_${randomBytes(16).toString("hex")}`;
-}
-
-/** One-shot capability store for the summary only; it never owns a Codex tool environment. */
-export class CompactionTransactionStore {
-  private readonly transactions = new Map<string, CompactionTransaction>();
-
-  begin(traceId: string, ttlMs: number): CompactionTransactionHandle {
-    if (!traceId.trim()) throw new Error("compaction transaction trace id is required");
-    if (!Number.isFinite(ttlMs) || ttlMs <= 0) {
-      throw new Error("compaction transaction TTL must be a positive finite number");
-    }
-    const transaction: CompactionTransaction = {
-      token: opaqueId("control"),
-      handoffId: opaqueId("handoff"),
-      traceId,
-    };
-    transaction.timer = setTimeout(() => {
-      this.finishError(transaction, new Error("compaction transaction timed out"));
-    }, ttlMs);
-    transaction.timer.unref?.();
-    this.transactions.set(transaction.token, transaction);
-    return { token: transaction.token, handoffId: transaction.handoffId };
-  }
-
-  submit(token: string, handoffId: string, summary: string): void {
-    const transaction = this.transactions.get(token);
-    if (!transaction) throw new Error("compaction control token is invalid, expired, or consumed");
-    if (transaction.summary !== undefined) throw new Error("compaction handoff was already submitted");
-    if (handoffId !== transaction.handoffId) {
-      throw new Error("compaction handoff id does not match the pending transaction");
-    }
-    const normalized = summary.trim();
-    if (!normalized) throw new Error("compaction handoff summary is empty");
-    transaction.summary = normalized;
-    console.info(`[chatgpt-web] broker trace=${transaction.traceId} accepted structured compaction handoff`);
-    if (transaction.timer) clearTimeout(transaction.timer);
-    transaction.timer = undefined;
-    if (transaction.waiter) this.consume(transaction);
-  }
-
-  wait(token: string, signal?: AbortSignal): Promise<string> {
-    const transaction = this.transactions.get(token);
-    if (!transaction) return Promise.reject(new Error("compaction control token is invalid, expired, or consumed"));
-    if (transaction.waiter) return Promise.reject(new Error("compaction transaction already has a waiter"));
-    if (transaction.summary !== undefined) return Promise.resolve(this.consume(transaction));
-    if (signal?.aborted) {
-      const error = new DOMException("compaction transaction aborted", "AbortError");
-      this.finishError(transaction, error);
-      return Promise.reject(error);
-    }
-    return new Promise<string>((resolve, reject) => {
-      const waiter: TransactionWaiter = { resolve, reject, ...(signal ? { signal } : {}) };
-      if (signal) {
-        waiter.onAbort = () => this.finishError(
-          transaction,
-          new DOMException("compaction transaction aborted", "AbortError"),
-        );
-        signal.addEventListener("abort", waiter.onAbort, { once: true });
-      }
-      transaction.waiter = waiter;
-    });
-  }
-
-  abort(token: string): void {
-    const transaction = this.transactions.get(token);
-    if (!transaction) return;
-    if (transaction.summary !== undefined) {
-      this.transactions.delete(token);
-      if (transaction.timer) clearTimeout(transaction.timer);
-      transaction.timer = undefined;
-      this.detachWaiter(transaction);
-      transaction.waiter = undefined;
-      return;
-    }
-    this.finishError(transaction, new Error("compaction transaction aborted"));
-  }
-
-  abortTrace(traceId: string): void {
-    for (const transaction of [...this.transactions.values()]) {
-      if (transaction.traceId === traceId && transaction.summary === undefined) {
-        this.finishError(transaction, new Error("compaction transaction was revoked"));
-      }
-    }
-  }
-
-  close(): void {
-    for (const transaction of [...this.transactions.values()]) {
-      this.finishError(transaction, new Error("compaction transaction broker closed"));
-    }
-  }
-
-  private consume(transaction: CompactionTransaction): string {
-    if (transaction.summary === undefined) throw new Error("compaction transaction is not ready");
-    const summary = transaction.summary;
-    const waiter = transaction.waiter;
-    this.transactions.delete(transaction.token);
-    this.detachWaiter(transaction);
-    transaction.waiter = undefined;
-    waiter?.resolve(summary);
-    return summary;
-  }
-
-  private finishError(transaction: CompactionTransaction, error: Error): void {
-    if (!this.transactions.delete(transaction.token)) return;
-    if (transaction.timer) clearTimeout(transaction.timer);
-    transaction.timer = undefined;
-    const waiter = transaction.waiter;
-    this.detachWaiter(transaction);
-    transaction.waiter = undefined;
-    waiter?.reject(error);
-  }
-
-  private detachWaiter(transaction: CompactionTransaction): void {
-    const waiter = transaction.waiter;
-    if (waiter?.signal && waiter.onAbort) {
-      waiter.signal.removeEventListener("abort", waiter.onAbort);
-    }
-  }
-}
+import { randomBytes } from "node:crypto";
+
+export interface CompactionTransactionHandle {
+  token: string;
+  handoffId: string;
+}
+
+interface TransactionWaiter {
+  resolve: (summary: string) => void;
+  reject: (error: Error) => void;
+  signal?: AbortSignal;
+  onAbort?: () => void;
+}
+
+interface CompactionTransaction extends CompactionTransactionHandle {
+  traceId: string;
+  summary?: string;
+  waiter?: TransactionWaiter;
+  timer?: ReturnType<typeof setTimeout>;
+}
+
+function opaqueId(prefix: "control" | "handoff"): string {
+  return `${prefix}_${randomBytes(16).toString("hex")}`;
+}
+
+/** One-shot capability store for the summary only; it never owns a Codex tool environment. */
+export class CompactionTransactionStore {
+  private readonly transactions = new Map<string, CompactionTransaction>();
+
+  begin(traceId: string, ttlMs: number): CompactionTransactionHandle {
+    if (!traceId.trim()) throw new Error("compaction transaction trace id is required");
+    if (!Number.isFinite(ttlMs) || ttlMs <= 0) {
+      throw new Error("compaction transaction TTL must be a positive finite number");
+    }
+    const transaction: CompactionTransaction = {
+      token: opaqueId("control"),
+      handoffId: opaqueId("handoff"),
+      traceId,
+    };
+    transaction.timer = setTimeout(() => {
+      this.finishError(transaction, new Error("compaction transaction timed out"));
+    }, ttlMs);
+    transaction.timer.unref?.();
+    this.transactions.set(transaction.token, transaction);
+    return { token: transaction.token, handoffId: transaction.handoffId };
+  }
+
+  submit(token: string, handoffId: string, summary: string): void {
+    const transaction = this.transactions.get(token);
+    if (!transaction) throw new Error("compaction control token is invalid, expired, or consumed");
+    if (transaction.summary !== undefined) throw new Error("compaction handoff was already submitted");
+    if (handoffId !== transaction.handoffId) {
+      throw new Error("compaction handoff id does not match the pending transaction");
+    }
+    const normalized = summary.trim();
+    if (!normalized) throw new Error("compaction handoff summary is empty");
+    transaction.summary = normalized;
+    console.info(`[chatgpt-web] broker trace=${transaction.traceId} accepted structured compaction handoff`);
+    if (transaction.timer) clearTimeout(transaction.timer);
+    transaction.timer = undefined;
+    if (transaction.waiter) this.consume(transaction);
+  }
+
+  wait(token: string, signal?: AbortSignal): Promise<string> {
+    const transaction = this.transactions.get(token);
+    if (!transaction) return Promise.reject(new Error("compaction control token is invalid, expired, or consumed"));
+    if (transaction.waiter) return Promise.reject(new Error("compaction transaction already has a waiter"));
+    if (transaction.summary !== undefined) return Promise.resolve(this.consume(transaction));
+    if (signal?.aborted) {
+      const error = new DOMException("compaction transaction aborted", "AbortError");
+      this.finishError(transaction, error);
+      return Promise.reject(error);
+    }
+    return new Promise<string>((resolve, reject) => {
+      const waiter: TransactionWaiter = { resolve, reject, ...(signal ? { signal } : {}) };
+      if (signal) {
+        waiter.onAbort = () => this.finishError(
+          transaction,
+          new DOMException("compaction transaction aborted", "AbortError"),
+        );
+        signal.addEventListener("abort", waiter.onAbort, { once: true });
+      }
+      transaction.waiter = waiter;
+    });
+  }
+
+  abort(token: string): void {
+    const transaction = this.transactions.get(token);
+    if (!transaction) return;
+    if (transaction.summary !== undefined) {
+      this.transactions.delete(token);
+      if (transaction.timer) clearTimeout(transaction.timer);
+      transaction.timer = undefined;
+      this.detachWaiter(transaction);
+      transaction.waiter = undefined;
+      return;
+    }
+    this.finishError(transaction, new Error("compaction transaction aborted"));
+  }
+
+  abortTrace(traceId: string): void {
+    for (const transaction of [...this.transactions.values()]) {
+      if (transaction.traceId === traceId && transaction.summary === undefined) {
+        this.finishError(transaction, new Error("compaction transaction was revoked"));
+      }
+    }
+  }
+
+  close(): void {
+    for (const transaction of [...this.transactions.values()]) {
+      this.finishError(transaction, new Error("compaction transaction broker closed"));
+    }
+  }
+
+  private consume(transaction: CompactionTransaction): string {
+    if (transaction.summary === undefined) throw new Error("compaction transaction is not ready");
+    const summary = transaction.summary;
+    const waiter = transaction.waiter;
+    this.transactions.delete(transaction.token);
+    this.detachWaiter(transaction);
+    transaction.waiter = undefined;
+    waiter?.resolve(summary);
+    return summary;
+  }
+
+  private finishError(transaction: CompactionTransaction, error: Error): void {
+    if (!this.transactions.delete(transaction.token)) return;
+    if (transaction.timer) clearTimeout(transaction.timer);
+    transaction.timer = undefined;
+    const waiter = transaction.waiter;
+    this.detachWaiter(transaction);
+    transaction.waiter = undefined;
+    waiter?.reject(error);
+  }
+
+  private detachWaiter(transaction: CompactionTransaction): void {
+    const waiter = transaction.waiter;
+    if (waiter?.signal && waiter.onAbort) {
+      waiter.signal.removeEventListener("abort", waiter.onAbort);
+    }
+  }
+}

package/src/adapters/chatgpt-web/concurrency.ts

@@ -1,6 +1,6 @@
-/**
- * ChatGPT Web concurrency is deliberately bounded. Every active Codex turn owns a real
- * browser document in the signed-in account, so unbounded fan-out would create account-level
- * traffic that is indistinguishable from spam.
- */
-export const MAX_CHATGPT_BROWSER_TABS = 5;
+/**
+ * ChatGPT Web concurrency is deliberately bounded. Every active Codex turn owns a real
+ * browser document in the signed-in account, so unbounded fan-out would create account-level
+ * traffic that is indistinguishable from spam.
+ */
+export const MAX_CHATGPT_BROWSER_TABS = 5;

package/src/adapters/chatgpt-web/conversation-key.ts

@@ -1,58 +1,58 @@
-import { createHash } from "node:crypto";
-import { SUMMARY_PREFIX } from "../../responses/compaction";
-import type { CodexParsedRequest } from "../../types";
-import { extractChatGptTurnIdentity } from "./environment";
-
-function messageText(item: Record<string, unknown>): string | undefined {
-  const content = item.content;
-  if (typeof content === "string") return content;
-  if (!Array.isArray(content)) return undefined;
-  return content.flatMap(block => {
-    if (!block || typeof block !== "object" || Array.isArray(block)) return [];
-    const text = (block as { text?: unknown }).text;
-    return typeof text === "string" ? [text] : [];
-  }).join("\n");
-}
-
-/** Native compaction remains part of the exact identity of a replayed Codex turn. */
-function compactionEpoch(input: unknown[] | undefined): unknown {
-  return input?.findLast(item => {
-    if (!item || typeof item !== "object" || Array.isArray(item)) return false;
-    const record = item as Record<string, unknown>;
-    return record.type === "compaction"
-      || record.type === "compaction_summary"
-      || record.type === "context_compaction"
-      || (record.role === "user" && messageText(record)?.startsWith(`${SUMMARY_PREFIX}\n`));
-  }) ?? null;
-}
-
-export function chatGptConversationKey(
-  parsed: CodexParsedRequest,
-  namespace: string,
-): string | undefined {
-  const identity = extractChatGptTurnIdentity(parsed);
-  if (!identity.threadId) return undefined;
-  const raw = parsed._rawBody as { input?: unknown[] } | undefined;
-  return createHash("sha256").update(JSON.stringify({
-    namespace,
-    threadId: identity.threadId,
-    modelId: parsed.modelId,
-    reasoning: parsed.options.reasoning,
-    compaction: compactionEpoch(raw?.input),
-  })).digest("hex");
-}
-
-/** Full history remains canonical; a retained epoch receives only the suffix after its last assistant reply. */
-export function retainedConversationResumeRequest(
-  parsed: CodexParsedRequest,
-): CodexParsedRequest | undefined {
-  const lastAssistant = parsed.context.messages.findLastIndex(message => message.role === "assistant");
-  if (lastAssistant < 0 || lastAssistant === parsed.context.messages.length - 1) return undefined;
-  return {
-    ...parsed,
-    context: {
-      ...parsed.context,
-      messages: parsed.context.messages.slice(lastAssistant + 1),
-    },
-  };
-}
+import { createHash } from "node:crypto";
+import { SUMMARY_PREFIX } from "../../responses/compaction";
+import type { CodexParsedRequest } from "../../types";
+import { extractChatGptTurnIdentity } from "./environment";
+
+function messageText(item: Record<string, unknown>): string | undefined {
+  const content = item.content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return undefined;
+  return content.flatMap(block => {
+    if (!block || typeof block !== "object" || Array.isArray(block)) return [];
+    const text = (block as { text?: unknown }).text;
+    return typeof text === "string" ? [text] : [];
+  }).join("\n");
+}
+
+/** Native compaction remains part of the exact identity of a replayed Codex turn. */
+function compactionEpoch(input: unknown[] | undefined): unknown {
+  return input?.findLast(item => {
+    if (!item || typeof item !== "object" || Array.isArray(item)) return false;
+    const record = item as Record<string, unknown>;
+    return record.type === "compaction"
+      || record.type === "compaction_summary"
+      || record.type === "context_compaction"
+      || (record.role === "user" && messageText(record)?.startsWith(`${SUMMARY_PREFIX}\n`));
+  }) ?? null;
+}
+
+export function chatGptConversationKey(
+  parsed: CodexParsedRequest,
+  namespace: string,
+): string | undefined {
+  const identity = extractChatGptTurnIdentity(parsed);
+  if (!identity.threadId) return undefined;
+  const raw = parsed._rawBody as { input?: unknown[] } | undefined;
+  return createHash("sha256").update(JSON.stringify({
+    namespace,
+    threadId: identity.threadId,
+    modelId: parsed.modelId,
+    reasoning: parsed.options.reasoning,
+    compaction: compactionEpoch(raw?.input),
+  })).digest("hex");
+}
+
+/** Full history remains canonical; a retained epoch receives only the suffix after its last assistant reply. */
+export function retainedConversationResumeRequest(
+  parsed: CodexParsedRequest,
+): CodexParsedRequest | undefined {
+  const lastAssistant = parsed.context.messages.findLastIndex(message => message.role === "assistant");
+  if (lastAssistant < 0 || lastAssistant === parsed.context.messages.length - 1) return undefined;
+  return {
+    ...parsed,
+    context: {
+      ...parsed.context,
+      messages: parsed.context.messages.slice(lastAssistant + 1),
+    },
+  };
+}