sideby 0.12.1 → 0.13.1

package/README.md

@@ -77,7 +77,7 @@ cc-switch's docs describe that switch: it writes the live settings file ([README
 | See Claude quota (Codex needs no setup) | `sideby quota setup claude --yes` | [Claude quota](docs/guide/usage.md#claude-quota) |
 | Find the cheapest auto-compact size from your own sessions, and use it in one click | `sideby tune` (or the panel's Context tuning tab) | [Context tuning](docs/guide/usage.md#context-tuning) |
 | See each account's model and effort, and set them per account | `sideby model <account>` (or click the model in the panel) | [Model and effort](docs/guide/usage.md#model-and-effort) |
-| Stop Claude sessions from connecting to claude.ai by themselves (Remote Control), for every account at once | `sideby remote-control off` (or the panel's banner) | [Remote Control](docs/guide/usage.md#remote-control) |
+| Choose whether Claude sessions connect to claude.ai by themselves (Remote Control), for every account at once | `sideby remote-control off` or `on` (or the panel's Settings) | [Remote Control](docs/guide/usage.md#remote-control) |
 | Move on when an account hits its limit | `sideby next claude` | [Handoff](docs/guide/usage.md#when-an-account-hits-its-limit) |
 | Let a running task move to the next account by itself when quota runs low (off by default; see the risk) | `sideby handoff enable` (or the panel) | [Auto Handoff](docs/guide/usage.md#auto-handoff) |
 | Short commands such as `ccw` | `sideby alias add ccw claude:work` | [Shell functions](docs/guide/configuration.md#shell-functions) |

package/dist/build.json

@@ -1 +1 @@
-{"id":"20261016T081651-7c664d"}
+{"id":"20261016T161929-77384f"}

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

@@ -8,6 +8,7 @@ export interface Io {
     /** The terminal Auto Handoff counts down on (spec §3.17); `process.stdin` when left out. */
     stdin?: HandoffIo['stdin'];
 }
+export declare function setJsonNotice(n: object | null): void;
 export declare function serializeDoctor(r: DoctorReport): {
     status: "issues" | "ok";
     accounts: {
@@ -44,8 +45,8 @@ export declare function cmdResume(a: ParsedArgs, io: Io): Promise<number>;
 export declare function cmdNext(a: ParsedArgs, io: Io): Promise<number>;
 export declare function cmdDoctor(a: ParsedArgs, io: Io): Promise<number>;
 /**
- * `sideby remote-control [off|undo] [--yes] [--json]` (spec §3.22, ADR-0017): whether Claude sessions connect to
- * claude.ai by themselves, and turning that off for every Account (a preview with exit 10 until --yes).
+ * `sideby remote-control [on|off|undo] [--yes] [--json]` (spec §3.22, ADR-0017): whether Claude sessions connect to
+ * claude.ai by themselves, and turning that on or off for every Account (a preview with exit 10 until --yes).
  */
 export declare function cmdRemoteControl(a: ParsedArgs, io: Io): Promise<number>;
 /**
@@ -74,6 +75,8 @@ export declare function cmdApp(a: ParsedArgs, io: Io): Promise<number>;
  * a Grok Bot window, new or open, and with `--remove` its removal (ADR-0019).
  */
 export declare function cmdDesktop(a: ParsedArgs, io: Io): Promise<number>;
+/** `sideby browser [--enable|--disable] [--yes]` and `sideby browser open <account> [--profile <p>]` (spec §3.24). */
+export declare function cmdBrowser(a: ParsedArgs, io: Io): Promise<number>;
 export declare function cmdAlias(a: ParsedArgs, io: Io): Promise<number>;
 /** `sideby families [family]`: each Family's layout, sign-in and Shared Items, from its FamilyDef (spec §3.16). */
 export declare function cmdFamilies(a: ParsedArgs, io: Io): Promise<number>;

package/dist/src/cli/commands.js

@@ -1,17 +1,18 @@
 import { fileURLToPath } from 'node:url';
 import { aliasesByAccount } from '../core/accounts.js';
 import { listAppProfiles, openAppProfile, parseProfileRef, removeAppProfile } from '../core/app-profiles.js';
+import { browserReport, openInBrowser, setBrowserSignIns } from '../core/browser-profiles.js';
 import { aliasRefs } from '../core/config.js';
 import { openDesktopApp, withDesktopApps } from '../core/desktop-app.js';
 import { UserError } from '../core/errors.js';
 import { requestHandoff } from '../core/handoff-chain.js';
 import { explain, readyDecision, runWithHandoff } from '../core/handoff-run.js';
 import { configureHandoff, handoffHint, handoffStatus } from '../core/handoff-status.js';
-import { runHost } from '../core/launch.js';
+import { installHint, runHost } from '../core/launch.js';
 import { accountModel, setAccountModel } from '../core/model-choice.js';
 import { resolvePaths, tildify } from '../core/paths.js';
 import { USAGE_DAYS } from '../core/quota-levels.js';
-import { groupsToTurnOff, groupsToUndo, } from '../core/remote-control.js';
+import { groupsToTurnOff, groupsToTurnOn, groupsToUndo, } from '../core/remote-control.js';
 import { SHELLS } from '../core/shell-init.js';
 import { suggestAlias, suggestName } from '../panel/page-logic.js';
 import { createRuntime, UnknownFamilyError } from '../runtime.js';
@@ -50,7 +51,12 @@ async function runAccountNow(rt, ref, args, io) {
     }
     return code;
 }
-const json = (io, data) => io.out(JSON.stringify({ schemaVersion: 1, ...data }, null, 2));
+// The `_notice` main.ts works out before a `--json` command (spec §3.23); every JSON output of this run carries it.
+let notice = null;
+export function setJsonNotice(n) {
+    notice = n;
+}
+const json = (io, data) => io.out(JSON.stringify({ schemaVersion: 1, ...data, ...(notice ? { _notice: notice } : {}) }, null, 2));
 function stripFix(f) {
     const { fix: _fix, ...rest } = f;
     return rest;
@@ -85,12 +91,13 @@ export async function cmdList(a, io) {
         io.out('No accounts found yet.');
         const installed = families.filter((f) => f.installed);
         if (installed.length === 0)
-            io.out(`Install a host first: ${families.map((f) => `${f.title} (${f.installUrl})`).join(', ')}`);
+            io.out(`Install a host first: ${families.map((f) => `${f.title} (${installHint(f)})`).join(', ')}`);
         else
             io.out(`Run ${installed.map((f) => f.bin).join(' or ')} once, then \`sideby new <family> <name>\`.`);
     }
     else {
         // `= main`: the other Accounts of its Same Login, which share its Quota (spec §3.21).
+        const brokenOf = (id) => families.find((f) => f.id === id)?.brokenBin;
         const sameMark = (refs) => refs?.length ? ` ${c.dim(`= ${refs.map((r) => r.slice(r.indexOf(':') + 1)).join(', ')}`)}` : '';
         const rows = statuses.map((s) => [
             `${c.bold(s.ref)}${sameMark(s.sameLogin)}`,
@@ -104,10 +111,17 @@ export async function cmdList(a, io) {
                         : c.dim('?'),
             s.identity?.email ?? c.dim('—'),
             s.model ?? c.dim('—'),
-            s.hostInstalled ? tildify(s.dir, home) : `${tildify(s.dir, home)} ${c.yellow('(host not installed)')}`,
+            s.hostInstalled
+                ? tildify(s.dir, home)
+                : `${tildify(s.dir, home)} ${c.yellow(brokenOf(s.family) ? '(host install broken)' : '(host not installed)')}`,
             ...(hasDesktop ? [s.desktopApp?.running ? c.green('open') : c.dim('—')] : []),
         ]);
         io.out(table(rows, ['ACCOUNT', 'TYPE', 'LOGIN', 'EMAIL', 'MODEL', 'DIR', ...(hasDesktop ? ['DESKTOP'] : [])]));
+        // One line per Host that cannot run, with what to do: the rows only say which accounts it affects.
+        for (const f of families.filter((x) => !x.installed && statuses.some((s) => s.family === x.id)))
+            io.out(c.yellow(f.brokenBin
+                ? `\n${f.title}'s install is broken (${tildify(f.brokenBin, home)} cannot run, often after an interrupted upgrade); reinstall it: ${installHint(f)}`
+                : `\n${f.title} is not installed; install it: ${installHint(f)}`));
         if (statuses.some((s) => s.sameLogin?.length))
             io.out(c.dim('\n= <account>: signed in as the same login as that account, so they share one quota.'));
         io.out(c.dim('\nsideby run <account>  ·  sideby new <family> <name>  ·  sideby quota  ·  sideby ui'));
@@ -471,13 +485,14 @@ function rcGroupLine(g, home) {
     return `  ${paint(state)} ${c.bold(g.accounts.join(', '))}  ${c.dim(where)}`;
 }
 /**
- * `sideby remote-control [off|undo] [--yes] [--json]` (spec §3.22, ADR-0017): whether Claude sessions connect to
- * claude.ai by themselves, and turning that off for every Account (a preview with exit 10 until --yes).
+ * `sideby remote-control [on|off|undo] [--yes] [--json]` (spec §3.22, ADR-0017): whether Claude sessions connect to
+ * claude.ai by themselves, and turning that on or off for every Account (a preview with exit 10 until --yes).
  */
 export async function cmdRemoteControl(a, io) {
     const [action, extra] = a.positionals;
-    if (extra !== undefined || (action !== undefined && action !== 'off' && action !== 'undo'))
-        throw new UsageError('usage: sideby remote-control [off|undo] [--yes] [--json]');
+    if (extra !== undefined ||
+        (action !== undefined && action !== 'on' && action !== 'off' && action !== 'undo'))
+        throw new UsageError('usage: sideby remote-control [on|off|undo] [--yes] [--json]');
     const wantJson = a.flags.has('json');
     const rt = await createRuntime();
     const home = rt.paths.home;
@@ -501,9 +516,15 @@ export async function cmdRemoteControl(a, io) {
             io.out(c.cyan('\nRun `sideby remote-control off` so no session connects by itself (it shows the change first).'));
         return 0;
     }
-    const todo = action === 'off' ? groupsToTurnOff(groups) : groupsToUndo(groups);
+    const apply = () => action === 'off' ? rt.remoteControlOff() : action === 'on' ? rt.remoteControlOn() : rt.remoteControlUndo();
+    const todo = action === 'off'
+        ? groupsToTurnOff(groups)
+        : action === 'on'
+            ? groupsToTurnOn(groups)
+            : groupsToUndo(groups);
+    const verb = action === 'off' ? 'turn it off' : action === 'on' ? 'turn it on' : 'undo';
     if (todo.length === 0) {
-        const r = action === 'off' ? await rt.remoteControlOff() : await rt.remoteControlUndo();
+        const r = await apply();
         if (wantJson)
             out({ applied: false, groups: show(groups), message: r.message });
         else
@@ -515,26 +536,30 @@ export async function cmdRemoteControl(a, io) {
             out({
                 applied: false,
                 groups: show(todo),
-                message: `Run again with --yes to ${action === 'off' ? 'turn it off' : 'undo'}.`,
+                message: `Run again with --yes to ${verb}.`,
             });
         else {
             io.out(action === 'off'
                 ? 'Turn off Remote Control at startup?'
-                : 'Put back the Remote Control setting sideby replaced?');
+                : action === 'on'
+                    ? 'Turn on Remote Control at startup?'
+                    : 'Put back the Remote Control setting sideby replaced?');
             for (const g of todo) {
-                const to = action === 'off' ? 'false' : 'what it was before';
+                const to = action === 'off' ? 'false' : action === 'on' ? 'true' : 'what it was before';
                 const from = g.state === 'default' ? 'not set' : g.state === 'on' ? 'true' : 'false';
                 io.out(`  ${tildify(g.file, home)}: remoteControlAtStartup ${from} -> ${to}`);
                 io.out(c.dim(`    used by ${g.accounts.join(', ')}`));
             }
             io.out(action === 'off'
                 ? 'Sessions already running stay connected until you restart them. You can still start it in a session with /remote-control, and undo this with `sideby remote-control undo`.'
-                : 'New sessions go back to the previous setting.');
-            io.out(`Run again with --yes to ${action === 'off' ? 'turn it off' : 'undo'}.`);
+                : action === 'on'
+                    ? 'Every new session then connects to claude.ai and the Claude app, where every device signed in to that account can read it. Undo this with `sideby remote-control undo`.'
+                    : 'New sessions go back to the previous setting.');
+            io.out(`Run again with --yes to ${verb}.`);
         }
         return 10;
     }
-    const r = action === 'off' ? await rt.remoteControlOff() : await rt.remoteControlUndo();
+    const r = await apply();
     const results = r.results.map((x) => ({ ...x, file: tildify(x.file, home) }));
     if (wantJson)
         out({ applied: r.ok, results, message: r.message });
@@ -1031,11 +1056,41 @@ export async function cmdUpdate(a, io) {
     const asJson = a.flags.has('json');
     const plan = await u.planUpdate(paths, process.env);
     const shown = u.shownPlan(plan);
+    const sk = plan.skill;
+    const skillLine = (s) => s.canRun
+        ? `the sideby skill (for ${s.installed.map((v) => v ?? 'no version').join(', ')}) is updated too:\n  ${s.command}`
+        : `the sideby skill is not updated by sideby: ${s.reason}.\n  ${s.command}`;
     if (!plan.available) {
+        // The CLI is current; an outdated skill is the one thing left to update.
+        if (sk?.outdated && sk.canRun) {
+            if (!a.flags.has('yes')) {
+                if (asJson)
+                    json(io, { ...shown, updated: false });
+                else {
+                    io.out(`${c.green('✓')} sideby ${plan.current} is the latest version.`);
+                    io.out(`\nUpdating ${skillLine(sk)}`);
+                    io.out(c.cyan('\nRun it with `sideby update --yes`.'));
+                }
+                return 10;
+            }
+            if (!asJson)
+                io.out(c.dim(`$ ${sk.command}`));
+            const r = await u.applySkillUpdate(sk, process.env, asJson ? undefined : (t) => process.stderr.write(t));
+            if (asJson)
+                json(io, { ...shown, updated: false, skillUpdated: r?.ok ?? false, message: r?.message ?? '' });
+            else if (r?.ok)
+                io.out(`${c.green('✓')} ${r.message}; agents load it in their next session.`);
+            else
+                io.err(c.red(`✗ ${r?.message}`));
+            return r?.ok ? 0 : 1;
+        }
         if (asJson)
             json(io, { ...shown, updated: false });
-        else
+        else {
             io.out(`${c.green('✓')} sideby ${plan.current} is the latest version.`);
+            if (sk?.outdated)
+                io.out(c.yellow(skillLine(sk)));
+        }
         return 0;
     }
     if (!plan.canRun) {
@@ -1053,6 +1108,8 @@ export async function cmdUpdate(a, io) {
         else {
             io.out(`sideby ${c.bold(plan.latest)} is available (you have ${plan.current}). What changed: ${plan.releaseNotes}`);
             io.out(`\nUpdating runs:\n  ${plan.command}`);
+            if (sk?.outdated)
+                io.out(`Then ${skillLine(sk)}`);
             io.out(c.cyan('\nRun it with `sideby update --yes`.'));
         }
         return 10;
@@ -1069,7 +1126,9 @@ export async function cmdUpdate(a, io) {
             updated: r.ok,
             message: r.message,
             restartedPanel: r.restartedPanel,
+            refreshedApp: r.refreshedApp,
             skill: SKILL_INSTALL,
+            ...(r.skillUpdated === undefined ? {} : { skillUpdated: r.skillUpdated }),
             ...(r.ok ? {} : { output: r.output }),
         });
         return r.ok ? 0 : 1;
@@ -1081,8 +1140,17 @@ export async function cmdUpdate(a, io) {
     io.out(`${c.green('✓')} ${r.message}.`);
     if (r.restartedPanel)
         io.out('  The background panel is restarting with the new version; open pages reload by themselves.');
+    if (r.refreshedApp)
+        io.out('  The desktop app now starts the new version and shows its icon.');
     io.out('  A `sideby ui` running in a terminal and sessions already running keep the old version until you restart them.');
-    io.out(`  If you use the sideby skill, update it too: ${SKILL_INSTALL}`);
+    if (r.skillUpdated)
+        io.out('  The sideby skill was updated too; agents load it in their next session.');
+    else if (r.skillUpdated === false)
+        io.err(c.yellow(`  ${r.skillMessage}`));
+    else if (sk?.outdated)
+        io.out(c.yellow(`  ${skillLine(sk)}`));
+    else if (!sk)
+        io.out(`  If you use the sideby skill, install it with: ${SKILL_INSTALL}`);
     return 0;
 }
 /** The internal `sideby update-check` the CLI starts detached: one Update Check, then Auto Update if it is on. */
@@ -1180,6 +1248,83 @@ export async function cmdDesktop(a, io) {
         io.err(c.cyan(n));
     return 0;
 }
+/** `sideby browser [--enable|--disable] [--yes]` and `sideby browser open <account> [--profile <p>]` (spec §3.24). */
+export async function cmdBrowser(a, io) {
+    const [sub, ref, ...extra] = a.positionals;
+    const rt = await createRuntime();
+    const home = rt.paths.home;
+    if (sub === 'open') {
+        if (!ref || extra.length || a.rest.length)
+            throw new UsageError('usage: sideby browser open <account> [--profile <folder|name>]');
+        const profile = a.flags.get('profile');
+        const r = await openInBrowser(rt, await rt.resolve(ref), typeof profile === 'string' ? profile : undefined);
+        if (a.flags.has('json'))
+            json(io, r);
+        else
+            io.out(`${c.green('✓')} opened ${r.url} in Chrome as ${c.bold(r.profile.name)} for ${c.bold(r.ref)}`);
+        return 0;
+    }
+    if (sub !== undefined || a.rest.length)
+        throw new UsageError('usage: sideby browser [--enable|--disable] [--yes] | sideby browser open <account>');
+    const enable = a.flags.has('enable');
+    if (enable || a.flags.has('disable')) {
+        if (enable && a.flags.has('disable'))
+            throw new UsageError('pass --enable or --disable, not both');
+        const r = await setBrowserSignIns(rt, enable, { apply: a.flags.has('yes') });
+        if (a.flags.has('json'))
+            json(io, r);
+        else if (!r.changed)
+            io.out(`Finding browser sign-ins is already ${enable ? 'on' : 'off'}; nothing to change.`);
+        else if (!r.applied) {
+            if (enable) {
+                io.out('sideby will read, on this computer only (nothing is sent anywhere):');
+                for (const x of r.reads)
+                    io.out(`  - ${x}`);
+                io.out('It never opens cookies, saved passwords or the Keychain, and never changes Chrome.');
+            }
+            io.out(`\nChange to ${tildify(r.file, home)}: browser.signIns ${enable ? 'off → on' : 'on → off'}`);
+            io.out(c.cyan(`Apply it with \`sideby browser --${enable ? 'enable' : 'disable'} --yes\`.`));
+        }
+        else
+            io.out(`${c.green('✓')} finding browser sign-ins is ${enable ? 'on' : 'off'}.`);
+        return r.changed && !r.applied ? 10 : 0;
+    }
+    const accounts = await rt.accounts();
+    const r = await browserReport(rt, accounts);
+    if (a.flags.has('json')) {
+        json(io, r);
+        return 0;
+    }
+    for (const p of r.problems)
+        io.err(c.yellow(p));
+    if (!r.enabled) {
+        io.out('Finding which Chrome browser user signed in to each account is off.');
+        io.out(c.cyan('Turn it on with `sideby browser --enable` (it shows what it reads first).'));
+        io.out(c.dim('Without it, open a website in a browser user you name: sideby browser open <account> --profile <name>'));
+        return 0;
+    }
+    if (!r.found) {
+        io.out('Google Chrome has no data on this computer yet; open it once, then try again.');
+        return 0;
+    }
+    const signedIn = new Set(r.profiles.flatMap((p) => p.signIns));
+    const now = new Date();
+    io.out(table(r.profiles.map((p) => [
+        p.name,
+        p.email ?? c.dim('-'),
+        p.dir,
+        p.signIns.join(', ') || c.dim('-'),
+        p.changedAt ? clock(p.changedAt, now) : '-',
+    ]), ['Browser user', 'Google account', 'Folder', 'Signed in to', 'Changed']));
+    const missing = accounts.filter((x) => r.families.matched.includes(x.family) && x.kind !== 'api' && !signedIn.has(x.ref));
+    if (missing.length)
+        io.out(c.dim(`\nNo browser user found for: ${missing.map((x) => x.ref).join(', ')}`));
+    if (r.families.openOnly.length)
+        io.out(c.dim(`${r.families.openOnly.join(', ')}: the website keeps no id to match; open it with --profile.`));
+    io.out(c.dim('\nRead from Chrome on this computer only; a browser user that signed out may still show.'));
+    io.out(c.dim('Open one: sideby browser open <account> [--profile <name>]'));
+    return 0;
+}
 export async function cmdAlias(a, io) {
     const [sub, alias, target, ...more] = a.positionals;
     const usage = 'usage: sideby alias add <short-command> <account> [-- host args]  |  sideby alias rm <short-command>';
@@ -1221,7 +1366,7 @@ export async function cmdFamilies(a, io) {
     families.forEach((f, i) => {
         if (i)
             io.out('');
-        io.out(`${c.bold(f.title)} (${f.id})  ${f.installed ? c.green('installed') : c.yellow(`not installed: ${f.installUrl}`)}`);
+        io.out(`${c.bold(f.title)} (${f.id})  ${f.installed ? c.green('installed') : c.yellow(f.brokenBin ? `install broken (${tildify(f.brokenBin, rt.paths.home)} cannot run); reinstall: ${installHint(f)}` : `not installed: ${installHint(f)}`)}`);
         io.out(`  Accounts   ~/${f.layout.main} (main), ~/${f.layout.account}; selected with ${f.selectVar}`);
         io.out(`  Sign in    sideby login ${f.id}:<name>  ${c.dim(f.login.args ? `(runs ${[f.bin, ...f.login.args].join(' ')})` : `(${f.login.hint})`)}`);
         const yes = (b) => (b ? c.green('yes') : c.dim('no public source'));

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

@@ -50,7 +50,9 @@ const FamilyInfo = Type.Object({
     title: Str,
     bin: Str,
     installUrl: Str,
+    installCommand: Type.Optional(Str),
     installed: Type.Boolean(),
+    brokenBin: Type.Optional(Str),
     plugin: Str,
     tuning: Type.Boolean(),
 });
@@ -210,6 +212,30 @@ const AppProfile = Type.Object({
 }, {
     description: 'A window of a desktop app that signs in apart from every account (Grok Bot, ADR-0019). Open or create one with `sideby desktop grok-bot:<name>`.',
 });
+/**
+ * On any `--json` output when there is something to mention once the task is done (spec §3.23): a newer sideby in the
+ * cached Update Check, or an installed sideby skill for another version. Off with SIDEBY_NO_UPDATE_NOTIFIER.
+ */
+const Notice = Type.Object({
+    update: Type.Optional(Type.Object({
+        current: Str,
+        latest: Str,
+        command: Type.String({
+            description: 'Run it after the user agrees: it shows the plan and exits 10; then --yes.',
+        }),
+        message: Str,
+    })),
+    skill: Type.Optional(Type.Object({
+        installed: Type.Union([Str, Type.Null()], {
+            description: "The skill's version; null when it has none.",
+        }),
+        current: Str,
+        command: Type.String({
+            description: 'Updates the installed sideby skill (run it after the user agrees).',
+        }),
+        message: Str,
+    })),
+}, { description: 'Not the answer to the task: mention it briefly afterwards and offer to update.' });
 export const OUTPUT_SCHEMAS = {
     list: Type.Object({
         schemaVersion: Version,
@@ -256,7 +282,12 @@ export const OUTPUT_SCHEMAS = {
     }, { title: 'sideby tune apply|undo --json' }),
     'remote-control': Type.Object({
         schemaVersion: Version,
-        action: Type.Union([Type.Literal('status'), Type.Literal('off'), Type.Literal('undo')]),
+        action: Type.Union([
+            Type.Literal('status'),
+            Type.Literal('on'),
+            Type.Literal('off'),
+            Type.Literal('undo'),
+        ]),
         applied: Type.Optional(Type.Boolean({ description: 'True once the change was written (or undone).' })),
         groups: Type.Optional(Type.Array(Type.Object({
             file: Str,
@@ -491,6 +522,47 @@ export const OUTPUT_SCHEMAS = {
             description: 'False when only the plan was shown; run again with --yes (exit 10).',
         }),
     }, { title: 'sideby desktop grok-bot:<name> --remove --json' }),
+    browser: Type.Object({
+        schemaVersion: Version,
+        enabled: Type.Boolean({
+            description: 'config `browser.signIns`. When false nothing of the browser was read and `profiles` is empty.',
+        }),
+        browser: Type.String({ description: 'The browser read, `Google Chrome`.' }),
+        found: Type.Boolean({ description: "Chrome's user data folder exists on this Mac." }),
+        profiles: Type.Array(Type.Object({
+            dir: Type.String({ description: "The browser user's folder, such as `Default` or `Profile 7`." }),
+            name: Type.String({ description: 'The name Chrome shows; it may be an email.' }),
+            email: Type.Optional(Type.String({ description: 'The Google account this browser user is signed in to Chrome with.' })),
+            signIns: Type.Array(Str, {
+                description: "Refs of the accounts this browser user signed in to on the vendor's website, as far as its local data shows; it may be left over from before a sign-out.",
+            }),
+            changedAt: Type.Optional(Type.String({ description: 'When its Local Storage last changed (ISO 8601).' })),
+        }), { description: 'Most recently changed first.' }),
+        families: Type.Object({
+            matched: Type.Array(Str, { description: 'Families whose accounts can be matched (claude, codex).' }),
+            openOnly: Type.Array(Str, {
+                description: 'Families that can only be opened in a browser user given with --profile (grok).',
+            }),
+        }),
+        problems: Type.Array(Str),
+    }, { title: 'sideby browser --json' }),
+    'browser-switch': Type.Object({
+        schemaVersion: Version,
+        enabled: Type.Boolean({ description: 'The value asked for.' }),
+        changed: Type.Boolean(),
+        applied: Type.Boolean({
+            description: 'False when only the change was shown; run again with --yes (exit 10).',
+        }),
+        file: Type.String({ description: 'The config file.' }),
+        reads: Type.Array(Str, { description: 'What sideby reads while it is on, all on this computer.' }),
+    }, { title: 'sideby browser --enable|--disable --json' }),
+    'browser-open': Type.Object({
+        schemaVersion: Version,
+        ref: Str,
+        url: Str,
+        profile: Type.Object({ dir: Str, name: Str }),
+        command: Type.Array(Str, { description: 'The `open` command sideby ran.' }),
+    }, { title: 'sideby browser open --json' }),
     update: Type.Object({
         schemaVersion: Version,
         current: Type.String({ description: 'The running sideby version.' }),
@@ -513,7 +585,28 @@ export const OUTPUT_SCHEMAS = {
         restartedPanel: Type.Optional(Type.Boolean({
             description: 'A background Panel was running and starts again with the new version.',
         })),
-        skill: Type.Optional(Type.String({ description: 'The command that updates the sideby skill; sideby never runs it.' })),
+        refreshedApp: Type.Optional(Type.Boolean({
+            description: 'The desktop app (`sideby app install`) was installed and was written again by the new version.',
+        })),
+        skill: Type.Optional(Type.String({ description: 'The command that installs the sideby skill by hand.' })),
+        skillUpdate: Type.Optional(Type.Object({
+            installed: Type.Array(Type.Union([Str, Type.Null()]), {
+                description: 'Versions of the installed sideby skills; null for one without a version.',
+            }),
+            outdated: Type.Boolean({
+                description: 'Some installed skill is for another version than sideby will run.',
+            }),
+            command: Str,
+            canRun: Type.Boolean({
+                description: 'False when sideby leaves the skill alone (see reason): give the user command.',
+            }),
+            reason: Type.Optional(Str),
+        }, {
+            description: 'The installed sideby skill, which the Update brings along; absent when none is installed.',
+        })),
+        skillUpdated: Type.Optional(Type.Boolean({
+            description: 'The skill was updated too (true) or that failed (false); absent when not tried.',
+        })),
         output: Type.Optional(Type.String({ description: 'What the failed install command printed.' })),
     }, { title: 'sideby update --json' }),
     error: Type.Object({
@@ -525,3 +618,8 @@ export const OUTPUT_SCHEMAS = {
     }, { title: 'sideby error --json' }),
     config: ConfigSchema,
 };
+for (const [name, schema] of Object.entries(OUTPUT_SCHEMAS)) {
+    const props = schema.properties;
+    if (name !== 'config' && props)
+        props._notice = Type.Optional(Notice);
+}

package/dist/src/cli/main.js

@@ -34,7 +34,7 @@ Usage:
                                       from your last 7 days of sessions (read-only)
   sideby model <account> [<model>|default] [--effort <level>|default] [--yes]
                                       show or set the model and effort sideby starts this account with
-  sideby remote-control [off|undo] [--yes]
+  sideby remote-control [on|off|undo] [--yes]
                                       whether Claude sessions connect to claude.ai by themselves;
                                       off stops that for every account (shows the change first)
   sideby handoff status               what Auto Handoff still needs on this machine
@@ -52,6 +52,10 @@ Usage:
   sideby desktop <account>            open the desktop app (Claude Desktop, the Codex app) as this
                                       account, next to the others (macOS)
   sideby desktop grok-bot:<name>      open a Grok Bot window, a new one for a new name (macOS)
+  sideby browser [--enable [--yes]]   which Chrome browser user signed in to each account's website
+                                      (read on this computer only; off until you enable it)
+  sideby browser open <account> [--profile <name>]
+                                      open claude.ai, chatgpt.com or grok.com in that browser user
   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)"
@@ -62,8 +66,8 @@ Usage:
 
 Options:
   --json        machine-readable output (list, new, next, alias, doctor, quota, tune, model, remote-control, handoff,
-                families, plugins, app, desktop, update)
-  -h, --help    show this help; \`sideby <command> --help\` for new, alias, login, doctor, families, desktop
+                families, plugins, app, desktop, browser, update)
+  -h, --help    show this help; \`sideby <command> --help\` for new, alias, login, doctor, families, desktop, browser
   -v, --version show the version
 
 An <account> is <family>:<name> (claude:work) or just <name> when it is unique.
@@ -164,6 +168,30 @@ Examples:
   sideby desktop grok-bot:002 --remove --yes
 Exit: 0 opened, brought to the front or removed; 1 not macOS, no desktop app for that host, API account, app not
 installed, a bad window name, or the app did not open; 10 --remove without --yes; 2 malformed command line.`,
+    browser: `sideby browser [--enable|--disable] [--yes] [--json]
+       sideby browser open <account> [--profile <folder|name>] [--json]
+
+Find which Google Chrome browser user signed in to each account's website (claude.ai for claude accounts,
+chatgpt.com for codex accounts), and open the website in that browser user. macOS only for now.
+
+Everything is read on this computer and sent nowhere. sideby reads each browser user's name, the key names (never
+the values) claude.ai and chatgpt.com keep in that browser user's Local Storage, and the account id in each Claude and
+Codex login file, only to compare. It never opens cookies, saved passwords or the Keychain, and never changes Chrome.
+It is off until you turn it on: --enable shows what it reads and changes config browser.signIns after --yes.
+
+"Signed in to" means that browser user's data shows a sign-in as that account; it may be left over from before a
+sign-out. grok.com keeps no id to match, so grok accounts can only be opened with --profile.
+
+open uses the one browser user that signed in to the account, or the one --profile names (folder such as
+"Profile 7", or the name Chrome shows). It runs: open -na "Google Chrome" --args --profile-directory=<folder> <url>.
+
+Examples:
+  sideby browser --enable --yes
+  sideby browser
+  sideby browser open cc008
+  sideby browser open grok:main --profile Work
+Exit: 0 shown, changed or opened; 1 not macOS, Chrome not installed, no or several browser users to choose from, or
+Chrome did not open; 10 --enable/--disable without --yes; 2 malformed command line.`,
     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
@@ -204,6 +232,7 @@ const COMMANDS = {
     ui: { flags: ['no-open', 'background', 'stop', 'serve-detached'], valued: ['port'] },
     app: { flags: ['json'], valued: ['url'] },
     desktop: { flags: ['json', 'remove', 'yes'] },
+    browser: { flags: ['json', 'enable', 'disable', 'yes'], valued: ['profile'] },
     'shell-init': { flags: ['write'] },
     plugins: { flags: ['json'] },
     families: { flags: ['json'] },
@@ -220,6 +249,38 @@ function noticeAllowed(cmd, parsed) {
         return false;
     return true;
 }
+/**
+ * Before a `--json` command (spec §3.23): the `_notice` its output carries, from the cached Update Check and the
+ * installed sideby skills, so an agent that reads JSON learns of a newer version too. Starts the next check detached
+ * when the last one is a day old, as afterCommand does on a terminal. Never fails the command.
+ */
+async function jsonNoticeFor() {
+    try {
+        const u = await import('../core/update.js');
+        const { resolvePaths } = await import('../core/paths.js');
+        const { loadConfig } = await import('../core/config.js');
+        const { packageVersion } = await import('../core/version.js');
+        const { installedSkillVersions, SKILL_INSTALL } = await import('../core/skill-check.js');
+        const paths = resolvePaths(process.env);
+        const config = await loadConfig(paths.configFile).catch(() => ({}));
+        const cache = await u.readUpdateCache(paths);
+        const skills = await installedSkillVersions(paths.home);
+        const n = u.jsonNotice(cache, packageVersion(), config, process.env, skills, SKILL_INSTALL);
+        if (!u.checksOff(process.env, config) && u.checkDue(cache, new Date())) {
+            const { spawn } = await import('node:child_process');
+            const child = spawn(process.execPath, [fileURLToPath(import.meta.url), 'update-check'], {
+                detached: true,
+                stdio: 'ignore',
+            });
+            child.on('error', () => { });
+            child.unref();
+        }
+        return n;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * After a command (spec §3.23): print the Update Notice and the result of an Auto Update, each at most once, and
  * start the next Update Check detached when the last one is a day old. Only on a terminal; never fails the command.
@@ -290,6 +351,7 @@ export async function main(argv) {
     // 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');
+    let notice = null;
     try {
         if (!spec)
             throw new UsageError(`unknown command "${cmd}"; run \`sideby --help\``);
@@ -325,6 +387,10 @@ export async function main(argv) {
             return 0;
         }
         const cmds = await import('./commands.js');
+        if (wantsJson && noticeAllowed(cmd, parsed)) {
+            notice = await jsonNoticeFor();
+            cmds.setJsonNotice(notice);
+        }
         const code = await dispatch(cmd, parsed, io, cmds);
         if (!wantsJson && noticeAllowed(cmd, parsed))
             await afterCommand();
@@ -336,7 +402,7 @@ export async function main(argv) {
         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));
+            console.log(JSON.stringify({ schemaVersion: 1, error: message, code, ...(notice ? { _notice: notice } : {}) }, null, 2));
         }
         else
             console.error(`sideby: ${message}`);
@@ -379,6 +445,8 @@ async function dispatch(cmd, parsed, io, cmds) {
             return await cmds.cmdApp(parsed, io);
         case 'desktop':
             return await cmds.cmdDesktop(parsed, io);
+        case 'browser':
+            return await cmds.cmdBrowser(parsed, io);
         case 'shell-init':
             return await cmds.cmdShellInit(parsed, io);
         case 'plugins':