@indykish/oracle 0.9.0

package/dist/scripts/test-browser.js

@@ -0,0 +1,103 @@
+#!/usr/bin/env tsx
+/**
+ * Lightweight browser connectivity smoke test.
+ * - Launches Chrome headful with a fixed DevTools port (default 45871 or env ORACLE_BROWSER_PORT/ORACLE_BROWSER_DEBUG_PORT).
+ * - 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';
+const DEFAULT_PORT = 45871;
+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';
+function normalizePort(raw) {
+    if (!raw)
+        return null;
+    const value = Number.parseInt(raw, 10);
+    if (!Number.isFinite(value) || value <= 0 || value > 65535)
+        return null;
+    return value;
+}
+function isWsl() {
+    if (process.platform !== 'linux')
+        return false;
+    if (process.env.WSL_DISTRO_NAME)
+        return true;
+    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 match = line.match(/^nameserver\s+([0-9.]+)/);
+            if (match?.[1])
+                return match[1];
+        }
+    }
+    catch {
+        // ignore
+    }
+    return null;
+}
+function firewallHint(host, devtoolsPort) {
+    if (!isWsl())
+        return null;
+    return [
+        `DevTools port ${host}:${devtoolsPort} is blocked from WSL.`,
+        '',
+        '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');
+}
+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 });
+        if (!res.ok)
+            return false;
+        const json = (await res.json());
+        return Boolean(json.webSocketDebuggerUrl);
+    }
+    catch {
+        return false;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+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'],
+    });
+    let ok = await fetchVersion(targetHost, chrome.port);
+    if (!ok) {
+        await sleep(500);
+        ok = await fetchVersion(targetHost, chrome.port);
+    }
+    await chrome.kill();
+    if (ok) {
+        console.log(`[browser-test] PASS: DevTools responding on ${targetHost}:${chrome.port}`);
+        process.exit(0);
+    }
+    const hint = firewallHint(targetHost, chrome.port);
+    console.error(`[browser-test] FAIL: DevTools not reachable at ${targetHost}:${chrome.port}`);
+    if (hint) {
+        console.error(hint);
+    }
+    process.exit(1);
+}
+main().catch((error) => {
+    console.error('[browser-test] Unexpected failure:', error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});

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

@@ -0,0 +1,68 @@
+#!/usr/bin/env npx tsx
+/**
+ * POC: Test connecting to remote Chrome instance
+ *
+ * On remote machine with display, run:
+ *   google-chrome --remote-debugging-port=9222 --remote-debugging-address=0.0.0.0
+ *
+ * Then run this script:
+ *   npx tsx scripts/test-remote-chrome.ts <remote-host> [port]
+ */
+import CDP from 'chrome-remote-interface';
+async function main() {
+    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');
+        const { Network, Page, Runtime } = client;
+        // Enable domains
+        await Promise.all([Network.enable(), Page.enable()]);
+        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']}`);
+        // Navigate to ChatGPT
+        console.log('\nNavigating to ChatGPT...');
+        await Page.navigate({ url: 'https://chatgpt.com/' });
+        await Page.loadEventFired();
+        console.log('✓ Page loaded');
+        // Check current URL
+        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({
+            expression: `
+        // Check for composer textarea (indicates logged in)
+        const composer = document.querySelector('textarea, [contenteditable="true"]');
+        const hasComposer = !!composer;
+
+        // Check for login button (indicates logged out)
+        const loginBtn = document.querySelector('a[href*="login"], button[data-testid*="login"]');
+        const hasLogin = !!loginBtn;
+
+        ({ hasComposer, hasLogin, loggedIn: hasComposer && !hasLogin })
+      `,
+        });
+        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');
+    }
+    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.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);
+        process.exit(1);
+    }
+}
+void main();

package/dist/src/bridge/connection.js

@@ -0,0 +1,103 @@
+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(':')) {
+        return `[${unwrapped}]:${port}`;
+    }
+    return `${unwrapped}:${port}`;
+}
+export function parseHostPort(raw) {
+    const target = raw.trim();
+    if (!target) {
+        throw new Error('Expected host:port but received an empty value.');
+    }
+    const ipv6Match = target.match(/^\[(.+)]:(\d+)$/);
+    let hostname;
+    let portSegment;
+    if (ipv6Match) {
+        hostname = ipv6Match[1]?.trim();
+        portSegment = ipv6Match[2]?.trim();
+    }
+    else {
+        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(':')) {
+            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);
+    if (!Number.isFinite(port) || port <= 0 || port > 65_535) {
+        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.');
+    }
+    let url;
+    try {
+        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);
+    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() ?? '';
+    if (!token) {
+        throw new Error('Connection string is missing token. Expected "?token=...".');
+    }
+    const remoteHost = normalizeHostPort(hostname, port);
+    return { remoteHost, remoteToken: token };
+}
+export function formatBridgeConnectionString(connection, options = {}) {
+    const { hostname, port } = parseHostPort(connection.remoteHost);
+    const base = `oracle+tcp://${normalizeHostPort(hostname, port)}`;
+    if (!options.includeToken) {
+        return base;
+    }
+    const params = new URLSearchParams({ token: connection.remoteToken });
+    return `${base}?${params.toString()}`;
+}
+export function looksLikePath(value) {
+    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');
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    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') {
+        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) {
+        throw new Error(`Invalid connection artifact at ${resolved}: remoteHost is missing.`);
+    }
+    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.
+    parseHostPort(remoteHost);
+    return parsed;
+}

package/dist/src/bridge/userConfigFile.js

@@ -0,0 +1,28 @@
+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 parsed = JSON5.parse(raw);
+        return { config: parsed ?? {}, loaded: true };
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'ENOENT') {
+            return { config: {}, loaded: false };
+        }
+        throw new Error(`Failed to read ${configPath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export async function writeUserConfigFile(configPath, config) {
+    const dir = path.dirname(configPath);
+    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.rename(tempPath, configPath);
+    if (process.platform !== 'win32') {
+        await fs.chmod(configPath, 0o600).catch(() => undefined);
+    }
+}