@indykish/oracle 0.9.0

package/dist/src/oracle/tokenEstimate.js

@@ -0,0 +1,37 @@
+import { TOKENIZER_OPTIONS } from './config.js';
+/**
+ * Estimate input tokens from the full request body instead of just system/user text.
+ * This is a conservative approximation: we tokenize the key textual fields and add a fixed buffer
+ * to cover structural JSON overhead and server-side wrappers (tools/reasoning/background/store).
+ */
+export function estimateRequestTokens(requestBody, modelConfig, bufferTokens = 200) {
+    const SEARCH_RESULT_BUFFER_TOKENS = 4000;
+    const parts = [];
+    if (requestBody.instructions) {
+        parts.push(requestBody.instructions);
+    }
+    for (const turn of requestBody.input ?? []) {
+        for (const content of turn.content ?? []) {
+            if (typeof content.text === 'string') {
+                parts.push(content.text);
+            }
+        }
+    }
+    if (requestBody.tools && requestBody.tools.length > 0) {
+        parts.push(JSON.stringify(requestBody.tools));
+    }
+    if (requestBody.reasoning) {
+        parts.push(JSON.stringify(requestBody.reasoning));
+    }
+    if (requestBody.background) {
+        parts.push('background:true');
+    }
+    if (requestBody.store) {
+        parts.push('store:true');
+    }
+    const concatenated = parts.join('\n');
+    const baseEstimate = modelConfig.tokenizer(concatenated, TOKENIZER_OPTIONS);
+    const hasWebSearch = requestBody.tools?.some((tool) => tool?.type === 'web_search_preview');
+    const searchBuffer = hasWebSearch ? SEARCH_RESULT_BUFFER_TOKENS : 0;
+    return baseEstimate + bufferTokens + searchBuffer;
+}

package/dist/src/oracle/tokenStats.js

@@ -0,0 +1,39 @@
+import chalk from 'chalk';
+import { createFileSections } from './files.js';
+export function getFileTokenStats(files, { cwd = process.cwd(), tokenizer, tokenizerOptions, inputTokenBudget, }) {
+    if (!files.length) {
+        return { stats: [], totalTokens: 0 };
+    }
+    const sections = createFileSections(files, cwd);
+    const stats = sections
+        .map((section) => {
+        const tokens = tokenizer(section.sectionText, tokenizerOptions);
+        const percent = inputTokenBudget ? (tokens / inputTokenBudget) * 100 : undefined;
+        return {
+            path: section.absolutePath,
+            displayPath: section.displayPath,
+            tokens,
+            percent,
+        };
+    })
+        .sort((a, b) => b.tokens - a.tokens);
+    const totalTokens = stats.reduce((sum, entry) => sum + entry.tokens, 0);
+    return { stats, totalTokens };
+}
+export function printFileTokenStats({ stats, totalTokens }, { inputTokenBudget, log = console.log }) {
+    if (!stats.length) {
+        return;
+    }
+    log(chalk.bold('File Token Usage'));
+    for (const entry of stats) {
+        const percentLabel = inputTokenBudget && entry.percent != null ? `${entry.percent.toFixed(2)}%` : 'n/a';
+        log(`${entry.tokens.toLocaleString().padStart(10)}  ${percentLabel.padStart(8)}  ${entry.displayPath}`);
+    }
+    if (inputTokenBudget) {
+        const totalPercent = (totalTokens / inputTokenBudget) * 100;
+        log(`Total: ${totalTokens.toLocaleString()} tokens (${totalPercent.toFixed(2)}% of ${inputTokenBudget.toLocaleString()})`);
+    }
+    else {
+        log(`Total: ${totalTokens.toLocaleString()} tokens`);
+    }
+}

package/dist/src/oracle/tokenStringifier.js

@@ -0,0 +1,24 @@
+// Minimal helper to stringify arbitrary input for tokenizer consumption.
+// Anthropic's tokenizer expects a string; we accept unknown and coerce safely.
+export function stringifyTokenizerInput(input) {
+    if (typeof input === 'string')
+        return input;
+    if (input === null || input === undefined)
+        return '';
+    if (typeof input === 'number' || typeof input === 'boolean' || typeof input === 'bigint') {
+        return String(input);
+    }
+    if (typeof input === 'object') {
+        try {
+            return JSON.stringify(input);
+        }
+        catch {
+            // fall through to generic stringification
+        }
+    }
+    if (typeof input === 'function') {
+        return input.toString();
+    }
+    return String(input);
+}
+export default stringifyTokenizerInput;

package/dist/src/oracle/types.js

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

package/dist/src/oracle.js

@@ -0,0 +1,12 @@
+export * from './oracle/types.js';
+export { MODEL_CONFIGS, DEFAULT_MODEL, PRO_MODELS, DEFAULT_SYSTEM_PROMPT, TOKENIZER_OPTIONS, } from './oracle/config.js';
+export { readFiles, createFileSections } from './oracle/files.js';
+export { buildPrompt, buildRequestBody, renderPromptMarkdown } from './oracle/request.js';
+export { estimateRequestTokens } from './oracle/tokenEstimate.js';
+export { formatUSD, formatNumber, formatElapsed } from './oracle/format.js';
+export { formatFileSection } from './oracle/markdown.js';
+export { getFileTokenStats, printFileTokenStats } from './oracle/tokenStats.js';
+export { OracleResponseError, OracleTransportError, OracleUserError, FileValidationError, BrowserAutomationError, PromptValidationError, describeTransportError, extractResponseMetadata, asOracleUserError, toTransportError, } from './oracle/errors.js';
+export { createDefaultClientFactory } from './oracle/client.js';
+export { runOracle, extractTextOutput } from './oracle/run.js';
+export { resolveGeminiModelId } from './oracle/gemini.js';

package/dist/src/oracleHome.js

@@ -0,0 +1,13 @@
+import os from 'node:os';
+import path from 'node:path';
+let oracleHomeDirOverride = null;
+/**
+ * Test-only hook: avoid mutating process.env (shared across Vitest worker threads).
+ * This override is scoped to the current Node worker.
+ */
+export function setOracleHomeDirOverrideForTest(dir) {
+    oracleHomeDirOverride = dir;
+}
+export function getOracleHomeDir() {
+    return oracleHomeDirOverride ?? process.env.ORACLE_HOME_DIR ?? path.join(os.homedir(), '.oracle');
+}

package/dist/src/remote/client.js

@@ -0,0 +1,129 @@
+import http from 'node:http';
+import path from 'node:path';
+import { readFile } from 'node:fs/promises';
+import { parseHostPort } from '../bridge/connection.js';
+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) {
+    try {
+        return parseHostPort(input);
+    }
+    catch (error) {
+        throw new Error(`Invalid remote host: ${input} (${error instanceof Error ? error.message : String(error)})`);
+    }
+}
+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/health.js

@@ -0,0 +1,113 @@
+import http from 'node:http';
+import net from 'node:net';
+import { parseHostPort } from '../bridge/connection.js';
+export async function checkTcpConnection(host, timeoutMs = 2000) {
+    const { hostname, port } = parseHostPort(host);
+    return await new Promise((resolve) => {
+        const socket = net.createConnection({ host: hostname, port });
+        const onError = (err) => {
+            cleanup();
+            resolve({ ok: false, error: err.message });
+        };
+        const onConnect = () => {
+            cleanup();
+            resolve({ ok: true });
+        };
+        const onTimeout = () => {
+            cleanup();
+            resolve({ ok: false, error: `timeout after ${timeoutMs}ms` });
+        };
+        const cleanup = () => {
+            socket.removeAllListeners();
+            socket.end();
+            socket.destroy();
+            socket.unref();
+        };
+        socket.setTimeout(timeoutMs);
+        socket.once('error', onError);
+        socket.once('connect', onConnect);
+        socket.once('timeout', onTimeout);
+    });
+}
+export async function checkRemoteHealth({ host, token, timeoutMs = 5000, }) {
+    const { hostname, port } = parseHostPort(host);
+    const headers = { accept: 'application/json' };
+    if (token) {
+        headers.authorization = `Bearer ${token}`;
+    }
+    try {
+        const response = await requestJson({
+            hostname,
+            port,
+            path: '/health',
+            headers,
+            timeoutMs,
+        });
+        if (response.statusCode === 200 && typeof response.json === 'object' && response.json) {
+            const ok = response.json.ok === true;
+            const version = response.json.version;
+            const uptimeSeconds = response.json.uptimeSeconds;
+            return {
+                ok,
+                statusCode: response.statusCode,
+                version: typeof version === 'string' ? version : undefined,
+                uptimeSeconds: typeof uptimeSeconds === 'number' ? uptimeSeconds : undefined,
+            };
+        }
+        if (response.statusCode === 404) {
+            return {
+                ok: false,
+                statusCode: response.statusCode,
+                error: 'remote host does not expose /health (upgrade oracle on the host and retry)',
+            };
+        }
+        const error = extractErrorMessage(response.json, response.bodyText) ?? `HTTP ${response.statusCode}`;
+        return { ok: false, statusCode: response.statusCode, error };
+    }
+    catch (error) {
+        return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    }
+}
+function extractErrorMessage(json, bodyText) {
+    if (json && typeof json === 'object') {
+        const err = json.error;
+        if (typeof err === 'string' && err.trim().length > 0) {
+            return err.trim();
+        }
+    }
+    const trimmed = bodyText.trim();
+    return trimmed.length ? trimmed : null;
+}
+async function requestJson({ hostname, port, path, headers, timeoutMs, }) {
+    return await new Promise((resolve, reject) => {
+        const req = http.request({
+            hostname,
+            port,
+            path,
+            method: 'GET',
+            headers,
+        }, (res) => {
+            res.setEncoding('utf8');
+            let body = '';
+            res.on('data', (chunk) => {
+                body += chunk;
+            });
+            res.on('end', () => {
+                const statusCode = res.statusCode ?? 0;
+                let json = null;
+                try {
+                    json = body.length ? JSON.parse(body) : null;
+                }
+                catch {
+                    json = null;
+                }
+                resolve({ statusCode, json, bodyText: body });
+            });
+        });
+        req.setTimeout(timeoutMs, () => {
+            req.destroy(new Error(`timeout after ${timeoutMs}ms`));
+        });
+        req.on('error', reject);
+        req.end();
+    });
+}

package/dist/src/remote/remoteServiceConfig.js

@@ -0,0 +1,31 @@
+function normalizeString(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length ? trimmed : undefined;
+}
+export function resolveRemoteServiceConfig({ cliHost, cliToken, userConfig, env = process.env, }) {
+    const configBrowserHost = normalizeString(userConfig?.browser?.remoteHost);
+    const configBrowserToken = normalizeString(userConfig?.browser?.remoteToken);
+    const envHost = normalizeString(env.ORACLE_REMOTE_HOST);
+    const envToken = normalizeString(env.ORACLE_REMOTE_TOKEN);
+    const cliHostValue = normalizeString(cliHost);
+    const cliTokenValue = normalizeString(cliToken);
+    const host = cliHostValue ?? configBrowserHost ?? envHost;
+    const token = cliTokenValue ?? configBrowserToken ?? envToken;
+    const hostSource = cliHostValue
+        ? 'cli'
+        : configBrowserHost
+            ? 'config.browser'
+            : envHost
+                ? 'env'
+                : 'unset';
+    const tokenSource = cliTokenValue
+        ? 'cli'
+        : configBrowserToken
+            ? 'config.browser'
+            : envToken
+                ? 'env'
+                : 'unset';
+    return { host, token, sources: { host: hostSource, token: tokenSource } };
+}