windows-development-sandbox 1.4.3 → 1.7.0

package/dist/core/schema/redact.js

@@ -0,0 +1,75 @@
+// Secrets in settings: which values are marked `secret` in the schemas, and printing a config without them.
+import { z } from 'zod';
+import { ConfigSchema } from './config.js';
+/** What is printed instead of a secret. */
+export const REDACTED = '***';
+let cached = null;
+const walk = (node, at, out) => {
+    if (typeof node !== 'object' || node === null)
+        return;
+    const n = node;
+    if (n.secret === true)
+        out.push(at);
+    for (const [k, v] of Object.entries(n.properties ?? {}))
+        walk(v, [...at, k], out);
+    if (typeof n.additionalProperties === 'object')
+        walk(n.additionalProperties, [...at, '*'], out);
+    if (n.items)
+        walk(n.items, [...at, '*'], out);
+    for (const key of ['anyOf', 'oneOf', 'allOf'])
+        if (Array.isArray(n[key]))
+            for (const v of n[key])
+                walk(v, at, out);
+};
+/** Every setting marked secret, found from the schema itself (so a new secret setting needs no list). */
+export function secretPaths() {
+    if (!cached) {
+        const out = [];
+        walk(z.toJSONSchema(ConfigSchema, { io: 'input', unrepresentable: 'any' }), [], out);
+        cached = out;
+    }
+    return cached;
+}
+const blank = (value, path) => {
+    if (path.length === 0)
+        return typeof value === 'string' && value !== '' ? REDACTED : value;
+    if (typeof value !== 'object' || value === null)
+        return value;
+    const [head, ...rest] = path;
+    if (Array.isArray(value))
+        return value.map((v) => (head === '*' ? blank(v, rest) : v));
+    const o = value;
+    return Object.fromEntries(Object.entries(o).map(([k, v]) => [k, head === '*' || head === k ? blank(v, rest) : v]));
+};
+/** A copy of `config` with every secret value replaced by ***. */
+export function redactSecrets(config) {
+    return secretPaths().reduce((value, path) => blank(value, path), config);
+}
+const collect = (value, path, out) => {
+    if (path.length === 0) {
+        if (typeof value === 'string' && value !== '')
+            out.push(value);
+        return;
+    }
+    if (typeof value !== 'object' || value === null)
+        return;
+    const [head, ...rest] = path;
+    const o = value;
+    for (const [k, v] of Object.entries(o))
+        if (head === '*' || head === k)
+            collect(v, rest, out);
+};
+/** The secret values in `config` (for scrubbing text that was built from it). */
+export function secretValues(config) {
+    const out = [];
+    for (const path of secretPaths())
+        collect(config, path, out);
+    return [...new Set(out)];
+}
+/** `text` with every secret value of `config` replaced by *** (a last safety net for output built from a config). */
+export function scrubSecrets(text, config) {
+    return secretValues(config)
+        .filter((v) => v.length >= 4)
+        .sort((a, b) => b.length - a.length)
+        .reduce((t, v) => t.split(v).join(REDACTED).split(JSON.stringify(v).slice(1, -1)).join(REDACTED), text);
+}

package/dist/core/schema/resume.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+export declare const RESUME_SESSIONS: readonly ["ask", "always", "afterCrash", "never"];
+export declare const ResumeSchema: z.ZodObject<{
+    sessions: z.ZodEnum<{
+        never: "never";
+        ask: "ask";
+        always: "always";
+        afterCrash: "afterCrash";
+    }>;
+    restartAfterCrash: z.ZodBoolean;
+}, z.core.$strict>;

package/dist/core/schema/resume.js

@@ -0,0 +1,12 @@
+// Reopening the sessions of the last sandbox. User config only: it starts sandboxes on this PC, so a project's
+// .sandbox-config.json can never set it (LocalOverrides has no `resume`).
+import { z } from 'zod';
+export const RESUME_SESSIONS = ['ask', 'always', 'afterCrash', 'never'];
+export const ResumeSchema = z.strictObject({
+    sessions: z
+        .enum(RESUME_SESSIONS)
+        .describe('When a sandbox starts after one that had agent sessions: "ask" lists them and asks whether to reopen them (without a terminal it prints the command sandbox resume), "always" reopens them, "afterCrash" reopens them only when the last sandbox ended unexpectedly, "never" leaves it to sandbox resume. Terminal tabs you opened yourself in the sandbox are never reopened.'),
+    restartAfterCrash: z
+        .boolean()
+        .describe('When the sandbox ends because Windows Sandbox crashed or ran out of memory, start it again by itself and reopen its sessions (at most 3 times in 6 hours).'),
+});

package/dist/core/schema/sandbox.d.ts

@@ -23,6 +23,9 @@ export declare const SandboxSchema: z.ZodObject<{
     headless: z.ZodBoolean;
     keepAwake: z.ZodBoolean;
 }, z.core.$strict>;
+export declare const SharingSchema: z.ZodObject<{
+    otherUsers: z.ZodBoolean;
+}, z.core.$strict>;
 export declare const NetworkSchema: z.ZodObject<{
     blockPrivateRanges: z.ZodBoolean;
     allowOnly: z.ZodArray<z.ZodString>;

package/dist/core/schema/sandbox.js

@@ -50,6 +50,11 @@ export const SandboxSchema = z.strictObject({
         .boolean()
         .describe('Keep this PC from sleeping while a sandbox runs, so agents left working overnight keep going (the screen may still turn off; closing a laptop lid still sleeps it).'),
 });
+export const SharingSchema = z.strictObject({
+    otherUsers: z
+        .boolean()
+        .describe('Let other Windows users of this PC use a sandbox you start: list its sessions, attach, run commands and stop it. They use the agent logins inside it, and history goes to your account.'),
+});
 const PortSchema = z.number().int().min(1).max(65535);
 const HostEntrySchema = z
     .string()
@@ -80,6 +85,7 @@ export const NetworkSchema = z.strictObject({
     proxy: z
         .string()
         .regex(/^(https?:\/\/[^\s]+)?$/, 'http://host:port')
+        .refine((v) => !/^https?:\/\/[^/?#]*@/i.test(v), 'no user name or password in the address (it would be stored in plain text and visible to the agent): use a proxy that needs no login')
         .describe('An HTTP proxy the sandbox uses to reach the internet (HTTP_PROXY / HTTPS_PROXY for everything in it), e.g. http://proxy.corp:8080. Empty = none.'),
 });
 export const AuditSchema = z.strictObject({

package/dist/core/schema/toolchains.d.ts

@@ -79,10 +79,10 @@ export declare const ToolchainsSchema: z.ZodObject<{
         openssl: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
     }, z.core.$strict>;
     bun: z.ZodObject<{
-        enabled: z.ZodBoolean;
+        enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
     }, z.core.$strict>;
     uv: z.ZodObject<{
-        enabled: z.ZodBoolean;
+        enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
     }, z.core.$strict>;
     vcRuntime: z.ZodObject<{
         enabled: z.ZodBoolean;
@@ -92,7 +92,7 @@ export declare const ToolchainsSchema: z.ZodObject<{
         vulkan: z.ZodBoolean;
     }, z.core.$strict>;
     vscode: z.ZodObject<{
-        enabled: z.ZodBoolean;
+        enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
         setup: z.ZodBoolean;
         recommended: z.ZodBoolean;
         extensions: z.ZodArray<z.ZodString>;

package/dist/core/schema/toolchains.js

@@ -107,8 +107,12 @@ export const ToolchainsSchema = z.strictObject({
         openssl: EnabledSchema.describe('`openssl` on PATH, from the copy Git for Windows ships (its mingw64\\bin is not put on PATH, so it cannot shadow MinGW\'s gcc). "auto" = on.'),
     })
         .describe('Small portable command-line tools from their GitHub releases, installed once into tools\\cli.'),
-    bun: toggle('Bun runtime (claude-mem needs it).'),
-    uv: toggle('uv, the Python package manager (claude-mem needs it).'),
+    bun: z.strictObject({
+        enabled: enabled('Bun (JavaScript runtime and package manager; claude-mem needs it).', 'bun.lock, bun.lockb or bunfig.toml'),
+    }),
+    uv: z.strictObject({
+        enabled: enabled('uv (fast Python package and tool manager; claude-mem needs it for its search index).', 'uv.lock, a [tool.uv] pyproject.toml, toolchains.python.tools, or an agent installed with uv'),
+    }),
     vcRuntime: toggle('Microsoft Visual C++ runtime for tools that need it (a real installer, so it runs on every boot, ~15 s). PHP installs it regardless.'),
     mesa: z.strictObject({
         enabled: z
@@ -119,9 +123,7 @@ export const ToolchainsSchema = z.strictObject({
             .describe('Also software Vulkan 1.4 (Mesa lavapipe) with the Khronos loader, registered for every program; for wgpu set WGPU_BACKEND=vulkan.'),
     }),
     vscode: z.strictObject({
-        enabled: z
-            .boolean()
-            .describe('Portable VS Code inside the sandbox (code on PATH, desktop shortcut); its settings and extensions persist.'),
+        enabled: EnabledSchema.describe('Portable VS Code inside the sandbox (code on PATH, desktop shortcut); its settings and extensions persist. true, false, or "auto" = when VS Code is installed on this PC.'),
         setup: z
             .boolean()
             .describe("Point VS Code at the sandbox's own tools (JDK, Python, Go, compilers, .NET, Git, PowerShell 7 and Git Bash terminals) and install the language extensions for the toolchains in use."),

package/dist/core/schema/vpn.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export declare const VPN_PROVIDERS: readonly ["nordvpn", "openvpn-file"];
+export declare const VpnSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    provider: z.ZodEnum<{
+        nordvpn: "nordvpn";
+        "openvpn-file": "openvpn-file";
+    }>;
+    protocol: z.ZodEnum<{
+        udp: "udp";
+        tcp: "tcp";
+    }>;
+    country: z.ZodString;
+    configFile: z.ZodString;
+    killSwitch: z.ZodBoolean;
+}, z.core.$strict>;
+export type VpnProvider = (typeof VPN_PROVIDERS)[number];

package/dist/core/schema/vpn.js

@@ -0,0 +1,22 @@
+// The VPN setting (inside the sandbox only; the login is not a setting: it is kept encrypted by `sandbox vpn login`).
+import { z } from 'zod';
+export const VPN_PROVIDERS = ['nordvpn', 'openvpn-file'];
+export const VpnSchema = z.strictObject({
+    enabled: z
+        .boolean()
+        .describe("Send the sandbox's traffic through a VPN. Only the sandbox: your PC's own connection is untouched. Needs a saved login first (sandbox vpn login). The agent in the sandbox can read that login and can turn the tunnel off (it is the administrator there)."),
+    provider: z
+        .enum(VPN_PROVIDERS)
+        .describe('nordvpn: a recommended NordVPN server is picked at every launch. openvpn-file: your own .ovpn file (configFile).'),
+    protocol: z.enum(['udp', 'tcp']).describe('udp is faster; tcp gets through networks that block udp.'),
+    country: z
+        .string()
+        .regex(/^([A-Za-z][A-Za-z .'-]{0,39})?$/, 'a country name or code like uk or Germany')
+        .describe('nordvpn: the country of the server, e.g. uk, us or Germany. Empty = the best server anywhere.'),
+    configFile: z
+        .string()
+        .describe("openvpn-file: the .ovpn file on this PC (its certificates inside it). Files that run programs (script-security, up, down, plugin ...) are refused. A project's file can never set this."),
+    killSwitch: z
+        .boolean()
+        .describe('Block all traffic that does not go through the tunnel: when the tunnel cannot start, the sandbox stays offline instead of using your normal connection. A project can only turn this on, never off.'),
+});

package/dist/core/schema/web.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export declare const WEB_DEFAULT_PORT = 47800;
+export declare const WebSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    port: z.ZodNumber;
+}, z.core.$strict>;

package/dist/core/schema/web.js

@@ -0,0 +1,14 @@
+// The web UI settings (sandbox web): not part of LocalOverrides, a repo never turns a way into your agents on.
+import { z } from 'zod';
+export const WEB_DEFAULT_PORT = 47800;
+export const WebSchema = z.strictObject({
+    enabled: z
+        .boolean()
+        .describe('(Beta) Allow the web UI: your sandbox sessions in a browser on this PC. Off by default, and nothing starts it by itself yet: sandbox web start works either way and runs it until sandbox web stop (or a restart of the PC).'),
+    port: z
+        .number()
+        .int()
+        .min(1024)
+        .max(65535)
+        .describe('Port of the web UI on 127.0.0.1 (this PC only). Pick another when it is taken.'),
+});

package/dist/core/types.d.ts

@@ -26,6 +26,14 @@ export interface LoadedConfig {
     config: Config;
     configPath: string | null;
     base: string;
+    /**
+     * The files the settings came from: the machine file (all-users install) and the user file, null when absent.
+     * Optional so callers that build a LoadedConfig by hand (no files) keep compiling.
+     */
+    layers?: {
+        machine: string | null;
+        user: string | null;
+    };
 }
 export interface RunRequest {
     packageRoot: string;
@@ -94,6 +102,16 @@ export interface DatabasePlan {
     port: number;
     adminPort?: number;
 }
+/** The VPN decided at launch (host/vpn/prepare.ts): its checked profile, and the login for the one-shot file. */
+export interface PreparedVpn {
+    session: GuestVpn;
+    /** The profile text, already checked. */
+    profile: string;
+    credentials: {
+        username: string;
+        password: string;
+    };
+}
 /** databases / pcLanguages: use these instead of scanning (tests). */
 export interface GenerateOptions {
     packageRoot: string;
@@ -116,6 +134,8 @@ export interface GenerateOptions {
         projects: BootWant[];
         keepOff: string[];
     };
+    /** The VPN for this launch (vpn.enabled); its profile goes in the launch folder, its login in the one-shot file. */
+    vpn?: PreparedVpn;
 }
 export interface Generated {
     wsbPath: string;
@@ -154,6 +174,16 @@ export interface ProfileResult {
     credentials: boolean;
     secretsRemoved: string[];
 }
+/** The VPN of one launch: what the guest needs besides the login (which comes in the one-shot secrets file). */
+export interface GuestVpn {
+    provider: Config['vpn']['provider'];
+    protocol: Config['vpn']['protocol'];
+    killSwitch: boolean;
+    /** The server's name, for messages. */
+    server: string;
+    /** The checked profile, relative to the launch folder. */
+    profile: string;
+}
 /** Written by the host to C:\AgentLaunch\session.json (read-only for the guest): everything the guest needs to know. */
 export interface GuestSession {
     launchId: string;
@@ -164,7 +194,10 @@ export interface GuestSession {
      * The launch folder's project id (file-name safe; status files and sessions use it). Older launch folders lack it.
      */
     projectId?: string;
-    /** Where project roots appear (C:\Projects), and the guest folders of the roots and the projects mapped at boot. Older launch folders lack them. */
+    /**
+     * Where project roots appear (C:\Projects), and the guest folders of the roots and the projects mapped at boot. Older
+     * launch folders lack them.
+     */
     projectsDir?: string;
     roots?: string[];
     /** false: start no agent session at boot (a restart that adds a project opens its sessions itself). */
@@ -185,6 +218,8 @@ export interface GuestSession {
     attach: Config['attach'];
     hooks: Config['hooks'];
     downloads: Config['downloads'];
+    /** Set when the VPN is on for this launch (older launch folders lack it). */
+    vpn?: GuestVpn;
     /** nodeVersion: this PC's Node (e.g. 22.11.0), found under nvm\v<version> when nvm is mapped, else under node. */
     /** volta / pyenv: this PC uses them (their "auto" settings turn them on in the sandbox too). */
     hostTools: {
@@ -212,12 +247,20 @@ export interface GuestSession {
         letter: string;
         target: string;
     }[];
-    /** sandbox.cpuLimit as a number (null = no cap); sandbox\cpucap.ps1 applies it before anything starts. */
+    /**
+     * sandbox.cpuLimit as a number (null = no cap); sandbox\scripts\set-cpu-cap.ps1 applies it before anything starts.
+     */
     cpuLimitPercent?: number | null;
-    /** sandbox.pageFileMb (0 = Windows' own); sandbox\pagefile.ps1 applies it at logon. */
+    /** sandbox.pageFileMb (0 = Windows' own); sandbox\scripts\set-page-file.ps1 applies it at logon. */
     pageFileMb?: number;
     /** Apps to install (catalogue ids and your own programs); missing in launch folders of older versions. */
     apps?: Config['apps'];
     /** audit.enabled and audit.processes: the sandbox reports the programs it starts (host keeps the log). */
     auditProcesses?: boolean;
+    /** Every agent's home variables (CODEX_HOME ...) -> folder below the state folder; older launch folders lack it. */
+    agentHomes?: Record<string, string>;
+    /** Per agent: folders of the user profile (.qwen ...) linked into the persistent state at boot. */
+    agentProfileDirs?: Record<string, string[]>;
+    /** Every configured agent (without its environment): a terminal command each; older launch folders lack it. */
+    agents?: Record<string, Harness>;
 }

package/dist/core/util/errors.d.ts

@@ -5,4 +5,4 @@ export declare class UserError extends Error {
 }
 /** Throws a UserError. Typed explicitly so TypeScript narrows after calls (arrow functions need it to act as never). */
 export declare const fail: (message: string, fix?: string) => never;
-export declare const errMsg: (e: unknown) => string;
+export declare function errMsg(e: unknown): string;

package/dist/core/util/errors.js

@@ -11,4 +11,6 @@ export class UserError extends Error {
 export const fail = (message, fix) => {
     throw new UserError(message, fix);
 };
-export const errMsg = (e) => (e instanceof Error ? e.message : String(e));
+export function errMsg(e) {
+    return e instanceof Error ? e.message : String(e);
+}

package/dist/core/util/fs.d.ts

@@ -1,8 +1,8 @@
-export declare const ensureDir: (p: string) => void;
-export declare const dirExists: (p: string) => boolean;
-export declare const fileExists: (p: string) => boolean;
-export declare const readJson: <T>(p: string) => T;
-export declare const tryReadJson: <T>(p: string) => T | null;
+export declare function ensureDir(p: string): void;
+export declare function dirExists(p: string): boolean;
+export declare function fileExists(p: string): boolean;
+export declare function readJson<T>(p: string): T;
+export declare function tryReadJson<T>(p: string): T | null;
 /** Atomic (a crash or a second command never leaves half a file); refused outside temp during the self-test. */
-export declare const writeJson: (p: string, value: unknown) => void;
-export declare const realPath: (p: string) => string;
+export declare function writeJson(p: string, value: unknown): void;
+export declare function realPath(p: string): string;

package/dist/core/util/fs.js

@@ -1,40 +1,44 @@
 import fs from 'node:fs';
 import { writeJsonAtomic } from '../../shared/io/index.js';
-export const ensureDir = (p) => {
+export function ensureDir(p) {
     fs.mkdirSync(p, { recursive: true });
-};
-export const dirExists = (p) => {
+}
+export function dirExists(p) {
     try {
         return fs.statSync(p).isDirectory();
     }
     catch {
         return false;
     }
-};
-export const fileExists = (p) => {
+}
+export function fileExists(p) {
     try {
         return fs.statSync(p).isFile();
     }
     catch {
         return false;
     }
-};
-export const readJson = (p) => JSON.parse(fs.readFileSync(p, 'utf8').replace(/^\uFEFF/, ''));
-export const tryReadJson = (p) => {
+}
+export function readJson(p) {
+    return JSON.parse(fs.readFileSync(p, 'utf8').replace(/^\uFEFF/, ''));
+}
+export function tryReadJson(p) {
     try {
         return readJson(p);
     }
     catch {
         return null;
     }
-};
+}
 /** Atomic (a crash or a second command never leaves half a file); refused outside temp during the self-test. */
-export const writeJson = (p, value) => writeJsonAtomic(p, value);
-export const realPath = (p) => {
+export function writeJson(p, value) {
+    return writeJsonAtomic(p, value);
+}
+export function realPath(p) {
     try {
         return fs.realpathSync(p);
     }
     catch {
         return p;
     }
-};
+}

package/dist/core/util/index.d.ts

@@ -1,7 +1,7 @@
-export { isWin, sleep, runPowerShell, captureOutput, runPowerShellAsync } from './process.js';
+export { isWin, sleep, captureOutput } from './process.js';
 export { UserError, fail, errMsg } from './errors.js';
 export { parseJsonc, readJsonc } from './jsonc.js';
 export { ensureDir, dirExists, fileExists, readJson, tryReadJson, writeJson, realPath } from './fs.js';
 export { xmlEscape, safeText, plainText } from './text.js';
-export { homeDir, expandPath, isRootPath, isUserProfile, isInsideOrEqual, findOnPath } from './paths.js';
+export { homeDir, expandPath, expandVariables, isRootPath, isUserProfile, isInsideOrEqual, findOnPath, } from './paths.js';
 export { isLink, removeLink, assertNoLinks } from './links.js';

package/dist/core/util/index.js

@@ -1,7 +1,7 @@
-export { isWin, sleep, runPowerShell, captureOutput, runPowerShellAsync } from './process.js';
+export { isWin, sleep, captureOutput } from './process.js';
 export { UserError, fail, errMsg } from './errors.js';
 export { parseJsonc, readJsonc } from './jsonc.js';
 export { ensureDir, dirExists, fileExists, readJson, tryReadJson, writeJson, realPath } from './fs.js';
 export { xmlEscape, safeText, plainText } from './text.js';
-export { homeDir, expandPath, isRootPath, isUserProfile, isInsideOrEqual, findOnPath } from './paths.js';
+export { homeDir, expandPath, expandVariables, isRootPath, isUserProfile, isInsideOrEqual, findOnPath, } from './paths.js';
 export { isLink, removeLink, assertNoLinks } from './links.js';

package/dist/core/util/jsonc.d.ts

@@ -2,5 +2,5 @@
  * Parses JSON with comments and trailing commas (JSONC, like VS Code's settings.json). Errors name the file, line
  * and column, and say what to fix.
  */
-export declare const parseJsonc: <T>(text: string, source: string) => T;
-export declare const readJsonc: <T>(file: string) => T;
+export declare function parseJsonc<T>(text: string, source: string): T;
+export declare function readJsonc<T>(file: string): T;

package/dist/core/util/jsonc.js

@@ -5,9 +5,12 @@ import { fail } from './errors.js';
  * Parses JSON with comments and trailing commas (JSONC, like VS Code's settings.json). Errors name the file, line
  * and column, and say what to fix.
  */
-export const parseJsonc = (text, source) => {
+export function parseJsonc(text, source) {
     const errors = [];
-    const value = parseJsoncText(text.replace(/^/, ''), errors, { allowTrailingComma: true, disallowComments: false });
+    const value = parseJsoncText(text.replace(/^\uFEFF/, ''), errors, {
+        allowTrailingComma: true,
+        disallowComments: false,
+    });
     if (errors.length) {
         const { offset, error } = errors[0];
         const before = text.slice(0, offset).split(/\r?\n/);
@@ -21,5 +24,7 @@ export const parseJsonc = (text, source) => {
             ').', 'Fix that spot in the file. Comments (// and /* */) and trailing commas are fine.');
     }
     return value;
-};
-export const readJsonc = (file) => parseJsonc(fs.readFileSync(file, 'utf8'), file);
+}
+export function readJsonc(file) {
+    return parseJsonc(fs.readFileSync(file, 'utf8'), file);
+}

package/dist/core/util/links.d.ts

@@ -1,10 +1,10 @@
 /** True if `p` itself is a symlink or junction (lstat; never follows it). */
-export declare const isLink: (p: string) => boolean;
+export declare function isLink(p: string): boolean;
 /** Removes a symlink or junction itself (never its target). Junctions need rmdir on Windows. */
-export declare const removeLink: (p: string) => void;
+export declare function removeLink(p: string): void;
 /**
  * The sandbox can write anywhere in its data folder, so it could swap a folder for a junction that points at this
  * PC's own disk. Before the host reads, writes or deletes anything under `root`, every existing path component from
  * `root` down to `target` must be a plain folder/file. Throws otherwise.
  */
-export declare const assertNoLinks: (root: string, target: string) => void;
+export declare function assertNoLinks(root: string, target: string): void;

package/dist/core/util/links.js

@@ -3,16 +3,16 @@ import path from 'node:path';
 import { assertTestWritable } from '../../shared/test-guard.js';
 import { fail } from './errors.js';
 /** True if `p` itself is a symlink or junction (lstat; never follows it). */
-export const isLink = (p) => {
+export function isLink(p) {
     try {
         return fs.lstatSync(p).isSymbolicLink();
     }
     catch {
         return false;
     }
-};
+}
 /** Removes a symlink or junction itself (never its target). Junctions need rmdir on Windows. */
-export const removeLink = (p) => {
+export function removeLink(p) {
     assertTestWritable(p);
     try {
         fs.unlinkSync(p);
@@ -20,13 +20,13 @@ export const removeLink = (p) => {
     catch {
         fs.rmdirSync(p);
     }
-};
+}
 /**
  * The sandbox can write anywhere in its data folder, so it could swap a folder for a junction that points at this
  * PC's own disk. Before the host reads, writes or deletes anything under `root`, every existing path component from
  * `root` down to `target` must be a plain folder/file. Throws otherwise.
  */
-export const assertNoLinks = (root, target) => {
+export function assertNoLinks(root, target) {
     const rel = path.relative(path.resolve(root), path.resolve(target));
     if (rel.startsWith('..') || path.isAbsolute(rel))
         fail('Refusing to touch ' + target + ': it is outside ' + root);
@@ -36,4 +36,4 @@ export const assertNoLinks = (root, target) => {
         if (isLink(current))
             fail('Refusing to touch ' + target + ': ' + current + ' is a link (possible escape attempt from the sandbox).');
     }
-};
+}

package/dist/core/util/paths.d.ts

@@ -1,7 +1,9 @@
-export declare const homeDir: () => string;
+export declare function homeDir(): string;
+/** Expands %VAR% and a leading ~, without resolving the result. */
+export declare function expandVariables(input: string): string;
 /** Expands %VAR% and resolves relative paths against `base`. */
-export declare const expandPath: (input: string, base: string) => string;
-export declare const isRootPath: (p: string) => boolean;
-export declare const isUserProfile: (p: string) => boolean;
-export declare const isInsideOrEqual: (parent: string, child: string) => boolean;
-export declare const findOnPath: (names: string[]) => string | null;
+export declare function expandPath(input: string, base: string): string;
+export declare function isRootPath(p: string): boolean;
+export declare function isUserProfile(p: string): boolean;
+export declare function isInsideOrEqual(parent: string, child: string): boolean;
+export declare function findOnPath(names: string[]): string | null;

package/dist/core/util/paths.js

@@ -1,27 +1,33 @@
 import os from 'node:os';
 import path from 'node:path';
 import { fileExists } from './fs.js';
-export const homeDir = () => process.env.USERPROFILE ?? os.homedir();
-/** Expands %VAR% and resolves relative paths against `base`. */
-export const expandPath = (input, base) => {
-    const expanded = input
+export function homeDir() {
+    return process.env.USERPROFILE ?? os.homedir();
+}
+/** Expands %VAR% and a leading ~, without resolving the result. */
+export function expandVariables(input) {
+    return input
         .replace(/%([^%]+)%/g, (_m, name) => process.env[name] ?? '%' + name + '%')
         .replace(/^~(?=$|[\\/])/, homeDir());
+}
+/** Expands %VAR% and resolves relative paths against `base`. */
+export function expandPath(input, base) {
+    const expanded = expandVariables(input);
     return path.resolve(path.isAbsolute(expanded) ? expanded : path.join(base, expanded));
-};
-export const isRootPath = (p) => {
+}
+export function isRootPath(p) {
     const n = path.resolve(p);
     return n.toLowerCase() === path.parse(n).root.toLowerCase();
-};
-export const isUserProfile = (p) => {
+}
+export function isUserProfile(p) {
     const profile = process.env.USERPROFILE ?? process.env.HOME ?? '';
     return profile !== '' && path.resolve(p).toLowerCase() === path.resolve(profile).toLowerCase();
-};
-export const isInsideOrEqual = (parent, child) => {
+}
+export function isInsideOrEqual(parent, child) {
     const rel = path.relative(path.resolve(parent).toLowerCase(), path.resolve(child).toLowerCase());
     return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
-};
-export const findOnPath = (names) => {
+}
+export function findOnPath(names) {
     const dirs = (process.env.PATH ?? process.env.Path ?? '').split(path.delimiter).filter((d) => d !== '');
     for (const name of names)
         for (const dir of dirs) {
@@ -30,4 +36,4 @@ export const findOnPath = (names) => {
                 return candidate;
         }
     return null;
-};
+}