windows-development-sandbox 1.5.0 → 1.7.0

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

@@ -1,11 +1,12 @@
 // `sandbox projects`: which projects a sandbox can open without a restart. Project roots (whole folders of projects),
-// the projects this tool has started before, and projects.all / projects.exclude. Changes to what is mapped take
+// the projects this tool has started before, and the all-projects and exclude settings. Changes to what is mapped take
 // effect at the next start; a project you start while a sandbox runs joins it when it can (projects.ts in host/).
 import path from 'node:path';
 import { checkbox } from '@inquirer/prompts';
+import { askChoice } from '../../../core/prompt.js';
 import { fail } from '../../../core/util/index.js';
 import { isSandboxRunning } from '../../../host/sandbox/index.js';
-import { c, pageSizeFor, shortenMiddle, termWidth, printJson, table } from '../../output/index.js';
+import { c, nextStep, pageSizeFor, shortenMiddle, termWidth, printJson, table } from '../../output/index.js';
 import { ProjectsService } from '../../services/index.js';
 const NEXT_START = 'This changes what is mapped from the next start.';
 function runningNote() {
@@ -18,7 +19,7 @@ function list(ctx, service) {
     const rows = listing.projects;
     if (printJson(ctx, { all: listing.all, roots: listing.roots, exclude: listing.exclude, projects: rows }))
         return 0;
-    console.log(c.bold('projects.all') +
+    console.log(c.bold('All projects') +
         ': ' +
         (listing.all ? 'on (every project below is mapped at every start, except excluded ones)' : 'off') +
         c.dim('   sandbox projects all on|off'));
@@ -42,7 +43,7 @@ function list(ctx, service) {
     console.log(c.dim('* = this folder.  Choose with: sandbox projects choose'));
     return 0;
 }
-/** Ticks the projects mapped at every start (turns projects.all on when any is ticked); the rest are excluded. */
+/** Ticks the projects mapped at every start (any ticked turns all-projects on); the rest are excluded. */
 async function choose(service) {
     const rows = service.rows().filter((r) => !r.root);
     if (!rows.length) {
@@ -65,14 +66,22 @@ async function choose(service) {
     console.log(mapped + ' project(s) mapped at every start, ' + excluded + ' excluded. ' + NEXT_START + runningNote());
     return 0;
 }
+/** The folder typed, or one picked from the known projects (or this folder) when it was left out. */
+async function folderOf(service, action, given) {
+    if (given)
+        return given;
+    const rows = service.rows();
+    return askChoice('Which folder?', [
+        { name: 'This folder (' + shortenMiddle(process.cwd(), termWidth() - 30) + ')', value: '.' },
+        ...rows.filter((r) => !r.here).map((r) => ({ name: shortenMiddle(r.folder, termWidth() - 12), value: r.folder })),
+    ], 'Usage: sandbox projects ' + action + ' <folder>   (. = this folder)');
+}
 function add(service, value) {
     const dir = service.add(value);
-    console.log('Added ' +
-        dir +
-        ' to your projects.' +
-        (service.settings().all
-            ? ' ' + NEXT_START
-            : ' It is mapped at every start once projects.all is on (sandbox projects all on).'));
+    const all = service.settings().all;
+    console.log('Added ' + dir + ' to your projects.' + (all ? ' ' + NEXT_START : ''));
+    if (!all)
+        nextStep('sandbox projects all on   (map every project at every start)');
     return 0;
 }
 function remove(service, value) {
@@ -88,18 +97,18 @@ function includeOrExclude(service, action, value) {
         ? (action === 'exclude' ? 'Excluded ' : 'Included ') + path.resolve(value) + '. ' + NEXT_START
         : 'Nothing changed.') +
         (action === 'include' && !service.settings().all
-            ? ' projects.all is off: sandbox projects all on maps your projects at every start.'
+            ? ' Mapping all projects is off: sandbox projects all on maps your projects at every start.'
             : '') +
         (changed ? runningNote() : ''));
     return 0;
 }
 function all(service, value) {
     if (value === undefined) {
-        console.log('projects.all is ' + (service.settings().all ? 'on' : 'off') + '.');
+        console.log('Mapping all projects at every start is ' + (service.settings().all ? 'on' : 'off') + '.');
         return 0;
     }
     service.setAll(value === 'on');
-    console.log('projects.all is ' +
+    console.log('Mapping all projects at every start is ' +
         value +
         '. ' +
         NEXT_START +
@@ -137,17 +146,17 @@ export async function projects(ctx) {
         case 'choose':
             return choose(service);
         case 'add':
-            return add(service, value);
+            return add(service, await folderOf(service, action, value));
         case 'remove':
-            return remove(service, value);
+            return remove(service, await folderOf(service, action, value));
         case 'include':
         case 'exclude':
-            return includeOrExclude(service, action, value);
+            return includeOrExclude(service, action, await folderOf(service, action, value));
         case 'all':
             return all(service, value);
         case 'roots':
             return roots(service, value, folder);
         default:
-            return fail('Unknown projects action "' + action + '".');
+            return fail('Unknown projects action "' + action + '".', 'Use: sandbox projects list | choose | add | remove | include | exclude | all | roots');
     }
 }

package/dist/cli/commands/registry.js

@@ -1,12 +1,15 @@
 import { launch } from './launch/index.js';
 import { setup } from './setup/index.js';
 import { data } from './data/index.js';
+import { storage } from './storage/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';
+import { vpn } from './vpn.js';
+import { web, webServer } from './web.js';
 export const HANDLERS = {
     launch: (ctx) => launch(ctx),
     generate: (ctx) => launch(ctx, true),
@@ -32,7 +35,11 @@ export const HANDLERS = {
     migrate: migrate,
     setup: setup,
     data: data,
+    storage: storage,
     'host-claude': claudeHost,
     host: hostCommand,
     _watch: watcher,
+    vpn: vpn,
+    web: web,
+    _web: webServer,
 };

package/dist/cli/commands/repair/checks/agents.d.ts

@@ -0,0 +1,2 @@
+import type { Check } from '../types.js';
+export declare const AGENT_CHECKS: Check[];

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

@@ -0,0 +1,70 @@
+// Agents: is the default agent one of those configured, and for each agent that keeps a login, is a saved login in
+// use in this data folder. Looks only; logins are never changed here.
+import { errMsg } from '../../../../core/util/index.js';
+import { AccountStore, AgentAccountStore } from '../../../../host/profile/index.js';
+import { ok, plural } from './common.js';
+function rowsOf(env, name, loginFiles) {
+    if (name === 'claude')
+        return new AccountStore(env.storageRoot).list(env.dataPath);
+    return loginFiles ? new AgentAccountStore(env.storageRoot, name, loginFiles).list(env.dataPath) : [];
+}
+export const AGENT_CHECKS = [
+    {
+        id: 'agents-default',
+        group: 'Agents & tools',
+        name: 'Default agent',
+        run: (env) => {
+            const config = env.ctx.loaded.config;
+            const name = env.ctx.options.harness ?? config.defaultHarness;
+            const harness = config.harnesses[name];
+            if (!harness)
+                return {
+                    status: 'needs-you',
+                    detail: '"' + name + '" is not one of your configured agents (' + Object.keys(config.harnesses).join(', ') + ')',
+                    means: 'sandbox launch has no agent to start.',
+                    fix: 'Set defaultHarness in your settings to one of those names (sandbox config path shows the file).',
+                };
+            return ok(name + ' (' + plural(Object.keys(config.harnesses).length, 'agent') + ' configured)');
+        },
+    },
+    {
+        id: 'agents-logins',
+        group: 'Agents & tools',
+        name: 'Agent logins',
+        run: (env) => {
+            const harnesses = env.ctx.loaded.config.harnesses;
+            const lines = [];
+            const idle = [];
+            for (const [name, harness] of Object.entries(harnesses)) {
+                let rows;
+                try {
+                    rows = rowsOf(env, name, harness.home?.loginFiles);
+                }
+                catch (e) {
+                    lines.push(name + ': saved logins cannot be read (' + errMsg(e) + ')');
+                    idle.push(name);
+                    continue;
+                }
+                if (!rows.length)
+                    continue;
+                const active = rows.find((r) => r.isActive);
+                if (active)
+                    lines.push(name + ': ' + active.name + ' is in use (' + plural(rows.length, 'login') + ' saved)');
+                else {
+                    lines.push(name + ': ' + plural(rows.length, 'login') + ' saved, none in use here');
+                    idle.push(name);
+                }
+            }
+            if (!lines.length)
+                return ok('no saved logins (sign in inside the sandbox the first time)');
+            if (!idle.length)
+                return { ...ok(lines.join('; ')) };
+            return {
+                status: 'warn',
+                detail: lines.join('; '),
+                means: 'The sandbox starts signed out for ' + idle.join(', ') + ' until you pick a saved login.',
+                fix: 'Run: sandbox account use <name>' + (idle[0] === 'claude' ? '' : ' --agent ' + idle[0]),
+            };
+        },
+    },
+];

package/dist/cli/commands/repair/checks/common.d.ts

@@ -0,0 +1,8 @@
+import type { Finding, RepairEnv } from '../types.js';
+export declare function ok(detail: string): Finding;
+export declare function rel(root: string, p: string): string;
+/** Throws unless every folder from the data folder's parent down to `p` is real (no link the sandbox made). */
+export declare function guard(env: RepairEnv, p: string): void;
+export declare function plural(n: number, one: string, many?: string): string;
+/** The current Windows user's name (what the group lists, without the domain). */
+export declare function sameUser(account: string, user: string): boolean;

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

@@ -0,0 +1,22 @@
+// Small helpers the checks share.
+import path from 'node:path';
+import { assertNoLinks } from '../../../../core/util/index.js';
+export function ok(detail) {
+    return { status: 'ok', detail };
+}
+export function rel(root, p) {
+    return path.relative(root, p) || '.';
+}
+/** Throws unless every folder from the data folder's parent down to `p` is real (no link the sandbox made). */
+export function guard(env, p) {
+    assertNoLinks(path.dirname(env.dataPath), p);
+}
+export function plural(n, one, many = one + 's') {
+    return n + ' ' + (n === 1 ? one : many);
+}
+/** The current Windows user's name (what the group lists, without the domain). */
+export function sameUser(account, user) {
+    const a = account.toLowerCase();
+    const u = user.toLowerCase();
+    return a === u || a.endsWith('\\' + u);
+}

package/dist/cli/commands/repair/checks/data.d.ts

@@ -0,0 +1,2 @@
+import type { Check } from '../types.js';
+export declare const DATA_CHECKS: Check[];

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

@@ -0,0 +1,241 @@
+// The data folder: where it is, that it can be written, how much room is left, data left behind in another folder, and
+// what an interrupted install left inside it (links the sandbox made, half-downloaded or half-installed tools). Nothing
+// here follows a link or deletes anything but leftovers.
+import fs from 'node:fs';
+import path from 'node:path';
+import { GB, freeBytesAt, humanBytes } from '../../../../core/disk.js';
+import { dirExists, isLink, removeLink } from '../../../../core/util/index.js';
+import { writeProblem } from '../../../../host/health/index.js';
+import { assertTestWritable } from '../../../../host/test-guard.js';
+import { OLD_DEFAULT_ROOT, StorageHistory, holdsData, oldDefaultRoot, otherDataFolders, sharedDefaultRoot, } from '../../../../host/storage/index.js';
+import { removeTree } from '../../data/remove.js';
+import { findHalfInstalled, findLinks, findStagingLeftovers, resolvedVersionsValid } from '../finders.js';
+import { guard, ok, plural, rel } from './common.js';
+const same = (a, b) => path.resolve(a).toLowerCase() === path.resolve(b).toLowerCase();
+export const DATA_CHECKS = [
+    {
+        id: 'data-folder',
+        group: 'Data folder',
+        name: 'Data folder',
+        checking: 'where the data folder is',
+        run: (env) => {
+            for (const dir of [env.storageRoot, env.dataPath])
+                if (isLink(dir))
+                    return {
+                        status: 'needs-you',
+                        detail: dir + ' is a link or junction',
+                        means: 'The sandbox tool refuses to work through links: one could lead to other folders on this PC.',
+                        fix: 'Point storage.root at the real folder (sandbox config path), or move the data with: sandbox storage move <folder>',
+                    };
+            if (!dirExists(env.storageRoot))
+                return ok(env.storageRoot + ' (not created yet; the first start makes it)');
+            const bad = writeProblem(env.storageRoot) ?? (dirExists(env.dataPath) ? writeProblem(env.dataPath) : null);
+            if (bad)
+                return {
+                    status: 'needs-you',
+                    detail: 'cannot write in ' + env.storageRoot + ' (' + bad + ')',
+                    means: 'The sandbox cannot save its tools, logins or logs.',
+                    fix: 'Check the folder is not read-only and that you may write to it, or choose another with: sandbox storage move <folder>',
+                };
+            return ok(env.dataPath + ' (you can write there)');
+        },
+    },
+    {
+        id: 'data-disk',
+        group: 'Data folder',
+        name: 'Free disk space',
+        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)'),
+                means: 'Tool installs and caches can use several GB.',
+                fix: 'See what is stored with: sandbox data, and free space with: sandbox data clean <target>',
+            };
+        },
+    },
+    {
+        id: 'data-pinned-old',
+        group: 'Data folder',
+        name: 'Old data folder',
+        run: (env) => {
+            const old = oldDefaultRoot();
+            const shared = sharedDefaultRoot();
+            if (!old || !same(env.storageRoot, old) || same(old, shared))
+                return ok('your data is not in the old per-user folder');
+            if (!holdsData(env.storageRoot))
+                return ok('the old folder is empty');
+            return {
+                status: 'warn',
+                detail: 'your data is still in the old per-user folder ' +
+                    old +
+                    ' (kept by settings that say ' +
+                    OLD_DEFAULT_ROOT +
+                    ')',
+                means: 'It keeps working. New installs keep their data in ' +
+                    shared +
+                    ', which only you can read, and which an install for everyone can share.',
+                fix: 'Move it when you like (it shows the size and time first): sandbox storage move "' + shared + '"',
+            };
+        },
+    },
+    {
+        id: 'data-elsewhere',
+        group: 'Data folder',
+        name: 'Data in other folders',
+        run: (env) => {
+            const others = otherDataFolders(env.storageRoot, new StorageHistory(env.userDir));
+            if (!others.length)
+                return ok('no saved data in any other known folder');
+            const both = holdsData(env.storageRoot);
+            return {
+                status: 'warn',
+                detail: (both ? 'data is in this folder and also in ' : 'data is in ') + others.join(', '),
+                means: both
+                    ? 'A move may have stopped half way, or you used another version for a while. Nothing is deleted for you.'
+                    : 'Your current data folder is empty, so the sandbox starts from scratch. That data is not lost.',
+                fix: both
+                    ? 'Check that other folder, and delete it yourself when you are sure. Or switch to it with: sandbox storage use "' +
+                        others[0] +
+                        '"'
+                    : 'Bring it here with: sandbox storage move "' +
+                        others[0] +
+                        '" (or switch with: sandbox storage use "' +
+                        others[0] +
+                        '")',
+            };
+        },
+    },
+    {
+        id: 'data-links',
+        group: 'Data folder',
+        name: 'Links in the data folder',
+        checking: 'the data folder for links',
+        needsIdle: 'look',
+        run: (env) => {
+            const links = findLinks(env.dataPath);
+            if (!links.length)
+                return ok('none (nothing in ' + env.dataPath + ' points elsewhere)');
+            return {
+                status: 'needs-you',
+                detail: plural(links.length, 'link') + ' made inside the sandbox',
+                means: "A link here could point at this PC's own files; the tool must not follow it.",
+                plan: 'remove ' + plural(links.length, 'link') + ' without following them',
+                lines: links.map((l) => rel(env.dataPath, l)),
+                data: links,
+            };
+        },
+        fix: (env, finding) => {
+            const links = Array.isArray(finding.data) ? finding.data : [];
+            // Only if every folder above is still real.
+            for (const link of links) {
+                guard(env, path.dirname(link));
+                removeLink(link);
+            }
+            return {
+                done: 'removed ' + plural(links.length, 'link') + ' without following ' + (links.length === 1 ? 'it' : 'them'),
+            };
+        },
+    },
+    {
+        id: 'data-downloads',
+        group: 'Data folder',
+        name: 'Interrupted downloads',
+        needsIdle: 'look',
+        run: (env) => {
+            guard(env, env.toolsDir);
+            const found = findStagingLeftovers(env.toolsDir);
+            if (!found.length)
+                return ok('none');
+            return {
+                status: 'needs-you',
+                detail: plural(found.length, 'half-finished download or copy folder'),
+                means: 'They only waste space; the next start downloads again.',
+                plan: 'remove ' + plural(found.length, 'half-finished folder'),
+                lines: found.map((p) => rel(env.toolsDir, p)),
+                data: found,
+            };
+        },
+        fix: (env, finding) => {
+            const found = Array.isArray(finding.data) ? finding.data : [];
+            guard(env, env.toolsDir);
+            for (const p of found)
+                removeTree(p, env.dataPath);
+            return { done: 'removed ' + plural(found.length, 'half-finished folder') };
+        },
+    },
+    {
+        id: 'data-toolchains',
+        group: 'Data folder',
+        name: 'Half-installed toolchains',
+        needsIdle: 'look',
+        run: (env) => {
+            guard(env, env.toolsDir);
+            const found = findHalfInstalled(env.toolsDir);
+            if (!found.length)
+                return ok('every toolchain folder has its program');
+            return {
+                status: 'needs-you',
+                detail: found.map((f) => rel(env.toolsDir, f.path) + ' (no ' + f.missing + ')').join(', '),
+                means: 'An install stopped half way; that tool will not run.',
+                plan: 'remove ' + plural(found.length, 'half-installed folder') + ' (the next sandbox installs them again)',
+                data: found.map((f) => f.path),
+            };
+        },
+        fix: (env, finding) => {
+            const found = Array.isArray(finding.data) ? finding.data : [];
+            guard(env, env.toolsDir);
+            for (const p of found)
+                removeTree(p, env.dataPath);
+            return {
+                done: 'removed ' + found.map((p) => rel(env.toolsDir, p)).join(', ') + '; the next sandbox installs them again',
+            };
+        },
+    },
+    {
+        id: 'data-versions-cache',
+        group: 'Data folder',
+        name: 'Resolved versions cache',
+        needsIdle: 'look',
+        run: (env) => {
+            const file = path.join(env.toolsDir, 'resolved-versions.json');
+            if (!fs.existsSync(file) && !isLink(file))
+                return ok('not created yet');
+            guard(env, env.toolsDir);
+            if (isLink(file))
+                return {
+                    status: 'needs-you',
+                    detail: 'tools\\resolved-versions.json is a link',
+                    plan: 'remove the link',
+                    data: file,
+                };
+            if (fs.statSync(file).size < 4 * 1024 * 1024 && resolvedVersionsValid(fs.readFileSync(file, 'utf8')))
+                return ok('valid');
+            return {
+                status: 'needs-you',
+                detail: 'tools\\resolved-versions.json is damaged',
+                means: 'The sandbox cannot read which tool versions it looked up.',
+                plan: 'remove it (versions are looked up again on the next start)',
+                data: file,
+            };
+        },
+        fix: (env, finding) => {
+            const file = String(finding.data);
+            guard(env, env.toolsDir);
+            if (isLink(file)) {
+                removeLink(file);
+                return { done: 'removed the link in place of tools\\resolved-versions.json' };
+            }
+            assertTestWritable(file);
+            fs.rmSync(file, { force: true });
+            return { done: 'removed tools\\resolved-versions.json (versions are looked up again on the next start)' };
+        },
+    },
+];

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

@@ -0,0 +1,2 @@
+import type { Check } from '../types.js';
+export declare const ALL_CHECKS: readonly Check[];

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

@@ -0,0 +1,20 @@
+import { AGENT_CHECKS } from './agents.js';
+import { DATA_CHECKS } from './data.js';
+import { INSTALL_CHECKS } from './install.js';
+import { MACHINE_CHECKS } from './machine.js';
+import { NETWORK_CHECKS } from './network.js';
+import { PC_CHECKS } from './pc.js';
+import { SANDBOX_CHECKS } from './sandbox.js';
+import { SETTINGS_CHECKS } from './settings.js';
+import { VPN_CHECKS } from './vpn.js';
+export const ALL_CHECKS = [
+    ...PC_CHECKS,
+    ...INSTALL_CHECKS,
+    ...MACHINE_CHECKS,
+    ...DATA_CHECKS,
+    ...SETTINGS_CHECKS,
+    ...SANDBOX_CHECKS,
+    ...AGENT_CHECKS,
+    ...NETWORK_CHECKS,
+    ...VPN_CHECKS,
+];

package/dist/cli/commands/repair/checks/install.d.ts

@@ -0,0 +1,5 @@
+import { type CommandCopy } from '../../../../host/health/index.js';
+import type { Check } from '../types.js';
+/** The exact way to get rid of one copy (nothing here runs it: doctor only prints it). */
+export declare function removalCommand(copy: CommandCopy): string;
+export declare const INSTALL_CHECKS: Check[];