windows-development-sandbox 1.4.1 → 1.4.3

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

@@ -6,32 +6,51 @@ import { spawnSync } from 'node:child_process';
 import _ from 'lodash';
 import { GB, freeBytesAt, humanBytes } from '../../../core/disk.js';
 import { assertTestWritable } from '../../../shared/test-guard.js';
-import { assertNoLinks, fileExists, isLink, isWin, removeLink } from '../../../core/util.js';
-import { resetRunDir } from '../../../host/channel.js';
-import { sandboxFeatureInstalled } from '../../../host/platform.js';
-import { listSessions, runPaths, scanRequests } from '../../../shared/rundir.js';
+import { assertNoLinks, fileExists, isLink, isWin, removeLink } from '../../../core/util/index.js';
+import { SandboxChannel } from '../../../host/channel/index.js';
+import { sandboxFeatureInstalled } from '../../../host/sandbox/index.js';
+import { RunDir } from '../../../shared/channel/index.js';
 import { removeTree } from '../data/remove.js';
-import { deadPidFiles, findHalfInstalled, findLinks, findStagingLeftovers, globalPackages, resolvedVersionsValid } from './finders.js';
+import { deadPidFiles, findHalfInstalled, findLinks, findStagingLeftovers, globalPackages, resolvedVersionsValid, } from './finders.js';
 import { ok, whileRunning } from './types.js';
-const rel = (root, p) => path.relative(root, p) || '.';
+function rel(root, p) {
+    return path.relative(root, p) || '.';
+}
 /** Fails (throws) unless every folder from the data folder to `p` is real. */
-const guard = (env, p) => assertNoLinks(path.dirname(env.dataPath), p);
+function guard(env, p) {
+    assertNoLinks(path.dirname(env.dataPath), p);
+}
 export const CHECKS = [
     {
         name: 'Config file',
-        run: (env) => (env.configError
-            ? { status: 'needs-you', detail: env.configError.message + (env.configError.fix ? ' ' + env.configError.fix : '') + ' (repair never rewrites your config; built-in defaults were used for the other checks.)' }
-            : ok(env.ctx.loaded.configPath ? env.ctx.loaded.configPath + ' is valid.' : 'none; using the built-in defaults.')),
+        run: (env) => env.configError
+            ? {
+                status: 'needs-you',
+                detail: env.configError.message +
+                    (env.configError.fix ? ' ' + env.configError.fix : '') +
+                    ' (repair never rewrites your config; built-in defaults were used for the other checks.)',
+            }
+            : ok(env.ctx.loaded.configPath ? env.ctx.loaded.configPath + ' is valid.' : 'none; using the built-in defaults.'),
     },
     {
         name: 'Windows Sandbox feature',
-        run: () => (sandboxFeatureInstalled() ? ok('enabled.') : { status: 'needs-you', detail: (isWin ? 'Windows Sandbox is not turned on.' : 'This is not Windows.') + ' Run: sandbox setup (it checks this PC and offers to turn it on).' }),
+        run: () => sandboxFeatureInstalled()
+            ? ok('enabled.')
+            : {
+                status: 'needs-you',
+                detail: (isWin ? 'Windows Sandbox is not turned on.' : 'This is not Windows.') +
+                    ' Run: sandbox setup (it checks this PC and offers to turn it on).',
+            },
     },
     {
         name: 'Links in the data folder',
         run: (env) => {
             if (isLink(env.dataPath))
-                return { status: 'needs-you', detail: env.dataPath + ' itself is a link or junction. agent-sandbox refuses to work through links; point storage.root at the real folder instead (sandbox config path).' };
+                return {
+                    status: 'needs-you',
+                    detail: env.dataPath +
+                        ' itself is a link or junction. agent-sandbox refuses to work through links; point storage.root at the real folder instead (sandbox config path).',
+                };
             // A running sandbox can swap folders for links while we look; only check a stopped one.
             if (env.running)
                 return whileRunning;
@@ -44,7 +63,13 @@ export const CHECKS = [
                 guard(env, path.dirname(link));
                 removeLink(link);
             }
-            return { status: 'fixed', detail: 'removed ' + links.length + ' link(s)/junction(s) the sandbox created, without following them: ' + links.map((l) => rel(env.dataPath, l)).join(', ') };
+            return {
+                status: 'fixed',
+                detail: 'removed ' +
+                    links.length +
+                    ' link(s)/junction(s) the sandbox created, without following them: ' +
+                    links.map((l) => rel(env.dataPath, l)).join(', '),
+            };
         },
     },
     {
@@ -52,18 +77,29 @@ export const CHECKS = [
         run: (env) => {
             if (env.running)
                 return ok('a sandbox is running; its state is in use.');
-            if (isLink(runPaths(env.dataPath).run)) {
-                resetRunDir(env.dataPath);
+            if (isLink(new RunDir(env.dataPath).root)) {
+                new SandboxChannel(env.dataPath).reset();
                 return { status: 'fixed', detail: 'the run folder was a link; removed the link itself.' };
             }
-            // The last sandbox's status file is normal after it closes; sessions still marked running or unanswered requests are not.
-            const ghosts = listSessions(env.dataPath).filter((s) => s.phase === 'running' || s.phase === 'starting').length;
-            const requests = scanRequests(env.dataPath);
+            // The last sandbox's status file is normal after it closes; sessions still marked running or unanswered requests
+            // are not.
+            const ghosts = new RunDir(env.dataPath)
+                .listSessions()
+                .filter((s) => s.phase === 'running' || s.phase === 'starting').length;
+            const requests = new RunDir(env.dataPath).scanRequests();
             const pending = requests.valid.length + requests.invalid.length;
             if (!ghosts && !pending)
                 return ok('clean.');
-            resetRunDir(env.dataPath);
-            return { status: 'fixed', detail: 'no sandbox is running, but ' + _.compact([ghosts && ghosts + ' session(s) were still marked running', pending && pending + ' request(s) were never answered']).join(' and ') + '; cleared the run state so status/attach do not show ghosts.' };
+            new SandboxChannel(env.dataPath).reset();
+            return {
+                status: 'fixed',
+                detail: 'no sandbox is running, but ' +
+                    _.compact([
+                        ghosts && ghosts + ' session(s) were still marked running',
+                        pending && pending + ' request(s) were never answered',
+                    ]).join(' and ') +
+                    '; cleared the run state so status/attach do not show ghosts.',
+            };
         },
     },
     {
@@ -76,7 +112,10 @@ export const CHECKS = [
                 return ok('a sandbox is running; kept.');
             assertTestWritable(file);
             fs.rmSync(file, { force: true });
-            return { status: 'fixed', detail: 'removed the saved hidden-window list from a sandbox that is no longer running.' };
+            return {
+                status: 'fixed',
+                detail: 'removed the saved hidden-window list from a sandbox that is no longer running.',
+            };
         },
     },
     {
@@ -89,7 +128,12 @@ export const CHECKS = [
                 assertTestWritable(f);
                 fs.rmSync(f, { force: true });
             }
-            return { status: 'fixed', detail: 'removed ' + dead.length + ' record(s) of a history sync watcher that is no longer running (the next launch starts a new one).' };
+            return {
+                status: 'fixed',
+                detail: 'removed ' +
+                    dead.length +
+                    ' record(s) of a history sync watcher that is no longer running (the next launch starts a new one).',
+            };
         },
     },
     {
@@ -103,7 +147,13 @@ export const CHECKS = [
                 return ok('none.');
             for (const p of found)
                 removeTree(p, env.dataPath);
-            return { status: 'fixed', detail: 'removed ' + found.length + ' half-finished download/copy folder(s): ' + found.map((p) => rel(env.toolsDir, p)).join(', ') };
+            return {
+                status: 'fixed',
+                detail: 'removed ' +
+                    found.length +
+                    ' half-finished download/copy folder(s): ' +
+                    found.map((p) => rel(env.toolsDir, p)).join(', '),
+            };
         },
     },
     {
@@ -117,7 +167,12 @@ export const CHECKS = [
                 return ok('every toolchain folder has its program.');
             for (const f of found)
                 removeTree(f.path, env.dataPath);
-            return { status: 'fixed', detail: 'removed ' + found.map((f) => rel(env.toolsDir, f.path) + ' (no ' + f.missing + ')').join(', ') + '; the next sandbox reinstalls them.' };
+            return {
+                status: 'fixed',
+                detail: 'removed ' +
+                    found.map((f) => rel(env.toolsDir, f.path) + ' (no ' + f.missing + ')').join(', ') +
+                    '; the next sandbox reinstalls them.',
+            };
         },
     },
     {
@@ -137,7 +192,10 @@ export const CHECKS = [
                 return ok('valid.');
             assertTestWritable(file);
             fs.rmSync(file, { force: true });
-            return { status: 'fixed', detail: 'tools\\resolved-versions.json was damaged; removed it (versions are looked up again on the next start).' };
+            return {
+                status: 'fixed',
+                detail: 'tools\\resolved-versions.json was damaged; removed it (versions are looked up again on the next start).',
+            };
         },
     },
     {
@@ -147,13 +205,24 @@ export const CHECKS = [
             if (!fileExists(npmCli))
                 return { status: 'skipped', detail: 'npm not found next to this Node (' + npmCli + ').' };
             // cwd = Node's own folder: npm reads .npmrc from the current folder, which could be a sandbox-writable workspace.
-            const result = spawnSync(process.execPath, [npmCli, 'ls', '-g', '--json', '--depth=0'], { cwd: path.dirname(process.execPath), encoding: 'utf8', windowsHide: true, timeout: 60000, maxBuffer: 16 * 1024 * 1024 });
+            const result = spawnSync(process.execPath, [npmCli, 'ls', '-g', '--json', '--depth=0'], {
+                cwd: path.dirname(process.execPath),
+                encoding: 'utf8',
+                windowsHide: true,
+                timeout: 60000,
+                maxBuffer: 16 * 1024 * 1024,
+            });
             const names = globalPackages(result.stdout ?? '');
             if (!names.length)
                 return { status: 'skipped', detail: 'could not read the global npm packages.' };
             if (names.includes('agent-sandbox') && names.includes('windows-development-sandbox'))
-                return { status: 'needs-you', detail: 'the old agent-sandbox package is still installed next to windows-development-sandbox, and their commands clash. Run: npm uninstall -g agent-sandbox' };
-            return ok(names.includes('agent-sandbox') ? 'agent-sandbox installed (the old name; fine on its own).' : 'no old agent-sandbox package.');
+                return {
+                    status: 'needs-you',
+                    detail: 'the old agent-sandbox package is still installed next to windows-development-sandbox, and their commands clash. Run: npm uninstall -g agent-sandbox',
+                };
+            return ok(names.includes('agent-sandbox')
+                ? 'agent-sandbox installed (the old name; fine on its own).'
+                : 'no old agent-sandbox package.');
         },
     },
     {
@@ -164,7 +233,14 @@ export const CHECKS = [
                 return { status: 'skipped', detail: 'could not check the drive of ' + env.storageRoot };
             if (free >= 20 * GB)
                 return ok(humanBytes(free) + ' free.');
-            return { status: 'warn', detail: humanBytes(free) + ' free on the drive of ' + env.storageRoot + (free < 5 * GB ? ': toolchains need several GB.' : ': getting low.') + ' See what is stored with: sandbox data, and free space with: sandbox data clean <target>' };
+            return {
+                status: 'warn',
+                detail: humanBytes(free) +
+                    ' free on the drive of ' +
+                    env.storageRoot +
+                    (free < 5 * GB ? ': toolchains need several GB.' : ': getting low.') +
+                    ' See what is stored with: sandbox data, and free space with: sandbox data clean <target>',
+            };
         },
     },
 ];

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

@@ -1,8 +1,11 @@
-/** Interrupted downloads and copies: `<name>.staging-<hex>` and `node-staging`, in tools\ and one folder down (tools\go\1.23.staging-ab12). */
-export declare const findStagingLeftovers: (toolsDir: string) => string[];
 /**
- * A toolchain folder and the program it must contain. `versions` means one folder per installed version (tools\go\1.23.2);
- * `match` limits which version folders count (tools\nvm also holds settings and nvm.exe).
+ * Interrupted downloads and copies: `<name>.staging-<hex>` and `node-staging`, in tools\ and one folder down
+ * (tools\go\1.23.staging-ab12).
+ */
+export declare function findStagingLeftovers(toolsDir: string): string[];
+/**
+ * A toolchain folder and the program it must contain. `versions` means one folder per installed version
+ * (tools\go\1.23.2); `match` limits which version folders count (tools\nvm also holds settings and nvm.exe).
  */
 export interface ToolRule {
     folder: string;
@@ -12,7 +15,7 @@ export interface ToolRule {
 }
 export declare const TOOL_RULES: ToolRule[];
 /** Toolchain folders that exist but lack their main program (an install that stopped half way). Never enters links. */
-export declare const findHalfInstalled: (toolsDir: string, rules?: ToolRule[]) => {
+export declare function findHalfInstalled(toolsDir: string, rules?: ToolRule[]): {
     path: string;
     missing: string;
 }[];
@@ -20,11 +23,11 @@ export declare const findHalfInstalled: (toolsDir: string, rules?: ToolRule[]) =
  * Every link or junction under `root` (the links themselves; nothing behind them is visited). Before descending into
  * a folder its real path must still be inside root: a folder swapped for a junction between two looks is not followed.
  */
-export declare const findLinks: (root: string) => string[];
+export declare function findLinks(root: string): string[];
 /** tools\resolved-versions.json is a JSON object (anything else makes the guest stumble). */
-export declare const resolvedVersionsValid: (text: string) => boolean;
+export declare function resolvedVersionsValid(text: string): boolean;
 /** Package names from `npm ls -g --json`; [] when the output is not what npm prints. */
-export declare const globalPackages: (json: string) => string[];
-export declare const pidAlive: (pid: number) => boolean;
+export declare function globalPackages(json: string): string[];
+export declare function pidAlive(pid: number): boolean;
 /** Sync-watcher pid files (storage\run\watcher-*.pid) whose process is gone (or whose content is not a pid). */
-export declare const deadPidFiles: (runDir: string, alive?: (pid: number) => boolean) => string[];
+export declare function deadPidFiles(runDir: string, alive?: (pid: number) => boolean): string[];

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

@@ -2,13 +2,16 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { z } from 'zod';
-import { dirExists, fileExists, isLink } from '../../../core/util.js';
-/** Interrupted downloads and copies: `<name>.staging-<hex>` and `node-staging`, in tools\ and one folder down (tools\go\1.23.staging-ab12). */
-export const findStagingLeftovers = (toolsDir) => {
+import { dirExists, fileExists, isLink } from '../../../core/util/index.js';
+/**
+ * Interrupted downloads and copies: `<name>.staging-<hex>` and `node-staging`, in tools\ and one folder down
+ * (tools\go\1.23.staging-ab12).
+ */
+export function findStagingLeftovers(toolsDir) {
     const isStaging = (name) => /\.staging-[0-9a-f]+$/i.test(name) || name.toLowerCase() === 'node-staging';
-    const realChildren = (dir) => (dirExists(dir) && !isLink(dir) ? fs.readdirSync(dir).map((n) => path.join(dir, n)) : []);
-    return realChildren(toolsDir).flatMap((p) => (isStaging(path.basename(p)) ? [p] : isLink(p) ? [] : realChildren(p).filter((c) => isStaging(path.basename(c)))));
-};
+    const realChildren = (dir) => dirExists(dir) && !isLink(dir) ? fs.readdirSync(dir).map((n) => path.join(dir, n)) : [];
+    return realChildren(toolsDir).flatMap((p) => isStaging(path.basename(p)) ? [p] : isLink(p) ? [] : realChildren(p).filter((c) => isStaging(path.basename(c))));
+}
 export const TOOL_RULES = [
     { folder: 'nvm', exe: ['nvm.exe'] },
     { folder: 'nvm', exe: ['node.exe'], versions: true, match: /^v\d+\.\d+\.\d+$/ },
@@ -20,7 +23,7 @@ export const TOOL_RULES = [
     { folder: 'python', exe: ['python.exe'], versions: true },
 ];
 /** Toolchain folders that exist but lack their main program (an install that stopped half way). Never enters links. */
-export const findHalfInstalled = (toolsDir, rules = TOOL_RULES) => {
+export function findHalfInstalled(toolsDir, rules = TOOL_RULES) {
     const realDir = (p) => dirExists(p) && !isLink(p);
     const staging = (name) => /\.staging-[0-9a-f]+$/i.test(name) || name.toLowerCase() === 'node-staging';
     return rules.flatMap((rule) => {
@@ -28,26 +31,37 @@ export const findHalfInstalled = (toolsDir, rules = TOOL_RULES) => {
         if (!realDir(base))
             return [];
         const folders = rule.versions
-            ? fs.readdirSync(base).filter((n) => !staging(n) && (!rule.match || rule.match.test(n))).map((n) => path.join(base, n)).filter(realDir)
+            ? fs
+                .readdirSync(base)
+                .filter((n) => !staging(n) && (!rule.match || rule.match.test(n)))
+                .map((n) => path.join(base, n))
+                .filter(realDir)
             : [base];
-        return folders.filter((f) => !fileExists(path.join(f, ...rule.exe))).map((f) => ({ path: f, missing: path.join(...rule.exe) }));
+        return folders
+            .filter((f) => !fileExists(path.join(f, ...rule.exe)))
+            .map((f) => ({ path: f, missing: path.join(...rule.exe) }));
     });
-};
+}
 /**
  * Every link or junction under `root` (the links themselves; nothing behind them is visited). Before descending into
  * a folder its real path must still be inside root: a folder swapped for a junction between two looks is not followed.
  */
-export const findLinks = (root) => {
+export function findLinks(root) {
     if (isLink(root))
         return [root];
-    const real = (p) => { try {
-        return fs.realpathSync.native(p).toLowerCase();
-    }
-    catch {
-        return '';
-    } };
+    const real = (p) => {
+        try {
+            return fs.realpathSync.native(p).toLowerCase();
+        }
+        catch {
+            return '';
+        }
+    };
     const top = real(root);
-    const inside = (p) => { const r = real(p); return r !== '' && (r === top || r.startsWith(top + path.sep)); };
+    const inside = (p) => {
+        const r = real(p);
+        return r !== '' && (r === top || r.startsWith(top + path.sep));
+    };
     const walk = (dir) => {
         if (!inside(dir))
             return [];
@@ -66,43 +80,49 @@ export const findLinks = (root) => {
         });
     };
     return dirExists(root) ? walk(root) : [];
-};
-const ResolvedVersions = z.record(z.string(), z.unknown());
+}
+const ResolvedVersionsSchema = z.record(z.string(), z.unknown());
 /** tools\resolved-versions.json is a JSON object (anything else makes the guest stumble). */
-export const resolvedVersionsValid = (text) => {
+export function resolvedVersionsValid(text) {
     try {
-        return ResolvedVersions.safeParse(JSON.parse(text.replace(/^/, ''))).success;
+        return ResolvedVersionsSchema.safeParse(JSON.parse(text.replace(/^\uFEFF/, ''))).success;
     }
     catch {
         return false;
     }
-};
-const NpmList = z.object({ dependencies: z.record(z.string(), z.unknown()).optional() });
+}
+const NpmListSchema = z.object({ dependencies: z.record(z.string(), z.unknown()).optional() });
 /** Package names from `npm ls -g --json`; [] when the output is not what npm prints. */
-export const globalPackages = (json) => {
+export function globalPackages(json) {
     try {
-        return Object.keys(NpmList.parse(JSON.parse(json)).dependencies ?? {});
+        return Object.keys(NpmListSchema.parse(JSON.parse(json)).dependencies ?? {});
     }
     catch {
         return [];
     }
-};
-const Pid = z.coerce.number().int().positive();
-export const pidAlive = (pid) => { try {
-    process.kill(pid, 0);
-    return true;
 }
-catch (e) {
-    return e.code === 'EPERM';
-} };
+const PidSchema = z.coerce.number().int().positive();
+export function pidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e.code === 'EPERM';
+    }
+}
 /** Sync-watcher pid files (storage\run\watcher-*.pid) whose process is gone (or whose content is not a pid). */
-export const deadPidFiles = (runDir, alive = pidAlive) => (dirExists(runDir) ? fs.readdirSync(runDir) : [])
-    .filter((n) => /^watcher-.*\.pid$/i.test(n))
-    .map((n) => path.join(runDir, n))
-    .filter((f) => { try {
-    const pid = Pid.safeParse(fs.readFileSync(f, 'utf8').trim());
-    return !pid.success || !alive(pid.data);
+export function deadPidFiles(runDir, alive = pidAlive) {
+    return (dirExists(runDir) ? fs.readdirSync(runDir) : [])
+        .filter((n) => /^watcher-.*\.pid$/i.test(n))
+        .map((n) => path.join(runDir, n))
+        .filter((f) => {
+        try {
+            const pid = PidSchema.safeParse(fs.readFileSync(f, 'utf8').trim());
+            return !pid.success || !alive(pid.data);
+        }
+        catch {
+            return false;
+        }
+    });
 }
-catch {
-    return false;
-} });

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

@@ -1,12 +1,12 @@
-import { UserError } from '../../../core/util.js';
+import { UserError } from '../../../core/util/index.js';
 import type { CliOptions } from '../../args.js';
 import { type Context } from '../context.js';
 import type { RepairCheck, RepairEnv, RepairResult } from './types.js';
 /** Runs every check in order; a check that throws is reported, never stops the rest. */
-export declare const runChecks: (env: RepairEnv, checks?: RepairCheck[]) => RepairResult[];
-export declare const repair: (ctx: Context, configError?: UserError | null) => number;
+export declare function runChecks(env: RepairEnv, checks?: RepairCheck[]): RepairResult[];
+export declare function repair(ctx: Context, configError?: UserError | null): 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 config problem as the first check.
  */
-export declare const repairCommand: (packageRoot: string, entry: string, options: CliOptions) => number;
+export declare function repairCommand(packageRoot: string, entry: string, options: CliOptions): number;

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

@@ -3,24 +3,40 @@
 // sandbox is running.
 import path from 'node:path';
 import _ from 'lodash';
-import { DEFAULTS, loadConfig, userDir } from '../../../core/config.js';
-import { errMsg, expandPath, UserError } from '../../../core/util.js';
-import { isSandboxRunning } from '../../../host/platform.js';
-import { createContext, printJson, table } from '../context.js';
+import { DEFAULTS, loadConfig, userDir } from '../../../core/config/index.js';
+import { errMsg, expandPath, UserError } from '../../../core/util/index.js';
+import { isSandboxRunning } from '../../../host/sandbox/index.js';
+import { createContext } from '../context.js';
+import { printJson, table } from '../../output/index.js';
 import { CHECKS } from './checks.js';
-const LABEL = { ok: 'OK', fixed: 'FIXED', 'needs-you': 'NEEDS YOU', warn: 'WARNING', skipped: 'SKIPPED' };
+const LABEL = {
+    ok: 'OK',
+    fixed: 'FIXED',
+    'needs-you': 'NEEDS YOU',
+    warn: 'WARNING',
+    skipped: 'SKIPPED',
+};
 /** Runs every check in order; a check that throws is reported, never stops the rest. */
-export const runChecks = (env, checks = CHECKS) => checks.map((check) => {
-    try {
-        return { name: check.name, ...check.run(env) };
-    }
-    catch (e) {
-        const fix = e instanceof UserError && e.fix ? ' ' + e.fix : '';
-        return { name: check.name, status: 'needs-you', detail: 'check failed: ' + errMsg(e) + fix };
-    }
-});
-export const repair = (ctx, configError = null) => {
-    const env = { ctx, running: isSandboxRunning(), dataPath: ctx.dataPath, storageRoot: ctx.storageRoot, toolsDir: path.join(ctx.dataPath, 'tools'), configError };
+export function runChecks(env, checks = CHECKS) {
+    return checks.map((check) => {
+        try {
+            return { name: check.name, ...check.run(env) };
+        }
+        catch (e) {
+            const fix = e instanceof UserError && e.fix ? ' ' + e.fix : '';
+            return { name: check.name, status: 'needs-you', detail: 'check failed: ' + errMsg(e) + fix };
+        }
+    });
+}
+export function repair(ctx, configError = null) {
+    const env = {
+        ctx,
+        running: isSandboxRunning(),
+        dataPath: ctx.dataPath,
+        storageRoot: ctx.storageRoot,
+        toolsDir: path.join(ctx.dataPath, 'tools'),
+        configError,
+    };
     // Re-check the config file even when the context loaded (it may have been edited since, or come from --config).
     if (!env.configError) {
         try {
@@ -38,14 +54,17 @@ export const repair = (ctx, configError = null) => {
         return results.some((r) => r.status === 'needs-you') ? 1 : 0;
     table(results.map((r) => [LABEL[r.status], r.name, r.detail]));
     const counts = _.countBy(results, 'status');
-    console.log('\n' + (counts['needs-you'] ? counts['needs-you'] + ' thing(s) need you (see NEEDS YOU above).' : 'All good' + (counts.fixed ? ': fixed ' + counts.fixed + ' problem(s).' : '.')));
+    console.log('\n' +
+        (counts['needs-you']
+            ? counts['needs-you'] + ' thing(s) need you (see NEEDS YOU above).'
+            : 'All good' + (counts.fixed ? ': fixed ' + counts.fixed + ' problem(s).' : '.')));
     return counts['needs-you'] ? 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 config problem as the first check.
  */
-export const repairCommand = (packageRoot, entry, options) => {
+export function repairCommand(packageRoot, entry, options) {
     let ctx;
     try {
         ctx = createContext(packageRoot, entry, options);
@@ -55,7 +74,14 @@ export const repairCommand = (packageRoot, entry, options) => {
             throw e;
         const loaded = { config: structuredClone(DEFAULTS), configPath: null, base: userDir() };
         const storageRoot = expandPath(loaded.config.storage.root, loaded.base);
-        return repair({ packageRoot, entry, options, loaded, storageRoot, dataPath: path.join(storageRoot, 'data', loaded.config.storage.dataName) }, e);
+        return repair({
+            packageRoot,
+            entry,
+            options,
+            loaded,
+            storageRoot,
+            dataPath: path.join(storageRoot, 'data', loaded.config.storage.dataName),
+        }, e);
     }
     return repair(ctx);
-};
+}

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

@@ -1,4 +1,4 @@
-import type { UserError } from '../../../core/util.js';
+import type { UserError } from '../../../core/util/index.js';
 import type { Context } from '../context.js';
 export type RepairStatus = 'ok' | 'fixed' | 'needs-you' | 'warn' | 'skipped';
 export interface RepairResult {
@@ -18,7 +18,7 @@ export interface RepairCheck {
     name: string;
     run: (env: RepairEnv) => Omit<RepairResult, 'name'>;
 }
-export declare const ok: (detail: string) => 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";

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

@@ -1,3 +1,8 @@
-export const ok = (detail) => ({ status: 'ok', detail });
+export function ok(detail) {
+    return { status: 'ok', detail };
+}
 /** 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 whileRunning = {
+    status: 'skipped',
+    detail: 'a sandbox is running and may be using it; run repair again once it is closed',
+};

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

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

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

@@ -0,0 +1,45 @@
+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 { requireOnPc, requireRunning } from '../context.js';
+import { attachHere, readySandbox } from '../launch/index.js';
+import { locateHere } from '../projects/index.js';
+import { ago } from '../../output/index.js';
+import { projectOf } from './list.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 ?? [];
+    return select({
+        message: 'Which session?' + (here.project ? ' (' + here.project.name + ' first)' : ''),
+        choices: running.map((s) => ({
+            value: s.id,
+            name: (here.guestDir && isWithin(here.guestDir, s.cwd) ? '* ' : '  ') +
+                safeText(s.harness).padEnd(9) +
+                ' ' +
+                safeText(projectOf(projects, s)).padEnd(16) +
+                ' ' +
+                ago(s.startedAt).padEnd(11) +
+                ' ' +
+                s.id,
+        })),
+    });
+}
+export async function attach(ctx) {
+    requireOnPc('attach');
+    requireRunning('Start one with: sandbox claude --terminal');
+    const ready = await readySandbox(ctx.dataPath);
+    const channel = new SandboxChannel(ctx.dataPath);
+    const id = ctx.options.positionals[0];
+    if (!id && channel.runningSessions().length === 0)
+        await sleep(1500);
+    const here = locateHere(ctx, ready);
+    if (id)
+        return attachHere(ctx, channel.pickSession(id));
+    // Several sessions: choose, this folder's project first (the newest is the default).
+    const running = sessionsFirstIn(channel.runningSessions(), 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));
+}

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

@@ -0,0 +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>;