@steipete/oracle 1.1.0 → 1.2.0

package/dist/src/cli/notifier.js

@@ -0,0 +1,223 @@
+import notifier from 'toasted-notifier';
+import { spawn } from 'node:child_process';
+import { formatUSD, formatNumber } from '../oracle/format.js';
+import { MODEL_CONFIGS } from '../oracle/config.js';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+const ORACLE_EMOJI = '🧿';
+export function resolveNotificationSettings({ cliNotify, cliNotifySound, env, config, }) {
+    const defaultEnabled = !(bool(env.CI) || bool(env.SSH_CONNECTION) || muteByConfig(env, config));
+    const envNotify = parseToggle(env.ORACLE_NOTIFY);
+    const envSound = parseToggle(env.ORACLE_NOTIFY_SOUND);
+    const enabled = cliNotify ?? envNotify ?? config?.enabled ?? defaultEnabled;
+    const sound = cliNotifySound ?? envSound ?? config?.sound ?? false;
+    return { enabled, sound };
+}
+export function deriveNotificationSettingsFromMetadata(metadata, env, config) {
+    if (metadata?.notifications) {
+        return metadata.notifications;
+    }
+    return resolveNotificationSettings({ cliNotify: undefined, cliNotifySound: undefined, env, config });
+}
+export async function sendSessionNotification(payload, settings, log, answerPreview) {
+    if (!settings.enabled || isTestEnv(process.env)) {
+        return;
+    }
+    const title = `Oracle${ORACLE_EMOJI} finished`;
+    const message = buildMessage(payload, sanitizePreview(answerPreview));
+    try {
+        if (await tryMacNativeNotifier(title, message, settings)) {
+            return;
+        }
+        // Fallback to toasted-notifier (cross-platform). macAppIconOption() is only honored on macOS.
+        await notifier.notify({
+            title,
+            message,
+            sound: settings.sound,
+        });
+    }
+    catch (error) {
+        if (isMacExecError(error)) {
+            const repaired = await repairMacNotifier(log);
+            if (repaired) {
+                try {
+                    await notifier.notify({ title, message, sound: settings.sound, ...(macAppIconOption()) });
+                    return;
+                }
+                catch (retryError) {
+                    const reason = retryError instanceof Error ? retryError.message : String(retryError);
+                    log(`(notify skipped after retry: ${reason})`);
+                    return;
+                }
+            }
+        }
+        const reason = error instanceof Error ? error.message : String(error);
+        log(`(notify skipped: ${reason})`);
+    }
+}
+function buildMessage(payload, answerPreview) {
+    const parts = [];
+    const sessionLabel = payload.sessionName || payload.sessionId;
+    parts.push(sessionLabel);
+    // Show cost only for API runs.
+    if (payload.mode === 'api') {
+        const cost = payload.costUsd ?? inferCost(payload);
+        if (cost !== undefined) {
+            // Round to $0.00 for a concise toast.
+            parts.push(formatUSD(Number(cost.toFixed(2))));
+        }
+    }
+    if (payload.characters != null) {
+        parts.push(`${formatNumber(payload.characters)} chars`);
+    }
+    if (answerPreview) {
+        parts.push(answerPreview);
+    }
+    return parts.join(' · ');
+}
+function sanitizePreview(preview) {
+    if (!preview)
+        return undefined;
+    let text = preview;
+    // Strip code fences and inline code markers.
+    text = text.replace(/```[\s\S]*?```/g, ' ');
+    text = text.replace(/`([^`]+)`/g, '$1');
+    // Convert markdown links and images to their visible text.
+    text = text.replace(/!\[([^\]]*)\]\([^)]+\)/g, '$1');
+    text = text.replace(/\[([^\]]+)\]\([^)]+\)/g, '$1');
+    // Drop bold/italic markers.
+    text = text.replace(/(\*\*|__|\*|_)/g, '');
+    // Remove headings / list markers / blockquotes.
+    text = text.replace(/^\s*#+\s*/gm, '');
+    text = text.replace(/^\s*[-*+]\s+/gm, '');
+    text = text.replace(/^\s*>\s+/gm, '');
+    // Collapse whitespace and trim.
+    text = text.replace(/\s+/g, ' ').trim();
+    // Limit length to keep notifications short.
+    const max = 200;
+    if (text.length > max) {
+        text = `${text.slice(0, max - 1)}…`;
+    }
+    return text;
+}
+// Exposed for unit tests only.
+export const testHelpers = { sanitizePreview };
+function inferCost(payload) {
+    const model = payload.model;
+    const usage = payload.usage;
+    if (!model || !usage)
+        return undefined;
+    const config = MODEL_CONFIGS[model];
+    if (!config)
+        return undefined;
+    return (usage.inputTokens * config.pricing.inputPerToken +
+        usage.outputTokens * config.pricing.outputPerToken);
+}
+function parseToggle(value) {
+    if (value == null)
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    if (['1', 'true', 'yes', 'on'].includes(normalized))
+        return true;
+    if (['0', 'false', 'no', 'off'].includes(normalized))
+        return false;
+    return undefined;
+}
+function bool(value) {
+    return Boolean(value && String(value).length > 0);
+}
+function isMacExecError(error) {
+    return Boolean(process.platform === 'darwin' &&
+        error &&
+        typeof error === 'object' &&
+        'code' in error &&
+        error.code === 'EACCES');
+}
+async function repairMacNotifier(log) {
+    const binPath = macNotifierPath();
+    if (!binPath)
+        return false;
+    try {
+        await fs.chmod(binPath, 0o755);
+        return true;
+    }
+    catch (chmodError) {
+        const reason = chmodError instanceof Error ? chmodError.message : String(chmodError);
+        log(`(notify repair failed: ${reason} — try: xattr -dr com.apple.quarantine "${path.dirname(binPath)}")`);
+        return false;
+    }
+}
+function macNotifierPath() {
+    if (process.platform !== 'darwin')
+        return null;
+    try {
+        const req = createRequire(import.meta.url);
+        const modPath = req.resolve('toasted-notifier');
+        const base = path.dirname(modPath);
+        return path.join(base, 'vendor', 'mac.noindex', 'terminal-notifier.app', 'Contents', 'MacOS', 'terminal-notifier');
+    }
+    catch {
+        return null;
+    }
+}
+function macAppIconOption() {
+    if (process.platform !== 'darwin')
+        return {};
+    const iconPaths = [
+        path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../assets-oracle-icon.png'),
+        path.resolve(process.cwd(), 'assets-oracle-icon.png'),
+    ];
+    for (const candidate of iconPaths) {
+        if (candidate && fsExistsSync(candidate)) {
+            return { appIcon: candidate };
+        }
+    }
+    return {};
+}
+function fsExistsSync(target) {
+    try {
+        return Boolean(require('node:fs').statSync(target));
+    }
+    catch {
+        return false;
+    }
+}
+async function tryMacNativeNotifier(title, message, settings) {
+    const binary = macNativeNotifierPath();
+    if (!binary)
+        return false;
+    return new Promise((resolve) => {
+        const child = spawn(binary, [title, message, settings.sound ? 'Glass' : ''], {
+            stdio: 'ignore',
+        });
+        child.on('error', () => resolve(false));
+        child.on('exit', (code) => resolve(code === 0));
+    });
+}
+function macNativeNotifierPath() {
+    if (process.platform !== 'darwin')
+        return null;
+    const candidates = [
+        path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../vendor/oracle-notifier/OracleNotifier.app/Contents/MacOS/OracleNotifier'),
+        path.resolve(process.cwd(), 'vendor/oracle-notifier/OracleNotifier.app/Contents/MacOS/OracleNotifier'),
+    ];
+    for (const candidate of candidates) {
+        if (fsExistsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function muteByConfig(env, config) {
+    if (!config?.muteIn)
+        return false;
+    return ((config.muteIn.includes('CI') && bool(env.CI)) ||
+        (config.muteIn.includes('SSH') && bool(env.SSH_CONNECTION)));
+}
+function isTestEnv(env) {
+    return (env.ORACLE_DISABLE_NOTIFICATIONS === '1' ||
+        env.NODE_ENV === 'test' ||
+        Boolean(env.VITEST || env.VITEST_WORKER_ID || env.JEST_WORKER_ID));
+}

package/dist/src/cli/promptRequirement.js

@@ -2,6 +2,9 @@
  * Determine whether the CLI should enforce a prompt requirement based on raw args and options.
  */
 export function shouldRequirePrompt(rawArgs, options) {
+    if (rawArgs.length === 0) {
+        return !options.prompt;
+    }
     const firstArg = rawArgs[0];
     const bypassPrompt = Boolean(options.session ||
         options.execSession ||

package/dist/src/cli/runOptions.js

@@ -0,0 +1,29 @@
+import { resolveEngine } from './engine.js';
+import { normalizeModelOption, inferModelFromLabel, resolveApiModel } from './options.js';
+export function resolveRunOptionsFromConfig({ prompt, files = [], model, engine, userConfig, env = process.env, }) {
+    const resolvedEngine = resolveEngineWithConfig({ engine, configEngine: userConfig?.engine, env });
+    const cliModelArg = normalizeModelOption(model ?? userConfig?.model) || 'gpt-5-pro';
+    const resolvedModel = resolvedEngine === 'browser' ? inferModelFromLabel(cliModelArg) : resolveApiModel(cliModelArg);
+    const promptWithSuffix = userConfig?.promptSuffix && userConfig.promptSuffix.trim().length > 0
+        ? `${prompt.trim()}\n${userConfig.promptSuffix}`
+        : prompt;
+    const search = userConfig?.search !== 'off';
+    const heartbeatIntervalMs = userConfig?.heartbeatSeconds !== undefined ? userConfig.heartbeatSeconds * 1000 : 30_000;
+    const runOptions = {
+        prompt: promptWithSuffix,
+        model: resolvedModel,
+        file: files ?? [],
+        search,
+        heartbeatIntervalMs,
+        filesReport: userConfig?.filesReport,
+        background: userConfig?.background,
+    };
+    return { runOptions, resolvedEngine };
+}
+function resolveEngineWithConfig({ engine, configEngine, env, }) {
+    if (engine)
+        return engine;
+    if (configEngine)
+        return configEngine;
+    return resolveEngine({ engine: undefined, env });
+}

package/dist/src/cli/sessionCommand.js

@@ -77,7 +77,7 @@ export async function handleSessionCommand(sessionId, command, deps = defaultDep
         console.log(`Ignoring flags on session attach: ${ignoredFlags.join(', ')}`);
     }
     const renderMarkdown = Boolean(sessionOptions.render || sessionOptions.renderMarkdown || autoRender);
-    await deps.attachSession(sessionId, { renderMarkdown });
+    await deps.attachSession(sessionId, { renderMarkdown, renderPrompt: !sessionOptions.hidePrompt });
 }
 export function formatSessionCleanupMessage(result, scope) {
     const deletedLabel = `${result.deleted} ${result.deleted === 1 ? 'session' : 'sessions'}`;

package/dist/src/cli/sessionDisplay.js

@@ -1,10 +1,12 @@
 import chalk from 'chalk';
 import kleur from 'kleur';
-import { filterSessionsByRange, listSessionsMetadata, readSessionLog, readSessionMetadata, SESSIONS_DIR, wait, } from '../sessionManager.js';
+import { filterSessionsByRange, listSessionsMetadata, readSessionLog, readSessionMetadata, readSessionRequest, SESSIONS_DIR, wait, } from '../sessionManager.js';
 import { renderMarkdownAnsi } from './markdownRenderer.js';
+import { formatElapsed, formatUSD } from '../oracle/format.js';
+import { MODEL_CONFIGS } from '../oracle.js';
 const isTty = () => Boolean(process.stdout.isTTY);
 const dim = (text) => (isTty() ? kleur.dim(text) : text);
-const MAX_RENDER_BYTES = 200_000;
+export const MAX_RENDER_BYTES = 200_000;
 const CLEANUP_TIP = 'Tip: Run "oracle session --clear --hours 24" to prune cached runs (add --all to wipe everything).';
 export async function showStatus({ hours, includeAll, limit, showExamples = false }) {
     const metas = await listSessionsMetadata();
@@ -18,12 +20,17 @@ export async function showStatus({ hours, includeAll, limit, showExamples = fals
         return;
     }
     console.log(chalk.bold('Recent Sessions'));
+    console.log(chalk.dim('Timestamp             Chars  Cost  Status     Model      ID'));
     for (const entry of entries) {
         const statusRaw = (entry.status || 'unknown').padEnd(9);
         const status = richTty ? colorStatus(entry.status ?? 'unknown', statusRaw) : statusRaw;
         const model = (entry.model || 'n/a').padEnd(9);
-        const created = entry.createdAt.replace('T', ' ').replace('Z', '');
-        console.log(`${created} | ${status} | ${model} | ${entry.id}`);
+        const created = formatTimestamp(entry.createdAt);
+        const chars = entry.options?.prompt?.length ?? entry.promptPreview?.length ?? 0;
+        const charLabel = chars > 0 ? String(chars).padStart(5) : '    -';
+        const costValue = resolveCost(entry);
+        const costLabel = costValue != null ? formatCostTable(costValue) : '     -';
+        console.log(`${created} | ${charLabel} | ${costLabel} | ${status} | ${model} | ${entry.id}`);
     }
     if (truncated) {
         console.log(chalk.yellow(`Showing ${entries.length} of ${total} sessions from the requested range. Run "oracle session --clear" or delete entries in ${SESSIONS_DIR} to free space, or rerun with --status-limit/--status-all.`));
@@ -76,6 +83,14 @@ export async function attachSession(sessionId, options) {
         }
     }
     const shouldTrimIntro = initialStatus === 'completed' || initialStatus === 'error';
+    if (options?.renderPrompt !== false) {
+        const prompt = await readStoredPrompt(sessionId);
+        if (prompt) {
+            console.log(chalk.bold('Prompt:'));
+            console.log(renderMarkdownAnsi(prompt));
+            console.log(dim('---'));
+        }
+    }
     if (shouldTrimIntro) {
         const fullLog = await readSessionLog(sessionId);
         const trimmed = trimBeforeFirstAnswer(fullLog);
@@ -104,6 +119,10 @@ export async function attachSession(sessionId, options) {
         else {
             process.stdout.write(trimmed);
         }
+        const summary = formatCompletionSummary(metadata, { includeSlug: true });
+        if (summary) {
+            console.log(`\n${chalk.green.bold(summary)}`);
+        }
         return;
     }
     if (wantsRender) {
@@ -187,9 +206,15 @@ export async function attachSession(sessionId, options) {
                     console.log('\nResult:');
                     console.log(`Session failed: ${latest.errorMessage}`);
                 }
-                if (latest.usage && initialStatus === 'running') {
-                    const usage = latest.usage;
-                    console.log(`\nFinished (tok i/o/r/t: ${usage.inputTokens}/${usage.outputTokens}/${usage.reasoningTokens}/${usage.totalTokens})`);
+                if (latest.status === 'completed' && latest.usage) {
+                    const summary = formatCompletionSummary(latest, { includeSlug: true });
+                    if (summary) {
+                        console.log(`\n${chalk.green.bold(summary)}`);
+                    }
+                    else {
+                        const usage = latest.usage;
+                        console.log(`\nFinished (tok i/o/r/t: ${usage.inputTokens}/${usage.outputTokens}/${usage.reasoningTokens}/${usage.totalTokens})`);
+                    }
                 }
             }
             break;
@@ -359,3 +384,65 @@ function extractRenderableChunks(text, state) {
     }
     return { chunks, remainder: buffer };
 }
+function formatTimestamp(iso) {
+    const date = new Date(iso);
+    const locale = 'en-US';
+    const opts = {
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: 'numeric',
+        minute: '2-digit',
+        second: undefined,
+        hour12: true,
+    };
+    const formatted = date.toLocaleString(locale, opts);
+    return formatted.replace(/(, )(\d:)/, '$1 $2');
+}
+export function formatCompletionSummary(metadata, options = {}) {
+    if (!metadata.usage || metadata.elapsedMs == null) {
+        return null;
+    }
+    const modeLabel = metadata.mode === 'browser' ? `${metadata.model ?? 'n/a'}[browser]` : metadata.model ?? 'n/a';
+    const usage = metadata.usage;
+    const cost = metadata.mode === 'browser' ? null : resolveCost(metadata);
+    const costPart = cost != null ? ` | ${formatUSD(cost)}` : '';
+    const tokensDisplay = `${usage.inputTokens}/${usage.outputTokens}/${usage.reasoningTokens}/${usage.totalTokens}`;
+    const filesCount = metadata.options?.file?.length ?? 0;
+    const filesPart = filesCount > 0 ? ` | files=${filesCount}` : '';
+    const slugPart = options.includeSlug ? ` | slug=${metadata.id}` : '';
+    return `Finished in ${formatElapsed(metadata.elapsedMs)} (${modeLabel}${costPart} | tok(i/o/r/t)=${tokensDisplay}${filesPart}${slugPart})`;
+}
+function resolveCost(metadata) {
+    if (metadata.mode === 'browser') {
+        return null;
+    }
+    if (metadata.usage?.cost != null) {
+        return metadata.usage.cost;
+    }
+    if (!metadata.model || !metadata.usage) {
+        return null;
+    }
+    const pricing = MODEL_CONFIGS[metadata.model]?.pricing;
+    if (!pricing) {
+        return null;
+    }
+    const input = metadata.usage.inputTokens ?? 0;
+    const output = metadata.usage.outputTokens ?? 0;
+    const cost = input * pricing.inputPerToken + output * pricing.outputPerToken;
+    return cost > 0 ? cost : null;
+}
+function formatCostTable(cost) {
+    return `$${cost.toFixed(3)}`.padStart(7);
+}
+async function readStoredPrompt(sessionId) {
+    const request = await readSessionRequest(sessionId);
+    if (request?.prompt && request.prompt.trim().length > 0) {
+        return request.prompt;
+    }
+    const meta = await readSessionMetadata(sessionId);
+    if (meta?.options?.prompt && meta.options.prompt.trim().length > 0) {
+        return meta.options.prompt;
+    }
+    return null;
+}

package/dist/src/cli/sessionRunner.js

@@ -1,18 +1,20 @@
 import kleur from 'kleur';
 import { updateSessionMetadata } from '../sessionManager.js';
-import { runOracle, OracleResponseError, OracleTransportError, extractResponseMetadata, asOracleUserError, } from '../oracle.js';
+import { runOracle, OracleResponseError, OracleTransportError, extractResponseMetadata, asOracleUserError, extractTextOutput, } from '../oracle.js';
 import { runBrowserSessionExecution } from '../browser/sessionRunner.js';
 import { formatResponseMetadata, formatTransportMetadata } from './sessionDisplay.js';
 import { markErrorLogged } from './errorUtils.js';
+import { sendSessionNotification, deriveNotificationSettingsFromMetadata, } from './notifier.js';
 const isTty = process.stdout.isTTY;
 const dim = (text) => (isTty ? kleur.dim(text) : text);
-export async function performSessionRun({ sessionMeta, runOptions, mode, browserConfig, cwd, log, write, version, }) {
+export async function performSessionRun({ sessionMeta, runOptions, mode, browserConfig, cwd, log, write, version, notifications, }) {
     await updateSessionMetadata(sessionMeta.id, {
         status: 'running',
         startedAt: new Date().toISOString(),
         mode,
         ...(browserConfig ? { browser: { config: browserConfig } } : {}),
     });
+    const notificationSettings = notifications ?? deriveNotificationSettingsFromMetadata(sessionMeta, process.env);
     try {
         if (mode === 'browser') {
             if (!browserConfig) {
@@ -32,6 +34,14 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                 transport: undefined,
                 error: undefined,
             });
+            await sendSessionNotification({
+                sessionId: sessionMeta.id,
+                sessionName: sessionMeta.options?.slug ?? sessionMeta.id,
+                mode,
+                model: sessionMeta.model,
+                usage: result.usage,
+                characters: result.answerText?.length,
+            }, notificationSettings, log, result.answerText?.slice(0, 140));
             return;
         }
         const result = await runOracle(runOptions, {
@@ -51,6 +61,15 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
             transport: undefined,
             error: undefined,
         });
+        const answerText = extractTextOutput(result.response);
+        await sendSessionNotification({
+            sessionId: sessionMeta.id,
+            sessionName: sessionMeta.options?.slug ?? sessionMeta.id,
+            mode,
+            model: sessionMeta.model ?? runOptions.model,
+            usage: result.usage,
+            characters: answerText.length,
+        }, notificationSettings, log, answerText.slice(0, 140));
     }
     catch (error) {
         const message = formatError(error);