@steipete/oracle 0.4.5 → 0.5.1

package/dist/src/remote/server.js

@@ -1,13 +1,32 @@
 import http from 'node:http';
 import os from 'node:os';
 import path from 'node:path';
+import net from 'node:net';
 import { randomBytes, randomUUID } from 'node:crypto';
+import { spawn, spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
 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';
+async function findAvailablePort() {
+    return await new Promise((resolve, reject) => {
+        const srv = net.createServer();
+        srv.on('error', (err) => reject(err));
+        srv.listen(0, () => {
+            const address = srv.address();
+            if (typeof address === 'object' && address?.port) {
+                const port = address.port;
+                srv.close(() => resolve(port));
+            }
+            else {
+                srv.close(() => reject(new Error('Unable to allocate port')));
+            }
+        });
+    });
+}
 export async function createRemoteServer(options = {}, deps = {}) {
     const runBrowser = deps.runBrowser ?? runBrowserMode;
     const server = http.createServer();
@@ -45,7 +64,6 @@ export async function createRemoteServer(options = {}, deps = {}) {
             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`);
@@ -106,6 +124,18 @@ export async function createRemoteServer(options = {}, deps = {}) {
                 payload.browserConfig.inlineCookiesSource = null;
                 payload.browserConfig.cookieSync = true;
             }
+            else {
+                payload.browserConfig = {};
+            }
+            // Enforce manual-login profile when cookie sync is unavailable (e.g., Windows/WSL).
+            if (options.manualLoginDefault) {
+                payload.browserConfig.manualLogin = true;
+                payload.browserConfig.manualLoginProfileDir = options.manualLoginProfileDir;
+                payload.browserConfig.keepBrowser = true;
+                if (verbose) {
+                    logger(`[serve] Enforcing manual-login profile at ${options.manualLoginProfileDir ?? 'default'} for remote run ${runId}`);
+                }
+            }
             const result = await runBrowser({
                 prompt: payload.prompt,
                 attachments,
@@ -146,6 +176,7 @@ export async function createRemoteServer(options = {}, deps = {}) {
     const also = extras.length ? `, also [${extras.join(', ')}]` : '';
     logger(color(chalk.cyanBright.bold, `Listening at ${primary}${also}`));
     logger(color(chalk.yellowBright, `Access token: ${authToken}`));
+    logger('Leave this terminal running; press Ctrl+C to stop oracle serve.');
     return {
         port: address.port,
         token: authToken,
@@ -157,15 +188,54 @@ export async function createRemoteServer(options = {}, deps = {}) {
     };
 }
 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);
+    const manualProfileDir = options.manualLoginProfileDir ?? path.join(os.homedir(), '.oracle', 'browser-profile');
+    const preferManualLogin = options.manualLoginDefault || process.platform === 'win32' || isWsl();
+    let cookies = null;
+    let opened = false;
+    if (isWsl() && process.env.ORACLE_ALLOW_WSL_SERVE !== '1') {
+        console.log('WSL detected. For reliable browser automation, run `oracle serve` from Windows PowerShell/Command Prompt so we can use your Windows Chrome profile.');
+        console.log('If you want to stay in WSL anyway, set ORACLE_ALLOW_WSL_SERVE=1 and ensure a Linux Chrome is installed, then rerun.');
+        console.log('Alternatively, start Windows Chrome with --remote-debugging-port=9222 and use `--remote-chrome <windows-ip>:9222`.');
+        return;
+    }
+    if (!preferManualLogin) {
+        // Warm-up: ensure this host has a ChatGPT login before accepting runs.
+        const result = await loadLocalChatgptCookies(console.log, CHATGPT_URL);
+        cookies = result.cookies;
+        opened = result.opened;
+    }
     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;
+        if (preferManualLogin) {
+            await mkdir(manualProfileDir, { recursive: true });
+            console.log(`Cookie extraction is unavailable on this platform. Using manual-login Chrome profile at ${manualProfileDir}. Remote runs will reuse this profile; sign in once when the browser opens.`);
+            const devtoolsPortFile = path.join(manualProfileDir, 'DevToolsActivePort');
+            const alreadyRunning = existsSync(devtoolsPortFile);
+            if (alreadyRunning) {
+                console.log('Detected an existing automation Chrome session; will reuse it for manual login.');
+            }
+            else {
+                void launchManualLoginChrome(manualProfileDir, CHATGPT_URL, console.log);
+            }
+        }
+        else if (opened) {
+            console.log('Opened chatgpt.com for login. Sign in, then restart `oracle serve` to continue.');
+            return;
+        }
+        else {
+            console.log('Please open https://chatgpt.com/ in this host\'s browser and sign in; then rerun.');
+            console.log('Tip: install xdg-utils (xdg-open) to enable automatic browser opening on Linux/WSL.');
+            return;
+        }
+    }
+    else {
+        console.log(`Detected ${cookies.length} ChatGPT cookies on this host; runs will reuse this session.`);
     }
-    console.log(`Detected ${cookies.length} ChatGPT cookies on this host; runs will reuse this session.`);
-    const server = await createRemoteServer(options);
+    const server = await createRemoteServer({
+        ...options,
+        manualLoginDefault: preferManualLogin,
+        manualLoginProfileDir: manualProfileDir,
+    });
     await new Promise((resolve) => {
         const shutdown = () => {
             console.log('Shutting down remote service...');
@@ -263,32 +333,153 @@ async function loadLocalChatgptCookies(logger, targetUrl) {
         });
         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;
+            const opened = triggerLocalLoginPrompt(logger, targetUrl);
+            return { cookies: null, opened };
         }
         logger(`Loaded ${cookies.length} local ChatGPT cookies on this host.`);
-        return cookies;
+        return { cookies, opened: false };
     }
     catch (error) {
-        logger(`Unable to load local ChatGPT cookies on this host: ${error instanceof Error ? error.message : String(error)}`);
-        triggerLocalLoginPrompt(logger, targetUrl);
-        return null;
+        const message = error instanceof Error ? error.message : String(error);
+        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.');
+        }
+        const opened = triggerLocalLoginPrompt(logger, targetUrl);
+        return { cookies: null, opened };
     }
 }
 function triggerLocalLoginPrompt(logger, url) {
-    const opener = process.platform === 'darwin'
-        ? 'open'
-        : process.platform === 'win32'
-            ? 'start'
-            : 'xdg-open';
+    const verbose = process.argv.includes('--verbose') || process.env.ORACLE_SERVE_VERBOSE === '1';
+    const openers = [];
+    if (process.platform === 'darwin') {
+        openers.push({ cmd: 'open' });
+    }
+    else if (process.platform === 'win32') {
+        openers.push({ cmd: 'start' });
+    }
+    else {
+        if (isWsl()) {
+            // Prefer wslview when available, then fall back to Windows start.exe to open in the host browser.
+            openers.push({ cmd: 'wslview' });
+            openers.push({ cmd: 'cmd.exe', args: ['/c', 'start', '', url] });
+        }
+        openers.push({ cmd: 'xdg-open' });
+    }
+    // Add a cross-platform, low-friction fallback when nothing above is available.
+    openers.push({ cmd: 'sensible-browser' });
     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.`);
+        if (verbose) {
+            logger(`[serve] Login opener candidates: ${openers.map((o) => o.cmd).join(', ')}`);
+        }
+        const candidate = openers.find((opener) => canSpawn(opener.cmd));
+        if (candidate) {
+            const child = spawn(candidate.cmd, candidate.args ?? [url], { stdio: 'ignore', detached: true });
+            child.unref();
+            child.once('error', (error) => {
+                if (verbose) {
+                    logger(`[serve] Opener ${candidate.cmd} failed: ${error instanceof Error ? error.message : String(error)}`);
+                }
+                logger(`Please open ${url} in this host's browser and sign in; then rerun.`);
+            });
+            logger(`Opened ${url} locally via ${candidate.cmd}. Please sign in; subsequent runs will reuse the session.`);
+            if (verbose && candidate.args) {
+                logger(`[serve] Opener args: ${candidate.args.join(' ')}`);
+            }
+            return true;
+        }
+        if (verbose) {
+            logger('[serve] No available opener found; prompting manual login.');
+        }
+        return false;
     }
     catch {
-        logger(`Please open ${url} in this host's browser and sign in; then rerun.`);
+        return false;
+    }
+}
+function isWsl() {
+    if (process.platform !== 'linux')
+        return false;
+    return Boolean(process.env.WSL_DISTRO_NAME || os.release().toLowerCase().includes('microsoft'));
+}
+function canSpawn(cmd) {
+    if (!cmd)
+        return false;
+    try {
+        if (process.platform === 'win32') {
+            // `where` returns non-zero when the command is not found.
+            const result = spawnSync('where', [cmd], { stdio: 'ignore' });
+            return result.status === 0;
+        }
+        // `command -v` is a shell builtin; run through sh. Fallback to `which`.
+        const shResult = spawnSync('sh', ['-c', `command -v ${cmd}`], { stdio: 'ignore' });
+        if (shResult.status === 0)
+            return true;
+        const whichResult = spawnSync('which', [cmd], { stdio: 'ignore' });
+        return whichResult.status === 0;
+    }
+    catch {
+        return false;
+    }
+}
+async function launchManualLoginChrome(profileDir, url, logger) {
+    const timeoutMs = 7000;
+    let finished = false;
+    const timeout = setTimeout(() => {
+        if (!finished) {
+            logger(`Timed out launching Chrome for manual login. Launch Chrome manually with --user-data-dir=${profileDir} and log in to ${url}.`);
+        }
+    }, timeoutMs);
+    try {
+        const chromeLauncher = await import('chrome-launcher');
+        const { launch } = chromeLauncher;
+        const debugPort = await findAvailablePort();
+        logger(`Planned manual-login Chrome DevTools port: ${debugPort}`);
+        const chrome = await launch({
+            // Expose DevTools so later runs can attach instead of spawning a second Chrome.
+            // Use a per-serve free port so the login window stays stable for all runs.
+            port: debugPort,
+            userDataDir: profileDir,
+            startingUrl: url,
+            chromeFlags: [
+                '--no-first-run',
+                '--no-default-browser-check',
+                `--user-data-dir=${profileDir}`,
+                '--remote-allow-origins=*',
+                `--remote-debugging-port=${debugPort}`, // ensure DevToolsActivePort is written even on Windows
+            ],
+        });
+        const chosenPort = chrome?.port ?? debugPort ?? null;
+        if (chosenPort) {
+            // Write DevToolsActivePort eagerly so maybeReuseRunningChrome can attach on the next run
+            const devtoolsFile = path.join(profileDir, 'DevToolsActivePort');
+            const devtoolsFileDefault = path.join(profileDir, 'Default', 'DevToolsActivePort');
+            const contents = `${chosenPort}\n/devtools/browser`;
+            await writeFile(devtoolsFile, contents).catch(() => undefined);
+            await writeFile(devtoolsFileDefault, contents).catch(() => undefined);
+            logger(`Manual-login Chrome DevTools port: ${chosenPort}`);
+            logger(`If needed, DevTools JSON at http://127.0.0.1:${chosenPort}/json/version`);
+        }
+        else {
+            logger('Warning: unable to determine manual-login Chrome DevTools port. Remote runs may fail to attach.');
+        }
+        finished = true;
+        clearTimeout(timeout);
+        const portInfo = chosenPort ? ` (DevTools port ${chosenPort})` : '';
+        logger(`Opened Chrome with manual-login profile at ${profileDir}${portInfo}. Complete login, then rerun remote sessions.`);
+    }
+    catch (error) {
+        finished = true;
+        clearTimeout(timeout);
+        const message = error instanceof Error ? error.message : String(error);
+        logger(`Unable to open Chrome for manual login (${message}). Launch Chrome manually with --user-data-dir=${profileDir} and log in to ${url}.`);
     }
 }

package/dist/src/sessionManager.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 import fs from 'node:fs/promises';
 import { createWriteStream } from 'node:fs';
 import { DEFAULT_MODEL } from './oracle.js';
+import { safeModelSlug } from './oracle/modelResolver.js';
 const ORACLE_HOME = process.env.ORACLE_HOME_DIR ?? path.join(os.homedir(), '.oracle');
 const SESSIONS_DIR = path.join(ORACLE_HOME, 'sessions');
 const METADATA_FILENAME = 'meta.json';
@@ -67,10 +68,12 @@ function modelsDir(id) {
     return path.join(sessionDir(id), MODELS_DIRNAME);
 }
 function modelJsonPath(id, model) {
-    return path.join(modelsDir(id), `${model}${MODEL_JSON_EXTENSION}`);
+    const slug = safeModelSlug(model);
+    return path.join(modelsDir(id), `${slug}${MODEL_JSON_EXTENSION}`);
 }
 function modelLogPath(id, model) {
-    return path.join(modelsDir(id), `${model}${MODEL_LOG_EXTENSION}`);
+    const slug = safeModelSlug(model);
+    return path.join(modelsDir(id), `${slug}${MODEL_LOG_EXTENSION}`);
 }
 async function fileExists(targetPath) {
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steipete/oracle",
-  "version": "0.4.5",
+  "version": "0.5.1",
   "description": "CLI wrapper around OpenAI Responses API with GPT-5.1 Pro, GPT-5.1, and GPT-5.1 Codex high reasoning modes.",
   "type": "module",
   "main": "dist/bin/oracle-cli.js",
@@ -52,46 +52,46 @@
     "chrome-cookies-secure": "3.0.0",
     "chrome-launcher": "^1.2.1",
     "chrome-remote-interface": "^0.33.3",
-    "clipboardy": "^4.0.0",
+    "clipboardy": "^5.0.1",
     "commander": "^14.0.2",
     "dotenv": "^17.2.3",
     "fast-glob": "^3.3.3",
     "gpt-tokenizer": "^3.4.0",
-    "inquirer": "^9.3.8",
+    "inquirer": "9.3.8",
     "json5": "^2.2.3",
     "keytar": "^7.9.0",
     "kleur": "^4.1.5",
     "markdansi": "^0.1.3",
-    "openai": "^6.9.0",
+    "openai": "^6.9.1",
     "shiki": "^3.15.0",
     "sqlite3": "^5.1.7",
     "toasted-notifier": "^10.1.0",
-    "zod": "^3.24.1"
+    "zod": "3.24.1"
   },
   "devDependencies": {
     "@anthropic-ai/tokenizer": "^0.0.4",
-    "@biomejs/biome": "^2.3.5",
+    "@biomejs/biome": "^2.3.7",
     "@cdktf/node-pty-prebuilt-multiarch": "0.10.2",
     "@types/chrome-remote-interface": "^0.31.14",
     "@types/inquirer": "^9.0.9",
-    "@types/json5": "^0.0.30",
+    "@types/json5": "^2.2.0",
     "@types/node": "^24.10.1",
-    "@vitest/coverage-v8": "4.0.9",
-    "devtools-protocol": "^0.0.1545402",
+    "@vitest/coverage-v8": "4.0.13",
+    "devtools-protocol": "^0.0.1548823",
     "es-toolkit": "^1.42.0",
     "esbuild": "^0.27.0",
-    "puppeteer-core": "^24.30.0",
+    "puppeteer-core": "^24.31.0",
     "tsx": "^4.20.6",
     "typescript": "^5.9.3",
-    "vitest": "^4.0.9"
+    "vitest": "^4.0.13"
   },
   "optionalDependencies": {
-    "win-dpapi": "^1.1.0"
+    "win-dpapi": "npm:@primno/dpapi@2.0.1"
   },
   "scripts": {
     "docs:list": "tsx scripts/docs-list.ts",
     "build": "tsc -p tsconfig.build.json && pnpm run build:vendor",
-    "build:vendor": "mkdir -p dist/vendor && cp -R vendor/oracle-notifier dist/vendor/oracle-notifier || true",
+    "build:vendor": "node -e \"const fs=require('fs'); const path=require('path'); const src=path.join('vendor','oracle-notifier'); const dest=path.join('dist','vendor','oracle-notifier'); fs.mkdirSync(dest,{recursive:true}); if(fs.existsSync(src)){ fs.cpSync(src,dest,{recursive:true,force:true}); }\"",
     "start": "pnpm run build && node ./dist/scripts/run-cli.js",
     "oracle": "pnpm start",
     "check": "pnpm run typecheck",
@@ -101,7 +101,7 @@
     "test:mcp": "pnpm run build && pnpm run test:mcp:unit && pnpm run test:mcp:mcporter",
     "test:mcp:unit": "vitest run tests/mcp*.test.ts tests/mcp/**/*.test.ts",
     "test:mcp:mcporter": "npx -y mcporter list oracle-local --schema --config config/mcporter.json && npx -y mcporter call oracle-local.sessions limit:1 --config config/mcporter.json",
-    "test:browser": "pnpm run build && ./scripts/browser-smoke.sh",
+    "test:browser": "pnpm run build && tsx scripts/test-browser.ts && ./scripts/browser-smoke.sh",
     "test:live": "ORACLE_LIVE_TEST=1 vitest run tests/live --exclude tests/live/openai-live.test.ts",
     "test:pro": "ORACLE_LIVE_TEST=1 vitest run tests/live/openai-live.test.ts",
     "test:coverage": "vitest run --coverage",