sideby 0.12.1 → 0.13.1

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

@@ -3,6 +3,7 @@
 // program sideby runs here (`open`, `ps`, `osascript`, `plutil`, `mdfind`) goes through `DesktopDeps.exec`, so
 // tests never start a real app.
 import { execFile } from 'node:child_process';
+import { readFileSync } from 'node:fs';
 import { chmod, mkdir, readdir, readFile, symlink } from 'node:fs/promises';
 import { basename, join } from 'node:path';
 import { desktopDef, profileAppFor } from '../families/desktop.js';
@@ -28,12 +29,27 @@ const overrides = new WeakMap();
 export function bindDesktopDeps(rt, deps) {
     overrides.set(rt, deps);
 }
+/** This Linux runs under WSL: `WSL_DISTRO_NAME` is set, or the kernel says Microsoft. */
+function isWsl() {
+    if (process.platform !== 'linux')
+        return false;
+    if (process.env.WSL_DISTRO_NAME)
+        return true;
+    try {
+        return /microsoft/i.test(readFileSync('/proc/sys/kernel/osrelease', 'utf8'));
+    }
+    catch {
+        return false;
+    }
+}
 export function depsFor(rt) {
     const o = overrides.get(rt) ?? {};
+    const wslMount = 'platform' in o || 'wslMount' in o ? o.wslMount : isWsl() ? '/mnt' : undefined;
     return {
         platform: o.platform ?? process.platform,
         appDirs: o.appDirs ?? ['/Applications', join(rt.paths.home, 'Applications')],
         exec: o.exec ?? defaultExec,
+        ...(wslMount ? { wslMount } : {}),
     };
 }
 /** The Desktop App of a Family, only when a built-in Plugin provides that Family (a plugin may not claim one). */
@@ -351,7 +367,7 @@ export async function withDesktopApps(rt, accounts, statuses) {
  * Doctor's extra checks for an Account's App Data (spec §3.20): the Desktop App's shared files under `link` rules,
  * only when that Account's App Data folder exists, never for the Main Account (it uses the app's default) or an API
  * Account. Results are named `app-data/<path>` and are not counted in `shared`. The App Data is the repair boundary:
- * a fix may only add a missing link inside it, never replace a real file.
+ * a fix may only add a missing link inside it or sync a file's `key` there, never replace a real file.
  */
 export async function checkAppData(plugins, home, account) {
     if (account.isMain || account.kind === 'api')
@@ -367,13 +383,18 @@ export async function checkAppData(plugins, home, account) {
         const item = { path: f.path, mode: 'link' };
         const mainPath = join(home, f.mainPath);
         const p = join(dir, item.path);
-        const res = await checkItem({ account, item, mainPath, accountPath: p, accountDir: dir, force: false });
+        const ctx = { account, item, mainPath, accountPath: p, accountDir: dir, force: false };
+        let res = await checkItem(ctx);
+        // The Desktop App writes its own file when the Main Account had none at first open, and replaces the link when
+        // it saves its preferences: not the user's doing, and a new link would be replaced again. With a `key`, only
+        // that key has to match the main file; `--fix` syncs it inside the App Data.
+        const own = res.results.some((r) => r.code === 'link.real-file');
+        if (own && f.key)
+            res = await checkItem({ ...ctx, item: { path: f.path, mode: 'json-key', key: f.key } });
         for (const r of res.results) {
             if (r.level === 'ok')
                 continue;
-            // The Desktop App writes its own file when the Main Account had none at first open, and may replace the link
-            // later: not the user's doing, so a warning with the way to share, never a failure and never replaced.
-            const own = r.code === 'link.real-file'
+            const mine = r.code === 'link.real-file'
                 ? {
                     level: 'warn',
                     message: `${item.path} is ${def.title}'s own copy for this account, not a link to the main account's`,
@@ -382,9 +403,9 @@ export async function checkAppData(plugins, home, account) {
                 : {};
             out.push({
                 ...r,
-                ...own,
-                item: `app-data/${item.path}`,
-                message: `${def.title} data: ${own.message ?? r.message}`,
+                ...mine,
+                item: `app-data/${r.item.startsWith(item.path) ? r.item : item.path}`,
+                message: `${def.title} data: ${mine.message ?? r.message}`,
             });
         }
     }

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

@@ -16,6 +16,13 @@ export interface PreparedLaunch {
 export type HostLaunch = Pick<PreparedLaunch, 'family' | 'bin' | 'args' | 'env' | 'title'>;
 /** Finds an executable on PATH; returns null when the Host is not installed. */
 export declare function which(bin: string, env: Env): Promise<string | null>;
+/**
+ * The first PATH entry named `bin` that exists but cannot run, such as a link left dangling by an interrupted
+ * upgrade; null when there is none. Only meaningful when `which` found nothing.
+ */
+export declare function brokenOnPath(bin: string, env: Env): Promise<string | null>;
+/** What to tell a user whose Host cannot run: the install command when the Family has one, else the page. */
+export declare function installHint(family: Pick<FamilyDef, 'installUrl' | 'installCommand'>): string;
 /**
  * Why a Host could not run `sideby` by name, or null when it can: something the Host runs on its own (the status line
  * tap, the handoff hook) needs sideby installed on PATH, not the npx cache, which can disappear. `why` completes

package/dist/src/core/launch.js

@@ -2,7 +2,7 @@ import { spawn } from 'node:child_process';
 import { access, constants } from 'node:fs/promises';
 import { constants as osConstants } from 'node:os';
 import { delimiter, join } from 'node:path';
-import { realpathOrNull } from './fs-safe.js';
+import { lstatOrNull, realpathOrNull } from './fs-safe.js';
 import { readSecretFile } from './secret-file.js';
 /** Finds an executable on PATH; returns null when the Host is not installed. */
 export async function which(bin, env) {
@@ -20,6 +20,26 @@ export async function which(bin, env) {
     }
     return null;
 }
+/**
+ * The first PATH entry named `bin` that exists but cannot run, such as a link left dangling by an interrupted
+ * upgrade; null when there is none. Only meaningful when `which` found nothing.
+ */
+export async function brokenOnPath(bin, env) {
+    for (const dir of (env.PATH ?? '').split(delimiter)) {
+        if (!dir)
+            continue;
+        const p = join(dir, bin);
+        if (await lstatOrNull(p))
+            return p;
+    }
+    return null;
+}
+/** What to tell a user whose Host cannot run: the install command when the Family has one, else the page. */
+export function installHint(family) {
+    return family.installCommand
+        ? `\`${family.installCommand}\` (or see ${family.installUrl})`
+        : family.installUrl;
+}
 /**
  * Why a Host could not run `sideby` by name, or null when it can: something the Host runs on its own (the status line
  * tap, the handoff hook) needs sideby installed on PATH, not the npx cache, which can disappear. `why` completes
@@ -141,7 +161,7 @@ export function spawnHost(p) {
         child.once('error', (err) => {
             cleanup();
             const msg = err.code === 'ENOENT'
-                ? `${p.family.title} is not installed (\`${p.bin}\` not found on PATH); install it: ${p.family.installUrl}`
+                ? `${p.family.title} is not installed (\`${p.bin}\` not found on PATH); install it: ${installHint(p.family)}`
                 : `could not start ${p.bin}: ${err.message}`;
             process.stderr.write(`sideby: ${msg}\n`);
             resolve(1);

package/dist/src/core/leveldb-keys.d.ts

@@ -0,0 +1,14 @@
+/** Files larger than this are skipped and reported. */
+export declare const MAX_LEVELDB_FILE: number;
+/** Snappy raw-format decompression (https://github.com/google/snappy/blob/main/format_description.txt). */
+export declare function snappyDecompress(src: Uint8Array): Uint8Array;
+/**
+ * The Local Storage key names of `origins` (`https://claude.ai`), from a `Local Storage/leveldb` directory. A key
+ * deleted later is left out. `changedAt` is the newest modification time of the files read. Files that are too large
+ * or unreadable go to `problems` (their name only).
+ */
+export declare function localStorageKeys(dir: string, origins: readonly string[]): Promise<{
+    keys: Map<string, Set<string>>;
+    changedAt?: number;
+    problems: string[];
+}>;

package/dist/src/core/leveldb-keys.js

@@ -0,0 +1,291 @@
+// Reads the key names of a Chrome Local Storage LevelDB directory, read-only (spec §3.24, ADR-0023). Only keys are
+// kept: a value's bytes are stepped over and never turned into text, compared or returned. A table block is Snappy
+// compressed as a whole, keys and values together, so it is decompressed into a buffer that is dropped after its keys
+// are taken. Nothing is written, locked or copied; a record cut short (Chrome writing while we read) is skipped.
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+/** Files larger than this are skipped and reported. */
+export const MAX_LEVELDB_FILE = 64 * 1024 * 1024;
+class Cut extends Error {
+}
+function varint(buf, pos) {
+    let result = 0;
+    let shift = 0;
+    for (let i = pos; i < buf.length && shift <= 35; i++) {
+        const b = buf[i];
+        result += (b & 0x7f) * 2 ** shift;
+        if (b < 0x80)
+            return [result, i + 1];
+        shift += 7;
+    }
+    throw new Cut();
+}
+/** Snappy raw-format decompression (https://github.com/google/snappy/blob/main/format_description.txt). */
+export function snappyDecompress(src) {
+    const [len, start] = varint(src, 0);
+    if (len > MAX_LEVELDB_FILE)
+        throw new Cut();
+    const out = new Uint8Array(len);
+    let o = 0;
+    let i = start;
+    while (i < src.length) {
+        const tag = src[i++];
+        const kind = tag & 3;
+        if (kind === 0) {
+            let n = tag >> 2;
+            if (n >= 60) {
+                const extra = n - 59;
+                n = 0;
+                for (let k = 0; k < extra; k++)
+                    n += (src[i + k] ?? 0) * 256 ** k;
+                i += extra;
+            }
+            n += 1;
+            if (i + n > src.length || o + n > len)
+                throw new Cut();
+            out.set(src.subarray(i, i + n), o);
+            i += n;
+            o += n;
+            continue;
+        }
+        let n;
+        let off;
+        if (kind === 1) {
+            n = ((tag >> 2) & 7) + 4;
+            off = ((tag >> 5) << 8) | (src[i++] ?? 0);
+        }
+        else if (kind === 2) {
+            n = (tag >> 2) + 1;
+            off = (src[i] ?? 0) | ((src[i + 1] ?? 0) << 8);
+            i += 2;
+        }
+        else {
+            n = (tag >> 2) + 1;
+            off =
+                ((src[i] ?? 0) | ((src[i + 1] ?? 0) << 8) | ((src[i + 2] ?? 0) << 16)) + (src[i + 3] ?? 0) * 2 ** 24;
+            i += 4;
+        }
+        if (off === 0 || off > o || o + n > len)
+            throw new Cut();
+        for (let k = 0; k < n; k++, o++)
+            out[o] = out[o - off];
+    }
+    if (o !== len)
+        throw new Cut();
+    return out;
+}
+/** A `.log` file: 32 KiB blocks of records that together form WriteBatches. */
+function readLog(buf, sink) {
+    const BLOCK = 32768;
+    const parts = [];
+    let pos = 0;
+    while (pos + 7 <= buf.length) {
+        const left = BLOCK - (pos % BLOCK);
+        if (left < 7) {
+            pos += left;
+            continue;
+        }
+        const len = buf[pos + 4] | (buf[pos + 5] << 8);
+        const type = buf[pos + 6];
+        const data = buf.subarray(pos + 7, pos + 7 + len);
+        pos += 7 + len;
+        if (type === 0 || data.length < len)
+            break;
+        if (type === 1)
+            batch(data, sink);
+        else if (type === 2)
+            parts.splice(0, parts.length, data);
+        else if (type === 3)
+            parts.push(data);
+        else if (type === 4 && parts.length) {
+            parts.push(data);
+            batch(concat(parts), sink);
+            parts.length = 0;
+        }
+    }
+}
+function concat(parts) {
+    const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
+    let o = 0;
+    for (const p of parts) {
+        out.set(p, o);
+        o += p.length;
+    }
+    return out;
+}
+function batch(b, sink) {
+    if (b.length < 12)
+        return;
+    const view = new DataView(b.buffer, b.byteOffset, b.byteLength);
+    let seq = view.getUint32(0, true) + view.getUint32(4, true) * 2 ** 32;
+    const count = view.getUint32(8, true);
+    let pos = 12;
+    try {
+        for (let n = 0; n < count && pos < b.length; n++, seq++) {
+            const tag = b[pos++];
+            const [kl, p1] = varint(b, pos);
+            const key = b.subarray(p1, p1 + kl);
+            pos = p1 + kl;
+            if (pos > b.length)
+                throw new Cut();
+            if (tag === 1) {
+                const [vl, p2] = varint(b, pos);
+                pos = p2 + vl; // the value is stepped over
+                sink(key, seq, true);
+            }
+            else if (tag === 0)
+                sink(key, seq, false);
+            else
+                break;
+        }
+    }
+    catch (e) {
+        if (!(e instanceof Cut))
+            throw e;
+    }
+}
+/** One block of a table: prefix-compressed entries, then the restart array. Calls `each` with key and value range. */
+function blockEntries(block, each) {
+    if (block.length < 4)
+        return;
+    const view = new DataView(block.buffer, block.byteOffset, block.byteLength);
+    const restarts = view.getUint32(block.length - 4, true);
+    const end = block.length - 4 - restarts * 4;
+    if (end < 0)
+        return;
+    let pos = 0;
+    let last = new Uint8Array(0);
+    while (pos < end) {
+        const [shared, p1] = varint(block, pos);
+        const [unshared, p2] = varint(block, p1);
+        const [vlen, p3] = varint(block, p2);
+        if (shared > last.length || p3 + unshared + vlen > end)
+            throw new Cut();
+        const key = new Uint8Array(shared + unshared);
+        key.set(last.subarray(0, shared), 0);
+        key.set(block.subarray(p3, p3 + unshared), shared);
+        each(key, p3 + unshared, p3 + unshared + vlen);
+        last = key;
+        pos = p3 + unshared + vlen;
+    }
+}
+function readBlock(file, offset, size) {
+    if (offset + size + 5 > file.length)
+        throw new Cut();
+    const raw = file.subarray(offset, offset + size);
+    const type = file[offset + size];
+    if (type === 0)
+        return raw;
+    if (type === 1)
+        return snappyDecompress(raw);
+    throw new Cut();
+}
+/** A `.ldb` (or `.sst`) table: footer → index block → data blocks. Only internal keys are taken from data blocks. */
+function readTable(buf, sink) {
+    if (buf.length < 48)
+        return;
+    const footer = buf.subarray(buf.length - 48);
+    const magic = new DataView(footer.buffer, footer.byteOffset + 40, 8);
+    if (magic.getUint32(0, true) !== 0x8b80fb57 || magic.getUint32(4, true) !== 0xdb477524)
+        return;
+    let [, p] = varint(footer, 0) // metaindex offset
+    ;
+    [, p] = varint(footer, p); // metaindex size
+    const [indexOff, p2] = varint(footer, p);
+    const [indexSize] = varint(footer, p2);
+    const index = readBlock(buf, indexOff, indexSize);
+    blockEntries(index, (_key, vs, ve) => {
+        const handle = index.subarray(vs, ve);
+        const [off, q] = varint(handle, 0);
+        const [size] = varint(handle, q);
+        let block;
+        try {
+            block = readBlock(buf, off, size);
+        }
+        catch (e) {
+            if (e instanceof Cut)
+                return;
+            throw e;
+        }
+        blockEntries(block, (ikey) => {
+            if (ikey.length < 8)
+                return;
+            const t = new DataView(ikey.buffer, ikey.byteOffset + ikey.length - 8, 8);
+            const tag = t.getUint32(0, true) + t.getUint32(4, true) * 2 ** 32;
+            sink(ikey.subarray(0, ikey.length - 8), Math.floor(tag / 256), tag % 256 === 1);
+        });
+    });
+}
+const latin1 = new TextDecoder('latin1');
+const utf16 = new TextDecoder('utf-16le');
+/**
+ * The Local Storage key names of `origins` (`https://claude.ai`), from a `Local Storage/leveldb` directory. A key
+ * deleted later is left out. `changedAt` is the newest modification time of the files read. Files that are too large
+ * or unreadable go to `problems` (their name only).
+ */
+export async function localStorageKeys(dir, origins) {
+    const problems = [];
+    const keys = new Map(origins.map((o) => [o, new Set()]));
+    let names;
+    try {
+        names = await readdir(dir);
+    }
+    catch {
+        return { keys, problems };
+    }
+    const prefixes = origins.map((o) => Buffer.from(`_${o}\u0000`, 'latin1'));
+    const states = new Map();
+    const sink = (key, seq, live) => {
+        const i = prefixes.findIndex((p) => key.length > p.length && Buffer.from(key.subarray(0, p.length)).equals(p));
+        if (i < 0)
+            return;
+        const prefix = prefixes[i];
+        const enc = key[prefix.length];
+        const body = key.subarray(prefix.length + 1);
+        const name = enc === 1 ? latin1.decode(body) : enc === 0 ? utf16.decode(body) : undefined;
+        if (name === undefined)
+            return;
+        const id = `${i}\u0000${name}`;
+        const prev = states.get(id);
+        if (!prev || seq >= prev.seq)
+            states.set(id, { origin: origins[i], name, seq, live });
+    };
+    let changedAt;
+    for (const name of names.sort()) {
+        const table = name.endsWith('.ldb') || name.endsWith('.sst');
+        if (!table && !name.endsWith('.log'))
+            continue;
+        const file = join(dir, name);
+        try {
+            const st = await stat(file);
+            if (!st.isFile())
+                continue;
+            if (st.size > MAX_LEVELDB_FILE) {
+                problems.push(`${name} is larger than 64 MB and was skipped`);
+                continue;
+            }
+            changedAt = Math.max(changedAt ?? 0, st.mtimeMs);
+            const buf = new Uint8Array(await readFile(file));
+            try {
+                if (table)
+                    readTable(buf, sink);
+                else
+                    readLog(buf, sink);
+            }
+            catch (e) {
+                if (!(e instanceof Cut))
+                    throw e;
+                problems.push(`${name} could not be read completely`);
+            }
+        }
+        catch (e) {
+            if (e instanceof Cut)
+                continue;
+            problems.push(`${name} could not be read`);
+        }
+    }
+    for (const s of states.values())
+        if (s.live)
+            keys.get(s.origin)?.add(s.name);
+    return { keys, ...(changedAt === undefined ? {} : { changedAt }), problems };
+}

package/dist/src/core/remote-control.d.ts

@@ -13,13 +13,15 @@ export interface RemoteControlGroup {
     state: RemoteControlState;
     /** For `blocked` and `missing`: why, and what to do. */
     reason?: string;
-    /** sideby turned it off here and can put the earlier value back. */
+    /** sideby set it here and can put the earlier value back. */
     undo: boolean;
 }
 export interface RemoteControlUndoRecord {
     file: string;
-    /** The value before sideby wrote `false`, or null when the key was not there. */
+    /** The value before sideby wrote, or null when the key was not there. */
     previous: boolean | null;
+    /** The value sideby wrote; records from before `on` existed lack it and mean `false`. */
+    wrote?: boolean;
     at: string;
 }
 export interface RemoteControlChange {
@@ -37,9 +39,18 @@ export interface RemoteControlChange {
 export declare function remoteControlGroups(accounts: readonly Account[], ctx: ReadContext): Promise<RemoteControlGroup[]>;
 /** The groups `off` would change: those that are on, or follow a default that may be on. */
 export declare function groupsToTurnOff(groups: readonly RemoteControlGroup[]): RemoteControlGroup[];
-/** Sets `remoteControlAtStartup` to false in every group that is on or follows the default, remembering each old value. */
-export declare function turnRemoteControlOff(accounts: readonly Account[], ctx: ReadContext): Promise<RemoteControlChange>;
-/** Groups sideby can put back: it wrote `false` there and the key still holds it. */
+/** The groups `on` would change: those that are off, or follow a default that may be off. */
+export declare function groupsToTurnOn(groups: readonly RemoteControlGroup[]): RemoteControlGroup[];
+/**
+ * Sets `remoteControlAtStartup` to `to` in every group that does not hold it yet (a default counts as either),
+ * remembering each old value for undo.
+ */
+export declare function setRemoteControl(accounts: readonly Account[], ctx: ReadContext, to: boolean): Promise<RemoteControlChange>;
+/** Sets `remoteControlAtStartup` to false in every group that is on or follows the default. */
+export declare const turnRemoteControlOff: (accounts: readonly Account[], ctx: ReadContext) => Promise<RemoteControlChange>;
+/** Sets `remoteControlAtStartup` to true in every group that is off or follows the default. */
+export declare const turnRemoteControlOn: (accounts: readonly Account[], ctx: ReadContext) => Promise<RemoteControlChange>;
+/** Groups sideby can put back: it wrote there and the key still holds what it wrote. */
 export declare function groupsToUndo(groups: readonly RemoteControlGroup[]): RemoteControlGroup[];
-/** Puts back what each file had before `off`, only while the key is still `false`. */
+/** Puts back what each file had before `on` or `off`, only while the key still holds what sideby wrote. */
 export declare function undoRemoteControlOff(accounts: readonly Account[], ctx: ReadContext): Promise<RemoteControlChange>;

package/dist/src/core/remote-control.js

@@ -1,4 +1,4 @@
-// Remote Control off by default (spec §3.22, ADR-0017): reads and writes one key, `remoteControlAtStartup`, of each
+// Remote Control at startup (spec §3.22, ADR-0017): reads and writes one key, `remoteControlAtStartup`, of each
 // Claude Account's `settings.json`. Accounts that share a file (a link to the Main Account's) form one group and one
 // write. Nothing but that key is ever read out of the file into an output, an error or the undo record; writes go
 // through `writeIfUnchanged`, keep every other key, and never create, replace or retarget a link.
@@ -60,7 +60,8 @@ export async function remoteControlGroups(accounts, ctx) {
             }
             else {
                 group.state = stateOf(read.obj[RC_KEY]);
-                group.undo = group.state === 'off' && (await readRecord(ctx, where.file)) !== null;
+                const record = await readRecord(ctx, where.file);
+                group.undo = record !== null && read.obj[RC_KEY] === (record.wrote ?? false);
             }
         }
     }
@@ -70,6 +71,10 @@ export async function remoteControlGroups(accounts, ctx) {
 export function groupsToTurnOff(groups) {
     return groups.filter((g) => g.state === 'on' || g.state === 'default');
 }
+/** The groups `on` would change: those that are off, or follow a default that may be off. */
+export function groupsToTurnOn(groups) {
+    return groups.filter((g) => g.state === 'off' || g.state === 'default');
+}
 async function writeKey(file, change, expect) {
     const read = await readObject(file);
     if ('error' in read)
@@ -81,18 +86,23 @@ async function writeKey(file, change, expect) {
     const wrote = await writeIfUnchanged(file, sha256(read.text), render(change({ ...read.obj }), read.text), mode);
     return wrote ? null : 'settings.json changed while sideby was writing, so nothing was changed. Try again.';
 }
-/** Sets `remoteControlAtStartup` to false in every group that is on or follows the default, remembering each old value. */
-export async function turnRemoteControlOff(accounts, ctx) {
+/**
+ * Sets `remoteControlAtStartup` to `to` in every group that does not hold it yet (a default counts as either),
+ * remembering each old value for undo.
+ */
+export async function setRemoteControl(accounts, ctx, to) {
     const groups = await remoteControlGroups(accounts, ctx);
-    const todo = groupsToTurnOff(groups);
+    const todo = to ? groupsToTurnOn(groups) : groupsToTurnOff(groups);
     if (todo.length === 0) {
-        const stuck = groups.find((g) => g.state === 'blocked');
+        const stuck = groups.find((g) => g.state === 'blocked' || (to && g.state === 'missing'));
         return stuck
             ? { ok: false, results: [], message: `Nothing was changed: ${stuck.reason}` }
             : {
                 ok: true,
                 results: [],
-                message: 'Remote Control already does not start by itself; nothing changed.',
+                message: to
+                    ? 'Remote Control already starts by itself; nothing changed.'
+                    : 'Remote Control already does not start by itself; nothing changed.',
             };
     }
     const results = [];
@@ -100,32 +110,43 @@ export async function turnRemoteControlOff(accounts, ctx) {
         let previous = null;
         const failed = await writeKey(g.file, (obj) => {
             previous = typeof obj[RC_KEY] === 'boolean' ? obj[RC_KEY] : null;
-            obj[RC_KEY] = false;
+            obj[RC_KEY] = to;
             return obj;
-        }, (obj) => (obj[RC_KEY] === false ? 'It was turned off meanwhile; nothing changed.' : null));
+        }, (obj) => (obj[RC_KEY] === to ? `It was turned ${to ? 'on' : 'off'} meanwhile; nothing changed.` : null));
         if (failed) {
             results.push({ file: g.file, accounts: g.accounts, ok: false, message: failed });
             continue;
         }
-        const record = { file: g.file, previous, at: new Date().toISOString() };
+        const record = {
+            file: g.file,
+            previous,
+            wrote: to,
+            at: new Date().toISOString(),
+        };
         await mkdir(join(ctx.stateDir, 'remote-control'), { recursive: true });
         await writeFileAtomic(recordPath(ctx, g.file), `${JSON.stringify(record, null, 2)}\n`, 0o600);
-        results.push({ file: g.file, accounts: g.accounts, ok: true, message: 'Turned off.' });
+        results.push({ file: g.file, accounts: g.accounts, ok: true, message: to ? 'Turned on.' : 'Turned off.' });
     }
     const ok = results.every((r) => r.ok);
     return {
         ok,
         results,
-        message: ok
-            ? 'Done. New sessions no longer connect to claude.ai by themselves; restart sessions that are already running. You can still start it in a session with /remote-control.'
-            : 'Some files could not be changed; see each line.',
+        message: !ok
+            ? 'Some files could not be changed; see each line.'
+            : to
+                ? 'Done. New sessions connect to claude.ai and the Claude app by themselves, where every device signed in to that account can read them; restart sessions that are already running.'
+                : 'Done. New sessions no longer connect to claude.ai by themselves; restart sessions that are already running. You can still start it in a session with /remote-control.',
     };
 }
-/** Groups sideby can put back: it wrote `false` there and the key still holds it. */
+/** Sets `remoteControlAtStartup` to false in every group that is on or follows the default. */
+export const turnRemoteControlOff = (accounts, ctx) => setRemoteControl(accounts, ctx, false);
+/** Sets `remoteControlAtStartup` to true in every group that is off or follows the default. */
+export const turnRemoteControlOn = (accounts, ctx) => setRemoteControl(accounts, ctx, true);
+/** Groups sideby can put back: it wrote there and the key still holds what it wrote. */
 export function groupsToUndo(groups) {
     return groups.filter((g) => g.undo);
 }
-/** Puts back what each file had before `off`, only while the key is still `false`. */
+/** Puts back what each file had before `on` or `off`, only while the key still holds what sideby wrote. */
 export async function undoRemoteControlOff(accounts, ctx) {
     const todo = groupsToUndo(await remoteControlGroups(accounts, ctx));
     if (todo.length === 0)
@@ -141,7 +162,9 @@ export async function undoRemoteControlOff(accounts, ctx) {
             else
                 obj[RC_KEY] = record.previous;
             return obj;
-        }, (obj) => obj[RC_KEY] === false ? null : 'The setting was changed after sideby set it, so it was left alone.');
+        }, (obj) => obj[RC_KEY] === (record.wrote ?? false)
+            ? null
+            : 'The setting was changed after sideby set it, so it was left alone.');
         if (!failed)
             await rm(recordPath(ctx, g.file), { force: true });
         results.push({ file: g.file, accounts: g.accounts, ok: !failed, message: failed ?? 'Put back.' });

package/dist/src/core/skill-check.d.ts

@@ -2,6 +2,19 @@ import type { FamilyDef, Finding } from '../types.ts';
 export declare const SKILL_INSTALL = "npx skills add Adonis0123/sideby -g";
 /** `metadata.version` from a SKILL.md frontmatter, or null when there is none. */
 export declare function skillVersionOf(text: string): string | null;
+/**
+ * The versions of the sideby skills an agent reads on this machine (`null`: a skill without one): where
+ * `npx skills add -g` puts it (`~/.agents/skills`) and Claude Code's user skills. Read for a `--json` output's
+ * `_notice`, so it looks at two fixed files only; Doctor checks every Family's main directory.
+ */
+export declare function installedSkillVersions(home: string): Promise<(string | null)[]>;
+/** The same skills with the real folder each lives in (for `sideby update`, which may update them). */
+export declare function installedSkills(home: string): Promise<{
+    dir: string;
+    version: string | null;
+}[]>;
+/** The command `sideby update` runs to update an installed sideby skill: it keeps the agents it was installed for. */
+export declare const SKILL_UPDATE: readonly ['npx', '-y', 'skills', 'update', 'sideby', '-g', '-y'];
 /**
  * Checks, for each given Family, the sideby skill its Host reads: `<main>/skills/sideby`, and for Codex also
  * `~/.agents/skills/sideby` (where `npx skills add -g` installs and Codex reads user skills). A file is read