@steipete/oracle 0.17.1 → 0.17.3

package/dist/src/browser/windowsCookies.js

@@ -0,0 +1,219 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import { existsSync, promises as fsp } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import sqlite3 from 'sqlite3';
+import { createRequire } from 'node:module';
+import { spawnSync } from 'node:child_process';
+let cachedUnprotect = null;
+function getUnprotectData() {
+    if (cachedUnprotect) {
+        return cachedUnprotect;
+    }
+    try {
+        // win-dpapi is CommonJS; require it explicitly and support both named/default shapes.
+        const dpapiModule = createRequire(import.meta.url)('win-dpapi');
+        const unprotect = dpapiModule?.Dpapi?.unprotectData ??
+            dpapiModule?.default?.unprotectData ??
+            ((_) => {
+                throw new Error('win-dpapi unprotectData not available');
+            });
+        cachedUnprotect = unprotect;
+        return unprotect;
+    }
+    catch (error) {
+        if (process.platform !== 'win32') {
+            // On macOS/Linux we don't need DPAPI; return a function that makes misuse obvious.
+            cachedUnprotect = () => {
+                throw new Error('win-dpapi is unavailable on non-Windows platforms');
+            };
+            return cachedUnprotect;
+        }
+        throw error;
+    }
+}
+export async function loadWindowsCookies(dbPath, filterNames) {
+    if (process.platform !== 'win32') {
+        throw new Error('loadWindowsCookies is only supported on Windows');
+    }
+    const localStatePath = await locateLocalState(dbPath);
+    const cookiesCopy = await copyLockedFile(dbPath, 'Cookies'); // name the copy exactly "Cookies"
+    const cookiesDirForFallback = await ensureCookiesDirForFallback(cookiesCopy);
+    const localStateCopy = await copyLockedFile(localStatePath, 'Local State');
+    const aesKey = await extractWindowsAesKey(localStateCopy);
+    const rows = await readChromeCookiesDb(cookiesCopy, filterNames);
+    const cookies = [];
+    for (const row of rows) {
+        const enc = row.encrypted_value && row.encrypted_value.length > 0 ? row.encrypted_value : Buffer.from(row.value ?? '', 'utf8');
+        const decrypted = enc.length > 0 ? decryptCookie(enc, aesKey) : '';
+        cookies.push({
+            name: row.name,
+            value: decrypted,
+            domain: row.host_key?.startsWith('.') ? row.host_key.slice(1) : row.host_key,
+            path: row.path ?? '/',
+            expires: normalizeExpiration(row.expires_utc),
+            secure: Boolean(row.is_secure),
+            httpOnly: Boolean(row.is_httponly),
+        });
+    }
+    if (process.env.ORACLE_DEBUG_COOKIES === '1') {
+        // eslint-disable-next-line no-console
+        console.log(`[cookies] windows decrypt decoded ${cookies.length} cookies from ${cookiesCopy} (fallback dir ${cookiesDirForFallback})`);
+    }
+    return cookies.filter((c) => c.value);
+}
+function decryptCookie(value, aesKey) {
+    const prefix = value.slice(0, 3).toString();
+    // Chrome prefixes AES-GCM encrypted cookies with version markers like v10/v11/v20; treat all v** the same.
+    if (/^v\d{2}$/u.test(prefix)) {
+        const iv = value.slice(3, 15);
+        const tag = value.slice(value.length - 16);
+        const data = value.slice(15, value.length - 16);
+        const decipher = crypto.createDecipheriv('aes-256-gcm', aesKey, iv);
+        decipher.setAuthTag(tag);
+        const decrypted = Buffer.concat([decipher.update(data), decipher.final()]);
+        return decrypted.toString('utf8');
+    }
+    const unprotectData = getUnprotectData();
+    const unprotected = unprotectData(value, undefined, 'CurrentUser');
+    return Buffer.from(unprotected).toString('utf8');
+}
+async function locateLocalState(dbPath) {
+    // Prefer sibling Local State near the profile path; fall back to default location.
+    const guess = path.resolve(path.join(path.dirname(dbPath), '..', 'Local State'));
+    if (existsSync(guess))
+        return guess;
+    const localState = path.join(os.homedir(), 'AppData', 'Local', 'Google', 'Chrome', 'User Data', 'Local State');
+    if (existsSync(localState))
+        return localState;
+    throw new Error('Chrome Local State not found for AES key');
+}
+async function extractWindowsAesKey(localStatePath) {
+    const raw = await fs.readFile(localStatePath, 'utf8');
+    const state = JSON.parse(raw);
+    const encKeyB64 = state?.os_crypt?.encrypted_key;
+    if (!encKeyB64)
+        throw new Error('encrypted_key missing in Local State');
+    const encKey = Buffer.from(encKeyB64, 'base64');
+    const dpapiBlob = encKey.slice(5); // strip "DPAPI"
+    const unprotectData = getUnprotectData();
+    const unprotected = unprotectData(dpapiBlob, undefined, 'CurrentUser');
+    return Buffer.from(unprotected);
+}
+async function readChromeCookiesDb(dbPath, filterNames) {
+    const db = await openSqlite(dbPath);
+    const placeholders = filterNames && filterNames.size > 0 ? `AND name IN (${Array.from(filterNames).map(() => '?').join(',')})` : '';
+    const params = filterNames ? Array.from(filterNames) : [];
+    const sql = `SELECT name,value,encrypted_value,host_key,path,expires_utc,is_secure,is_httponly FROM cookies WHERE host_key LIKE '%chatgpt.com%' ${placeholders}`;
+    try {
+        return await allSqlite(db, sql, params);
+    }
+    finally {
+        db.close();
+    }
+}
+function openSqlite(dbPath) {
+    return new Promise((resolve, reject) => {
+        const db = new sqlite3.Database(dbPath, sqlite3.OPEN_READONLY, (err) => {
+            if (err)
+                reject(err);
+            else
+                resolve(db);
+        });
+    });
+}
+async function copyLockedFile(sourcePath, targetName) {
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'oracle-cookie-'));
+    const tempPath = targetName ? path.join(tempDir, targetName) : path.join(tempDir, path.basename(sourcePath));
+    const psScript = `
+$src = '${sourcePath.replace(/'/g, "''")}'
+$dst = '${tempPath.replace(/'/g, "''")}'
+try {
+  $fs = [System.IO.File]::Open($src, [System.IO.FileMode]::Open, [System.IO.FileAccess]::Read, [System.IO.FileShare]::ReadWrite)
+  $bytes = New-Object byte[] $fs.Length
+  $null = $fs.Read($bytes, 0, $fs.Length)
+  $fs.Close()
+  [System.IO.File]::WriteAllBytes($dst, $bytes)
+  exit 0
+} catch {
+  exit 1
+}
+`;
+    const encoded = Buffer.from(psScript, 'utf16le').toString('base64');
+    const result = spawnSync('powershell.exe', ['-NoProfile', '-NonInteractive', '-EncodedCommand', encoded], {
+        timeout: 15000,
+        encoding: 'utf8',
+    });
+    if (result.status !== 0) {
+        // Fallback: best-effort normal copy
+        await fs.copyFile(sourcePath, tempPath);
+    }
+    if (process.env.ORACLE_DEBUG_COOKIES === '1') {
+        // eslint-disable-next-line no-console
+        console.log(`[cookies] copied locked file ${sourcePath} -> ${tempPath}`);
+    }
+    return tempPath;
+}
+// Create a directory containing a file named "Cookies" for chrome-cookies-secure fallback
+export async function ensureCookiesDirForFallback(cookieFile) {
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'oracle-cookies-secure-'));
+    const target = path.join(dir, 'Cookies');
+    await fs.copyFile(cookieFile, target);
+    return dir;
+}
+function allSqlite(db, sql, params) {
+    return new Promise((resolve, reject) => {
+        db.all(sql, params, (err, rows) => {
+            if (err)
+                reject(err);
+            else
+                resolve((rows ?? []));
+        });
+    });
+}
+function normalizeExpiration(expires) {
+    if (!expires || Number.isNaN(expires)) {
+        return undefined;
+    }
+    const value = Number(expires);
+    if (value <= 0)
+        return undefined;
+    if (value > 1_000_000_000_000) {
+        return Math.round(value / 1_000_000 - 11644473600);
+    }
+    if (value > 1_000_000_000) {
+        return Math.round(value / 1000);
+    }
+    return Math.round(value);
+}
+export async function materializeCookieFile(sourcePath) {
+    if (process.platform !== 'win32')
+        return sourcePath;
+    const resolved = await resolveDirectoryCandidate(sourcePath);
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'oracle-cookies-'));
+    const tempPath = path.join(tempDir, 'Cookies');
+    await fs.copyFile(resolved, tempPath);
+    return tempPath;
+}
+async function resolveDirectoryCandidate(inputPath) {
+    const stat = await fs.stat(inputPath).catch(() => null);
+    if (!stat?.isDirectory())
+        return inputPath;
+    const network = path.join(inputPath, 'Network', 'Cookies');
+    const direct = path.join(inputPath, 'Cookies');
+    if (await fileExists(network))
+        return network;
+    if (await fileExists(direct))
+        return direct;
+    return inputPath;
+}
+async function fileExists(candidate) {
+    try {
+        const stat = await fsp.stat(candidate);
+        return stat.isFile();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/src/cli/browserConfig.js

@@ -19,7 +19,7 @@ const BROWSER_MODEL_LABELS = [
     // Most specific first (e.g., "gpt-5.2-thinking" before "gpt-5.2")
     ["gpt-5.6-sol", "GPT-5.6 Sol"],
     ["gpt-5.6", "GPT-5.6 Sol"],
-    ["gpt-5.5-pro", "Pro"],
+    ["gpt-5.5-pro", "GPT-5.5"],
     ["gpt-5.5-instant", "GPT-5.5 Instant"],
     ["gpt-5.5", "Thinking 5.5"],
     ["gpt-5.4-pro", "Pro"],
@@ -85,8 +85,11 @@ export async function buildBrowserConfig(options) {
     const normalizedOverride = desiredModelOverride?.toLowerCase() ?? "";
     const baseModel = options.model.toLowerCase();
     const isChatGptModel = baseModel.startsWith("gpt-") && !baseModel.includes("codex");
+    const normalizedBrowserModel = normalizeChatGptModelForBrowser(options.model);
     const shouldUseOverride = !isChatGptModel && normalizedOverride.length > 0 && normalizedOverride !== baseModel;
     const modelStrategy = normalizeBrowserModelStrategy(options.browserModelStrategy) ?? DEFAULT_MODEL_STRATEGY;
+    const thinkingTime = normalizeThinkingTimeLevel(options.browserThinkingTime) ??
+        (modelStrategy === "select" && normalizedBrowserModel === "gpt-5.5-pro" ? "pro" : undefined);
     assertBrowserModelAvailable(options.model, modelStrategy);
     const cookieNames = parseCookieNames(options.browserCookieNames ?? process.env.ORACLE_BROWSER_COOKIE_NAMES);
     let inline = await resolveInlineCookies({
@@ -158,14 +161,19 @@ export async function buildBrowserConfig(options) {
         cookieSyncWaitMs: options.browserCookieWait
             ? parseBrowserDuration(options.browserCookieWait, "--browser-cookie-wait", 0)
             : undefined,
-        cookieSync: options.browserNoCookieSync ? false : undefined,
+        cookieSync: options.browserNoCookieSync
+            ? false
+            : options.browserManualLoginCookieSync === true
+                ? true
+                : undefined,
         cookieNames,
         inlineCookies: inline?.cookies,
         inlineCookiesSource: inline?.source ?? null,
-        headless: undefined, // disable headless; Cloudflare blocks it
+        headless: options.browserHeadless === true ? true : undefined,
         keepBrowser: options.browserKeepBrowser ? true : undefined,
         manualLogin: options.browserManualLogin === undefined ? undefined : options.browserManualLogin,
         manualLoginProfileDir: options.browserManualLoginProfileDir ?? undefined,
+        manualLoginCookieSync: options.browserManualLoginCookieSync,
         copyProfileSource: options.copyProfile ?? undefined,
         hideWindow: options.browserHideWindow ? true : undefined,
         desiredModel,
@@ -175,7 +183,7 @@ export async function buildBrowserConfig(options) {
         allowCookieErrors: options.browserAllowCookieErrors ?? true,
         remoteChrome,
         browserTabRef: options.browserTab ?? undefined,
-        thinkingTime: normalizeThinkingTimeLevel(options.browserThinkingTime) ?? undefined,
+        thinkingTime,
         researchMode: options.browserResearch === "deep" ? "deep" : "off",
         archiveConversations: options.browserArchive,
     };
@@ -199,6 +207,7 @@ function validateAttachRunningOptions(options, { attachRunning, hasInlineCookies
         options.browserChromeProfile ? "--browser-chrome-profile" : null,
         options.browserCookiePath ? "--browser-cookie-path" : null,
         options.browserNoCookieSync ? "--browser-no-cookie-sync" : null,
+        options.browserHeadless ? "--browser-headless" : null,
         options.browserHideWindow ? "--browser-hide-window" : null,
         options.browserKeepBrowser ? "--browser-keep-browser" : null,
         options.browserManualLogin ? "--browser-manual-login" : null,

package/dist/src/cli/browserDefaults.js

@@ -76,7 +76,7 @@ export function applyBrowserDefaultsFromConfig(options, config, getSource) {
     if (isUnset("browserCookieWait") && typeof browser.cookieSyncWaitMs === "number") {
         options.browserCookieWait = String(browser.cookieSyncWaitMs);
     }
-    if (isUnset("browserHeadless") && browser.headless !== undefined) {
+    if (!attachRunningRequested && isUnset("browserHeadless") && browser.headless !== undefined) {
         options.browserHeadless = browser.headless;
     }
     if (!attachRunningRequested && isUnset("browserHideWindow") && browser.hideWindow !== undefined) {
@@ -111,4 +111,9 @@ export function applyBrowserDefaultsFromConfig(options, config, getSource) {
         browser.manualLoginProfileDir !== undefined) {
         options.browserManualLoginProfileDir = browser.manualLoginProfileDir;
     }
+    if (!attachRunningRequested &&
+        isUnset("browserManualLoginCookieSync") &&
+        browser.manualLoginCookieSync !== undefined) {
+        options.browserManualLoginCookieSync = browser.manualLoginCookieSync;
+    }
 }

package/dist/src/cli/options.js

@@ -133,7 +133,7 @@ export function parseThinkingTimeOption(value) {
     if (normalized) {
         return normalized;
     }
-    throw new InvalidArgumentError('Thinking time must be one of "light", "standard", "extended", "extra-high", "heavy", or a ChatGPT UI alias like "instant", "medium", "high", or "xhigh".');
+    throw new InvalidArgumentError('Thinking time must be one of "light", "standard", "extended", "extra-high", "pro", "heavy", or a ChatGPT UI alias like "instant", "medium", "high", or "xhigh".');
 }
 export function normalizeModelOption(value) {
     return (value ?? "").trim();

package/dist/src/cli/projectSources.js

@@ -71,14 +71,21 @@ export async function buildProjectSourcesBrowserConfig({ options, projectUrl, co
             envProfileDir ??
             null)
         : null;
+    const manualLoginCookieSync = flagConfig.manualLoginCookieSync ?? configuredBrowser.manualLoginCookieSync;
+    const cookieSync = flagConfig.cookieSync === false
+        ? false
+        : manualLogin
+            ? manualLoginCookieSync === true
+            : configuredBrowser.cookieSync;
     return {
         ...configuredBrowser,
         ...flagConfig,
         url: projectUrl,
         chatgptUrl: projectUrl,
-        cookieSync: manualLogin ? false : (flagConfig.cookieSync ?? configuredBrowser.cookieSync),
+        cookieSync,
         manualLogin,
         manualLoginProfileDir,
+        manualLoginCookieSync,
         desiredModel: null,
         modelStrategy: "ignore",
         researchMode: "off",

package/dist/src/mcp/tools/consult.js

@@ -271,7 +271,7 @@ export function buildConsultBrowserConfig({ userConfig, env, runModel, inputMode
         ...configuredBrowser,
         url: configuredUrl,
         chatgptUrl: configuredUrl,
-        cookieSync: !manualLogin,
+        cookieSync: !manualLogin || configuredBrowser.manualLoginCookieSync === true,
         headless: configuredBrowser.headless ?? false,
         hideWindow: configuredBrowser.hideWindow ?? false,
         keepBrowser: browserKeepBrowser ?? configuredBrowser.keepBrowser ?? false,

package/dist/src/oracle/thinkingTime.js

@@ -3,6 +3,10 @@ export const THINKING_TIME_LEVELS = [
     "standard",
     "extended",
     "extra-high",
+    // ChatGPT's unified Intelligence picker exposes Pro as the top effort tier of
+    // the active model rather than a separate model row, so it is a level here.
+    // Kept distinct from "heavy": requesting Pro must be deliberate.
+    "pro",
     "heavy",
 ];
 export const THINKING_TIME_ALIASES = [
@@ -38,6 +42,8 @@ export function normalizeThinkingTimeLevel(value) {
         case "extrahigh":
         case "xhigh":
             return "extra-high";
+        case "pro":
+            return "pro";
         case "heavy":
             return "heavy";
         default:

package/dist/src/sessionManager.js

@@ -23,11 +23,86 @@ const DEFAULT_SLUG = "session";
 const MAX_SLUG_WORDS = 5;
 const MIN_CUSTOM_SLUG_WORDS = 3;
 const MAX_SLUG_WORD_LENGTH = 10;
+// Session artifacts (prompt, attached file contents, model responses) are sensitive.
+// Keep them owner-only, matching the meta.json / bridge-config posture (0o600/0o700).
+const SESSION_DIR_MODE = 0o700;
+const SESSION_FILE_MODE = 0o600;
+const sessionStorageHardening = new Map();
 async function ensureDir(dirPath) {
-    await fs.mkdir(dirPath, { recursive: true });
+    await fs.mkdir(dirPath, { recursive: true, mode: SESSION_DIR_MODE });
+}
+function isMissingPathError(error) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+async function chmodIfPresent(targetPath, mode) {
+    try {
+        await fs.chmod(targetPath, mode);
+        return true;
+    }
+    catch (error) {
+        if (isMissingPathError(error)) {
+            return false;
+        }
+        throw error;
+    }
+}
+async function hardenSessionStorageEntry(targetPath) {
+    let stats;
+    try {
+        stats = await fs.lstat(targetPath);
+    }
+    catch (error) {
+        if (isMissingPathError(error)) {
+            return;
+        }
+        throw error;
+    }
+    if (stats.isSymbolicLink()) {
+        return;
+    }
+    if (stats.isDirectory()) {
+        if (!(await chmodIfPresent(targetPath, SESSION_DIR_MODE))) {
+            return;
+        }
+        let entries;
+        try {
+            entries = await fs.readdir(targetPath);
+        }
+        catch (error) {
+            if (isMissingPathError(error)) {
+                return;
+            }
+            throw error;
+        }
+        for (const entry of entries) {
+            await hardenSessionStorageEntry(path.join(targetPath, entry));
+        }
+        return;
+    }
+    if (stats.isFile()) {
+        await chmodIfPresent(targetPath, SESSION_FILE_MODE);
+    }
 }
 export async function ensureSessionStorage() {
-    await ensureDir(getSessionsDir());
+    const sessionsDir = getSessionsDir();
+    await ensureDir(sessionsDir);
+    if (process.platform === "win32") {
+        return;
+    }
+    const stats = await fs.lstat(sessionsDir);
+    if (stats.isSymbolicLink() || !stats.isDirectory()) {
+        return;
+    }
+    const identity = `${sessionsDir}:${stats.dev}:${stats.ino}`;
+    let hardening = sessionStorageHardening.get(identity);
+    if (!hardening) {
+        hardening = hardenSessionStorageEntry(sessionsDir).catch((error) => {
+            sessionStorageHardening.delete(identity);
+            throw error;
+        });
+        sessionStorageHardening.set(identity, hardening);
+    }
+    await hardening;
 }
 function slugify(text, maxWords = MAX_SLUG_WORDS) {
     const normalized = text?.toLowerCase() ?? "";
@@ -110,7 +185,7 @@ async function reserveUniqueSessionDir(baseSlug) {
     for (;;) {
         const dir = sessionDir(candidate);
         try {
-            await fs.mkdir(dir, { recursive: false });
+            await fs.mkdir(dir, { recursive: false, mode: SESSION_DIR_MODE });
             return candidate;
         }
         catch (error) {
@@ -171,7 +246,10 @@ export async function updateModelRunMetadata(sessionId, model, updates) {
         ...updates,
         model,
     });
-    await fs.writeFile(modelJsonPath(sessionId, model), JSON.stringify(next, null, 2), "utf8");
+    await fs.writeFile(modelJsonPath(sessionId, model), JSON.stringify(next, null, 2), {
+        encoding: "utf8",
+        mode: SESSION_FILE_MODE,
+    });
     return next;
 }
 export async function readModelRunMetadata(sessionId, model) {
@@ -261,10 +339,13 @@ export async function initializeSession(options, cwd, notifications, baseSlugOve
             status: "pending",
             log: { path: path.relative(sessionDir(sessionId), logFilePath) },
         };
-        await fs.writeFile(jsonPath, JSON.stringify(modelRecord, null, 2), "utf8");
-        await fs.writeFile(logFilePath, "", "utf8");
+        await fs.writeFile(jsonPath, JSON.stringify(modelRecord, null, 2), {
+            encoding: "utf8",
+            mode: SESSION_FILE_MODE,
+        });
+        await fs.writeFile(logFilePath, "", { encoding: "utf8", mode: SESSION_FILE_MODE });
     }));
-    await fs.writeFile(logPath(sessionId), "", "utf8");
+    await fs.writeFile(logPath(sessionId), "", { encoding: "utf8", mode: SESSION_FILE_MODE });
     return metadata;
 }
 export async function readSessionMetadata(sessionId) {
@@ -350,9 +431,9 @@ async function attachModelRuns(meta, sessionId) {
 export function createSessionLogWriter(sessionId, model) {
     const targetPath = model ? modelLogPath(sessionId, model) : logPath(sessionId);
     if (model) {
-        mkdirSync(modelsDir(sessionId), { recursive: true });
+        mkdirSync(modelsDir(sessionId), { recursive: true, mode: SESSION_DIR_MODE });
     }
-    const stream = createWriteStream(targetPath, { flags: "a" });
+    const stream = createWriteStream(targetPath, { flags: "a", mode: SESSION_FILE_MODE });
     const logLine = (line = "") => {
         stream.write(`${line}\n`);
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steipete/oracle",
-  "version": "0.17.1",
+  "version": "0.17.3",
   "description": "CLI wrapper around OpenAI Responses API with GPT-5.6 Sol, GPT-5.6, 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://askoracle.sh",
@@ -58,7 +58,7 @@
   },
   "dependencies": {
     "@anthropic-ai/tokenizer": "^0.0.4",
-    "@google/genai": "^2.15.0",
+    "@google/genai": "^2.16.0",
     "@google/generative-ai": "^0.24.1",
     "@modelcontextprotocol/sdk": "^1.30.0",
     "@steipete/sweet-cookie": "^0.4.1",
@@ -86,15 +86,15 @@
     "@anthropic-ai/tokenizer": "^0.0.4",
     "@types/chrome-remote-interface": "^0.34.0",
     "@types/inquirer": "^9.0.10",
-    "@types/node": "^26.1.2",
+    "@types/node": "^26.2.0",
     "@vitest/coverage-v8": "4.1.10",
-    "devtools-protocol": "0.0.1673900",
+    "devtools-protocol": "0.0.1676105",
     "es-toolkit": "^1.50.0",
     "esbuild": "^0.28.1",
     "oxfmt": "0.62.0",
     "oxlint": "^1.77.0",
     "puppeteer-core": "^25.5.0",
-    "tsx": "^4.23.7",
+    "tsx": "^4.23.11",
     "typescript": "^7.0.2",
     "vitest": "^4.1.10"
   },
@@ -109,5 +109,5 @@
   "engines": {
     "node": ">=24"
   },
-  "packageManager": "pnpm@10.34.5"
+  "packageManager": "pnpm@11.20.0"
 }