@steipete/oracle 0.17.1 → 0.17.3

package/dist/oracle/src/sessionManager.js

@@ -0,0 +1,205 @@
+import os from 'node:os';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { createWriteStream } from 'node:fs';
+const ORACLE_HOME = process.env.ORACLE_HOME_DIR ?? path.join(os.homedir(), '.oracle');
+const SESSIONS_DIR = path.join(ORACLE_HOME, 'sessions');
+const MAX_STATUS_LIMIT = 1000;
+const DEFAULT_SLUG = 'session';
+const MAX_SLUG_WORDS = 5;
+const MIN_CUSTOM_SLUG_WORDS = 3;
+async function ensureDir(dirPath) {
+    await fs.mkdir(dirPath, { recursive: true });
+}
+export async function ensureSessionStorage() {
+    await ensureDir(SESSIONS_DIR);
+}
+function slugify(text, maxWords = MAX_SLUG_WORDS) {
+    const normalized = text?.toLowerCase() ?? '';
+    const words = normalized.match(/[a-z0-9]+/g) ?? [];
+    const trimmed = words.slice(0, maxWords);
+    return trimmed.length > 0 ? trimmed.join('-') : DEFAULT_SLUG;
+}
+function countSlugWords(slug) {
+    return slug.split('-').filter(Boolean).length;
+}
+function normalizeCustomSlug(candidate) {
+    const slug = slugify(candidate, MAX_SLUG_WORDS);
+    const wordCount = countSlugWords(slug);
+    if (wordCount < MIN_CUSTOM_SLUG_WORDS || wordCount > MAX_SLUG_WORDS) {
+        throw new Error(`Custom slug must include between ${MIN_CUSTOM_SLUG_WORDS} and ${MAX_SLUG_WORDS} words.`);
+    }
+    return slug;
+}
+export function createSessionId(prompt, customSlug) {
+    if (customSlug) {
+        return normalizeCustomSlug(customSlug);
+    }
+    return slugify(prompt);
+}
+function sessionDir(id) {
+    return path.join(SESSIONS_DIR, id);
+}
+function metaPath(id) {
+    return path.join(sessionDir(id), 'session.json');
+}
+function logPath(id) {
+    return path.join(sessionDir(id), 'output.log');
+}
+function requestPath(id) {
+    return path.join(sessionDir(id), 'request.json');
+}
+async function fileExists(targetPath) {
+    try {
+        await fs.access(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function ensureUniqueSessionId(baseSlug) {
+    let candidate = baseSlug;
+    let suffix = 2;
+    while (await fileExists(sessionDir(candidate))) {
+        candidate = `${baseSlug}-${suffix}`;
+        suffix += 1;
+    }
+    return candidate;
+}
+export async function initializeSession(options, cwd) {
+    await ensureSessionStorage();
+    const baseSlug = createSessionId(options.prompt || DEFAULT_SLUG, options.slug);
+    const sessionId = await ensureUniqueSessionId(baseSlug);
+    const dir = sessionDir(sessionId);
+    await ensureDir(dir);
+    const mode = options.mode ?? 'api';
+    const browserConfig = options.browserConfig;
+    const metadata = {
+        id: sessionId,
+        createdAt: new Date().toISOString(),
+        status: 'pending',
+        promptPreview: (options.prompt || '').slice(0, 160),
+        model: options.model,
+        cwd,
+        mode,
+        browser: browserConfig ? { config: browserConfig } : undefined,
+        options: {
+            prompt: options.prompt,
+            file: options.file ?? [],
+            model: options.model,
+            maxInput: options.maxInput,
+            system: options.system,
+            maxOutput: options.maxOutput,
+            silent: options.silent,
+            filesReport: options.filesReport,
+            slug: sessionId,
+            mode,
+            browserConfig,
+            verbose: options.verbose,
+            heartbeatIntervalMs: options.heartbeatIntervalMs,
+            browserInlineFiles: options.browserInlineFiles,
+            background: options.background,
+        },
+    };
+    await fs.writeFile(metaPath(sessionId), JSON.stringify(metadata, null, 2), 'utf8');
+    await fs.writeFile(requestPath(sessionId), JSON.stringify(metadata.options, null, 2), 'utf8');
+    await fs.writeFile(logPath(sessionId), '', 'utf8');
+    return metadata;
+}
+export async function readSessionMetadata(sessionId) {
+    try {
+        const raw = await fs.readFile(metaPath(sessionId), 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export async function updateSessionMetadata(sessionId, updates) {
+    const existing = (await readSessionMetadata(sessionId)) ?? { id: sessionId };
+    const next = { ...existing, ...updates };
+    await fs.writeFile(metaPath(sessionId), JSON.stringify(next, null, 2), 'utf8');
+    return next;
+}
+export function createSessionLogWriter(sessionId) {
+    const stream = createWriteStream(logPath(sessionId), { flags: 'a' });
+    const logLine = (line = '') => {
+        stream.write(`${line}\n`);
+    };
+    const writeChunk = (chunk) => {
+        stream.write(chunk);
+        return true;
+    };
+    return { stream, logLine, writeChunk, logPath: logPath(sessionId) };
+}
+export async function listSessionsMetadata() {
+    await ensureSessionStorage();
+    const entries = await fs.readdir(SESSIONS_DIR).catch(() => []);
+    const metas = [];
+    for (const entry of entries) {
+        const meta = await readSessionMetadata(entry);
+        if (meta) {
+            metas.push(meta);
+        }
+    }
+    return metas.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+}
+export function filterSessionsByRange(metas, { hours = 24, includeAll = false, limit = 100 }) {
+    const maxLimit = Math.min(limit, MAX_STATUS_LIMIT);
+    let filtered = metas;
+    if (!includeAll) {
+        const cutoff = Date.now() - hours * 60 * 60 * 1000;
+        filtered = metas.filter((meta) => new Date(meta.createdAt).getTime() >= cutoff);
+    }
+    const limited = filtered.slice(0, maxLimit);
+    const truncated = filtered.length > maxLimit;
+    return { entries: limited, truncated, total: filtered.length };
+}
+export async function readSessionLog(sessionId) {
+    try {
+        return await fs.readFile(logPath(sessionId), 'utf8');
+    }
+    catch {
+        return '';
+    }
+}
+export async function deleteSessionsOlderThan({ hours = 24, includeAll = false, } = {}) {
+    await ensureSessionStorage();
+    const entries = await fs.readdir(SESSIONS_DIR).catch(() => []);
+    if (!entries.length) {
+        return { deleted: 0, remaining: 0 };
+    }
+    const cutoff = includeAll ? Number.NEGATIVE_INFINITY : Date.now() - hours * 60 * 60 * 1000;
+    let deleted = 0;
+    for (const entry of entries) {
+        const dir = sessionDir(entry);
+        let createdMs;
+        const meta = await readSessionMetadata(entry);
+        if (meta?.createdAt) {
+            const parsed = Date.parse(meta.createdAt);
+            if (!Number.isNaN(parsed)) {
+                createdMs = parsed;
+            }
+        }
+        if (createdMs == null) {
+            try {
+                const stats = await fs.stat(dir);
+                createdMs = stats.birthtimeMs || stats.mtimeMs;
+            }
+            catch {
+                continue;
+            }
+        }
+        if (includeAll || (createdMs != null && createdMs < cutoff)) {
+            await fs.rm(dir, { recursive: true, force: true });
+            deleted += 1;
+        }
+    }
+    const remaining = Math.max(entries.length - deleted, 0);
+    return { deleted, remaining };
+}
+export async function wait(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export { ORACLE_HOME, SESSIONS_DIR, MAX_STATUS_LIMIT };

package/dist/oracle/src/version.js

@@ -0,0 +1,39 @@
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+let cachedVersion = null;
+export function getCliVersion() {
+    if (cachedVersion) {
+        return cachedVersion;
+    }
+    cachedVersion = readVersionFromPackage();
+    return cachedVersion;
+}
+function readVersionFromPackage() {
+    const modulePath = fileURLToPath(import.meta.url);
+    let currentDir = path.dirname(modulePath);
+    const filesystemRoot = path.parse(currentDir).root;
+    // biome-ignore lint/nursery/noUnnecessaryConditions: deliberate sentinel loop to walk up directories
+    while (true) {
+        const candidate = path.join(currentDir, 'package.json');
+        try {
+            const raw = readFileSync(candidate, 'utf8');
+            const parsed = JSON.parse(raw);
+            const version = typeof parsed.version === 'string' && parsed.version.trim().length > 0
+                ? parsed.version.trim()
+                : '0.0.0';
+            return version;
+        }
+        catch (error) {
+            const code = error instanceof Error && 'code' in error ? error.code : undefined;
+            if (code && code !== 'ENOENT') {
+                break;
+            }
+        }
+        if (currentDir === filesystemRoot) {
+            break;
+        }
+        currentDir = path.dirname(currentDir);
+    }
+    return '0.0.0';
+}

package/dist/scripts/chrome/browser-tools.js

@@ -0,0 +1,295 @@
+import { Command } from 'commander';
+import { execSync, spawn } from 'node:child_process';
+import os from 'node:os';
+import path from 'node:path';
+import puppeteer from 'puppeteer-core';
+const DEFAULT_PORT = 9222;
+const DEFAULT_PROFILE_DIR = path.join(os.homedir(), '.cache', 'scraping');
+const DEFAULT_CHROME_BIN = '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome';
+function browserURL(port) {
+    return `http://localhost:${port}`;
+}
+async function connectBrowser(port) {
+    return puppeteer.connect({ browserURL: browserURL(port), defaultViewport: null });
+}
+async function getActivePage(port) {
+    const browser = await connectBrowser(port);
+    const pages = await browser.pages();
+    const page = pages.at(-1);
+    if (!page) {
+        await browser.disconnect();
+        throw new Error('No active tab found');
+    }
+    return { browser, page };
+}
+const program = new Command();
+program
+    .name('browser-tools')
+    .description('Minimal Chrome DevTools helpers inspired by Mario Zechner’s “What if you don’t need MCP?” article.')
+    .configureHelp({
+    sortSubcommands: true,
+})
+    .showSuggestionAfterError();
+program
+    .command('start')
+    .description('Launch Chrome with remote debugging enabled.')
+    .option('-p, --port <number>', 'Remote debugging port (default: 9222)', (value) => Number.parseInt(value, 10), DEFAULT_PORT)
+    .option('--profile', 'Copy your existing Chrome profile before launching.', false)
+    .option('--profile-dir <path>', 'Directory for the temporary Chrome profile.', DEFAULT_PROFILE_DIR)
+    .option('--chrome-path <path>', 'Path to the Chrome binary.', DEFAULT_CHROME_BIN)
+    .action(async (options) => {
+    const { port, profile, profileDir, chromePath } = options;
+    try {
+        execSync("killall 'Google Chrome'", { stdio: 'ignore' });
+    }
+    catch {
+        // ignore
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+    execSync(`mkdir -p "${profileDir}"`);
+    if (profile) {
+        const source = path.join(os.homedir(), 'Library', 'Application Support', 'Google', 'Chrome') + '/';
+        execSync(`rsync -a --delete "${source}" "${profileDir}/"`, { stdio: 'ignore' });
+    }
+    spawn(chromePath, ['--remote-debugging-port=' + port, `--user-data-dir=${profileDir}`, '--no-first-run', '--disable-popup-blocking'], {
+        detached: true,
+        stdio: 'ignore',
+    }).unref();
+    let connected = false;
+    for (let attempt = 0; attempt < 30; attempt++) {
+        try {
+            const browser = await connectBrowser(port);
+            await browser.disconnect();
+            connected = true;
+            break;
+        }
+        catch {
+            await new Promise((resolve) => setTimeout(resolve, 500));
+        }
+    }
+    if (!connected) {
+        console.error(`✗ Failed to start Chrome on port ${port}`);
+        process.exit(1);
+    }
+    console.log(`✓ Chrome listening on http://localhost:${port}${profile ? ' (with your profile)' : ''}`);
+});
+program
+    .command('nav <url>')
+    .description('Navigate the current tab or open a new tab.')
+    .option('--port <number>', 'Debugger port (default: 9222)', (value) => Number.parseInt(value, 10), DEFAULT_PORT)
+    .option('--new', 'Open in a new tab instead of reusing the current tab.', false)
+    .action(async (url, options) => {
+    const port = options.port;
+    const browser = await connectBrowser(port);
+    try {
+        if (options.new) {
+            const page = await browser.newPage();
+            await page.goto(url, { waitUntil: 'domcontentloaded' });
+            console.log('✓ Opened in new tab:', url);
+        }
+        else {
+            const pages = await browser.pages();
+            const page = pages.at(-1);
+            if (!page) {
+                throw new Error('No active tab found');
+            }
+            await page.goto(url, { waitUntil: 'domcontentloaded' });
+            console.log('✓ Navigated current tab to:', url);
+        }
+    }
+    finally {
+        await browser.disconnect();
+    }
+});
+program
+    .command('eval <code...>')
+    .description('Evaluate JavaScript in the active page context.')
+    .option('--port <number>', 'Debugger port (default: 9222)', (value) => Number.parseInt(value, 10), DEFAULT_PORT)
+    .action(async (code, options) => {
+    const snippet = code.join(' ');
+    const port = options.port;
+    const { browser, page } = await getActivePage(port);
+    try {
+        const result = await page.evaluate((body) => {
+            const AsyncFunctionConstructor = Object.getPrototypeOf(async function () { }).constructor;
+            return new AsyncFunctionConstructor(`return (${body})`)();
+        }, snippet);
+        if (Array.isArray(result)) {
+            result.forEach((entry, index) => {
+                if (index > 0)
+                    console.log('');
+                Object.entries(entry).forEach(([key, value]) => console.log(`${key}: ${value}`));
+            });
+        }
+        else if (typeof result === 'object' && result !== null) {
+            Object.entries(result).forEach(([key, value]) => console.log(`${key}: ${value}`));
+        }
+        else {
+            console.log(result);
+        }
+    }
+    finally {
+        await browser.disconnect();
+    }
+});
+program
+    .command('screenshot')
+    .description('Capture the current viewport and print the temp PNG path.')
+    .option('--port <number>', 'Debugger port (default: 9222)', (value) => Number.parseInt(value, 10), DEFAULT_PORT)
+    .action(async (options) => {
+    const port = options.port;
+    const { browser, page } = await getActivePage(port);
+    try {
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const filePath = path.join(os.tmpdir(), `screenshot-${timestamp}.png`);
+        await page.screenshot({ path: filePath });
+        console.log(filePath);
+    }
+    finally {
+        await browser.disconnect();
+    }
+});
+program
+    .command('pick <message...>')
+    .description('Interactive DOM picker that prints metadata for clicked elements.')
+    .option('--port <number>', 'Debugger port (default: 9222)', (value) => Number.parseInt(value, 10), DEFAULT_PORT)
+    .action(async (messageParts, options) => {
+    const message = messageParts.join(' ');
+    const port = options.port;
+    const { browser, page } = await getActivePage(port);
+    try {
+        await page.evaluate(() => {
+            const scope = globalThis;
+            if (scope.pickOverlayInjected) {
+                return;
+            }
+            scope.pickOverlayInjected = true;
+            scope.pick = async (prompt) => new Promise((resolve) => {
+                const selections = [];
+                const selectedElements = new Set();
+                const overlay = document.createElement('div');
+                overlay.style.cssText =
+                    'position:fixed;top:0;left:0;width:100%;height:100%;z-index:2147483647;pointer-events:none';
+                const highlight = document.createElement('div');
+                highlight.style.cssText =
+                    'position:absolute;border:2px solid #3b82f6;background:rgba(59,130,246,0.1);transition:all 0.05s ease';
+                overlay.appendChild(highlight);
+                const banner = document.createElement('div');
+                banner.style.cssText =
+                    'position:fixed;bottom:20px;left:50%;transform:translateX(-50%);background:#1f2937;color:#fff;padding:12px 24px;border-radius:8px;font:14px system-ui;box-shadow:0 4px 12px rgba(0,0,0,0.3);pointer-events:auto;z-index:2147483647';
+                const updateBanner = () => {
+                    banner.textContent = `${prompt} (${selections.length} selected, Cmd/Ctrl+click to add, Enter to finish, ESC to cancel)`;
+                };
+                const cleanup = () => {
+                    document.removeEventListener('mousemove', onMove, true);
+                    document.removeEventListener('click', onClick, true);
+                    document.removeEventListener('keydown', onKey, true);
+                    overlay.remove();
+                    banner.remove();
+                    selectedElements.forEach((el) => (el.style.outline = ''));
+                };
+                const serialize = (el) => {
+                    const parents = [];
+                    let current = el.parentElement;
+                    while (current && current !== document.body) {
+                        const id = current.id ? `#${current.id}` : '';
+                        const cls = current.className ? `.${current.className.trim().split(/\\s+/).join('.')}` : '';
+                        parents.push(`${current.tagName.toLowerCase()}${id}${cls}`);
+                        current = current.parentElement;
+                    }
+                    return {
+                        tag: el.tagName.toLowerCase(),
+                        id: el.id || null,
+                        class: el.className || null,
+                        text: el.textContent?.trim()?.slice(0, 200) || null,
+                        html: el.outerHTML.slice(0, 500),
+                        parents: parents.join(' > '),
+                    };
+                };
+                const onMove = (event) => {
+                    const node = document.elementFromPoint(event.clientX, event.clientY);
+                    if (!node || overlay.contains(node) || banner.contains(node))
+                        return;
+                    const rect = node.getBoundingClientRect();
+                    highlight.style.cssText = `position:absolute;border:2px solid #3b82f6;background:rgba(59,130,246,0.1);top:${rect.top}px;left:${rect.left}px;width:${rect.width}px;height:${rect.height}px`;
+                };
+                const onClick = (event) => {
+                    if (banner.contains(event.target))
+                        return;
+                    event.preventDefault();
+                    event.stopPropagation();
+                    const node = document.elementFromPoint(event.clientX, event.clientY);
+                    if (!node || overlay.contains(node) || banner.contains(node))
+                        return;
+                    if (event.metaKey || event.ctrlKey) {
+                        if (!selectedElements.has(node)) {
+                            selectedElements.add(node);
+                            node.style.outline = '3px solid #10b981';
+                            selections.push(serialize(node));
+                            updateBanner();
+                        }
+                    }
+                    else {
+                        cleanup();
+                        const info = serialize(node);
+                        resolve(selections.length > 0 ? selections : info);
+                    }
+                };
+                const onKey = (event) => {
+                    if (event.key === 'Escape') {
+                        cleanup();
+                        resolve(null);
+                    }
+                    else if (event.key === 'Enter' && selections.length > 0) {
+                        cleanup();
+                        resolve(selections);
+                    }
+                };
+                document.addEventListener('mousemove', onMove, true);
+                document.addEventListener('click', onClick, true);
+                document.addEventListener('keydown', onKey, true);
+                document.body.append(overlay, banner);
+                updateBanner();
+            });
+        });
+        const result = await page.evaluate((msg) => {
+            const pickFn = window.pick;
+            if (!pickFn) {
+                return null;
+            }
+            return pickFn(msg);
+        }, message);
+        if (Array.isArray(result)) {
+            result.forEach((entry, index) => {
+                if (index > 0)
+                    console.log('');
+                Object.entries(entry).forEach(([key, value]) => console.log(`${key}: ${value}`));
+            });
+        }
+        else if (result && typeof result === 'object') {
+            Object.entries(result).forEach(([key, value]) => console.log(`${key}: ${value}`));
+        }
+        else {
+            console.log(result);
+        }
+    }
+    finally {
+        await browser.disconnect();
+    }
+});
+program
+    .command('cookies')
+    .description('Dump cookies from the active tab as JSON.')
+    .option('--port <number>', 'Debugger port (default: 9222)', (value) => Number.parseInt(value, 10), DEFAULT_PORT)
+    .action(async (options) => {
+    const port = options.port;
+    const { browser, page } = await getActivePage(port);
+    try {
+        const cookies = await page.cookies();
+        console.log(JSON.stringify(cookies, null, 2));
+    }
+    finally {
+        await browser.disconnect();
+    }
+});
+program.parseAsync(process.argv);

package/dist/scripts/git-policy.js

@@ -1,5 +1,4 @@
 import { resolve } from "node:path";
-const COMMIT_HELPER_SUBCOMMANDS = new Set(["add", "commit"]);
 const GUARDED_SUBCOMMANDS = new Set(["push", "pull", "merge", "rebase", "cherry-pick"]);
 const DESTRUCTIVE_SUBCOMMANDS = new Set([
     "reset",
@@ -90,12 +89,6 @@ export function analyzeGitExecution(commandArgs, workspaceDir) {
         workDir,
     };
 }
-export function requiresCommitHelper(subcommand) {
-    if (!subcommand) {
-        return false;
-    }
-    return COMMIT_HELPER_SUBCOMMANDS.has(subcommand);
-}
 export function requiresExplicitGitConsent(subcommand) {
     if (!subcommand) {
         return false;
@@ -120,7 +113,6 @@ export function evaluateGitPolicies(context) {
     const invocationArgv = context.invocation?.argv;
     const normalizedArgv = Array.isArray(invocationArgv) ? invocationArgv : [];
     return {
-        requiresCommitHelper: requiresCommitHelper(context.subcommand),
         requiresExplicitConsent: requiresExplicitGitConsent(context.subcommand),
         isDestructive: isDestructiveGitSubcommand(context.command, normalizedArgv),
     };

package/dist/scripts/runner.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 /**
  * Sweetistics runner wrapper: enforces timeouts, git policy, and trash-safe deletes before dispatching any repo command.
- * When you tweak its behavior, add a short note to AGENTS.md via `./scripts/committer "docs: update AGENTS for runner" "AGENTS.md"` so other agents know the new expectations.
+ * When you tweak its behavior, add a short note to AGENTS.md so other agents know the new expectations.
  */
 import { spawn } from "node:child_process";
 import { cpSync, existsSync, renameSync, rmSync } from "node:fs";
@@ -670,10 +670,6 @@ function enforceGitPolicies(gitContext) {
         console.error('git rebase requires the user to explicitly type "rebase" in chat. Once they do, rerun with RUNNER_THE_USER_GAVE_ME_CONSENT=1 in the same command (e.g. RUNNER_THE_USER_GAVE_ME_CONSENT=1 ./runner git rebase --continue).');
         process.exit(1);
     }
-    if (evaluation.requiresCommitHelper) {
-        console.error('Direct git add/commit is disabled. Use ./scripts/committer "chore(runner): describe change" "scripts/runner.ts" instead—see AGENTS.md and ./scripts/committer for details. The helper auto-stashes unrelated files before committing.');
-        process.exit(1);
-    }
     if (evaluation.requiresExplicitConsent || evaluation.isDestructive) {
         if (hasConsentOverride) {
             if (ENABLE_DEBUG_LOGS) {