windows-development-sandbox 1.4.0 → 1.4.3

package/dist/guest/toolchains/databases/postgres.js

@@ -1,38 +0,0 @@
-// PostgreSQL from EnterpriseDB's Windows binaries (without pgAdmin).
-import path from 'node:path';
-import { fetchJson, installArchive } from '../../../shared/download.js';
-import { execAsync, exists, log, logsDir } from '../../env.js';
-import { resolveCached, tool } from '../common.js';
-import { portOpen } from '../../ports.js';
-import { clearStaleLocks, createOnce, dataFor } from './server.js';
-/** The data folder of a PostgreSQL major version (one cluster per major). */
-export const postgresData = (version) => dataFor('postgres-' + version.split('.')[0]);
-export const setupPostgres = async (env, plan) => {
-    const exact = await resolveCached('postgres:' + plan.version, async () => {
-        const versions = (await fetchJson('https://www.postgresql.org/versions.json')).filter((v) => v.supported);
-        const hit = plan.version === 'latest' ? versions.find((v) => v.current) ?? versions[versions.length - 1] : versions.find((v) => v.major === plan.version.split('.')[0]);
-        return hit ? hit.major + '.' + hit.latestMinor : Promise.reject(new Error('No supported PostgreSQL ' + plan.version));
-    });
-    const home = tool('postgres', exact);
-    const bin = path.join(home, 'bin');
-    if (!exists(path.join(bin, 'pg_ctl.exe'))) {
-        log('Downloading PostgreSQL ' + exact + ' (~330 MB once) ...');
-        // EDB publishes no checksums; the download is HTTPS from EnterpriseDB, PostgreSQL's official Windows packager.
-        await installArchive('https://get.enterprisedb.com/postgresql/postgresql-' + exact + '-1-windows-x64-binaries.zip', home, {
-            locate: 'pg_ctl.exe', up: 1, fileName: 'postgresql-' + exact + '.zip', members: ['pgsql/bin', 'pgsql/lib', 'pgsql/share', 'pgsql/include'],
-        });
-    }
-    const data = postgresData(exact);
-    await createOnce(data, 'PG_VERSION', async () => {
-        log('Creating the PostgreSQL database (first start) ...');
-        await execAsync(path.join(bin, 'initdb.exe'), ['-D', data, '-U', 'postgres', '-A', 'trust', '-E', 'UTF8', '--locale=C'], { stdio: 'ignore' });
-    });
-    if (await portOpen(plan.port))
-        throw new Error('port ' + plan.port + ' is already in use (change databases.postgres.port)');
-    await clearStaleLocks(data, ['postmaster.pid'], plan.port);
-    // postgres.exe refuses to run as an administrator (the sandbox user is one); pg_ctl drops the rights first.
-    await execAsync(path.join(bin, 'pg_ctl.exe'), ['start', '-D', data, '-w', '-t', '60', '-l', path.join(logsDir, 'postgres.log'), '-o', '-p ' + plan.port + ' -c listen_addresses=localhost'], { stdio: 'ignore' });
-    Object.assign(env.vars, { PGHOST: 'localhost', PGPORT: String(plan.port), PGUSER: 'postgres' });
-    env.prepend.push(bin);
-    env.summary.push('postgres ' + exact + ': localhost:' + plan.port + ', user postgres, no password (postgres://postgres@localhost:' + plan.port + '/postgres)');
-};

package/dist/guest/toolchains/databases/redis.d.ts

@@ -1,3 +0,0 @@
-import type { DatabasePlan } from '../../../core/types.js';
-import { type ToolEnv } from '../common.js';
-export declare const setupRedis: (env: ToolEnv, plan: DatabasePlan) => Promise<void>;

package/dist/guest/toolchains/databases/redis.js

@@ -1,16 +0,0 @@
-// Redis (the maintained community Windows build of upstream Redis).
-import path from 'node:path';
-import { exists, mkdirp } from '../../env.js';
-import { installFromGithub, tool } from '../common.js';
-import { dataFor, startServer } from './server.js';
-export const setupRedis = async (env, plan) => {
-    const home = tool('redis');
-    if (!exists(path.join(home, 'redis-server.exe'))) {
-        // Redis has no official Windows build; this one is built from upstream Redis with MSYS2.
-        await installFromGithub('redis-windows/redis-windows', /^Redis-[\d.]+-Windows-x64-msys2\.zip$/, { dest: home, what: (a) => 'Redis (' + a.name + ', ~10 MB once)', locate: 'redis-server.exe' });
-    }
-    const data = mkdirp(dataFor('redis'));
-    await startServer('redis', path.join(home, 'redis-server.exe'), ['--port', String(plan.port), '--bind', '127.0.0.1', '--dir', data.replace(/\\/g, '/'), '--appendonly', 'yes'], plan.port);
-    env.prepend.push(home);
-    env.summary.push('redis: redis://127.0.0.1:' + plan.port + ' (redis-cli on PATH)');
-};

package/dist/guest/toolchains/git.d.ts

@@ -1,3 +0,0 @@
-import type { GitAccess } from '../../core/types.js';
-import { type ToolEnv } from './common.js';
-export declare const setupGit: (env: ToolEnv, hostCopy: boolean, refresh: boolean, access: GitAccess) => Promise<void>;

package/dist/guest/toolchains/go.d.ts

@@ -1,3 +0,0 @@
-import type { Toolchains } from '../../core/types.js';
-import { type ToolEnv } from './common.js';
-export declare const setupGo: (env: ToolEnv, config: Toolchains["go"]) => Promise<void>;

package/dist/guest/toolchains/java.d.ts

@@ -1,8 +0,0 @@
-import type { Toolchains } from '../../core/types.js';
-import { type ToolEnv } from './common.js';
-/**
- * A JDK for tools that run on Java (DynamoDB Local): the newest one already installed, else the newest LTS. Returns its
- * folder; the agent's Java on PATH stays whatever toolchains.java says.
- */
-export declare const ensureJdk: () => Promise<string>;
-export declare const setupJava: (env: ToolEnv, config: Toolchains["java"]) => Promise<void>;

package/dist/guest/toolchains/node.d.ts

@@ -1,3 +0,0 @@
-import type { Toolchains, ToolVersions } from '../../core/types.js';
-import { type ToolEnv } from './common.js';
-export declare const setupNode: (env: ToolEnv, versions: ToolVersions, config: Toolchains["node"]) => Promise<void>;

package/dist/guest/toolchains/pwsh.d.ts

@@ -1,4 +0,0 @@
-import { type ToolEnv } from './common.js';
-/** Where pwsh.exe lives (the host's Windows Terminal profile points at the same folder under C:\AgentData). */
-export declare const pwshDir: () => string;
-export declare const setupPwsh: (env: ToolEnv, refresh?: boolean) => Promise<void>;

package/dist/guest/toolchains/python.d.ts

@@ -1,3 +0,0 @@
-import type { Toolchains, ToolVersions } from '../../core/types.js';
-import { type ToolEnv } from './common.js';
-export declare const setupPython: (env: ToolEnv, config: Toolchains["python"], versions: ToolVersions) => Promise<void>;

package/dist/guest/toolchains/scripting/php.d.ts

@@ -1,3 +0,0 @@
-import type { Toolchains } from '../../../core/types.js';
-import { type ToolEnv } from '../common.js';
-export declare const setupPhp: (env: ToolEnv, config: Toolchains["php"]) => Promise<void>;

package/dist/guest/toolchains/scripting/ruby.d.ts

@@ -1,3 +0,0 @@
-import type { Toolchains } from '../../../core/types.js';
-import { type ToolEnv } from '../common.js';
-export declare const setupRuby: (env: ToolEnv, config: Toolchains["ruby"]) => Promise<void>;

package/dist/host/accounts.d.ts

@@ -1,32 +0,0 @@
-export interface Account {
-    name: string;
-    savedAt: string;
-    email: string | null;
-    credentials: unknown;
-    oauthAccount: unknown;
-}
-export interface AccountRow {
-    name: string;
-    email: string | null;
-    isDefault: boolean;
-    isActive: boolean;
-    savedAt: string;
-}
-export declare const accountsDir: (storageRoot: string) => string;
-export declare const sandboxClaudeDir: (dataPath: string) => string;
-export declare const readAccount: (storageRoot: string, name: string) => Account | null;
-export declare const defaultAccount: (storageRoot: string) => string | null;
-export declare const activeAccount: (dataPath: string) => string | null;
-export declare const listAccounts: (storageRoot: string, dataPath: string) => AccountRow[];
-/** Saves the sandbox's current login (or this PC's, with fromHost) under `name`. */
-export declare const saveAccount: (storageRoot: string, dataPath: string, name: string, fromHost: {
-    claudeDir: string;
-    globalStateFile: string;
-} | null) => Account;
-/**
- * Makes `name` the sandbox's login. Claude refreshes (rotates) tokens while it runs, so the outgoing account's
- * current tokens are saved back first; otherwise its stored refresh token could already be invalid.
- */
-export declare const activateAccount: (storageRoot: string, dataPath: string, name: string) => Account;
-export declare const setDefaultAccount: (storageRoot: string, name: string | null) => void;
-export declare const removeAccount: (storageRoot: string, name: string) => void;

package/dist/host/accounts.js

@@ -1,128 +0,0 @@
-// Several Claude logins for the sandbox. Each account is a saved copy of Claude's .credentials.json plus the
-// `oauthAccount` block of .claude.json, kept in host-only storage (<storage>\accounts, never mapped into a sandbox).
-// Switching writes them into the sandbox's persistent Claude state; when the sandbox is running the agent is then
-// restarted in place with --continue so the conversation carries on.
-import fs from 'node:fs';
-import path from 'node:path';
-import { z } from 'zod';
-import { isSafeFileName } from '../shared/paths.js';
-import { assertTestWritable } from './test-guard.js';
-import { readValid, writeJsonAtomic } from '../shared/rundir.js';
-import { assertNoLinks, fail, fileExists, isLink, removeLink, tryReadJson, writeJson } from '../core/util.js';
-const NAME = /^[A-Za-z0-9_-]{1,40}$/;
-const AccountSchema = z.object({ name: z.string().regex(NAME), savedAt: z.string().max(64), email: z.string().max(200).nullable(), credentials: z.looseObject({}), oauthAccount: z.unknown() });
-const IndexSchema = z.object({ default: z.string().regex(NAME).optional(), active: z.record(z.string().max(200), z.string().regex(NAME)).optional() });
-const ACCOUNT_CACHES = ['remote-settings.json', 'policy-limits.json', 'policy-limits.json.stamp.json'];
-const MAX_LOGIN_BYTES = 1024 * 1024;
-/** .claude.json holds per-project state and can be large; it is still capped so a hostile file cannot exhaust memory. */
-const MAX_STATE_BYTES = 256 * 1024 * 1024;
-export const accountsDir = (storageRoot) => path.join(storageRoot, 'accounts');
-export const sandboxClaudeDir = (dataPath) => path.join(dataPath, 'state', 'claude');
-const storageOf = (dataPath) => path.dirname(path.dirname(dataPath));
-const dataName = (dataPath) => path.basename(dataPath);
-const accountFile = (storageRoot, name) => path.join(accountsDir(storageRoot), name + '.json');
-const indexFile = (storageRoot) => path.join(accountsDir(storageRoot), 'index.json');
-const readIndex = (storageRoot) => readValid(IndexSchema, indexFile(storageRoot)) ?? {};
-const updateIndex = (storageRoot, change) => writeJsonAtomic(indexFile(storageRoot), change(readIndex(storageRoot)));
-/** A file name of its own: not "index" (the index file), not a Windows device name such as con or nul. */
-const validName = (name) => NAME.test(name) && name.toLowerCase() !== 'index' && isSafeFileName(name + '.json');
-const assertName = (name) => { if (!validName(name))
-    fail('Invalid account name "' + name + '".', 'Use letters, numbers, - and _ only (max 40), e.g. work or personal.'); };
-const emailOf = (oauthAccount) => {
-    const email = oauthAccount?.emailAddress;
-    return typeof email === 'string' ? email.slice(0, 200) : null;
-};
-export const readAccount = (storageRoot, name) => (validName(name) ? readValid(AccountSchema, accountFile(storageRoot, name)) : null);
-export const defaultAccount = (storageRoot) => readIndex(storageRoot).default ?? null;
-export const activeAccount = (dataPath) => readIndex(storageOf(dataPath)).active?.[dataName(dataPath)] ?? null;
-const setActive = (dataPath, name) => updateIndex(storageOf(dataPath), (i) => ({ ...i, active: { ...i.active, [dataName(dataPath)]: name } }));
-export const listAccounts = (storageRoot, dataPath) => {
-    const dir = accountsDir(storageRoot);
-    if (!fs.existsSync(dir))
-        return [];
-    const def = defaultAccount(storageRoot);
-    const active = activeAccount(dataPath);
-    return fs.readdirSync(dir)
-        .filter((f) => f.endsWith('.json') && f !== 'index.json')
-        .map((f) => readAccount(storageRoot, f.slice(0, -5)))
-        .filter((a) => a !== null)
-        .map((a) => ({ name: a.name, email: a.email, isDefault: a.name === def, isActive: a.name === active, savedAt: a.savedAt }));
-};
-/** Reads a JSON file that may be sandbox-written: no links, size-capped. */
-const readUntrusted = (file, max) => (fileExists(file) && !isLink(file) && fs.statSync(file).size <= max ? tryReadJson(file) : null);
-/** The login currently in a Claude config folder (+ its global state file). */
-const readLogin = (claudeDir, globalStateFile) => {
-    const credentials = readUntrusted(path.join(claudeDir, '.credentials.json'), MAX_LOGIN_BYTES);
-    if (!credentials || typeof credentials !== 'object')
-        fail('No Claude login found in ' + claudeDir + '.', 'Sign in to Claude first (inside the sandbox, or on this PC with --from-host), then save it again.');
-    return { credentials, oauthAccount: readUntrusted(globalStateFile, MAX_STATE_BYTES)?.oauthAccount ?? null };
-};
-const store = (storageRoot, name, login) => {
-    const account = { name, savedAt: new Date().toISOString(), email: emailOf(login.oauthAccount), ...login };
-    writeJsonAtomic(accountFile(storageRoot, name), account);
-    return account;
-};
-const sandboxLogin = (dataPath) => {
-    assertNoLinks(dataPath, sandboxClaudeDir(dataPath));
-    return { claudeDir: sandboxClaudeDir(dataPath), globalStateFile: path.join(sandboxClaudeDir(dataPath), '.claude.json') };
-};
-/** Saves the sandbox's current login (or this PC's, with fromHost) under `name`. */
-export const saveAccount = (storageRoot, dataPath, name, fromHost) => {
-    assertName(name);
-    const source = fromHost ?? sandboxLogin(dataPath);
-    const account = store(storageRoot, name, readLogin(source.claudeDir, source.globalStateFile));
-    if (!fromHost)
-        setActive(dataPath, name);
-    if (!defaultAccount(storageRoot))
-        setDefaultAccount(storageRoot, name);
-    return account;
-};
-/** Replaces a file that may be a sandbox-planted link instead of writing through it. */
-const writeSandboxJson = (file, value) => {
-    assertTestWritable(file);
-    if (isLink(file))
-        removeLink(file);
-    writeJson(file, value);
-};
-/**
- * Makes `name` the sandbox's login. Claude refreshes (rotates) tokens while it runs, so the outgoing account's
- * current tokens are saved back first; otherwise its stored refresh token could already be invalid.
- */
-export const activateAccount = (storageRoot, dataPath, name) => {
-    const account = readAccount(storageRoot, name) ?? fail('Unknown account "' + name + '".', 'Saved accounts: ' + (listAccounts(storageRoot, dataPath).map((a) => a.name).join(', ') || 'none yet; save one with sandbox account save <name>'));
-    const { claudeDir, globalStateFile } = sandboxLogin(dataPath);
-    const outgoing = activeAccount(dataPath);
-    if (outgoing && outgoing !== name && readAccount(storageRoot, outgoing) && fileExists(path.join(claudeDir, '.credentials.json'))) {
-        try {
-            store(storageRoot, outgoing, readLogin(claudeDir, globalStateFile));
-        }
-        catch { /* nothing usable to save back */ }
-    }
-    fs.mkdirSync(claudeDir, { recursive: true });
-    // Caches tied to the previous account (Claude deletes these on /logout); otherwise its org policy could linger.
-    for (const cache of ACCOUNT_CACHES) {
-        const file = path.join(claudeDir, cache);
-        if (isLink(file))
-            removeLink(file);
-        else
-            fs.rmSync(file, { force: true });
-    }
-    writeSandboxJson(path.join(claudeDir, '.credentials.json'), account.credentials);
-    const state = readUntrusted(globalStateFile, MAX_STATE_BYTES);
-    if (account.oauthAccount && (state || !fileExists(globalStateFile)))
-        writeSandboxJson(globalStateFile, { ...(state ?? {}), oauthAccount: account.oauthAccount });
-    setActive(dataPath, name);
-    return account;
-};
-export const setDefaultAccount = (storageRoot, name) => {
-    if (name !== null && !readAccount(storageRoot, name))
-        fail('Unknown account "' + name + '".', 'See your accounts with: sandbox account list');
-    updateIndex(storageRoot, (i) => ({ ...i, default: name ?? undefined }));
-};
-export const removeAccount = (storageRoot, name) => {
-    if (!readAccount(storageRoot, name))
-        fail('Unknown account "' + name + '".', 'See your accounts with: sandbox account list');
-    fs.rmSync(accountFile(storageRoot, name));
-    if (defaultAccount(storageRoot) === name)
-        setDefaultAccount(storageRoot, null);
-};

package/dist/host/agent-commands.d.ts

@@ -1,25 +0,0 @@
-import type { Config } from '../core/types.js';
-export declare const commandsDir: (storageRoot: string) => string;
-export interface AgentCommand {
-    harness: string;
-    command: string;
-    real: string;
-}
-/** The agent's own executable on this PC, skipping this tool's forwarding files. */
-export declare const realAgent: (command: string, skipDir: string, pathValue?: string) => string | null;
-/** The agents that get a forwarding command: installed on this PC, and listed (or "auto" = all of them). */
-export declare const agentCommands: (config: Config, storageRoot: string, pathValue?: string) => AgentCommand[];
-/** The .cmd file for one agent (cmd, PowerShell and Windows Terminal all run it). */
-export declare const forwardingCmd: (a: AgentCommand, node: string, entry: string) => string;
-/** The same for Git Bash, which looks for a file without an extension. */
-export declare const forwardingSh: (a: AgentCommand, node: string, entry: string) => string;
-export interface Reconciled {
-    on: boolean;
-    commands: AgentCommand[];
-    changed: boolean;
-}
-/**
- * Makes this PC match agentCommands: on = a forwarding file per installed agent and the folder first on your PATH;
- * off = no files, no PATH entry. Only touches files it wrote and its own PATH entry; does nothing when already right.
- */
-export declare const reconcileAgentCommands: (config: Config, storageRoot: string, node: string, entry: string) => Reconciled;

package/dist/host/agent-commands.js

@@ -1,145 +0,0 @@
-// (Beta) Agent commands: with agentCommands.enabled, typing an agent's own command on this PC (claude, codex, ...) starts
-// it in a hidden sandbox for the folder you are in and attaches that terminal. Small forwarding files in
-// <storage>\agent-commands go first on YOUR PATH (so they win over npm's and the installers' copies); turning it off
-// removes the files and that one PATH entry. SANDBOX_AGENT_DIRECT=1 runs the real agent on this PC instead.
-import fs from 'node:fs';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { ensureDir, fileExists } from '../core/util.js';
-import { writeFileAtomic } from '../shared/rundir.js';
-import { safeRemove } from '../shared/safe-remove.js';
-import { SYSTEM } from '../shared/system.js';
-import { refuseInSelfTest } from './test-guard.js';
-export const commandsDir = (storageRoot) => path.join(storageRoot, 'agent-commands');
-/** Marks files this tool wrote, so only those are ever replaced or removed. */
-const MARKER = 'windows-development-sandbox agent command';
-const EXTENSIONS = ['.exe', '.cmd', '.bat'];
-/** cmd.exe expands % and ^ even inside quotes: such paths cannot go into a forwarding file safely. */
-const cmdSafe = (p) => !/[%"^\r\n]/.test(p);
-/** The agent's own executable on this PC, skipping this tool's forwarding files. */
-export const realAgent = (command, skipDir, pathValue = process.env.PATH ?? process.env.Path ?? '') => {
-    const skip = path.resolve(skipDir).toLowerCase();
-    const dirs = pathValue.split(path.delimiter).filter((d) => d && path.resolve(d).toLowerCase() !== skip);
-    for (const dir of dirs)
-        for (const ext of EXTENSIONS) {
-            const candidate = path.join(dir, command + ext);
-            if (fileExists(candidate))
-                return candidate;
-        }
-    return null;
-};
-/** The agents that get a forwarding command: installed on this PC, and listed (or "auto" = all of them). */
-export const agentCommands = (config, storageRoot, pathValue) => {
-    const wanted = config.agentCommands.agents;
-    return Object.entries(config.harnesses).flatMap(([harness, h]) => {
-        if (wanted !== 'auto' && !wanted.includes(harness))
-            return [];
-        const command = h.npmBin ?? (h.hostExecutable ? path.parse(h.hostExecutable).name : harness);
-        const real = /^[A-Za-z0-9._-]+$/.test(command) ? realAgent(command, commandsDir(storageRoot), pathValue) : null;
-        return real && cmdSafe(real) ? [{ harness, command, real }] : [];
-    });
-};
-/** The .cmd file for one agent (cmd, PowerShell and Windows Terminal all run it). */
-export const forwardingCmd = (a, node, entry) => [
-    '@echo off',
-    'rem ' + MARKER + ' (Beta). Turn off: sandbox agent-commands off. Run the real one: set SANDBOX_AGENT_DIRECT=1',
-    'if "%SANDBOX_AGENT_DIRECT%"=="1" goto direct',
-    '"' + node + '" "' + entry + '" launch --harness ' + a.harness + ' --headless --terminal -- %*',
-    'exit /b %errorlevel%',
-    ':direct',
-    'call "' + a.real + '" %*',
-    '',
-].join('\r\n');
-/** The same for Git Bash, which looks for a file without an extension. */
-export const forwardingSh = (a, node, entry) => {
-    const posix = (p) => p.replace(/^([A-Za-z]):/, (_m, d) => '/' + d.toLowerCase()).replace(/\\/g, '/');
-    const q = (s) => "'" + s.replace(/'/g, "'\\''") + "'";
-    return [
-        '#!/bin/sh',
-        '# ' + MARKER + ' (Beta). Turn off: sandbox agent-commands off. Run the real one: SANDBOX_AGENT_DIRECT=1',
-        'if [ "$SANDBOX_AGENT_DIRECT" = "1" ]; then exec ' + q(posix(a.real)) + ' "$@"; fi',
-        'exec ' + q(posix(node)) + ' ' + q(posix(entry)) + ' launch --harness ' + a.harness + ' --headless --terminal -- "$@"',
-        '',
-    ].join('\n');
-};
-/** Runs a PowerShell script that edits YOUR PATH (HKCU\Environment) unexpanded, then tells Windows it changed. */
-const editUserPath = (dir, add) => {
-    refuseInSelfTest('change your PATH');
-    const quoted = "'" + dir.replace(/'/g, "''") + "'";
-    const script = [
-        '$dir = ' + quoted,
-        "$key = [Microsoft.Win32.Registry]::CurrentUser.CreateSubKey('Environment')",
-        'try {',
-        "  $raw = [string]$key.GetValue('Path', '', [Microsoft.Win32.RegistryValueOptions]::DoNotExpandEnvironmentNames)",
-        "  $rest = @($raw -split ';' | Where-Object { $_ -and $_.TrimEnd('\\') -ine $dir.TrimEnd('\\') })",
-        // First, so these commands win over the agents' own folders (also on YOUR PATH).
-        add ? '  $new = (@($dir) + $rest) -join \';\'' : "  $new = $rest -join ';'",
-        '  if ($new -eq $raw.TrimEnd(\';\')) { exit 0 }',
-        "  if ($new.Length -gt 32000) { Write-Error 'PATH too long'; exit 3 }",
-        "  $kind = if ($key.GetValueNames() -contains 'Path') { $key.GetValueKind('Path') } else { [Microsoft.Win32.RegistryValueKind]::ExpandString }",
-        "  $key.SetValue('Path', $new, $kind)",
-        '} finally { $key.Close() }',
-        "Add-Type -Namespace WdsAgents -Name Native -MemberDefinition '[System.Runtime.InteropServices.DllImport(\"user32.dll\", CharSet = System.Runtime.InteropServices.CharSet.Auto)] public static extern System.IntPtr SendMessageTimeout(System.IntPtr hWnd, uint msg, System.UIntPtr wParam, string lParam, uint flags, uint timeout, out System.UIntPtr result);'",
-        '$ignored = [UIntPtr]::Zero',
-        "[void][WdsAgents.Native]::SendMessageTimeout([IntPtr]0xffff, 0x1A, [UIntPtr]::Zero, 'Environment', 2, 5000, [ref]$ignored)",
-    ].join('\n');
-    const result = spawnSync(SYSTEM.powershell(), ['-NoProfile', '-NonInteractive', '-OutputFormat', 'Text', '-Command', script], { encoding: 'utf8', windowsHide: true });
-    if (result.status === 3)
-        throw new Error('Your PATH is too long to add ' + dir + '.');
-    if (result.status !== 0)
-        throw new Error('Could not ' + (add ? 'add ' + dir + ' to' : 'remove ' + dir + ' from') + ' your PATH: ' + (result.stderr || result.error?.message || 'exit ' + result.status).trim());
-};
-const ownFiles = (dir) => fs.existsSync(dir)
-    ? fs.readdirSync(dir).map((f) => path.join(dir, f)).filter((f) => { try {
-        return fs.lstatSync(f).isFile() && fs.readFileSync(f, 'utf8').includes(MARKER);
-    }
-    catch {
-        return false;
-    } })
-    : [];
-/**
- * Makes this PC match agentCommands: on = a forwarding file per installed agent and the folder first on your PATH;
- * off = no files, no PATH entry. Only touches files it wrote and its own PATH entry; does nothing when already right.
- */
-export const reconcileAgentCommands = (config, storageRoot, node, entry) => {
-    const dir = commandsDir(storageRoot);
-    if (!config.agentCommands.enabled) {
-        if (!fs.existsSync(dir))
-            return { on: false, commands: [], changed: false };
-        for (const f of ownFiles(dir))
-            fs.rmSync(f, { force: true });
-        editUserPath(dir, false);
-        if (fs.readdirSync(dir).length === 0)
-            safeRemove(dir, storageRoot);
-        return { on: false, commands: [], changed: true };
-    }
-    if (!cmdSafe(node) || !cmdSafe(entry))
-        throw new Error('This tool is installed in a folder whose path has % " or ^, which cannot go into a command file safely.');
-    const commands = agentCommands(config, storageRoot);
-    ensureDir(dir);
-    const wanted = new Map();
-    for (const a of commands) {
-        wanted.set(path.join(dir, a.command + '.cmd'), forwardingCmd(a, node, entry));
-        wanted.set(path.join(dir, a.command), forwardingSh(a, node, entry));
-    }
-    let changed = false;
-    for (const f of ownFiles(dir))
-        if (!wanted.has(f)) {
-            fs.rmSync(f, { force: true });
-            changed = true;
-        }
-    for (const [file, text] of wanted) {
-        const current = fileExists(file) ? fs.readFileSync(file, 'utf8') : null;
-        // A file of the same name that this tool did not write is never replaced.
-        if (current !== null && !current.includes(MARKER))
-            continue;
-        if (current !== text) {
-            writeFileAtomic(file, text);
-            changed = true;
-        }
-    }
-    const onPath = (process.env.PATH ?? '').split(path.delimiter).some((d) => path.resolve(d).toLowerCase() === path.resolve(dir).toLowerCase());
-    if (changed || !onPath)
-        editUserPath(dir, true);
-    return { on: true, commands, changed: changed || !onPath };
-};

package/dist/host/channel.d.ts

@@ -1,38 +0,0 @@
-import type { GuestRequest, GuestResponse, Harness, SandboxStatus, SessionStatus } from '../core/types.js';
-import type { ProjectSpecT } from '../shared/schema.js';
-/** Where progress lines go: printed by default; a spinner passes its own. Text from the sandbox, made safe first. */
-export type Progress = (line: string) => void;
-/** Waits until the sandbox finished provisioning, reporting each boot step. */
-export declare const waitForReady: (dataPath: string, launchId: string | null, isAlive: () => boolean, progress?: Progress) => Promise<SandboxStatus>;
-export declare const sendRequest: (dataPath: string, request: GuestRequest) => void;
-export declare const waitForResponse: (dataPath: string, requestId: string, isAlive: () => boolean, timeoutMs: number) => Promise<GuestResponse>;
-/** project: a project registered after boot (provisioned first). harnessSpec: the agent's definition, for an agent the sandbox did not boot with. */
-export declare const requestSession: (dataPath: string, harness: string, args: string[], cwd: string, extra?: {
-    project?: ProjectSpecT;
-    harnessSpec?: Harness;
-}) => string;
-/**
- * Provisions a registered project without starting an agent and waits for it, printing its progress (the guest's
- * run\projects\<name>.json) as it goes. Throws when it failed.
- */
-export declare const prepareProject: (dataPath: string, project: ProjectSpecT, isAlive: () => boolean, progress?: Progress) => Promise<GuestResponse>;
-export declare const waitForSession: (dataPath: string, sessionId: string, isAlive: () => boolean, timeoutMs?: number, progress?: Progress) => Promise<SessionStatus>;
-/** Runs a command inside the sandbox (in the workspace or a folder below it) and returns its output. */
-export declare const execInSandbox: (dataPath: string, command: string[], cwd: string, timeoutSeconds: number, isAlive: () => boolean) => Promise<GuestResponse>;
-/** Restarts running sessions in place (they resume via the harness's resumeArguments, e.g. claude --continue). */
-export declare const restartSessions: (dataPath: string, harness: string | null, isAlive: () => boolean, cwd?: string) => Promise<GuestResponse>;
-export declare const pingSandbox: (dataPath: string, isAlive: () => boolean) => Promise<GuestResponse>;
-export declare const runningSessions: (dataPath: string) => SessionStatus[];
-/** Most sessions the host will ever contact for one listing: a sandbox can write as many session files as it likes. */
-export declare const MAX_QUERIED_SESSIONS = 32;
-/** Running sessions of the sandbox that is running now (its launch id), newest last, capped. */
-export declare const currentSessions: (dataPath: string) => SessionStatus[];
-/** Sessions in this guest folder or below (one project's) first, each group newest first. */
-export declare const sessionsFirstIn: (sessions: SessionStatus[], guestDir: string | null) => SessionStatus[];
-/**
- * The session with this id (or id prefix), else the most recently started running one: in `guestDir` (the project
- * you are in) when it has one, else any.
- */
-export declare const pickSession: (dataPath: string, sessionId?: string, guestDir?: string | null) => SessionStatus;
-/** Forgets status from a previous sandbox run so nothing stale is picked up. */
-export declare const resetRunDir: (dataPath: string) => void;