pi-oracle 0.3.4 → 0.4.0

package/extensions/oracle/worker/auth-flow-helpers.d.mts

@@ -0,0 +1,41 @@
+export interface OracleAuthLoginProbe {
+  ok: boolean;
+  status: number;
+  pageUrl?: string;
+  domLoginCta?: boolean;
+  onAuthPage?: boolean;
+  error?: string;
+  bodyKeys?: string[];
+  bodyHasId?: boolean;
+  bodyHasEmail?: boolean;
+  name?: string;
+  responsePreview?: string;
+}
+
+export type OracleAuthPageState =
+  | "challenge_blocking"
+  | "login_required"
+  | "transient_outage_error"
+  | "auth_transitioning"
+  | "authenticated_and_ready"
+  | "unknown";
+
+export interface OracleAuthPageClassification {
+  state: OracleAuthPageState;
+  message: string;
+}
+
+export declare function normalizeLoginProbeResult(result: unknown): OracleAuthLoginProbe;
+export declare function buildAccountChooserCandidateLabels(name?: string): string[];
+export declare function classifyChatAuthPage(args: {
+  url: string;
+  snapshot: string;
+  body: string;
+  probe?: OracleAuthLoginProbe;
+  allowedOrigins: readonly string[];
+  cookieSourceLabel: string;
+  runtimeProfileDir: string;
+  logPath: string;
+  composerLabel?: string;
+  addFilesLabel?: string;
+}): OracleAuthPageClassification;

package/extensions/oracle/worker/auth-flow-helpers.mjs

@@ -0,0 +1,165 @@
+// Purpose: Provide pure auth-bootstrap classification helpers for ChatGPT browser state handling.
+// Responsibilities: Normalize login-probe payloads, classify ChatGPT auth page states, and derive account chooser candidate labels.
+// Scope: Pure worker/auth decision logic only; browser I/O, logging, and side effects stay in auth-bootstrap.mjs.
+// Usage: Imported by auth-bootstrap.mjs and sanity tests to exercise auth classification behavior without driving a browser.
+// Invariants/Assumptions: Inputs are already captured snapshots/probe results from the live browser session; outputs are deterministic and side-effect free.
+
+/** @typedef {import("./auth-flow-helpers.d.mts").OracleAuthLoginProbe} OracleAuthLoginProbe */
+/** @typedef {import("./auth-flow-helpers.d.mts").OracleAuthPageClassification} OracleAuthPageClassification */
+
+const DEFAULT_COMPOSER_LABEL = "Chat with ChatGPT";
+const DEFAULT_ADD_FILES_LABEL = "Add files and more";
+
+/**
+ * @param {unknown} result
+ * @returns {OracleAuthLoginProbe}
+ */
+export function normalizeLoginProbeResult(result) {
+  if (!result || typeof result !== "object") {
+    return { ok: false, status: 0, error: "invalid-probe-result" };
+  }
+  const value = /** @type {Record<string, unknown>} */ (result);
+  return {
+    ok: value.ok === true,
+    status: typeof value.status === "number" ? value.status : 0,
+    pageUrl: typeof value.pageUrl === "string" ? value.pageUrl : undefined,
+    domLoginCta: value.domLoginCta === true,
+    onAuthPage: value.onAuthPage === true,
+    error: typeof value.error === "string" ? value.error : undefined,
+    bodyKeys: Array.isArray(value.bodyKeys) ? value.bodyKeys.filter((entry) => typeof entry === "string") : [],
+    bodyHasId: value.bodyHasId === true,
+    bodyHasEmail: value.bodyHasEmail === true,
+    name: typeof value.name === "string" ? value.name : undefined,
+    responsePreview: typeof value.responsePreview === "string" ? value.responsePreview : undefined,
+  };
+}
+
+/**
+ * @param {string | undefined} name
+ * @returns {string[]}
+ */
+export function buildAccountChooserCandidateLabels(name) {
+  const normalized = typeof name === "string" ? name.trim() : "";
+  if (!normalized) return [];
+  const firstToken = normalized.split(/\s+/)[0] || "";
+  return firstToken && firstToken !== normalized ? [normalized, firstToken] : [normalized];
+}
+
+/**
+ * @param {{
+ *   url: string;
+ *   snapshot: string;
+ *   body: string;
+ *   probe?: OracleAuthLoginProbe;
+ *   allowedOrigins: readonly string[];
+ *   cookieSourceLabel: string;
+ *   runtimeProfileDir: string;
+ *   logPath: string;
+ *   composerLabel?: string;
+ *   addFilesLabel?: string;
+ * }} args
+ * @returns {OracleAuthPageClassification}
+ */
+export function classifyChatAuthPage(args) {
+  const text = `${args.snapshot}\n${args.body}`;
+  const composerLabel = args.composerLabel || DEFAULT_COMPOSER_LABEL;
+  const addFilesLabel = args.addFilesLabel || DEFAULT_ADD_FILES_LABEL;
+  const onAllowedOrigin = args.allowedOrigins.some((origin) => args.url.startsWith(origin));
+  const hasComposer = args.snapshot.includes(`textbox "${composerLabel}"`);
+  const hasAddFiles = args.snapshot.includes(`button "${addFilesLabel}"`);
+  const hasModelControl =
+    args.snapshot.includes('button "Model selector"') ||
+    /button "(Instant|Thinking|Pro)(?: [^"]*)?"/.test(args.snapshot);
+
+  const challengePatterns = [
+    /just a moment/i,
+    /verify you are human/i,
+    /cloudflare/i,
+    /captcha|turnstile|hcaptcha/i,
+    /unusual activity detected/i,
+    /we detect suspicious activity/i,
+  ];
+  if (challengePatterns.some((pattern) => pattern.test(text))) {
+    return {
+      state: "challenge_blocking",
+      message:
+        `ChatGPT challenge detected after syncing cookies from ${args.cookieSourceLabel}. ` +
+        `The isolated oracle browser was left open on profile ${args.runtimeProfileDir}; complete the challenge there, then rerun /oracle-auth. Logs: ${args.logPath}`,
+    };
+  }
+
+  if (/http error 431|request header or cookie too large/i.test(text)) {
+    return {
+      state: "login_required",
+      message:
+        `Imported auth hit HTTP 431 during ChatGPT auth resolution, which usually means the imported cookie set is too large or stale. ` +
+        `Inspect ${args.logPath}.`,
+    };
+  }
+
+  const outagePatterns = [
+    /something went wrong/i,
+    /a network error occurred/i,
+    /an error occurred while connecting to the websocket/i,
+    /try again later/i,
+  ];
+  if (outagePatterns.some((pattern) => pattern.test(text))) {
+    return { state: "transient_outage_error", message: `ChatGPT is showing a transient outage/error page. Logs: ${args.logPath}` };
+  }
+
+  if (args.probe?.status === 401 || args.probe?.status === 403) {
+    return {
+      state: "login_required",
+      message:
+        `Synced cookies from ${args.cookieSourceLabel}, but ChatGPT still rejected the session ` +
+        `(status=${args.probe?.status ?? 0}). Check auth.chromeProfile/auth.chromeCookiePath and inspect ${args.logPath}.`,
+    };
+  }
+
+  if (args.probe?.onAuthPage) {
+    if (args.probe?.bodyHasId || args.probe?.bodyHasEmail) {
+      return {
+        state: "auth_transitioning",
+        message:
+          `ChatGPT is on /auth/login, but /backend-api/me returned a partial authenticated session. ` +
+          `Trying to drive the login resolution flow. Logs: ${args.logPath}`,
+      };
+    }
+    return {
+      state: "login_required",
+      message:
+        `Synced cookies from ${args.cookieSourceLabel}, but ChatGPT still rejected the session ` +
+        `(status=${args.probe?.status ?? 0}). Check auth.chromeProfile/auth.chromeCookiePath and inspect ${args.logPath}.`,
+    };
+  }
+
+  if (onAllowedOrigin && args.probe?.status === 200 && hasComposer && hasAddFiles && hasModelControl) {
+    if (!args.probe?.domLoginCta) {
+      return {
+        state: "authenticated_and_ready",
+        message: `Imported ChatGPT auth from ${args.cookieSourceLabel} into the isolated oracle profile. Logs: ${args.logPath}`,
+      };
+    }
+
+    return {
+      state: "auth_transitioning",
+      message:
+        args.probe?.bodyHasId || args.probe?.bodyHasEmail
+          ? `ChatGPT backend session is authenticated but the shell still shows public CTA chrome. Logs: ${args.logPath}`
+          : `ChatGPT accepted cookies but is still hydrating/auth-selecting. Logs: ${args.logPath}`,
+    };
+  }
+
+  if (onAllowedOrigin && args.probe?.ok && hasComposer && hasAddFiles && hasModelControl) {
+    return {
+      state: "authenticated_and_ready",
+      message: `Imported ChatGPT auth from ${args.cookieSourceLabel} into the isolated oracle profile. Logs: ${args.logPath}`,
+    };
+  }
+
+  if (args.url && !onAllowedOrigin) {
+    return { state: "login_required", message: `Imported auth redirected away from the expected ChatGPT origin. Logs: ${args.logPath}` };
+  }
+
+  return { state: "unknown", message: `ChatGPT page state is not yet ready. Logs: ${args.logPath}` };
+}

package/extensions/oracle/worker/chatgpt-flow-helpers.d.mts

@@ -0,0 +1,13 @@
+export interface OracleStableValueState {
+  lastValue: string;
+  stableCount: number;
+}
+
+export declare function assistantSnapshotSlice(snapshot: string, composerLabel: string, responseIndex: number): string | undefined;
+export declare function stripUrlQueryAndHash(url: string | undefined): string;
+export declare function isConversationPathUrl(url: string): boolean;
+export declare function resolveStableConversationUrlCandidate(url: string, previousChatUrl?: string): string | undefined;
+export declare function nextStableValueState(
+  state: Partial<OracleStableValueState> | undefined,
+  nextValue: string,
+): OracleStableValueState;

package/extensions/oracle/worker/chatgpt-flow-helpers.mjs

@@ -0,0 +1,85 @@
+// Purpose: Provide pure ChatGPT conversation-state helpers used by the oracle worker.
+// Responsibilities: Slice assistant snapshot regions, normalize URLs, and track stable conversation URL observations.
+// Scope: Pure worker flow logic only; browser I/O and polling loops stay in run-job.mjs.
+// Usage: Imported by run-job.mjs and sanity tests to validate conversation-state heuristics without driving a browser.
+// Invariants/Assumptions: Snapshot text comes from agent-browser `snapshot -i`; URL inputs may be malformed and must fail safely.
+
+/** @typedef {import("./chatgpt-flow-helpers.d.mts").OracleStableValueState} OracleStableValueState */
+
+/**
+ * @param {string} snapshot
+ * @param {string} composerLabel
+ * @param {number} responseIndex
+ * @returns {string | undefined}
+ */
+export function assistantSnapshotSlice(snapshot, composerLabel, responseIndex) {
+  const lines = snapshot.split("\n");
+  const assistantHeadingIndices = lines.flatMap((line, index) => (line.includes('heading "ChatGPT said:"') ? [index] : []));
+  const startIndex = assistantHeadingIndices[responseIndex];
+  if (startIndex === undefined) return undefined;
+
+  const endCandidates = [];
+  const nextAssistantIndex = assistantHeadingIndices[responseIndex + 1];
+  if (nextAssistantIndex !== undefined) endCandidates.push(nextAssistantIndex);
+
+  const composerIndex = lines.findIndex(
+    (line, index) => index > startIndex && line.includes(`textbox "${composerLabel}"`),
+  );
+  if (composerIndex !== -1) endCandidates.push(composerIndex);
+
+  const endIndex = endCandidates.length > 0 ? Math.min(...endCandidates) : undefined;
+  return lines.slice(startIndex, endIndex).join("\n");
+}
+
+/**
+ * @param {string | undefined} url
+ * @returns {string}
+ */
+export function stripUrlQueryAndHash(url) {
+  if (typeof url !== "string") return "";
+  try {
+    const parsed = new URL(url);
+    parsed.hash = "";
+    parsed.search = "";
+    return parsed.toString();
+  } catch {
+    return url;
+  }
+}
+
+/**
+ * @param {string} url
+ * @returns {boolean}
+ */
+export function isConversationPathUrl(url) {
+  try {
+    return /\/c\/[A-Za-z0-9-]+$/i.test(new URL(url).pathname);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * @param {string} url
+ * @param {string | undefined} previousChatUrl
+ * @returns {string | undefined}
+ */
+export function resolveStableConversationUrlCandidate(url, previousChatUrl) {
+  const normalizedUrl = stripUrlQueryAndHash(url);
+  if (!normalizedUrl) return undefined;
+  if (isConversationPathUrl(normalizedUrl)) return normalizedUrl;
+  const normalizedPrevious = stripUrlQueryAndHash(previousChatUrl);
+  return normalizedPrevious && normalizedPrevious === normalizedUrl ? normalizedUrl : undefined;
+}
+
+/**
+ * @param {Partial<OracleStableValueState> | undefined} state
+ * @param {string} nextValue
+ * @returns {OracleStableValueState}
+ */
+export function nextStableValueState(state, nextValue) {
+  return {
+    lastValue: nextValue,
+    stableCount: state?.lastValue === nextValue ? (state?.stableCount ?? 0) + 1 : 1,
+  };
+}

package/extensions/oracle/worker/chatgpt-ui-helpers.mjs

@@ -1,10 +1,24 @@
+// Purpose: Provide pure ChatGPT UI interpretation helpers shared by oracle worker/auth flows.
+// Responsibilities: Normalize allowed origins, interpret model-selection snapshots, and derive assistant-completion signatures.
+// Scope: Pure snapshot/text heuristics only; browser I/O and retry loops stay in the worker/auth entrypoints.
+// Usage: Imported by worker/auth runtime code and sanity tests to keep browser-driven logic behaviorally testable.
+// Invariants/Assumptions: Snapshot text comes from agent-browser `snapshot -i`; helper outputs must stay deterministic and side-effect free.
+
 import { parseSnapshotEntries } from "./artifact-heuristics.mjs";
 
+/** @typedef {import("./chatgpt-ui-helpers.d.mts").OracleUiModelFamily} OracleUiModelFamily */
+/** @typedef {import("./chatgpt-ui-helpers.d.mts").OracleUiSelection} OracleUiSelection */
+/** @typedef {import("./artifact-heuristics.d.mts").SnapshotEntry} SnapshotEntry */
+
+/** @typedef {{ responseText: string; artifactLabels?: string[]; suspiciousArtifactLabels?: string[] }} CompletionSignatureArgs */
+/** @typedef {{ hasStopStreaming: boolean; hasTargetCopyResponse: boolean; responseText: string; artifactLabels?: string[]; suspiciousArtifactLabels?: string[] }} DerivedCompletionSignatureArgs */
+
 export const CHATGPT_CANONICAL_APP_ORIGINS = Object.freeze([
   "https://chatgpt.com",
   "https://chat.openai.com",
 ]);
 
+/** @type {Record<OracleUiModelFamily, string>} */
 const MODEL_FAMILY_PREFIX = {
   instant: "Instant ",
   thinking: "Thinking ",
@@ -13,6 +27,10 @@ const MODEL_FAMILY_PREFIX = {
 
 const AUTO_SWITCH_LABEL = "Auto-switch to Thinking";
 
+/**
+ * @param {string | undefined} url
+ * @returns {string | undefined}
+ */
 function originFromUrl(url) {
   if (typeof url !== "string" || !url.trim()) return undefined;
   try {
@@ -22,18 +40,35 @@ function originFromUrl(url) {
   }
 }
 
+/**
+ * @param {Array<string | undefined>} values
+ * @returns {string[]}
+ */
 function uniqueStrings(values) {
   return [...new Set(values.filter((value) => typeof value === "string" && value))];
 }
 
+/**
+ * @param {string | undefined} value
+ * @returns {string | undefined}
+ */
 function titleCase(value) {
   return value ? `${value[0].toUpperCase()}${value.slice(1)}` : value;
 }
 
+/**
+ * @param {string | undefined} value
+ * @returns {string}
+ */
 function normalizeText(value) {
   return String(value || "").replace(/\s+/g, " ").trim();
 }
 
+/**
+ * @param {string} chatUrl
+ * @param {string | undefined} authUrl
+ * @returns {string[]}
+ */
 export function buildAllowedChatGptOrigins(chatUrl, authUrl) {
   return uniqueStrings([
     ...CHATGPT_CANONICAL_APP_ORIGINS,
@@ -43,6 +78,11 @@ export function buildAllowedChatGptOrigins(chatUrl, authUrl) {
   ]);
 }
 
+/**
+ * @param {string | undefined} label
+ * @param {OracleUiModelFamily} family
+ * @returns {boolean}
+ */
 export function matchesModelFamilyLabel(label, family) {
   const normalized = String(label || "");
   const prefix = MODEL_FAMILY_PREFIX[family];
@@ -50,12 +90,22 @@ export function matchesModelFamilyLabel(label, family) {
   return normalized === exact || normalized.startsWith(prefix) || normalized.startsWith(`${exact},`);
 }
 
+/**
+ * @param {OracleUiSelection} selection
+ * @returns {string | undefined}
+ */
 export function requestedEffortLabel(selection) {
   return selection?.effort ? titleCase(selection.effort) : undefined;
 }
 
+/**
+ * @param {string} snapshot
+ * @param {string | undefined} effortLabel
+ * @returns {boolean}
+ */
 export function effortSelectionVisible(snapshot, effortLabel) {
   if (!effortLabel) return true;
+  /** @type {SnapshotEntry[]} */
   const entries = parseSnapshotEntries(snapshot);
   return entries.some((entry) => {
     if (entry.disabled) return false;
@@ -72,19 +122,27 @@ export function effortSelectionVisible(snapshot, effortLabel) {
   });
 }
 
+/**
+ * @param {string} snapshot
+ * @returns {boolean}
+ */
 export function thinkingChipVisible(snapshot) {
   return /button "(?:Light|Standard|Extended|Heavy)(?: thinking)?(?:, click to remove)?"/i.test(snapshot);
 }
 
+/**
+ * @param {string} snapshot
+ * @returns {boolean}
+ */
 export function snapshotHasModelConfigurationUi(snapshot) {
+  /** @type {SnapshotEntry[]} */
   const entries = parseSnapshotEntries(snapshot);
   const visibleFamilies = new Set(
     entries
       .filter((entry) => entry.kind === "button" && typeof entry.label === "string")
       .flatMap((entry) =>
-        Object.keys(MODEL_FAMILY_PREFIX)
-          .filter((family) => matchesModelFamilyLabel(entry.label, family))
-          .map((family) => family),
+        /** @type {OracleUiModelFamily[]} */ (["instant", "thinking", "pro"])
+          .filter((family) => matchesModelFamilyLabel(entry.label, family)),
       ),
   );
   const hasCloseButton = entries.some((entry) => entry.kind === "button" && entry.label === "Close" && !entry.disabled);
@@ -94,7 +152,12 @@ export function snapshotHasModelConfigurationUi(snapshot) {
   return visibleFamilies.size >= 2 || hasCloseButton || hasEffortCombobox;
 }
 
+/**
+ * @param {string} snapshot
+ * @returns {boolean | undefined}
+ */
 export function autoSwitchToThinkingSelectionVisible(snapshot) {
+  /** @type {SnapshotEntry[]} */
   const entries = parseSnapshotEntries(snapshot);
   let foundControl = false;
 
@@ -111,6 +174,11 @@ export function autoSwitchToThinkingSelectionVisible(snapshot) {
   return foundControl ? false : undefined;
 }
 
+/**
+ * @param {string} snapshot
+ * @param {OracleUiSelection} selection
+ * @returns {boolean}
+ */
 export function snapshotCanSafelySkipModelConfiguration(snapshot, selection) {
   if (!snapshotStronglyMatchesRequestedModel(snapshot, selection)) return false;
 
@@ -126,11 +194,15 @@ export function snapshotCanSafelySkipModelConfiguration(snapshot, selection) {
   return true;
 }
 
+/**
+ * @param {string} snapshot
+ * @param {OracleUiSelection} selection
+ * @returns {boolean}
+ */
 export function snapshotStronglyMatchesRequestedModel(snapshot, selection) {
+  /** @type {SnapshotEntry[]} */
   const entries = parseSnapshotEntries(snapshot);
-  const familyMatched = entries.some((entry) => {
-    return !entry.disabled && matchesModelFamilyLabel(entry.label, selection.modelFamily);
-  });
+  const familyMatched = entries.some((entry) => !entry.disabled && matchesModelFamilyLabel(entry.label, selection.modelFamily));
   if (!familyMatched) return false;
 
   const configurationUiVisible = snapshotHasModelConfigurationUi(snapshot);
@@ -153,11 +225,15 @@ export function snapshotStronglyMatchesRequestedModel(snapshot, selection) {
   return false;
 }
 
+/**
+ * @param {string} snapshot
+ * @param {OracleUiSelection} selection
+ * @returns {boolean}
+ */
 export function snapshotWeaklyMatchesRequestedModel(snapshot, selection) {
+  /** @type {SnapshotEntry[]} */
   const entries = parseSnapshotEntries(snapshot);
-  const familyMatched = entries.some((entry) => {
-    return !entry.disabled && matchesModelFamilyLabel(entry.label, selection.modelFamily);
-  });
+  const familyMatched = entries.some((entry) => !entry.disabled && matchesModelFamilyLabel(entry.label, selection.modelFamily));
 
   if (selection.modelFamily === "thinking") {
     return familyMatched || effortSelectionVisible(snapshot, requestedEffortLabel(selection));
@@ -177,6 +253,10 @@ export function snapshotWeaklyMatchesRequestedModel(snapshot, selection) {
   return false;
 }
 
+/**
+ * @param {CompletionSignatureArgs} args
+ * @returns {string | undefined}
+ */
 export function buildAssistantCompletionSignature({ responseText, artifactLabels = [], suspiciousArtifactLabels = [] }) {
   const normalizedResponse = normalizeText(responseText);
   if (normalizedResponse) return `text:${normalizedResponse}`;
@@ -187,6 +267,10 @@ export function buildAssistantCompletionSignature({ responseText, artifactLabels
   return undefined;
 }
 
+/**
+ * @param {DerivedCompletionSignatureArgs} args
+ * @returns {string | undefined}
+ */
 export function deriveAssistantCompletionSignature({
   hasStopStreaming,
   hasTargetCopyResponse,