sideby 0.5.0 → 0.7.0

package/dist/src/core/desktop-app.js

@@ -0,0 +1,371 @@
+// Opens a Family's Desktop App for one Account (spec §3.20, ADR-0015): macOS only, built-in claude and codex only.
+// The app bundle is started unchanged with `open`; another Account's instance gets its own App Data folder. Every
+// program sideby runs here (`open`, `ps`, `osascript`, `plutil`, `mdfind`) goes through `DesktopDeps.exec`, so
+// tests never start a real app.
+import { execFile } from 'node:child_process';
+import { chmod, mkdir, readdir, readFile, symlink } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import { desktopDef } from '../families/desktop.js';
+import { UserError } from './errors.js';
+import { lstatOrNull, statOrNull } from './fs-safe.js';
+import { checkItem } from './share-modes.js';
+const OPEN = '/usr/bin/open';
+const PS = '/bin/ps';
+const OSASCRIPT = '/usr/bin/osascript';
+const PLUTIL = '/usr/bin/plutil';
+const MDFIND = '/usr/bin/mdfind';
+function defaultExec(cmd, args, env) {
+    return new Promise((resolve) => execFile(cmd, [...args], { timeout: 15_000, maxBuffer: 16 * 1024 * 1024, ...(env ? { env: env } : {}) }, (err, stdout, stderr) => {
+        const code = err ? (typeof err.code === 'number' ? err.code : 1) : 0;
+        resolve({ code, stdout: String(stdout ?? ''), stderr: String(stderr ?? '') });
+    }));
+}
+const overrides = new WeakMap();
+/**
+ * Internal: makes every Desktop App call made with this Runtime use `deps` instead of the machine. Only
+ * `createRuntime` calls it, from its `desktop` option, which is the one way to replace the machine (tests).
+ */
+export function bindDesktopDeps(rt, deps) {
+    overrides.set(rt, deps);
+}
+function depsFor(rt) {
+    const o = overrides.get(rt) ?? {};
+    return {
+        platform: o.platform ?? process.platform,
+        appDirs: o.appDirs ?? ['/Applications', join(rt.paths.home, 'Applications')],
+        exec: o.exec ?? defaultExec,
+    };
+}
+/** The Desktop App of a Family, only when a built-in Plugin provides that Family (a plugin may not claim one). */
+export function desktopAppOf(plugins, familyId) {
+    const builtin = plugins.some((p) => p.source === 'builtin' && p.families.includes(familyId));
+    return builtin ? desktopDef(familyId) : undefined;
+}
+/** Where a non-main Account's App Data lives: `~/Library/Application Support/sideby/<family>/<name>`. */
+export function appDataDir(home, account) {
+    return join(home, 'Library', 'Application Support', 'sideby', account.family, account.name);
+}
+const plistString = (xml, key) => {
+    const m = new RegExp(`<key>${key}</key>\\s*<string>([^<]*)</string>`).exec(xml);
+    return m?.[1];
+};
+/** Reads string keys of an app's Info.plist: XML directly, a binary plist through `plutil`. */
+async function bundleInfo(deps, app) {
+    const file = join(app, 'Contents', 'Info.plist');
+    let text;
+    try {
+        text = await readFile(file, 'utf8');
+    }
+    catch {
+        return {};
+    }
+    if (text.startsWith('<?xml') || text.includes('<plist'))
+        return { id: plistString(text, 'CFBundleIdentifier'), exe: plistString(text, 'CFBundleExecutable') };
+    const read = async (key) => {
+        const r = await deps.exec(PLUTIL, ['-extract', key, 'raw', '-o', '-', file]);
+        return r.code === 0 ? r.stdout.trim() || undefined : undefined;
+    };
+    return { id: await read('CFBundleIdentifier'), exe: await read('CFBundleExecutable') };
+}
+/**
+ * Finds the app by bundle id: the usual names in the app folders first, then (with `spotlight`) Spotlight. Listing
+ * Accounts leaves Spotlight out to stay fast; opening one asks it too.
+ */
+export async function findApp(def, deps, opts = {}) {
+    const check = async (path) => {
+        if (!(await statOrNull(path))?.isDirectory())
+            return null;
+        const info = await bundleInfo(deps, path);
+        if (info.id !== def.bundleId)
+            return null;
+        return { path, executable: info.exe || basename(path, '.app') };
+    };
+    for (const dir of deps.appDirs)
+        for (const name of def.bundleNames) {
+            const found = await check(join(dir, name));
+            if (found)
+                return found;
+        }
+    if (!opts.spotlight)
+        return null;
+    const r = await deps.exec(MDFIND, [`kMDItemCFBundleIdentifier == "${def.bundleId}"`]);
+    if (r.code !== 0)
+        return null;
+    for (const line of r.stdout.split('\n')) {
+        const p = line.trim();
+        if (!p.endsWith('.app') || p.includes('/.Trash/'))
+            continue;
+        const found = await check(p);
+        if (found)
+            return found;
+    }
+    return null;
+}
+/** Every process with its command line, or null when `ps` failed (then nothing is known to run). */
+async function processes(deps) {
+    const r = await deps.exec(PS, ['-axo', 'pid=,command=']);
+    if (r.code !== 0)
+        return null;
+    const out = [];
+    for (const line of r.stdout.split('\n')) {
+        const m = /^\s*(\d+)\s+(.*)$/.exec(line);
+        if (m)
+            out.push({ pid: Number(m[1]), command: m[2].trimEnd() });
+    }
+    return out;
+}
+/** The arguments after the app's own executable, when `p` is the app's main process (not a helper). */
+function mainArgs(app, p) {
+    const exe = `/${basename(app.path)}/Contents/MacOS/${app.executable}`;
+    const at = p.command.indexOf(exe);
+    if (at === -1)
+        return null;
+    const rest = p.command.slice(at + exe.length);
+    return rest === '' || rest.startsWith(' ') ? rest : null;
+}
+/** The running instance of this Account: the one with its App Data, or for the Main Account the one without any. */
+export function instanceOf(app, appData, procs) {
+    return procs.find((p) => {
+        const args = mainArgs(app, p);
+        if (args === null)
+            return false;
+        if (appData === null)
+            return !args.includes('--user-data-dir=');
+        const flag = ` --user-data-dir=${appData}`;
+        const at = args.indexOf(flag);
+        if (at === -1)
+            return false;
+        const after = args.slice(at + flag.length);
+        return after === '' || after.startsWith(' ') || after === '/' || after.startsWith('/ ');
+    });
+}
+/** Brings a running app to the front through NSRunningApplication (no Automation permission needed). */
+async function activate(deps, pid) {
+    const script = [
+        "ObjC.import('AppKit');",
+        `const app = $.NSRunningApplication.runningApplicationWithProcessIdentifier(${Math.trunc(pid)});`,
+        "app.isNil() ? 'missing' : (app.activateWithOptions($.NSApplicationActivateAllWindows | $.NSApplicationActivateIgnoringOtherApps) ? 'ok' : 'refused')",
+    ].join(' ');
+    const r = await deps.exec(OSASCRIPT, ['-l', 'JavaScript', '-e', script]);
+    return r.code === 0 && r.stdout.trim() === 'ok';
+}
+/** The environment `open` runs with: the caller's, without anything that would pick another Account (spec §3.5). */
+function openEnv(base, family, def) {
+    const env = { ...base };
+    for (const v of family.hijackVars)
+        delete env[v];
+    delete env[family.selectVar];
+    for (const v of def.clearVars)
+        delete env[v];
+    for (const k of Object.keys(env))
+        if (k.startsWith('SIDEBY_') || isSessionVar(k))
+            delete env[k];
+    return env;
+}
+/**
+ * Variables an agent session sets for its own children; a Desktop App started from that session must not inherit
+ * them. Named one by one, so a user setting such as `CLAUDE_CODE_USE_BEDROCK` still reaches the app.
+ */
+const SESSION_PREFIXES = ['CODEX_COMPANION_', 'CODEX_SANDBOX'];
+const SESSION_VARS = new Set([
+    'CLAUDE_CODE_SESSION_ID',
+    'CLAUDE_CODE_MESSAGING_TOKEN',
+    'CLAUDE_CODE_ENTRYPOINT',
+    'CLAUDE_CODE_CHILD_SESSION',
+    'CLAUDE_PID',
+    'CLAUDE_PLUGIN_DATA',
+    'CLAUDECODE',
+    'CODEX_THREAD_ID',
+]);
+function isSessionVar(k) {
+    return SESSION_VARS.has(k) || SESSION_PREFIXES.some((p) => k.startsWith(p));
+}
+function notMac(platform) {
+    return new UserError(`opening a desktop app per account works on macOS only for now (this is ${platform}); use \`sideby run <account>\` for the terminal`, { code: 'not-macos' });
+}
+function notInstalled(def, deps) {
+    return new UserError(`${def.title} is not installed (looked in ${deps.appDirs.join(' and ')}); install it from ${def.installUrl}, then try again`, { code: 'app-not-installed' });
+}
+/**
+ * Opens the Account's Desktop App, or brings its running instance to the front. Never starts a second instance of the
+ * same Account, never ends a process, never touches the app bundle or the Host account directory.
+ */
+export async function openDesktopApp(rt, ref) {
+    const deps = depsFor(rt);
+    const account = await rt.resolve(ref);
+    const family = rt.families.get(account.family);
+    const def = family ? desktopAppOf(rt.plugins, account.family) : undefined;
+    if (!family || !def) {
+        const have = [...rt.families.keys()].filter((id) => desktopAppOf(rt.plugins, id));
+        throw new UserError(`${account.ref}: ${family?.title ?? account.family} has no desktop app sideby can open${have.length ? ` (only ${have.join(' and ')} accounts do)` : ''}; use \`sideby run ${account.ref}\``, { code: 'no-desktop-app' });
+    }
+    if (account.kind === 'api')
+        throw new UserError(`${account.ref} is an API account; ${def.title} signs in with a subscription only, so open it for a subscription account, or use \`sideby run ${account.ref}\``, { code: 'api-account' });
+    if (deps.platform !== 'darwin')
+        throw notMac(deps.platform);
+    const app = await findApp(def, deps, { spotlight: true });
+    if (!app)
+        throw notInstalled(def, deps);
+    const home = rt.paths.home;
+    const appData = account.isMain ? null : appDataDir(home, account);
+    const listed = await processes(deps);
+    const procs = listed ?? [];
+    const base = {
+        ref: account.ref,
+        family: account.family,
+        app: def.title,
+        appPath: app.path,
+        ...(appData ? { appData } : {}),
+        createdAppData: false,
+        linked: [],
+        notices: [],
+    };
+    const running = instanceOf(app, appData, procs);
+    if (running) {
+        const focused = await activate(deps, running.pid);
+        return {
+            ...base,
+            action: focused ? 'focused' : 'already-running',
+            notices: focused
+                ? []
+                : [
+                    `${def.title} is already open for ${account.ref}; switch to it from the Dock (sideby does not start a second one)`,
+                ],
+        };
+    }
+    let created = false;
+    let fresh = false;
+    const linked = [];
+    if (appData) {
+        const st = await lstatOrNull(appData);
+        if (st && !st.isDirectory())
+            throw new UserError(`${appData} is not a folder; move it away, then try again (sideby keeps ${def.title}'s data for ${account.ref} there)`, { code: 'app-data-invalid' });
+        if (!st) {
+            await mkdir(appData, { recursive: true, mode: 0o700 });
+            await chmod(appData, 0o700);
+            created = true;
+        }
+        const shared = new Set(def.sharedFiles.map((f) => f.path));
+        fresh = created || (await readdir(appData)).every((e) => shared.has(e));
+        if (fresh)
+            for (const f of def.sharedFiles) {
+                const target = join(appData, f.path);
+                const main = join(home, f.mainPath);
+                // Never replace anything: link only where nothing is, and only to a file the Main Account has.
+                if ((await lstatOrNull(target)) || !(await statOrNull(main))?.isFile())
+                    continue;
+                await symlink(main, target);
+                linked.push(f.path);
+            }
+    }
+    const notices = [];
+    if (!account.isMain && def.signInInApp && fresh) {
+        const others = procs.some((p) => mainArgs(app, p) !== null);
+        notices.push(others
+            ? `First time for ${account.ref}: sign in inside ${def.title} with the account you use for ${account.ref}, not one it suggests from another window. Close the other ${def.title} windows while you sign in, because the browser may send the sign-in back to one of them`
+            : `First time for ${account.ref}: sign in inside ${def.title} with the account you use for ${account.ref}, not one it suggests from another window`);
+    }
+    if (!def.signInInApp) {
+        const login = await Promise.resolve()
+            .then(() => family.loginState?.(account))
+            .catch(() => undefined);
+        if (login === 'logged-out')
+            notices.push(`${account.ref} is not signed in yet; run \`sideby login ${account.ref}\` first. If ${def.title} offers "Welcome back" with your main account's email, do not pick it: that signs this account in as the main one. Choose to use another account`);
+    }
+    // The Main Account needs `-n` too: without it, `open` brings forward whichever instance runs, often another
+    // Account's window. A second Main instance cannot start here, since a running one was found above.
+    // Without a process list a running Main instance cannot be ruled out, so plain `open -a` (no second instance).
+    const mainArgsList = listed ? ['-n', '-a', app.path] : ['-a', app.path];
+    const args = appData ? def.openArgs(app.path, account.dir, appData) : mainArgsList;
+    const r = await deps.exec(OPEN, args, openEnv(rt.env, family, def));
+    if (r.code !== 0)
+        throw new UserError(`could not open ${def.title} for ${account.ref}: ${r.stderr.trim() || `open exited with ${r.code}`}; try opening ${app.path} once by hand, then try again`, { code: 'open-failed' });
+    return { ...base, action: 'started', createdAppData: created, linked, command: [OPEN, ...args], notices };
+}
+/**
+ * Desktop App state per Account ref for `sideby list` and the Panel: only on macOS, only Subscription Accounts of a
+ * Family that has one. One process listing for all of them; never throws.
+ */
+export async function desktopStatuses(rt, accounts) {
+    const out = new Map();
+    const deps = depsFor(rt);
+    if (deps.platform !== 'darwin')
+        return out;
+    try {
+        const eligible = accounts.filter((a) => a.kind !== 'api' && desktopAppOf(rt.plugins, a.family));
+        if (!eligible.length)
+            return out;
+        const apps = new Map();
+        for (const id of new Set(eligible.map((a) => a.family)))
+            apps.set(id, await findApp(desktopDef(id), deps));
+        const procs = [...apps.values()].some(Boolean) ? ((await processes(deps)) ?? []) : [];
+        for (const a of eligible) {
+            const app = apps.get(a.family) ?? null;
+            out.set(a.ref, {
+                app: desktopDef(a.family).title,
+                installed: app !== null,
+                running: app
+                    ? Boolean(instanceOf(app, a.isMain ? null : appDataDir(rt.paths.home, a), procs))
+                    : false,
+            });
+        }
+    }
+    catch {
+        // A display nicety: a failure leaves the field out.
+    }
+    return out;
+}
+/**
+ * Adds `desktopApp` to each status whose Account has one, for `sideby list` and the Panel. The process listing runs
+ * while `statuses` is still being built; the order of the statuses is kept.
+ */
+export async function withDesktopApps(rt, accounts, statuses) {
+    const [list, desktop] = await Promise.all([statuses, desktopStatuses(rt, accounts)]);
+    return list.map((s) => {
+        const d = desktop.get(s.ref);
+        return d ? { ...s, desktopApp: d } : s;
+    });
+}
+/**
+ * Doctor's extra checks for an Account's App Data (spec §3.20): the Desktop App's shared files under `link` rules,
+ * only when that Account's App Data folder exists, never for the Main Account (it uses the app's default) or an API
+ * Account. Results are named `app-data/<path>` and are not counted in `shared`. The App Data is the repair boundary:
+ * a fix may only add a missing link inside it, never replace a real file.
+ */
+export async function checkAppData(plugins, home, account) {
+    if (account.isMain || account.kind === 'api')
+        return [];
+    const def = desktopAppOf(plugins, account.family);
+    if (!def?.sharedFiles.length)
+        return [];
+    const dir = appDataDir(home, account);
+    if (!(await lstatOrNull(dir))?.isDirectory())
+        return [];
+    const out = [];
+    for (const f of def.sharedFiles) {
+        const item = { path: f.path, mode: 'link' };
+        const mainPath = join(home, f.mainPath);
+        const p = join(dir, item.path);
+        const res = await checkItem({ account, item, mainPath, accountPath: p, accountDir: dir, force: false });
+        for (const r of res.results) {
+            if (r.level === 'ok')
+                continue;
+            // The Desktop App writes its own file when the Main Account had none at first open, and may replace the link
+            // later: not the user's doing, so a warning with the way to share, never a failure and never replaced.
+            const own = r.code === 'link.real-file'
+                ? {
+                    level: 'warn',
+                    message: `${item.path} is ${def.title}'s own copy for this account, not a link to the main account's`,
+                    hint: `${def.title} made it itself; that is fine. To share the main account's instead, quit that window, then: mv "${p}" "${p}.local" && ln -s "${mainPath}" "${p}"`,
+                }
+                : {};
+            out.push({
+                ...r,
+                ...own,
+                item: `app-data/${item.path}`,
+                message: `${def.title} data: ${own.message ?? r.message}`,
+            });
+        }
+    }
+    return out;
+}

package/dist/src/core/doctor.d.ts

@@ -1,5 +1,5 @@
 import type { HookBus } from '../plugins/bus.ts';
-import type { Account, FamilyDef, Finding } from '../types.ts';
+import type { Account, CheckResult, FamilyDef, Finding } from '../types.ts';
 export interface AccountReport {
     ref: string;
     family: string;
@@ -35,6 +35,11 @@ export interface DoctorInput {
     force?: boolean;
     /** This sideby's version: when set, installed sideby skills of the checked Families are compared with it. */
     skillVersion?: string;
+    /**
+     * More core checks for an Account that is not the Main Account, merged after its Shared Items. They are not
+     * counted in `shared`; a result's `fix` runs with the others under `--fix` and must stay within what it checked.
+     */
+    extraChecks?: (account: Account) => Promise<CheckResult[]>;
 }
 export declare function runDoctor(input: DoctorInput): Promise<DoctorReport>;
 /** Applies every fixable Finding once, in order; one failing fix never stops the others. */

package/dist/src/core/doctor.js

@@ -43,6 +43,25 @@ async function checkAccount(input, family, account) {
                 if (r.level !== 'ok')
                     findings.push(toFinding(r, account.ref, 'core'));
         }
+        // Extra checks (for example a Desktop App's data folder) add Findings but never count toward `shared`.
+        // A failing extra check costs only its own Findings, never the whole run.
+        try {
+            for (const r of (await input.extraChecks?.(account)) ?? [])
+                if (r.level !== 'ok')
+                    findings.push(toFinding(r, account.ref, 'core'));
+        }
+        catch (e) {
+            findings.push({
+                level: 'warn',
+                account: account.ref,
+                item: 'extra',
+                code: 'extra-check.error',
+                message: `could not finish an extra check of ${account.ref}: ${e instanceof Error ? e.message : String(e)}`,
+                hint: 'run sideby doctor again; if it keeps failing, check that the folder it names is readable',
+                fixable: false,
+                source: 'core',
+            });
+        }
         if (looksLikeBackup(account.name))
             findings.push({
                 level: 'warn',

package/dist/src/core/model-choice.d.ts

@@ -0,0 +1,41 @@
+import type { Runtime } from '../runtime.ts';
+import type { Account, ModelChoice } from '../types.ts';
+/** Where a shown value comes from: sideby's own argument, the Host's config, or the last session. */
+export type ChoiceSource = 'sideby' | 'host' | 'last';
+export interface AccountModel {
+    ref: string;
+    family: string;
+    /** Whether sideby can set it for this Account; when not, `reason` says why. */
+    settable: boolean;
+    reason?: string;
+    efforts: string[];
+    models: string[];
+    sideby: ModelChoice;
+    host: ModelChoice;
+    last: ModelChoice;
+    model?: {
+        value: string;
+        from: ChoiceSource;
+    };
+    effort?: {
+        value: string;
+        from: ChoiceSource;
+    };
+}
+/** `last` is the model and effort of the newest session, from the usage reader when the caller already has it. */
+export declare function accountModel(rt: Runtime, account: Account, last?: ModelChoice): Promise<AccountModel>;
+/** A change: `undefined` keeps what sideby sets now, `null` goes back to the Host's default. */
+export interface ModelChange {
+    model?: string | null;
+    effort?: string | null;
+}
+/** Shows, or with `apply` writes, the change to the Account's model and effort arguments. */
+export declare function setAccountModel(rt: Runtime, account: Account, change: ModelChange, opts: {
+    apply: boolean;
+}): Promise<{
+    changed: boolean;
+    applied: boolean;
+    file: string;
+    diff: string;
+    args: string[];
+}>;

package/dist/src/core/model-choice.js

@@ -0,0 +1,128 @@
+// Model and effort per Account (spec §3.19, ADR-0014): what an Account starts with, and the one change sideby makes,
+// to the model and effort arguments in the config's `accounts.<ref>.args`. No Host file is written.
+import { join } from 'node:path';
+import { MODEL_NAME } from '../families/shared/model-args.js';
+import { editConfigAccounts } from './config.js';
+import { UserError } from './errors.js';
+import { lineDiff } from './handoff-status.js';
+function pick(key, sideby, host, last) {
+    if (sideby[key])
+        return { value: sideby[key], from: 'sideby' };
+    if (host[key])
+        return { value: host[key], from: 'host' };
+    if (last[key])
+        return { value: last[key], from: 'last' };
+    return undefined;
+}
+/** `last` is the model and effort of the newest session, from the usage reader when the caller already has it. */
+export async function accountModel(rt, account, last) {
+    const f = rt.families.get(account.family);
+    const mc = f?.modelChoice;
+    const base = {
+        ref: account.ref,
+        family: account.family,
+        efforts: [],
+        models: [],
+        sideby: {},
+        host: {},
+        last: {},
+    };
+    if (!mc)
+        return { ...base, settable: false, reason: `${f?.title ?? account.family} has no model choice in sideby` };
+    let seen = last;
+    if (!seen) {
+        const u = await rt.usage(account).catch(() => null);
+        seen =
+            u?.status === 'ok'
+                ? {
+                    ...(u.lastModel ? { model: u.lastModel } : {}),
+                    ...(u.lastEffort ? { effort: u.lastEffort } : {}),
+                }
+                : {};
+    }
+    const sideby = mc.fromArgs(rt.config.accounts?.[account.ref]?.args ?? []).choice;
+    // An API account's model is the one its proxy.env names (the Family's `model` reader); the effort still comes from settings.
+    const apiModel = account.kind === 'api' ? await f.model?.(account).catch(() => undefined) : undefined;
+    const configured = await mc.configured(account, sideby.model ?? apiModel, seen.model);
+    const host = apiModel ? { ...configured, model: apiModel } : configured;
+    const models = [...new Set([...mc.models, ...(seen.model ? [seen.model] : [])])];
+    const out = {
+        ...base,
+        settable: account.kind !== 'api',
+        efforts: [...mc.efforts],
+        models,
+        sideby,
+        host,
+        last: seen,
+    };
+    if (account.kind === 'api')
+        out.reason = 'an API account takes its model from proxy.env';
+    const m = pick('model', sideby, host, seen);
+    const e = pick('effort', sideby, host, seen);
+    if (m)
+        out.model = m;
+    if (e)
+        out.effort = e;
+    return out;
+}
+const pretty = (v) => JSON.stringify(v ?? {}, null, 2);
+/** Shows, or with `apply` writes, the change to the Account's model and effort arguments. */
+export async function setAccountModel(rt, account, change, opts) {
+    const f = rt.families.get(account.family);
+    const mc = f?.modelChoice;
+    if (!mc)
+        throw new UserError(`${f?.title ?? account.family} has no model choice in sideby`, {
+            code: 'unsupported',
+        });
+    if (account.kind === 'api')
+        throw new UserError(`${account.ref} is an API account: its model comes from proxy.env, so set it there`, {
+            code: 'api-account',
+        });
+    if (typeof change.model === 'string' && !MODEL_NAME.test(change.model))
+        throw new UserError(`"${change.model}" is not a model name sideby passes on: use letters, digits and . _ : / [ ] - only, for example ${mc.models[0] ?? 'gpt-5'}`, { code: 'bad-value' });
+    if (typeof change.effort === 'string' && !mc.efforts.includes(change.effort))
+        throw new UserError(`"${change.effort}" is not an effort level for ${f.title}; use one of: ${mc.efforts.join(', ')}, default`, {
+            code: 'bad-value',
+        });
+    let args = [];
+    const r = await editConfigAccounts(rt.paths.configFile, (current) => {
+        const now = current[account.ref]?.args ?? [];
+        const unchanged = (list) => list.length === now.length && list.every((x, i) => x === now[i]);
+        const { choice, rest } = mc.fromArgs(now);
+        const next = { ...choice };
+        for (const k of ['model', 'effort']) {
+            if (change[k] === null)
+                delete next[k];
+            else if (change[k] !== undefined)
+                next[k] = change[k];
+        }
+        // After a `--` everything is prompt text, so the choice goes in front of it.
+        const dd = rest.indexOf('--');
+        const add = mc.toArgs(next);
+        args = dd < 0 ? [...rest, ...add] : [...rest.slice(0, dd), ...add, ...rest.slice(dd)];
+        // Nothing to write, not even an empty `accounts` key in a config that has none.
+        if (unchanged(args))
+            return null;
+        const out = { ...current };
+        if (args.length)
+            out[account.ref] = { ...current[account.ref], args };
+        else {
+            const { args: _gone, ...others } = current[account.ref] ?? {};
+            if (Object.keys(others).length)
+                out[account.ref] = others;
+            else
+                delete out[account.ref];
+        }
+        return out;
+    }, { dryRun: !opts.apply });
+    const file = rt.paths.configFile;
+    return {
+        changed: r.changed,
+        applied: r.changed && opts.apply,
+        file,
+        diff: r.changed
+            ? `--- ${join('sideby', 'config.json')} (accounts)\n${lineDiff(pretty(r.before), pretty(r.after))}\n`
+            : '',
+        args,
+    };
+}

package/dist/src/core/tuning-apply.js

@@ -32,7 +32,7 @@ function render(obj, original) {
 }
 async function readObject(file) {
     const st = await stat(file).catch(() => null);
-    if (!st || !st.isFile())
+    if (!st?.isFile())
         return { error: 'it is not a regular file' };
     if (st.size > MAX_BYTES)
         return { error: 'it is too large to be a settings file' };

package/dist/src/families/claude/desktop.d.ts

@@ -0,0 +1,6 @@
+import type { DesktopAppDef } from '../desktop.ts';
+/**
+ * Claude Desktop (spec §3.20). Its Code tab honours CLAUDE_CONFIG_DIR; the data folder moves only with
+ * `--user-data-dir` (signed builds ignore CLAUDE_USER_DATA_DIR).
+ */
+export declare const claudeDesktop: DesktopAppDef;

package/dist/src/families/claude/desktop.js

@@ -0,0 +1,28 @@
+/**
+ * Claude Desktop (spec §3.20). Its Code tab honours CLAUDE_CONFIG_DIR; the data folder moves only with
+ * `--user-data-dir` (signed builds ignore CLAUDE_USER_DATA_DIR).
+ */
+export const claudeDesktop = {
+    family: 'claude',
+    title: 'Claude Desktop',
+    bundleId: 'com.anthropic.claudefordesktop',
+    bundleNames: ['Claude.app'],
+    installUrl: 'https://claude.ai/download',
+    openArgs: (app, dir, appData) => [
+        '-n',
+        '-a',
+        app,
+        '--env',
+        `CLAUDE_CONFIG_DIR=${dir}`,
+        '--args',
+        `--user-data-dir=${appData}`,
+    ],
+    clearVars: ['CLAUDE_USER_DATA_DIR'],
+    signInInApp: true,
+    sharedFiles: [
+        {
+            path: 'claude_desktop_config.json',
+            mainPath: 'Library/Application Support/Claude/claude_desktop_config.json',
+        },
+    ],
+};

package/dist/src/families/claude/index.js

@@ -8,6 +8,7 @@ import { BUILTIN_LOGOS } from '../logos.js';
 import { dirWrittenAt, groupedEntryWrittenAt, resumeFlagSession, withoutResumeFlag, } from '../shared/sessions.js';
 import { claudeHandoff } from './handoff.js';
 import { CLAUDE_LAYOUT } from './layout.js';
+import { claudeModelChoice } from './model.js';
 import { readClaudeQuota } from './quota.js';
 import { readClaudeTuning } from './tuning.js';
 import { readClaudeUsage } from './usage.js';
@@ -114,6 +115,7 @@ export const claudeFamily = {
     },
     loginState,
     model,
+    modelChoice: claudeModelChoice,
     identity: claudeIdentity,
     readQuota: readClaudeQuota,
     readUsage: readClaudeUsage,

package/dist/src/families/claude/model.d.ts

@@ -0,0 +1,2 @@
+import type { FamilyModelChoice } from '../../types.ts';
+export declare const claudeModelChoice: FamilyModelChoice;