ask-pro 0.1.69 → 0.2.78

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "ask-pro",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Minimal browser-backed ChatGPT Pro escalation workflow for agents via $ask-pro.",
   "author": {
     "name": "Jonathan",

package/README.md

@@ -23,21 +23,17 @@ codex plugin add ask-pro@ask-pro
 ```
 
 Update with `codex plugin marketplace upgrade ask-pro`, then restart Codex.
-Both installs run the same bundled launcher and share the same state.
+Both installs run the same bundled launcher. The `ask-pro` npm package
+(`npm i -g ask-pro`) still works too. All three share the same state.
 
 You need Node.js 24+, npm, Chrome, and a ChatGPT account with Pro access. The
 browser runtime is developed and tested on Windows; other operating systems
 need validation.
 
-**Upgrading from an earlier version:** ask-pro state moved from
-`~/.codex/state/ask-pro` to `~/.agents/state/ask-pro`. Before the first run
-after upgrading, and while no ask-pro run is active, copy your signed-in browser
-state once:
-
-```powershell
-New-Item -ItemType Directory -Force "$HOME\.agents\state" | Out-Null
-Copy-Item -Recurse "$HOME\.codex\state\ask-pro" "$HOME\.agents\state\ask-pro"
-```
+**Upgrading from an earlier version:** nothing to do. On its first run,
+ask-pro moves your signed-in browser profiles from `~/.codex/state/ask-pro` to
+`~/.agents/state/ask-pro`. If Chrome still has the old profile open, ask-pro
+uses it where it is and moves it on a later run.
 
 ## Browser and session state
 

package/dist/bin/ask-pro-cli.js

@@ -10,7 +10,8 @@ import { Command, Option } from "commander";
 import { createAskProSession, getAskProSessionPaths, pruneExpiredAskProSessions, readAskProAnswer, readAskProStatus, updateAskProResumeCommand, updateAskProStatus, } from "../src/ask-pro/session.js";
 import { AskProNeedsAuthError, isSuspiciousPreambleAnswer, resumeAskProBrowserSession, runAskProBrowserSession, } from "../src/ask-pro/browserRunner.js";
 import { renderToonRecord } from "../src/ask-pro/toon.js";
-import { askProAgentIdForManagedBrowserProfileDir, defaultAskProBrowserProfileDir, } from "../src/browser/profilePaths.js";
+import { askProAgentIdForLegacyBrowserProfileDir, askProAgentIdForManagedBrowserProfileDir, defaultAskProBrowserProfileDir, isLegacyAskProManagedBrowserProfileDir, } from "../src/browser/profilePaths.js";
+import { migrateLegacyAskProProfiles } from "../src/browser/profileMigration.js";
 import { getCliVersion } from "../src/version.js";
 const program = new Command();
 program
@@ -60,6 +61,10 @@ async function runAskPro(question, options) {
     if (options.answers && question.trim())
         throw new Error("Use --answers with --resume, without a question argument.");
     await pruneExpiredAskProSessions({ cwd });
+    await migrateLegacyAskProProfiles({
+        log: (message) => console.error(message),
+        lockTimeoutMs: 5_000,
+    });
     if (options.status !== undefined) {
         const { status } = await readAskProStatus({ cwd, sessionId: optionSessionId(options.status) });
         printStatusRecord(status, {
@@ -522,9 +527,11 @@ async function readBrowserMetadata(cwd, sessionId) {
 function profileMode(profileDir) {
     if (!profileDir)
         return undefined;
-    if (askProAgentIdForManagedBrowserProfileDir(profileDir))
+    if (askProAgentIdForManagedBrowserProfileDir(profileDir) ||
+        askProAgentIdForLegacyBrowserProfileDir(profileDir))
         return "agent";
-    if (path.resolve(profileDir) === path.resolve(defaultAskProBrowserProfileDir()))
+    if (path.resolve(profileDir) === path.resolve(defaultAskProBrowserProfileDir()) ||
+        isLegacyAskProManagedBrowserProfileDir(profileDir))
         return "shared";
     return undefined;
 }

package/dist/src/ask-pro/browserRunner.js

@@ -5,7 +5,8 @@ import { AssistantStoppedError, BrowserAutomationError } from "../browser/errors
 import { AssistantQuestionsError } from "../browser/actions/questions.js";
 import { readAskProQuestions, parseQuestionAnswers, writeAskProQuestions } from "./questions.js";
 import { GitHubConnectionRequiredError } from "../browser/actions/github.js";
-import { askProAgentIdForManagedBrowserProfileDir, askProBrowserProfileDirForAgentId, isAskProManagedBrowserProfileDir, resolveAskProAgentId, } from "../browser/profilePaths.js";
+import { askProAgentIdForLegacyBrowserProfileDir, askProAgentIdForManagedBrowserProfileDir, askProBrowserProfileDirForAgentId, isAskProManagedBrowserProfileDir, isLegacyAskProManagedBrowserProfileDir, resolveAskProAgentId, } from "../browser/profilePaths.js";
+import { prepareAskProBrowserProfile } from "../browser/profileMigration.js";
 import { runBrowserMode } from "../browserMode.js";
 import { closeTab } from "../browser/chromeLifecycle.js";
 import { resumeBrowserSession } from "../browser/reattach.js";
@@ -28,7 +29,7 @@ async function runAskProBrowserSessionWithLease({ cwd, sessionId, temporary: req
     const temporary = requestedTemporary ?? (sessionStatus.github ? false : undefined);
     const artifactsRequested = sessionStatus.artifacts === true;
     const agentId = agentIdOverride !== undefined ? agentIdOverride : resolveAskProAgentId();
-    const browserProfile = browserProfileDir ?? askProBrowserProfileDirForAgentId(agentId);
+    const browserProfile = browserProfileDir ?? (await prepareAskProBrowserProfile(agentId));
     const metadata = await readBrowserMetadata(paths.browser).catch(() => null);
     const chatgptUrl = chatgptUrlOverride ??
         (temporary === true
@@ -317,7 +318,7 @@ async function resumeAskProBrowserSessionWithLease({ cwd, sessionId, temporary,
         : effectiveTemporary === false
             ? ASK_PRO_CHATGPT_URL
             : (metadata.url ?? ASK_PRO_TEMPORARY_CHATGPT_URL);
-    const fallbackProfile = resolveResumeBrowserProfile(metadata);
+    const fallbackProfile = await resolveResumeBrowserProfile(metadata);
     if (sessionStatus.status === "NEEDS_GITHUB_CONNECTION" ||
         (sessionStatus.github && metadata.runtime?.githubCheckPending === true)) {
         await closeSessionBrowserTab(cwd, sessionId, logger);
@@ -716,26 +717,39 @@ async function writeTerminalBrowserMetadata(cwd, sessionId, status, reason) {
         },
     });
 }
-function resolveResumeBrowserProfile(metadata) {
+async function resolveResumeBrowserProfile(metadata) {
     const agentProfile = resolveStoredAgentProfile(metadata.agentId);
     const profileDir = metadata.profileDir;
     const profileAgentId = profileDir ? askProAgentIdForManagedBrowserProfileDir(profileDir) : null;
-    if (profileAgentId && profileAgentId !== metadata.agentId) {
+    const legacyAgentId = profileDir ? askProAgentIdForLegacyBrowserProfileDir(profileDir) : null;
+    if ((profileAgentId ?? legacyAgentId) && (profileAgentId ?? legacyAgentId) !== metadata.agentId) {
         throw new Error("Stored ask-pro agent profile does not match stored agent id.");
     }
     if (profileAgentId && agentProfile) {
         return profileDir;
     }
+    // Sessions from earlier versions record the old profile location; resume where it is now.
+    if (legacyAgentId && agentProfile) {
+        return prepareAskProBrowserProfile(metadata.agentId);
+    }
     if (profileDir &&
         !profileAgentId &&
+        !legacyAgentId &&
         !agentProfile &&
         isAskProManagedBrowserProfileDir(profileDir)) {
         return askProBrowserProfileDirForAgentId(null);
     }
+    if (profileDir &&
+        !profileAgentId &&
+        !legacyAgentId &&
+        !agentProfile &&
+        isLegacyAskProManagedBrowserProfileDir(profileDir)) {
+        return prepareAskProBrowserProfile(null);
+    }
     if (profileDir) {
         throw new Error("Stored ask-pro profile path is invalid.");
     }
-    return askProBrowserProfileDirForAgentId(metadata.agentId);
+    return prepareAskProBrowserProfile(metadata.agentId);
 }
 function resolveStoredAgentProfile(agentId) {
     if (!agentId)

package/dist/src/browser/profileMigration.js

@@ -0,0 +1,299 @@
+import { randomUUID } from "node:crypto";
+import { rmSync } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { askProBrowserProfileDirForAgentId, askProBrowserProfileDirUnder, askProStateDir, isResolvedAskProAgentId, legacyAskProStateDirs, } from "./profilePaths.js";
+import { acquireProfileRunLock, isBrowserProfileInUse, isProcessAlive, releaseProfileRunLock, } from "./profileState.js";
+// Coordination files live in the current state folder: the migration lock, records of runs that
+// still use an old profile, unfinished copies and the profiles already reported as leftovers.
+const MIGRATION_DIR = ".migration";
+const PROFILE_LOCK_FILENAME = "ask-pro-automation.lock";
+const MIGRATION_LOCK_TIMEOUT_MS = 15 * 60_000;
+const TRASH_PREFIX = ".ask-pro-trash-";
+/**
+ * Moves browser profiles left by earlier versions into the current state folder. A profile that
+ * is in use stays where it is and moves on a later run. Never fails the caller.
+ */
+export async function migrateLegacyAskProProfiles(options = {}) {
+    const env = options.env ?? process.env;
+    const stateDir = askProStateDir(env);
+    try {
+        const profiles = await findLegacyProfiles(env);
+        if (profiles.length === 0)
+            return;
+        if (await someMissing(profiles.map((profile) => profile.target))) {
+            await withMigrationLock(stateDir, options.lockTimeoutMs, async () => {
+                // Only the newest old copy of each profile moves, even if it must wait for a later run.
+                const claimed = new Set();
+                for (const profile of profiles) {
+                    if (claimed.has(profile.target))
+                        continue;
+                    claimed.add(profile.target);
+                    if (!(await exists(profile.target)))
+                        await moveProfile(profile, stateDir);
+                }
+            });
+        }
+        await reportLeftovers(profiles, stateDir, options.log);
+        await removeEmptyFolders(profiles);
+    }
+    catch {
+        // retried on a later run
+    }
+}
+/**
+ * The browser profile this run uses: the current one, or an earlier version's profile that is
+ * still in use and has not moved yet. The old location is then kept for the whole run.
+ */
+export async function prepareAskProBrowserProfile(agentId, options = {}) {
+    const env = options.env ?? process.env;
+    await migrateLegacyAskProProfiles(options);
+    const target = askProBrowserProfileDirForAgentId(agentId, env);
+    if (await exists(target))
+        return target;
+    const stateDir = askProStateDir(env);
+    const pick = async (record) => {
+        if (await exists(target))
+            return target;
+        for (const root of legacyAskProStateDirs(env)) {
+            const legacy = askProBrowserProfileDirUnder(root, agentId);
+            if (!(await exists(legacy)))
+                continue;
+            if (record)
+                await recordLegacyUse(stateDir, legacy);
+            return legacy;
+        }
+        return target;
+    };
+    // The record keeps a concurrent migration from moving the profile out from under this run.
+    return withMigrationLock(stateDir, MIGRATION_LOCK_TIMEOUT_MS, () => pick(true)).catch(() => pick(false));
+}
+async function findLegacyProfiles(env) {
+    const stateDir = askProStateDir(env);
+    const profiles = [];
+    for (const root of legacyAskProStateDirs(env)) {
+        const entries = await fs.readdir(root).catch(() => []);
+        if (entries.length === 0)
+            continue;
+        for (const entry of entries.filter((name) => name.startsWith(TRASH_PREFIX))) {
+            await fs.rm(path.join(root, entry), { recursive: true, force: true }).catch(() => undefined);
+        }
+        const agentIds = entries.includes("agents")
+            ? (await fs.readdir(path.join(root, "agents")).catch(() => [])).filter(isResolvedAskProAgentId)
+            : [];
+        for (const agentId of [null, ...agentIds]) {
+            const legacy = askProBrowserProfileDirUnder(root, agentId);
+            if (await isRealFolder(legacy)) {
+                profiles.push({ root, legacy, target: askProBrowserProfileDirUnder(stateDir, agentId) });
+            }
+        }
+    }
+    return profiles;
+}
+async function moveProfile(profile, stateDir) {
+    const { legacy, target } = profile;
+    if (await hasLiveLegacyUse(stateDir, legacy))
+        return;
+    let lock;
+    try {
+        // Holding the profile's run lock keeps other ask-pro runs, old versions included, from
+        // opening it mid-move.
+        lock = await acquireProfileRunLock(legacy, { timeoutMs: 1, pollMs: 1 });
+    }
+    catch {
+        return;
+    }
+    if (!lock)
+        return;
+    let lockPath = lock.path;
+    try {
+        if (await isBrowserProfileInUse(legacy, { ignoreLockId: lock.lockId }))
+            return;
+        await fs.mkdir(path.dirname(target), { recursive: true });
+        try {
+            await fs.rename(legacy, target);
+            lockPath = path.join(target, PROFILE_LOCK_FILENAME);
+            await linkOldPath(legacy, target);
+            return;
+        }
+        catch (error) {
+            // Anything but a move across volumes (on Windows: a profile Chrome still has open) is
+            // retried on a later run.
+            if (error.code !== "EXDEV")
+                return;
+        }
+        await copyProfile(legacy, target, stateDir);
+        await removeFolder(legacy, profile.root, () => linkOldPath(legacy, target));
+    }
+    catch {
+        // retried on a later run
+    }
+    finally {
+        await releaseProfileRunLock(lockPath, lock.lockId);
+    }
+}
+async function copyProfile(legacy, target, stateDir) {
+    const staging = path.join(stateDir, MIGRATION_DIR, `copy-${randomUUID()}`);
+    const ownLock = path.join(legacy, PROFILE_LOCK_FILENAME);
+    try {
+        await fs.cp(legacy, staging, {
+            recursive: true,
+            errorOnExist: true,
+            force: false,
+            verbatimSymlinks: true,
+            filter: (source) => source !== ownLock,
+        });
+        const [expected, copied] = await Promise.all([listTree(legacy), listTree(staging)]);
+        expected.delete(PROFILE_LOCK_FILENAME);
+        if (expected.size !== copied.size ||
+            [...expected].some(([name, kind]) => copied.get(name) !== kind)) {
+            throw new Error("ask-pro browser profile copy is incomplete.");
+        }
+        await fs.rename(staging, target);
+    }
+    finally {
+        await fs.rm(staging, { recursive: true, force: true }).catch(() => undefined);
+    }
+}
+// Relative path -> entry kind, with file sizes.
+async function listTree(root) {
+    const tree = new Map();
+    const walk = async (dir) => {
+        for (const entry of await fs.readdir(dir, { withFileTypes: true })) {
+            const full = path.join(dir, entry.name);
+            const name = path.relative(root, full);
+            if (entry.isDirectory()) {
+                tree.set(name, "dir");
+                await walk(full);
+            }
+            else if (entry.isSymbolicLink()) {
+                tree.set(name, `link:${await fs.readlink(full)}`);
+            }
+            else {
+                tree.set(name, `file:${(await fs.lstat(full)).size}`);
+            }
+        }
+    };
+    await walk(root);
+    return tree;
+}
+// An older ask-pro install that has not been updated yet keeps opening the old path. A link
+// there sends it to the moved profile, so it stays signed in and shares the same run lock.
+async function linkOldPath(legacy, target) {
+    const type = process.platform === "win32" ? "junction" : "dir";
+    await fs.symlink(target, legacy, type).catch(() => undefined);
+}
+// Moves the folder aside in one step, so a partly deleted profile is never left behind, and runs
+// `afterMove` before the slow delete. A folder that cannot be moved stays and is reported as a
+// leftover.
+async function removeFolder(folder, root, afterMove) {
+    const trash = path.join(root, `${TRASH_PREFIX}${randomUUID()}`);
+    try {
+        await fs.rename(folder, trash);
+    }
+    catch {
+        return;
+    }
+    await afterMove();
+    await fs.rm(trash, { recursive: true, force: true }).catch(() => undefined);
+}
+async function withMigrationLock(stateDir, timeoutMs = MIGRATION_LOCK_TIMEOUT_MS, action) {
+    const dir = path.join(stateDir, MIGRATION_DIR);
+    const lock = await acquireProfileRunLock(dir, {
+        timeoutMs,
+        pollMs: 200,
+    });
+    try {
+        // Copies left by an interrupted migration; none can be in progress while the lock is held.
+        for (const entry of await fs.readdir(dir)) {
+            if (entry.startsWith("copy-")) {
+                await fs.rm(path.join(dir, entry), { recursive: true, force: true }).catch(() => undefined);
+            }
+        }
+        return await action();
+    }
+    finally {
+        await lock?.release();
+    }
+}
+async function recordLegacyUse(stateDir, legacy) {
+    const record = path.join(stateDir, MIGRATION_DIR, `in-use-${process.pid}-${randomUUID()}.json`);
+    await fs.writeFile(record, JSON.stringify({ pid: process.pid, profile: legacy }));
+    process.once("exit", () => rmSync(record, { force: true }));
+}
+async function hasLiveLegacyUse(stateDir, legacy) {
+    const dir = path.join(stateDir, MIGRATION_DIR);
+    let inUse = false;
+    for (const entry of await fs.readdir(dir).catch(() => [])) {
+        if (!entry.startsWith("in-use-"))
+            continue;
+        const record = path.join(dir, entry);
+        const { pid, profile } = await fs
+            .readFile(record, "utf8")
+            .then((raw) => JSON.parse(raw))
+            .catch(() => ({ pid: undefined, profile: undefined }));
+        if (!pid || !isProcessAlive(pid)) {
+            await fs.rm(record, { force: true }).catch(() => undefined);
+        }
+        else if (profile && samePath(profile, legacy)) {
+            inUse = true;
+        }
+    }
+    return inUse;
+}
+// Reports once per folder an old profile that stays behind because a current one already exists.
+async function reportLeftovers(profiles, stateDir, log) {
+    if (!log)
+        return;
+    const leftovers = [];
+    for (const profile of profiles) {
+        if ((await isRealFolder(profile.legacy)) && (await exists(profile.target))) {
+            leftovers.push(profile);
+        }
+    }
+    if (leftovers.length === 0)
+        return;
+    const file = path.join(stateDir, MIGRATION_DIR, "reported-leftovers.json");
+    const reported = await fs
+        .readFile(file, "utf8")
+        .then((raw) => JSON.parse(raw))
+        .catch(() => []);
+    const fresh = leftovers.filter((profile) => !reported.includes(profile.legacy));
+    if (fresh.length === 0)
+        return;
+    for (const { legacy, target } of fresh) {
+        log(`ask-pro now uses ${target}. Once no Chrome window or older ask-pro uses ${legacy}, you can delete it.`);
+    }
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    await fs.writeFile(file, JSON.stringify([...reported, ...fresh.map((profile) => profile.legacy)]));
+}
+// Removes old state folders the migration emptied. Folders that still hold anything stay.
+async function removeEmptyFolders(profiles) {
+    for (const root of new Set(profiles.map((profile) => profile.root))) {
+        const agents = path.join(root, "agents");
+        for (const agentId of await fs.readdir(agents).catch(() => [])) {
+            if (isResolvedAskProAgentId(agentId)) {
+                await fs.rmdir(path.join(agents, agentId)).catch(() => undefined);
+            }
+        }
+        await fs.rmdir(agents).catch(() => undefined);
+        await fs.rmdir(root).catch(() => undefined);
+    }
+}
+async function someMissing(paths) {
+    for (const candidate of paths)
+        if (!(await exists(candidate)))
+            return true;
+    return false;
+}
+// Not the link an earlier move leaves at the old path.
+async function isRealFolder(candidate) {
+    return fs.lstat(candidate).then((info) => info.isDirectory(), () => false);
+}
+async function exists(candidate) {
+    return fs.stat(candidate).then((info) => info.isDirectory(), () => false);
+}
+function samePath(left, right) {
+    const normalize = (value) => process.platform === "win32" ? path.resolve(value).toLowerCase() : path.resolve(value);
+    return normalize(left) === normalize(right);
+}

package/dist/src/browser/profilePaths.js

@@ -6,12 +6,12 @@ export function defaultAskProBrowserProfileDir() {
     return askProBrowserProfileDirForAgentId(null);
 }
 export function askProBrowserProfileDirForAgentId(agentId, env = process.env) {
-    return profileDirUnder(askProStateDir(env), agentId);
+    return askProBrowserProfileDirUnder(askProStateDir(env), agentId);
 }
-function profileDirUnder(root, agentId) {
+export function askProBrowserProfileDirUnder(root, agentId) {
     if (!agentId)
         return path.join(root, "browser-profile");
-    if (!RESOLVED_AGENT_ID_PATTERN.test(agentId)) {
+    if (!isResolvedAskProAgentId(agentId)) {
         throw new Error("Stored ask-pro agent id is invalid.");
     }
     return path.join(root, "agents", agentId, "browser-profile");
@@ -42,12 +42,36 @@ function agentIdForProfileDir(profileDir, stateRoot) {
     if (parts.length !== 2 || parts[1] !== "browser-profile")
         return null;
     const agentId = parts[0];
-    return RESOLVED_AGENT_ID_PATTERN.test(agentId) ? agentId : null;
+    return isResolvedAskProAgentId(agentId) ? agentId : null;
 }
-function askProStateDir(env = process.env) {
+export function isResolvedAskProAgentId(agentId) {
+    return RESOLVED_AGENT_ID_PATTERN.test(agentId);
+}
+export function askProStateDir(env = process.env) {
     const override = env.ASK_PRO_STATE_DIR?.trim();
     return override ? path.resolve(override) : path.join(os.homedir(), ".agents", "state", "ask-pro");
 }
+// State folders of earlier versions, in the order profiles are migrated from them.
+export function legacyAskProStateDirs(env = process.env) {
+    const codexHome = env.CODEX_HOME?.trim();
+    const current = normalizeProfilePath(askProStateDir(env));
+    return [
+        path.join(codexHome ? path.resolve(codexHome) : path.join(os.homedir(), ".codex"), "state", "ask-pro"),
+        path.join(os.homedir(), ".agents", "skills", "ask-pro"),
+    ].filter((dir) => normalizeProfilePath(dir) !== current);
+}
+export function askProAgentIdForLegacyBrowserProfileDir(profileDir) {
+    for (const root of legacyAskProStateDirs()) {
+        const agentId = agentIdForProfileDir(profileDir, root);
+        if (agentId)
+            return agentId;
+    }
+    return null;
+}
+export function isLegacyAskProManagedBrowserProfileDir(profileDir) {
+    const resolved = normalizeProfilePath(profileDir);
+    return (legacyAskProStateDirs().some((root) => normalizeProfilePath(askProBrowserProfileDirUnder(root, null)) === resolved) || askProAgentIdForLegacyBrowserProfileDir(profileDir) !== null);
+}
 export function resolveAskProAgentId(env = process.env) {
     const value = env.ASK_PRO_AGENT_ID;
     if (value === undefined)

package/dist/src/browser/profileState.js

@@ -168,6 +168,30 @@ function parseProfileRunLock(payload) {
         return null;
     }
 }
+// True while an ask-pro run holds the profile or a Chrome process may still have it open. An
+// unanswerable process scan counts as in use.
+export async function isBrowserProfileInUse(userDataDir, options = {}) {
+    let raw = null;
+    try {
+        raw = await readFile(path.join(userDataDir, ASK_PRO_PROFILE_LOCK_FILENAME), "utf8");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            return true;
+    }
+    const lock = parseProfileRunLock(raw);
+    if (lock && lock.lockId !== options.ignoreLockId && isProcessAlive(lock.pid))
+        return true;
+    const pid = await readChromePid(userDataDir);
+    const port = await readDevToolsPort(userDataDir);
+    const [owner, devTools] = await Promise.all([
+        isChromeUsingUserDataDir(userDataDir),
+        port ? verifyDevToolsReachable({ port, attempts: 1 }) : null,
+    ]);
+    if (owner === true || (pid && isProcessAlive(pid) && devTools?.ok))
+        return true;
+    return owner === null;
+}
 export async function acquireProfileRunLock(userDataDir, options) {
     const timeoutMs = options.timeoutMs;
     if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ask-pro",
-  "version": "0.1.69",
+  "version": "0.2.78",
   "description": "Browser-backed ChatGPT Pro escalation for hard engineering questions.",
   "keywords": [
     "agents",
@@ -41,6 +41,7 @@
     "dist/src/browser/liveTabs.js",
     "dist/src/browser/modelStrategy.js",
     "dist/src/browser/pageActions.js",
+    "dist/src/browser/profileMigration.js",
     "dist/src/browser/profilePaths.js",
     "dist/src/browser/profileState.js",
     "dist/src/browser/providerDomFlow.js",