@giovannijecha/jecode 0.8.4 → 0.8.6

package/dist/credentials.js

@@ -9,12 +9,12 @@
 // The file lives under ~/.jecode and never in this repo. A
 // secret in the working tree is one `git add -A` from being published, which
 // is why "not in the repo" is a rule and not a preference.
-import { chmod, mkdir } from "node:fs/promises";
 import * as path from "node:path";
 import { atomicWrite } from "./atomic.js";
+import { assertDirectoryAnchor, captureDirectDirectorySync, preparePrivateDirectory, } from "./directory-anchor.js";
 import { withStoreLock } from "./store-lock.js";
 import { legacyUserDataPath, userDataLabel, userDataPath } from "./user-data.js";
-import { assertStoreText, readBoundedJsonSync, USER_STORE_LIMITS } from "./user-store.js";
+import { assertStoreText, readBoundedJsonForMutationSync, readBoundedJsonSync, USER_STORE_LIMITS, } from "./user-store.js";
 /** Keys this session was given but not asked to keep. Dies with the window. */
 const held = new Map();
 /** The saved file, read once. `undefined` until the first look at it. */
@@ -79,35 +79,37 @@ export function forgetSession(name) {
 export async function keep(name, value) {
     assertCredential(name, value);
     const file = storePath();
-    await prepare(file);
-    return withStoreLock(file, async () => {
-        const all = { ...readSavedStore(), [name]: value };
+    const directory = await prepare(file);
+    const anchoredFile = path.join(directory.path, path.basename(file));
+    return withStoreLock(anchoredFile, async () => {
+        const all = { ...readSavedStoreForMutation(anchoredFile, directory), [name]: value };
         if (Object.keys(all).length > USER_STORE_LIMITS.credentialEntries) {
             throw new Error("too many saved credentials");
         }
-        await persist(file, all);
+        await persist(anchoredFile, all, directory);
         saved = all;
         // A newly saved replacement must become active immediately. Otherwise an
         // older session-only value would keep shadowing the value just written.
         held.delete(name);
         return file;
-    });
+    }, undefined, async () => assertDirectoryAnchor(directory));
 }
 /** Remove only the saved copy. An environment or session value is untouched. */
 export async function forgetSaved(name) {
     const file = storePath();
-    await prepare(file);
-    return withStoreLock(file, async () => {
-        const all = { ...readSavedStore() };
+    const directory = await prepare(file);
+    const anchoredFile = path.join(directory.path, path.basename(file));
+    return withStoreLock(anchoredFile, async () => {
+        const all = { ...readSavedStoreForMutation(anchoredFile, directory) };
         if (use(all[name]) === undefined) {
             saved = all;
             return false;
         }
         delete all[name];
-        await persist(file, all);
+        await persist(anchoredFile, all, directory);
         saved = all;
         return true;
-    });
+    }, undefined, async () => assertDirectoryAnchor(directory));
 }
 export function storePath() {
     return userDataPath("credentials.json");
@@ -137,9 +139,44 @@ function readSavedStore() {
     const legacy = legacyUserDataPath("credentials.json");
     return current ?? (legacy === undefined ? undefined : readStore(legacy)) ?? {};
 }
+function readSavedStoreForMutation(file, directory) {
+    const current = readCredentialStoreForMutation(file, directory);
+    if (current !== undefined)
+        return current;
+    const legacy = legacyUserDataPath("credentials.json");
+    if (legacy === undefined)
+        return {};
+    return readCredentialStoreForMutation(legacy) ?? {};
+}
+function readCredentialStoreForMutation(file, directory) {
+    let anchor = directory;
+    if (anchor === undefined) {
+        try {
+            anchor = captureDirectDirectorySync(path.dirname(file), "credential store directory");
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return undefined;
+            throw new Error("credential store is invalid, unsafe, or too large", { cause: error });
+        }
+    }
+    const anchoredFile = path.join(anchor.path, path.basename(file));
+    const value = readBoundedJsonForMutationSync(anchoredFile, USER_STORE_LIMITS.credentialsBytes, "credential store", anchor);
+    if (value === undefined)
+        return undefined;
+    if (!record(value))
+        throw new Error("credential store has an unsupported structure");
+    const entries = Object.entries(value);
+    if (entries.length > USER_STORE_LIMITS.credentialEntries ||
+        entries.some(([name, candidate]) => !credential(name, candidate)))
+        throw new Error("credential store has invalid entries");
+    return Object.fromEntries(entries);
+}
 function readStore(file) {
     try {
-        const parsed = readBoundedJsonSync(file, USER_STORE_LIMITS.credentialsBytes);
+        const directory = captureDirectDirectorySync(path.dirname(file), "credential store directory");
+        const anchoredFile = path.join(directory.path, path.basename(file));
+        const parsed = readBoundedJsonSync(anchoredFile, USER_STORE_LIMITS.credentialsBytes, directory);
         if (!record(parsed))
             return {};
         // Anything that is not a string is not a key, whatever the file says.
@@ -156,14 +193,15 @@ function readStore(file) {
 }
 async function prepare(file) {
     const directory = path.dirname(file);
-    await mkdir(directory, { recursive: true, mode: 0o700 });
-    if (process.platform !== "win32")
-        await chmod(directory, 0o700);
+    return preparePrivateDirectory(directory, "credential store directory");
 }
-async function persist(file, values) {
+async function persist(file, values, directory) {
     const text = `${JSON.stringify(values, null, 2)}\n`;
     assertStoreText(text, USER_STORE_LIMITS.credentialsBytes);
-    await atomicWrite(file, text, { mode: 0o600 });
+    await atomicWrite(file, text, {
+        mode: 0o600,
+        validate: async () => assertDirectoryAnchor(directory),
+    });
 }
 function assertCredential(name, value) {
     if (!credential(name, value))

package/dist/directory-anchor.js

@@ -0,0 +1,91 @@
+// Stable ownership boundary for private data directories.
+import { constants, lstatSync, realpath as realpathCallback, realpathSync } from "node:fs";
+import { lstat, mkdir, open } from "node:fs/promises";
+import * as path from "node:path";
+import { fileIdentity, sameFileIdentity } from "./file-identity.js";
+export async function preparePrivateDirectory(directory, label, mode = 0o700) {
+    const resolved = path.resolve(directory);
+    await mkdir(resolved, { recursive: true, mode });
+    const anchor = await captureDirectDirectory(resolved, label);
+    await secureDirectoryMode(anchor, mode);
+    return anchor;
+}
+export async function createPrivateDirectory(directory, label, mode = 0o700) {
+    const resolved = path.resolve(directory);
+    await mkdir(resolved, { mode });
+    const anchor = await captureDirectDirectory(resolved, label);
+    await secureDirectoryMode(anchor, mode);
+    return anchor;
+}
+export async function captureDirectDirectory(directory, label) {
+    const resolved = path.resolve(directory);
+    const [canonical, named] = await Promise.all([
+        nativeRealpath(resolved),
+        lstat(resolved, { bigint: true }),
+    ]);
+    if (named.isSymbolicLink() || !named.isDirectory()) {
+        throw new Error(`${label} is not a direct directory`);
+    }
+    const direct = await lstat(canonical, { bigint: true });
+    if (direct.isSymbolicLink() || !direct.isDirectory() ||
+        !sameFileIdentity(fileIdentity(named), fileIdentity(direct)))
+        throw new Error(`${label} changed while it was anchored`);
+    return Object.freeze({ path: canonical, identity: fileIdentity(direct), label });
+}
+export function captureDirectDirectorySync(directory, label) {
+    const resolved = path.resolve(directory);
+    const canonical = realpathSync.native(resolved);
+    const named = lstatSync(resolved, { bigint: true });
+    if (named.isSymbolicLink() || !named.isDirectory()) {
+        throw new Error(`${label} is not a direct directory`);
+    }
+    const direct = lstatSync(canonical, { bigint: true });
+    if (direct.isSymbolicLink() || !direct.isDirectory() ||
+        !sameFileIdentity(fileIdentity(named), fileIdentity(direct)))
+        throw new Error(`${label} changed while it was anchored`);
+    return Object.freeze({ path: canonical, identity: fileIdentity(direct), label });
+}
+export async function assertDirectoryAnchor(anchor) {
+    const current = await lstat(anchor.path, { bigint: true });
+    if (current.isSymbolicLink() || !current.isDirectory() ||
+        !sameFileIdentity(anchor.identity, fileIdentity(current))) {
+        throw new Error(`${anchor.label} changed during use`);
+    }
+}
+export function assertDirectoryAnchorSync(anchor) {
+    const current = lstatSync(anchor.path, { bigint: true });
+    if (current.isSymbolicLink() || !current.isDirectory() ||
+        !sameFileIdentity(anchor.identity, fileIdentity(current))) {
+        throw new Error(`${anchor.label} changed during use`);
+    }
+}
+function nativeRealpath(target) {
+    return new Promise((resolve, reject) => {
+        realpathCallback.native(target, (error, canonical) => {
+            if (error !== null)
+                reject(error);
+            else
+                resolve(canonical);
+        });
+    });
+}
+async function secureDirectoryMode(anchor, mode) {
+    if (process.platform === "win32")
+        return;
+    const handle = await open(anchor.path, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+    try {
+        const opened = await handle.stat({ bigint: true });
+        if (!opened.isDirectory() ||
+            !sameFileIdentity(anchor.identity, fileIdentity(opened)))
+            throw new Error(`${anchor.label} changed before its permissions were secured`);
+        await handle.chmod(mode);
+        const secured = await handle.stat({ bigint: true });
+        if (!secured.isDirectory() ||
+            !sameFileIdentity(anchor.identity, fileIdentity(secured)))
+            throw new Error(`${anchor.label} changed while its permissions were secured`);
+    }
+    finally {
+        await handle.close();
+    }
+    await assertDirectoryAnchor(anchor);
+}

package/dist/file-identity.js

@@ -0,0 +1,12 @@
+// Portable-enough identity checks for named files and directories.
+export function fileIdentity(details) {
+    return Object.freeze({
+        dev: details.dev,
+        ino: details.ino,
+        birthtimeNs: details.birthtimeNs,
+    });
+}
+export function sameFileIdentity(left, right) {
+    return left.dev === right.dev && left.ino === right.ino &&
+        left.birthtimeNs === right.birthtimeNs;
+}

package/dist/model-command.js

@@ -2,7 +2,7 @@
 import { saveCommandSettings } from "./command-settings.js";
 import { compatibleEffort } from "./effort.js";
 import { providerFailure } from "./provider-errors.js";
-import { providerLabel } from "./provider-label.js";
+import { providerLabel, providerRouteLabel } from "./provider-label.js";
 import { PROVIDERS } from "./providers/index.js";
 import { readSettings } from "./settings.js";
 /** Build one searchable catalogue from every provider that is usable now. */
@@ -76,7 +76,7 @@ export async function modelsCommand(session, host, behavior = {}, providers = PR
             label: choice.model,
             // Provider identity is part of the choice, not optional help: keep it
             // visible even when the terminal is only at the supported minimum.
-            value: providerLabel(choice.provider.id),
+            value: providerRouteLabel(choice.provider),
         })),
         searchable: true,
         query: "",
@@ -111,7 +111,7 @@ export async function modelsCommand(session, host, behavior = {}, providers = PR
     if (behavior.announce !== false) {
         host.emit({
             kind: "notice",
-            text: `model · ${providerLabel(chosen.provider.id)} · ${chosen.model}`,
+            text: `model · ${providerRouteLabel(chosen.provider)} · ${chosen.model}`,
             tone: "info",
         });
     }
@@ -138,6 +138,7 @@ async function alignEffort(provider, model, effort, host) {
 }
 function catalogDescription(disconnected, failed) {
     const parts = [
+        "The connection on the right will run this model; API and account usage stay separate",
         disconnected.length === 0
             ? undefined
             : `Not connected: ${disconnected.map((provider) => providerLabel(provider.id)).join(", ")}`,
@@ -145,7 +146,7 @@ function catalogDescription(disconnected, failed) {
             ? undefined
             : `Unavailable: ${failed.map((entry) => providerLabel(entry.provider.id)).join(", ")}`,
     ].filter((part) => part !== undefined);
-    return parts.length === 0 ? undefined : `${parts.join(" · ")} · manage in /providers`;
+    return `${parts.join(" · ")} · manage access in /providers`;
 }
 function emptyCatalogMessage(connected, failed) {
     if (failed.length === 1 && connected.length === 1) {

package/dist/openai-account-command.js

@@ -1,9 +1,11 @@
-// Interactive ChatGPT account management for the OpenAI Codex provider.
+// Interactive account management for the OpenAI Codex provider.
 import { openAICodexAccount } from "./accounts.js";
 import { headlessEnvironment, openExternal } from "./external-browser.js";
 import { openAIAccountHint, removeOpenAIAccount, saveOpenAIAccount, } from "./openai-account.js";
 import { beginBrowserLogin, beginDeviceLogin, } from "./openai-oauth.js";
+import { providerLabel } from "./provider-label.js";
 import { heading } from "./tui/picker.js";
+const ACCOUNT_LABEL = providerLabel("openai-codex");
 const DEFAULT_DEPENDENCIES = {
     beginBrowser: beginBrowserLogin,
     beginDevice: beginDeviceLogin,
@@ -16,12 +18,12 @@ export async function openAIAccountCommand(session, host, dependencies = DEFAULT
     const connected = openAICodexAccount() !== undefined;
     const actions = connected
         ? [
-            { label: "reconnect ChatGPT", hint: "replace the current sign-in", key: "r" },
+            { label: `reconnect ${ACCOUNT_LABEL}`, hint: "replace the current sign-in", key: "r" },
             { label: "sign out", hint: "remove the saved account", key: "s" },
         ]
-        : [{ label: "connect ChatGPT", hint: "sign in with OpenAI", key: "c" }];
+        : [{ label: `connect ${ACCOUNT_LABEL}`, hint: "sign in with OpenAI", key: "c" }];
     const action = await host.choose({
-        title: heading("ChatGPT", openAIAccountHint(), session.palette),
+        title: heading(ACCOUNT_LABEL, openAIAccountHint(), session.palette),
         options: actions,
         index: 0,
     });
@@ -29,9 +31,14 @@ export async function openAIAccountCommand(session, host, dependencies = DEFAULT
         return false;
     if (connected && actions[action]?.key === "s") {
         const result = await removeOpenAIAccount(host.signal);
+        const route = session.provider.id === "openai-codex"
+            ? " · choose another provider in /models"
+            : "";
         host.emit({
             kind: "notice",
-            text: result.revokeFailed ? "ChatGPT disconnected · remote sign-out could not be confirmed" : "ChatGPT disconnected",
+            text: result.revokeFailed
+                ? `${ACCOUNT_LABEL} disconnected · remote sign-out could not be confirmed${route}`
+                : `${ACCOUNT_LABEL} disconnected${route}`,
             tone: result.revokeFailed ? "warn" : "info",
         });
         return result.removed;
@@ -51,14 +58,14 @@ async function connectOpenAIAccount(session, host, dependencies) {
         { label: "sign in with device code", hint: "WSL, SSH, or headless", key: "d" },
     ];
     const choice = await host.choose({
-        title: heading("connect ChatGPT", "OpenAI OAuth", session.palette),
+        title: heading(`connect ${ACCOUNT_LABEL}`, "OpenAI OAuth", session.palette),
         description: "Choose the flow for this terminal. Your password stays on OpenAI's website.",
         options: methods,
         index: dependencies.headless() ? 1 : 0,
     });
     if (choice === undefined)
         return false;
-    host.status?.("Starting ChatGPT sign-in");
+    host.status?.(`Starting ${ACCOUNT_LABEL} sign-in`);
     let login;
     try {
         login = choice === 1
@@ -89,7 +96,13 @@ async function waitForLogin(login, session, host, openUrl) {
             if (outcome.kind === "account") {
                 host.dismiss?.();
                 await saveOpenAIAccount(outcome.account, host.signal);
-                host.emit({ kind: "notice", text: "ChatGPT connected", tone: "info" });
+                host.emit({
+                    kind: "notice",
+                    text: session.provider.id === "openai-codex"
+                        ? `${ACCOUNT_LABEL} connected · current provider route`
+                        : `${ACCOUNT_LABEL} connected · choose an ${ACCOUNT_LABEL} model in /models to use this account`,
+                    tone: "info",
+                });
                 return true;
             }
             if (outcome.kind === "error") {
@@ -100,7 +113,7 @@ async function waitForLogin(login, session, host, openUrl) {
                 await openUrl(login.url);
                 continue;
             }
-            local.abort(new Error("ChatGPT sign-in cancelled"));
+            local.abort(new Error(`${ACCOUNT_LABEL} sign-in cancelled`));
             return false;
         }
     }
@@ -113,7 +126,7 @@ function waitingPicker(login, session) {
         ? "Finish sign-in in your browser. Jecode will continue automatically."
         : `Enter ${login.code} on OpenAI's device page. Jecode will continue automatically.`;
     return {
-        title: heading("ChatGPT sign-in", login.code ?? "waiting for browser", session.palette),
+        title: heading(`${ACCOUNT_LABEL} sign-in`, login.code ?? "waiting for browser", session.palette),
         description: detail,
         options: [
             { label: "open browser again", key: "o" },

package/dist/openai-account.js

@@ -1,6 +1,8 @@
-// The live ChatGPT account: persistence, proactive refresh, and logout.
+// The live OpenAI account: persistence, proactive refresh, and logout.
 import { openAICodexAccount, updateOpenAICodexAccount } from "./accounts.js";
 import { refreshOpenAITokens, revokeOpenAITokens } from "./openai-oauth.js";
+import { providerLabel } from "./provider-label.js";
+const ACCOUNT_LABEL = providerLabel("openai-codex");
 const REFRESH_EARLY_MS = 5 * 60_000;
 let refreshing;
 export function openAIAccountHint() {
@@ -33,7 +35,7 @@ export async function removeOpenAIAccount(signal) {
 export async function openAIAuthorization(rejectedToken, signal, onStatus) {
     const account = openAICodexAccount();
     if (account === undefined)
-        throw new Error("ChatGPT account is not connected");
+        throw new Error(`${ACCOUNT_LABEL} is not connected`);
     const mustRefresh = rejectedToken !== undefined || expiresSoon(account);
     const ready = mustRefresh
         ? await refreshAccount(rejectedToken, signal, onStatus)
@@ -47,14 +49,14 @@ async function refreshAccount(rejectedToken, signal, onStatus) {
         throw abortReason(signal);
     const task = updateOpenAICodexAccount(async (current) => {
         if (current === undefined)
-            throw new Error("ChatGPT account is not connected");
+            throw new Error(`${ACCOUNT_LABEL} is not connected`);
         if (!requiresAuthorityRefresh(current, rejectedToken))
             return current;
-        onStatus?.("Refreshing ChatGPT sign-in");
+        onStatus?.(`Refreshing ${ACCOUNT_LABEL} sign-in`);
         return refreshOpenAITokens(current);
     }).then((account) => {
         if (account === undefined)
-            throw new Error("ChatGPT account is not connected");
+            throw new Error(`${ACCOUNT_LABEL} is not connected`);
         return account;
     });
     refreshing = task;

package/dist/openai-oauth-callback.js

@@ -3,6 +3,8 @@ import { timingSafeEqual } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { createServer } from "node:http";
 import { leadingText } from "./text-boundary.js";
+import { providerLabel } from "./provider-label.js";
+const ACCOUNT_LABEL = providerLabel("openai-codex");
 const CALLBACK_PORTS = [1455, 1457];
 export const OPENAI_CALLBACK_PATH = "/auth/callback";
 export async function openAICallback(state) {
@@ -26,7 +28,14 @@ export async function openAICallback(state) {
             outgoing.writeHead(400).end("Invalid sign-in callback.");
             return;
         }
-        const incoming = new URL(request.url, "http://localhost");
+        let incoming;
+        try {
+            incoming = new URL(request.url, "http://localhost");
+        }
+        catch {
+            outgoing.writeHead(400).end("Invalid sign-in callback.");
+            return;
+        }
         if (incoming.pathname !== OPENAI_CALLBACK_PATH) {
             outgoing.writeHead(404).end("Not found.");
             return;
@@ -43,10 +52,10 @@ export async function openAICallback(state) {
         const authError = incoming.searchParams.get("error_description") ?? incoming.searchParams.get("error");
         const authorizationCode = incoming.searchParams.get("code");
         if (authError !== null) {
-            rejectCode(new Error(`ChatGPT sign-in was rejected · ${leadingText(authError, 300)}`));
+            rejectCode(new Error(`${ACCOUNT_LABEL} sign-in was rejected · ${leadingText(authError, 300)}`));
         }
         else if (authorizationCode === null || authorizationCode === "") {
-            rejectCode(new Error("ChatGPT sign-in returned no authorization code"));
+            rejectCode(new Error(`${ACCOUNT_LABEL} sign-in returned no authorization code`));
         }
         else {
             resolveCode(authorizationCode);
@@ -94,7 +103,7 @@ async function firstAvailableServer(handler) {
                 throw error;
         }
     }
-    throw new Error("ChatGPT sign-in could not open callback ports 1455 or 1457");
+    throw new Error(`${ACCOUNT_LABEL} sign-in could not open callback ports 1455 or 1457`);
 }
 function listen(server, port) {
     return new Promise((resolve, reject) => {

package/dist/openai-oauth-tokens.js

@@ -1,15 +1,17 @@
 // Validate OAuth token responses and extract the ChatGPT account claims.
+import { providerLabel } from "./provider-label.js";
+const ACCOUNT_LABEL = providerLabel("openai-codex");
 const CLAIMS = "https://api.openai.com/auth";
 export function openAITokenReply(value, previousRefresh) {
     if (!record(value))
-        throw new Error("OpenAI sign-in returned an invalid token response");
+        throw new Error(`${ACCOUNT_LABEL} sign-in returned an invalid token response`);
     const accessToken = required(value["access_token"], "access token");
     const refreshToken = optional(value["refresh_token"]) ?? previousRefresh;
     const expiresIn = value["expires_in"];
     if (refreshToken === undefined)
-        throw new Error("OpenAI sign-in did not return a refresh token");
+        throw new Error(`${ACCOUNT_LABEL} sign-in did not return a refresh token`);
     if (typeof expiresIn !== "number" || !Number.isFinite(expiresIn) || expiresIn <= 0) {
-        throw new Error("OpenAI sign-in did not return a valid token lifetime");
+        throw new Error(`${ACCOUNT_LABEL} sign-in did not return a valid token lifetime`);
     }
     const idToken = optional(value["id_token"]);
     return {
@@ -25,7 +27,7 @@ export function openAIAccountFromTokens(token) {
     const auth = record(access[CLAIMS]) ? access[CLAIMS] : {};
     const accountId = optional(auth["chatgpt_account_id"]) ?? optional(identity?.["chatgpt_account_id"]);
     if (accountId === undefined)
-        throw new Error("OpenAI sign-in did not identify a ChatGPT account");
+        throw new Error(`${ACCOUNT_LABEL} sign-in did not identify an account`);
     const email = optional(identity?.["email"]);
     const plan = optional(auth["chatgpt_plan_type"]) ?? optional(identity?.["chatgpt_plan_type"]);
     return {
@@ -40,7 +42,7 @@ export function openAIAccountFromTokens(token) {
 function jwt(token) {
     const part = token.split(".")[1];
     if (part === undefined)
-        throw new Error("OpenAI sign-in returned an unreadable token");
+        throw new Error(`${ACCOUNT_LABEL} sign-in returned an unreadable token`);
     try {
         const value = JSON.parse(Buffer.from(part, "base64url").toString("utf8"));
         if (!record(value))
@@ -48,13 +50,13 @@ function jwt(token) {
         return value;
     }
     catch {
-        throw new Error("OpenAI sign-in returned an unreadable token");
+        throw new Error(`${ACCOUNT_LABEL} sign-in returned an unreadable token`);
     }
 }
 function required(value, label) {
     const found = optional(value);
     if (found === undefined)
-        throw new Error(`OpenAI sign-in returned no ${label}`);
+        throw new Error(`${ACCOUNT_LABEL} sign-in returned no ${label}`);
     return found;
 }
 function optional(value) {

package/dist/openai-oauth.js

@@ -5,8 +5,10 @@
 // an account on disk.
 import { createHash, randomBytes } from "node:crypto";
 import { oauthRequest } from "./oauth-http.js";
+import { providerLabel } from "./provider-label.js";
 import { OPENAI_CALLBACK_PATH, openAICallback } from "./openai-oauth-callback.js";
 import { openAIAccountFromTokens, openAITokenReply, } from "./openai-oauth-tokens.js";
+const ACCOUNT_LABEL = providerLabel("openai-codex");
 const CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
 const AUTHORITY = "https://auth.openai.com";
 const AUTHORIZE = `${AUTHORITY}/oauth/authorize`;
@@ -91,7 +93,7 @@ export async function refreshOpenAITokens(account, signal) {
     const token = openAITokenReply(response.value, account.refreshToken);
     const refreshed = openAIAccountFromTokens(token);
     if (refreshed.accountId !== account.accountId) {
-        throw new Error("OpenAI refreshed a different ChatGPT account · sign in again");
+        throw new Error(`${ACCOUNT_LABEL} refresh returned a different account · sign in again`);
     }
     return {
         ...refreshed,
@@ -125,7 +127,7 @@ async function exchange(code, signal) {
 async function pollDevice(deviceAuthId, userCode, interval, signal) {
     const deadline = new AbortController();
     const timer = setTimeout(() => {
-        deadline.abort(new Error("ChatGPT device sign-in timed out after 15 minutes"));
+        deadline.abort(new Error(`${ACCOUNT_LABEL} device sign-in timed out after 15 minutes`));
     }, LOGIN_LIMIT_MS);
     const combined = signal === undefined
         ? deadline.signal
@@ -149,10 +151,10 @@ async function pollDevice(deviceAuthId, userCode, interval, signal) {
             }
             const errorCode = deviceErrorCode(response.value);
             if (errorCode === "access_denied") {
-                throw new Error("ChatGPT device sign-in was denied");
+                throw new Error(`${ACCOUNT_LABEL} device sign-in was denied`);
             }
             if (errorCode === "expired_token") {
-                throw new Error("ChatGPT device sign-in code expired");
+                throw new Error(`${ACCOUNT_LABEL} device sign-in code expired`);
             }
             const pending = errorCode === "authorization_pending" ||
                 errorCode === "deviceauth_authorization_pending" ||
@@ -160,7 +162,7 @@ async function pollDevice(deviceAuthId, userCode, interval, signal) {
             const slowDown = errorCode === "slow_down" ||
                 (response.status === 429 && errorCode === undefined);
             if (!pending && !slowDown) {
-                throw new Error(`ChatGPT device sign-in failed (${response.status})`);
+                throw new Error(`${ACCOUNT_LABEL} device sign-in failed (${response.status})`);
             }
             if (slowDown)
                 intervalMs += SLOW_DOWN_INCREMENT_MS;
@@ -192,7 +194,7 @@ function intervalSeconds(value) {
 function required(value, label) {
     const found = optional(value);
     if (found === undefined)
-        throw new Error(`OpenAI sign-in returned no ${label}`);
+        throw new Error(`${ACCOUNT_LABEL} sign-in returned no ${label}`);
     return found;
 }
 function optional(value) {

package/dist/permission-command.js

@@ -42,7 +42,7 @@ export function permissionsPicker(tools, index = 0, adjust) {
         index: Math.min(Math.max(0, index), Math.max(0, tools.length - 1)),
     };
 }
-function permissionControlPicker(control, host, selected) {
+export function permissionControlPicker(control, host, selected) {
     return permissionsPicker(control.listTools(), selected, (index, step) => {
         const tool = control.listTools()[index];
         if (tool === undefined)