sideby 0.0.0-stage → 0.2.1

package/dist/src/cli/json-schemas.js

@@ -0,0 +1,259 @@
+// JSON Schemas for every `--json` output. Additive changes keep schemaVersion 1; removals, renames or
+// meaning changes bump it (spec §3.9). `pnpm schemas` writes these to schemas/*.json.
+import { Type } from 'typebox';
+import { ConfigSchema } from '../core/config.js';
+const Str = Type.String();
+const Level = Type.Union([Type.Literal('ok'), Type.Literal('warn'), Type.Literal('fail')]);
+const Kind = Type.Union([Type.Literal('subscription'), Type.Literal('api')]);
+const Version = Type.Literal(1);
+const AppPlatform = Type.Union([Type.Literal('darwin'), Type.Literal('linux')]);
+const Account = Type.Object({
+    family: Str,
+    name: Str,
+    ref: Str,
+    dir: Str,
+    isMain: Type.Boolean(),
+    kind: Kind,
+    secretFile: Type.Optional(Str),
+});
+const AccountStatus = Type.Intersect([
+    Account,
+    Type.Object({
+        familyTitle: Str,
+        hostInstalled: Type.Boolean(),
+        login: Type.Union([
+            Type.Literal('logged-in'),
+            Type.Literal('logged-out'),
+            Type.Literal('unknown'),
+            Type.Literal('not-needed'),
+        ]),
+        model: Type.Optional(Str),
+        identity: Type.Optional(Type.Object({ email: Type.Optional(Str), org: Type.Optional(Str) }, {
+            description: "Who the account is signed in as, from the host's login file: identity fields only, never a token (ADR-0003).",
+        })),
+        problems: Type.Optional(Type.Array(Str)),
+    }),
+]);
+const FamilyInfo = Type.Object({
+    id: Str,
+    title: Str,
+    bin: Str,
+    installUrl: Str,
+    installed: Type.Boolean(),
+    plugin: Str,
+});
+const ShareModeSchema = Type.Union(['link', 'copy', 'link-or-copy', 'link-or-local', 'local', 'local-if-api', 'info', 'json-key'].map((m) => Type.Literal(m)));
+const FamilyDetail = Type.Intersect([
+    FamilyInfo,
+    Type.Object({
+        layout: Type.Object({ main: Str, account: Str }, { description: 'Relative to HOME, for example `.claude` and `.claude-<name>`.' }),
+        selectVar: Type.String({
+            description: 'Environment variable that selects a non-main Account directory.',
+        }),
+        login: Type.Object({
+            args: Type.Union([Type.Array(Str), Type.Null()], {
+                description: "Arguments of the Host's sign-in command; null when sign-in happens inside the Host.",
+            }),
+            hint: Str,
+        }),
+        quota: Type.Boolean(),
+        usage: Type.Boolean(),
+        quotaSetup: Type.Boolean({ description: 'Quota needs `sideby quota setup <family>` once.' }),
+        shared: Type.Array(Type.Object({
+            path: Str,
+            mode: ShareModeSchema,
+            key: Type.Optional(Str),
+            mainPath: Type.Optional(Str),
+            credential: Type.Optional(Type.Boolean()),
+            noSymlink: Type.Optional(Type.Boolean()),
+            source: Type.Union([Type.Literal('family'), Type.Literal('config')]),
+            meaning: Type.String({
+                description: 'What the item looks like in each Account, in one fixed sentence.',
+            }),
+        })),
+    }),
+]);
+const PluginError = Type.Object({ where: Str, message: Str });
+const Finding = Type.Object({
+    level: Level,
+    account: Str,
+    item: Str,
+    code: Str,
+    message: Str,
+    hint: Type.Optional(Str),
+    source: Str,
+    fixable: Type.Boolean(),
+});
+const QuotaWindow = Type.Object({
+    label: Str,
+    windowMinutes: Type.Number(),
+    usedPercent: Type.Number(),
+    resetsAt: Str,
+});
+const Quota = Type.Union([
+    Type.Object({
+        status: Type.Literal('ok'),
+        windows: Type.Array(QuotaWindow),
+        observedAt: Str,
+        source: Str,
+        plan: Type.Optional(Str),
+    }),
+    Type.Object({ status: Type.Literal('unavailable'), reason: Str, detail: Type.Optional(Str) }),
+]);
+const Usage = Type.Union([
+    Type.Object({
+        status: Type.Literal('ok'),
+        days: Type.Number(),
+        sessions: Type.Number(),
+        inputTokens: Type.Number(),
+        outputTokens: Type.Number(),
+        cacheReadTokens: Type.Number(),
+        cacheWriteTokens: Type.Number(),
+        totalTokens: Type.Number(),
+        daily: Type.Optional(Type.Array(Type.Object({ date: Str, totalTokens: Type.Number() }), {
+            description: 'Tokens per local day (YYYY-MM-DD), oldest first, days without records as 0.',
+        })),
+        lastActivityAt: Type.Optional(Str),
+    }),
+    Type.Object({ status: Type.Literal('unavailable'), reason: Str, detail: Type.Optional(Str) }),
+]);
+const QuotaSetupPlan = Type.Object({
+    status: Type.Union([Type.Literal('enabled'), Type.Literal('ready'), Type.Literal('blocked')]),
+    file: Str,
+    diff: Str,
+    message: Str,
+});
+const ShellInitFiles = Type.Array(Type.Object({
+    shell: Type.Union([Type.Literal('zsh'), Type.Literal('bash')]),
+    path: Str,
+    ok: Type.Boolean(),
+    action: Type.Optional(Type.Union([Type.Literal('written'), Type.Literal('unchanged')])),
+    message: Type.Optional(Str),
+}), { description: 'One entry per config `shellInitFile`, rewritten after the change.' });
+export const OUTPUT_SCHEMAS = {
+    list: Type.Object({
+        schemaVersion: Version,
+        families: Type.Array(FamilyInfo),
+        accounts: Type.Array(AccountStatus),
+        pluginErrors: Type.Array(PluginError),
+    }, { title: 'sideby list --json' }),
+    doctor: Type.Object({
+        schemaVersion: Version,
+        status: Type.Union([Type.Literal('ok'), Type.Literal('issues')]),
+        accounts: Type.Array(Type.Object({
+            ref: Str,
+            family: Str,
+            name: Str,
+            kind: Kind,
+            dir: Str,
+            shared: Type.Object({ ok: Type.Number(), total: Type.Number() }),
+            backups: Type.Number(),
+            findings: Type.Array(Finding),
+        })),
+        general: Type.Array(Finding),
+        fixes: Type.Array(Type.Object({ account: Str, item: Str, code: Str, ok: Type.Boolean(), message: Str })),
+    }, { title: 'sideby doctor --json' }),
+    quota: Type.Object({
+        schemaVersion: Version,
+        accounts: Type.Array(Type.Object({ ref: Str, kind: Kind, quota: Quota, usage: Usage })),
+    }, { title: 'sideby quota --json' }),
+    next: Type.Object({
+        schemaVersion: Version,
+        family: Str,
+        pick: Type.Union([Str, Type.Null()], {
+            description: 'The recommended account; null when none can be used now (exit code 1).',
+        }),
+        accounts: Type.Array(Type.Object({
+            ref: Str,
+            kind: Kind,
+            state: Type.Union([
+                Type.Literal('ready'),
+                Type.Literal('unknown'),
+                Type.Literal('api'),
+                Type.Literal('full'),
+                Type.Literal('logged-out'),
+            ], {
+                description: 'ready and unknown can be picked; api only with --include-api; full and logged-out never.',
+            }),
+            pressure: Type.Union([Type.Number(), Type.Null()], {
+                description: 'Used percent of the fullest window not reset yet; null without quota.',
+            }),
+            resetsAt: Type.Optional(Type.String({ description: 'For full: when its last full window resets.' })),
+            observedAt: Type.Optional(Type.String({ description: "When the account's quota was recorded (its last session)." })),
+        }), { description: 'Every account of the family, best first.' }),
+        hasQuota: Type.Boolean({
+            description: 'False when no account has quota data: the pick is then a guess, and `sideby next` does not start it (exit 1).',
+        }),
+        earliestReset: Type.Optional(Type.Object({ ref: Str, at: Str }, {
+            description: 'Set when nothing can be picked and some accounts are full: the first to come back.',
+        })),
+    }, { title: 'sideby next --json' }),
+    'quota-setup': Type.Object({ schemaVersion: Version, family: Str, applied: Type.Boolean(), plan: QuotaSetupPlan }, { title: 'sideby quota setup --json' }),
+    'quota-teardown': Type.Object({ schemaVersion: Version, family: Str, ok: Type.Boolean(), message: Str, diff: Type.Optional(Str) }, { title: 'sideby quota teardown --json' }),
+    new: Type.Object({
+        schemaVersion: Version,
+        ok: Type.Boolean(),
+        account: Account,
+        steps: Type.Array(Type.Object({ item: Str, action: Str, ok: Type.Boolean(), message: Type.Optional(Str) })),
+        hookErrors: Type.Array(Type.Object({ plugin: Str, message: Str })),
+        nextSteps: Type.Array(Str),
+        alias: Type.Optional(Type.Object({ name: Str, added: Type.Boolean(), message: Type.Optional(Str) }, { description: 'The `--alias` short command; `added: false` means the Account exists without it.' })),
+        shellInitFiles: Type.Optional(ShellInitFiles),
+        suggestion: Type.Optional(Type.Object({ name: Str, alias: Type.Optional(Str), aliasProblem: Type.Optional(Str) }, {
+            description: 'Only with `--next`: the picked name, the short command that follows the existing pattern, or why that short command was left out.',
+        })),
+    }, { title: 'sideby new --json' }),
+    alias: Type.Object({
+        schemaVersion: Version,
+        ok: Type.Boolean({ description: 'False when a config `shellInitFile` was not rewritten.' }),
+        alias: Str,
+        status: Type.Union([
+            Type.Literal('added'),
+            Type.Literal('exists'),
+            Type.Literal('removed'),
+            Type.Literal('absent'),
+        ]),
+        account: Type.Optional(Str),
+        args: Type.Optional(Type.Array(Str, { description: 'Host arguments `sideby run <alias>` adds.' })),
+        shellInitFiles: Type.Optional(ShellInitFiles),
+    }, { title: 'sideby alias add|rm --json' }),
+    plugins: Type.Object({
+        schemaVersion: Version,
+        plugins: Type.Array(Type.Object({
+            name: Str,
+            version: Str,
+            source: Str,
+            description: Type.Optional(Str),
+            families: Type.Array(Str),
+            configKeys: Type.Array(Str),
+        })),
+        errors: Type.Array(PluginError),
+    }, { title: 'sideby plugins --json' }),
+    families: Type.Object({ schemaVersion: Version, families: Type.Array(FamilyDetail) }, { title: 'sideby families --json' }),
+    'app-install': Type.Object({
+        schemaVersion: Version,
+        platform: AppPlatform,
+        path: Str,
+        files: Type.Array(Str),
+        mode: Type.Union([Type.Literal('panel'), Type.Literal('url')]),
+        url: Type.Optional(Str),
+        node: Str,
+        entry: Str,
+        updated: Type.Boolean(),
+        hints: Type.Array(Str),
+    }, { title: 'sideby app install --json' }),
+    'app-uninstall': Type.Object({
+        schemaVersion: Version,
+        platform: AppPlatform,
+        removed: Type.Array(Str),
+        skipped: Type.Array(Type.Object({ path: Str, reason: Str })),
+    }, { title: 'sideby app uninstall --json' }),
+    error: Type.Object({
+        schemaVersion: Version,
+        error: Type.String({ description: 'What went wrong and what to do next.' }),
+        code: Type.String({
+            description: '`usage` for a malformed command line (exit 2), a reason such as `no-quota-source` or `alias-invalid`, or `error`.',
+        }),
+    }, { title: 'sideby error --json' }),
+    config: ConfigSchema,
+};

package/dist/src/cli/main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function main(argv: string[]): Promise<number>;

package/dist/src/cli/main.js

@@ -0,0 +1,276 @@
+#!/usr/bin/env node
+// Entry point. Keeps imports lazy so `statusline-tap`, which Claude Code runs on every refresh, starts fast.
+import { realpathSync } from 'node:fs';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+const MIN_NODE = [22, 18];
+const HELP = `sideby — run every AI coding account side by side
+
+Usage:
+  sideby                              list accounts (same as \`sideby list\`)
+  sideby run <account> [-- args]      start the host CLI for one account
+  sideby new <family> <name>|--next [--api] [--alias <short>]
+                                      create an account (families: claude, codex, grok, pi);
+                                      --next picks the next name and short command (cc008);
+                                      --alias also adds a short command such as cc008
+  sideby families [family]            what each host's accounts share with the main account,
+                                      where they live and how they sign in
+  sideby alias add <short> <account> [-- args]
+                                      add a short command, optionally with host arguments
+                                      (sideby alias add pi-kimi pi:main -- --model kimi-coding/k3)
+  sideby alias rm <short>             remove a short command
+  sideby login <account>              sign in to an account
+  sideby resume <family> [-- args]    run the host; a session resumed by id (claude --resume <id>,
+                                      codex resume <id>) starts in the account that holds it
+  sideby next <family> [--dry-run] [--include-api] [-- args]
+                                      recommend the account with the most quota left (claude, codex)
+                                      and start it; --dry-run only recommends
+  sideby doctor [target] [--fix] [--force]
+                                      check shared items and permissions; --fix repairs safe issues
+  sideby quota [account]              quota and 7-day token usage
+  sideby quota setup claude [--yes]   turn on Claude quota (shows the change first)
+  sideby quota teardown claude        undo it, restoring the original file
+  sideby ui [--port n] [--no-open]    open the local panel
+  sideby ui --background              same, without a terminal: keeps running after this command exits
+  sideby ui --stop                    stop the background panel
+  sideby app install [--url <url>]    add a sideby app that opens the panel (macOS, Linux)
+  sideby app uninstall                remove that app
+  sideby shell-init zsh|bash          print shell functions, e.g. eval "$(sideby shell-init zsh)"
+  sideby shell-init [zsh|bash] --write
+                                      rewrite the config's shellInitFile with them
+  sideby plugins                      list loaded plugins and load errors
+
+Options:
+  --json        machine-readable output (list, new, next, alias, doctor, quota, families, plugins, app)
+  -h, --help    show this help; \`sideby <command> --help\` for new, alias, login, doctor, families
+  -v, --version show the version
+
+An <account> is <family>:<name> (claude:work) or just <name> when it is unique.
+
+For AI agents:
+  Add --json and read the result; JSON Schemas ship in the package under schemas/.
+  Install the skill: npx skills add Adonis0123/sideby -g
+  Setup steps and the full contract: https://github.com/Adonis0123/sideby/blob/main/llms.txt
+  Run everything else yourself, but hand the user these as one line each: \`sideby login <account>\`
+  (browser sign-in), filling in proxy.env, and \`sideby run\` or \`sideby next\` (interactive sessions).
+  Exit 10 means a change was shown: ask the user, then run it again with --yes.`;
+/** `sideby <command> --help` for the commands agents use to set up and repair accounts (spec §3.16). */
+const COMMAND_HELP = {
+    new: `sideby new <family> <name> [--api] [--alias <short>] [--json]
+sideby new <family> --next [--api] [--alias <short>] [--json]
+
+Create an account directory (~/.claude-<name>, ~/.codex-<name>, ~/.grok-<name>, ~/.pi-<name>/agent) and link or
+copy the main account's shared items into it. \`sideby families <family>\` lists them.
+
+  --next          pick the name: the next number after the highest numbered account (001…007 → 008), else work;
+                  without --alias, also add a short command that follows your existing ones (cc007 → cc008)
+  --api           API account: also writes an empty proxy.env template (mode 600) for the user to fill in
+  --alias <short> add a short command for it to the config (it becomes a shell function)
+
+Examples:
+  sideby new claude --next --json        # ~/.claude-008 plus cc008 when cc001…cc007 exist
+  sideby new claude work                 # ~/.claude-work
+  sideby new claude deepseek --api       # then the user fills in ~/.claude-deepseek/proxy.env
+
+Writes: the account directory; the config \`aliases\` and every \`shellInitFile\` when a short command is added.
+Next: the user signs in with \`sideby login <account>\` (subscription) or fills in proxy.env (API).
+Exit: 0 done; 1 invalid name or alias, directory exists, or partly failed; 2 malformed command line.`,
+    alias: `sideby alias add <short> <account> [-- host args] [--json]
+sideby alias rm <short> [--json]
+
+A short command starts one account: \`sideby run <short>\`, or just \`<short>\` once your shell loads
+\`sideby shell-init\`. Host arguments after -- are added only when it starts through the short command; it is
+the same account (same sign-in, same sessions), so do not create an account per model.
+
+Examples:
+  sideby alias add cc008 claude:008
+  sideby alias add pi-kimi pi:main -- --model kimi-coding/k3
+  sideby alias rm cc008
+
+Writes: the config \`aliases\` and every \`shellInitFile\`. New shell functions work in a new shell, or after
+eval "$(sideby shell-init zsh)" (put that line in ~/.zshrc once).
+Exit: 0 done (also when it already exists or is absent); 1 invalid, reserved or taken; 2 malformed.`,
+    login: `sideby login <account>
+
+Run the host's own sign-in for one account: claude auth login, codex login, grok login. For pi it starts pi;
+then type /login. It opens a browser and needs the person who owns the account, so an agent hands this
+line to the user instead of running it (in Claude Code: ! sideby login claude:008).
+
+sideby never reads, copies or stores the credentials the host writes.
+Exit: the host's exit code.`,
+    doctor: `sideby doctor [account|family] [--fix] [--force] [--json]
+
+Check every account's shared items against the main account, credential file modes (600), backup leftovers,
+and whether the installed sideby skill matches this version.
+
+  --fix     repair what is safe: add missing links, refresh copies, chmod 600, sync MCP servers
+  --force   with --fix, also let a synced MCP list (json-key) drop entries the account has
+
+--fix never replaces a real file with a link and never changes where an existing link points; those are
+reported with the command to run.
+
+Examples:
+  sideby doctor --json
+  sideby doctor claude:008 --fix
+Exit: 0 when nothing fails (warnings allowed); 1 when a check fails.`,
+    families: `sideby families [family] [--json]
+
+For each host (built in or from a plugin): where its accounts live, the variable that selects one, how to sign
+in, whether quota and usage can be read, and every shared item with what it looks like in each account
+(a link to the main account's, a copy, or the account's own file). Everything else in an account directory
+(sign-in, sessions, history) belongs to that account.
+
+Examples:
+  sideby families
+  sideby families claude --json
+Exit: 0; 1 unknown family; 2 malformed command line.`,
+};
+function nodeTooOld() {
+    const [maj = 0, min = 0] = process.versions.node.split('.').map(Number);
+    return maj < MIN_NODE[0] || (maj === MIN_NODE[0] && min < MIN_NODE[1]);
+}
+const COMMANDS = {
+    list: { flags: ['json'] },
+    run: { flags: [] },
+    resume: { flags: [] },
+    login: { flags: [] },
+    next: { flags: ['dry-run', 'include-api', 'json'] },
+    new: { flags: ['api', 'json', 'next'], valued: ['alias'] },
+    alias: { flags: ['json'] },
+    doctor: { flags: ['fix', 'force', 'json'] },
+    quota: { flags: ['json', 'yes'] },
+    ui: { flags: ['no-open', 'background', 'stop', 'serve-detached'], valued: ['port'] },
+    app: { flags: ['json'], valued: ['url'] },
+    'shell-init': { flags: ['write'] },
+    plugins: { flags: ['json'] },
+    families: { flags: ['json'] },
+};
+export async function main(argv) {
+    const [first, ...rest] = argv;
+    if (first === 'statusline-tap') {
+        const { runStatuslineTap } = await import('../quota/statusline-tap.js');
+        return runStatuslineTap(rest, process.env, process.stdin, process.stdout);
+    }
+    if (first === '-v' || first === '--version' || first === 'version') {
+        const { packageVersion } = await import('../core/version.js');
+        console.log(packageVersion());
+        return 0;
+    }
+    if (first === '-h' || first === '--help' || first === 'help') {
+        console.log((rest[0] !== undefined && first === 'help' && COMMAND_HELP[rest[0]]) || HELP);
+        return 0;
+    }
+    if (nodeTooOld()) {
+        console.error(`sideby needs Node ${MIN_NODE.join('.')} or newer (you have ${process.versions.node}). Upgrade: https://nodejs.org`);
+        return 1;
+    }
+    const cmd = first === undefined || first.startsWith('--') ? 'list' : first;
+    const args = first === undefined || first.startsWith('--') ? argv : rest;
+    const spec = COMMANDS[cmd];
+    const io = { out: (s) => console.log(s), err: (s) => console.error(s) };
+    const { parseArgs, UsageError } = await import('./args.js');
+    // Only sideby's own options count: arguments after `--` belong to the host.
+    const own = args.includes('--') ? args.slice(0, args.indexOf('--')) : args;
+    const wantsJson = Boolean(spec?.flags.includes('json')) && own.includes('--json');
+    try {
+        if (!spec)
+            throw new UsageError(`unknown command "${cmd}"; run \`sideby --help\``);
+        // `run` and `resume` pass everything after the account or family through to the host, with or without `--`.
+        let parsed;
+        if (cmd === 'run' || cmd === 'resume') {
+            const sep = args.indexOf('--');
+            const head = sep === -1 ? args : args.slice(0, sep);
+            const [ref, ...more] = head;
+            parsed = {
+                positionals: ref ? [ref] : [],
+                flags: new Map(),
+                rest: [...more, ...(sep === -1 ? [] : args.slice(sep + 1))],
+            };
+            if (ref === '-h' || ref === '--help')
+                parsed.flags.set('help', true);
+        }
+        else {
+            try {
+                parsed = parseArgs(args, [...spec.flags, 'help'], spec.valued ?? []);
+            }
+            catch (err) {
+                // `alias add` takes Host arguments too; the usual mistake is leaving out the `--` before them.
+                if (cmd === 'alias' && err instanceof UsageError && err.message.startsWith('unknown option'))
+                    throw new UsageError(`${err.message}; put Host arguments after \`--\`, for example: sideby alias add pi-kimi pi:main -- --model kimi-coding/k3`);
+                if (cmd === 'next' && err instanceof UsageError && err.message.startsWith('unknown option'))
+                    throw new UsageError(`${err.message}; put Host arguments after \`--\`, for example: sideby next claude -- --model opus`);
+                throw err;
+            }
+        }
+        if (parsed.flags.has('help')) {
+            console.log(COMMAND_HELP[cmd] ?? HELP);
+            return 0;
+        }
+        const cmds = await import('./commands.js');
+        switch (cmd) {
+            case 'list':
+                return await cmds.cmdList(parsed, io);
+            case 'run':
+                return await cmds.cmdRun(parsed, io, 'run');
+            case 'login':
+                return await cmds.cmdRun(parsed, io, 'login');
+            case 'resume':
+                return await cmds.cmdResume(parsed, io);
+            case 'next':
+                return await cmds.cmdNext(parsed, io);
+            case 'new':
+                return await cmds.cmdNew(parsed, io);
+            case 'alias':
+                return await cmds.cmdAlias(parsed, io);
+            case 'doctor':
+                return await cmds.cmdDoctor(parsed, io);
+            case 'quota':
+                return await cmds.cmdQuota(parsed, io);
+            case 'ui':
+                return await cmds.cmdUi(parsed, io);
+            case 'app':
+                return await cmds.cmdApp(parsed, io);
+            case 'shell-init':
+                return await cmds.cmdShellInit(parsed, io);
+            case 'plugins':
+                return await cmds.cmdPlugins(parsed, io);
+            case 'families':
+                return await cmds.cmdFamilies(parsed, io);
+        }
+        return 2;
+    }
+    catch (err) {
+        const usage = err instanceof UsageError;
+        const message = err instanceof Error ? err.message : String(err);
+        if (wantsJson) {
+            const { UserError } = await import('../core/errors.js');
+            const code = usage ? 'usage' : err instanceof UserError && err.code ? err.code : 'error';
+            console.log(JSON.stringify({ schemaVersion: 1, error: message, code }, null, 2));
+        }
+        else
+            console.error(`sideby: ${message}`);
+        if (!usage && process.env.SIDEBY_DEBUG && err instanceof Error)
+            console.error(err.stack);
+        return usage ? 2 : 1;
+    }
+}
+// Run when executed directly, also through symlinks (npm's bin shim, a user alias like `sb`).
+function isEntry() {
+    const arg = process.argv[1];
+    if (!arg)
+        return false;
+    try {
+        return (pathToFileURL(realpathSync(arg)).href ===
+            pathToFileURL(realpathSync(fileURLToPath(import.meta.url))).href);
+    }
+    catch {
+        return false;
+    }
+}
+if (isEntry()) {
+    main(process.argv.slice(2)).then((code) => {
+        process.exitCode = code;
+    }, (err) => {
+        console.error(`sideby: ${err instanceof Error ? err.message : String(err)}`);
+        process.exitCode = 1;
+    });
+}

package/dist/src/cli/schemas.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/cli/schemas.js

@@ -0,0 +1,16 @@
+// Writes schemas/*.json from OUTPUT_SCHEMAS. CI regenerates and fails if the result differs from git.
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { OUTPUT_SCHEMAS } from './json-schemas.js';
+const root = join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'schemas');
+await mkdir(root, { recursive: true });
+for (const [name, schema] of Object.entries(OUTPUT_SCHEMAS)) {
+    const doc = {
+        $schema: 'https://json-schema.org/draft/2020-12/schema',
+        $id: `sideby/${name}.json`,
+        ...schema,
+    };
+    await writeFile(join(root, `${name}.json`), `${JSON.stringify(doc, null, 2)}\n`);
+}
+console.log(`wrote ${Object.keys(OUTPUT_SCHEMAS).length} schemas to schemas/`);

package/dist/src/core/account-name.d.ts

@@ -0,0 +1,2 @@
+/** Valid Account names. A leaf module with no I/O so the status line tap can import it cheaply. */
+export declare const ACCOUNT_NAME: RegExp;

package/dist/src/core/account-name.js

@@ -0,0 +1,2 @@
+/** Valid Account names. A leaf module with no I/O so the status line tap can import it cheaply. */
+export const ACCOUNT_NAME = /^[a-z0-9][a-z0-9-]{0,31}$/;

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

@@ -0,0 +1,20 @@
+import type { Account, FamilyDef } from '../types.ts';
+import { ACCOUNT_NAME } from './account-name.ts';
+import { UserError } from './errors.ts';
+export { ACCOUNT_NAME };
+export declare function looksLikeBackup(name: string): boolean;
+export declare function mainDirOf(family: FamilyDef, home: string): string;
+export declare function accountDirOf(family: FamilyDef, home: string, name: string): string;
+/**
+ * The Account for this Family and name, read from its directory: the one place an Account is built.
+ * Whether it is an API Account follows the Secret File on disk (and the Family's secretFileMeansApi).
+ */
+export declare function accountAt(family: FamilyDef, home: string, name: string): Promise<Account>;
+/** Discovers the Main Account (if its directory exists) and every `<prefix><name><suffix>` directory in HOME. */
+export declare function discoverAccounts(family: FamilyDef, home: string, ignore?: ReadonlySet<string>): Promise<Account[]>;
+export declare class AccountRefError extends UserError {
+}
+/** Resolves `<family>:<name>`, an alias from the config, or a name unique across Families. */
+export declare function resolveRef(ref: string, accounts: readonly Account[], aliases?: Readonly<Record<string, string>>): Account;
+/** Alias names per Account ref, sorted. An alias whose target matches no Account is left out. */
+export declare function aliasesByAccount(aliases: Readonly<Record<string, string>> | undefined, accounts: readonly Account[]): Map<string, string[]>;