@steipete/oracle 0.4.0

package/dist/src/remote/client.js

@@ -0,0 +1,128 @@
+import http from 'node:http';
+import path from 'node:path';
+import { readFile } from 'node:fs/promises';
+export function createRemoteBrowserExecutor({ host, token }) {
+    // Return a drop-in replacement for runBrowserMode so the browser session runner can stay unchanged.
+    return async function remoteBrowserExecutor(options) {
+        const payload = {
+            prompt: options.prompt,
+            attachments: await serializeAttachments(options.attachments ?? []),
+            browserConfig: options.config ?? {},
+            options: {
+                heartbeatIntervalMs: options.heartbeatIntervalMs,
+                verbose: options.verbose,
+            },
+        };
+        const body = Buffer.from(JSON.stringify(payload));
+        const { hostname, port } = parseHost(host);
+        return new Promise((resolve, reject) => {
+            const req = http.request({
+                hostname,
+                port,
+                path: '/runs',
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Content-Length': body.length,
+                    ...(token ? { authorization: `Bearer ${token}` } : {}),
+                },
+            }, (res) => {
+                if (res.statusCode !== 200) {
+                    collectError(res)
+                        .then((message) => reject(new Error(message)))
+                        .catch(reject);
+                    return;
+                }
+                res.setEncoding('utf8');
+                let buffer = '';
+                let resolved = null;
+                res.on('data', (chunk) => {
+                    buffer += chunk;
+                    let newlineIndex = buffer.indexOf('\n');
+                    while (newlineIndex !== -1) {
+                        const line = buffer.slice(0, newlineIndex).trim();
+                        buffer = buffer.slice(newlineIndex + 1);
+                        if (line.length > 0) {
+                            handleEvent(line, options, (result) => {
+                                resolved = result;
+                            }, reject);
+                        }
+                        newlineIndex = buffer.indexOf('\n');
+                    }
+                });
+                res.on('end', () => {
+                    if (resolved) {
+                        resolve(resolved);
+                        return;
+                    }
+                    reject(new Error('Remote browser run completed without a result.'));
+                });
+            });
+            req.on('error', reject);
+            req.write(body);
+            req.end();
+        });
+    };
+}
+async function serializeAttachments(attachments) {
+    const serialized = [];
+    for (const attachment of attachments) {
+        // Read the local file upfront so the remote host never touches the caller's filesystem.
+        const content = await readFile(attachment.path);
+        serialized.push({
+            fileName: path.basename(attachment.path),
+            displayPath: attachment.displayPath,
+            sizeBytes: attachment.sizeBytes,
+            contentBase64: content.toString('base64'),
+        });
+    }
+    return serialized;
+}
+function parseHost(input) {
+    const [hostname, portStr] = input.split(':');
+    const port = Number.parseInt(portStr ?? '', 10);
+    if (!hostname || Number.isNaN(port)) {
+        throw new Error(`Invalid remote host: ${input}`);
+    }
+    return { hostname, port };
+}
+function handleEvent(line, options, onResult, onError) {
+    let event;
+    try {
+        event = JSON.parse(line);
+    }
+    catch (error) {
+        onError(new Error(`Failed to parse remote event: ${error instanceof Error ? error.message : String(error)}`));
+        return;
+    }
+    if (event.type === 'log') {
+        options.log?.(event.message);
+        return;
+    }
+    if (event.type === 'error') {
+        onError(new Error(event.message));
+        return;
+    }
+    if (event.type === 'result') {
+        onResult(event.result);
+    }
+}
+function collectError(res) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        res.on('data', (chunk) => {
+            chunks.push(typeof chunk === 'string' ? Buffer.from(chunk) : chunk);
+        });
+        res.on('end', () => {
+            const raw = Buffer.concat(chunks).toString('utf8');
+            try {
+                const parsed = JSON.parse(raw);
+                resolve(parsed.error ?? `Remote host responded with status ${res.statusCode}`);
+            }
+            catch {
+                resolve(raw || `Remote host responded with status ${res.statusCode}`);
+            }
+        });
+        res.on('error', reject);
+    });
+}

package/dist/src/remote/server.js

@@ -0,0 +1,294 @@
+import http from 'node:http';
+import os from 'node:os';
+import path from 'node:path';
+import { randomBytes, randomUUID } from 'node:crypto';
+import { mkdtemp, rm, mkdir, writeFile } from 'node:fs/promises';
+import chalk from 'chalk';
+import { runBrowserMode } from '../browserMode.js';
+import { loadChromeCookies } from '../browser/chromeCookies.js';
+import { CHATGPT_URL } from '../browser/constants.js';
+import { normalizeChatgptUrl } from '../browser/utils.js';
+export async function createRemoteServer(options = {}, deps = {}) {
+    const runBrowser = deps.runBrowser ?? runBrowserMode;
+    const server = http.createServer();
+    const logger = options.logger ?? console.log;
+    const authToken = options.token ?? randomBytes(16).toString('hex');
+    const verbose = process.argv.includes('--verbose') || process.env.ORACLE_SERVE_VERBOSE === '1';
+    const color = process.stdout.isTTY
+        ? (formatter, msg) => formatter(msg)
+        : (_formatter, msg) => msg;
+    // Single-flight guard: remote Chrome can only host one run at a time, so we serialize requests.
+    let busy = false;
+    if (!process.listenerCount('unhandledRejection')) {
+        process.on('unhandledRejection', (reason) => {
+            logger(`Unhandled promise rejection in remote server: ${reason instanceof Error ? reason.message : String(reason)}`);
+        });
+    }
+    server.on('request', async (req, res) => {
+        if (req.method === 'GET' && req.url === '/status') {
+            logger('[serve] Health check /status');
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: true }));
+            return;
+        }
+        if (req.method !== 'POST' || req.url !== '/runs') {
+            res.statusCode = 404;
+            res.end();
+            return;
+        }
+        const authHeader = req.headers.authorization ?? '';
+        if (authHeader !== `Bearer ${authToken}`) {
+            if (verbose) {
+                logger(`[serve] Unauthorized /runs attempt from ${formatSocket(req)} (missing/invalid token)`);
+            }
+            res.writeHead(401, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'unauthorized' }));
+            return;
+        }
+        // biome-ignore lint/nursery/noUnnecessaryConditions: busy guard protects single-run host
+        if (busy) {
+            if (verbose) {
+                logger(`[serve] Busy: rejecting new run from ${formatSocket(req)} while another run is active`);
+            }
+            res.writeHead(409, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'busy' }));
+            return;
+        }
+        busy = true;
+        const runStartedAt = Date.now();
+        let payload = null;
+        try {
+            const body = await readRequestBody(req);
+            payload = JSON.parse(body);
+            if (payload?.browserConfig) {
+                payload.browserConfig.url = normalizeChatgptUrl(payload.browserConfig.url, CHATGPT_URL);
+            }
+        }
+        catch (_error) {
+            busy = false;
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'invalid_request' }));
+            return;
+        }
+        res.writeHead(200, { 'Content-Type': 'application/x-ndjson' });
+        const runId = randomUUID();
+        logger(`[serve] Accepted run ${runId} from ${formatSocket(req)} (prompt ${payload?.prompt?.length ?? 0} chars)`);
+        // Each run gets an isolated temp dir so attachments/logs don't collide.
+        const runDir = await mkdtemp(path.join(os.tmpdir(), `oracle-serve-${runId}-`));
+        const attachmentDir = path.join(runDir, 'attachments');
+        await mkdir(attachmentDir, { recursive: true });
+        const sendEvent = (event) => {
+            res.write(`${JSON.stringify(event)}\n`);
+        };
+        const attachments = [];
+        try {
+            const attachmentsPayload = Array.isArray(payload.attachments) ? payload.attachments : [];
+            for (const [index, attachment] of attachmentsPayload.entries()) {
+                const safeName = sanitizeName(attachment.fileName ?? `attachment-${index + 1}`);
+                const filePath = path.join(attachmentDir, safeName);
+                await writeFile(filePath, Buffer.from(attachment.contentBase64, 'base64'));
+                attachments.push({
+                    path: filePath,
+                    displayPath: attachment.displayPath,
+                    sizeBytes: attachment.sizeBytes,
+                });
+            }
+            // Reuse the existing browser logger surface so clients see the same log stream.
+            const automationLogger = ((message) => {
+                if (typeof message === 'string') {
+                    sendEvent({ type: 'log', message });
+                }
+            });
+            automationLogger.verbose = Boolean(payload.options.verbose);
+            // Remote runs always rely on the host's own Chrome profile; ignore any inline cookie transfer.
+            if (payload.browserConfig) {
+                payload.browserConfig.inlineCookies = null;
+                payload.browserConfig.inlineCookiesSource = null;
+                payload.browserConfig.cookieSync = true;
+            }
+            const result = await runBrowser({
+                prompt: payload.prompt,
+                attachments,
+                config: payload.browserConfig,
+                log: automationLogger,
+                heartbeatIntervalMs: payload.options.heartbeatIntervalMs,
+                verbose: payload.options.verbose,
+            });
+            sendEvent({ type: 'result', result: sanitizeResult(result) });
+            logger(`[serve] Run ${runId} completed in ${Date.now() - runStartedAt}ms`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            sendEvent({ type: 'error', message });
+            logger(`[serve] Run ${runId} failed after ${Date.now() - runStartedAt}ms: ${message}`);
+        }
+        finally {
+            busy = false;
+            res.end();
+            try {
+                await rm(runDir, { recursive: true, force: true });
+            }
+            catch {
+                // ignore cleanup errors
+            }
+        }
+    });
+    await new Promise((resolve) => {
+        server.listen(options.port ?? 0, options.host ?? '0.0.0.0', () => resolve());
+    });
+    const address = server.address();
+    if (!address || typeof address === 'string') {
+        throw new Error('Unable to determine server address.');
+    }
+    const reachable = formatReachableAddresses(address.address, address.port);
+    const primary = reachable[0] ?? `${address.address}:${address.port}`;
+    const extras = reachable.slice(1);
+    const also = extras.length ? `, also [${extras.join(', ')}]` : '';
+    logger(color(chalk.cyanBright.bold, `Listening at ${primary}${also}`));
+    logger(color(chalk.yellowBright, `Access token: ${authToken}`));
+    return {
+        port: address.port,
+        token: authToken,
+        async close() {
+            await new Promise((resolve, reject) => {
+                server.close((err) => (err ? reject(err) : resolve()));
+            });
+        },
+    };
+}
+export async function serveRemote(options = {}) {
+    // Warm-up: ensure this host has a ChatGPT login before accepting runs.
+    const cookies = await loadLocalChatgptCookies(console.log, CHATGPT_URL);
+    if (!cookies || cookies.length === 0) {
+        console.log('No ChatGPT cookies detected on this host.');
+        console.log('Opened chatgpt.com for login. Sign in, then restart `oracle serve` to continue.');
+        return;
+    }
+    console.log(`Detected ${cookies.length} ChatGPT cookies on this host; runs will reuse this session.`);
+    const server = await createRemoteServer(options);
+    await new Promise((resolve) => {
+        const shutdown = () => {
+            console.log('Shutting down remote service...');
+            server
+                .close()
+                .catch((error) => console.error('Failed to close remote server:', error))
+                .finally(() => resolve());
+        };
+        process.on('SIGINT', shutdown);
+        process.on('SIGTERM', shutdown);
+    });
+}
+async function readRequestBody(req) {
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(typeof chunk === 'string' ? Buffer.from(chunk) : chunk);
+    }
+    return Buffer.concat(chunks).toString('utf8');
+}
+function sanitizeName(raw) {
+    return raw.replace(/[^a-zA-Z0-9._-]/g, '_');
+}
+function sanitizeResult(result) {
+    return {
+        answerText: result.answerText,
+        answerMarkdown: result.answerMarkdown,
+        answerHtml: result.answerHtml,
+        tookMs: result.tookMs,
+        answerTokens: result.answerTokens,
+        answerChars: result.answerChars,
+        chromePid: undefined,
+        chromePort: undefined,
+        userDataDir: undefined,
+    };
+}
+function formatSocket(req) {
+    const socket = req.socket;
+    const host = socket.remoteAddress ?? 'unknown';
+    const port = socket.remotePort ?? '0';
+    return `${host}:${port}`;
+}
+function formatReachableAddresses(bindAddress, port) {
+    const ipv4 = [];
+    const ipv6 = [];
+    if (bindAddress && bindAddress !== '::' && bindAddress !== '0.0.0.0') {
+        if (bindAddress.includes(':')) {
+            ipv6.push(`[${bindAddress}]:${port}`);
+        }
+        else {
+            ipv4.push(`${bindAddress}:${port}`);
+        }
+    }
+    try {
+        const interfaces = os.networkInterfaces();
+        for (const entries of Object.values(interfaces)) {
+            if (!entries)
+                continue;
+            for (const entry of entries) {
+                const iface = entry;
+                if (!iface || iface.internal)
+                    continue;
+                const family = typeof iface.family === 'string' ? iface.family : iface.family === 4 ? 'IPv4' : iface.family === 6 ? 'IPv6' : '';
+                if (family === 'IPv4') {
+                    const addr = iface.address;
+                    if (addr.startsWith('127.'))
+                        continue;
+                    if (addr.startsWith('169.254.'))
+                        continue; // APIPA/link-local
+                    ipv4.push(`${addr}:${port}`);
+                }
+                else if (family === 'IPv6') {
+                    const addr = iface.address.toLowerCase();
+                    if (addr === '::1' || addr.startsWith('fe80:'))
+                        continue; // loopback/link-local
+                    ipv6.push(`[${iface.address}]:${port}`);
+                }
+            }
+        }
+    }
+    catch {
+        // network interface probing can fail in locked-down environments; ignore
+    }
+    // de-dup
+    return Array.from(new Set([...ipv4, ...ipv6]));
+}
+async function loadLocalChatgptCookies(logger, targetUrl) {
+    try {
+        logger('Loading ChatGPT cookies from this host\'s Chrome profile...');
+        const cookies = await Promise.resolve(loadChromeCookies({
+            targetUrl,
+            profile: 'Default',
+        })).catch((error) => {
+            logger(`Unable to load local ChatGPT cookies on this host: ${error instanceof Error ? error.message : String(error)}`);
+            return [];
+        });
+        if (!cookies || cookies.length === 0) {
+            logger('No local ChatGPT cookies found on this host. Please log in once; opening ChatGPT...');
+            triggerLocalLoginPrompt(logger, targetUrl);
+            return null;
+        }
+        logger(`Loaded ${cookies.length} local ChatGPT cookies on this host.`);
+        return cookies;
+    }
+    catch (error) {
+        logger(`Unable to load local ChatGPT cookies on this host: ${error instanceof Error ? error.message : String(error)}`);
+        triggerLocalLoginPrompt(logger, targetUrl);
+        return null;
+    }
+}
+function triggerLocalLoginPrompt(logger, url) {
+    const opener = process.platform === 'darwin'
+        ? 'open'
+        : process.platform === 'win32'
+            ? 'start'
+            : 'xdg-open';
+    try {
+        // Fire and forget; user completes login in the opened browser window.
+        void import('node:child_process').then(({ spawn }) => {
+            spawn(opener, [url], { stdio: 'ignore', detached: true }).unref();
+        });
+        logger(`Opened ${url} locally. Please sign in; subsequent runs will reuse the session.`);
+    }
+    catch {
+        logger(`Please open ${url} in this host's browser and sign in; then rerun.`);
+    }
+}

package/dist/src/remote/types.js

@@ -0,0 +1 @@
+export {};