@steipete/oracle 0.10.0 → 0.11.1

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

@@ -0,0 +1,391 @@
+import { formatElapsed } from "../../oracle/format.js";
+import { ASSISTANT_ROLE_SELECTOR, CONVERSATION_TURN_SELECTOR } from "../constants.js";
+const THINKING_STALE_HINT_MS = 10 * 60_000;
+export function startThinkingStatusMonitor(Runtime, logger, options = {}) {
+    const intervalMs = resolveThinkingStatusInterval(options.intervalMs);
+    if (!intervalMs) {
+        return () => { };
+    }
+    const now = options.now ?? Date.now;
+    let stopped = false;
+    let pending = false;
+    let lastFingerprint = null;
+    let lastChangedAt = now();
+    const startedAt = now();
+    const interval = setInterval(async () => {
+        // stop flag flips asynchronously
+        if (stopped || pending) {
+            return;
+        }
+        pending = true;
+        try {
+            const snapshot = await readThinkingStatus(Runtime);
+            if (stopped) {
+                return;
+            }
+            const tickAt = now();
+            if (snapshot) {
+                const fingerprint = buildThinkingStatusFingerprint(snapshot);
+                if (fingerprint !== lastFingerprint) {
+                    lastFingerprint = fingerprint;
+                    lastChangedAt = tickAt;
+                }
+                if (stopped) {
+                    return;
+                }
+                logger(formatThinkingLog(startedAt, tickAt, snapshot, "", tickAt - lastChangedAt));
+            }
+            else {
+                logger(formatThinkingWaitingLog(startedAt, tickAt));
+            }
+        }
+        catch {
+            // ignore DOM polling errors
+        }
+        finally {
+            pending = false;
+        }
+    }, intervalMs);
+    interval.unref?.();
+    return () => {
+        // multiple callers may race to stop
+        if (stopped) {
+            return;
+        }
+        stopped = true;
+        clearInterval(interval);
+    };
+}
+export function formatThinkingLog(startedAt, now, status, locatorSuffix, unchangedMs = 0) {
+    const elapsedMs = now - startedAt;
+    const elapsedText = formatElapsed(elapsedMs);
+    const snapshot = typeof status === "string"
+        ? { message: sanitizeThinkingText(status) || "active", source: "inline" }
+        : status;
+    const progress = typeof snapshot.progressPercent === "number" && Number.isFinite(snapshot.progressPercent)
+        ? `${Math.max(0, Math.min(100, Math.round(snapshot.progressPercent)))}% UI progress`
+        : null;
+    const prefix = progress
+        ? `[browser] ChatGPT thinking - ${progress}, ${elapsedText} elapsed`
+        : `[browser] ChatGPT thinking - ${elapsedText} elapsed`;
+    const statusLabel = snapshot.message ? `; status=${snapshot.message}` : "";
+    const changeLabel = unchangedMs > 0 ? `; last change ${formatElapsed(unchangedMs)} ago` : "";
+    const staleLabel = unchangedMs >= THINKING_STALE_HINT_MS ? "; stale-hint=no UI progress change" : "";
+    const sourceLabel = snapshot.source ? `; source=${snapshot.source}` : "";
+    return `${prefix}${statusLabel}${changeLabel}${staleLabel}${sourceLabel}${locatorSuffix}`;
+}
+export function formatThinkingWaitingLog(startedAt, now) {
+    return `[browser] Waiting for ChatGPT response - ${formatElapsed(now - startedAt)} elapsed; no thinking status detected yet.`;
+}
+function resolveThinkingStatusInterval(intervalMs) {
+    if (intervalMs === 0) {
+        return null;
+    }
+    if (typeof intervalMs === "number" && Number.isFinite(intervalMs) && intervalMs > 0) {
+        return Math.max(1000, Math.floor(intervalMs));
+    }
+    return 30_000;
+}
+function buildThinkingStatusFingerprint(snapshot) {
+    return [
+        snapshot.source,
+        snapshot.message,
+        snapshot.progressPercent == null ? "" : Math.round(snapshot.progressPercent),
+        snapshot.panelVisible ? "panel" : "",
+    ].join(":");
+}
+async function readThinkingStatus(Runtime) {
+    const expression = buildThinkingStatusExpression();
+    const { result } = await Runtime.evaluate({
+        expression,
+        awaitPromise: true,
+        returnByValue: true,
+    });
+    const value = result.value;
+    if (typeof value === "string") {
+        const sanitized = sanitizeThinkingText(value);
+        return sanitized ? { message: sanitized, source: "inline" } : null;
+    }
+    if (!value || typeof value !== "object") {
+        return null;
+    }
+    const source = value.source === "sidecar" ? "sidecar" : "inline";
+    const message = sanitizeThinkingText(value.message ?? "");
+    const progressPercent = typeof value.progressPercent === "number" && Number.isFinite(value.progressPercent)
+        ? Math.max(0, Math.min(100, value.progressPercent))
+        : undefined;
+    if (!message && progressPercent == null) {
+        return null;
+    }
+    return {
+        message: message || "active",
+        source,
+        progressPercent,
+        panelOpened: value.panelOpened === true,
+        panelVisible: value.panelVisible === true,
+    };
+}
+const SAFE_THINKING_STATUS_MESSAGES = new Set([
+    "active",
+    "thinking sidecar active",
+    "thinking sidecar opened",
+]);
+export function sanitizeThinkingText(raw) {
+    if (!raw) {
+        return "";
+    }
+    const trimmed = raw.replace(/\s+/g, " ").trim();
+    const prefixPattern = /^(pro thinking)\s*[•:\-–—]*\s*/i;
+    const normalized = prefixPattern.test(trimmed)
+        ? trimmed.replace(prefixPattern, "").trim()
+        : trimmed;
+    if (!normalized) {
+        return "";
+    }
+    const normalizedKey = normalized.toLowerCase();
+    return SAFE_THINKING_STATUS_MESSAGES.has(normalizedKey) ? normalizedKey : "active";
+}
+function buildThinkingStatusExpression() {
+    const conversationLiteral = JSON.stringify(CONVERSATION_TURN_SELECTOR);
+    const assistantLiteral = JSON.stringify(ASSISTANT_ROLE_SELECTOR);
+    const selectors = [
+        "span.loading-shimmer",
+        "span.flex.items-center.gap-1.truncate.text-start.align-middle.text-token-text-tertiary",
+        '[data-testid*="thinking"]',
+        '[data-testid*="reasoning"]',
+        '[role="status"]',
+        '[aria-live="polite"]',
+    ];
+    const keywords = ["pro thinking", "thinking", "reasoning"];
+    const selectorLiteral = JSON.stringify(selectors);
+    const keywordsLiteral = JSON.stringify(keywords);
+    return `(async () => {
+    const CONVERSATION_SELECTOR = ${conversationLiteral};
+    const ASSISTANT_SELECTOR = ${assistantLiteral};
+    const selectors = ${selectorLiteral};
+    const keywords = ${keywordsLiteral};
+    const normalize = (value) =>
+      String(value || '')
+        .normalize('NFD')
+        .replace(/[\\u0300-\\u036f]/g, '')
+        .toLowerCase()
+        .replace(/\\s+/g, ' ')
+        .trim();
+    const isVisible = (node) => {
+      if (!(node instanceof HTMLElement)) return false;
+      const rect = node.getBoundingClientRect();
+      if (!rect || rect.width <= 0 || rect.height <= 0) return false;
+      const style = window.getComputedStyle(node);
+      if (
+        style.display === 'none' ||
+        style.visibility === 'hidden' ||
+        (style.opacity !== '' && Number(style.opacity) === 0)
+      ) {
+        return false;
+      }
+      return rect.bottom >= 0 && rect.right >= 0 && rect.top <= window.innerHeight && rect.left <= window.innerWidth;
+    };
+    const labelFor = (node) =>
+      normalize([
+        node.textContent,
+        node.getAttribute?.('aria-label'),
+        node.getAttribute?.('title'),
+        node.getAttribute?.('data-testid'),
+      ].filter(Boolean).join(' '));
+    const looksLikeThinking = (node) => {
+      const label = labelFor(node);
+      return (
+        label.includes('thinking') ||
+        label.includes('reasoning') ||
+        label.includes('pro thinking') ||
+        label.includes('myslen') ||
+        label.includes('mysl') ||
+        label.includes('rozumow')
+      );
+    };
+    const isComposerAdjacent = (node) =>
+      Boolean(node.closest?.('[contenteditable="true"], textarea, [data-testid*="composer"], [id*="composer"]'));
+    const isAssistantTurn = (node) => {
+      if (!(node instanceof HTMLElement)) return false;
+      const turnAttr = (node.getAttribute('data-turn') || node.dataset?.turn || '').toLowerCase();
+      if (turnAttr === 'assistant') return true;
+      const role = (node.getAttribute('data-message-author-role') || node.dataset?.messageAuthorRole || '').toLowerCase();
+      if (role === 'assistant') return true;
+      const testId = (node.getAttribute('data-testid') || '').toLowerCase();
+      if (testId.includes('assistant')) return true;
+      return Boolean(node.querySelector(ASSISTANT_SELECTOR) || node.querySelector('[data-testid*="assistant"]'));
+    };
+    const latestAssistantTurn = () => {
+      const turns = Array.from(document.querySelectorAll(CONVERSATION_SELECTOR));
+      for (let index = turns.length - 1; index >= 0; index -= 1) {
+        if (isAssistantTurn(turns[index])) {
+          return turns[index];
+        }
+      }
+      return null;
+    };
+    const findThinkingDisclosure = (scope) => {
+      const candidates = Array.from(
+        scope.querySelectorAll(
+          [
+            'button',
+            '[role="button"]',
+            '[aria-expanded]',
+            '[data-testid*="thinking"]',
+            '[data-testid*="reasoning"]',
+          ].join(','),
+        ),
+      );
+      for (const node of candidates) {
+        if (!(node instanceof HTMLElement)) continue;
+        if (!isVisible(node) || isComposerAdjacent(node) || !looksLikeThinking(node)) continue;
+        if (node.getAttribute('aria-haspopup') === 'menu') continue;
+        if (node.dataset?.oracleThinkingProbed === 'true') continue;
+        const expanded = normalize(node.getAttribute('aria-expanded'));
+        if (expanded !== 'false') {
+          continue;
+        }
+        return node;
+      }
+      return null;
+    };
+    const findProgressPercent = (scope) => {
+      const progressNodes = Array.from(
+        scope.querySelectorAll('progress, [role="progressbar"], [aria-valuenow], [data-testid*="progress"], [class*="progress"]'),
+      );
+      const readNumeric = (raw) => {
+        if (raw == null || raw === '') return null;
+        const value = Number(String(raw).replace('%', '').trim());
+        return Number.isFinite(value) ? value : null;
+      };
+      const readStylePercent = (node) => {
+        const style = node instanceof HTMLElement ? window.getComputedStyle(node) : null;
+        if (!style) return null;
+        const widthMatch = String(node.style?.width || style.width || '').match(
+          /([0-9]+(?:\\.[0-9]+)?)%/,
+        );
+        if (widthMatch) return readNumeric(widthMatch[1]);
+        const transform = String(style.transform || '');
+        const scaleMatch = transform.match(/scaleX\\(([0-9.]+)\\)/);
+        if (scaleMatch) {
+          const scale = readNumeric(scaleMatch[1]);
+          return scale == null ? null : scale * 100;
+        }
+        const matrixMatch = transform.match(/matrix\\(([0-9.\\-]+),/);
+        if (matrixMatch) {
+          const scale = readNumeric(matrixMatch[1]);
+          return scale == null ? null : scale * 100;
+        }
+        return null;
+      };
+      for (const node of progressNodes) {
+        if (!(node instanceof HTMLElement) || !isVisible(node)) continue;
+        const ariaNow = readNumeric(node.getAttribute('aria-valuenow'));
+        if (ariaNow != null) {
+          const ariaMin = readNumeric(node.getAttribute('aria-valuemin')) ?? 0;
+          const ariaMax = readNumeric(node.getAttribute('aria-valuemax')) ?? 100;
+          const span = Math.max(ariaMax - ariaMin, 1);
+          return Math.max(0, Math.min(100, ((ariaNow - ariaMin) / span) * 100));
+        }
+        if (node instanceof HTMLProgressElement && Number.isFinite(node.value) && Number.isFinite(node.max) && node.max > 0) {
+          return Math.max(0, Math.min(100, (node.value / node.max) * 100));
+        }
+        const stylePercent = readStylePercent(node);
+        if (stylePercent != null) {
+          return Math.max(0, Math.min(100, stylePercent));
+        }
+      }
+      return null;
+    };
+    const findThinkingPanel = () => {
+      const candidates = Array.from(
+        document.querySelectorAll(
+          [
+            'aside',
+            '[role="complementary"]',
+            '[role="dialog"]',
+            '[data-testid*="thinking"]',
+            '[data-testid*="reasoning"]',
+            '[data-testid*="sidebar"]',
+            '[class*="sidecar"]',
+            '[class*="sidebar"]',
+          ].join(','),
+        ),
+      );
+      for (const node of candidates) {
+        if (!(node instanceof HTMLElement) || !isVisible(node) || isComposerAdjacent(node)) continue;
+        const rect = node.getBoundingClientRect();
+        const rightSidePanel = rect.left >= window.innerWidth * 0.35 && rect.width >= 180 && rect.height >= 120;
+        const hasProgress = findProgressPercent(node) != null;
+        if (hasProgress || (rightSidePanel && looksLikeThinking(node))) {
+          return node;
+        }
+      }
+      return null;
+    };
+    const existingPanel = findThinkingPanel();
+    if (existingPanel) {
+      return {
+        message: 'thinking sidecar active',
+        source: 'sidecar',
+        progressPercent: findProgressPercent(existingPanel),
+        panelOpened: false,
+        panelVisible: true,
+      };
+    }
+    let panelOpened = false;
+    const currentTurn = latestAssistantTurn();
+    const disclosure = currentTurn ? findThinkingDisclosure(currentTurn) : null;
+    if (disclosure) {
+      try {
+        disclosure.dataset.oracleThinkingProbed = 'true';
+        disclosure.click();
+        panelOpened = true;
+        await new Promise((resolve) => setTimeout(resolve, 200));
+      } catch {
+        // non-fatal; fall through to passive status detection
+      }
+    }
+    const panel = findThinkingPanel();
+    if (panel) {
+      const progressPercent = findProgressPercent(panel);
+      return {
+        message: panelOpened ? 'thinking sidecar opened' : 'thinking sidecar active',
+        source: 'sidecar',
+        progressPercent,
+        panelOpened,
+        panelVisible: true,
+      };
+    }
+    const nodes = new Set();
+    for (const selector of selectors) {
+      document.querySelectorAll(selector).forEach((node) => nodes.add(node));
+    }
+    for (const node of nodes) {
+      if (!(node instanceof HTMLElement)) {
+        continue;
+      }
+      const text = node.textContent?.trim();
+      if (!text) {
+        continue;
+      }
+      const classLabel = String(node.className || '').toLowerCase();
+      const dataLabel = ((node.getAttribute('data-testid') || '') + ' ' + (node.getAttribute('aria-label') || ''))
+        .toLowerCase();
+      const normalizedText = text.toLowerCase();
+      const matches = keywords.some((keyword) =>
+        normalizedText.includes(keyword) || classLabel.includes(keyword) || dataLabel.includes(keyword)
+      );
+      if (matches) {
+        return {
+          message: 'active',
+          source: 'inline',
+        };
+      }
+    }
+    return null;
+  })()`;
+}
+export const startThinkingStatusMonitorForTest = startThinkingStatusMonitor;
+export const readThinkingStatusForTest = readThinkingStatus;
+export const buildThinkingStatusExpressionForTest = buildThinkingStatusExpression;

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);
+}