windows-development-sandbox 1.10.0 → 1.11.3

package/dist/cli/operations/input.js

@@ -3,33 +3,57 @@
 import { DEFINITIONS } from '../../app/features/defs.js';
 import { fail } from '../../core/util/index.js';
 import { inputField } from './spec.js';
-/** The definition a command runs: its own command, or an action of a hand-written one (`config get`). */
+/** The words of an action: `contained on` is two words, each one a positional argument. */
+function actionWords(action) {
+    return action.split(' ');
+}
+/** Whether the positionals start with every word of the action (`contained`, `on`). */
+function startsWithAction(action, positionals) {
+    return actionWords(action).every((word, i) => positionals[i] === word);
+}
+/** The definition a command runs: its own command, or an action of a hand-written one (`config get`, `storage use`). */
 export function definitionFor(command, positionals) {
-    return DEFINITIONS.find((d) => d.cli?.name === command && (d.cli.action === undefined || d.cli.action === positionals[0]));
+    return DEFINITIONS.find((d) => d.cli?.name === command && (d.cli.action === undefined || startsWithAction(d.cli.action, positionals)));
 }
 /** commander's attribute name for a long flag: --keep-old -> keepOld. */
 function attribute(flag) {
     return flag.replace(/^--/, '').replace(/-([a-z])/g, (_m, ch) => ch.toUpperCase());
 }
+/**
+ * What a flag gave: --no-<flag> is stored by commander as <flag>: false, and the input field it sets is true then.
+ */
+function flagValue(raw, flag) {
+    if (flag.startsWith('--no-')) {
+        const positive = attribute('--' + flag.slice('--no-'.length));
+        return raw[positive] === false ? true : undefined;
+    }
+    return raw[attribute(flag)];
+}
 /** The input a command line gives a definition (fields not on the line are left to the schema's defaults). */
 export function cliInput(def, options) {
     const hint = def.cli;
     if (!hint)
         return {};
-    const positionals = hint.action ? options.positionals.slice(1) : options.positionals;
+    const positionals = hint.action ? options.positionals.slice(actionWords(hint.action).length) : options.positionals;
     const names = hint.positional ?? [];
     const missing = names.slice(positionals.length).filter((name) => !inputField(def, name).optional);
     if (missing.length)
         fail('Missing ' + missing.join(' and ') + '.', 'Usage: sandbox ' + [hint.name, hint.action, ...names.map((n) => '<' + n + '>')].filter(Boolean).join(' '));
     const input = {};
     names.forEach((name, i) => {
-        if (positionals[i] !== undefined)
+        // A list takes the rest of the line (`data clean tools/go logs`); only the last positional may be one.
+        if (inputField(def, name).kind === 'list') {
+            if (i !== names.length - 1)
+                throw new Error(def.id + ': only the last positional may be a list');
+            input[name] = positionals.slice(i);
+        }
+        else if (positionals[i] !== undefined)
             input[name] = positionals[i];
     });
     for (const [name, flag] of Object.entries(hint.flags ?? {})) {
         if (!flag)
             continue;
-        const value = (flag.shownAs ? options.raw[attribute(flag.shownAs)] : undefined) ?? options.raw[attribute(flag.flag)];
+        const value = (flag.shownAs ? flagValue(options.raw, flag.shownAs) : undefined) ?? flagValue(options.raw, flag.flag);
         if (value !== undefined)
             input[name] = value;
     }

package/dist/cli/operations/io-cli.js

@@ -21,8 +21,14 @@ function interactive() {
 async function ask(q, options) {
     if ('problem' in q && q.problem)
         console.log(c.yellow(q.problem));
+    // A question with its own words for "no terminal" fails with them, before any other way of asking (confirm has its
+    // own rule: --yes and implied answer it).
+    if (q.kind !== 'confirm' && !interactive() && 'noTerminal' in q && q.noTerminal)
+        fail(q.noTerminal.message, q.noTerminal.fix);
     switch (q.kind) {
         case 'confirm': {
+            if (q.skipWithYes && options.yes)
+                return false;
             if (q.implied || options.yes)
                 return true;
             if (!interactive())
@@ -51,11 +57,13 @@ export function cliIO(options) {
         progress.stop();
         return (await ask(q, options));
     };
+    // With --json the lines go to stderr, so stdout is the JSON alone.
+    const write = options.json ? console.error : console.log;
     const io = ioFromAsker(asker, {
         progress: (text) => progress.show(text),
         log: (text, tone) => {
             progress.stop();
-            console.log(tone ? PAINT[tone](text) : text);
+            write(tone ? PAINT[tone](text) : text);
         },
     });
     return { io, close: () => progress.stop() };

package/dist/cli/operations/spec.js

@@ -58,6 +58,7 @@ function argSpec(def, name) {
         description: field.help ?? '',
         required: !field.optional,
         ...(choices ? { choices } : {}),
+        ...(field.kind === 'list' ? { variadic: true } : {}),
     };
 }
 /** The manifest command of a definition that is a command of its own. */
@@ -80,6 +81,10 @@ export function commandSpecOf(def) {
         ...(hint.examples ? { examples: [...hint.examples] } : {}),
     };
 }
+/** The first word of an action: `contained` for `contained on`. */
+function firstWord(action) {
+    return action.split(' ')[0];
+}
 /**
  * A hand-written command with the actions the definitions add (`config reset`): the action is one of the first
  * argument's choices, each later argument is asked for it in the menu's command form, and --json is offered when an
@@ -90,10 +95,11 @@ export function withActions(spec, defs = actionDefinitions()) {
     if (!mine.length || !spec.args.length)
         return spec;
     const [first, ...rest] = spec.args;
-    const actions = mine.map((d) => d.cli.action);
+    // A two-word action (`contained on`) is listed by its first word: the argument's choice is that word.
+    const actions = mine.map((d) => firstWord(d.cli.action));
     const choices = Array.isArray(first.choices) ? [...new Set([...first.choices, ...actions])] : first.choices;
     const asked = (arg, position) => {
-        const users = mine.filter((d) => (d.cli?.positional?.length ?? 0) > position).map((d) => d.cli.action);
+        const users = mine.filter((d) => (d.cli?.positional?.length ?? 0) > position).map((d) => firstWord(d.cli.action));
         if (!users.length || arg.when === undefined)
             return arg;
         const when = Array.isArray(arg.when) ? arg.when : [arg.when];

package/dist/cli/output/render-view.js

@@ -21,6 +21,8 @@ function sectionLines(section) {
         lines.push(c.bold(section.title) + (section.summary ? '  ' + section.summary : ''));
     if (section.facts?.length)
         lines.push(...tableLines(section.facts.map((f) => [f.label, f.value])));
+    if (section.text?.length)
+        lines.push(...section.text);
     if (section.columns && items.length) {
         const columns = section.columns;
         lines.push(...tableLines([

package/dist/cli/{commands/data/collect.js → services/data-collect.js}

@@ -2,8 +2,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import _ from 'lodash';
-import { sizeOf } from '../../../core/disk.js';
-import { dirExists, isLink } from '../../../core/util/index.js';
+import { sizeOf } from '../../core/disk.js';
+import { dirExists, isLink } from '../../core/util/index.js';
 const AREA_ORDER = ['tools', 'databases', 'state', 'logs', 'data', 'host'];
 /** Folders of the data folder that get one row per child; anything else at the top level is listed as itself. */
 const PER_CHILD = ['tools', 'databases', 'state'];

package/dist/cli/{commands/data/remove.js → services/data-remove.js}

@@ -1,8 +1,8 @@
 // Deleting inside the data folder. The sandbox can write there, so links are removed themselves and never followed.
 import fs from 'node:fs';
 import path from 'node:path';
-import { dirExists, isLink, removeLink } from '../../../core/util/index.js';
-import { removeRefusal, safeRemove } from '../../../shared/io/index.js';
+import { dirExists, isLink, removeLink } from '../../core/util/index.js';
+import { removeRefusal, safeRemove } from '../../shared/io/index.js';
 /** Deletes p (strictly inside root): links inside are removed first and never followed; see shared/safe-remove.ts. */
 export function removeTree(p, root) {
     const unlinkInside = (dir) => {

package/dist/cli/services/data-service.d.ts

@@ -1,6 +1,6 @@
 import { type DiskUsage } from '../../core/disk.js';
 import type { Context } from '../commands/context.js';
-import { type DataEntry } from '../commands/data/collect.js';
+import { type DataEntry } from './data-collect.js';
 import { type CleanTarget } from './data-targets.js';
 export interface DataReport {
     readonly dataPath: string;

package/dist/cli/services/data-service.js

@@ -6,8 +6,8 @@ import _ from 'lodash';
 import { diskUsage, sizeOf } from '../../core/disk.js';
 import { assertNoLinks, errMsg, fail, isLink } from '../../core/util/index.js';
 import { isSandboxRunning } from '../../host/sandbox/index.js';
-import { collectDataEntries } from '../commands/data/collect.js';
-import { removeTree } from '../commands/data/remove.js';
+import { collectDataEntries } from './data-collect.js';
+import { removeTree } from './data-remove.js';
 import { resolveCleanTargets } from './data-targets.js';
 export class DataService {
     ctx;

package/dist/cli/services/databases-service.d.ts

@@ -23,5 +23,10 @@ export declare class DatabasesService {
     /** The databases the sandbox can start and whether each runs now. */
     list(cwd: string): Promise<DatabaseRow[]>;
     /** Running databases by port, from `sbx-db list` (best effort: null when the sandbox does not answer). */
+    /**
+     * The ports of the databases running in the sandbox (null: it could not be asked). Asked inside the sandbox, so a
+     * live page reading it every few seconds shares one answer for PORTS_FRESH_MS.
+     */
     runningPorts(cwd: string): Promise<Set<number> | null>;
+    private askPorts;
 }

package/dist/cli/services/databases-service.js

@@ -11,6 +11,9 @@ export function parseDatabaseList(stdout) {
         return m ? [{ name: m[1], running: m[2] === 'running', port: Number(m[3]), title: safeText(m[4]) }] : [];
     });
 }
+/** How long an answer about the running databases' ports is reused (they change only when one starts or stops). */
+const PORTS_FRESH_MS = 20_000;
+const recentPorts = new Map();
 export class DatabasesService {
     ctx;
     constructor(ctx) {
@@ -41,7 +44,19 @@ export class DatabasesService {
         return parseDatabaseList((await this.run('list', undefined, cwd)).stdout ?? '');
     }
     /** Running databases by port, from `sbx-db list` (best effort: null when the sandbox does not answer). */
+    /**
+     * The ports of the databases running in the sandbox (null: it could not be asked). Asked inside the sandbox, so a
+     * live page reading it every few seconds shares one answer for PORTS_FRESH_MS.
+     */
     async runningPorts(cwd) {
+        const known = recentPorts.get(cwd);
+        if (known && Date.now() - known.at < PORTS_FRESH_MS)
+            return known.ports;
+        const ports = await this.askPorts(cwd);
+        recentPorts.set(cwd, { at: Date.now(), ports });
+        return ports;
+    }
+    async askPorts(cwd) {
         try {
             const r = await new SandboxChannel(this.ctx.dataPath).exec(['sbx-db', 'list'], cwd, 30);
             return new Set((r.stdout ?? '')

package/dist/cli/services/health-service.d.ts

@@ -11,12 +11,16 @@ export interface SetupReport {
 export declare class HealthService {
     private readonly ctx;
     constructor(ctx: Context);
-    /** The table `doctor` shows: [name, detail] rows. */
-    doctor(): string[][];
+    /** The table `doctor` shows: [name, detail] rows (for the agent given, default: this folder's or the default one). */
+    doctor(harness?: string | undefined): string[][];
     /** Fails unless this is Windows: Windows Sandbox runs nowhere else. */
     assertWindows(): void;
     /** The setup checklist for this PC. */
     setupReport(): SetupReport;
-    /** Runs the enable command in an elevated PowerShell (Windows asks for permission); true if it worked. */
-    enableFeature(): boolean;
+    /**
+     * Runs the enable command in an elevated PowerShell (Windows asks for permission); true if it worked. The helper
+     * reads no input and writes nothing to the console (its exit code is the result), so 'ignore' is safe where there is
+     * no terminal to give the prompt (the menu and the web).
+     */
+    enableFeature(stdio?: 'inherit' | 'ignore'): boolean;
 }

package/dist/cli/services/health-service.js

@@ -15,10 +15,10 @@ export class HealthService {
     constructor(ctx) {
         this.ctx = ctx;
     }
-    /** The table `doctor` shows: [name, detail] rows. */
-    doctor() {
+    /** The table `doctor` shows: [name, detail] rows (for the agent given, default: this folder's or the default one). */
+    doctor(harness = this.ctx.options.harness) {
         const { ctx } = this;
-        const rows = doctorRows(ctx.loaded.config, ctx.options.harness ?? ctx.loaded.config.defaultHarness, ctx.storageRoot, ctx.loaded.configPath);
+        const rows = doctorRows(ctx.loaded.config, harness ?? ctx.loaded.config.defaultHarness, ctx.storageRoot, ctx.loaded.configPath);
         // Inside a sandbox the feature and "running" rows describe the sandbox itself, and the host rows describe nothing
         // useful.
         if (insideSandbox())
@@ -73,11 +73,13 @@ export class HealthService {
         const facts = gatherFacts(this.ctx.storageRoot);
         return { facts, checks: buildChecks(facts), canEnable: canEnableFeature(facts) };
     }
-    /** Runs the enable command in an elevated PowerShell (Windows asks for permission); true if it worked. */
-    enableFeature() {
+    /**
+     * Runs the enable command in an elevated PowerShell (Windows asks for permission); true if it worked. The helper
+     * reads no input and writes nothing to the console (its exit code is the result), so 'ignore' is safe where there is
+     * no terminal to give the prompt (the menu and the web).
+     */
+    enableFeature(stdio = 'inherit') {
         refuseInSelfTest('turn on Windows features');
-        return (spawnSync(SYSTEM.powershell(), nativeScript('scripts/run-elevated.ps1', ['-Command', ENABLE_COMMAND + ' | Out-Null']), {
-            stdio: 'inherit',
-        }).status === 0);
+        return (spawnSync(SYSTEM.powershell(), nativeScript('scripts/run-elevated.ps1', ['-Command', ENABLE_COMMAND + ' | Out-Null']), { stdio }).status === 0);
     }
 }

package/dist/cli/services/index.d.ts

@@ -1,14 +1,17 @@
 export { AccountsService, type AccountRef, type AccountsContext, type AgentAccounts } from './accounts-service.js';
 export { AgentCommandsService, type AgentCommand, type AgentCommandsStatus } from './agent-commands-service.js';
 export { DataService, type CleanOutcome, type CleanPlan, type DataReport, type SizedTarget } from './data-service.js';
+export { cleanTargetOf, collectDataEntries, type DataArea, type DataEntry } from './data-collect.js';
+export { removeTree } from './data-remove.js';
 export { resolveCleanTargets, type CleanTarget } from './data-targets.js';
 export { DatabasesService, parseDatabaseList, type DatabaseAction, type DatabaseRow } from './databases-service.js';
 export { autoMigrates, continuesAfterFailedMigration, MigrateService, type MigrateContext, type MigrateResult, } from './migrate-service.js';
 export { NPM_UPDATE_COMMAND, UpdateService, runsAsSystem, type CheckResult, type UpdateServiceOptions, type UpdateStatus, type UpdateTaskPort, } from './update-service.js';
-export { NORD_STEPS, VpnService, type VpnReport } from './vpn-service.js';
+export { VpnService, type VpnReport } from './vpn-service.js';
 export { LogsService, type LogFile } from './logs-service.js';
 export { WebService, webSession } from './web-service.js';
 export { HealthService, type SetupReport } from './health-service.js';
 export { ProjectsService, type ProjectRow, type ProjectSettings, type ProjectsListing } from './projects-service.js';
 export { SandboxService, type OtherSession, type ProjectInfo, type SandboxReport, type SandboxState, type StopPlan, } from './sandbox-service.js';
 export { SessionsService, projectOf, viewerText, type ListedSession, type RestartScope } from './sessions-service.js';
+export { StorageService, storageBusy } from './storage-service.js';

package/dist/cli/services/index.js

@@ -1,14 +1,17 @@
 export { AccountsService } from './accounts-service.js';
 export { AgentCommandsService } from './agent-commands-service.js';
 export { DataService } from './data-service.js';
+export { cleanTargetOf, collectDataEntries } from './data-collect.js';
+export { removeTree } from './data-remove.js';
 export { resolveCleanTargets } from './data-targets.js';
 export { DatabasesService, parseDatabaseList } from './databases-service.js';
 export { autoMigrates, continuesAfterFailedMigration, MigrateService, } from './migrate-service.js';
 export { NPM_UPDATE_COMMAND, UpdateService, runsAsSystem, } from './update-service.js';
-export { NORD_STEPS, VpnService } from './vpn-service.js';
+export { VpnService } from './vpn-service.js';
 export { LogsService } from './logs-service.js';
 export { WebService, webSession } from './web-service.js';
 export { HealthService } from './health-service.js';
 export { ProjectsService } from './projects-service.js';
 export { SandboxService, } from './sandbox-service.js';
 export { SessionsService, projectOf, viewerText } from './sessions-service.js';
+export { StorageService, storageBusy } from './storage-service.js';

package/dist/cli/services/logs-service.d.ts

@@ -12,6 +12,13 @@ export declare class LogsService {
     private dir;
     /** Log files, newest first. */
     files(): LogFile[];
+    /** The folder the logs are in (whether or not it exists yet). */
+    folder(): string;
+    /**
+     * The path of the log called `name`: only an exact name from files() is accepted, so a name from outside (a browser)
+     * can never become a path of its own.
+     */
+    byName(name: string): string;
     /** The newest log, or a UserError when there is none yet. */
     newest(): string;
     /**

package/dist/cli/services/logs-service.js

@@ -32,6 +32,19 @@ export class LogsService {
         });
         return _.orderBy(found, 'modified', 'desc');
     }
+    /** The folder the logs are in (whether or not it exists yet). */
+    folder() {
+        return hostDataFolder(this.ctx.dataPath, 'logs');
+    }
+    /**
+     * The path of the log called `name`: only an exact name from files() is accepted, so a name from outside (a browser)
+     * can never become a path of its own.
+     */
+    byName(name) {
+        const found = this.files().find((f) => f.name === name);
+        return (found?.path ??
+            fail('There is no log called ' + safeText(name) + '.', 'Pick one from: sandbox logs, or the Logs page.'));
+    }
     /** The newest log, or a UserError when there is none yet. */
     newest() {
         return (this.files()[0]?.path ??

package/dist/cli/services/storage-service.d.ts

@@ -0,0 +1,19 @@
+import { type MoveProgress, type MoveResult } from '../../host/storage/index.js';
+import type { Context } from '../commands/context.js';
+/** Why a move cannot start (a background sync is still on a data folder in the old storage), or null. */
+export declare function storageBusy(root: string): string | null;
+export declare class StorageService {
+    private readonly ctx;
+    constructor(ctx: Pick<Context, 'loaded' | 'storageRoot'>);
+    /** Why a move or a switch cannot happen now, or null. */
+    busy(): string | null;
+    /** Throws a UserError when moving to `to` is not possible right now. */
+    validate(to: string): void;
+    /** Moves the data (copying across drives) and remembers both folders. */
+    move(to: string, keepOld: boolean, onProgress?: (progress: MoveProgress) => void): Promise<MoveResult>;
+    /** Looks for the data in `to` from now on, without moving it. The caller has checked `busy()`. */
+    use(to: string): void;
+    /** The folders offered for a choice: the default, folders that hold data, and each other drive's AgentSandbox. */
+    knownFolders(): string[];
+    private mover;
+}

package/dist/cli/services/storage-service.js

@@ -0,0 +1,71 @@
+// The storage folder's work for the command line, the menu and the web: where the saved data is, moving it (both
+// folders remembered), switching to another folder without moving, and the folders offered for a choice. Never prints.
+import fs from 'node:fs';
+import path from 'node:path';
+import { userConfigPath, userDir } from '../../core/config/index.js';
+import { diskUsage } from '../../core/disk.js';
+import { protectPrivateFolder } from '../../host/sharing/index.js';
+import { isSandboxRunning } from '../../host/sandbox/index.js';
+import { mountedSets, sharedDefaultRoot, StorageHistory, StorageMove, otherDataFolders, } from '../../host/storage/index.js';
+import { watcherRunning } from '../../sync/index.js';
+/** Why a move cannot start (a background sync is still on a data folder in the old storage), or null. */
+export function storageBusy(root) {
+    const mounted = mountedSets(root);
+    if (mounted.length > 0)
+        return ('The contained storage of "' +
+            mounted.join('", "') +
+            '" is mounted (a disk image; moving now would reach into it).');
+    const data = path.join(root, 'data');
+    try {
+        for (const name of fs.readdirSync(data))
+            if (watcherRunning(path.join(data, name)))
+                return 'The background sync of "' + name + '" is still finishing.';
+    }
+    catch {
+        // no data folder: nothing runs
+    }
+    return null;
+}
+export class StorageService {
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    /** Why a move or a switch cannot happen now, or null. */
+    busy() {
+        return storageBusy(this.ctx.storageRoot);
+    }
+    /** Throws a UserError when moving to `to` is not possible right now. */
+    validate(to) {
+        this.mover().validate(this.ctx.storageRoot, to);
+    }
+    /** Moves the data (copying across drives) and remembers both folders. */
+    async move(to, keepOld, onProgress) {
+        const from = this.ctx.storageRoot;
+        const result = await this.mover().move(from, to, {
+            keepOld,
+            ...(onProgress ? { onProgress } : {}),
+        });
+        const history = new StorageHistory(userDir());
+        history.remember(from);
+        history.remember(to);
+        return result;
+    }
+    /** Looks for the data in `to` from now on, without moving it. The caller has checked `busy()`. */
+    use(to) {
+        new StorageHistory(userDir()).remember(this.ctx.storageRoot);
+        this.mover().pin(to);
+    }
+    /** The folders offered for a choice: the default, folders that hold data, and each other drive's AgentSandbox. */
+    knownFolders() {
+        const root = this.ctx.storageRoot;
+        const known = [sharedDefaultRoot(), ...otherDataFolders(root, new StorageHistory(userDir()))];
+        const drives = diskUsage(root)
+            .filter((d) => !d.holdsStorage)
+            .map((d) => path.join(d.drive, 'AgentSandbox'));
+        return [...new Set([...known, ...drives])].filter((f) => f.toLowerCase() !== root.toLowerCase());
+    }
+    mover() {
+        return new StorageMove(this.ctx.loaded.configPath ?? userConfigPath(), () => storageBusy(this.ctx.storageRoot), isSandboxRunning, protectPrivateFolder);
+    }
+}

package/dist/cli/services/vpn-service.d.ts

@@ -1,5 +1,6 @@
 import type { Config } from '../../core/types.js';
 import type { VpnProvider } from '../../core/schema/index.js';
+import type { SecretStore } from '../../host/secrets/index.js';
 import { type LoginState, type VpnCredentials, type VpnLine } from '../../host/vpn/index.js';
 import type { Context } from '../commands/context.js';
 export interface VpnReport {
@@ -13,15 +14,16 @@ export interface VpnReport {
     /** The running sandbox's tunnel, when one runs with the VPN on. */
     readonly running: VpnLine | null;
 }
-/** The steps to get the NordVPN service credentials, in the words of Nord Account (shown before asking). */
-export declare const NORD_STEPS: readonly string[];
 export declare class VpnService {
     private readonly ctx;
     private readonly login;
-    constructor(ctx: Context);
+    constructor(ctx: Context, secrets?: SecretStore);
     private get config();
     get provider(): VpnProvider;
-    report(): Promise<VpnReport>;
+    /** Without `tunnel` the sandbox is not asked (no request to the network): `running` is then null. */
+    report({ tunnel }?: {
+        tunnel?: boolean;
+    }): Promise<VpnReport>;
     loginState(): LoginState;
     save(credentials: VpnCredentials): void;
     remove(): boolean;

package/dist/cli/services/vpn-service.js

@@ -1,18 +1,11 @@
 import { isSandboxRunning } from '../../host/sandbox/index.js';
 import { hostPublicIp, readVpnLine, VpnLogin, } from '../../host/vpn/index.js';
-/** The steps to get the NordVPN service credentials, in the words of Nord Account (shown before asking). */
-export const NORD_STEPS = [
-    'Sign in at https://my.nordaccount.com with your usual NordVPN e-mail and password.',
-    'Open NordVPN, then "Set up NordVPN manually" (under Advanced settings).',
-    'Verify your e-mail if it asks, then copy the "Service credentials": a user name and a password.',
-    'These are NOT your account password. You can revoke them in the same place whenever you like.',
-];
 export class VpnService {
     ctx;
     login;
-    constructor(ctx) {
+    constructor(ctx, secrets) {
         this.ctx = ctx;
-        this.login = new VpnLogin(ctx.storageRoot);
+        this.login = new VpnLogin(ctx.storageRoot, secrets);
     }
     get config() {
         return this.ctx.loaded.config.vpn;
@@ -20,9 +13,10 @@ export class VpnService {
     get provider() {
         return this.config.provider;
     }
-    async report() {
+    /** Without `tunnel` the sandbox is not asked (no request to the network): `running` is then null. */
+    async report({ tunnel = true } = {}) {
         const c = this.config;
-        const running = isSandboxRunning();
+        const running = tunnel && isSandboxRunning();
         return {
             enabled: c.enabled,
             provider: c.provider,

package/dist/cli/services/web-service.d.ts

@@ -1,11 +1,14 @@
 import type { SessionStatus } from '../../core/types.js';
 import type { WebBackend } from '../../host/web/index.js';
 import type { Endpoint } from '../../shared/pty/index.js';
-import type { NewSessionRequest, WebInfo, WebSession } from '../../shared/web/index.js';
+import type { WebInfo, WebProject, WebSession } from '../../shared/web/index.js';
 import type { Context } from '../commands/context.js';
+import { type SandboxView } from '../commands/shared-use.js';
 import { type ListedSession } from './sessions-service.js';
 /** A session as the browser may see it: no attach address or token, text made safe. */
 export declare function webSession(s: SessionStatus | ListedSession, viewers: number | null | undefined): WebSession;
+/** The projects of the running sandbox as the browser may see them (its guest folders made safe). */
+export declare function runningProjects(view: SandboxView): WebProject[];
 export declare class WebService implements WebBackend {
     private readonly ctx;
     private cached;
@@ -14,9 +17,7 @@ export declare class WebService implements WebBackend {
     private view;
     /** The sandbox is this user's, or another user's and shared with them. */
     private mayUse;
-    private projects;
     info(): Promise<WebInfo>;
     sessions(): Promise<WebSession[]>;
     endpoint(sessionId: string): Endpoint | null;
-    create(request: NewSessionRequest): Promise<WebSession>;
 }

package/dist/cli/services/web-service.js

@@ -1,8 +1,8 @@
 // What the web UI's server may do with the running sandbox: the same sessions, projects and rules as the CLI (another
 // user's sandbox is shown and used only as far as the sharing rules allow). Returns data, never prints.
 import path from 'node:path';
-import { fail, safeText } from '../../core/util/index.js';
-import { hostEndpoint, SandboxChannel } from '../../host/channel/index.js';
+import { safeText } from '../../core/util/index.js';
+import { hostEndpoint } from '../../host/channel/index.js';
 import { insideSandbox, isSandboxRunning } from '../../host/sandbox/index.js';
 import { ownerRule } from '../../host/sharing/index.js';
 import { RunDir } from '../../shared/channel/index.js';
@@ -11,7 +11,6 @@ import { registryOf } from '../commands/projects/here.js';
 import { SessionsService } from './sessions-service.js';
 /** The owner is asked (a process listing) at most this often: the browser polls. */
 const VIEW_TTL_MS = 3000;
-const SESSION_START_MS = 15 * 60 * 1000;
 const MAX_SESSIONS = 50;
 /** A session as the browser may see it: no attach address or token, text made safe. */
 export function webSession(s, viewers) {
@@ -27,6 +26,15 @@ export function webSession(s, viewers) {
         canOpen: s.phase === 'running' && hostEndpoint(s) !== null,
     };
 }
+/** The projects of the running sandbox as the browser may see them (its guest folders made safe). */
+export function runningProjects(view) {
+    const known = registryOf(view.ctx).read()?.projects ?? [];
+    if (known.length)
+        return known.map((p) => ({ name: p.name, guest: safeText(p.guest) }));
+    // A sandbox from before projects existed has only its launch folder.
+    const status = new RunDir(view.ctx.dataPath).readSandboxStatus();
+    return status ? [{ name: 'workspace', guest: safeText(status.guestWorkspace) }] : [];
+}
 export class WebService {
     ctx;
     cached = null;
@@ -46,14 +54,6 @@ export class WebService {
     mayUse(view) {
         return !view.owner || ownerRule(view.owner, { kind: 'use' }).kind === 'allow';
     }
-    projects(view) {
-        const known = registryOf(view.ctx).read()?.projects ?? [];
-        if (known.length)
-            return known.map((p) => ({ name: p.name, guest: safeText(p.guest) }));
-        // A sandbox from before projects existed has only its launch folder.
-        const status = new RunDir(view.ctx.dataPath).readSandboxStatus();
-        return status ? [{ name: 'workspace', guest: safeText(status.guestWorkspace) }] : [];
-    }
     info() {
         const config = this.ctx.loaded.config;
         const view = this.view();
@@ -63,7 +63,7 @@ export class WebService {
             canUse: view !== null && this.mayUse(view),
             harnesses: Object.keys(config.harnesses),
             defaultHarness: config.defaultHarness,
-            projects: view && this.mayUse(view) ? this.projects(view) : [],
+            projects: view && this.mayUse(view) ? runningProjects(view) : [],
         });
     }
     async sessions() {
@@ -88,24 +88,4 @@ export class WebService {
             return null;
         return hostEndpoint(session);
     }
-    async create(request) {
-        const view = this.view();
-        if (!view)
-            return fail('No Windows Sandbox is running.', 'Start one with sandbox claude, then try again.');
-        if (view.owner && view.owner.kind !== 'none' && view.owner.kind !== 'mine') {
-            const rule = ownerRule(view.owner, { kind: 'use' });
-            if (rule.kind === 'refuse')
-                return fail(rule.reason, rule.fix);
-        }
-        const project = this.projects(view).find((p) => p.name === request.project);
-        if (!project)
-            return fail('The running sandbox has no project "' + request.project + '".');
-        const harness = view.ctx.loaded.config.harnesses[request.harness];
-        if (!harness)
-            return fail('There is no agent called "' + request.harness + '".');
-        const channel = new SandboxChannel(view.ctx.dataPath);
-        const id = channel.requestSession(request.harness, [], project.guest, { harnessSpec: harness });
-        const session = await channel.waitForSession(id, SESSION_START_MS, () => undefined);
-        return webSession(session, null);
-    }
 }

package/dist/core/config/defaults.js

@@ -37,6 +37,7 @@ export const DEFAULTS = {
     },
     network: { blockPrivateRanges: true, allowOnly: [], blockHosts: [], forwardPorts: [], dns: [], proxy: '' },
     vpn: { enabled: false, provider: 'nordvpn', protocol: 'udp', country: '', configFile: '', killSwitch: true },
+    github: { shareToken: false },
     provisioning: {
         copyFromHost: true,
         fallbackToInstall: true,
@@ -93,7 +94,7 @@ export const DEFAULTS = {
         dynamodb: { enabled: 'auto', port: 8000, adminPort: 8001, admin: true },
         sqlserver: { enabled: 'auto' },
     },
-    attach: { enabled: true, reuseSession: true, auto: false, autoHide: false },
+    attach: { enabled: true, reuseSession: true, auto: false, autoHide: false, confirmCtrlC: true },
     web: { enabled: false, port: 47800, openOnLaunch: false },
     agentCommands: { enabled: false, agents: 'auto' },
     secrets: { strip: true, allow: [], patterns: [], warnFiles: true },