@steipete/oracle 0.12.0 → 0.13.0

package/dist/src/oracle/run.js

@@ -14,7 +14,7 @@ import { getFileTokenStats, printFileTokenStats } from "./tokenStats.js";
 import { OracleResponseError, OracleTransportError, PromptValidationError, describeTransportError, toTransportError, } from "./errors.js";
 import { isCustomBaseUrl } from "./baseUrl.js";
 import { createDefaultClientFactory } from "./client.js";
-import { formatBaseUrlForLog, maskApiKey } from "./logging.js";
+import { maskApiKey } from "./logging.js";
 import { startHeartbeat } from "../heartbeat.js";
 import { startOscProgress } from "./oscProgress.js";
 import { createFsAdapter } from "./fsAdapter.js";
@@ -25,60 +25,49 @@ import { createMarkdownStreamer } from "markdansi";
 import { executeBackgroundResponse } from "./background.js";
 import { formatTokenEstimate, formatTokenValue, resolvePreviewMode } from "./runUtils.js";
 import { estimateUsdCost } from "tokentally";
-import { defaultOpenRouterBaseUrl, isOpenRouterBaseUrl, isProModel, resolveModelConfig, normalizeOpenRouterBaseUrl, } from "./modelResolver.js";
+import { isOpenRouterBaseUrl, isProModel, resolveModelConfig } from "./modelResolver.js";
 import { validateProviderRouting } from "./providerRouting.js";
+import { formatRouteTargetForLog, resolveProviderRoute, } from "./providerRoutePlan.js";
 const isStdoutTty = process.stdout.isTTY && chalk.level > 0;
 const dim = (text) => (isStdoutTty ? kleur.dim(text) : text);
 // Default timeout for non-pro API runs (fast models) — give them up to 120s.
 const DEFAULT_TIMEOUT_NON_PRO_MS = 120_000;
 const DEFAULT_TIMEOUT_PRO_MS = 60 * 60 * 1000;
-const DEFAULT_PROVIDER_HOSTS = {
-    anthropic: "api.anthropic.com",
-    google: "generativelanguage.googleapis.com",
-    openai: "api.openai.com",
-    xai: "api.x.ai",
-};
 const defaultWait = (ms) => new Promise((resolve) => {
     setTimeout(resolve, ms);
 });
-function formatRouteTargetForLog(raw, fallbackHost = "") {
-    if (!raw)
-        return fallbackHost;
-    try {
-        const parsed = new URL(raw);
-        const segments = parsed.pathname.split("/").filter(Boolean);
-        let path = "";
-        if (segments.length > 0) {
-            path = `/${segments[0]}`;
-            if (segments.length > 1) {
-                path += "/...";
-            }
-        }
-        return `${parsed.host}${path}`;
-    }
-    catch {
-        const formatted = formatBaseUrlForLog(raw).replace(/^https?:\/\//u, "");
-        return formatted || fallbackHost;
+function formatProviderRouteLogLine(route, keySource) {
+    if (route.isAzureOpenAI) {
+        return `Provider: Azure OpenAI | endpoint: ${formatRouteTargetForLog(route.azureEndpoint)} | deployment: ${route.azureDeploymentName || "none"} | key: ${keySource}`;
     }
+    return `Provider: ${route.providerLabel} | base: ${route.base} | key: ${keySource}`;
 }
-function formatProviderRouteLogLine({ provider, baseUrl, openRouterFallback, isAzureOpenAI, azureEndpoint, azureDeploymentName, envVar, }) {
-    if (isAzureOpenAI) {
-        return `Provider: Azure OpenAI | endpoint: ${formatRouteTargetForLog(azureEndpoint)} | deployment: ${azureDeploymentName || "none"} | key: ${envVar}`;
+function runtimeKeySource({ route, providerMode, optionsApiKey, }) {
+    if (optionsApiKey &&
+        (route.isAzureOpenAI ||
+            providerMode === "openai" ||
+            route.provider === "openai" ||
+            route.providerLabel === "OpenAI-compatible")) {
+        return "apiKey option";
     }
-    const isOpenRouter = isOpenRouterBaseUrl(baseUrl) || openRouterFallback;
-    const routeProvider = isOpenRouter
-        ? "OpenRouter"
-        : baseUrl && isCustomBaseUrl(baseUrl)
-            ? "OpenAI-compatible"
-            : provider === "anthropic"
-                ? "Anthropic"
-                : provider === "google"
-                    ? "Google Gemini"
-                    : provider === "xai"
-                        ? "xAI"
-                        : "OpenAI";
-    const fallbackHost = DEFAULT_PROVIDER_HOSTS[provider] ?? DEFAULT_PROVIDER_HOSTS.openai;
-    return `Provider: ${routeProvider} | base: ${formatRouteTargetForLog(baseUrl, fallbackHost)} | key: ${envVar}`;
+    if (route.isAzureOpenAI) {
+        return "AZURE_OPENAI_API_KEY|OPENAI_API_KEY";
+    }
+    if (providerMode === "openai") {
+        return "OPENAI_API_KEY";
+    }
+    if (isOpenRouterBaseUrl(route.baseUrl) || route.openRouterFallback || route.model.includes("/")) {
+        return "OPENROUTER_API_KEY";
+    }
+    if (route.model.startsWith("gpt"))
+        return "OPENAI_API_KEY";
+    if (route.model.startsWith("gemini"))
+        return "GEMINI_API_KEY";
+    if (route.model.startsWith("claude"))
+        return "ANTHROPIC_API_KEY";
+    if (route.model.startsWith("grok"))
+        return "XAI_API_KEY";
+    return optionsApiKey ? "apiKey option" : route.keySource;
 }
 export async function runOracle(options, deps = {}) {
     const { apiKey: optionsApiKey = options.apiKey, cwd = process.cwd(), fs: fsModule = createFsAdapter(fs), log = console.log, write: sinkWrite = (_text) => true, allowStdout = true, stdoutWrite: stdoutWriteDep, now = () => performance.now(), clientFactory = createDefaultClientFactory(), client, wait = defaultWait, } = deps;
@@ -86,13 +75,10 @@ export async function runOracle(options, deps = {}) {
         ? (stdoutWriteDep ?? process.stdout.write.bind(process.stdout))
         : () => true;
     const isTty = allowStdout && isStdoutTty;
-    const resolvedXaiBaseUrl = process.env.XAI_BASE_URL?.trim() || "https://api.x.ai/v1";
-    const openRouterApiKey = process.env.OPENROUTER_API_KEY?.trim();
-    const defaultOpenRouterBase = defaultOpenRouterBaseUrl();
     const previewMode = resolvePreviewMode(options.previewMode ?? options.preview);
     const isPreview = Boolean(previewMode);
     const providerMode = options.provider ?? "auto";
-    const routing = validateProviderRouting({
+    validateProviderRouting({
         model: options.model,
         providerMode,
         azure: options.azure,
@@ -103,99 +89,23 @@ export async function runOracle(options, deps = {}) {
             }
         },
     });
-    const { provider, isAzureOpenAI, azureEndpoint, azureDeploymentName } = routing;
-    const hasOpenAIKey = Boolean(optionsApiKey) ||
-        Boolean(process.env.OPENAI_API_KEY) ||
-        Boolean(providerMode !== "openai" && process.env.AZURE_OPENAI_API_KEY && options.azure?.endpoint);
-    const hasAnthropicKey = Boolean(optionsApiKey) || Boolean(process.env.ANTHROPIC_API_KEY);
-    const hasGeminiKey = Boolean(optionsApiKey) || Boolean(process.env.GEMINI_API_KEY);
-    const hasXaiKey = Boolean(optionsApiKey) || Boolean(process.env.XAI_API_KEY);
-    let baseUrl = options.baseUrl?.trim();
-    const providerQualifiedOpenRouterCandidate = !isAzureOpenAI && providerMode !== "openai" && options.model.includes("/");
-    if (baseUrl &&
-        providerQualifiedOpenRouterCandidate &&
-        !isOpenRouterBaseUrl(baseUrl) &&
-        !isCustomBaseUrl(baseUrl)) {
-        baseUrl = undefined;
-    }
-    if (!baseUrl) {
-        let envBaseUrl;
-        if (options.model.startsWith("grok")) {
-            envBaseUrl = resolvedXaiBaseUrl;
-        }
-        else if (provider === "anthropic") {
-            envBaseUrl = process.env.ANTHROPIC_BASE_URL?.trim();
-        }
-        else {
-            envBaseUrl = process.env.OPENAI_BASE_URL?.trim();
-        }
-        if (!providerQualifiedOpenRouterCandidate || (envBaseUrl && isCustomBaseUrl(envBaseUrl))) {
-            baseUrl = envBaseUrl;
-        }
-    }
-    const providerKeyMissing = !isAzureOpenAI &&
-        (providerMode === "openai"
-            ? !hasOpenAIKey
-            : (provider === "openai" && !hasOpenAIKey) ||
-                (provider === "anthropic" && !hasAnthropicKey) ||
-                (provider === "google" && !hasGeminiKey) ||
-                (provider === "xai" && !hasXaiKey) ||
-                provider === "other");
-    const providerQualifiedOpenRouterRoute = providerQualifiedOpenRouterCandidate && !baseUrl;
-    const openRouterFallback = !baseUrl &&
-        (providerQualifiedOpenRouterRoute ||
-            (providerMode !== "openai" &&
-                providerKeyMissing &&
-                (provider === "other" || Boolean(openRouterApiKey))));
-    if (!baseUrl || openRouterFallback) {
-        if (openRouterFallback) {
-            baseUrl = defaultOpenRouterBase;
-        }
-    }
-    if (baseUrl && isOpenRouterBaseUrl(baseUrl)) {
-        baseUrl = normalizeOpenRouterBaseUrl(baseUrl);
-    }
+    const route = resolveProviderRoute({
+        model: options.model,
+        providerMode,
+        azure: options.azure,
+        baseUrl: options.baseUrl,
+        apiKey: optionsApiKey,
+        env: process.env,
+    });
+    const { isAzureOpenAI, azureDeploymentName } = route;
+    const baseUrl = route.baseUrl;
+    const openRouterFallback = route.openRouterFallback;
     const logVerbose = (message) => {
         if (options.verbose) {
             log(dim(`[verbose] ${message}`));
         }
     };
-    const getApiKeyForModel = (model) => {
-        if (isAzureOpenAI) {
-            if (optionsApiKey)
-                return { key: optionsApiKey, source: "apiKey option" };
-            const key = process.env.AZURE_OPENAI_API_KEY ?? process.env.OPENAI_API_KEY;
-            return { key, source: "AZURE_OPENAI_API_KEY|OPENAI_API_KEY" };
-        }
-        if (providerMode === "openai") {
-            if (optionsApiKey)
-                return { key: optionsApiKey, source: "apiKey option" };
-            return { key: process.env.OPENAI_API_KEY, source: "OPENAI_API_KEY" };
-        }
-        if (isOpenRouterBaseUrl(baseUrl) || openRouterFallback) {
-            return { key: optionsApiKey ?? openRouterApiKey, source: "OPENROUTER_API_KEY" };
-        }
-        if (typeof model === "string" && model.startsWith("gpt")) {
-            if (optionsApiKey)
-                return { key: optionsApiKey, source: "apiKey option" };
-            return { key: process.env.OPENAI_API_KEY, source: "OPENAI_API_KEY" };
-        }
-        if (typeof model === "string" && model.startsWith("gemini")) {
-            return { key: optionsApiKey ?? process.env.GEMINI_API_KEY, source: "GEMINI_API_KEY" };
-        }
-        if (typeof model === "string" && model.startsWith("claude")) {
-            return { key: optionsApiKey ?? process.env.ANTHROPIC_API_KEY, source: "ANTHROPIC_API_KEY" };
-        }
-        if (typeof model === "string" && model.startsWith("grok")) {
-            return { key: optionsApiKey ?? process.env.XAI_API_KEY, source: "XAI_API_KEY" };
-        }
-        return {
-            key: optionsApiKey ?? openRouterApiKey,
-            source: optionsApiKey ? "apiKey option" : "OPENROUTER_API_KEY",
-        };
-    };
-    const apiKeyResult = getApiKeyForModel(options.model);
-    const apiKey = apiKeyResult.key;
+    const apiKey = route.apiKey;
     if (!apiKey) {
         const envVar = isAzureOpenAI
             ? "AZURE_OPENAI_API_KEY (or OPENAI_API_KEY)"
@@ -203,15 +113,7 @@ export async function runOracle(options, deps = {}) {
                 ? "OPENAI_API_KEY"
                 : isOpenRouterBaseUrl(baseUrl) || openRouterFallback
                     ? "OPENROUTER_API_KEY"
-                    : options.model.startsWith("gpt")
-                        ? "OPENAI_API_KEY"
-                        : options.model.startsWith("gemini")
-                            ? "GEMINI_API_KEY"
-                            : options.model.startsWith("claude")
-                                ? "ANTHROPIC_API_KEY"
-                                : options.model.startsWith("grok")
-                                    ? "XAI_API_KEY"
-                                    : "OPENROUTER_API_KEY";
+                    : route.keySource;
         const browserModeHint = options.model.startsWith("gpt")
             ? ' If you have a ChatGPT Pro subscription, retry with --engine browser (or MCP engine:"browser" / preset:"chatgpt-pro-heavy"); browser mode uses your signed-in ChatGPT session instead of an API key.'
             : "";
@@ -219,7 +121,7 @@ export async function runOracle(options, deps = {}) {
             env: envVar,
         });
     }
-    const envVar = apiKeyResult.source;
+    const envVar = runtimeKeySource({ route, providerMode, optionsApiKey });
     const minPromptLength = Number.parseInt(process.env.ORACLE_MIN_PROMPT_CHARS ?? "10", 10);
     const promptLength = options.prompt?.trim().length ?? 0;
     // Enforce the short-prompt guardrail on pro-tier models because they're costly; cheaper models can run short prompts without blocking.
@@ -227,7 +129,7 @@ export async function runOracle(options, deps = {}) {
     if (isProTierModel && !Number.isNaN(minPromptLength) && promptLength < minPromptLength) {
         throw new PromptValidationError(`Prompt is too short (<${minPromptLength} chars). This was likely accidental; please provide more detail.`, { minPromptLength, promptLength });
     }
-    const resolverOpenRouterApiKey = openRouterFallback || isOpenRouterBaseUrl(baseUrl) ? (openRouterApiKey ?? apiKey) : undefined;
+    const resolverOpenRouterApiKey = openRouterFallback || isOpenRouterBaseUrl(baseUrl) ? apiKey : undefined;
     const modelConfig = await resolveModelConfig(options.model, {
         baseUrl,
         openRouterApiKey: resolverOpenRouterApiKey,
@@ -326,15 +228,7 @@ export async function runOracle(options, deps = {}) {
     if (!isPreview) {
         if (!options.suppressHeader) {
             log(headerLine);
-            log(dim(formatProviderRouteLogLine({
-                provider,
-                baseUrl,
-                openRouterFallback,
-                isAzureOpenAI,
-                azureEndpoint,
-                azureDeploymentName,
-                envVar,
-            })));
+            log(dim(formatProviderRouteLogLine(route, envVar)));
         }
         const maskedKey = maskApiKey(apiKey);
         if (maskedKey && options.verbose) {
@@ -409,7 +303,7 @@ export async function runOracle(options, deps = {}) {
             : proxyCompatibleBaseUrl
                 ? proxyCompatibleBaseUrl
                 : modelConfig.model.startsWith("claude")
-                    ? (process.env.ANTHROPIC_BASE_URL ?? baseUrl)
+                    ? baseUrl
                     : baseUrl;
     const clientInstance = client ??
         clientFactory(apiKey, {

package/dist/src/sessionManager.js

@@ -1,6 +1,6 @@
 import path from "node:path";
 import fs from "node:fs/promises";
-import { createWriteStream } from "node:fs";
+import { createWriteStream, mkdirSync } from "node:fs";
 import net from "node:net";
 import { DEFAULT_MODEL } from "./oracle/config.js";
 import { formatElapsed } from "./oracle/format.js";
@@ -86,14 +86,26 @@ async function fileExists(targetPath) {
         return false;
     }
 }
-async function ensureUniqueSessionId(baseSlug) {
+function isFileExistsError(error) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
+}
+async function reserveUniqueSessionDir(baseSlug) {
     let candidate = baseSlug;
     let suffix = 2;
-    while (await fileExists(sessionDir(candidate))) {
+    for (;;) {
+        const dir = sessionDir(candidate);
+        try {
+            await fs.mkdir(dir, { recursive: false });
+            return candidate;
+        }
+        catch (error) {
+            if (!isFileExistsError(error)) {
+                throw error;
+            }
+        }
         candidate = `${baseSlug}-${suffix}`;
         suffix += 1;
     }
-    return candidate;
 }
 async function listModelRunFiles(sessionId) {
     const dir = modelsDir(sessionId);
@@ -153,9 +165,7 @@ export async function readModelRunMetadata(sessionId, model) {
 export async function initializeSession(options, cwd, notifications, baseSlugOverride) {
     await ensureSessionStorage();
     const baseSlug = baseSlugOverride || createSessionId(options.prompt || DEFAULT_SLUG, options.slug);
-    const sessionId = await ensureUniqueSessionId(baseSlug);
-    const dir = sessionDir(sessionId);
-    await ensureDir(dir);
+    const sessionId = await reserveUniqueSessionDir(baseSlug);
     const mode = options.mode ?? "api";
     const browserConfig = options.browserConfig;
     const modelList = Array.isArray(options.models) && options.models.length > 0
@@ -239,25 +249,25 @@ export async function initializeSession(options, cwd, notifications, baseSlugOve
     return metadata;
 }
 export async function readSessionMetadata(sessionId) {
-    const modern = await readModernSessionMetadata(sessionId);
+    const modern = await readModernSessionMetadata(sessionId, { reconcile: true, persist: false });
     if (modern) {
         return modern;
     }
-    const legacy = await readLegacySessionMetadata(sessionId);
+    const legacy = await readLegacySessionMetadata(sessionId, { reconcile: true, persist: false });
     if (legacy) {
         return legacy;
     }
     return null;
 }
 export async function updateSessionMetadata(sessionId, updates) {
-    const existing = (await readModernSessionMetadata(sessionId)) ??
-        (await readLegacySessionMetadata(sessionId)) ??
+    const existing = (await readModernSessionMetadata(sessionId, { reconcile: false, persist: false })) ??
+        (await readLegacySessionMetadata(sessionId, { reconcile: false, persist: false })) ??
         { id: sessionId };
     const next = { ...existing, ...updates };
     await fs.writeFile(metaPath(sessionId), JSON.stringify(next, null, 2), "utf8");
     return next;
 }
-async function readModernSessionMetadata(sessionId) {
+async function readModernSessionMetadata(sessionId, options) {
     try {
         const raw = await fs.readFile(metaPath(sessionId), "utf8");
         const parsed = JSON.parse(raw);
@@ -265,25 +275,31 @@ async function readModernSessionMetadata(sessionId) {
             return null;
         }
         const enriched = await attachModelRuns(parsed, sessionId);
-        const runtimeChecked = await markDeadBrowser(enriched, { persist: false });
-        return await markZombie(runtimeChecked, { persist: false });
+        return options.reconcile ? reconcileSessionMetadata(enriched, options) : enriched;
     }
     catch {
         return null;
     }
 }
-async function readLegacySessionMetadata(sessionId) {
+async function readLegacySessionMetadata(sessionId, options) {
     try {
         const raw = await fs.readFile(legacySessionPath(sessionId), "utf8");
         const parsed = JSON.parse(raw);
         const enriched = await attachModelRuns(parsed, sessionId);
-        const runtimeChecked = await markDeadBrowser(enriched, { persist: false });
-        return await markZombie(runtimeChecked, { persist: false });
+        return options.reconcile ? reconcileSessionMetadata(enriched, options) : enriched;
     }
     catch {
         return null;
     }
 }
+async function readRawSessionMetadata(sessionId) {
+    return ((await readModernSessionMetadata(sessionId, { reconcile: false, persist: false })) ??
+        (await readLegacySessionMetadata(sessionId, { reconcile: false, persist: false })));
+}
+async function reconcileSessionMetadata(meta, { persist }) {
+    const runtimeChecked = await markDeadBrowser(meta, { persist });
+    return await markZombie(runtimeChecked, { persist });
+}
 function isSessionMetadataRecord(value) {
     return Boolean(value && typeof value.id === "string" && value.status);
 }
@@ -297,7 +313,7 @@ async function attachModelRuns(meta, sessionId) {
 export function createSessionLogWriter(sessionId, model) {
     const targetPath = model ? modelLogPath(sessionId, model) : logPath(sessionId);
     if (model) {
-        void ensureDir(modelsDir(sessionId));
+        mkdirSync(modelsDir(sessionId), { recursive: true });
     }
     const stream = createWriteStream(targetPath, { flags: "a" });
     const logLine = (line = "") => {
@@ -314,10 +330,10 @@ export async function listSessionsMetadata() {
     const entries = await fs.readdir(getSessionsDir()).catch(() => []);
     const metas = [];
     for (const entry of entries) {
-        let meta = await readSessionMetadata(entry);
+        let meta = await readRawSessionMetadata(entry);
         if (meta) {
-            meta = await markDeadBrowser(meta, { persist: true });
-            meta = await markZombie(meta, { persist: true }); // keep stored metadata consistent with zombie detection
+            // Keep stored metadata consistent with status reconciliation done by `oracle status`.
+            meta = await reconcileSessionMetadata(meta, { persist: true });
             metas.push(meta);
         }
     }
@@ -388,7 +404,7 @@ export async function readModelLog(sessionId, model) {
     }
 }
 export async function readSessionRequest(sessionId) {
-    const modern = await readModernSessionMetadata(sessionId);
+    const modern = await readModernSessionMetadata(sessionId, { reconcile: false, persist: false });
     if (modern?.options) {
         return modern.options;
     }

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@steipete/oracle",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "CLI wrapper around OpenAI Responses API with GPT-5.5 Pro, GPT-5.5, GPT-5.4, GPT-5.2, GPT-5.1, and GPT-5.1 Codex high reasoning modes.",
   "keywords": [],
-  "homepage": "https://github.com/steipete/oracle#readme",
+  "homepage": "https://askoracle.sh",
   "bugs": {
     "url": "https://github.com/steipete/oracle/issues"
   },
@@ -46,7 +46,7 @@
     "test": "vitest run",
     "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": "pnpm dlx mcporter list oracle-local --schema --config config/mcporter.json && pnpm dlx mcporter call oracle-local.sessions limit:1 --config config/mcporter.json",
+    "test:mcp:mcporter": "CHROME_DEVTOOLS_URL=http://127.0.0.1:0 pnpm dlx mcporter list oracle-local --schema --config config/mcporter.json && CHROME_DEVTOOLS_URL=http://127.0.0.1:0 pnpm dlx mcporter call oracle-local.sessions limit:1 --config config/mcporter.json",
     "test:browser": "pnpm run build && tsx scripts/test-browser.ts && ./scripts/browser-smoke.sh",
     "test:packed-cli": "node scripts/packed-cli-smoke.mjs",
     "test:live": "ORACLE_LIVE_TEST=1 vitest run tests/live --exclude tests/live/openai-live.test.ts",
@@ -61,7 +61,7 @@
     "@google/genai": "^2.0.1",
     "@google/generative-ai": "^0.24.1",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@steipete/sweet-cookie": "^0.2.0",
+    "@steipete/sweet-cookie": "^0.3.0",
     "chalk": "^5.6.2",
     "chrome-launcher": "^1.2.1",
     "chrome-remote-interface": "^0.34.0",
@@ -70,11 +70,11 @@
     "dotenv": "^17.4.2",
     "fast-glob": "^3.3.3",
     "gpt-tokenizer": "^3.4.0",
-    "inquirer": "13.4.2",
+    "inquirer": "13.4.3",
     "json5": "^2.2.3",
     "kleur": "^4.1.5",
     "markdansi": "0.2.1",
-    "openai": "^6.35.0",
+    "openai": "^6.38.0",
     "osc-progress": "^0.3.0",
     "qs": "^6.15.1",
     "shiki": "^4.0.2",
@@ -84,17 +84,17 @@
   },
   "devDependencies": {
     "@anthropic-ai/tokenizer": "^0.0.4",
-    "@types/chrome-remote-interface": "^0.33.0",
+    "@types/chrome-remote-interface": "^0.34.0",
     "@types/inquirer": "^9.0.9",
     "@types/node": "^25.6.0",
-    "@typescript/native-preview": "7.0.0-dev.20260508.1",
-    "@vitest/coverage-v8": "4.1.5",
-    "devtools-protocol": "0.0.1627472",
+    "@typescript/native-preview": "7.0.0-dev.20260516.1",
+    "@vitest/coverage-v8": "4.1.6",
+    "devtools-protocol": "0.0.1629771",
     "es-toolkit": "^1.46.1",
     "esbuild": "^0.28.0",
-    "oxfmt": "0.48.0",
+    "oxfmt": "0.50.0",
     "oxlint": "^1.62.0",
-    "puppeteer-core": "^24.42.0",
+    "puppeteer-core": "^25.0.2",
     "tsx": "^4.21.0",
     "typescript": "^6.0.3",
     "vitest": "^4.1.5"
@@ -113,7 +113,8 @@
   "packageManager": "pnpm@10.33.2",
   "pnpm": {
     "overrides": {
-      "devtools-protocol": "0.0.1627472"
+      "devtools-protocol": "0.0.1629771",
+      "vite": "7.3.2"
     },
     "onlyBuiltDependencies": [
       "esbuild"