windows-development-sandbox 1.4.3 → 1.7.0

package/dist/cli/commands/projects/here.js

@@ -3,27 +3,40 @@
 // folder a project of the running sandbox when it can without a restart (launch, start, exec, db).
 import path from 'node:path';
 import { select } from '@inquirer/prompts';
-import { describeMissing, missingTip } from '../../../core/local-config/index.js';
+import { describeMissing, missingTip, protectionsOf } from '../../../core/local-config/index.js';
 import { askYesNo } from '../../../core/prompt.js';
-import { isInsideOrEqual } from '../../../core/util/index.js';
+import { fail, isInsideOrEqual } from '../../../core/util/index.js';
+import { ownerName } from '../../../host/sharing/index.js';
 import { resolveRun } from '../../../core/run/index.js';
 import { SandboxChannel } from '../../../host/channel/index.js';
-import { ProjectRegistry, joinRunning } from '../../../host/projects/index.js';
+import { BorrowedRegistry, ProjectRegistry, joinRunning, runningRegistry, } from '../../../host/projects/index.js';
 import { c, working } from '../../output/index.js';
 import { describeSessions } from './describe-sessions.js';
 import { guestPathFor } from '../context.js';
+/** The running sandbox's projects: this user's registry, or the record of the user who shares theirs. */
+export function registryOf(ctx) {
+    return ctx.borrowed ? new BorrowedRegistry(ctx.borrowed.record) : new ProjectRegistry(ctx.storageRoot);
+}
 /** The folder the command is about: --workspace, else the current one. */
 export function hereDir(ctx) {
     return path.resolve(ctx.options.workspace ?? process.cwd());
 }
+/**
+ * Your running sandbox's registry, rebuilt from its launch folder when the file is missing, unreadable or an earlier
+ * sandbox's (another copy or version of this tool started it). null only for a sandbox without one at all.
+ */
+function ownRegistry(ctx) {
+    return runningRegistry(ctx.storageRoot, ctx.dataPath, protectionsOf(ctx.loaded.config));
+}
 /** Where this folder is in the running sandbox, if it is in it at all (nothing is registered). */
 export function locateHere(ctx, status) {
     const dir = hereDir(ctx);
-    const here = new ProjectRegistry(ctx.storageRoot).here(dir);
+    const own = ctx.borrowed ? null : ownRegistry(ctx);
+    const here = registryOf(ctx).here(dir);
     if (here)
         return here;
     // A sandbox started before projects existed: only its launch folder.
-    if (!new ProjectRegistry(ctx.storageRoot).read() && status && isInsideOrEqual(status.workspaceHost, dir))
+    if (!ctx.borrowed && !own && status && isInsideOrEqual(status.workspaceHost, dir))
         return { project: null, guestDir: guestPathFor(dir, status.workspaceHost, status.guestWorkspace) };
     return { project: null, guestDir: null };
 }
@@ -40,8 +53,16 @@ export function markRestarted() {
 export async function joinHere(ctx, status, o = {}) {
     const { options, loaded, packageRoot, storageRoot, dataPath } = ctx;
     const dir = hereDir(ctx);
+    // Another user's sandbox: only the projects it already has; nothing joins it, nothing restarts it.
+    if (ctx.borrowed) {
+        const user = ownerName(ctx.borrowed.user);
+        const known = registryOf(ctx).here(dir);
+        if (!known)
+            fail(dir + ' is not one of the folders in ' + user + "'s sandbox.", 'Run it from a folder that sandbox has (sandbox status lists them), or ask ' + user + ' to add this one.');
+        return { project: known.project, guestDir: known.guestDir, spec: null, harness: null, notes: [] };
+    }
     // A sandbox started before projects existed: only its launch folder (guestPathFor explains why otherwise).
-    if (!new ProjectRegistry(storageRoot).read())
+    if (!ownRegistry(ctx))
         return {
             project: null,
             guestDir: guestPathFor(dir, status.workspaceHost, status.guestWorkspace),
@@ -94,12 +115,13 @@ export async function joinHere(ctx, status, o = {}) {
             console.log(c.yellow(describeMissing(name, missing)));
             shown = true;
             const sessions = new SandboxChannel(dataPath).currentSessions();
-            const ending = sessions.length ? describeSessions(sessions) + ' will end' : 'no session is running';
+            if (sessions.length)
+                console.log(describeSessions(sessions) + ' will be reopened after the restart.');
             return select({
                 message: 'What now?',
                 choices: [
-                    { name: 'Continue anyway (join without them)', value: 'continue' },
-                    { name: 'Restart with them (' + ending + ')', value: 'restart' },
+                    { name: 'Restart with them (sessions reopen and continue)', value: 'restart' },
+                    { name: 'Continue without them', value: 'continue' },
                     { name: 'Cancel', value: 'cancel' },
                 ],
                 default: 'continue',

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

@@ -1,14 +1,2 @@
 import { type Context } from '../context.js';
-interface Row {
-    readonly folder: string;
-    readonly here: boolean;
-    readonly known: boolean;
-    readonly root: string | null;
-    readonly excluded: boolean;
-    readonly mappedAtStart: boolean;
-    readonly running: string | null;
-}
-/** Every project worth listing: known ones, the running sandbox's, and this folder. */
-export declare function projectRows(ctx: Context): Row[];
 export declare function projects(ctx: Context): Promise<number>;
-export {};

package/dist/cli/commands/projects/projects.js

@@ -1,73 +1,31 @@
 // `sandbox projects`: which projects a sandbox can open without a restart. Project roots (whole folders of projects),
-// the projects this tool has started before, and projects.all / projects.exclude. Changes to what is mapped take
+// the projects this tool has started before, and the all-projects and exclude settings. Changes to what is mapped take
 // effect at the next start; a project you start while a sandbox runs joins it when it can (projects.ts in host/).
 import path from 'node:path';
 import { checkbox } from '@inquirer/prompts';
-import { assertSafeMapping, assertSafeWorkspace } from '../../../core/safe-paths.js';
-import { dirExists, expandPath, fail, isRootPath } from '../../../core/util/index.js';
+import { askChoice } from '../../../core/prompt.js';
+import { fail } from '../../../core/util/index.js';
 import { isSandboxRunning } from '../../../host/sandbox/index.js';
-import { KnownProjects, projectMapper, ProjectRegistry } from '../../../host/projects/index.js';
-import { isWithin } from '../../../shared/paths/index.js';
-import { c, pageSizeFor, shortenMiddle, termWidth, printJson, table } from '../../output/index.js';
-import { hereDir } from './here.js';
-import { addToList, removeFromList, setSetting } from '../user-config.js';
-function settings(ctx) {
-    const p = ctx.loaded.config.projects;
-    const expand = (list) => list.map((x) => expandPath(x, ctx.loaded.base));
-    return { all: p.all, roots: expand(p.roots), exclude: expand(p.exclude) };
-}
-/** Every project worth listing: known ones, the running sandbox's, and this folder. */
-export function projectRows(ctx) {
-    const s = settings(ctx);
-    const registry = isSandboxRunning() ? new ProjectRegistry(ctx.storageRoot).read() : null;
-    const here = hereDir(ctx);
-    const known = new KnownProjects(ctx.storageRoot).list();
-    const folders = [...known.map((k) => k.host), ...(registry?.projects.map((p) => p.host) ?? [])];
-    const unique = folders.filter((f, i) => folders.findIndex((g) => g.toLowerCase() === f.toLowerCase()) === i);
-    return unique.map((folder) => {
-        const root = s.roots.find((r) => isWithin(r, folder)) ?? null;
-        const excluded = s.exclude.some((e) => isWithin(e, folder));
-        const inSandbox = registry?.projects.find((p) => p.host.toLowerCase() === folder.toLowerCase());
-        return {
-            folder,
-            here: isWithin(folder, here),
-            known: known.some((k) => k.host.toLowerCase() === folder.toLowerCase()),
-            root,
-            excluded,
-            mappedAtStart: root !== null || (s.all && !excluded && dirExists(folder)),
-            running: inSandbox ? inSandbox.name + ' (' + inSandbox.mechanism + ')' : null,
-        };
-    });
-}
+import { c, nextStep, pageSizeFor, shortenMiddle, termWidth, printJson, table } from '../../output/index.js';
+import { ProjectsService } from '../../services/index.js';
 const NEXT_START = 'This changes what is mapped from the next start.';
 function runningNote() {
     return isSandboxRunning()
         ? ' The running sandbox keeps what it has; start a project in it (sandbox claude there) and it joins without a restart when it can, or you are offered one.'
         : '';
 }
-/** A folder for roots: it holds projects, so it must pass the same checks as a workspace and must not be a drive. */
-function checkFolder(ctx, folder, what) {
-    const dir = path.resolve(folder);
-    if (!dirExists(dir))
-        fail('The folder ' + dir + ' does not exist.', 'Check the path.');
-    if (isRootPath(dir))
-        fail('A whole drive cannot be ' + what + ': ' + dir, 'Use the folder that holds your projects, e.g. F:\\Code.');
-    assertSafeWorkspace(dir, ctx.packageRoot, ctx.storageRoot);
-    assertSafeMapping(dir, ctx.packageRoot, ctx.storageRoot);
-    return dir;
-}
-function list(ctx) {
-    const rows = projectRows(ctx);
-    const s = settings(ctx);
-    if (printJson(ctx, { all: s.all, roots: s.roots, exclude: s.exclude, projects: rows }))
+function list(ctx, service) {
+    const listing = service.list();
+    const rows = listing.projects;
+    if (printJson(ctx, { all: listing.all, roots: listing.roots, exclude: listing.exclude, projects: rows }))
         return 0;
-    console.log(c.bold('projects.all') +
+    console.log(c.bold('All projects') +
         ': ' +
-        (s.all ? 'on (every project below is mapped at every start, except excluded ones)' : 'off') +
+        (listing.all ? 'on (every project below is mapped at every start, except excluded ones)' : 'off') +
         c.dim('   sandbox projects all on|off'));
     console.log(c.bold('Roots') +
         ': ' +
-        (s.roots.length ? s.roots.join(', ') : c.dim('none (sandbox projects roots add <folder>)')));
+        (listing.roots.length ? listing.roots.join(', ') : c.dim('none (sandbox projects roots add <folder>)')));
     if (!rows.length) {
         console.log('No projects yet: start one with sandbox claude in its folder.');
         return 0;
@@ -85,79 +43,72 @@ function list(ctx) {
     console.log(c.dim('* = this folder.  Choose with: sandbox projects choose'));
     return 0;
 }
-/** Ticks the projects mapped at every start (turns projects.all on when any is ticked); the rest are excluded. */
-async function choose(ctx) {
-    const rows = projectRows(ctx).filter((r) => !r.root);
+/** Ticks the projects mapped at every start (any ticked turns all-projects on); the rest are excluded. */
+async function choose(service) {
+    const rows = service.rows().filter((r) => !r.root);
     if (!rows.length) {
         console.log('No projects to choose from yet (projects in a root are always mapped with it). Start one with sandbox claude in its folder.');
         return 0;
     }
     if (!process.stdin.isTTY)
         fail('sandbox projects choose needs an interactive terminal.', 'Use sandbox projects include|exclude <folder> instead.');
-    const s = settings(ctx);
+    const all = service.settings().all;
     const picked = await checkbox({
         message: 'Projects mapped at every start, so they open without a restart (every agent in the sandbox can see them):',
         pageSize: pageSizeFor(rows.length),
         choices: rows.map((r) => ({
             value: r.folder,
             name: shortenMiddle(r.folder, termWidth() - 12) + (r.here ? c.dim('  (this folder)') : ''),
-            checked: s.all && !r.excluded,
+            checked: all && !r.excluded,
         })),
     });
-    const exclude = rows.filter((r) => !picked.includes(r.folder)).map((r) => r.folder);
-    setSetting(ctx, ['projects', 'exclude'], [...s.exclude.filter((e) => !rows.some((r) => r.folder.toLowerCase() === e.toLowerCase())), ...exclude]);
-    setSetting(ctx, ['projects', 'all'], picked.length > 0);
-    console.log(picked.length + ' project(s) mapped at every start, ' + exclude.length + ' excluded. ' + NEXT_START + runningNote());
+    const { mapped, excluded } = service.choose(rows, picked);
+    console.log(mapped + ' project(s) mapped at every start, ' + excluded + ' excluded. ' + NEXT_START + runningNote());
     return 0;
 }
-function add(ctx, value) {
-    const dir = checkFolder(ctx, value, 'a project');
-    new KnownProjects(ctx.storageRoot).remember(dir);
-    console.log('Added ' +
-        dir +
-        ' to your projects.' +
-        (settings(ctx).all
-            ? ' ' + NEXT_START
-            : ' It is mapped at every start once projects.all is on (sandbox projects all on).'));
+/** The folder typed, or one picked from the known projects (or this folder) when it was left out. */
+async function folderOf(service, action, given) {
+    if (given)
+        return given;
+    const rows = service.rows();
+    return askChoice('Which folder?', [
+        { name: 'This folder (' + shortenMiddle(process.cwd(), termWidth() - 30) + ')', value: '.' },
+        ...rows.filter((r) => !r.here).map((r) => ({ name: shortenMiddle(r.folder, termWidth() - 12), value: r.folder })),
+    ], 'Usage: sandbox projects ' + action + ' <folder>   (. = this folder)');
+}
+function add(service, value) {
+    const dir = service.add(value);
+    const all = service.settings().all;
+    console.log('Added ' + dir + ' to your projects.' + (all ? ' ' + NEXT_START : ''));
+    if (!all)
+        nextStep('sandbox projects all on   (map every project at every start)');
     return 0;
 }
-function remove(ctx, value) {
-    const dir = path.resolve(value);
-    const forgot = new KnownProjects(ctx.storageRoot).forget(dir);
-    // The running sandbox forgets it too (its folder stays visible until the sandbox stops, if it was mapped).
-    const registered = isSandboxRunning()
-        ? new ProjectRegistry(ctx.storageRoot)
-            .read()
-            ?.projects.find((p) => !p.primary && p.host.toLowerCase() === dir.toLowerCase())
-        : undefined;
-    if (registered)
-        projectMapper({ storageRoot: ctx.storageRoot, packageRoot: ctx.packageRoot, wsbShare: false }).unregister(registered.name);
-    console.log(forgot || registered
+function remove(service, value) {
+    const { dir, removed } = service.forget(value);
+    console.log(removed
         ? 'Removed ' + dir + ' from your projects (nothing in the folder was touched).'
         : dir + ' was not in your projects.');
     return 0;
 }
-function includeOrExclude(ctx, action, value) {
-    const dir = path.resolve(value);
-    const changed = action === 'exclude'
-        ? addToList(ctx, ['projects', 'exclude'], dir)
-        : removeFromList(ctx, ['projects', 'exclude'], dir);
-    if (action === 'include')
-        new KnownProjects(ctx.storageRoot).remember(dir);
-    console.log((changed ? (action === 'exclude' ? 'Excluded ' : 'Included ') + dir + '. ' + NEXT_START : 'Nothing changed.') +
-        (action === 'include' && !settings(ctx).all
-            ? ' projects.all is off: sandbox projects all on maps your projects at every start.'
+function includeOrExclude(service, action, value) {
+    const changed = action === 'exclude' ? service.exclude(value) : service.include(value);
+    console.log((changed
+        ? (action === 'exclude' ? 'Excluded ' : 'Included ') + path.resolve(value) + '. ' + NEXT_START
+        : 'Nothing changed.') +
+        (action === 'include' && !service.settings().all
+            ? ' Mapping all projects is off: sandbox projects all on maps your projects at every start.'
             : '') +
         (changed ? runningNote() : ''));
     return 0;
 }
-function all(ctx, value) {
+function all(service, value) {
     if (value === undefined) {
-        console.log('projects.all is ' + (settings(ctx).all ? 'on' : 'off') + '.');
+        console.log('Mapping all projects at every start is ' + (service.settings().all ? 'on' : 'off') + '.');
         return 0;
     }
-    setSetting(ctx, ['projects', 'all'], value === 'on');
-    console.log('projects.all is ' +
+    service.setAll(value === 'on');
+    console.log('Mapping all projects at every start is ' +
         value +
         '. ' +
         NEXT_START +
@@ -165,15 +116,14 @@ function all(ctx, value) {
         runningNote());
     return 0;
 }
-function roots(ctx, value, folder) {
+function roots(service, value, folder) {
     if (!value || value === 'list') {
-        const list = settings(ctx).roots;
+        const list = service.settings().roots;
         console.log(list.length ? list.join('\n') : 'No project roots. Add one: sandbox projects roots add <folder>');
         return 0;
     }
     if (value === 'add') {
-        const dir = checkFolder(ctx, folder, 'a project root');
-        const added = addToList(ctx, ['projects', 'roots'], dir);
+        const { dir, added } = service.addRoot(folder);
         console.log(added
             ? 'Added the project root ' +
                 dir +
@@ -183,31 +133,30 @@ function roots(ctx, value, folder) {
             : dir + ' is a root already.');
         return 0;
     }
-    const dir = path.resolve(folder);
-    console.log(removeFromList(ctx, ['projects', 'roots'], dir)
-        ? 'Removed the project root ' + dir + '. ' + NEXT_START
-        : dir + ' was not a root.');
+    const { dir, removed } = service.removeRoot(folder);
+    console.log(removed ? 'Removed the project root ' + dir + '. ' + NEXT_START : dir + ' was not a root.');
     return 0;
 }
 export async function projects(ctx) {
     const [action = 'list', value, folder] = ctx.options.positionals;
+    const service = new ProjectsService(ctx);
     switch (action) {
         case 'list':
-            return list(ctx);
+            return list(ctx, service);
         case 'choose':
-            return choose(ctx);
+            return choose(service);
         case 'add':
-            return add(ctx, value);
+            return add(service, await folderOf(service, action, value));
         case 'remove':
-            return remove(ctx, value);
+            return remove(service, await folderOf(service, action, value));
         case 'include':
         case 'exclude':
-            return includeOrExclude(ctx, action, value);
+            return includeOrExclude(service, action, await folderOf(service, action, value));
         case 'all':
-            return all(ctx, value);
+            return all(service, value);
         case 'roots':
-            return roots(ctx, value, folder);
+            return roots(service, value, folder);
         default:
-            return fail('Unknown projects action "' + action + '".');
+            return fail('Unknown projects action "' + action + '".', 'Use: sandbox projects list | choose | add | remove | include | exclude | all | roots');
     }
 }

package/dist/cli/commands/projects/restart.d.ts

@@ -1,15 +1,5 @@
-import type { SandboxStatus } from '../../../core/types.js';
 import { type NeedsRestart } from '../../../host/projects/index.js';
 import type { Context } from '../context.js';
-import type { LaunchExtras, OpenSessionOptions } from '../launch/index.js';
-import { type Joined } from './here.js';
-/** What a restart needs from launch (launch imports this file, so it is handed in rather than imported). */
-export interface Relauncher {
-    launch(ctx: Context, generateOnly: boolean, extras: LaunchExtras): Promise<number>;
-    readySandbox(dataPath: string): Promise<SandboxStatus>;
-    joinHere(ctx: Context, status: SandboxStatus, o?: {
-        noRestart?: boolean;
-    }): Promise<Joined>;
-    openSession(ctx: Context, ready: SandboxStatus, joined: Joined, o: OpenSessionOptions): Promise<number>;
-}
+import { type Relauncher } from '../sessions/reopen.js';
+export type { Relauncher };
 export declare function offerRestart(ctx: Context, needs: NeedsRestart[], then: () => Promise<number>, relauncher: Relauncher): Promise<number>;

package/dist/cli/commands/projects/restart.js

@@ -11,10 +11,11 @@ import { fail, sleep } from '../../../core/util/index.js';
 import { SandboxChannel } from '../../../host/channel/index.js';
 import { isSandboxRunning } from '../../../host/sandbox/index.js';
 import { ProjectRegistry } from '../../../host/projects/index.js';
-import { hostDirFor, projectForGuestDir } from '../../../shared/paths/index.js';
 import { RunDir } from '../../../shared/channel/index.js';
+import { SessionLedger } from '../../../host/life/index.js';
 import { watcherRunning } from '../../../sync/index.js';
 import { c, working } from '../../output/index.js';
+import { freshContext, reopenedText, reopenSessions, sessionsToReopen } from '../sessions/reopen.js';
 import { markRestarted } from './here.js';
 import { describeSessions } from './describe-sessions.js';
 /** The command to run again with consent, for a non-interactive terminal. */
@@ -24,16 +25,11 @@ function againWithYes(ctx) {
         (ctx.options.terminal ? ' -t' : '') +
         ' --yes');
 }
-/** Where each running session is on this PC, so it can be reopened after the restart. */
-function sessionsToReopen(registry, sessions) {
-    return sessions.flatMap((s) => {
-        const project = projectForGuestDir([...registry.projects, ...registry.roots.map((r) => ({ ...r }))], s.cwd);
-        return project ? [{ harness: s.harness, hostDir: hostDirFor(project, s.cwd) }] : [];
-    });
-}
 /** Shuts the sandbox down and waits until it (and the background sync's final pass) is gone. */
 async function stopAndWait(ctx) {
     const status = new RunDir(ctx.dataPath).readSandboxStatus();
+    // Stopped on purpose, not a crash: the watcher must not start it again by itself.
+    new SessionLedger(ctx.storageRoot, ctx.dataPath).markClosedOnPurpose();
     await working('Stopping the sandbox (history syncs back)', async () => {
         await new SandboxChannel(ctx.dataPath)
             .exec(['C:\\Windows\\System32\\shutdown.exe', '/s', '/t', '0'], status?.guestWorkspace ?? 'C:\\', 30)
@@ -47,22 +43,6 @@ async function stopAndWait(ctx) {
             await sleep(1000);
     });
 }
-/** The same command for another folder, as a plain new session (nothing attached, no agent arguments). */
-function freshContext(ctx, workspace, harness, more = {}) {
-    return {
-        ...ctx,
-        options: {
-            ...ctx.options,
-            workspace,
-            harness,
-            terminal: false,
-            newSession: true,
-            passthrough: [],
-            sessions: [],
-            ...more,
-        },
-    };
-}
 /**
  * Says what a restart maps, keeps and ends. `hidden`: the folders the running sandbox cannot show; a project that only
  * wants boot settings or folders is not among them (you already chose the restart, or gave --yes, when asked).
@@ -76,7 +56,7 @@ function explain(needs, hidden, registry, sessions) {
         ' (and keeps ' +
         registry.projects.map((p) => p.host).join(', ') +
         '). ' +
-        (sessions.length ? describeSessions(sessions) + ' will end' : 'No session is running') +
+        (sessions.length ? describeSessions(sessions) + ' will end and reopen afterwards' : 'No session is running') +
         '; your files, tools, databases and logins are kept. It takes about a minute.');
     for (const parent of _.uniq(hidden.map((n) => path.dirname(n.hostDir))))
         console.log(c.dim('No restart next time for folders in ' + parent + ': sandbox projects roots add "' + parent + '"'));
@@ -91,27 +71,7 @@ async function consented(ctx) {
     const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
     if (!interactive)
         fail('Not restarting without your consent.', 'Run it again with --yes to restart: ' + againWithYes(ctx));
-    return askYesNo('Restart the sandbox now?');
-}
-/** Reopens each session the restart ended, continuing its conversation where the agent supports it. */
-async function reopenSessions(ctx, ready, reopen, relauncher) {
-    for (const s of reopen) {
-        const at = freshContext(ctx, s.hostDir, s.harness);
-        try {
-            const joined = await relauncher.joinHere(at, ready, { noRestart: true });
-            for (const note of joined.notes)
-                console.log(note);
-            await relauncher.openSession(at, ready, joined, {
-                attach: false,
-                harness: s.harness,
-                args: ctx.loaded.config.harnesses[s.harness]?.resumeArguments ?? [],
-                reuse: false,
-            });
-        }
-        catch (e) {
-            console.warn(c.yellow('Could not reopen ' + s.harness + ' in ' + s.hostDir + ': ' + (e instanceof Error ? e.message : String(e))));
-        }
-    }
+    return askYesNo('Restart the sandbox now? (its sessions reopen and continue)');
 }
 export async function offerRestart(ctx, needs, then, relauncher) {
     const folders = needs.map((n) => n.hostDir);
@@ -127,11 +87,6 @@ export async function offerRestart(ctx, needs, then, relauncher) {
         return 1;
     }
     const reopen = sessionsToReopen(registry, sessions);
-    const resume = reopen.length > 0 &&
-        (ctx.options.yes ||
-            (await askYesNo('Reopen the ' +
-                reopen.length +
-                ' session(s) afterwards (continuing their conversations where the agent supports it)?', true)));
     await stopAndWait(ctx);
     markRestarted();
     const keep = registry.projects.filter((p) => !p.primary && p.mechanism !== 'root').map((p) => p.host);
@@ -143,7 +98,9 @@ export async function offerRestart(ctx, needs, then, relauncher) {
         waitUntilReady: true,
     });
     const ready = await relauncher.readySandbox(ctx.dataPath);
-    if (resume)
-        await reopenSessions(ctx, ready, reopen, relauncher);
+    if (reopen.length) {
+        const opened = await reopenSessions(ctx, ready, reopen, relauncher);
+        console.log(reopenedText(opened, reopen.length, reopen));
+    }
     return then();
 }

package/dist/cli/commands/registry.js

@@ -1,11 +1,15 @@
 import { launch } from './launch/index.js';
 import { setup } from './setup/index.js';
 import { data } from './data/index.js';
+import { storage } from './storage/index.js';
 import { attach, db, exec, hide, restart, sessions, show, status, stop } from './sessions/index.js';
 import { account } from './accounts.js';
 import { projects } from './projects/index.js';
-import { audit, claudeHost, clean, config, doctor, logs, sync, watcher } from './maintenance/index.js';
+import { audit, claudeHost, clean, config, doctor, hostCommand, logs, migrate, sync, watcher, } from './maintenance/index.js';
+import { resume } from './resume.js';
 import { agentCommandsCommand } from './agent-commands.js';
+import { vpn } from './vpn.js';
+import { web, webServer } from './web.js';
 export const HANDLERS = {
     launch: (ctx) => launch(ctx),
     generate: (ctx) => launch(ctx, true),
@@ -16,6 +20,7 @@ export const HANDLERS = {
     'agent-commands': agentCommandsCommand,
     db: db,
     restart: restart,
+    resume: resume,
     stop: stop,
     show: show,
     hide: hide,
@@ -27,8 +32,14 @@ export const HANDLERS = {
     clean: clean,
     config: config,
     doctor: doctor,
+    migrate: migrate,
     setup: setup,
     data: data,
+    storage: storage,
     'host-claude': claudeHost,
+    host: hostCommand,
     _watch: watcher,
+    vpn: vpn,
+    web: web,
+    _web: webServer,
 };

package/dist/cli/commands/repair/checks/agents.d.ts

@@ -0,0 +1,2 @@
+import type { Check } from '../types.js';
+export declare const AGENT_CHECKS: Check[];

package/dist/cli/commands/repair/checks/agents.js

@@ -0,0 +1,70 @@
+// Agents: is the default agent one of those configured, and for each agent that keeps a login, is a saved login in
+// use in this data folder. Looks only; logins are never changed here.
+import { errMsg } from '../../../../core/util/index.js';
+import { AccountStore, AgentAccountStore } from '../../../../host/profile/index.js';
+import { ok, plural } from './common.js';
+function rowsOf(env, name, loginFiles) {
+    if (name === 'claude')
+        return new AccountStore(env.storageRoot).list(env.dataPath);
+    return loginFiles ? new AgentAccountStore(env.storageRoot, name, loginFiles).list(env.dataPath) : [];
+}
+export const AGENT_CHECKS = [
+    {
+        id: 'agents-default',
+        group: 'Agents & tools',
+        name: 'Default agent',
+        run: (env) => {
+            const config = env.ctx.loaded.config;
+            const name = env.ctx.options.harness ?? config.defaultHarness;
+            const harness = config.harnesses[name];
+            if (!harness)
+                return {
+                    status: 'needs-you',
+                    detail: '"' + name + '" is not one of your configured agents (' + Object.keys(config.harnesses).join(', ') + ')',
+                    means: 'sandbox launch has no agent to start.',
+                    fix: 'Set defaultHarness in your settings to one of those names (sandbox config path shows the file).',
+                };
+            return ok(name + ' (' + plural(Object.keys(config.harnesses).length, 'agent') + ' configured)');
+        },
+    },
+    {
+        id: 'agents-logins',
+        group: 'Agents & tools',
+        name: 'Agent logins',
+        run: (env) => {
+            const harnesses = env.ctx.loaded.config.harnesses;
+            const lines = [];
+            const idle = [];
+            for (const [name, harness] of Object.entries(harnesses)) {
+                let rows;
+                try {
+                    rows = rowsOf(env, name, harness.home?.loginFiles);
+                }
+                catch (e) {
+                    lines.push(name + ': saved logins cannot be read (' + errMsg(e) + ')');
+                    idle.push(name);
+                    continue;
+                }
+                if (!rows.length)
+                    continue;
+                const active = rows.find((r) => r.isActive);
+                if (active)
+                    lines.push(name + ': ' + active.name + ' is in use (' + plural(rows.length, 'login') + ' saved)');
+                else {
+                    lines.push(name + ': ' + plural(rows.length, 'login') + ' saved, none in use here');
+                    idle.push(name);
+                }
+            }
+            if (!lines.length)
+                return ok('no saved logins (sign in inside the sandbox the first time)');
+            if (!idle.length)
+                return { ...ok(lines.join('; ')) };
+            return {
+                status: 'warn',
+                detail: lines.join('; '),
+                means: 'The sandbox starts signed out for ' + idle.join(', ') + ' until you pick a saved login.',
+                fix: 'Run: sandbox account use <name>' + (idle[0] === 'claude' ? '' : ' --agent ' + idle[0]),
+            };
+        },
+    },
+];

package/dist/cli/commands/repair/checks/common.d.ts

@@ -0,0 +1,8 @@
+import type { Finding, RepairEnv } from '../types.js';
+export declare function ok(detail: string): Finding;
+export declare function rel(root: string, p: string): string;
+/** Throws unless every folder from the data folder's parent down to `p` is real (no link the sandbox made). */
+export declare function guard(env: RepairEnv, p: string): void;
+export declare function plural(n: number, one: string, many?: string): string;
+/** The current Windows user's name (what the group lists, without the domain). */
+export declare function sameUser(account: string, user: string): boolean;

package/dist/cli/commands/repair/checks/common.js

@@ -0,0 +1,22 @@
+// Small helpers the checks share.
+import path from 'node:path';
+import { assertNoLinks } from '../../../../core/util/index.js';
+export function ok(detail) {
+    return { status: 'ok', detail };
+}
+export function rel(root, p) {
+    return path.relative(root, p) || '.';
+}
+/** Throws unless every folder from the data folder's parent down to `p` is real (no link the sandbox made). */
+export function guard(env, p) {
+    assertNoLinks(path.dirname(env.dataPath), p);
+}
+export function plural(n, one, many = one + 's') {
+    return n + ' ' + (n === 1 ? one : many);
+}
+/** The current Windows user's name (what the group lists, without the domain). */
+export function sameUser(account, user) {
+    const a = account.toLowerCase();
+    const u = user.toLowerCase();
+    return a === u || a.endsWith('\\' + u);
+}