windows-development-sandbox 1.4.3 → 1.7.0

package/dist/cli/commands/repair/printer.d.ts

@@ -0,0 +1,32 @@
+import type { CheckResult, Summary } from './types.js';
+import type { RunHooks } from './engine.js';
+/** Where text goes (the terminal; a test collects it). */
+export interface Out {
+    write(text: string): void;
+}
+/** "12 ok, 2 fixed, 1 needs you": the parts that are zero are left out (except ok). */
+export declare function summaryText(s: Summary): string;
+export declare class HealthPrinter {
+    private readonly out;
+    /** Redraw lines in place (a terminal); otherwise each result is one finished line. */
+    private readonly animate;
+    private group;
+    private live;
+    constructor(out: Out, 
+    /** Redraw lines in place (a terminal); otherwise each result is one finished line. */
+    animate?: boolean);
+    private glyph;
+    private clearLive;
+    private heading;
+    title(text: string): void;
+    /** Hooks for HealthRun: print as the checks run (and, for repair, as the fixes are applied). */
+    hooks(): RunHooks;
+    /** One result: the line, then what it means and what to do when it is not ok. */
+    result(r: CheckResult): void;
+    /** What a fix did, on the line it started. */
+    private fixed;
+    /** What repair will change, listed before it asks. */
+    plan(fixable: readonly CheckResult[]): void;
+    summary(results: readonly CheckResult[], s: Summary): void;
+    line(text: string): void;
+}

package/dist/cli/commands/repair/printer.js

@@ -0,0 +1,132 @@
+// How doctor and repair look: headings per group, one line per result as it finishes (a "Checking ..." line while it
+// runs on a terminal), "What it means" and "Fix" under what is not ok, and the summary. The engine's only printing.
+import { c, canAnimate } from '../../output/index.js';
+const GLYPH = {
+    ok: { tty: '✔', plain: '[ok]', paint: c.green },
+    fixed: { tty: '✔', plain: '[fixed]', paint: c.cyan },
+    warn: { tty: '!', plain: '[!]', paint: c.yellow },
+    'needs-you': { tty: '✘', plain: '[x]', paint: c.red },
+    skipped: { tty: '–', plain: '[-]', paint: c.dim },
+};
+const MAX_LINES = 6;
+/** "12 ok, 2 fixed, 1 needs you": the parts that are zero are left out (except ok). */
+export function summaryText(s) {
+    const parts = [
+        s.ok + ' ok',
+        s.fixed && s.fixed + ' fixed',
+        s.needsYou && s.needsYou + ' ' + (s.needsYou === 1 ? 'needs' : 'need') + ' you',
+        s.warn && s.warn + (s.warn === 1 ? ' warning' : ' warnings'),
+        s.skipped && s.skipped + ' skipped',
+    ];
+    return parts.filter(Boolean).join(', ');
+}
+export class HealthPrinter {
+    out;
+    animate;
+    group = null;
+    live = false;
+    constructor(out, 
+    /** Redraw lines in place (a terminal); otherwise each result is one finished line. */
+    animate = canAnimate(process.env, Boolean(process.stdout.isTTY))) {
+        this.out = out;
+        this.animate = animate;
+    }
+    glyph(status) {
+        const g = GLYPH[status];
+        return g.paint(this.animate ? g.tty : g.plain);
+    }
+    clearLive() {
+        if (this.live)
+            this.out.write('\r\x1b[2K');
+        this.live = false;
+    }
+    heading(group) {
+        if (group === this.group)
+            return;
+        this.group = group;
+        this.out.write('\n' + c.bold(group) + '\n');
+    }
+    title(text) {
+        this.out.write(c.bold(text) + '\n');
+    }
+    /** Hooks for HealthRun: print as the checks run (and, for repair, as the fixes are applied). */
+    hooks() {
+        return {
+            lookStart: (check) => {
+                this.heading(check.group);
+                if (!this.animate)
+                    return;
+                this.live = true;
+                this.out.write('  ' + c.dim('… Checking ' + (check.checking ?? check.name.toLowerCase()) + '…'));
+            },
+            lookEnd: (result) => {
+                this.clearLive();
+                this.result(result);
+            },
+            fixStart: (result) => {
+                this.heading(result.group);
+                if (!this.animate)
+                    return;
+                this.live = true;
+                this.out.write('  ' + c.dim('… Fixing: ' + (result.plan ?? result.name) + '…'));
+            },
+            fixEnd: (result) => {
+                this.clearLive();
+                this.fixed(result);
+            },
+        };
+    }
+    /** One result: the line, then what it means and what to do when it is not ok. */
+    result(r) {
+        this.heading(r.group);
+        const note = r.timedOut ? ' (took too long)' : '';
+        this.out.write('  ' + this.glyph(r.status) + ' ' + c.bold(r.name) + ': ' + r.detail + note + '\n');
+        if (r.status === 'ok')
+            return;
+        if (r.means)
+            this.out.write('      What it means: ' + r.means + '\n');
+        if (r.fixable && r.plan)
+            this.out.write('      Fix: sandbox repair will ' + r.plan + '\n');
+        else if (r.fix)
+            this.out.write('      Fix: ' + r.fix + '\n');
+        for (const line of (r.lines ?? []).slice(0, MAX_LINES))
+            this.out.write('        ' + line + '\n');
+        if ((r.lines?.length ?? 0) > MAX_LINES)
+            this.out.write('        ... and ' + (r.lines.length - MAX_LINES) + ' more\n');
+    }
+    /** What a fix did, on the line it started. */
+    fixed(r) {
+        this.heading(r.group);
+        if (r.status === 'fixed') {
+            this.out.write('  ' + this.glyph('fixed') + ' ' + c.bold(r.name) + ': ' + (r.applied?.done ?? r.detail) + '\n');
+            return;
+        }
+        const prefix = '  ' + this.glyph('needs-you') + ' ' + c.bold(r.name) + ': ';
+        this.out.write(prefix + 'the fix did not work' + (r.error ? ' (' + r.error + ')' : '') + '\n');
+        if (r.fix)
+            this.out.write('      Fix: ' + r.fix + '\n');
+    }
+    /** What repair will change, listed before it asks. */
+    plan(fixable) {
+        this.out.write('\n' + c.bold('Repair will change:') + '\n');
+        fixable.forEach((r, i) => {
+            this.out.write('  ' + (i + 1) + '. ' + r.name + ': ' + (r.plan ?? r.detail) + '\n');
+            for (const line of (r.lines ?? []).slice(0, MAX_LINES))
+                this.out.write('       ' + line + '\n');
+        });
+        this.out.write('Nothing is deleted except leftovers; your settings, logins and projects are never removed.\n');
+    }
+    summary(results, s) {
+        this.clearLive();
+        this.out.write('\n' + c.bold('Summary') + ': ' + summaryText(s) + '\n');
+        const left = results.filter((r) => r.status === 'needs-you');
+        if (left.length) {
+            this.out.write('\n' + c.bold('Still needs you:') + '\n');
+            for (const r of left)
+                this.out.write('  - ' + r.name + ': ' + (r.fix ?? r.detail) + '\n');
+        }
+    }
+    line(text) {
+        this.out.write(text + '\n');
+    }
+}

package/dist/cli/commands/repair/run.d.ts

@@ -0,0 +1,33 @@
+import { UserError } from '../../../core/util/index.js';
+import type { CliOptions } from '../../args.js';
+import { type Context } from '../context.js';
+import { HealthPrinter } from './printer.js';
+import type { Check, CheckResult, RepairEnv, Summary } from './types.js';
+/** What both commands find, and what they do about it. */
+export interface HealthReport {
+    readonly found: CheckResult[];
+    readonly final: CheckResult[];
+    readonly summary: Summary;
+    /** Fixes were applied. */
+    readonly changed: boolean;
+}
+interface Plan {
+    /** Fix without asking. */
+    readonly yes: boolean;
+    /** May ask (a terminal, and not --json). */
+    readonly ask: boolean;
+    /** The question asked after the list of what will change. */
+    readonly question: (n: number) => string;
+}
+/** Runs the checks, then (when allowed) the fixes. `printer` is null for --json. */
+export declare function runHealth(env: RepairEnv, printer: HealthPrinter | null, plan: Plan, checks?: readonly Check[], confirmFix?: (question: string) => Promise<boolean>): Promise<HealthReport>;
+/** `sandbox doctor` */
+export declare function runDoctor(ctx: Context): Promise<number>;
+/** `sandbox repair` for a loaded context. */
+export declare function runRepair(ctx: Context, configError?: UserError | null): Promise<number>;
+/**
+ * Entry point that works even when the config file is broken (createContext would throw): falls back to the built-in
+ * defaults so the other checks still run, and reports the settings problem as a check of its own.
+ */
+export declare function repairCommand(packageRoot: string, entry: string, options: CliOptions): Promise<number>;
+export {};

package/dist/cli/commands/repair/run.js

@@ -0,0 +1,133 @@
+// `sandbox doctor` and `sandbox repair`: both run the same checks through the same engine, a line each as it ends.
+// doctor only looks (and offers to fix, or fixes with --fix); repair looks, lists what it would change, asks once, then
+// fixes and writes a log. --json prints the results instead and never asks.
+import path from 'node:path';
+import { confirm } from '@inquirer/prompts';
+import { DEFAULTS, userDir } from '../../../core/config/index.js';
+import { packageVersion } from '../../../core/package-info.js';
+import { expandPath, UserError } from '../../../core/util/index.js';
+import { insideSandbox } from '../../../host/sandbox/index.js';
+import { printJson, table } from '../../output/index.js';
+import { HealthService } from '../../services/index.js';
+import { createContext, requireOnPc } from '../context.js';
+import { ALL_CHECKS } from './checks/index.js';
+import { buildEnv } from './env.js';
+import { HealthRun, summarize } from './engine.js';
+import { logText, writeRepairLog } from './log.js';
+import { HealthPrinter } from './printer.js';
+const interactive = () => Boolean(process.stdin.isTTY && process.stdout.isTTY);
+const stdout = { write: (text) => void process.stdout.write(text) };
+/** Runs the checks, then (when allowed) the fixes. `printer` is null for --json. */
+export async function runHealth(env, printer, plan, checks = ALL_CHECKS, confirmFix = (q) => confirm({ message: q, default: true })) {
+    const run = new HealthRun(checks, env, printer?.hooks());
+    const found = await run.look();
+    const fixable = found.filter((r) => r.fixable);
+    let final = found;
+    let changed = false;
+    if (fixable.length) {
+        let go = plan.yes;
+        if (!go && plan.ask) {
+            printer?.plan(fixable);
+            go = await confirmFix(plan.question(fixable.length));
+        }
+        if (go) {
+            if (plan.yes)
+                printer?.plan(fixable);
+            final = await run.fix(found);
+            changed = true;
+        }
+        else
+            printer?.line('\nNothing was changed.');
+    }
+    return { found, final, summary: summarize(final), changed };
+}
+function quote(n, what) {
+    return n + ' ' + what + (n === 1 ? '' : 's');
+}
+/** `sandbox doctor` */
+export async function runDoctor(ctx) {
+    const health = new HealthService(ctx);
+    if (insideSandbox()) {
+        table(health.doctor());
+        return 0;
+    }
+    const json = ctx.options.json;
+    const printer = json ? null : new HealthPrinter(stdout);
+    printer?.title('Checking this PC, the install, your settings and the sandbox...');
+    const env = buildEnv(ctx);
+    const report = await runHealth(env, printer, {
+        yes: ctx.options.fix,
+        ask: !json && interactive(),
+        question: (n) => quote(n, 'problem') + ' can be fixed. Fix ' + (n === 1 ? 'it' : 'them') + ' now?',
+    });
+    const details = health.doctor();
+    if (printJson(ctx, { checks: report.final, summary: report.summary, details }))
+        return 0;
+    printer?.summary(report.final, report.summary);
+    const left = report.final.filter((r) => r.fixable).length;
+    if (left && !report.changed)
+        printer?.line('\n' + quote(left, 'problem') + ' can be fixed: run sandbox repair (or sandbox doctor --fix).');
+    printer?.line('\n' + 'Details');
+    table(details);
+    return 0;
+}
+/** `sandbox repair` for a loaded context. */
+export async function runRepair(ctx, configError = null) {
+    requireOnPc('repair');
+    const json = ctx.options.json;
+    const printer = json ? null : new HealthPrinter(stdout);
+    printer?.title('Checking this PC, the install, your settings and the sandbox...');
+    const env = buildEnv(ctx, configError);
+    const yes = ctx.options.yes;
+    const ask = !json && interactive();
+    const report = await runHealth(env, printer, {
+        yes,
+        ask,
+        question: (n) => 'Fix ' + (n === 1 ? 'this problem' : 'these ' + n + ' problems') + '?',
+    });
+    const when = new Date();
+    const log = writeRepairLog(ctx.storageRoot, logText({
+        when,
+        version: packageVersion(),
+        command: 'sandbox repair' + (yes ? ' --yes' : ''),
+        found: report.found,
+        final: report.final,
+        summary: report.summary,
+    }), when);
+    const stillFixable = report.final.filter((r) => r.fixable).length;
+    if (printJson(ctx, { checks: report.final, summary: report.summary, changed: report.changed, log })) {
+        return report.summary.needsYou ? 1 : 0;
+    }
+    printer?.summary(report.final, report.summary);
+    if (stillFixable && !ask && !yes)
+        printer?.line('\n' + quote(stillFixable, 'problem') + ' can be fixed: run sandbox repair --yes.');
+    printer?.line(log
+        ? '\nLog of what was found and changed: ' + log
+        : '\nNo log was written (the storage folder does not exist yet).');
+    return report.summary.needsYou ? 1 : 0;
+}
+/**
+ * Entry point that works even when the config file is broken (createContext would throw): falls back to the built-in
+ * defaults so the other checks still run, and reports the settings problem as a check of its own.
+ */
+export function repairCommand(packageRoot, entry, options) {
+    let ctx;
+    try {
+        ctx = createContext(packageRoot, entry, options);
+    }
+    catch (e) {
+        if (!(e instanceof UserError))
+            throw e;
+        const loaded = { config: structuredClone(DEFAULTS), configPath: null, base: userDir() };
+        const storageRoot = expandPath(loaded.config.storage.root, loaded.base);
+        return runRepair({
+            packageRoot,
+            entry,
+            options,
+            loaded,
+            storageRoot,
+            dataPath: path.join(storageRoot, 'data', loaded.config.storage.dataName),
+        }, e);
+    }
+    return runRepair(ctx);
+}

package/dist/cli/commands/repair/types.d.ts

@@ -1,11 +1,89 @@
 import type { UserError } from '../../../core/util/index.js';
+import type { InstallLayout, InstallRecord } from '../../../host/install/index.js';
+import type { SystemProbe } from '../../../host/health/index.js';
+import type { MachineFacts } from '../setup/facts.js';
+import type { Migration } from '../../../host/migrate/index.js';
 import type { Context } from '../context.js';
 export type RepairStatus = 'ok' | 'fixed' | 'needs-you' | 'warn' | 'skipped';
+/** The headings the output is grouped under, in the order they are shown. */
+export declare const CHECK_GROUPS: readonly ["This PC", "Install", "Data folder", "Settings", "Sandbox", "Agents & tools", "Network"];
+export type CheckGroup = (typeof CHECK_GROUPS)[number];
+/** The short form of a result (the menu shows these). */
 export interface RepairResult {
     name: string;
     status: RepairStatus;
     detail: string;
 }
+/** What a check's run() finds. */
+export interface Finding {
+    /** ok, a warning (nothing to do now), something you need to do, or not checked. */
+    status: 'ok' | 'warn' | 'needs-you' | 'skipped';
+    /** One line: what was found. */
+    detail: string;
+    /** What it means for you (shown when not ok). */
+    means?: string;
+    /** What to do about it yourself, when repair cannot (a command or a step). */
+    fix?: string;
+    /** What repair would change, in a few words ("remove 2 stale records"). Set only when fix() can mend this. */
+    plan?: string;
+    /** More lines shown under the plan when repair lists what it will change (a diff, the folders). */
+    lines?: string[];
+    /** Handed to fix() unchanged: what run() decided (the folders to remove ...). */
+    data?: unknown;
+}
+/** What a fix reports: what it changed. The before/after lines come from running the check again. */
+export interface FixOutcome {
+    done: string;
+}
+export interface Check {
+    /** Stable id (kebab-case): used in --json and the repair log. */
+    id: string;
+    group: CheckGroup;
+    /** Short label for the result line ("Data folder"). */
+    name: string;
+    /** "the data folder" in "Checking the data folder..."; the lower-cased name when left out. */
+    checking?: string;
+    /** Not shown at all when it returns false (an all-users check on another install). */
+    applies?: (env: RepairEnv) => boolean;
+    /** Slower checks (the network, Windows tools) say how long they may take; the default is 20 seconds. */
+    timeoutMs?: number;
+    /** look: do not even look while a sandbox runs (the folders are in use). fix: look, but fix only when none runs. */
+    needsIdle?: 'look' | 'fix';
+    run: (env: RepairEnv) => Finding | Promise<Finding>;
+    fix?: (env: RepairEnv, finding: Finding) => FixOutcome | Promise<FixOutcome>;
+}
+export interface CheckResult extends RepairResult {
+    id: string;
+    group: CheckGroup;
+    means?: string;
+    fix?: string;
+    plan?: string;
+    lines?: string[];
+    /** Repair can mend this one (a plan exists and the check has a fix). */
+    fixable: boolean;
+    timedOut?: boolean;
+    /** Milliseconds the look took. */
+    ms: number;
+    /** After a fix: what was changed, and what the check said before. */
+    applied?: {
+        done: string;
+        before: string;
+        after: string;
+    };
+    /** After a fix that failed: why. */
+    error?: string;
+}
+export interface Summary {
+    total: number;
+    ok: number;
+    fixed: number;
+    warn: number;
+    needsYou: number;
+    skipped: number;
+    /** Results repair could still mend. */
+    fixable: number;
+}
+/** Everything the checks read, in one place: injectable, so tests point it at temp folders. */
 export interface RepairEnv {
     ctx: Context;
     running: boolean;
@@ -13,14 +91,24 @@ export interface RepairEnv {
     storageRoot: string;
     toolsDir: string;
     configError: UserError | null;
+    /** The managed install this program runs from, or null (npm). */
+    layout: InstallLayout | null;
+    /** install.json of that install. */
+    record: InstallRecord | null;
+    /** %ProgramData%\AgentSandbox (the PC-wide folder of an all-users install). */
+    machineHome: string;
+    /** ~/.agent-sandbox: the settings file and what belongs to it. */
+    userDir: string;
+    /** The settings file in use (--config, AGENT_SANDBOX_CONFIG, else <userDir>\config.json). */
+    configFile: string;
+    /** The settings updates that exist (a test gives its own). */
+    migrations: readonly Migration[];
+    /** The user-scope install folder next to an all-users one (checked for leftovers). */
+    userInstallRoot: string | null;
+    system: SystemProbe;
+    now: () => number;
+    /** What `sandbox setup` learns about this PC (looked up once, the first time a check asks). */
+    facts: () => MachineFacts;
 }
-export interface RepairCheck {
-    name: string;
-    run: (env: RepairEnv) => Omit<RepairResult, 'name'>;
-}
-export declare function ok(detail: string): Omit<RepairResult, 'name'>;
 /** For fixes that must not touch folders a running sandbox may be using. */
-export declare const whileRunning: {
-    status: "skipped";
-    detail: string;
-};
+export declare const WHILE_RUNNING = "a sandbox is running and may be using it; run repair again once it is closed";

package/dist/cli/commands/repair/types.js

@@ -1,8 +1,12 @@
-export function ok(detail) {
-    return { status: 'ok', detail };
-}
+/** The headings the output is grouped under, in the order they are shown. */
+export const CHECK_GROUPS = [
+    'This PC',
+    'Install',
+    'Data folder',
+    'Settings',
+    'Sandbox',
+    'Agents & tools',
+    'Network',
+];
 /** For fixes that must not touch folders a running sandbox may be using. */
-export const whileRunning = {
-    status: 'skipped',
-    detail: 'a sandbox is running and may be using it; run repair again once it is closed',
-};
+export const WHILE_RUNNING = 'a sandbox is running and may be using it; run repair again once it is closed';

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

@@ -0,0 +1,2 @@
+import { type Context } from './context.js';
+export declare function resume(ctx: Context): Promise<number>;

package/dist/cli/commands/resume.js

@@ -0,0 +1,61 @@
+// `sandbox resume`: open the sessions of the last sandbox again. Starts the sandbox the way it was started when none
+// runs. `--auto` is how the background watcher calls it after a crash (resume.restartAfterCrash): no questions, and the
+// resume.sessions setting decides whether the sessions open ("ask" counts as "always" there: nobody is at the PC).
+import { sleep } from '../../core/util/index.js';
+import { SandboxChannel } from '../../host/channel/index.js';
+import { describeLast, LifeRecord, SessionLedger, shouldReopen } from '../../host/life/index.js';
+import { ProjectRegistry } from '../../host/projects/index.js';
+import { isSandboxRunning } from '../../host/sandbox/index.js';
+import { requireOnPc } from './context.js';
+import { launch, RELAUNCHER } from './launch/index.js';
+import { freshContext, ledgerToReopen, notRunningYet, reopenedText, reopenSessions, sessionsToReopen, } from './sessions/reopen.js';
+/** Windows Sandbox needs a moment after the old one is gone before a new one can start. */
+const SETTLE_SECONDS = 30;
+/** Starts the sandbox again the way the ledger says it was started: its launch folder, agent and projects. */
+async function startAgain(ctx, saved) {
+    const again = freshContext(ctx, saved.launch.primary, saved.launch.harness ?? undefined, {
+        noAgent: saved.launch.harness === null,
+        headless: saved.launch.headless ? true : undefined,
+    });
+    return launch(again, false, { extraProjects: saved.launch.projects, autoSession: false, waitUntilReady: true });
+}
+export async function resume(ctx) {
+    requireOnPc('resume');
+    const { storageRoot, dataPath, options } = ctx;
+    const saved = new SessionLedger(storageRoot, dataPath).read();
+    if (!saved) {
+        console.log('Nothing to resume. Start one: sandbox claude.');
+        return 0;
+    }
+    // By hand, you asked for it. From the watcher, the setting decides.
+    const setting = ctx.loaded.config.resume.sessions;
+    const life = new LifeRecord(storageRoot, dataPath).read();
+    const reopening = !options.auto || shouldReopen(setting === 'ask' ? 'always' : setting, life, saved) === 'reopen';
+    if (!options.auto && !saved.sessions.length) {
+        console.log('Nothing to resume. Start one: sandbox claude.');
+        return 0;
+    }
+    if (reopening && saved.sessions.length)
+        console.log('Last time: ' + describeLast(saved.sessions) + '.');
+    if (options.auto)
+        for (let i = 0; i < SETTLE_SECONDS && isSandboxRunning(); i++)
+            await sleep(1000);
+    if (!isSandboxRunning()) {
+        const code = await startAgain(ctx, saved);
+        if (code !== 0)
+            return code;
+    }
+    if (!reopening || !saved.sessions.length)
+        return 0;
+    const ready = await RELAUNCHER.readySandbox(ctx.dataPath);
+    const registry = new ProjectRegistry(storageRoot).read();
+    const open = registry ? sessionsToReopen(registry, new SandboxChannel(dataPath).currentSessions()) : [];
+    const reopen = notRunningYet(ledgerToReopen(saved.sessions), open);
+    if (!reopen.length) {
+        console.log('Everything from the last sandbox is open already.');
+        return 0;
+    }
+    const opened = await reopenSessions(ctx, ready, reopen, RELAUNCHER);
+    console.log(reopenedText(opened, reopen.length, reopen));
+    return opened === reopen.length ? 0 : 1;
+}

package/dist/cli/commands/sessions/attach.d.ts

@@ -1,2 +1,2 @@
 import { type Context } from '../context.js';
-export declare function attach(ctx: Context): Promise<number>;
+export declare function attach(asked: Context): Promise<number>;

package/dist/cli/commands/sessions/attach.js

@@ -1,16 +1,14 @@
 import { select } from '@inquirer/prompts';
-import { SandboxChannel, sessionsFirstIn } from '../../../host/channel/index.js';
-import { ProjectRegistry } from '../../../host/projects/index.js';
-import { isWithin } from '../../../shared/paths/index.js';
 import { safeText, sleep } from '../../../core/util/index.js';
+import { isWithin } from '../../../shared/paths/index.js';
 import { requireOnPc, requireRunning } from '../context.js';
 import { attachHere, readySandbox } from '../launch/index.js';
 import { locateHere } from '../projects/index.js';
+import { useSharedSandbox } from '../shared-use.js';
 import { ago } from '../../output/index.js';
-import { projectOf } from './list.js';
+import { SessionsService } from '../../services/index.js';
 /** Asks which session to attach to, this folder's project first (the newest is the default). */
-function chooseSession(ctx, running, here) {
-    const projects = new ProjectRegistry(ctx.storageRoot).read()?.projects ?? [];
+function chooseSession(service, running, here) {
     return select({
         message: 'Which session?' + (here.project ? ' (' + here.project.name + ' first)' : ''),
         choices: running.map((s) => ({
@@ -18,7 +16,7 @@ function chooseSession(ctx, running, here) {
             name: (here.guestDir && isWithin(here.guestDir, s.cwd) ? '* ' : '  ') +
                 safeText(s.harness).padEnd(9) +
                 ' ' +
-                safeText(projectOf(projects, s)).padEnd(16) +
+                safeText(service.projectName(s)).padEnd(16) +
                 ' ' +
                 ago(s.startedAt).padEnd(11) +
                 ' ' +
@@ -26,20 +24,21 @@ function chooseSession(ctx, running, here) {
         })),
     });
 }
-export async function attach(ctx) {
+export async function attach(asked) {
     requireOnPc('attach');
     requireRunning('Start one with: sandbox claude --terminal');
+    const ctx = await useSharedSandbox(asked, { kind: 'use' });
     const ready = await readySandbox(ctx.dataPath);
-    const channel = new SandboxChannel(ctx.dataPath);
+    const service = new SessionsService(ctx);
     const id = ctx.options.positionals[0];
-    if (!id && channel.runningSessions().length === 0)
+    if (!id && service.runningCount() === 0)
         await sleep(1500);
     const here = locateHere(ctx, ready);
     if (id)
-        return attachHere(ctx, channel.pickSession(id));
+        return attachHere(ctx, service.pick(id));
     // Several sessions: choose, this folder's project first (the newest is the default).
-    const running = sessionsFirstIn(channel.runningSessions(), here.guestDir);
+    const running = service.running(here.guestDir);
     if (running.length > 1 && process.stdin.isTTY && process.stdout.isTTY)
-        return attachHere(ctx, channel.pickSession(await chooseSession(ctx, running, here)));
-    return attachHere(ctx, channel.pickSession(undefined, here.guestDir));
+        return attachHere(ctx, service.pick(await chooseSession(service, running, here)));
+    return attachHere(ctx, service.pick(undefined, here.guestDir));
 }

package/dist/cli/commands/sessions/control.d.ts

@@ -1,4 +1,4 @@
 import { type Context } from '../context.js';
 /** Restarts this folder's project's sessions (--all: every session). */
 export declare function restart(ctx: Context): Promise<number>;
-export declare function stop(ctx: Context): Promise<number>;
+export declare function stop(asked: Context): Promise<number>;