@steipete/oracle 0.8.4 → 0.8.6

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

package/dist/src/remote/server.js

@@ -9,6 +9,7 @@ import chalk from 'chalk';
 import { runBrowserMode } from '../browserMode.js';
 import { getCookies } from '@steipete/sweet-cookie';
 import { CHATGPT_URL } from '../browser/constants.js';
+import { getCliVersion } from '../version.js';
 import { cleanupStaleProfileState, readDevToolsPort, verifyDevToolsReachable, writeChromePid, writeDevToolsActivePort, } from '../browser/profileState.js';
 import { normalizeChatgptUrl } from '../browser/utils.js';
 async function findAvailablePort() {
@@ -32,6 +33,7 @@ export async function createRemoteServer(options = {}, deps = {}) {
     const server = http.createServer();
     const logger = options.logger ?? console.log;
     const authToken = options.token ?? randomBytes(16).toString('hex');
+    const startedAt = Date.now();
     const verbose = process.argv.includes('--verbose') || process.env.ORACLE_SERVE_VERBOSE === '1';
     const color = process.stdout.isTTY
         ? (formatter, msg) => formatter(msg)
@@ -50,6 +52,24 @@ export async function createRemoteServer(options = {}, deps = {}) {
             res.end(JSON.stringify({ ok: true }));
             return;
         }
+        if (req.method === 'GET' && req.url === '/health') {
+            const authHeader = req.headers.authorization ?? '';
+            if (authHeader !== `Bearer ${authToken}`) {
+                if (verbose) {
+                    logger(`[serve] Unauthorized /health attempt from ${formatSocket(req)} (missing/invalid token)`);
+                }
+                res.writeHead(401, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'unauthorized' }));
+                return;
+            }
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                ok: true,
+                version: getCliVersion(),
+                uptimeSeconds: Math.round((Date.now() - startedAt) / 1000),
+            }));
+            return;
+        }
         if (req.method !== 'POST' || req.url !== '/runs') {
             res.statusCode = 404;
             res.end();
@@ -352,7 +372,14 @@ async function loadLocalChatgptCookies(logger, targetUrl) {
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        logger(`Unable to load local ChatGPT cookies on this host: ${message}`);
+        const missingDbMatch = message.match(/Unable to locate Chrome cookie DB at (.+?)(?:\.|$)/);
+        if (missingDbMatch) {
+            const lookedPath = missingDbMatch[1];
+            logger(`Chrome cookies not found at ${lookedPath}. Set --browser-cookie-path to your Chrome profile or log in manually.`);
+        }
+        else {
+            logger(`Unable to load local ChatGPT cookies on this host: ${message}`);
+        }
         if (process.platform === 'linux' && isWsl()) {
             logger('WSL hint: Chrome lives under /mnt/c/Users/<you>/AppData/Local/Google/Chrome/User Data/Default; pass --browser-cookie-path to that directory if auto-detect fails.');
         }

package/dist/src/sessionManager.js

@@ -2,7 +2,7 @@ import path from 'node:path';
 import fs from 'node:fs/promises';
 import { createWriteStream } from 'node:fs';
 import net from 'node:net';
-import { DEFAULT_MODEL } from './oracle.js';
+import { DEFAULT_MODEL, formatElapsed } from './oracle.js';
 import { safeModelSlug } from './oracle/modelResolver.js';
 import { getOracleHomeDir } from './oracleHome.js';
 export function getSessionsDir() {
@@ -151,9 +151,9 @@ export async function updateModelRunMetadata(sessionId, model, updates) {
 export async function readModelRunMetadata(sessionId, model) {
     return readModelRunFile(sessionId, model);
 }
-export async function initializeSession(options, cwd, notifications) {
+export async function initializeSession(options, cwd, notifications, baseSlugOverride) {
     await ensureSessionStorage();
-    const baseSlug = createSessionId(options.prompt || DEFAULT_SLUG, options.slug);
+    const baseSlug = baseSlugOverride || createSessionId(options.prompt || DEFAULT_SLUG, options.slug);
     const sessionId = await ensureUniqueSessionId(baseSlug);
     const dir = sessionDir(sessionId);
     await ensureDir(dir);
@@ -201,7 +201,18 @@ export async function initializeSession(options, cwd, notifications) {
             search: options.search,
             baseUrl: options.baseUrl,
             azure: options.azure,
+            timeoutSeconds: options.timeoutSeconds,
+            httpTimeoutMs: options.httpTimeoutMs,
+            zombieTimeoutMs: options.zombieTimeoutMs,
+            zombieUseLastActivity: options.zombieUseLastActivity,
             writeOutputPath: options.writeOutputPath,
+            waitPreference: options.waitPreference,
+            youtube: options.youtube,
+            generateImage: options.generateImage,
+            editImage: options.editImage,
+            outputPath: options.outputPath,
+            aspectRatio: options.aspectRatio,
+            geminiShowThoughts: options.geminiShowThoughts,
         },
     };
     await ensureDir(modelsDir(sessionId));
@@ -442,7 +453,7 @@ export async function getSessionPaths(sessionId) {
     return { dir, metadata, log, request };
 }
 async function markZombie(meta, { persist }) {
-    if (!isZombie(meta)) {
+    if (!(await isZombie(meta))) {
         return meta;
     }
     if (meta.mode === 'browser') {
@@ -461,10 +472,11 @@ async function markZombie(meta, { persist }) {
             }
         }
     }
+    const maxAgeMs = resolveZombieMaxAgeMs(meta);
     const updated = {
         ...meta,
         status: 'error',
-        errorMessage: 'Session marked as zombie (>60m stale)',
+        errorMessage: `Session marked as zombie (> ${formatElapsed(maxAgeMs)} stale)`,
         completedAt: new Date().toISOString(),
     };
     if (persist) {
@@ -510,7 +522,7 @@ async function markDeadBrowser(meta, { persist }) {
     }
     return updated;
 }
-function isZombie(meta) {
+async function isZombie(meta) {
     if (meta.status !== 'running') {
         return false;
     }
@@ -522,7 +534,60 @@ function isZombie(meta) {
     if (Number.isNaN(startedMs)) {
         return false;
     }
-    return Date.now() - startedMs > ZOMBIE_MAX_AGE_MS;
+    const useLastActivity = meta.options?.zombieUseLastActivity === true;
+    const lastActivityMs = useLastActivity ? await getLastActivityMs(meta) : null;
+    const anchorMs = lastActivityMs ?? startedMs;
+    const maxAgeMs = resolveZombieMaxAgeMs(meta);
+    return Date.now() - anchorMs > maxAgeMs;
+}
+function resolveZombieMaxAgeMs(meta) {
+    const explicit = meta.options?.zombieTimeoutMs;
+    const hasExplicit = typeof explicit === 'number' && Number.isFinite(explicit) && explicit > 0;
+    let maxAgeMs = hasExplicit ? explicit : ZOMBIE_MAX_AGE_MS;
+    if (!hasExplicit) {
+        const timeoutSeconds = meta.options?.timeoutSeconds;
+        if (typeof timeoutSeconds === 'number' && Number.isFinite(timeoutSeconds) && timeoutSeconds > 0) {
+            const timeoutMs = timeoutSeconds * 1000;
+            if (timeoutMs > maxAgeMs) {
+                maxAgeMs = timeoutMs;
+            }
+        }
+    }
+    return maxAgeMs;
+}
+async function getLastActivityMs(meta) {
+    const candidates = new Set();
+    candidates.add(logPath(meta.id));
+    const modelNames = new Set();
+    if (typeof meta.model === 'string' && meta.model.length > 0) {
+        modelNames.add(meta.model);
+    }
+    if (Array.isArray(meta.models)) {
+        for (const entry of meta.models) {
+            if (entry?.model) {
+                modelNames.add(entry.model);
+            }
+        }
+    }
+    for (const modelName of modelNames) {
+        candidates.add(modelLogPath(meta.id, modelName));
+    }
+    let latest = 0;
+    let sawStat = false;
+    for (const candidate of candidates) {
+        try {
+            const stats = await fs.stat(candidate);
+            const mtimeMs = Number.isFinite(stats.mtimeMs) ? stats.mtimeMs : stats.mtime.getTime();
+            if (Number.isFinite(mtimeMs)) {
+                latest = Math.max(latest, mtimeMs);
+                sawStat = true;
+            }
+        }
+        catch {
+            // ignore missing logs; fallback to startedAt
+        }
+    }
+    return sawStat ? latest : null;
 }
 function isProcessAlive(pid) {
     if (!pid)

package/dist/src/sessionStore.js

@@ -3,8 +3,8 @@ class FileSessionStore {
     ensureStorage() {
         return ensureSessionStorage();
     }
-    createSession(options, cwd, notifications) {
-        return initializeSession(options, cwd, notifications);
+    createSession(options, cwd, notifications, baseSlugOverride) {
+        return initializeSession(options, cwd, notifications, baseSlugOverride);
     }
     readSession(sessionId) {
         return readSessionMetadata(sessionId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steipete/oracle",
-  "version": "0.8.4",
+  "version": "0.8.6",
   "description": "CLI wrapper around OpenAI Responses API with GPT-5.2 Pro (via gpt-5.1-pro alias), GPT-5.2, GPT-5.1, and GPT-5.1 Codex high reasoning modes.",
   "type": "module",
   "main": "dist/bin/oracle-cli.js",
@@ -62,49 +62,49 @@
   "homepage": "https://github.com/steipete/oracle#readme",
   "dependencies": {
     "@anthropic-ai/tokenizer": "^0.0.4",
-    "@google/genai": "^1.34.0",
+    "@google/genai": "^1.40.0",
     "@google/generative-ai": "^0.24.1",
-    "@modelcontextprotocol/sdk": "^1.25.1",
+    "@modelcontextprotocol/sdk": "^1.26.0",
     "@steipete/sweet-cookie": "^0.1.0",
     "chalk": "^5.6.2",
     "chrome-launcher": "^1.2.1",
     "chrome-remote-interface": "^0.33.3",
-    "clipboardy": "^5.0.2",
-    "commander": "^14.0.2",
-    "dotenv": "^17.2.3",
+    "clipboardy": "^5.2.1",
+    "commander": "^14.0.3",
+    "dotenv": "^17.2.4",
     "fast-glob": "^3.3.3",
     "gpt-tokenizer": "^3.4.0",
-    "inquirer": "13.1.0",
+    "inquirer": "13.2.2",
     "json5": "^2.2.3",
     "kleur": "^4.1.5",
-    "markdansi": "0.2.0",
-    "openai": "^6.15.0",
-    "osc-progress": "^0.2.0",
+    "markdansi": "0.2.1",
+    "openai": "^6.18.0",
+    "osc-progress": "^0.3.0",
     "qs": "^6.14.1",
-    "shiki": "^3.20.0",
+    "shiki": "^3.22.0",
     "toasted-notifier": "^10.1.0",
     "tokentally": "^0.1.1",
-    "zod": "^4.3.5"
+    "zod": "^4.3.6"
   },
   "devDependencies": {
     "@anthropic-ai/tokenizer": "^0.0.4",
-    "@biomejs/biome": "^2.3.11",
+    "@biomejs/biome": "^2.3.14",
     "@cdktf/node-pty-prebuilt-multiarch": "0.10.2",
     "@types/chrome-remote-interface": "^0.33.0",
     "@types/inquirer": "^9.0.9",
-    "@types/node": "^25.0.3",
-    "@vitest/coverage-v8": "4.0.16",
-    "devtools-protocol": "0.0.1561482",
-    "es-toolkit": "^1.43.0",
-    "esbuild": "^0.27.2",
-    "puppeteer-core": "^24.34.0",
+    "@types/node": "^25.2.1",
+    "@vitest/coverage-v8": "4.0.18",
+    "devtools-protocol": "0.0.1580600",
+    "es-toolkit": "^1.44.0",
+    "esbuild": "^0.27.3",
+    "puppeteer-core": "^24.37.2",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
-    "vitest": "^4.0.16"
+    "vitest": "^4.0.18"
   },
   "pnpm": {
     "overrides": {
-      "devtools-protocol": "0.0.1561482"
+      "devtools-protocol": "0.0.1568893"
     },
     "onlyBuiltDependencies": [
       "@cdktf/node-pty-prebuilt-multiarch",