sideby 0.9.3 → 0.11.0

package/README.md

@@ -16,28 +16,17 @@
 
 <p align="center">English | <a href="README.zh-CN.md">中文</a></p>
 
-## Why not just an alias?
-
-`CLAUDE_CONFIG_DIR` plus a shell alias already starts a second account. It does not keep skills and settings in one place, and it does not show quota for every account. [Does this break a provider's terms?](docs/guide/faq.md#terms)
-
-| | At the same time | Skills, hooks, settings | Quota and usage | Setup |
-|---|---|---|---|---|
-| `CLAUDE_CONFIG_DIR` and an alias | Yes. Each terminal exports the variable. | Each directory is its own copy. They drift unless you symlink by hand. | That session's status line | One alias per account |
-| [cc-switch](https://github.com/farion1231/cc-switch) | Enabling a provider writes the host's live config, so open sessions share that switch. | Plugin settings are copied across providers as a separate step. | The active provider, from its quota endpoint | Install the desktop app |
-| sideby | Yes. `sideby run` selects the directory for that process and leaves your shell alone. | Linked to the main account. `sideby doctor --fix` repairs copies. Sign-in and sessions stay separate. | Every account, from local files. Claude needs `quota setup`. | `npm i -g sideby`, then `sideby new` and sign in |
-
-cc-switch's docs describe that switch: it writes the live settings file ([README](https://github.com/farion1231/cc-switch#readme)). [#1105](https://github.com/farion1231/cc-switch/issues/1105) and [#2908](https://github.com/farion1231/cc-switch/issues/2908) ask for several sessions at once. [#1106](https://github.com/farion1231/cc-switch/issues/1106) is closed; the maintainer says Claude Code's "open terminal" can start one provider without changing the global config.
-
 ## Quick start
 
 Requires Node 22.18+ and at least one Host CLI (Claude Code, Codex, Grok Build or pi) installed. AI agents: follow the setup steps in [`llms.txt`](llms.txt) ("Set up sideby for a user") instead.
 
 ```sh
 npm i -g sideby
-sideby new claude work        # create ~/.claude-work, sharing ~/.claude's skills and hooks
-sideby login claude:work      # sign in once
-sideby run work               # Claude Code on the work account
-sideby ui                     # every account's quota at http://127.0.0.1:17420
+sideby new claude work           # create ~/.claude-work, sharing ~/.claude's skills and hooks
+sideby login claude:work         # sign in once
+sideby run work                  # Claude Code on the work account
+sideby quota setup claude --yes  # Claude quota in the panel; undo: sideby quota teardown claude
+sideby ui                        # every account's quota at http://127.0.0.1:17420
 ```
 
 `sideby run claude:main` keeps using `~/.claude` in another terminal at the same time. Arguments after `--` go to the Host: `sideby run work -- --resume`. To try it without installing, run `npx sideby`.
@@ -55,6 +44,10 @@ The agent checks Node and your Host CLIs, installs sideby and the skill, creates
 
 ## What it looks like
 
+The 25-second story: one account buried in tasks, then accounts side by side sharing one setup, and a task moving on when one runs out.
+
+https://github.com/user-attachments/assets/3a470c03-9009-4f1d-b7f6-8b4625d74958
+
 <img alt="Two terminals: the personal account and the work account running at the same time, both linked to the main account's skills and settings, then the local quota panel, and at 95% Auto Handoff moving work's session to the next account" src="https://raw.githubusercontent.com/Adonis0123/sideby/main/docs/assets/demo.gif" width="1280">
 
 <picture>
@@ -63,6 +56,18 @@ The agent checks Node and your Host CLIs, installs sideby and the skill, creates
   <img alt="sideby panel: every account's 5h and 7d quota, 7-day token usage and health in one page" src="https://raw.githubusercontent.com/Adonis0123/sideby/main/docs/assets/panel.png" width="1280">
 </picture>
 
+## Why not just an alias?
+
+`CLAUDE_CONFIG_DIR` plus a shell alias already starts a second account. It does not keep skills and settings in one place, and it does not show quota for every account. [Does this break a provider's terms?](docs/guide/faq.md#terms)
+
+| | At the same time | Skills, hooks, settings | Quota and usage | Setup |
+|---|---|---|---|---|
+| `CLAUDE_CONFIG_DIR` and an alias | Yes. Each terminal exports the variable. | Each directory is its own copy. They drift unless you symlink by hand. | That session's status line | One alias per account |
+| [cc-switch](https://github.com/farion1231/cc-switch) | Enabling a provider writes the host's live config, so open sessions share that switch. | Plugin settings are copied across providers as a separate step. | The active provider, from its quota endpoint | Install the desktop app |
+| sideby | Yes. `sideby run` selects the directory for that process and leaves your shell alone. | Linked to the main account. `sideby doctor --fix` repairs copies. Sign-in and sessions stay separate. | Every account, from local files. Claude needs `quota setup`. | `npm i -g sideby`, then `sideby new` and sign in |
+
+cc-switch's docs describe that switch: it writes the live settings file ([README](https://github.com/farion1231/cc-switch#readme)). [#1105](https://github.com/farion1231/cc-switch/issues/1105) and [#2908](https://github.com/farion1231/cc-switch/issues/2908) ask for several sessions at once. [#1106](https://github.com/farion1231/cc-switch/issues/1106) is closed; the maintainer says Claude Code's "open terminal" can start one provider without changing the global config.
+
 ## What else it does
 
 | You want to | Run | Guide |
@@ -72,11 +77,13 @@ The agent checks Node and your Host CLIs, installs sideby and the skill, creates
 | 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) |
 | 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) |
 | Reopen a session from Orca and the like in the account that holds it | `"resumeRouting": true` in config | [Resuming from other tools](docs/guide/configuration.md#resuming-from-other-tools) |
 | Open Claude Desktop or the Codex app as one account, several side by side (macOS) | `sideby desktop claude:work` (or the panel) | [Desktop apps](docs/guide/usage.md#desktop-apps) |
+| Keep several Grok Bot windows open, each signed in to its own account (macOS) | `sideby desktop grok-bot:002` (or the panel) | [Grok Bot windows](docs/guide/usage.md#grok-bot-windows) |
 | Open the panel from the Dock or app menu | `sideby app install` | [Panel app](docs/guide/panel.md#panel-app) |
 | Show the panel inside your own local page | `createPanelHandler()` | [Embed the panel](docs/guide/panel.md#embed-the-panel) |
 | Add a Host or a pre-launch check | a local plugin | [Plugins](docs/guide/plugins.md) |

package/dist/build.json

@@ -1 +1 @@
-{"id":"20261015T124638-3ce884"}
+{"id":"20261016T040419-834a8d"}

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

@@ -43,6 +43,11 @@ export declare function cmdResume(a: ParsedArgs, io: Io): Promise<number>;
 /** `sideby next <family>`: recommend the Account with the most room, then start it (spec §3.13). */
 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).
+ */
+export declare function cmdRemoteControl(a: ParsedArgs, io: Io): Promise<number>;
 /**
  * `sideby model <account> [<model>|default] [--effort <level>|default] [--yes]` (spec §3.19, ADR-0014): shows the
  * Account's model and effort; with a change, shows it (exit 10) and writes it with --yes.
@@ -57,7 +62,10 @@ export declare function cmdPlugins(a: ParsedArgs, io: Io): Promise<number>;
 export declare function cmdShellInit(a: ParsedArgs, io: Io): Promise<number>;
 export declare function cmdUi(a: ParsedArgs, io: Io): Promise<number>;
 export declare function cmdApp(a: ParsedArgs, io: Io): Promise<number>;
-/** `sideby desktop <account>`: the Family's Desktop App as that Account (spec §3.20). */
+/**
+ * `sideby desktop <account>`: the Family's Desktop App as that Account (spec §3.20); `sideby desktop grok-bot:<name>`:
+ * a Grok Bot window, new or open, and with `--remove` its removal (ADR-0019).
+ */
 export declare function cmdDesktop(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). */

package/dist/src/cli/commands.js

@@ -1,5 +1,6 @@
 import { fileURLToPath } from 'node:url';
 import { aliasesByAccount } from '../core/accounts.js';
+import { listAppProfiles, openAppProfile, parseProfileRef, removeAppProfile } from '../core/app-profiles.js';
 import { aliasRefs } from '../core/config.js';
 import { openDesktopApp, withDesktopApps } from '../core/desktop-app.js';
 import { UserError } from '../core/errors.js';
@@ -10,6 +11,7 @@ import { 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 { SHELLS } from '../core/shell-init.js';
 import { suggestAlias, suggestName } from '../panel/page-logic.js';
 import { createRuntime, UnknownFamilyError } from '../runtime.js';
@@ -54,11 +56,14 @@ function tilde(text, home) {
 export async function cmdList(a, io) {
     const rt = await createRuntime();
     const accounts = await rt.accounts();
-    const statuses = await withDesktopApps(rt, accounts, Promise.all(accounts.map((x) => rt.status(x))));
+    const [statuses, appProfiles] = await Promise.all([
+        withDesktopApps(rt, accounts, Promise.all(accounts.map((x) => rt.status(x)))),
+        listAppProfiles(rt),
+    ]);
     const hasDesktop = statuses.some((s) => s.desktopApp);
     const families = await rt.familyInfo();
     if (a.flags.has('json')) {
-        json(io, { families, accounts: statuses, pluginErrors: [...rt.pluginErrors] });
+        json(io, { families, accounts: statuses, appProfiles, pluginErrors: [...rt.pluginErrors] });
         return 0;
     }
     const home = rt.paths.home;
@@ -93,6 +98,25 @@ export async function cmdList(a, io) {
             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'));
     }
+    // App Profiles (ADR-0019): windows of an app that signs in apart from the Accounts above.
+    for (const app of new Set(appProfiles.map((p) => p.app))) {
+        const list = appProfiles.filter((p) => p.app === app);
+        io.out(`\n${c.bold(app)} ${c.dim('(signs in on its own, not with the accounts above)')}`);
+        io.out(table(list.map((p) => [
+            c.bold(p.ref),
+            p.running ? c.green('open') : c.dim('—'),
+            p.signedIn === true
+                ? c.green('signed in')
+                : p.signedIn === false
+                    ? c.yellow('not signed in')
+                    : c.dim('?'),
+            p.appData ? tildify(p.appData, home) : c.dim('default'),
+        ]), ['WINDOW', 'STATE', 'SIGN-IN', 'DATA']));
+        if (!list[0]?.installed)
+            io.out(c.yellow(`${app} is not installed; these windows open again once it is`));
+        const id = list[0]?.ref.slice(0, list[0].ref.indexOf(':'));
+        io.out(c.dim(`sideby desktop ${id}:<name> opens one (a new name makes a new window)`));
+    }
     for (const s of statuses)
         for (const p of s.problems ?? [])
             io.err(c.yellow(`${s.ref}: ${p}`));
@@ -413,6 +437,100 @@ async function cmdTuneChange(a, io, action) {
         io.out(r.message);
     return r.ok ? 0 : 1;
 }
+const RC_STATE = {
+    on: 'on',
+    default: 'default',
+    off: 'off',
+    missing: 'no file',
+    blocked: 'cannot change',
+};
+function rcGroupLine(g, home) {
+    const state = RC_STATE[g.state].padEnd(13);
+    const paint = g.state === 'on'
+        ? c.yellow
+        : g.state === 'off'
+            ? c.green
+            : g.state === 'default'
+                ? (x) => x
+                : c.dim;
+    const where = g.reason ? tilde(g.reason, home) : tildify(g.file, 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).
+ */
+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]');
+    const wantJson = a.flags.has('json');
+    const rt = await createRuntime();
+    const home = rt.paths.home;
+    const show = (gs) => gs.map((g) => ({ ...g, file: tildify(g.file, home) }));
+    const out = (data) => json(io, { action: action ?? 'status', ...data });
+    const groups = await rt.remoteControl();
+    if (!action) {
+        if (wantJson) {
+            out({ groups: show(groups) });
+            return 0;
+        }
+        if (groups.length === 0) {
+            io.out('No Claude accounts found.');
+            return 0;
+        }
+        io.out('Remote Control: whether Claude sessions connect to claude.ai/code and the Claude app by themselves');
+        for (const g of groups)
+            io.out(rcGroupLine(g, home));
+        io.out(c.dim('  on: every session connects; default: Claude Code or your organization decides; off: only when you run /remote-control'));
+        if (groupsToTurnOff(groups).length)
+            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);
+    if (todo.length === 0) {
+        const r = action === 'off' ? await rt.remoteControlOff() : await rt.remoteControlUndo();
+        if (wantJson)
+            out({ applied: false, groups: show(groups), message: r.message });
+        else
+            io.out(tilde(r.message, home));
+        return r.ok ? 0 : 1;
+    }
+    if (!a.flags.has('yes')) {
+        if (wantJson)
+            out({
+                applied: false,
+                groups: show(todo),
+                message: `Run again with --yes to ${action === 'off' ? 'turn it off' : 'undo'}.`,
+            });
+        else {
+            io.out(action === 'off'
+                ? 'Turn off 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 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'}.`);
+        }
+        return 10;
+    }
+    const r = action === 'off' ? await rt.remoteControlOff() : await rt.remoteControlUndo();
+    const results = r.results.map((x) => ({ ...x, file: tildify(x.file, home) }));
+    if (wantJson)
+        out({ applied: r.ok, results, message: r.message });
+    else {
+        for (const x of results)
+            io.out(`  ${x.ok ? c.green('ok') : c.red('failed')} ${x.file}: ${x.message}`);
+        io.out(r.message);
+    }
+    return r.ok ? 0 : 1;
+}
 const FROM = {
     sideby: 'set by sideby',
     host: 'from the host config',
@@ -765,7 +883,10 @@ export async function cmdHandoff(a, io) {
             requested: true,
             ...(next ? { next } : {}),
             ...(request.brief ? { brief: request.brief } : {}),
+            ...(request.now ? { now: true } : {}),
         });
+    else if (request.now)
+        io.out(`This session was waiting for its quota; ${next ?? 'the next account'} takes over now.`);
     else
         io.out(`${next ? `${next} takes over` : 'The next account starts'} when this turn ends; finish the turn now.`);
     return 0;
@@ -924,13 +1045,32 @@ export async function cmdApp(a, io) {
     }
     return r.skipped.length ? 1 : 0;
 }
-/** `sideby desktop <account>`: the Family's Desktop App as that Account (spec §3.20). */
+/**
+ * `sideby desktop <account>`: the Family's Desktop App as that Account (spec §3.20); `sideby desktop grok-bot:<name>`:
+ * a Grok Bot window, new or open, and with `--remove` its removal (ADR-0019).
+ */
 export async function cmdDesktop(a, io) {
     const [ref, ...extra] = a.positionals;
     if (!ref || extra.length || a.rest.length)
-        throw new UsageError('usage: sideby desktop <account>');
+        throw new UsageError('usage: sideby desktop <account> | sideby desktop grok-bot:<name> [--remove [--yes]]');
     const rt = await createRuntime();
-    const r = await openDesktopApp(rt, ref);
+    const profile = parseProfileRef(ref) !== undefined;
+    if (a.flags.has('remove')) {
+        if (!profile)
+            throw new UsageError('--remove works on Grok Bot windows only: sideby desktop grok-bot:<name> --remove');
+        const r = await removeAppProfile(rt, ref, { yes: a.flags.has('yes') });
+        if (a.flags.has('json'))
+            json(io, r);
+        else if (r.removed)
+            io.out(`${c.green('✓')} removed the ${r.app} window ${c.bold(r.ref)} and its data`);
+        else {
+            io.out(`Remove the ${r.app} window ${c.bold(r.ref)}?`);
+            io.out(`  deletes ${tildify(r.appData, rt.paths.home)}: its sign-in, bots and local data on this Mac`);
+            io.out('Run again with --yes to remove it.');
+        }
+        return r.removed ? 0 : 10;
+    }
+    const r = profile ? await openAppProfile(rt, ref) : await openDesktopApp(rt, ref);
     if (a.flags.has('json')) {
         json(io, r);
         return 0;

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

@@ -194,11 +194,30 @@ const ShellInitFiles = Type.Array(Type.Object({
     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.' });
+const AppProfile = Type.Object({
+    ref: Type.String({ description: "`grok-bot:<name>`; `grok-bot:main` is the app's own default data." }),
+    app: Type.String({ description: 'The app, for example `Grok Bot`.' }),
+    name: Str,
+    isMain: Type.Boolean(),
+    appData: Type.Optional(Type.String({
+        description: "This window's data folder; absent for the main one, which uses the app's default.",
+    })),
+    installed: Type.Boolean(),
+    running: Type.Boolean({ description: "This window's own instance runs now." }),
+    signedIn: Type.Optional(Type.Boolean({
+        description: 'What the app last wrote about its sign-in (it keeps the last value after the app quits); absent when unknown. Which account is signed in is not known.',
+    })),
+}, {
+    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>`.',
+});
 export const OUTPUT_SCHEMAS = {
     list: Type.Object({
         schemaVersion: Version,
         families: Type.Array(FamilyInfo),
         accounts: Type.Array(AccountStatus),
+        appProfiles: Type.Optional(Type.Array(AppProfile, {
+            description: 'Grok Bot windows (macOS, when Grok Bot is installed or has windows), the main one first. Not accounts.',
+        })),
         pluginErrors: Type.Array(PluginError),
     }, { title: 'sideby list --json' }),
     doctor: Type.Object({
@@ -235,6 +254,30 @@ export const OUTPUT_SCHEMAS = {
         })),
         message: Type.Optional(Str),
     }, { title: 'sideby tune apply|undo --json' }),
+    'remote-control': Type.Object({
+        schemaVersion: Version,
+        action: Type.Union([Type.Literal('status'), 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,
+            accounts: Type.Array(Str, { description: 'Claude accounts whose settings.json is this file.' }),
+            state: Type.Union([
+                Type.Literal('on'),
+                Type.Literal('default'),
+                Type.Literal('off'),
+                Type.Literal('missing'),
+                Type.Literal('blocked'),
+            ], {
+                description: 'on: remoteControlAtStartup is true; default: not set; off: false; missing: no settings.json; blocked: cannot be changed safely (see reason).',
+            }),
+            reason: Type.Optional(Str),
+            undo: Type.Boolean({
+                description: 'sideby turned it off here and can put the earlier value back.',
+            }),
+        }), { description: 'For status, every file; for a preview, the files that would change.' })),
+        results: Type.Optional(Type.Array(Type.Object({ file: Str, accounts: Type.Array(Str), ok: Type.Boolean(), message: Str }))),
+        message: Type.Optional(Str),
+    }, { title: 'sideby remote-control [off|undo] --json' }),
     model: Type.Object({
         schemaVersion: Version,
         account: Str,
@@ -356,6 +399,8 @@ export const OUTPUT_SCHEMAS = {
         requested: Type.Literal(true),
         next: Type.Optional(Str),
         brief: Type.Optional(Str),
+        /** The session was waiting for its quota, so the handoff starts now instead of after a turn (ADR-0018). */
+        now: Type.Optional(Type.Literal(true)),
     }, { title: 'sideby handoff ready --json' }),
     'handoff-setup': Type.Object({ schemaVersion: Version, family: Str, applied: Type.Boolean(), plan: QuotaSetupPlan }, { title: 'sideby handoff setup --json' }),
     'handoff-teardown': Type.Object({ schemaVersion: Version, family: Str, ok: Type.Boolean(), message: Str, diff: Type.Optional(Str) }, { title: 'sideby handoff teardown --json' }),
@@ -421,7 +466,7 @@ export const OUTPUT_SCHEMAS = {
     desktop: Type.Object({
         schemaVersion: Version,
         ref: Str,
-        family: Str,
+        family: Type.String({ description: 'The family, or `grok-bot` for a Grok Bot window.' }),
         app: Type.String({ description: 'The desktop app, for example `Claude Desktop`.' }),
         appPath: Str,
         action: Type.Union([Type.Literal('started'), Type.Literal('focused'), Type.Literal('already-running')], {
@@ -437,6 +482,15 @@ export const OUTPUT_SCHEMAS = {
         command: Type.Optional(Type.Array(Str, { description: 'The `open` command sideby ran.' })),
         notices: Type.Array(Str),
     }, { title: 'sideby desktop --json' }),
+    'desktop-remove': Type.Object({
+        schemaVersion: Version,
+        ref: Str,
+        app: Str,
+        appData: Type.String({ description: 'The folder that is (or would be) deleted.' }),
+        removed: Type.Boolean({
+            description: 'False when only the plan was shown; run again with --yes (exit 10).',
+        }),
+    }, { title: 'sideby desktop grok-bot:<name> --remove --json' }),
     error: Type.Object({
         schemaVersion: Version,
         error: Type.String({ description: 'What went wrong and what to do next.' }),

package/dist/src/cli/main.js

@@ -34,6 +34,9 @@ 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]
+                                      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
   sideby handoff enable [--yes]       turn it on (shows the config change first); --same-family,
                                       --order claude=codex001,cc002, --threshold n, --prepare-at n
@@ -48,6 +51,7 @@ Usage:
   sideby ui --stop                    stop the background panel
   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 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)"
@@ -56,8 +60,8 @@ Usage:
   sideby plugins                      list loaded plugins and load errors
 
 Options:
-  --json        machine-readable output (list, new, next, alias, doctor, quota, tune, handoff, families, plugins, app,
-                desktop)
+  --json        machine-readable output (list, new, next, alias, doctor, quota, tune, model, remote-control, handoff,
+                families, plugins, app, desktop)
   -h, --help    show this help; \`sideby <command> --help\` for new, alias, login, doctor, families, desktop
   -v, --version show the version
 
@@ -130,6 +134,7 @@ Examples:
   sideby doctor claude:008 --fix
 Exit: 0 when nothing fails (warnings allowed); 1 when a check fails.`,
     desktop: `sideby desktop <account> [--json]
+       sideby desktop grok-bot:<name> [--remove [--yes]] [--json]
 
 Open the host's desktop app as one account: Claude Desktop for claude accounts, the Codex app (ChatGPT.app) for codex
 accounts. Each account gets its own window, side by side with the others; macOS only for now.
@@ -139,14 +144,22 @@ directory (CLAUDE_CONFIG_DIR, CODEX_HOME) and its own app data folder,
 ~/Library/Application Support/sideby/<family>/<name>/. When that account's window is already open, sideby brings it
 to the front instead of starting another one. API accounts are refused: the apps sign in with a subscription only.
 
-sideby never copies or changes the app, and never closes a window. The first time, sign in inside Claude Desktop;
-close other Claude Desktop windows while you do, because the sign-in may come back to one of them.
+Grok Bot signs in with a Cursor account, apart from every account above, so its windows have names of their own:
+grok-bot:<name> opens that window, and makes it first when the name is new (a new window, signed out). grok-bot or
+grok-bot:main is Grok Bot's own default window. --remove deletes a window you made, which signs it out and deletes
+its data on this Mac; it asks for --yes first (exit 10) and refuses while that window is open. \`sideby list\` shows
+the Grok Bot windows.
+
+sideby never copies or changes the app, and never closes a window. The first time, sign in inside the new window;
+close the app's other windows while you do, because the sign-in may come back to one of them.
 
 Examples:
   sideby desktop claude:work
   sideby desktop cc008 --json
-Exit: 0 opened or brought to the front; 1 not macOS, no desktop app for that host, API account, app not installed,
-or the app did not open; 2 malformed command line.`,
+  sideby desktop grok-bot:002
+  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.`,
     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
@@ -179,13 +192,14 @@ const COMMANDS = {
     quota: { flags: ['json', 'yes'] },
     tune: { flags: ['json', 'yes'] },
     model: { flags: ['json', 'yes'], valued: ['effort'] },
+    'remote-control': { flags: ['json', 'yes'] },
     handoff: {
         flags: ['json', 'yes', 'same-family', 'no-same-family'],
         valued: ['brief', 'to', 'order', 'prepare-at', 'threshold', 'wait-minutes', 'countdown'],
     },
     ui: { flags: ['no-open', 'background', 'stop', 'serve-detached'], valued: ['port'] },
     app: { flags: ['json'], valued: ['url'] },
-    desktop: { flags: ['json'] },
+    desktop: { flags: ['json', 'remove', 'yes'] },
     'shell-init': { flags: ['write'] },
     plugins: { flags: ['json'] },
     families: { flags: ['json'] },
@@ -283,6 +297,8 @@ export async function main(argv) {
                 return await cmds.cmdTune(parsed, io);
             case 'model':
                 return await cmds.cmdModel(parsed, io);
+            case 'remote-control':
+                return await cmds.cmdRemoteControl(parsed, io);
             case 'handoff':
                 return await cmds.cmdHandoff(parsed, io);
             case 'ui':

package/dist/src/core/app-profiles.d.ts

@@ -0,0 +1,50 @@
+import { type ProfileAppDef } from '../families/desktop.ts';
+import type { Runtime } from '../runtime.ts';
+import { type DesktopOpenResult } from './desktop-app.ts';
+export interface AppProfileStatus {
+    /** `grok-bot:<name>`; the Main Profile is `grok-bot:main`. */
+    ref: string;
+    /** The app as messages name it, for example `Grok Bot`. */
+    app: string;
+    name: string;
+    isMain: boolean;
+    /** The Profile's app data folder; absent for the Main Profile, which uses the app's default. */
+    appData?: string;
+    installed: boolean;
+    /** That Profile's own window runs now. */
+    running: boolean;
+    /** What the app last wrote about its sign-in; absent when unknown. */
+    signedIn?: boolean;
+}
+export interface AppProfileRemoveResult {
+    ref: string;
+    app: string;
+    appData: string;
+    /** False when only the plan was shown (no `--yes`). */
+    removed: boolean;
+}
+/** The app and Profile name a ref names, or undefined when it is not an App Profile ref. */
+export declare function parseProfileRef(ref: string): {
+    def: ProfileAppDef;
+    name: string;
+} | undefined;
+/** Where the App Profiles of an app live: `~/Library/Application Support/sideby/<app>`. */
+export declare function profilesRoot(home: string, def: ProfileAppDef): string;
+/**
+ * Every App Profile with its state, for `sideby list` and the Panel: only on macOS, and per app only when it is
+ * installed or has Profiles. The Main Profile first. Never throws.
+ */
+export declare function listAppProfiles(rt: Runtime): Promise<AppProfileStatus[]>;
+/**
+ * Opens an App Profile's window, creating its folder first when it is new, or brings its running window to the front.
+ * Never starts a second window for the same Profile and never ends a process.
+ */
+export declare function openAppProfile(rt: Runtime, ref: string): Promise<DesktopOpenResult>;
+/**
+ * Removes a non-main App Profile's folder, which signs that window out and deletes its local data. Without `yes` it
+ * only returns what would go. Refuses the Main Profile, a running window, a missing folder and anything that is not a
+ * real folder inside sideby's own; never follows a link.
+ */
+export declare function removeAppProfile(rt: Runtime, ref: string, opts: {
+    yes: boolean;
+}): Promise<AppProfileRemoveResult>;