windows-development-sandbox 1.5.0 → 1.9.0

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

@@ -1,246 +0,0 @@
-// The repair checks, in the order they run. Each either confirms all is well, fixes the problem itself, or says what
-// you need to do. Nothing under the data folder is followed through a link.
-import fs from 'node:fs';
-import path from 'node:path';
-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/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 { ok, whileRunning } from './types.js';
-function rel(root, p) {
-    return path.relative(root, p) || '.';
-}
-/** Fails (throws) unless every folder from the data folder to `p` is real. */
-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.'),
-    },
-    {
-        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).',
-            },
-    },
-    {
-        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).',
-                };
-            // A running sandbox can swap folders for links while we look; only check a stopped one.
-            if (env.running)
-                return whileRunning;
-            const links = findLinks(env.dataPath);
-            if (!links.length)
-                return ok('none (nothing in ' + env.dataPath + ' points elsewhere).');
-            // A link here can only have been made inside the sandbox; it could point at this PC's own files. Remove the link
-            // itself, and only if every folder above it is still real.
-            for (const link of links) {
-                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(', '),
-            };
-        },
-    },
-    {
-        name: 'Sandbox run state',
-        run: (env) => {
-            if (env.running)
-                return ok('a sandbox is running; its state is in use.');
-            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 = 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.');
-            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.',
-            };
-        },
-    },
-    {
-        name: 'Hidden-window state',
-        run: (env) => {
-            const file = path.join(env.storageRoot, 'run', 'hidden-windows.json');
-            if (!fs.existsSync(file) && !isLink(file))
-                return ok('clean.');
-            if (env.running)
-                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.',
-            };
-        },
-    },
-    {
-        name: 'Sync watcher',
-        run: (env) => {
-            const dead = deadPidFiles(path.join(env.storageRoot, 'run'));
-            if (!dead.length)
-                return ok('no stale watcher records.');
-            for (const f of dead) {
-                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).',
-            };
-        },
-    },
-    {
-        name: 'Interrupted downloads',
-        run: (env) => {
-            if (env.running)
-                return whileRunning;
-            guard(env, env.toolsDir);
-            const found = findStagingLeftovers(env.toolsDir);
-            if (!found.length)
-                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(', '),
-            };
-        },
-    },
-    {
-        name: 'Half-installed toolchains',
-        run: (env) => {
-            if (env.running)
-                return whileRunning;
-            guard(env, env.toolsDir);
-            const found = findHalfInstalled(env.toolsDir);
-            if (!found.length)
-                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.',
-            };
-        },
-    },
-    {
-        name: 'Resolved versions cache',
-        run: (env) => {
-            const file = path.join(env.toolsDir, 'resolved-versions.json');
-            if (!fs.existsSync(file) && !isLink(file))
-                return ok('not created yet.');
-            if (env.running)
-                return whileRunning;
-            guard(env, env.toolsDir);
-            if (isLink(file)) {
-                removeLink(file);
-                return { status: 'fixed', detail: 'removed a link in place of tools\\resolved-versions.json.' };
-            }
-            if (fs.statSync(file).size < 4 * 1024 * 1024 && resolvedVersionsValid(fs.readFileSync(file, 'utf8')))
-                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).',
-            };
-        },
-    },
-    {
-        name: 'Installed packages',
-        run: () => {
-            const npmCli = path.join(path.dirname(process.execPath), 'node_modules', 'npm', 'bin', 'npm-cli.js');
-            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 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.');
-        },
-    },
-    {
-        name: 'Free disk',
-        run: (env) => {
-            const free = freeBytesAt(env.storageRoot);
-            if (free === null)
-                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>',
-            };
-        },
-    },
-];

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

@@ -1,4 +0,0 @@
-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(asked: Context): Promise<number>;

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

@@ -1,66 +0,0 @@
-import path from 'node:path';
-import { askYesNo } from '../../../core/prompt.js';
-import { fail, safeText } from '../../../core/util/index.js';
-import { SandboxChannel } from '../../../host/channel/index.js';
-import { runningOwner } from '../../../host/sharing/index.js';
-import { useSharedSandbox } from '../shared-use.js';
-import { requireOnPc, requireRunning } from '../context.js';
-import { working, c } from '../../output/index.js';
-import { SandboxService, SessionsService } from '../../services/index.js';
-/** Restarts this folder's project's sessions (--all: every session). */
-export async function restart(ctx) {
-    requireOnPc('restart');
-    requireRunning();
-    await useSharedSandbox(ctx, { kind: 'owner-only', what: 'restart the agents' });
-    const service = new SessionsService(ctx);
-    const scope = service.restartScope(Boolean(ctx.options.all));
-    if (scope.notAProject)
-        console.log(c.dim(scope.folder + ' is not a project of the running sandbox: restarting every session.'));
-    console.log(safeText(await working('Restarting the agents' + (scope.guest ? ' of ' + scope.projectName : ''), () => service.restart(ctx.options.harness ?? null, scope.guest))));
-    return 0;
-}
-/**
- * Stopping ends every project's sessions: other projects' sessions need a yes (or --yes). A script must never end them
- * by accident, so without a terminal to ask in it fails.
- */
-async function othersMayEnd(ctx, others) {
-    if (!others.length || ctx.options.yes)
-        return true;
-    const interactive = process.stdin.isTTY && process.stdout.isTTY;
-    if (!interactive)
-        fail(others.length + ' of these sessions belong to other projects, so the sandbox was not stopped.', 'Stop it anyway with: sandbox stop --yes');
-    return askYesNo(others.length + ' of them belong to other projects. Stop the whole sandbox?');
-}
-export async function stop(asked) {
-    requireOnPc('stop');
-    if (!new SandboxService(asked).isRunning()) {
-        console.log('No Windows Sandbox is running.');
-        return 0;
-    }
-    // Another user's sandbox: only when shared, and only after typing their name (--yes in scripts).
-    let ctx = asked;
-    if (runningOwner().kind !== 'mine') {
-        ctx = await useSharedSandbox(asked, (shared) => ({
-            kind: 'stop',
-            sessions: new SandboxChannel(shared.dataPath).currentSessions().length,
-        }));
-    }
-    const service = new SandboxService(ctx);
-    // Stopping ends every project's sessions, not just this folder's: say which, and ask when others would end too.
-    const { sandbox, running, others } = service.stopPlan();
-    if (running.length)
-        console.log('Stopping ends ' +
-            running.length +
-            ' session(s): ' +
-            running
-                .map((s) => safeText(s.harness) + ' in ' + safeText(s.project ?? path.win32.basename(s.cwd)))
-                .join(', ') +
-            '.');
-    if (!(await othersMayEnd(ctx, others))) {
-        console.log('Nothing changed.');
-        return 1;
-    }
-    await working('Asking the sandbox to shut down', () => service.shutdown(sandbox));
-    console.log('Sandbox is shutting down; history and claude-mem sync back when it closes.');
-    return 0;
-}

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

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

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

@@ -1,45 +0,0 @@
-import _ from 'lodash';
-import { safeText } from '../../../core/util/index.js';
-import { printJson, table, ago, c, shortenMiddle, termWidth } from '../../output/index.js';
-import { SessionsService, viewerText } from '../../services/index.js';
-import { lookAtSandbox } from '../shared-use.js';
-export async function sessions(asked) {
-    // Another user's sandbox: shared, its sessions are listed from their folders; not shared, only whose it is.
-    const view = lookAtSandbox(asked);
-    const ctx = view.ctx;
-    if (view.limited) {
-        if (!printJson(ctx, []))
-            console.log(view.line);
-        return 0;
-    }
-    if (view.line && !ctx.options.json)
-        console.log(c.bold(view.line));
-    const service = new SessionsService(ctx);
-    const list = await service.list();
-    if (printJson(ctx, list.map((s) => _.omit(s, 'attach'))))
-        return 0;
-    if (list.length === 0) {
-        console.log('No sessions. Start one with: sandbox claude');
-        return 0;
-    }
-    // Harness, cwd and times are written by the sandbox.
-    const folderWidth = Math.max(16, termWidth() - 80);
-    table([
-        ['', 'ID', 'AGENT', 'PROJECT', 'STATE', 'ATTACHED', 'FOLDER', 'STARTED'],
-        ...service
-            .ordered(list)
-            .map((s) => [
-            s.here ? '*' : '',
-            s.id,
-            safeText(s.harness),
-            safeText(s.projectName ?? '-'),
-            s.phase + (s.exitCode !== undefined ? ' (' + s.exitCode + ')' : ''),
-            viewerText(s.viewers),
-            shortenMiddle(safeText(s.cwd), folderWidth),
-            ago(s.startedAt),
-        ]),
-    ]);
-    if (list.some((s) => s.here))
-        console.log(c.dim('* = the project of this folder'));
-    return 0;
-}

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

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

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

@@ -1,93 +0,0 @@
-import _ from 'lodash';
-import { safeText } from '../../../core/util/index.js';
-import { printJson, table, ago, c, shortenMiddle, termWidth } from '../../output/index.js';
-import { SandboxService } from '../../services/index.js';
-import { lookAtSandbox } from '../shared-use.js';
-const MECHANISM_TEXT = {
-    launch: 'started from here',
-    root: 'in a project root',
-    boot: 'mapped at start',
-};
-function mechanismText(mechanism) {
-    return mechanism in MECHANISM_TEXT ? MECHANISM_TEXT[mechanism] : 'wsb share';
-}
-function printProject(p) {
-    console.log((p.here ? '* ' : '  ') +
-        c.bold(p.name) +
-        '  ' +
-        p.host +
-        '  ->  ' +
-        p.guest +
-        c.dim('  (' + mechanismText(p.mechanism) + ')'));
-    console.log('      setup: ' +
-        p.setup.phase +
-        (p.setup.phase === 'ready' ? '' : ' - ' + shortenMiddle(p.setup.message, termWidth() - 20)));
-    if (p.databases.length)
-        console.log('      databases: ' + p.databases.map((d) => d.database + ' :' + d.port + ' ' + d.state).join(', '));
-    for (const s of p.sessions)
-        console.log('      session ' + s.id + '  ' + s.harness + '  ' + s.viewers + '  ' + ago(s.started));
-    for (const f of p.repoGuard)
-        console.log('      ' + c.yellow('guard: ' + f));
-}
-export async function status(asked) {
-    // Another user's sandbox: shared, it is shown from their folders; not shared, only whose it is.
-    const view = lookAtSandbox(asked);
-    const ctx = view.ctx;
-    if (view.limited) {
-        const owner = view.owner;
-        const user = owner?.kind === 'other' ? owner.user : null;
-        if (!printJson(ctx, { sandbox: { running: true, shared: false, startedBy: user } }))
-            console.log(view.line);
-        return 0;
-    }
-    const report = await new SandboxService(ctx).status();
-    const { startedAt, ...state } = report.sandbox;
-    const info = {
-        // Same keys and order as the service's state, with the start time shown as an uptime.
-        sandbox: {
-            ...(ctx.borrowed ? { startedBy: ctx.borrowed.user, shared: true } : {}),
-            running: state.running,
-            phase: state.phase,
-            message: state.message,
-            headless: state.headless,
-            uptime: state.running && startedAt ? ago(startedAt).replace(' ago', '') : null,
-            daemon: state.daemon,
-            account: state.account,
-            syncWatcher: state.syncWatcher,
-        },
-        here: report.here,
-        roots: report.roots,
-        projects: report.projects,
-        otherSessions: report.otherSessions,
-        repoGuard: report.repoGuard,
-    };
-    if (printJson(ctx, info))
-        return 0;
-    const yesNo = (v) => (typeof v === 'boolean' ? (v ? 'yes' : 'no') : String(v ?? '-'));
-    if (view.line)
-        console.log(c.bold(view.line) + c.dim('. Its window is on their desktop; use its agents here.'));
-    table(Object.entries(info.sandbox).map(([k, v]) => [_.startCase(k), safeText(yesNo(v))]));
-    if (!state.running)
-        return 0;
-    console.log('\n' +
-        c.bold('Projects') +
-        c.dim('  (* = this folder: ' + info.here.folder + (info.here.project ? '' : ', not in this sandbox') + ')'));
-    for (const p of info.projects)
-        printProject(p);
-    for (const r of info.roots)
-        console.log('  root  ' + r.host + '  ->  ' + r.guest + c.dim('  (every project in it opens without a restart)'));
-    for (const s of info.otherSessions)
-        console.log('  session ' + s.id + '  ' + s.harness + '  ' + s.cwd);
-    const findings = info.repoGuard.findings;
-    console.log('\n' +
-        c.bold('Repo guard') +
-        '  ' +
-        info.repoGuard.guarded +
-        ' folder(s) guarded; ' +
-        (findings.length
-            ? c.yellow(findings.length + ' change(s) neutralised:')
-            : 'nothing from the sandbox needed neutralising'));
-    for (const f of findings.slice(-10))
-        console.log('  ' + c.yellow(safeText(f)));
-    return 0;
-}

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

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

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

@@ -1,18 +0,0 @@
-import { requireOnPc, requireRunning } from '../context.js';
-import { SandboxService } from '../../services/index.js';
-import { useSharedSandbox } from '../shared-use.js';
-export async function show(ctx) {
-    requireOnPc('show');
-    requireRunning();
-    await useSharedSandbox(ctx, { kind: 'owner-only', what: 'show the window', window: true });
-    new SandboxService(ctx).showWindow();
-    return 0;
-}
-export async function hide(ctx) {
-    requireOnPc('hide');
-    requireRunning();
-    await useSharedSandbox(ctx, { kind: 'owner-only', what: 'hide the window', window: true });
-    await new SandboxService(ctx).hideWindow();
-    console.log('Sandbox window hidden. Bring it back with: sbx-show');
-    return 0;
-}

package/dist/cli/menu/pages/start-page.d.ts

@@ -1,43 +0,0 @@
-import type { Context } from '../../commands/context.js';
-import { type App, type ListOptions, type ListResult } from '../../tui/index.js';
-import { ListPage, type Outcome } from './list-page.js';
-export type WindowChoice = 'config' | 'hide' | 'show';
-export interface StartModel {
-    readonly folder: string;
-    readonly defaultAgent: string;
-    readonly agents: readonly {
-        readonly name: string;
-        readonly ready: boolean;
-    }[];
-    readonly last: string[] | undefined;
-    readonly attach: boolean;
-    readonly window: WindowChoice;
-    /** Agents that can be run on this PC without the sandbox (see hostAgentsToShow). */
-    readonly hostAgents: readonly string[];
-}
-/**
- * The "not sandboxed" entries: only while agent commands are on (typing the agent then starts the sandbox, so a way to
- * run the real one is needed), one per agent found installed on this PC.
- */
-export declare function hostAgentsToShow(enabled: boolean, found: readonly {
-    harness: string;
-}[]): string[];
-/** The command line a start stands for. Pure. */
-export declare function startArgv(m: StartModel, agent: string, cwd: string): string[];
-/** The list for the start tab. Pure. */
-export declare function startOptions(m: StartModel, cwd?: string): ListOptions<string>;
-export declare class StartPage extends ListPage<string> {
-    private readonly ctx;
-    readonly label = "Start";
-    private attach;
-    private window;
-    private folder;
-    private model;
-    constructor(app: App, ctx: Context);
-    /** Is this agent already in the sandbox's persistent storage (so starting it needs no install)? */
-    private installed;
-    private current;
-    protected load(): Promise<void>;
-    protected options(): ListOptions<string>;
-    protected act(result: ListResult<string>): Promise<Outcome<string>>;
-}