windows-development-sandbox 1.5.0 → 1.7.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/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>>;
-}

package/dist/cli/menu/pages/start-page.js

@@ -1,192 +0,0 @@
-// Tab 1: start an agent here. The agents are listed (Enter starts one), with the few options that matter right under
-// them; everything else is behind "More options…" (the full start form).
-import fs from 'node:fs';
-import path from 'node:path';
-import { commandLine, readHistory } from '../../history.js';
-import { AgentCommandsService } from '../../services/index.js';
-import { commandSpec } from '../../manifest.js';
-import { Text, Theme } from '../../tui/index.js';
-import { CommandForm } from '../command-form.js';
-import { SeveralAgents } from '../several.js';
-import { ListPage } from './list-page.js';
-/**
- * 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 function hostAgentsToShow(enabled, found) {
-    return enabled ? found.map((a) => a.harness) : [];
-}
-const WINDOW_TEXT = { config: 'as configured', hide: 'hidden', show: 'shown' };
-/** The command line a start stands for. Pure. */
-export function startArgv(m, agent, cwd) {
-    return [
-        'launch',
-        '--harness',
-        agent,
-        ...(m.attach ? ['--terminal'] : []),
-        ...(m.window === 'hide' ? ['--headless'] : m.window === 'show' ? ['--window'] : []),
-        ...(path.resolve(m.folder).toLowerCase() === path.resolve(cwd).toLowerCase() ? [] : ['--workspace', m.folder]),
-    ];
-}
-/** The list for the start tab. Pure. */
-export function startOptions(m, cwd = process.cwd()) {
-    const section = 'Start in ' + path.basename(m.folder);
-    const agents = [...m.agents].sort((a, b) => Number(b.name === m.defaultAgent) - Number(a.name === m.defaultAgent));
-    return {
-        path: [],
-        intro: m.folder,
-        items: [
-            ...(m.last
-                ? [
-                    {
-                        value: 'repeat',
-                        label: 'Repeat last',
-                        section: 'Quick start',
-                        hint: Theme.muted(Text.truncate(commandLine(m.last), 50)),
-                        description: 'Runs the last command again.',
-                    },
-                ]
-                : []),
-            ...agents.map((a) => ({
-                value: 'agent:' + a.name,
-                label: 'Start ' + a.name,
-                section,
-                hint: (a.name === m.defaultAgent ? Theme.accent('default  ') : '') +
-                    (a.ready ? Theme.ok('ready') : Theme.muted('installs on first start')),
-                description: 'Runs: ' + commandLine(startArgv(m, a.name, cwd)),
-            })),
-            {
-                value: 'opt:attach',
-                label: 'Attach this terminal',
-                section: 'Options',
-                hint: m.attach ? Theme.ok('yes') : Theme.muted('no'),
-                description: 'Shows the agent in this terminal (Ctrl+] detaches). Without it the agent runs in the sandbox.',
-            },
-            {
-                value: 'opt:window',
-                label: 'Sandbox window',
-                section: 'Options',
-                hint: WINDOW_TEXT[m.window],
-                description: 'Hide or show the Windows Sandbox window (sbx-show brings a hidden one back).',
-            },
-            {
-                value: 'opt:folder',
-                label: 'Folder',
-                section: 'Options',
-                hint: Text.middle(m.folder, 40),
-                description: 'The project folder to work on.',
-            },
-            ...m.hostAgents.map((agent) => ({
-                value: 'host:' + agent,
-                label: 'Run ' + agent + ' on this PC (not sandboxed)',
-                section: 'Not sandboxed',
-                description: 'Runs the real ' + agent + ' on this PC, with no sandbox around it.',
-            })),
-            {
-                value: 'more',
-                label: 'More options…',
-                section: 'More',
-                description: 'Node and Python versions, databases, scripts and the rest of the start form.',
-            },
-            {
-                value: 'several',
-                label: 'Start several agents…',
-                section: 'More',
-                description: 'One or more projects, one or more agents each, all in one sandbox.',
-            },
-            {
-                value: 'noagent',
-                label: 'Start a sandbox without an agent…',
-                section: 'More',
-                description: 'Tools and databases only.',
-            },
-        ],
-        enterLabel: 'start',
-        escapeLabel: 'quit',
-    };
-}
-export class StartPage extends ListPage {
-    ctx;
-    label = 'Start';
-    attach = false;
-    window = 'config';
-    folder = process.cwd();
-    model;
-    constructor(app, ctx) {
-        super(app);
-        this.ctx = ctx;
-    }
-    /** Is this agent already in the sandbox's persistent storage (so starting it needs no install)? */
-    installed(name) {
-        const h = this.ctx.loaded.config.harnesses[name];
-        const dir = path.join(this.ctx.dataPath, 'tools', 'agents', name);
-        return (Boolean(h) &&
-            [h.hostExecutable, h.npmBin && h.npmBin + '.cmd', h.uvBin && h.uvBin + '.exe'].some((f) => f && fs.existsSync(path.join(dir, f))));
-    }
-    current() {
-        const config = this.ctx.loaded.config;
-        const commands = new AgentCommandsService(this.ctx).status();
-        return {
-            folder: this.folder,
-            defaultAgent: config.defaultHarness,
-            agents: Object.keys(config.harnesses).map((name) => ({ name, ready: this.installed(name) })),
-            last: readHistory()[0]?.argv,
-            attach: this.attach,
-            window: this.window,
-            hostAgents: hostAgentsToShow(commands.enabled, commands.found),
-        };
-    }
-    load() {
-        this.model = this.current();
-        return Promise.resolve();
-    }
-    options() {
-        this.model = this.current();
-        return startOptions(this.model);
-    }
-    async act(result) {
-        if (result.kind !== 'pick')
-            return {};
-        const id = result.value;
-        const model = this.current();
-        if (id.startsWith('host:'))
-            return { exit: { kind: 'run', argv: ['host', id.slice(5)] } };
-        if (id.startsWith('agent:'))
-            return { exit: { kind: 'run', argv: startArgv(model, id.slice(6), process.cwd()) } };
-        switch (id) {
-            case 'repeat':
-                return model.last ? { exit: { kind: 'run', argv: model.last } } : {};
-            case 'opt:attach':
-                this.attach = !this.attach;
-                return {};
-            case 'opt:window':
-                this.window = this.window === 'config' ? 'hide' : this.window === 'hide' ? 'show' : 'config';
-                return {};
-            case 'opt:folder': {
-                const typed = await this.app.text({
-                    path: ['Start', 'Folder'],
-                    label: 'Project folder',
-                    initial: this.folder,
-                    validate: (v) => (fs.existsSync(path.resolve(v)) ? true : 'That folder does not exist.'),
-                });
-                if (typed)
-                    this.folder = path.resolve(typed);
-                return {};
-            }
-            case 'more': {
-                const argv = await new CommandForm(this.app, this.ctx, commandSpec('launch'), startArgv(model, model.defaultAgent, process.cwd()).slice(1)).run();
-                return argv ? { exit: { kind: 'run', argv } } : {};
-            }
-            case 'several': {
-                const argv = await new SeveralAgents(this.app, this.ctx).run();
-                return argv ? { exit: { kind: 'run', argv } } : {};
-            }
-            case 'noagent': {
-                const argv = await new CommandForm(this.app, this.ctx, commandSpec('start')).run();
-                return argv ? { exit: { kind: 'run', argv } } : {};
-            }
-            default:
-                return {};
-        }
-    }
-}

package/dist/cli/tui/tab-bar.d.ts

@@ -1,9 +0,0 @@
-export interface TabInfo {
-    readonly label: string;
-    /** Something is waiting in this tab (unsaved changes). */
-    readonly marked?: boolean;
-}
-export declare class TabBar {
-    /** One line, exactly `width` columns wide: full names, then tighter, then numbers, then only the open tab. */
-    static render(tabs: readonly TabInfo[], active: number, width: number): string;
-}

package/dist/cli/tui/tab-bar.js

@@ -1,33 +0,0 @@
-// The tabs across the top of every screen: a number and a name each, shortened when the terminal is narrow.
-import { Text } from './text.js';
-import { Theme } from './theme.js';
-export class TabBar {
-    /** One line, exactly `width` columns wide: full names, then tighter, then numbers, then only the open tab. */
-    static render(tabs, active, width) {
-        const paint = (text, on) => (on ? Theme.selected(text) : Theme.muted(text));
-        const mark = (tab) => (tab.marked ? Theme.changed(Theme.glyph.changed) : '');
-        const build = (pad, shown) => tabs
-            .map((tab, i) => {
-            const text = shown(i) + (tab.marked ? ' ' + Text.strip(mark(tab)) : '');
-            // The open tab is in brackets too, so it shows without colour.
-            if (i === active) {
-                const space = ' '.repeat(Math.max(0, pad - 1));
-                return paint(space + '[' + text + ']' + space, true);
-            }
-            return paint(' '.repeat(pad) + text + ' '.repeat(pad), false);
-        })
-            .join('');
-        const full = (i) => i + 1 + ' ' + tabs[i].label;
-        const attempts = [
-            build(2, full),
-            build(1, full),
-            build(1, (i) => (i === active ? full(i) : String(i + 1))),
-            build(0, (i) => (i === active ? full(i) : String(i + 1))),
-        ];
-        const fits = attempts.find((line) => Text.width(line) <= width - 1);
-        if (fits)
-            return Text.fit(fits, width);
-        const only = '[' + (active + 1) + '/' + tabs.length + ' ' + tabs[active].label + ']';
-        return Text.fit(Theme.selected(only), width);
-    }
-}