windows-development-sandbox 1.4.1 → 1.5.0

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

@@ -0,0 +1,93 @@
+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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,18 @@
+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/commands/setup/checks.d.ts

@@ -6,8 +6,8 @@ export interface Check {
     detail: string;
 }
 /** Windows Sandbox needs Pro, Enterprise or Education (build 18305+); Home ("Core*") and Server cannot run it. */
-export declare const editionSupport: (edition: string | null) => EditionSupport;
-export declare const nodeMajor: (version: string) => number;
+export declare function editionSupport(edition: string | null): EditionSupport;
+export declare function nodeMajor(version: string): number;
 /** Offer to enable the feature only when it is off and this edition can have it. */
-export declare const canEnableFeature: (f: MachineFacts) => boolean;
-export declare const buildChecks: (f: MachineFacts) => Check[];
+export declare function canEnableFeature(f: MachineFacts): boolean;
+export declare function buildChecks(f: MachineFacts): Check[];

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

@@ -2,7 +2,7 @@
 import { GB } from '../../../core/disk.js';
 import { ENABLE_COMMAND } from './facts.js';
 /** Windows Sandbox needs Pro, Enterprise or Education (build 18305+); Home ("Core*") and Server cannot run it. */
-export const editionSupport = (edition) => {
+export function editionSupport(edition) {
     if (!edition)
         return 'unknown';
     if (/^Core/i.test(edition))
@@ -10,13 +10,24 @@ export const editionSupport = (edition) => {
     if (/^Server/i.test(edition))
         return 'unsupported';
     return /^(Professional|Enterprise|Education|IoTEnterprise)/i.test(edition) ? 'supported' : 'unknown';
-};
-export const nodeMajor = (version) => Number(/^v?(\d+)/.exec(version.trim())?.[1] ?? 0);
+}
+export function nodeMajor(version) {
+    return Number(/^v?(\d+)/.exec(version.trim())?.[1] ?? 0);
+}
 /** Offer to enable the feature only when it is off and this edition can have it. */
-export const canEnableFeature = (f) => f.feature !== 'enabled' && f.feature !== 'pending' && !f.sandboxExe && ['supported', 'unknown'].includes(editionSupport(f.edition));
-const formatGb = (bytes) => (bytes / GB).toFixed(1) + ' GB';
-const check = (name, status, detail) => ({ name, status, detail });
-const editionCheck = (f) => {
+export function canEnableFeature(f) {
+    return (f.feature !== 'enabled' &&
+        f.feature !== 'pending' &&
+        !f.sandboxExe &&
+        ['supported', 'unknown'].includes(editionSupport(f.edition)));
+}
+function formatGb(bytes) {
+    return (bytes / GB).toFixed(1) + ' GB';
+}
+function check(name, status, detail) {
+    return { name, status, detail };
+}
+function editionCheck(f) {
     const support = editionSupport(f.edition);
     const edition = (f.edition ?? 'unknown edition') + (f.build ? ', build ' + f.build : '');
     const name = 'Windows edition';
@@ -29,17 +40,17 @@ const editionCheck = (f) => {
     if (support === 'supported')
         return check(name, 'action', edition + ': too old; Windows Sandbox needs Windows 10 version 1903 or newer.');
     return check(name, 'warn', edition + ': not sure this edition has Windows Sandbox (it needs Pro, Enterprise or Education).');
-};
-const virtualizationCheck = (f) => {
+}
+function virtualizationCheck(f) {
     const name = 'CPU virtualization';
     const virt = f.hypervisorPresent || f.virtualizationFirmware;
     if (virt)
         return check(name, 'ok', f.hypervisorPresent ? 'on (hypervisor running)' : 'on');
     if (virt === false)
-        return check(name, 'action', 'off. Turn on Intel VT-x / AMD-V (SVM) in your PC\'s BIOS/UEFI settings, then run this again.');
+        return check(name, 'action', "off. Turn on Intel VT-x / AMD-V (SVM) in your PC's BIOS/UEFI settings, then run this again.");
     return check(name, 'warn', 'could not tell; if Windows Sandbox will not start, turn on VT-x / AMD-V in the BIOS/UEFI.');
-};
-const featureCheck = (f) => {
+}
+function featureCheck(f) {
     const name = 'Windows Sandbox feature';
     if (f.feature === 'enabled' && f.sandboxExe)
         return check(name, 'ok', 'enabled');
@@ -48,16 +59,16 @@ const featureCheck = (f) => {
     if (f.sandboxExe)
         return check(name, 'ok', 'installed');
     return check(name, 'action', 'not enabled. In an admin PowerShell: ' + ENABLE_COMMAND + ', then restart.');
-};
-const memoryCheck = (f) => {
+}
+function memoryCheck(f) {
     const gb = formatGb(f.totalRamBytes);
     if (f.totalRamBytes < 4 * GB)
         return check('Memory', 'action', gb + ': Windows Sandbox needs at least 4 GB.');
     if (f.totalRamBytes < 8 * GB)
         return check('Memory', 'warn', gb + ': works, but 8 GB or more is recommended.');
     return check('Memory', 'ok', gb);
-};
-const diskCheck = (f) => {
+}
+function diskCheck(f) {
     if (f.freeDiskBytes === null)
         return check('Free disk', 'warn', 'could not check the drive of ' + f.storageRoot);
     const free = formatGb(f.freeDiskBytes) + ' free for ' + f.storageRoot;
@@ -66,6 +77,12 @@ const diskCheck = (f) => {
     if (f.freeDiskBytes < 20 * GB)
         return check('Free disk', 'warn', free + ': getting low; toolchains and caches can use several GB.');
     return check('Free disk', 'ok', free);
-};
-const nodeCheck = (f) => nodeMajor(f.nodeVersion) >= 20 ? check('Node.js', 'ok', f.nodeVersion) : check('Node.js', 'action', f.nodeVersion + ': needs 20 or newer (winget install OpenJS.NodeJS.LTS).');
-export const buildChecks = (f) => [editionCheck(f), virtualizationCheck(f), featureCheck(f), memoryCheck(f), diskCheck(f), nodeCheck(f)];
+}
+function nodeCheck(f) {
+    return nodeMajor(f.nodeVersion) >= 20
+        ? check('Node.js', 'ok', f.nodeVersion)
+        : check('Node.js', 'action', f.nodeVersion + ': needs 20 or newer (winget install OpenJS.NodeJS.LTS).');
+}
+export function buildChecks(f) {
+    return [editionCheck(f), virtualizationCheck(f), featureCheck(f), memoryCheck(f), diskCheck(f), nodeCheck(f)];
+}

package/dist/cli/commands/setup/facts.d.ts

@@ -16,16 +16,16 @@ export interface MachineFacts {
 }
 export declare const ENABLE_COMMAND: string;
 /** `reg query <key>` output to { valueName: data }. */
-export declare const parseRegQuery: (text: string) => Record<string, string>;
+export declare function parseRegQuery(text: string): Record<string, string>;
 /** The "State : ..." line of `Dism /Get-FeatureInfo` (English output only; anything else is unknown). */
-export declare const parseDismState: (text: string) => FeatureState;
+export declare function parseDismState(text: string): FeatureState;
 /** Win32_OptionalFeature.InstallState: 1 enabled, 2 disabled, 3 absent. */
-export declare const featureFromInstallState: (state: number | null | undefined) => FeatureState;
-declare const Probe: z.ZodObject<{
+export declare function featureFromInstallState(state: number | null | undefined): FeatureState;
+declare const ProbeSchema: z.ZodObject<{
     virtualizationFirmware: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
     hypervisorPresent: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
     installState: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
 }, z.core.$strip>;
-export declare const parseProbe: (text: string) => z.infer<typeof Probe>;
-export declare const gatherFacts: (storageRoot: string) => MachineFacts;
+export declare function parseProbe(text: string): z.infer<typeof ProbeSchema>;
+export declare function gatherFacts(storageRoot: string): MachineFacts;
 export {};

package/dist/cli/commands/setup/facts.js

@@ -3,46 +3,48 @@ import os from 'node:os';
 import _ from 'lodash';
 import { z } from 'zod';
 import { freeBytesAt } from '../../../core/disk.js';
-import { captureOutput, fileExists } from '../../../core/util.js';
+import { captureOutput, fileExists } from '../../../core/util/index.js';
+import { nativeScript } from '../../../host/native.js';
 import { SYSTEM, system32 } from '../../../shared/system.js';
 const FEATURE = 'Containers-DisposableClientVM';
 export const ENABLE_COMMAND = 'Enable-WindowsOptionalFeature -Online -FeatureName ' + FEATURE + ' -All -NoRestart';
 /** `reg query <key>` output to { valueName: data }. */
-export const parseRegQuery = (text) => Object.fromEntries(_.compact(text.split(/\r?\n/).map((line) => /^\s+(\S+)\s+REG_\w+\s+(.*)$/.exec(line)?.slice(1, 3))));
+export function parseRegQuery(text) {
+    return Object.fromEntries(_.compact(text
+        .split(/\r?\n/)
+        .map((line) => /^\s+(\S+)\s+REG_\w+\s+(.*)$/.exec(line)?.slice(1, 3))));
+}
 /** The "State : ..." line of `Dism /Get-FeatureInfo` (English output only; anything else is unknown). */
-export const parseDismState = (text) => {
+export function parseDismState(text) {
     const state = /^State\s*:\s*(.+?)\s*$/im.exec(text)?.[1].toLowerCase() ?? '';
     if (state === 'enabled')
         return 'enabled';
     if (state.includes('pending'))
         return 'pending';
     return state.startsWith('disabled') ? 'disabled' : 'unknown';
-};
+}
 /** Win32_OptionalFeature.InstallState: 1 enabled, 2 disabled, 3 absent. */
-export const featureFromInstallState = (state) => state === 1 ? 'enabled' : state === 2 || state === 3 ? 'disabled' : 'unknown';
-// Fixed script (no outside data): CPU/hypervisor facts and the feature state, readable without admin rights.
-const PROBE = [
-    '$ErrorActionPreference = "SilentlyContinue"',
-    '$cpu = @(Get-CimInstance Win32_Processor)',
-    '$cs = Get-CimInstance Win32_ComputerSystem',
-    '$f = Get-CimInstance Win32_OptionalFeature -Filter "Name=\'' + FEATURE + '\'"',
-    '$v = $null; if ($cpu.Count) { $v = [bool]($cpu | Where-Object { $_.VirtualizationFirmwareEnabled }) }',
-    '$h = $null; if ($cs) { $h = [bool]$cs.HypervisorPresent }',
-    '$s = $null; if ($f) { $s = [int]$f.InstallState }',
-    '@{ virtualizationFirmware = $v; hypervisorPresent = $h; installState = $s } | ConvertTo-Json -Compress',
-].join('; ');
-const Probe = z.object({ virtualizationFirmware: z.boolean().nullable(), hypervisorPresent: z.boolean().nullable(), installState: z.number().nullable() }).partial();
-export const parseProbe = (text) => {
+export function featureFromInstallState(state) {
+    return state === 1 ? 'enabled' : state === 2 || state === 3 ? 'disabled' : 'unknown';
+}
+const ProbeSchema = z
+    .object({
+    virtualizationFirmware: z.boolean().nullable(),
+    hypervisorPresent: z.boolean().nullable(),
+    installState: z.number().nullable(),
+})
+    .partial();
+export function parseProbe(text) {
     try {
-        return Probe.parse(JSON.parse(_.last(text.trim().split(/\r?\n/)) ?? ''));
+        return ProbeSchema.parse(JSON.parse(_.last(text.trim().split(/\r?\n/)) ?? ''));
     }
     catch {
         return {};
     }
-};
-export const gatherFacts = (storageRoot) => {
+}
+export function gatherFacts(storageRoot) {
     const reg = parseRegQuery(captureOutput(SYSTEM.reg(), ['query', 'HKLM\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion']));
-    const probe = parseProbe(captureOutput(SYSTEM.powershell(), ['-NoProfile', '-NonInteractive', '-Command', PROBE]));
+    const probe = parseProbe(captureOutput(SYSTEM.powershell(), nativeScript('scripts/sandbox-probe.ps1', ['-Feature', FEATURE])));
     // DISM knows about a pending restart but needs admin rights; the CIM state works for everyone.
     const dism = parseDismState(captureOutput(SYSTEM.dism(), ['/English', '/Online', '/Get-FeatureInfo', '/FeatureName:' + FEATURE]));
     return {
@@ -57,4 +59,4 @@ export const gatherFacts = (storageRoot) => {
         storageRoot,
         nodeVersion: process.version,
     };
-};
+}

package/dist/cli/commands/setup/index.d.ts

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

package/dist/cli/commands/setup/index.js

@@ -1,43 +1,41 @@
 // `sandbox setup`: checks this PC can run Windows Sandbox and offers to turn the feature on.
-import { spawnSync } from 'node:child_process';
 import { askYesNo } from '../../../core/prompt.js';
-import { fail, isWin } from '../../../core/util.js';
-import { refuseInSelfTest } from '../../../host/test-guard.js';
-import { SYSTEM } from '../../../shared/system.js';
-import { c } from '../../colors.js';
-import { table } from '../context.js';
-import { buildChecks, canEnableFeature } from './checks.js';
-import { ENABLE_COMMAND, gatherFacts } from './facts.js';
-const LABEL = { ok: c.green('OK'), warn: c.yellow('WARNING'), action: c.red('ACTION NEEDED') };
-const print = (checks) => table(checks.map((check) => [LABEL[check.status], check.name, check.detail]));
-/** Runs the enable command in an elevated PowerShell (Windows asks for permission); true if it worked. */
-const enableFeature = () => {
-    refuseInSelfTest('turn on Windows features');
-    const inner = "'-NoProfile','-Command','" + ENABLE_COMMAND + " | Out-Null'";
-    const outer = "try { $p = Start-Process -FilePath '" + SYSTEM.powershell() + "' -Verb RunAs -Wait -PassThru -WindowStyle Hidden -ArgumentList " + inner + '; exit $p.ExitCode } catch { exit 1 }';
-    return spawnSync(SYSTEM.powershell(), ['-NoProfile', '-NonInteractive', '-Command', outer], { stdio: 'inherit' }).status === 0;
+import { fail } from '../../../core/util/index.js';
+import { c, table } from '../../output/index.js';
+import { HealthService } from '../../services/index.js';
+import { ENABLE_COMMAND } from './facts.js';
+const LABEL = {
+    ok: c.green('OK'),
+    warn: c.yellow('WARNING'),
+    action: c.red('ACTION NEEDED'),
 };
-export const setup = async (ctx) => {
-    if (!isWin)
-        fail('Windows Sandbox only runs on Windows.', 'Run sandbox setup on a Windows 10/11 Pro, Enterprise or Education PC.');
+function print(checks) {
+    table(checks.map((check) => [LABEL[check.status], check.name, check.detail]));
+}
+export async function setup(ctx) {
+    const health = new HealthService(ctx);
+    health.assertWindows();
     console.log('Checking this PC for Windows Sandbox...\n');
-    const facts = gatherFacts(ctx.storageRoot);
-    let checks = buildChecks(facts);
+    const first = health.setupReport();
+    let checks = first.checks;
     print(checks);
-    if (canEnableFeature(facts)) {
+    if (first.canEnable) {
         console.log('');
         if (await askYesNo('Turn on Windows Sandbox now? Windows will ask for admin permission.')) {
             console.log('Enabling Windows Sandbox (this can take a minute)...');
-            if (!enableFeature())
+            if (!health.enableFeature())
                 fail('Windows Sandbox could not be enabled (or the admin prompt was declined).', 'In an admin PowerShell run: ' + ENABLE_COMMAND + ', then restart Windows.');
             console.log('Done. Restart Windows to finish, then run sandbox setup again.\n');
-            checks = buildChecks(gatherFacts(ctx.storageRoot));
+            checks = health.setupReport().checks;
             print(checks);
         }
         else
             console.log('To do it yourself, in an admin PowerShell run:\n  ' + ENABLE_COMMAND + '\nthen restart Windows.');
     }
     const todo = checks.filter((check) => check.status === 'action').length;
-    console.log('\n' + (todo ? todo + ' thing(s) to fix before the sandbox can start (see ACTION NEEDED above).' : 'This PC is ready. cd into a project and run sandbox claude (or sandbox for no agent).'));
+    console.log('\n' +
+        (todo
+            ? todo + ' thing(s) to fix before the sandbox can start (see ACTION NEEDED above).'
+            : 'This PC is ready. cd into a project and run sandbox claude (or sandbox for no agent).'));
     return todo ? 1 : 0;
-};
+}

package/dist/cli/commands/shared-use.d.ts

@@ -0,0 +1,29 @@
+import { type OwnerAction } from '../../host/sharing/index.js';
+import type { SandboxOwner } from '../../host/sharing/owner.js';
+import type { Context } from './context.js';
+/** The sandbox is another user's and shared with this one. */
+type SharedOwner = Extract<SandboxOwner, {
+    kind: 'other';
+}>;
+/**
+ * The context for working in another user's shared sandbox: its data folder, its projects (from its record), and none
+ * of this user's agent environment. A login chosen with --account would end up in their sandbox, so it is refused.
+ */
+export declare function borrowedContext(ctx: Context, owner: SharedOwner): Context;
+export interface SandboxView {
+    /** Where to read from: the owner's data folder when the sandbox is another user's and shared. */
+    readonly ctx: Context;
+    /** "Running, started by alice (shared with you)", or null for your own sandbox. */
+    readonly line: string | null;
+    /** The sandbox is another user's and not shared: there is nothing to show but that. */
+    readonly limited: boolean;
+    readonly owner: SandboxOwner | null;
+}
+/** For status and sessions: they work for anyone, and say whose sandbox this is. */
+export declare function lookAtSandbox(ctx: Context): SandboxView;
+/**
+ * For a command that acts on the running sandbox: refuses with the reason when this user may not, asks for the typed
+ * confirmation when the rule wants one (--yes in a script), and returns the context to use.
+ */
+export declare function useSharedSandbox(ctx: Context, action: OwnerAction | ((shared: Context) => OwnerAction)): Promise<Context>;
+export {};

package/dist/cli/commands/shared-use.js

@@ -0,0 +1,69 @@
+// Whose is the running sandbox? Windows allows one per PC, so with an all-users install another user's sandbox may be
+// the one running. These helpers apply the rules in host/sharing/rules.ts: a command that only looks goes on whatever
+// the owner (and says whose it is), a command that uses the sandbox goes on when it is shared (working on the owner's
+// data folder, with none of this user's logins or agent environment), and the rest is the owner's alone.
+import _ from 'lodash';
+import { askTyped } from '../../core/prompt.js';
+import { fail } from '../../core/util/index.js';
+import { insideSandbox, isSandboxRunning } from '../../host/sandbox/index.js';
+import { ownerLine, ownerName, ownerRule, runningOwner, sharedDataPath, } from '../../host/sharing/index.js';
+/** What the user's own settings must not carry into another user's sandbox: their agent environment values. */
+function withoutHarnessEnvironment(loaded) {
+    return {
+        ...loaded,
+        config: {
+            ...loaded.config,
+            harnesses: _.mapValues(loaded.config.harnesses, (harness) => ({ ...harness, environment: {} })),
+        },
+    };
+}
+/**
+ * The context for working in another user's shared sandbox: its data folder, its projects (from its record), and none
+ * of this user's agent environment. A login chosen with --account would end up in their sandbox, so it is refused.
+ */
+export function borrowedContext(ctx, owner) {
+    if (ctx.options.account)
+        fail('--account cannot be used in ' + ownerName(owner.user) + "'s sandbox.", 'The sandbox uses the logins of ' + ownerName(owner.user) + '; yours stay on your side.');
+    return {
+        ...ctx,
+        dataPath: sharedDataPath(owner.record),
+        loaded: withoutHarnessEnvironment(ctx.loaded),
+        borrowed: { user: owner.user, record: owner.record },
+    };
+}
+/** The running sandbox's owner, or null when there is nothing to ask (none running, or this is inside the sandbox). */
+function ownerNow() {
+    if (insideSandbox() || !isSandboxRunning())
+        return null;
+    return runningOwner();
+}
+/** For status and sessions: they work for anyone, and say whose sandbox this is. */
+export function lookAtSandbox(ctx) {
+    const owner = ownerNow();
+    if (!owner)
+        return { ctx, line: null, limited: false, owner };
+    const line = ownerLine(owner);
+    if (owner.kind === 'other' && owner.shared)
+        return { ctx: borrowedContext(ctx, owner), line, limited: false, owner };
+    return { ctx, line, limited: owner.kind !== 'mine' && owner.kind !== 'none', owner };
+}
+/**
+ * For a command that acts on the running sandbox: refuses with the reason when this user may not, asks for the typed
+ * confirmation when the rule wants one (--yes in a script), and returns the context to use.
+ */
+export async function useSharedSandbox(ctx, action) {
+    const owner = ownerNow();
+    if (!owner || owner.kind === 'mine' || owner.kind === 'none')
+        return ctx;
+    const target = owner.kind === 'other' && owner.shared ? borrowedContext(ctx, owner) : ctx;
+    const rule = ownerRule(owner, typeof action === 'function' ? action(target) : action);
+    if (rule.kind === 'refuse')
+        return fail(rule.reason, rule.fix);
+    if (rule.kind === 'confirm' && !ctx.options.yes) {
+        if (!(process.stdin.isTTY && process.stdout.isTTY))
+            fail(rule.prompt + ' It was not stopped.', 'In a script, add --yes to do it anyway.');
+        if (!(await askTyped(rule.prompt, rule.expected)))
+            fail('Nothing changed.');
+    }
+    return target;
+}

package/dist/cli/commands/user-config.d.ts

@@ -1,8 +1,8 @@
 import type { Context } from './context.js';
-export declare const configFile: (ctx: Context) => string;
+export declare function configFile(ctx: Context): string;
 /** The value as written in your file (not merged with the defaults). */
-export declare const fileSetting: <T>(ctx: Context, key: string[], fallback: T) => T;
-export declare const setSetting: (ctx: Context, key: string[], value: unknown) => void;
+export declare function fileSetting<T>(ctx: Context, key: string[], fallback: T): T;
+export declare function setSetting(ctx: Context, key: string[], value: unknown): void;
 /** Adds a folder to a list setting (projects.roots, projects.exclude, ...) unless it is there already. */
-export declare const addToList: (ctx: Context, key: string[], folder: string) => boolean;
-export declare const removeFromList: (ctx: Context, key: string[], folder: string) => boolean;
+export declare function addToList(ctx: Context, key: string[], folder: string): boolean;
+export declare function removeFromList(ctx: Context, key: string[], folder: string): boolean;

package/dist/cli/commands/user-config.js

@@ -4,17 +4,19 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { parse } from 'jsonc-parser';
 import _ from 'lodash';
-import { userConfigPath } from '../../core/config.js';
-import { fail } from '../../core/util.js';
-import { editConfigText } from '../menu/settings/config-file.js';
-export const configFile = (ctx) => ctx.loaded.configPath ?? userConfigPath();
+import { userConfigPath } from '../../core/config/index.js';
+import { fail } from '../../core/util/index.js';
+import { editConfigText } from '../menu/settings/index.js';
+export function configFile(ctx) {
+    return ctx.loaded.configPath ?? userConfigPath();
+}
 /** The value as written in your file (not merged with the defaults). */
-export const fileSetting = (ctx, key, fallback) => {
+export function fileSetting(ctx, key, fallback) {
     const file = configFile(ctx);
     const text = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '';
     return _.get(parse(text) ?? {}, key) ?? fallback;
-};
-export const setSetting = (ctx, key, value) => {
+}
+export function setSetting(ctx, key, value) {
     const file = configFile(ctx);
     const text = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '';
     const result = editConfigText(text, key, value);
@@ -22,20 +24,20 @@ export const setSetting = (ctx, key, value) => {
         fail('Could not change ' + key.join('.') + ':\n  ' + result.problems.join('\n  '));
     fs.mkdirSync(path.dirname(file), { recursive: true });
     fs.writeFileSync(file, result.text, 'utf8');
-};
+}
 /** Adds a folder to a list setting (projects.roots, projects.exclude, ...) unless it is there already. */
-export const addToList = (ctx, key, folder) => {
+export function addToList(ctx, key, folder) {
     const list = fileSetting(ctx, key, []);
     if (list.some((p) => path.resolve(p).toLowerCase() === path.resolve(folder).toLowerCase()))
         return false;
     setSetting(ctx, key, [...list, folder]);
     return true;
-};
-export const removeFromList = (ctx, key, folder) => {
+}
+export function removeFromList(ctx, key, folder) {
     const list = fileSetting(ctx, key, []);
     const rest = list.filter((p) => path.resolve(p).toLowerCase() !== path.resolve(folder).toLowerCase());
     if (rest.length === list.length)
         return false;
     setSetting(ctx, key, rest);
     return true;
-};
+}

package/dist/cli/history.d.ts

@@ -1,11 +1,12 @@
 import { z } from 'zod';
-declare const History: z.ZodArray<z.ZodObject<{
+declare const HistorySchema: z.ZodArray<z.ZodObject<{
     argv: z.ZodArray<z.ZodString>;
     at: z.ZodString;
 }, z.core.$strict>>;
-export declare const readHistory: () => z.output<typeof History>;
+type History = z.output<typeof HistorySchema>;
+export declare function readHistory(): History;
 /** Remembers a command (menu or typed) so the menu can offer it again. Never fails the command itself. */
-export declare const recordHistory: (argv: string[]) => void;
+export declare function recordHistory(argv: string[]): void;
 /** argv as you would type it (quoted where needed). */
-export declare const commandLine: (argv: string[]) => string;
+export declare function commandLine(argv: string[]): string;
 export {};