even-keel 0.0.2 → 0.2.0-rc.2

package/dist/src/account/model.js

@@ -0,0 +1,234 @@
+import { stripAnsi } from '../ansi.js';
+import { fail, notice } from '../notice/notice.js';
+import { CODEX } from '../codex/name.js';
+import { COPILOT } from '../copilot/name.js';
+import { OPENCODE } from '../opencode/name.js';
+import { isLive } from '../sessions/agents.js';
+import { APP_LABELS } from './apps.js';
+export const GLOBAL_ACCOUNT = 'global';
+/** The key of Codex's own account folder, `CODEX_HOME` or `~/.codex` (`AccountHomes`). */
+export const CODEX_ACCOUNT = 'codex';
+/** ChatGPT's `chatgpt_plan_type` of an account without a subscription. */
+const FREE_PLAN = 'free';
+const URL_PATTERN = /https:\/\/[^\s"'<>\u001b]+/g;
+const TRAILING_PUNCTUATION = /[.,;:!?)\]]+$/;
+/** Codex's code is the line under "Enter this one-time code", OpenCode's follows "Enter code:"; a code counts once its line ends. */
+const DEVICE_CODE = /(?:one-time code[^\n]*\n[ \t]*|Enter code:[ \t]*)([A-Z0-9]+(?:-[A-Z0-9]+)*)[ \t]*\n/g;
+export function parseAuthStatus(text) {
+    let body;
+    try {
+        body = JSON.parse(text);
+    }
+    catch {
+        throw fail('claude.statusNotJson', {}, { detail: text.trim().slice(0, 200) });
+    }
+    if (typeof body !== 'object' || body === null || Array.isArray(body))
+        throw fail('claude.statusNotObject', {});
+    const fields = body;
+    if (typeof fields.loggedIn !== 'boolean')
+        throw fail('claude.statusNoFlag', {});
+    return {
+        loggedIn: fields.loggedIn,
+        authMethod: stringOf(fields.authMethod),
+        email: stringOf(fields.email),
+        orgName: stringOf(fields.orgName),
+        subscriptionType: stringOf(fields.subscriptionType),
+    };
+}
+/** An API account signs in with a key from its folder's `settings.json`, not with claude.ai (`docs/accounts.md`). */
+export function isApiKey(status) {
+    return status?.authMethod === 'api_key' || status?.authMethod === 'api_key_helper';
+}
+/** An API account has no e-mail: its folder key stands in for it wherever an account is told apart by e-mail. */
+export function withIdentity(status, key) {
+    return status.loggedIn && status.email === null && isApiKey(status) ? { ...status, email: key } : status;
+}
+export function cleanOutput(raw) {
+    return stripAnsi(raw).replace(/\r\n?/g, '\n');
+}
+export function loginUrls(output) {
+    const found = cleanOutput(output).match(URL_PATTERN) ?? [];
+    return [...new Set(found.map((url) => url.replace(TRAILING_PUNCTUATION, '')))];
+}
+/** The one-time code a device sign-in printed, Codex's or OpenCode's: the last one, `null` when there is none yet. */
+export function loginCode(output) {
+    return [...cleanOutput(output).matchAll(DEVICE_CODE)].at(-1)?.[1] ?? null;
+}
+export function parseCredentialTimes(text) {
+    const none = { accessExpiresAt: null, loginExpiresAt: null, erased: false };
+    if (text === undefined)
+        return none;
+    let body;
+    try {
+        body = JSON.parse(text);
+    }
+    catch {
+        return none;
+    }
+    const oauth = body?.claudeAiOauth;
+    if (typeof oauth !== 'object' || oauth === null)
+        return none;
+    const { expiresAt, refreshTokenExpiresAt } = oauth;
+    const time = (value) => (typeof value === 'number' && Number.isFinite(value) ? value : null);
+    return { accessExpiresAt: time(expiresAt), loginExpiresAt: time(refreshTokenExpiresAt), erased: expiresAt === 0 };
+}
+export function needsLogin(status, times, now) {
+    if (status?.loggedIn === false || times.erased)
+        return true;
+    return times.loginExpiresAt !== null && times.loginExpiresAt <= now.getTime();
+}
+export function folderName(email, taken) {
+    const base = folderBase(email);
+    const used = new Set([...taken.map((name) => name.toLowerCase()), GLOBAL_ACCOUNT, CODEX_ACCOUNT]);
+    if (!used.has(base))
+        return base;
+    let index = 2;
+    while (used.has(`${base}-${index}`))
+        index++;
+    return `${base}-${index}`;
+}
+/** Whether the folder `key` bears the name `folderName` gives a sign-in of `email`, numbered or not. */
+export function namedAfter(key, email) {
+    const base = folderBase(email);
+    const lower = key.toLowerCase();
+    return lower === base || (lower.startsWith(`${base}-`) && /^\d+$/.test(lower.slice(base.length + 1)));
+}
+function folderBase(email) {
+    const local = (email ?? '').split('@')[0].toLowerCase();
+    return local.replace(/[^a-z0-9._-]+/g, '-').replace(/^[.-]+|[.-]+$/g, '') || 'account';
+}
+/** Machine accounts have no profile email; their folder identifies them in the current view and the ledger alike. */
+export function accountId(key, email) {
+    return email === null ? key : `${key}/${email}`;
+}
+export function activeEntry(view) {
+    return view.accounts.find((entry) => entry.key === view.active);
+}
+export function switchProblem(view, key) {
+    const target = view.accounts.find((entry) => entry.key === key);
+    if (target === undefined)
+        return notice('account.unknown', { key });
+    if (key === view.active)
+        return notice('account.alreadyActive', { key });
+    if (target.removing)
+        return notice('account.removing', { account: target.status?.email ?? key });
+    if (copilotOnly(target))
+        return copilotUnsupported();
+    if (target.needsLogin || target.status?.loggedIn !== true)
+        return notice('account.needsLogin', { account: target.status?.email ?? key });
+    return freeHeld(view.accounts, key);
+}
+export function removeProblem(view, key) {
+    const target = view.accounts.find((entry) => entry.key === key);
+    if (target === undefined)
+        return notice('account.unknown', { key });
+    if (key === view.active)
+        return notice('account.activeKept', {});
+    const named = view.pool.filter((entry) => entry.account === key && entry.byDefault !== true);
+    if (named.some((entry) => entry.project === null))
+        return notice('account.sharedPool', { agent: target.agent });
+    const projects = [...new Set([...named.map((entry) => entry.project), ...target.projects])];
+    if (projects.length > 0)
+        return notice('account.projectPool', { agent: target.agent, projects });
+    if (view.login?.target === key && view.login.error === null)
+        return notice('account.signInRunning', {});
+    const user = target.global ? undefined : view.apps.find((app) => app.account === key);
+    if (user !== undefined)
+        return notice('account.usedByApp', { app: APP_LABELS[user.app] });
+    return undefined;
+}
+export function liveSessions(agents, key) {
+    return agents
+        .filter((agent) => (agent.account ?? GLOBAL_ACCOUNT) === key && isLive(agent))
+        .map((agent) => agent.name ?? agent.sessionId.slice(0, 8));
+}
+export function loginBlock(chains, agents, active) {
+    const running = chains.filter((chain) => !chain.paused).map((chain) => chain.project);
+    const busy = agents.flatMap((agent) => {
+        if ((agent.account ?? GLOBAL_ACCOUNT) !== active)
+            return [];
+        if (agent.state === 'done' || agent.state === 'stopped' || agent.state === 'failed')
+            return [];
+        if (agent.status !== 'busy' && agent.status !== 'shell' && agent.status !== 'waiting')
+            return [];
+        const status = agent.status === 'waiting' ? 'waiting' : 'busy';
+        return [{ name: agent.name ?? agent.sessionId.slice(0, 8), status, waitingFor: agent.waitingFor ?? null }];
+    });
+    return running.length === 0 && busy.length === 0 ? null : { chains: running, sessions: busy };
+}
+export function loginBlockNotice(block) {
+    if (block.chains.length > 0)
+        return notice('account.chainRunning', { project: block.chains.join(', ') });
+    return notice('account.sessionsBusy', { sessions: block.sessions.map((session) => session.name) });
+}
+/** Why no session starts in the account folder `key` — the active one, where Claude sessions start, unless given. */
+export function launchBlock(view, key = view.active) {
+    const active = view.accounts.find((entry) => entry.key === key);
+    if (active === undefined)
+        return key === view.active ? notice('account.activeGone', { key }) : notice('account.homeGone', { key });
+    if (copilotOnly(active))
+        return copilotUnsupported();
+    if (view.login !== null && view.login.target === key && view.login.error === null)
+        return notice('account.signingIn', {});
+    if (active.status?.loggedIn === false)
+        return notice('account.signedOut', {});
+    if (active.needsLogin)
+        return notice('account.loginExpired', { account: active.status?.email ?? active.key });
+    return freeHeld(view.accounts, key);
+}
+/**
+ * The keys of the Codex accounts on the free plan past the first in the folders' order: OpenAI's terms forbid several
+ * free accounts to get round the limits, so only the first of them works (BTN-176).
+ */
+export function extraFree(accounts) {
+    return freeCodex(accounts)
+        .slice(1)
+        .map((entry) => entry.key);
+}
+/**
+ * Whether an account of the agent just added takes the shared pool's entry for it: it does while that entry names no
+ * folder of the agent, so an install that signed in only from the page does not stay on a built-in folder that was
+ * never there (BTN-227).
+ */
+export function takesShared(pool, homes, agent) {
+    const shared = pool.find((entry) => entry.project === null && entry.provider === agent)?.account;
+    return shared === undefined || !homes.some((home) => home.key === shared && home.agent === agent);
+}
+/** Why no account of the agent is added: its CLI is not found, with where to get it. */
+export function missingNotice(agent) {
+    if (agent === OPENCODE)
+        return notice('login.opencodeMissing', {});
+    if (agent === COPILOT)
+        return notice('login.copilotMissing', {});
+    return notice(agent === CODEX ? 'login.codexMissing' : 'login.claudeMissing', {});
+}
+/**
+ * Why a Codex sign-in on the free plan is not added: another account already holds the one free plan, or the sign-in
+ * is that very account again.
+ */
+export function secondFreeProblem(accounts, agent, status) {
+    if (agent !== CODEX || !isFree(status))
+        return undefined;
+    const first = freeCodex(accounts)[0];
+    if (first === undefined)
+        return undefined;
+    const account = first.status?.email ?? first.key;
+    const same = status.email !== null && first.status?.email?.toLowerCase() === status.email.toLowerCase();
+    return notice(same ? 'account.sameFree' : 'account.secondFree', { account });
+}
+function freeHeld(accounts, key) {
+    const [first, ...rest] = freeCodex(accounts);
+    if (first === undefined || !rest.some((entry) => entry.key === key))
+        return undefined;
+    return notice('account.extraFree', { account: first.status?.email ?? first.key });
+}
+function freeCodex(accounts) {
+    return accounts.filter((entry) => entry.agent === CODEX && isFree(entry.status));
+}
+function isFree(status) {
+    return status?.loggedIn === true && status.subscriptionType === FREE_PLAN;
+}
+function stringOf(value) {
+    return typeof value === 'string' && value !== '' ? value : null;
+}
+import { copilotOnly, copilotUnsupported } from '../opencode/support.js';

package/dist/src/account/network.js

@@ -0,0 +1,51 @@
+import { CODEX } from '../codex/name.js';
+import { COPILOT } from '../copilot/name.js';
+import { OPENCODE } from '../opencode/name.js';
+const CLAUDE_API = 'https://api.anthropic.com';
+const OPENAI_API = 'https://api.openai.com';
+const OPENCODE_API = 'https://opencode.ai';
+const GITHUB_API = 'https://api.github.com';
+/** The API the agent's sign-in renews its tokens against: account calls wait until it answers (EKR-15). */
+export function providerUrl(agent) {
+    if (agent === OPENCODE)
+        return OPENCODE_API;
+    if (agent === COPILOT)
+        return GITHUB_API;
+    return agent === CODEX ? OPENAI_API : CLAUDE_API;
+}
+/** Any HTTP answer, an error status too, means the network is up. */
+export async function answers(url, timeoutMs) {
+    try {
+        await fetch(url, { method: 'HEAD', signal: AbortSignal.timeout(timeoutMs) });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Whether a provider answers, probed at most once per `ttlMs`. After a reboot the service starts before the network,
+ * and a CLI call that renews an account's single-use token then may lose the renewal and sign the account out.
+ */
+export class Reachability {
+    options;
+    known = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    up(url) {
+        const known = this.known.get(url);
+        if (known?.asking !== undefined)
+            return known.asking;
+        if (known !== undefined && this.options.now() - known.at < this.options.ttlMs)
+            return Promise.resolve(known.up);
+        const asking = this.options.probe(url).then((up) => {
+            this.known.set(url, { up, at: this.options.now() });
+            if (up !== (known?.up ?? true))
+                this.options.onChange(url, up);
+            return up;
+        });
+        this.known.set(url, { up: known?.up ?? true, at: known?.at ?? -Infinity, asking });
+        return asking;
+    }
+}

package/dist/src/account/organizations.js

@@ -0,0 +1,17 @@
+/**
+ * The organization each API account's key pays through, as the provider last named it to a working key (BTN-418):
+ * a dead key's answer names none, so it is kept while the key works, and a replacing key of another one is refused.
+ * Keyed by the account folder's key; table `key_organizations` (step 14, `docs/storage.md`).
+ */
+export async function loadKeyOrganizations(db) {
+    const { rows } = await db.query('select account, organization from key_organizations order by account');
+    return new Map(rows.map((row) => [row.account, row.organization]));
+}
+/** Starts its write at the call: see `Writes`. */
+export async function saveKeyOrganization(db, account, organization, at) {
+    await db.query(`insert into key_organizations (account, organization, seen_at) values ($1, $2, $3)
+       on conflict (account) do update set organization = excluded.organization, seen_at = excluded.seen_at`, [account, organization, at.toISOString()]);
+}
+export async function forgetKeyOrganization(db, account) {
+    await db.query('delete from key_organizations where account = $1', [account]);
+}

package/dist/src/account/service-defaults.js

@@ -0,0 +1,17 @@
+import { checkCredit, checkOpenAiCredit } from './credit.js';
+import { checkApiKey, checkGitHubToken, checkOpenAiKey } from './keycheck.js';
+export const KEY_CHECK_MS = 60 * 60_000;
+export const KEY_CHECK_TIMEOUT_MS = 15_000;
+export const CREDIT_CHECK_MS = 5 * 60_000;
+/**
+ * The key and credit checks by whose key it is (`keyProvider`). GitHub has no way to ask about a token's AI credits: a
+ * Copilot account waits out spent credit by its monthly allowance instead (`Agent.keyUsage`, BTN-341).
+ */
+export const KEY_CHECKS = { anthropic: checkApiKey, openai: checkOpenAiKey, github: checkGitHubToken };
+export const CREDIT_CHECKS = {
+    anthropic: checkCredit,
+    openai: checkOpenAiCredit,
+    github: async () => ({ state: 'unknown', reason: 'GitHub does not tell the AI credits of a token' }),
+};
+export const APP_POLL_MS = 5_000;
+export const LOGIN_TIMEOUT_MS = 10 * 60_000;

package/dist/src/account/share.js

@@ -0,0 +1,275 @@
+import { copyFileSync, existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, readlinkSync, renameSync, rmdirSync, symlinkSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { pathKey, sameSpelling } from '../paths.js';
+import { projectDirName } from '../sessions/paths.js';
+const PROJECT_KEYS = [
+    'hasTrustDialogAccepted',
+    'mcpServers',
+    'allowedTools',
+    'enabledMcpjsonServers',
+    'disabledMcpjsonServers',
+    'disabledMcpServers',
+    'mcpContextUris',
+    'hasClaudeMdExternalIncludesApproved',
+    'hasClaudeMdExternalIncludesWarningShown',
+];
+const ONBOARDING_KEYS = ['hasCompletedOnboarding', 'lastOnboardingVersion'];
+const LINKED_DIRS = ['agents', 'commands', 'hooks', 'output-styles'];
+const OWN_SKILLS = new Set(['synced', '.trash']);
+export const API_KEY_VARIABLE = 'ANTHROPIC_API_KEY';
+const COPIED_FILES = ['CLAUDE.md', join('plugins', 'installed_plugins.json'), join('plugins', 'known_marketplaces.json')];
+/** The global settings win, except the folder's own API key: it is what makes an API account (`docs/accounts.md`). */
+export function mergeSettings(global, folder) {
+    const merged = { ...folder, ...global };
+    const key = objectOf(folder?.env)[API_KEY_VARIABLE];
+    if (typeof key === 'string')
+        merged.env = { ...objectOf(global.env), [API_KEY_VARIABLE]: key };
+    if (folder?.apiKeyHelper !== undefined)
+        merged.apiKeyHelper = folder.apiKeyHelper;
+    return merged;
+}
+/**
+ * Project memory lives next to the global folder, not inside it: the global folder and every account folder hold only
+ * a link to it. The CLI asks before every write whose real path lies in a `.claude` folder that is not the session's own.
+ */
+export function memoryStore(globalDir) {
+    return join(dirname(globalDir), '.claude-memory');
+}
+/** Shared skills live next to the global folder for the same reason as memory: `~/.claude/skills/<name>` links to it. */
+export function skillStore(globalDir) {
+    return join(dirname(globalDir), '.claude-skills');
+}
+/** `agents`, `commands`, `hooks` and `output-styles` each live in their own store next to the global folder, as skills do. */
+export function linkedStore(globalDir, name) {
+    return join(dirname(globalDir), `.claude-${name}`);
+}
+/** The repository's folder in the memory store; chain sessions also get it as `autoMemoryDirectory`. */
+export function sharedMemory(globalDir, repo) {
+    return join(memoryStore(globalDir), projectDirName(repo));
+}
+export function linkType(platform) {
+    return platform === 'win32' ? 'junction' : 'dir';
+}
+export function shareProjects(global, folder, platform = process.platform) {
+    const projects = { ...objectOf(folder.projects) };
+    const globalProjects = Object.entries(objectOf(global.projects));
+    const keyOf = (path) => pathKey(path, platform);
+    const trusted = new Set(globalProjects.filter(([, value]) => objectOf(value).hasTrustDialogAccepted === true).map(([path]) => keyOf(path)));
+    for (const [path, value] of globalProjects) {
+        const project = objectOf(value);
+        if (!trusted.has(keyOf(path)))
+            continue;
+        const setup = Object.fromEntries(PROJECT_KEYS.filter((key) => key in project).map((key) => [key, project[key]]));
+        projects[path] = { ...objectOf(projects[path]), ...setup };
+    }
+    const shared = { ...folder, projects };
+    if (global.mcpServers !== undefined)
+        shared.mcpServers = global.mcpServers;
+    for (const key of ONBOARDING_KEYS)
+        if (shared[key] === undefined && global[key] !== undefined)
+            shared[key] = global[key];
+    return JSON.stringify(shared) === JSON.stringify(folder) ? undefined : shared;
+}
+export function shareConfig(global, dir, warn = console.warn) {
+    mkdirSync(dir, { recursive: true });
+    let changed = false;
+    const settings = readJson(join(global.dir, 'settings.json'));
+    if (settings !== undefined)
+        changed = writeIfChanged(join(dir, 'settings.json'), mergeSettings(settings, readJson(join(dir, 'settings.json')))) || changed;
+    const config = readJson(global.config);
+    if (config !== undefined) {
+        const shared = shareProjects(config, readJson(join(dir, '.claude.json')) ?? {});
+        if (shared !== undefined) {
+            writeFileSync(join(dir, '.claude.json'), JSON.stringify(shared, null, 2));
+            changed = true;
+        }
+    }
+    for (const file of COPIED_FILES)
+        changed = copyIfChanged(join(global.dir, file), join(dir, file)) || changed;
+    for (const name of LINKED_DIRS) {
+        const own = join(global.dir, name);
+        const stored = linkedStore(global.dir, name);
+        changed = absorbFolder(own, stored, warn, name) || changed;
+        changed = link(linksTo(own, stored) ? stored : own, join(dir, name)) || changed;
+    }
+    const skills = skillStore(global.dir);
+    for (const name of entries(join(global.dir, 'skills'))) {
+        if (OWN_SKILLS.has(name))
+            continue;
+        const own = join(global.dir, 'skills', name);
+        const stored = join(skills, name);
+        changed = absorbFolder(own, stored, warn, 'skills') || changed;
+        const path = join(dir, 'skills', name);
+        const target = linksTo(own, stored) ? stored : own;
+        if (!linksElsewhere(path, [own, stored]))
+            changed = link(target, path) || changed;
+    }
+    const store = memoryStore(global.dir);
+    const projects = new Set([...entries(join(global.dir, 'projects')), ...entries(join(dir, 'projects'))]);
+    for (const project of projects) {
+        const shared = join(store, project);
+        const owns = [global.dir, dir].map((home) => join(home, 'projects', project, 'memory'));
+        for (const own of owns)
+            changed = absorbMemory(shared, own, warn) || changed;
+        for (const own of owns)
+            changed = link(shared, own) || changed;
+    }
+    return changed;
+}
+/** Moves what a folder's own memory holds into the store; files that differ stay and are warned about. */
+function absorbMemory(shared, own, warn) {
+    if (!existsSync(own))
+        return false;
+    const stat = lstatSync(own);
+    if (stat.isSymbolicLink() || !stat.isDirectory())
+        return false;
+    mkdirSync(shared, { recursive: true });
+    return moveInto(own, shared, warn, 'memory');
+}
+/**
+ * Moves a global skill or linked folder kept as a real folder into the store and leaves a link in its place; one already linked
+ * (to the store or elsewhere) stays, a missing one is linked to the store if it has it. A folder the store already has
+ * is merged as memory is; a locked one waits for the next launch.
+ */
+function absorbFolder(own, stored, warn, what) {
+    const stat = lstatOf(own);
+    if (stat === undefined)
+        return link(stored, own);
+    if (stat.isSymbolicLink() || !stat.isDirectory())
+        return false;
+    try {
+        if (!existsSync(stored)) {
+            mkdirSync(dirname(stored), { recursive: true });
+            renameSync(own, stored);
+            symlinkSync(stored, own, linkType(process.platform));
+            return true;
+        }
+        const moved = moveInto(own, stored, warn, what);
+        return link(stored, own) || moved;
+    }
+    catch (error) {
+        warn(`${what}: ${own} was not moved to ${stored} (${error instanceof Error ? error.message : String(error)}); left in place`);
+        return false;
+    }
+}
+function moveInto(from, to, warn, what) {
+    let changed = false;
+    for (const entry of readdirSync(from, { withFileTypes: true })) {
+        const source = join(from, entry.name);
+        const target = join(to, entry.name);
+        if (entry.isDirectory()) {
+            mkdirSync(target, { recursive: true });
+            changed = moveInto(source, target, warn, what) || changed;
+            if (readdirSync(source).length === 0)
+                rmdirSync(source);
+        }
+        else if (!existsSync(target)) {
+            copyFileSync(source, target);
+            unlinkSync(source);
+            changed = true;
+        }
+        else if (readFileSync(source).equals(readFileSync(target))) {
+            unlinkSync(source);
+            changed = true;
+        }
+        else {
+            warn(`${what}: ${source} differs from ${target}; left in place, merge by hand`);
+        }
+    }
+    return changed;
+}
+function link(target, path) {
+    if (!isDirectory(target))
+        return false;
+    const stat = lstatOf(path);
+    if (stat?.isSymbolicLink()) {
+        if (sameSpelling(linkTarget(path), target))
+            return false;
+        unlinkSync(path);
+    }
+    else if (stat !== undefined) {
+        if (!stat.isDirectory() || readdirSync(path).length > 0)
+            return false;
+        rmdirSync(path);
+    }
+    mkdirSync(join(path, '..'), { recursive: true });
+    symlinkSync(target, path, linkType(process.platform));
+    return true;
+}
+function copyIfChanged(from, to) {
+    let source;
+    try {
+        source = readFileSync(from);
+    }
+    catch {
+        return false;
+    }
+    try {
+        if (readFileSync(to).equals(source))
+            return false;
+    }
+    catch {
+        mkdirSync(join(to, '..'), { recursive: true });
+    }
+    copyFileSync(from, to);
+    return true;
+}
+function writeIfChanged(file, value) {
+    if (JSON.stringify(readJson(file)) === JSON.stringify(value))
+        return false;
+    writeFileSync(file, JSON.stringify(value, null, 2));
+    return true;
+}
+function readJson(file) {
+    try {
+        const value = JSON.parse(readFileSync(file, 'utf8'));
+        return typeof value === 'object' && value !== null && !Array.isArray(value) ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function entries(dir) {
+    try {
+        return readdirSync(dir, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory() || entry.isSymbolicLink())
+            .map((entry) => entry.name);
+    }
+    catch {
+        return [];
+    }
+}
+function lstatOf(path) {
+    try {
+        return lstatSync(path);
+    }
+    catch {
+        return undefined;
+    }
+}
+function linksTo(path, target) {
+    return lstatOf(path)?.isSymbolicLink() === true && sameSpelling(linkTarget(path), target);
+}
+/** A live link to a folder other than the given ones: a skill the user pointed somewhere on purpose. */
+function linksElsewhere(path, targets) {
+    if (lstatOf(path)?.isSymbolicLink() !== true || !existsSync(path))
+        return false;
+    return !targets.some((target) => sameSpelling(linkTarget(path), target));
+}
+/** A junction's target comes back as `\\?\C:\…\` on Windows. */
+function linkTarget(path) {
+    return readlinkSync(path)
+        .replace(/^\\\\\?\\/, '')
+        .replace(/[\\/]+$/, '');
+}
+function isDirectory(path) {
+    try {
+        return lstatSync(path).isDirectory() || lstatSync(path).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+function objectOf(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value) ? value : {};
+}

package/dist/src/account/transport.js

@@ -0,0 +1,29 @@
+import { CLAUDE } from '../claude/name.js';
+export const TRANSPORTS = ['sdk', 'bg'];
+/** The `execution.claude` that runs each account by its kind (`transportOf`), the setting's default (BTN-353). */
+export const AUTO_EXECUTION = 'auto';
+export function isTransport(value) {
+    return typeof value === 'string' && TRANSPORTS.includes(value);
+}
+/**
+ * The transport of an account's new sessions by `execution.claude`: the one it names, else on `auto` the SDK on an API
+ * key and `--bg` on a subscription, which Anthropic's terms do not clearly allow to drive through the SDK. `null` — the
+ * account's agent has one way only.
+ */
+export function transportOf(agent, execution, apiKey) {
+    if (agent !== CLAUDE)
+        return null;
+    if (isTransport(execution))
+        return execution;
+    return apiKey ? 'sdk' : 'bg';
+}
+/**
+ * The `execution.claude` the accounts' own choices become (BTN-353): `auto` when each is what `auto` gives its account,
+ * the SDK when every one chose it, else `auto`, with the accounts whose way changes by it.
+ */
+export function executionOfChoices(choices) {
+    const moved = choices.filter((choice) => choice.transport !== transportOf(CLAUDE, AUTO_EXECUTION, choice.apiKey));
+    if (moved.length > 0 && choices.every((choice) => choice.transport === 'sdk'))
+        return { execution: 'sdk', moved: [] };
+    return { execution: AUTO_EXECUTION, moved };
+}