@steipete/oracle 0.9.0 → 0.11.0

package/dist/scripts/test-browser.js

@@ -5,14 +5,15 @@
  * - Verifies the DevTools /json/version endpoint responds.
  * - Prints a WSL-friendly firewall hint if the port is unreachable.
  */
-import { setTimeout as sleep } from 'node:timers/promises';
-import { launch } from 'chrome-launcher';
-import os from 'node:os';
-import { readFileSync } from 'node:fs';
+import { setTimeout as sleep } from "node:timers/promises";
+import { launch } from "chrome-launcher";
+import os from "node:os";
+import { readFileSync } from "node:fs";
 const DEFAULT_PORT = 45871;
-const port = normalizePort(process.env.ORACLE_BROWSER_PORT ?? process.env.ORACLE_BROWSER_DEBUG_PORT) ?? DEFAULT_PORT;
+const port = normalizePort(process.env.ORACLE_BROWSER_PORT ?? process.env.ORACLE_BROWSER_DEBUG_PORT) ??
+    DEFAULT_PORT;
 const hostHint = resolveWslHost();
-const targetHost = hostHint ?? '127.0.0.1';
+const targetHost = hostHint ?? "127.0.0.1";
 function normalizePort(raw) {
     if (!raw)
         return null;
@@ -22,18 +23,18 @@ function normalizePort(raw) {
     return value;
 }
 function isWsl() {
-    if (process.platform !== 'linux')
+    if (process.platform !== "linux")
         return false;
     if (process.env.WSL_DISTRO_NAME)
         return true;
-    return os.release().toLowerCase().includes('microsoft');
+    return os.release().toLowerCase().includes("microsoft");
 }
 function resolveWslHost() {
     if (!isWsl())
         return null;
     try {
-        const resolv = readFileSync('/etc/resolv.conf', 'utf8');
-        for (const line of resolv.split('\n')) {
+        const resolv = readFileSync("/etc/resolv.conf", "utf8");
+        for (const line of resolv.split("\n")) {
             const match = line.match(/^nameserver\s+([0-9.]+)/);
             if (match?.[1])
                 return match[1];
@@ -49,19 +50,21 @@ function firewallHint(host, devtoolsPort) {
         return null;
     return [
         `DevTools port ${host}:${devtoolsPort} is blocked from WSL.`,
-        '',
-        'PowerShell (admin):',
+        "",
+        "PowerShell (admin):",
         `New-NetFirewallRule -DisplayName 'Chrome DevTools ${devtoolsPort}' -Direction Inbound -Action Allow -Protocol TCP -LocalPort ${devtoolsPort}`,
         "New-NetFirewallRule -DisplayName 'Chrome DevTools (chrome.exe)' -Direction Inbound -Action Allow -Program 'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe' -Protocol TCP",
-        '',
-        'Re-run ./runner pnpm test:browser after adding the rule.',
-    ].join('\n');
+        "",
+        "Re-run ./runner pnpm test:browser after adding the rule.",
+    ].join("\n");
 }
 async function fetchVersion(host, devtoolsPort) {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), 5000);
     try {
-        const res = await fetch(`http://${host}:${devtoolsPort}/json/version`, { signal: controller.signal });
+        const res = await fetch(`http://${host}:${devtoolsPort}/json/version`, {
+            signal: controller.signal,
+        });
         if (!res.ok)
             return false;
         const json = (await res.json());
@@ -78,7 +81,7 @@ async function main() {
     console.log(`[browser-test] launching Chrome on ${targetHost}:${port} (headful)…`);
     const chrome = await launch({
         port,
-        chromeFlags: ['--remote-debugging-address=0.0.0.0'],
+        chromeFlags: ["--remote-debugging-address=0.0.0.0"],
     });
     let ok = await fetchVersion(targetHost, chrome.port);
     if (!ok) {
@@ -98,6 +101,6 @@ async function main() {
     process.exit(1);
 }
 main().catch((error) => {
-    console.error('[browser-test] Unexpected failure:', error instanceof Error ? error.message : String(error));
+    console.error("[browser-test] Unexpected failure:", error instanceof Error ? error.message : String(error));
     process.exit(1);
 });

package/dist/scripts/test-remote-chrome.js

@@ -8,30 +8,30 @@
  * Then run this script:
  *   npx tsx scripts/test-remote-chrome.ts <remote-host> [port]
  */
-import CDP from 'chrome-remote-interface';
+import CDP from "chrome-remote-interface";
 async function main() {
-    const host = process.argv[2] || 'localhost';
-    const port = parseInt(process.argv[3] || '9222', 10);
+    const host = process.argv[2] || "localhost";
+    const port = parseInt(process.argv[3] || "9222", 10);
     console.log(`Attempting to connect to Chrome at ${host}:${port}...`);
     try {
         // Test connection
         const client = await CDP({ host, port });
-        console.log('✓ Connected to Chrome DevTools Protocol');
+        console.log("✓ Connected to Chrome DevTools Protocol");
         const { Network, Page, Runtime } = client;
         // Enable domains
         await Promise.all([Network.enable(), Page.enable()]);
-        console.log('✓ Enabled Network and Page domains');
+        console.log("✓ Enabled Network and Page domains");
         // Get browser version info
         const version = await CDP.Version({ host, port });
         console.log(`✓ Browser: ${version.Browser}`);
-        console.log(`✓ Protocol: ${version['Protocol-Version']}`);
+        console.log(`✓ Protocol: ${version["Protocol-Version"]}`);
         // Navigate to ChatGPT
-        console.log('\nNavigating to ChatGPT...');
-        await Page.navigate({ url: 'https://chatgpt.com/' });
+        console.log("\nNavigating to ChatGPT...");
+        await Page.navigate({ url: "https://chatgpt.com/" });
         await Page.loadEventFired();
-        console.log('✓ Page loaded');
+        console.log("✓ Page loaded");
         // Check current URL
-        const evalResult = await Runtime.evaluate({ expression: 'window.location.href' });
+        const evalResult = await Runtime.evaluate({ expression: "window.location.href" });
         console.log(`✓ Current URL: ${evalResult.result.value}`);
         // Check if logged in (look for specific elements)
         const checkLogin = await Runtime.evaluate({
@@ -49,19 +49,19 @@ async function main() {
         });
         console.log(`✓ Login status: ${JSON.stringify(checkLogin.result.value)}`);
         await client.close();
-        console.log('\n✓ POC successful! Remote Chrome connection works.');
-        console.log('\nTo use Oracle with remote Chrome, you would need to:');
-        console.log('1. Ensure cookies are loaded in remote Chrome');
-        console.log('2. Configure Oracle with --remote-chrome <host:port> to use this instance');
-        console.log('3. Ensure Oracle skips local Chrome launch when --remote-chrome is specified');
+        console.log("\n✓ POC successful! Remote Chrome connection works.");
+        console.log("\nTo use Oracle with remote Chrome, you would need to:");
+        console.log("1. Ensure cookies are loaded in remote Chrome");
+        console.log("2. Configure Oracle with --remote-chrome <host:port> to use this instance");
+        console.log("3. Ensure Oracle skips local Chrome launch when --remote-chrome is specified");
     }
     catch (error) {
-        console.error('✗ Connection failed:', error instanceof Error ? error.message : error);
-        console.log('\nTroubleshooting:');
-        console.log('1. Ensure Chrome is running on remote machine with:');
+        console.error("✗ Connection failed:", error instanceof Error ? error.message : error);
+        console.log("\nTroubleshooting:");
+        console.log("1. Ensure Chrome is running on remote machine with:");
         console.log(`   google-chrome --remote-debugging-port=${port} --remote-debugging-address=0.0.0.0`);
-        console.log('2. Check firewall allows connections to port', port);
-        console.log('3. Verify network connectivity to', host);
+        console.log("2. Check firewall allows connections to port", port);
+        console.log("3. Verify network connectivity to", host);
         process.exit(1);
     }
 }

package/dist/src/bridge/connection.js

@@ -1,9 +1,9 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
+import fs from "node:fs/promises";
+import path from "node:path";
 export function normalizeHostPort(hostname, port) {
     const trimmed = hostname.trim();
-    const unwrapped = trimmed.startsWith('[') && trimmed.endsWith(']') ? trimmed.slice(1, -1) : trimmed;
-    if (unwrapped.includes(':')) {
+    const unwrapped = trimmed.startsWith("[") && trimmed.endsWith("]") ? trimmed.slice(1, -1) : trimmed;
+    if (unwrapped.includes(":")) {
         return `[${unwrapped}]:${port}`;
     }
     return `${unwrapped}:${port}`;
@@ -11,7 +11,7 @@ export function normalizeHostPort(hostname, port) {
 export function parseHostPort(raw) {
     const target = raw.trim();
     if (!target) {
-        throw new Error('Expected host:port but received an empty value.');
+        throw new Error("Expected host:port but received an empty value.");
     }
     const ipv6Match = target.match(/^\[(.+)]:(\d+)$/);
     let hostname;
@@ -21,43 +21,43 @@ export function parseHostPort(raw) {
         portSegment = ipv6Match[2]?.trim();
     }
     else {
-        const lastColon = target.lastIndexOf(':');
+        const lastColon = target.lastIndexOf(":");
         if (lastColon === -1) {
             throw new Error(`Invalid host:port format: ${target}. Expected host:port (IPv6 must use [host]:port notation).`);
         }
         hostname = target.slice(0, lastColon).trim();
         portSegment = target.slice(lastColon + 1).trim();
-        if (hostname.includes(':')) {
+        if (hostname.includes(":")) {
             throw new Error(`Invalid host:port format: ${target}. Wrap IPv6 addresses in brackets, e.g. "[2001:db8::1]:9473".`);
         }
     }
     if (!hostname) {
         throw new Error(`Invalid host:port format: ${target}. Host portion is missing.`);
     }
-    const port = Number.parseInt(portSegment ?? '', 10);
+    const port = Number.parseInt(portSegment ?? "", 10);
     if (!Number.isFinite(port) || port <= 0 || port > 65_535) {
-        throw new Error(`Invalid port: "${portSegment ?? ''}". Expected a number between 1 and 65535.`);
+        throw new Error(`Invalid port: "${portSegment ?? ""}". Expected a number between 1 and 65535.`);
     }
     return { hostname, port };
 }
 export function parseBridgeConnectionString(input) {
     const raw = input.trim();
     if (!raw) {
-        throw new Error('Missing connection string.');
+        throw new Error("Missing connection string.");
     }
     let url;
     try {
-        url = raw.includes('://') ? new URL(raw) : new URL(`oracle+tcp://${raw}`);
+        url = raw.includes("://") ? new URL(raw) : new URL(`oracle+tcp://${raw}`);
     }
     catch (error) {
         throw new Error(`Invalid connection string: ${error instanceof Error ? error.message : String(error)}`);
     }
     const hostname = url.hostname?.trim();
-    const port = Number.parseInt(url.port ?? '', 10);
+    const port = Number.parseInt(url.port ?? "", 10);
     if (!hostname || !Number.isFinite(port) || port <= 0 || port > 65_535) {
         throw new Error(`Invalid connection string host: ${raw}. Expected host:port.`);
     }
-    const token = url.searchParams.get('token')?.trim() ?? '';
+    const token = url.searchParams.get("token")?.trim() ?? "";
     if (!token) {
         throw new Error('Connection string is missing token. Expected "?token=...".');
     }
@@ -74,11 +74,11 @@ export function formatBridgeConnectionString(connection, options = {}) {
     return `${base}?${params.toString()}`;
 }
 export function looksLikePath(value) {
-    return value.includes('/') || value.includes('\\') || value.endsWith('.json');
+    return value.includes("/") || value.includes("\\") || value.endsWith(".json");
 }
 export async function readBridgeConnectionArtifact(filePath) {
     const resolved = path.resolve(process.cwd(), filePath);
-    const raw = await fs.readFile(resolved, 'utf8');
+    const raw = await fs.readFile(resolved, "utf8");
     let parsed;
     try {
         parsed = JSON.parse(raw);
@@ -86,15 +86,15 @@ export async function readBridgeConnectionArtifact(filePath) {
     catch (error) {
         throw new Error(`Failed to parse connection artifact JSON at ${resolved}: ${error instanceof Error ? error.message : String(error)}`);
     }
-    if (!parsed || typeof parsed !== 'object') {
+    if (!parsed || typeof parsed !== "object") {
         throw new Error(`Invalid connection artifact at ${resolved}: expected an object.`);
     }
     const remoteHost = parsed.remoteHost;
     const remoteToken = parsed.remoteToken;
-    if (typeof remoteHost !== 'string' || remoteHost.trim().length === 0) {
+    if (typeof remoteHost !== "string" || remoteHost.trim().length === 0) {
         throw new Error(`Invalid connection artifact at ${resolved}: remoteHost is missing.`);
     }
-    if (typeof remoteToken !== 'string' || remoteToken.trim().length === 0) {
+    if (typeof remoteToken !== "string" || remoteToken.trim().length === 0) {
         throw new Error(`Invalid connection artifact at ${resolved}: remoteToken is missing.`);
     }
     // Validate host formatting early so downstream checks don't crash.

package/dist/src/bridge/userConfigFile.js

@@ -1,15 +1,15 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import JSON5 from 'json5';
+import fs from "node:fs/promises";
+import path from "node:path";
+import JSON5 from "json5";
 export async function readUserConfigFile(configPath) {
     try {
-        const raw = await fs.readFile(configPath, 'utf8');
+        const raw = await fs.readFile(configPath, "utf8");
         const parsed = JSON5.parse(raw);
         return { config: parsed ?? {}, loaded: true };
     }
     catch (error) {
         const code = error.code;
-        if (code === 'ENOENT') {
+        if (code === "ENOENT") {
             return { config: {}, loaded: false };
         }
         throw new Error(`Failed to read ${configPath}: ${error instanceof Error ? error.message : String(error)}`);
@@ -20,9 +20,9 @@ export async function writeUserConfigFile(configPath, config) {
     await fs.mkdir(dir, { recursive: true, mode: 0o700 });
     const contents = `${JSON.stringify(config, null, 2)}\n`;
     const tempPath = `${configPath}.tmp-${process.pid}-${Date.now()}`;
-    await fs.writeFile(tempPath, contents, { encoding: 'utf8', mode: 0o600 });
+    await fs.writeFile(tempPath, contents, { encoding: "utf8", mode: 0o600 });
     await fs.rename(tempPath, configPath);
-    if (process.platform !== 'win32') {
+    if (process.platform !== "win32") {
         await fs.chmod(configPath, 0o600).catch(() => undefined);
     }
 }

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

@@ -0,0 +1,224 @@
+export function isProjectChatgptUrl(url) {
+    return /\/project(?:[/?#]|$)/i.test(url ?? "");
+}
+export function resolveBrowserArchiveDecision({ mode = "auto", chatgptUrl, conversationUrl, researchMode, followUpCount, }) {
+    if (mode === "never") {
+        return { mode, shouldArchive: false, reason: "disabled" };
+    }
+    if (!conversationUrl) {
+        return { mode, shouldArchive: false, reason: "missing-conversation-url" };
+    }
+    if (mode === "always") {
+        return { mode, shouldArchive: true, reason: "forced" };
+    }
+    if (isProjectChatgptUrl(chatgptUrl) || isProjectChatgptUrl(conversationUrl)) {
+        return { mode, shouldArchive: false, reason: "project-conversation" };
+    }
+    if (researchMode === "deep") {
+        return { mode, shouldArchive: false, reason: "deep-research" };
+    }
+    if ((followUpCount ?? 0) > 0) {
+        return { mode, shouldArchive: false, reason: "multi-turn" };
+    }
+    return { mode, shouldArchive: true, reason: "successful-one-shot" };
+}
+export async function archiveChatGptConversation(Runtime, logger, { mode, conversationUrl, }) {
+    const evaluated = await Runtime.evaluate({
+        expression: buildArchiveConversationExpression(),
+        awaitPromise: true,
+        returnByValue: true,
+    });
+    const value = evaluated.result?.value;
+    const resolvedUrl = value?.conversationUrl ?? conversationUrl ?? undefined;
+    if (value?.status === "archived") {
+        logger("[browser] Archived ChatGPT conversation after saving local artifacts.");
+        return { mode, attempted: true, archived: true, conversationUrl: resolvedUrl };
+    }
+    const reason = value?.status === "skipped" ? value.reason : "archive-failed";
+    const error = value?.status === "failed" ? value.error : undefined;
+    logger(`[browser] ChatGPT archive skipped (${error ?? reason}).`);
+    return {
+        mode,
+        attempted: true,
+        archived: false,
+        reason,
+        conversationUrl: resolvedUrl,
+        error,
+    };
+}
+export function buildArchiveConversationExpressionForTest() {
+    return buildArchiveConversationExpression();
+}
+function buildArchiveConversationExpression() {
+    return `(() => {
+    const conversationUrl = typeof location === 'object' ? location.href : null;
+    const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+    const normalize = (value) =>
+      String(value ?? '')
+        .replace(/\\s+/g, ' ')
+        .trim()
+        .toLowerCase();
+    const isVisible = (element) => {
+      if (!element || !(element instanceof HTMLElement)) return false;
+      const rect = element.getBoundingClientRect();
+      const style = getComputedStyle(element);
+      return rect.width > 0 && rect.height > 0 && style.visibility !== 'hidden' && style.display !== 'none';
+    };
+    const labelFor = (element) =>
+      normalize([
+        element.getAttribute?.('aria-label'),
+        element.getAttribute?.('title'),
+        element.textContent,
+      ].filter(Boolean).join(' '));
+	    const click = (element) => {
+	      const rect = element.getBoundingClientRect();
+	      const eventInit = {
+	        bubbles: true,
+	        cancelable: true,
+	        view: window,
+	        clientX: rect.left + rect.width / 2,
+	        clientY: rect.top + rect.height / 2,
+	        button: 0,
+	      };
+	      if (typeof PointerEvent === 'function') {
+	        element.dispatchEvent(new PointerEvent('pointerdown', {
+	          ...eventInit,
+	          buttons: 1,
+	          pointerId: 1,
+	          pointerType: 'mouse',
+	          isPrimary: true,
+	        }));
+	      }
+	      element.dispatchEvent(new MouseEvent('mousedown', { ...eventInit, buttons: 1 }));
+	      if (typeof PointerEvent === 'function') {
+	        element.dispatchEvent(new PointerEvent('pointerup', {
+	          ...eventInit,
+	          buttons: 0,
+	          pointerId: 1,
+	          pointerType: 'mouse',
+	          isPrimary: true,
+	        }));
+	      }
+	      element.dispatchEvent(new MouseEvent('mouseup', { ...eventInit, buttons: 0 }));
+	      element.dispatchEvent(new MouseEvent('click', { ...eventInit, buttons: 0 }));
+	    };
+    const findConversationMenuButton = () => {
+      const buttons = Array.from(document.querySelectorAll('button,[role="button"]'))
+        .filter((element) => element instanceof HTMLElement && isVisible(element));
+      const labelled = buttons
+        .map((element) => ({ element, label: labelFor(element), rect: element.getBoundingClientRect() }))
+        .filter(({ label }) =>
+          label.includes('more') ||
+          label.includes('conversation options') ||
+          label.includes('open menu') ||
+          label.includes('więcej') ||
+          label.includes('opcje')
+        );
+      const headerCandidates = labelled
+        .filter(({ rect }) => rect.top < 180 && rect.right > window.innerWidth - 420)
+        .sort((a, b) => b.rect.right - a.rect.right);
+      return (headerCandidates[0] ?? labelled[0])?.element ?? null;
+    };
+	    const visibleMenuCandidates = () => {
+	      const menuRoots = Array.from(document.querySelectorAll('[role="menu"]'))
+	        .filter((element) => element instanceof HTMLElement && isVisible(element));
+	      const roots = menuRoots.length > 0 ? menuRoots : [document];
+	      return roots.flatMap((root) =>
+	        Array.from(root.querySelectorAll('[role="menuitem"],[role="option"],button,div[tabindex],a')),
+	      ).filter((element) => element instanceof HTMLElement && isVisible(element));
+	    };
+	    const findArchiveMenuItem = () => {
+	      const candidates = visibleMenuCandidates();
+	      return candidates.find((element) => {
+	        const label = labelFor(element);
+	        if (!label) return false;
+	        if (label.includes('unarchive') || label.includes('restore')) return false;
+	        return label.includes('archive') || label.includes('archiwizuj');
+	      }) ?? null;
+	    };
+	    const findArchiveConfirmationButton = () => {
+	      const candidates = Array.from(document.querySelectorAll('[role="dialog"] button,[role="dialog"] [role="button"]'))
+	        .filter((element) => element instanceof HTMLElement && isVisible(element));
+	      return candidates.find((element) => {
+	        const label = labelFor(element);
+	        if (!label) return false;
+	        if (label.includes('unarchive') || label.includes('restore')) return false;
+	        return label === 'archive' || label === 'archiwizuj' || label.includes('archive conversation');
+	      }) ?? null;
+	    };
+	    const hasUnarchiveMenuItem = () => {
+	      const candidates = visibleMenuCandidates();
+	      return candidates.some((element) => {
+	        const label = labelFor(element);
+	        return (
+	          label.includes('unarchive') ||
+	          label.includes('restore') ||
+	          label.includes('przywróć') ||
+	          label.includes('przywroc')
+	        );
+	      });
+	    };
+	    const hasArchiveConfirmation = () => {
+	      const visibleText = Array.from(document.querySelectorAll('[role="status"],[role="alert"],[data-testid*="toast"],[class*="toast"],[class*="snackbar"]'))
+	        .filter((element) => element instanceof HTMLElement && isVisible(element))
+	        .map((element) => labelFor(element))
+	        .join(' ');
+	      return (
+	        visibleText.includes('archived') ||
+	        visibleText.includes('conversation archived') ||
+	        visibleText.includes('chat archived') ||
+	        visibleText.includes('zarchiwizowano') ||
+	        visibleText.includes('archiwum')
+	      );
+	    };
+	    const waitForArchiveConfirmation = async () => {
+	      const deadline = Date.now() + 3000;
+	      while (Date.now() < deadline) {
+	        if (conversationUrl && location.href !== conversationUrl) return true;
+	        if (hasArchiveConfirmation()) return true;
+	        await sleep(150);
+	      }
+	      return false;
+	    };
+	    const verifyArchivedStateFromMenu = async () => {
+	      const menuButton = findConversationMenuButton();
+	      if (!menuButton) return false;
+	      click(menuButton);
+	      await sleep(300);
+	      const archived = hasUnarchiveMenuItem();
+	      document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));
+	      return archived;
+	    };
+	    return (async () => {
+	      const menuButton = findConversationMenuButton();
+      if (!menuButton) {
+        return { status: 'skipped', reason: 'conversation-menu-not-found', conversationUrl };
+      }
+      click(menuButton);
+      await sleep(350);
+      const archiveItem = findArchiveMenuItem();
+      if (!archiveItem) {
+        document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));
+        return { status: 'skipped', reason: 'archive-menu-item-not-found', conversationUrl };
+	      }
+	      click(archiveItem);
+	      await sleep(350);
+	      const confirmButton = findArchiveConfirmationButton();
+	      if (confirmButton) {
+	        click(confirmButton);
+	        await sleep(500);
+	      }
+	      if (await waitForArchiveConfirmation()) {
+	        return { status: 'archived', conversationUrl };
+	      }
+	      if (await verifyArchivedStateFromMenu()) {
+	        return { status: 'archived', conversationUrl };
+	      }
+	      return { status: 'skipped', reason: 'archive-not-confirmed', conversationUrl };
+	    })().catch((error) => ({
+      status: 'failed',
+      error: error instanceof Error ? error.message : String(error),
+      conversationUrl,
+    }));
+  })()`;
+}