windows-development-sandbox 1.4.1 → 1.5.0

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

@@ -0,0 +1,106 @@
+// The last way in for a folder the running sandbox cannot show (not in a project root, no `wsb share`): restart it
+// with that folder mapped as well. Only ever with your consent (a prompt, or --yes): it lists what will end, stops
+// the sandbox cleanly (history and claude-mem sync back as on any close), starts it again from the same launch
+// folder with the projects it had plus the new one, reopens the sessions it ended (continuing their conversations
+// where the agent supports it) and then starts the new project's session.
+import path from 'node:path';
+import _ from 'lodash';
+import { askYesNo } from '../../../core/prompt.js';
+import { missingTip } from '../../../core/local-config/index.js';
+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 { 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. */
+function againWithYes(ctx) {
+    return ('sandbox ' +
+        (ctx.options.noAgent ? 'start' : (ctx.options.harness ?? ctx.loaded.config.defaultHarness)) +
+        (ctx.options.terminal ? ' -t' : '') +
+        ' --yes');
+}
+/** 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)
+            .catch(() => null);
+        for (let i = 0; i < 180 && isSandboxRunning(); i++)
+            await sleep(1000);
+        if (isSandboxRunning())
+            fail('The sandbox did not shut down within 3 minutes.', 'Close its window yourself, then run the command again.');
+        // The watcher syncs history back a few seconds after the window closes; the next start needs it gone.
+        for (let i = 0; i < 60 && watcherRunning(ctx.dataPath); i++)
+            await sleep(1000);
+    });
+}
+/**
+ * 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).
+ */
+function explain(needs, hidden, registry, sessions) {
+    for (const need of hidden)
+        console.log(c.yellow('Windows Sandbox cannot add ' + need.hostDir + ' while it runs: ' + need.reason + '.'));
+    console.log((hidden.length
+        ? 'A restart maps ' + (hidden.length === 1 ? 'it' : 'them') + ' as well'
+        : 'Restarting with what ' + needs.map((n) => path.basename(n.hostDir)).join(', ') + ' wants') +
+        ' (and keeps ' +
+        registry.projects.map((p) => p.host).join(', ') +
+        '). ' +
+        (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 + '"'));
+    for (const need of needs)
+        if (need.missing)
+            console.log(c.dim(missingTip(need.missing)));
+}
+/** --yes, or a yes at the prompt; without a terminal to ask in, it fails with the command to run. */
+async function consented(ctx) {
+    if (ctx.options.yes)
+        return true;
+    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? (its sessions reopen and continue)');
+}
+export async function offerRestart(ctx, needs, then, relauncher) {
+    const folders = needs.map((n) => n.hostDir);
+    const registry = new ProjectRegistry(ctx.storageRoot).read() ??
+        fail('The running sandbox was started by an older version, so it cannot take another folder.', 'Stop it (sandbox stop) and start it again from ' + folders[0] + '.');
+    const primary = registry.projects.find((p) => p.primary) ??
+        fail('The running sandbox has no launch folder on record.', 'Stop it (sandbox stop) and start it again.');
+    const sessions = new SandboxChannel(ctx.dataPath).currentSessions();
+    const hidden = needs.filter((n) => !n.missing);
+    explain(needs, hidden, registry, sessions);
+    if (hidden.length && !(await consented(ctx))) {
+        console.log('Nothing changed.');
+        return 1;
+    }
+    const reopen = sessionsToReopen(registry, sessions);
+    await stopAndWait(ctx);
+    markRestarted();
+    const keep = registry.projects.filter((p) => !p.primary && p.mechanism !== 'root').map((p) => p.host);
+    const harness = ctx.options.harness ?? ctx.options.sessions[0]?.harness;
+    const relaunch = freshContext(ctx, primary.host, harness, { noAgent: false });
+    await relauncher.launch(relaunch, false, {
+        extraProjects: [...keep, ...folders],
+        autoSession: false,
+        waitUntilReady: true,
+    });
+    const ready = await relauncher.readySandbox(ctx.dataPath);
+    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.d.ts

@@ -0,0 +1,3 @@
+import type { Context } from './context.js';
+export type Handler = (ctx: Context) => number | Promise<number | void>;
+export declare const HANDLERS: Readonly<Partial<Record<string, Handler>>>;

package/dist/cli/commands/registry.js

@@ -0,0 +1,38 @@
+import { launch } from './launch/index.js';
+import { setup } from './setup/index.js';
+import { data } from './data/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, hostCommand, logs, migrate, sync, watcher, } from './maintenance/index.js';
+import { resume } from './resume.js';
+import { agentCommandsCommand } from './agent-commands.js';
+export const HANDLERS = {
+    launch: (ctx) => launch(ctx),
+    generate: (ctx) => launch(ctx, true),
+    attach: attach,
+    sessions: sessions,
+    status: status,
+    exec: exec,
+    'agent-commands': agentCommandsCommand,
+    db: db,
+    restart: restart,
+    resume: resume,
+    stop: stop,
+    show: show,
+    hide: hide,
+    account: account,
+    projects: projects,
+    sync: sync,
+    logs: logs,
+    audit: audit,
+    clean: clean,
+    config: config,
+    doctor: doctor,
+    migrate: migrate,
+    setup: setup,
+    data: data,
+    'host-claude': claudeHost,
+    host: hostCommand,
+    _watch: watcher,
+};

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,9 @@
-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 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;