@steipete/oracle 0.9.0 → 0.11.0

package/dist/src/browser/actions/thinkingTime.js

@@ -1,35 +1,37 @@
-import { MENU_CONTAINER_SELECTOR, MENU_ITEM_SELECTOR } from '../constants.js';
-import { logDomFailure } from '../domDebug.js';
-import { buildClickDispatcher } from './domEvents.js';
+import { MENU_CONTAINER_SELECTOR, MENU_ITEM_SELECTOR, MODEL_BUTTON_SELECTOR, } from "../constants.js";
+import { logDomFailure } from "../domDebug.js";
+import { buildClickDispatcher } from "./domEvents.js";
 /**
- * Selects a specific thinking time level in ChatGPT's composer pill menu.
+ * Selects a specific thinking time level in ChatGPT's composer.
+ *
+ * Best-effort: if the chip / menu / option is missing (e.g. ChatGPT moved the
+ * effort selector into the per-model trailing button and we can't navigate it,
+ * or the language pack uses tokens we don't yet match), we log a debug dump
+ * and continue with whatever effort the UI defaults to.
+ *
  * @param level - The thinking time intensity: 'light', 'standard', 'extended', or 'heavy'
  */
 export async function ensureThinkingTime(Runtime, level, logger) {
     const result = await evaluateThinkingTimeSelection(Runtime, level);
     const capitalizedLevel = level.charAt(0).toUpperCase() + level.slice(1);
     switch (result?.status) {
-        case 'already-selected':
+        case "already-selected":
             logger(`Thinking time: ${result.label ?? capitalizedLevel} (already selected)`);
             return;
-        case 'switched':
+        case "switched":
             logger(`Thinking time: ${result.label ?? capitalizedLevel}`);
             return;
-        case 'chip-not-found': {
-            await logDomFailure(Runtime, logger, 'thinking-chip');
-            throw new Error('Unable to find the Thinking chip button in the composer area.');
-        }
-        case 'menu-not-found': {
-            await logDomFailure(Runtime, logger, 'thinking-time-menu');
-            throw new Error('Unable to find the Thinking time dropdown menu.');
-        }
-        case 'option-not-found': {
-            await logDomFailure(Runtime, logger, `${level}-option`);
-            throw new Error(`Unable to find the ${capitalizedLevel} option in the Thinking time menu.`);
+        case "chip-not-found":
+        case "menu-not-found":
+        case "option-not-found": {
+            await logDomFailure(Runtime, logger, `thinking-${result.status}`);
+            logger(`Thinking time: ${result.status.replaceAll("-", " ")} (requested ${capitalizedLevel}); continuing with ChatGPT default.`);
+            return;
         }
         default: {
-            await logDomFailure(Runtime, logger, 'thinking-time-unknown');
-            throw new Error(`Unknown error selecting ${capitalizedLevel} thinking time.`);
+            await logDomFailure(Runtime, logger, "thinking-time-unknown");
+            logger(`Thinking time: unknown outcome selecting ${capitalizedLevel}; continuing with ChatGPT default.`);
+            return;
         }
     }
 }
@@ -43,22 +45,22 @@ export async function ensureThinkingTimeIfAvailable(Runtime, level, logger) {
         const result = await evaluateThinkingTimeSelection(Runtime, level);
         const capitalizedLevel = level.charAt(0).toUpperCase() + level.slice(1);
         switch (result?.status) {
-            case 'already-selected':
+            case "already-selected":
                 logger(`Thinking time: ${result.label ?? capitalizedLevel} (already selected)`);
                 return true;
-            case 'switched':
+            case "switched":
                 logger(`Thinking time: ${result.label ?? capitalizedLevel}`);
                 return true;
-            case 'chip-not-found':
-            case 'menu-not-found':
-            case 'option-not-found':
+            case "chip-not-found":
+            case "menu-not-found":
+            case "option-not-found":
                 if (logger.verbose) {
-                    logger(`Thinking time: ${result.status.replaceAll('-', ' ')}; continuing with default.`);
+                    logger(`Thinking time: ${result.status.replaceAll("-", " ")}; continuing with default.`);
                 }
                 return false;
             default:
                 if (logger.verbose) {
-                    logger('Thinking time: unknown outcome; continuing with default.');
+                    logger("Thinking time: unknown outcome; continuing with default.");
                 }
                 return false;
         }
@@ -67,7 +69,7 @@ export async function ensureThinkingTimeIfAvailable(Runtime, level, logger) {
         const message = error instanceof Error ? error.message : String(error);
         if (logger.verbose) {
             logger(`Thinking time selection failed (${message}); continuing with default.`);
-            await logDomFailure(Runtime, logger, 'thinking-time');
+            await logDomFailure(Runtime, logger, "thinking-time");
         }
         return false;
     }
@@ -83,124 +85,219 @@ async function evaluateThinkingTimeSelection(Runtime, level) {
 function buildThinkingTimeExpression(level) {
     const menuContainerLiteral = JSON.stringify(MENU_CONTAINER_SELECTOR);
     const menuItemLiteral = JSON.stringify(MENU_ITEM_SELECTOR);
+    const modelButtonLiteral = JSON.stringify(MODEL_BUTTON_SELECTOR);
     const targetLevelLiteral = JSON.stringify(level.toLowerCase());
     return `(async () => {
     ${buildClickDispatcher()}
 
     const MENU_CONTAINER_SELECTOR = ${menuContainerLiteral};
     const MENU_ITEM_SELECTOR = ${menuItemLiteral};
+    const MODEL_BUTTON_SELECTOR = ${modelButtonLiteral};
     const TARGET_LEVEL = ${targetLevelLiteral};
 
-    const CHIP_SELECTORS = [
-      '[data-testid="composer-footer-actions"] button[aria-haspopup="menu"]',
-      'button.__composer-pill[aria-haspopup="menu"]',
-      '.__composer-pill-composite button[aria-haspopup="menu"]',
-    ];
+    // Bilingual matchers: English level token + observed Chinese variants.
+    const LEVEL_TOKENS = {
+      light: ['light', '轻'],
+      standard: ['standard', '标准'],
+      extended: ['extended', '扩展', '深度', '加强'],
+      heavy: ['heavy', '重度', '加重', '高'],
+    };
+    const targetTokens = LEVEL_TOKENS[TARGET_LEVEL] || [TARGET_LEVEL];
 
     const INITIAL_WAIT_MS = 150;
-    const MAX_WAIT_MS = 10000;
+    const STEP_WAIT_MS = 200;
+    const MAX_WAIT_MS = 8000;
 
+    const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+    // Keep CJK characters so we can match Chinese labels against LEVEL_TOKENS.
     const normalize = (value) => (value || '')
       .toLowerCase()
-      .replace(/[^a-z0-9]+/g, ' ')
+      .replace(/[^a-z0-9\\u4e00-\\u9fa5]+/g, ' ')
       .replace(/\\s+/g, ' ')
       .trim();
+    const matchesLevel = (text) => {
+      const t = normalize(text);
+      return targetTokens.some((tok) => t.includes(String(tok).toLowerCase()));
+    };
+    const optionIsSelected = (node) => {
+      if (!(node instanceof HTMLElement)) return false;
+      const ariaChecked = node.getAttribute('aria-checked');
+      const dataState = (node.getAttribute('data-state') || '').toLowerCase();
+      if (ariaChecked === 'true') return true;
+      return dataState === 'checked' || dataState === 'selected' || dataState === 'on';
+    };
+    const closeOpenMenus = () => {
+      try {
+        document.dispatchEvent(
+          new KeyboardEvent('keydown', { key: 'Escape', code: 'Escape', keyCode: 27, which: 27, bubbles: true }),
+        );
+      } catch {}
+    };
 
-    const findThinkingChip = () => {
-      for (const selector of CHIP_SELECTORS) {
-        const buttons = document.querySelectorAll(selector);
-        for (const btn of buttons) {
-          // Skip toggle buttons (no haspopup) - only click dropdown triggers to avoid disabling Pro mode
+    // ---------- OLD UI: standalone composer chip labelled "Thinking" ----------
+    const OLD_CHIP_SELECTORS = [
+      '[data-testid="composer-footer-actions"] button[aria-haspopup="menu"]',
+      '.__composer-pill-composite button[aria-haspopup="menu"]',
+    ];
+    const findOldChip = () => {
+      for (const selector of OLD_CHIP_SELECTORS) {
+        for (const btn of document.querySelectorAll(selector)) {
           if (btn.getAttribute?.('aria-haspopup') !== 'menu') continue;
+          // The new model picker pill also reuses .__composer-pill — skip it.
+          if (btn.matches?.(MODEL_BUTTON_SELECTOR)) continue;
           const aria = normalize(btn.getAttribute?.('aria-label') ?? '');
           const text = normalize(btn.textContent ?? '');
-          if (aria.includes('thinking') || text.includes('thinking')) {
-            return btn;
-          }
-
-          // In some cases the pill is labeled "Pro".
-          if (aria.includes('pro') || text.includes('pro')) {
-            return btn;
-          }
+          if (aria.includes('thinking') || text.includes('thinking')) return btn;
+        }
+      }
+      return null;
+    };
+    const findOldEffortMenu = () => {
+      const menus = document.querySelectorAll(MENU_CONTAINER_SELECTOR + ', [role="group"]');
+      for (const menu of menus) {
+        const label = menu.querySelector?.('.__menu-label, [class*="menu-label"]');
+        if (normalize(label?.textContent ?? '').includes('thinking time')) return menu;
+        const text = normalize(menu.textContent ?? '');
+        if (text.includes('standard') && text.includes('extended')) return menu;
+      }
+      return null;
+    };
+    const findOptionInMenu = (menu) => {
+      for (const item of menu.querySelectorAll(MENU_ITEM_SELECTOR)) {
+        if (
+          matchesLevel(item.textContent ?? '') ||
+          matchesLevel(item.getAttribute?.('aria-label') ?? '')
+        ) {
+          return item;
         }
       }
       return null;
     };
 
-    const chip = findThinkingChip();
-    if (!chip) {
+    const oldChip = findOldChip();
+    if (oldChip) {
+      dispatchClickSequence(oldChip);
+      const start = performance.now();
+      while (performance.now() - start < MAX_WAIT_MS) {
+        await sleep(100);
+        const menu = findOldEffortMenu();
+        if (!menu) continue;
+        const opt = findOptionInMenu(menu);
+        if (!opt) {
+          closeOpenMenus();
+          return { status: 'option-not-found' };
+        }
+        const already = optionIsSelected(opt);
+        const label = opt.textContent?.trim?.() || null;
+        dispatchClickSequence(opt);
+        await sleep(STEP_WAIT_MS);
+        closeOpenMenus();
+        return { status: already ? 'already-selected' : 'switched', label };
+      }
+      closeOpenMenus();
+      return { status: 'menu-not-found' };
+    }
+
+    // ---------- NEW UI: thinking effort lives inside the model picker ----------
+    // Each eligible model row carries a trailing button:
+    //   [data-model-picker-thinking-effort-action="true"] (role="menuitem", aria-haspopup="menu")
+    // Clicking it expands a submenu of effort options. We use aria-controls to
+    // resolve the submenu deterministically rather than scoring menu contents.
+    const TRAILING_SELECTOR = '[data-model-picker-thinking-effort-action="true"]';
+
+    const findModelButton = () => document.querySelector(MODEL_BUTTON_SELECTOR);
+    const findTrailingButtons = () => Array.from(document.querySelectorAll(TRAILING_SELECTOR));
+    const pickTrailingForCurrentModel = () => {
+      const trailings = findTrailingButtons();
+      if (trailings.length === 0) return null;
+      if (trailings.length === 1) return trailings[0];
+      // Prefer the trailing button whose model row is currently selected.
+      for (const t of trailings) {
+        const row = t.closest('[role="menuitem"], [role="menuitemradio"], [data-radix-collection-item]');
+        if (row && (optionIsSelected(row) || row.querySelector('[aria-checked="true"]'))) return t;
+      }
+      // Fallback: first one with non-zero box.
+      for (const t of trailings) {
+        const r = t.getBoundingClientRect?.();
+        if (r && r.width > 0 && r.height > 0) return t;
+      }
+      return trailings[0];
+    };
+
+    const modelBtn = findModelButton();
+    if (!modelBtn) {
       return { status: 'chip-not-found' };
     }
 
-    dispatchClickSequence(chip);
+    // Open model menu (idempotent — leaves it open if already open).
+    if (modelBtn.getAttribute('aria-expanded') !== 'true') {
+      dispatchClickSequence(modelBtn);
+      await sleep(INITIAL_WAIT_MS);
+    }
 
-    return new Promise((resolve) => {
-      const start = performance.now();
+    let trailing = null;
+    const trailingDeadline = performance.now() + MAX_WAIT_MS;
+    while (performance.now() < trailingDeadline) {
+      trailing = pickTrailingForCurrentModel();
+      if (trailing) break;
+      await sleep(100);
+    }
+    if (!trailing) {
+      closeOpenMenus();
+      return { status: 'chip-not-found' };
+    }
 
-      const findMenu = () => {
-        const menus = document.querySelectorAll(MENU_CONTAINER_SELECTOR + ', [role="group"]');
-        for (const menu of menus) {
-          const label = menu.querySelector?.('.__menu-label, [class*="menu-label"]');
-          if (normalize(label?.textContent ?? '').includes('thinking time')) {
-            return menu;
-          }
-          const text = normalize(menu.textContent ?? '');
-          if (text.includes('standard') && text.includes('extended')) {
-            return menu;
-          }
-        }
-        return null;
-      };
-
-      const findTargetOption = (menu) => {
-        const items = menu.querySelectorAll(MENU_ITEM_SELECTOR);
-        for (const item of items) {
-          const text = normalize(item.textContent ?? '');
-          if (text.includes(TARGET_LEVEL)) {
-            return item;
-          }
-        }
-        return null;
-      };
-
-      const optionIsSelected = (node) => {
-        if (!(node instanceof HTMLElement)) return false;
-        const ariaChecked = node.getAttribute('aria-checked');
-        const dataState = (node.getAttribute('data-state') || '').toLowerCase();
-        if (ariaChecked === 'true') return true;
-        if (dataState === 'checked' || dataState === 'selected' || dataState === 'on') return true;
-        return false;
-      };
+    dispatchClickSequence(trailing);
+    await sleep(STEP_WAIT_MS);
 
-      const attempt = () => {
-        const menu = findMenu();
-        if (!menu) {
-          if (performance.now() - start > MAX_WAIT_MS) {
-            resolve({ status: 'menu-not-found' });
-            return;
-          }
-          setTimeout(attempt, 100);
-          return;
+    // Resolve the effort submenu via aria-controls when ChatGPT exposes it,
+    // otherwise fall back to scanning newly opened menus for our level tokens.
+    const resolveEffortMenu = () => {
+      const id = trailing.getAttribute('aria-controls');
+      if (id) {
+        const node = document.getElementById(id);
+        if (node) return node;
+      }
+      const menus = document.querySelectorAll(MENU_CONTAINER_SELECTOR + ', [role="group"]');
+      let best = null;
+      for (const menu of menus) {
+        if (menu === modelBtn || menu.contains(trailing)) continue;
+        const text = normalize(menu.textContent ?? '');
+        let hits = 0;
+        for (const tokens of Object.values(LEVEL_TOKENS)) {
+          if (tokens.some((tok) => text.includes(String(tok).toLowerCase()))) hits += 1;
         }
+        if (hits >= 2 && (!best || hits > best.hits)) best = { menu, hits };
+      }
+      return best?.menu ?? null;
+    };
 
-        const targetOption = findTargetOption(menu);
-        if (!targetOption) {
-          resolve({ status: 'option-not-found' });
-          return;
-        }
+    let effortMenu = null;
+    const effortDeadline = performance.now() + MAX_WAIT_MS;
+    while (performance.now() < effortDeadline) {
+      effortMenu = resolveEffortMenu();
+      if (effortMenu) break;
+      await sleep(100);
+    }
+    if (!effortMenu) {
+      closeOpenMenus();
+      return { status: 'menu-not-found' };
+    }
 
-        const alreadySelected =
-          optionIsSelected(targetOption) ||
-          optionIsSelected(targetOption.querySelector?.('[aria-checked="true"], [data-state="checked"], [data-state="selected"]'));
-        const label = targetOption.textContent?.trim?.() || null;
-        dispatchClickSequence(targetOption);
-        resolve({ status: alreadySelected ? 'already-selected' : 'switched', label });
-      };
+    const targetOption = findOptionInMenu(effortMenu);
+    if (!targetOption) {
+      closeOpenMenus();
+      return { status: 'option-not-found' };
+    }
 
-      setTimeout(attempt, INITIAL_WAIT_MS);
-    });
+    const already = optionIsSelected(targetOption);
+    const label = targetOption.textContent?.trim?.() || null;
+    dispatchClickSequence(targetOption);
+    await sleep(STEP_WAIT_MS);
+    closeOpenMenus();
+    return { status: already ? 'already-selected' : 'switched', label };
   })()`;
 }
-export function buildThinkingTimeExpressionForTest(level = 'extended') {
+export function buildThinkingTimeExpressionForTest(level = "extended") {
     return buildThinkingTimeExpression(level);
 }

package/dist/src/browser/artifacts.js

@@ -0,0 +1,150 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { getOracleHomeDir } from "../oracleHome.js";
+const ARTIFACTS_DIRNAME = "artifacts";
+function sanitizePathSegment(value, fallback) {
+    const sanitized = value
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-|-$/g, "")
+        .slice(0, 80);
+    return sanitized || fallback;
+}
+function normalizeSessionId(sessionId) {
+    return sanitizePathSegment(path.basename(sessionId), "session");
+}
+export function resolveSessionArtifactsDir(sessionId) {
+    return path.join(getOracleHomeDir(), "sessions", normalizeSessionId(sessionId), ARTIFACTS_DIRNAME);
+}
+async function pathExists(targetPath) {
+    try {
+        await fs.access(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function resolveUniquePath(basePath) {
+    const ext = path.extname(basePath);
+    const stem = ext ? path.basename(basePath, ext) : path.basename(basePath);
+    const dir = path.dirname(basePath);
+    let candidate = basePath;
+    let suffix = 2;
+    while (await pathExists(candidate)) {
+        candidate = path.join(dir, `${stem}-${suffix}${ext}`);
+        suffix += 1;
+    }
+    return candidate;
+}
+async function readSizeBytes(targetPath) {
+    try {
+        return (await fs.stat(targetPath)).size;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function writeTextBrowserArtifact(params) {
+    const text = params.contents.trim();
+    if (!params.sessionId || text.length === 0) {
+        return null;
+    }
+    const dir = resolveSessionArtifactsDir(params.sessionId);
+    await fs.mkdir(dir, { recursive: true });
+    const filename = sanitizePathSegment(params.filename, "artifact.md");
+    const targetPath = await resolveUniquePath(path.join(dir, filename));
+    await fs.writeFile(targetPath, `${text}\n`, "utf8");
+    params.logger?.(`[browser] Saved ${params.kind} artifact to ${targetPath}`);
+    return {
+        kind: params.kind,
+        path: targetPath,
+        label: params.label,
+        mimeType: params.mimeType ?? "text/markdown",
+        sizeBytes: await readSizeBytes(targetPath),
+        sourceUrl: params.sourceUrl,
+    };
+}
+function isToolOnlyPlaceholder(text) {
+    const normalized = text.toLowerCase().replace(/\s+/g, " ").trim();
+    return (normalized === "called tool" ||
+        normalized === "used tool" ||
+        normalized === "użyto narzędzia" ||
+        normalized === "narzędzie wywołane");
+}
+export async function saveDeepResearchReportArtifact(params) {
+    const report = params.reportMarkdown.trim();
+    if (report.length < 40 || isToolOnlyPlaceholder(report)) {
+        return null;
+    }
+    return writeTextBrowserArtifact({
+        sessionId: params.sessionId,
+        kind: "deep-research-report",
+        filename: "deep-research-report.md",
+        contents: report,
+        label: "Deep Research report",
+        mimeType: "text/markdown",
+        sourceUrl: params.conversationUrl,
+        logger: params.logger,
+    });
+}
+export async function saveBrowserTranscriptArtifact(params) {
+    const answer = params.answerMarkdown.trim();
+    if (!answer) {
+        return null;
+    }
+    const artifactLines = params.artifacts && params.artifacts.length > 0
+        ? [
+            "",
+            "## Artifacts",
+            "",
+            ...params.artifacts.map((artifact) => {
+                const label = artifact.label ?? artifact.kind;
+                return `- ${label}: ${artifact.path}`;
+            }),
+        ]
+        : [];
+    const conversationLines = params.conversationUrl
+        ? ["", `Conversation: ${params.conversationUrl}`, ""]
+        : ["", ""];
+    const body = [
+        "# Oracle Browser Transcript",
+        ...conversationLines,
+        "## Prompt",
+        "",
+        params.prompt.trim(),
+        "",
+        "## Answer",
+        "",
+        answer,
+        ...artifactLines,
+    ].join("\n");
+    return writeTextBrowserArtifact({
+        sessionId: params.sessionId,
+        kind: "transcript",
+        filename: "transcript.md",
+        contents: body,
+        label: "Browser transcript",
+        mimeType: "text/markdown",
+        sourceUrl: params.conversationUrl,
+        logger: params.logger,
+    });
+}
+export function appendArtifacts(existing, additions) {
+    const merged = new Map();
+    for (const artifact of existing ?? []) {
+        merged.set(`${artifact.kind}:${artifact.path}`, artifact);
+    }
+    for (const artifact of additions) {
+        if (artifact) {
+            merged.set(`${artifact.kind}:${artifact.path}`, artifact);
+        }
+    }
+    const values = Array.from(merged.values());
+    return values.length > 0 ? values : undefined;
+}
+export const __test__ = {
+    normalizeSessionId,
+    sanitizePathSegment,
+};

package/dist/src/browser/attachRunning.js

@@ -0,0 +1,31 @@
+import { discoverDevToolsActivePortCandidates, } from "./detect.js";
+export async function resolveAttachRunningConnection(config, logger) {
+    const host = config.remoteChrome?.host ?? "127.0.0.1";
+    const port = config.remoteChrome?.port ?? 9222;
+    if (config.chromePath) {
+        logger("Note: --browser-chrome-path is ignored when --browser-attach-running is enabled.");
+    }
+    logger(config.remoteChrome
+        ? `Using explicit attach-running target ${host}:${port}.`
+        : `Using default attach-running target ${host}:${port}.`);
+    const candidates = (await discoverDevToolsActivePortCandidates({ host }))
+        .filter((candidate) => candidate.port === port)
+        .sort(compareDevToolsCandidates);
+    if (candidates.length === 0) {
+        throw new Error(`No running browser with attach metadata matched ${host}:${port}. Enable remote debugging in chrome://inspect/#remote-debugging first.`);
+    }
+    const candidate = candidates[0];
+    logger(`Selected attach-running browser metadata from ${candidate.path}`);
+    return {
+        host,
+        port: candidate.port,
+        browserWSEndpoint: candidate.browserWSEndpoint,
+        profileRoot: candidate.profileRoot,
+    };
+}
+function compareDevToolsCandidates(left, right) {
+    if (right.mtimeMs !== left.mtimeMs) {
+        return right.mtimeMs - left.mtimeMs;
+    }
+    return left.path.localeCompare(right.path);
+}