windows-development-sandbox 1.4.1 → 1.4.3

package/dist/guest/gitrules.js

@@ -1,11 +0,0 @@
-const SHELLS = ['Bash', 'PowerShell'];
-const WRITE_COMMANDS = ['commit', 'push', 'add', 'rm', 'mv', 'merge', 'rebase', 'reset', 'checkout', 'switch', 'restore', 'stash', 'tag', 'cherry-pick', 'revert', 'am', 'apply', 'clean', 'pull', 'fetch', 'clone', 'init', 'gc', 'prune', 'update-ref', 'update-index', 'filter-branch', 'replace', 'worktree add', 'branch -d', 'branch -D', 'branch -m', 'branch -M', 'config --add', 'config --unset', 'remote add', 'remote remove', 'remote set-url'];
-const GIT_DIR_PATHS = ['**/.git', '**/.git/**'];
-export const gitDenyRules = (access) => {
-    if (access === 'full')
-        return [];
-    const commands = access === 'none' ? ['git'] : WRITE_COMMANDS.map((c) => 'git ' + c);
-    const shellRules = SHELLS.flatMap((shell) => commands.map((c) => shell + '(' + c + ':*)'));
-    const fileRules = GIT_DIR_PATHS.flatMap((p) => (access === 'none' ? ['Read(' + p + ')', 'Edit(' + p + ')'] : ['Edit(' + p + ')']));
-    return [...shellRules, ...fileRules];
-};

package/dist/guest/project-status.d.ts

@@ -1,5 +0,0 @@
-import type { DatabasePlan } from '../core/types.js';
-import type { ProjectStatusT } from '../shared/schema.js';
-/** The launch folder's project id (older launch folders: derived from its name). */
-export declare const primaryProject: () => string;
-export declare const saveProjectStatus: (name: string, workspace: string, phase: ProjectStatusT["phase"], message: string, databases: DatabasePlan[], summary: string[]) => void;

package/dist/guest/project-status.js

@@ -1,17 +0,0 @@
-import { now, writeJsonAtomic } from '../shared/rundir.js';
-import { hubName } from '../shared/projects.js';
-import { errMsg, run, session, warn } from './env.js';
-/** The launch folder's project id (older launch folders: derived from its name). */
-export const primaryProject = () => session.projectId ?? hubName(session.workspaceHost || session.project, []);
-export const saveProjectStatus = (name, workspace, phase, message, databases, summary) => {
-    try {
-        writeJsonAtomic(run.project(name), {
-            name, workspace, phase, message: message.slice(0, 3500), updatedAt: now(),
-            databases: databases.filter((d) => d.database !== 'sqlserver').slice(0, 16).map((d) => ({ database: d.database, port: d.port })),
-            summary: summary.slice(0, 64).map((s) => s.slice(0, 500)),
-        });
-    }
-    catch (e) {
-        warn('Could not write the status of project ' + name + ': ' + errMsg(e));
-    }
-};

package/dist/guest/setup/user.js

@@ -1,51 +0,0 @@
-// Making the sandbox feel like your PC: desktop look and Git identity.
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { SYSTEM } from '../../shared/system.js';
-import { dryRun, exec, exists, isWin, launchDir, log, mkdirp, powershell, session, toolsDir } from '../env.js';
-const psQuote = (s) => "'" + s.replace(/'/g, "''") + "'";
-/** Imports the host's look (registry values + wallpaper) and restarts Explorer so it applies. */
-export const applyPersonalization = () => {
-    const dir = path.join(launchDir, 'personalize');
-    if (!session.personalization || !exists(dir) || dryRun || !isWin)
-        return;
-    exec(SYSTEM.reg(), ['import', path.join(dir, 'personalize.reg')], { stdio: 'ignore' });
-    const wallpaper = fs.readdirSync(dir).find((f) => f.startsWith('wallpaper'));
-    const local = wallpaper ? path.join(mkdirp(path.join(os.homedir(), 'Pictures')), wallpaper) : null;
-    if (wallpaper && local)
-        fs.copyFileSync(path.join(dir, wallpaper), local);
-    powershell([
-        local ? "Set-ItemProperty -Path 'HKCU:\\Control Panel\\Desktop' -Name WallPaper -Value " + psQuote(local) : '',
-        "Add-Type -Namespace AgentSandbox -Name Desk -MemberDefinition '[System.Runtime.InteropServices.DllImport(\"user32.dll\", CharSet = System.Runtime.InteropServices.CharSet.Unicode)] public static extern int SystemParametersInfo(int a, int b, string c, int d);'",
-        local ? '[void][AgentSandbox.Desk]::SystemParametersInfo(20, 0, ' + psQuote(local) + ', 3)' : '',
-        // Explorer restarts by itself and picks up taskbar/theme changes.
-        'Stop-Process -Name explorer -Force -ErrorAction SilentlyContinue',
-    ].filter(Boolean).join('\n'));
-    log('Desktop personalisation applied from this PC.');
-};
-/**
- * Your Git identity from this PC (name/email only), plus safe.directory for the mapped workspace (its owner SID
- * differs in the sandbox). Uses the real git.exe directly: the read-only guard would rightly refuse `config --add`.
- */
-export const setupGitConfig = (env) => {
-    // A dry run (the self-test) must not touch the real ~/.gitconfig: it once replaced the sandbox's own, safe.directory
-    // included, so git refused the workspace until the next boot.
-    if (dryRun)
-        return;
-    const source = path.join(launchDir, 'home', '.gitconfig');
-    if (exists(source))
-        fs.copyFileSync(source, path.join(os.homedir(), '.gitconfig'));
-    const git = path.join(toolsDir, 'git', 'cmd', 'git.exe');
-    if (!exists(git))
-        return;
-    const { GIT_DIR: _gitDir, ...rest } = env;
-    spawnSync(git, ['config', '--global', '--add', 'safe.directory', '*'], { env: rest, windowsHide: true, stdio: 'ignore' });
-    // Windows long paths are on in the sandbox, but git skips files over 260 characters unless told.
-    spawnSync(git, ['config', '--global', 'core.longpaths', 'true'], { env: rest, windowsHide: true, stdio: 'ignore' });
-    // Git for Windows' system config says autocrlf=true: checkouts made in the sandbox (worktrees, clones) got CRLF and
-    // tools that want LF (rustfmt, shellcheck, prettier) failed on every file. "input" keeps the line endings the repo
-    // has, and a checkout from your PC (CRLF in the folder) still shows as unchanged.
-    spawnSync(git, ['config', '--global', 'core.autocrlf', 'input'], { env: rest, windowsHide: true, stdio: 'ignore' });
-};

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

@@ -1,10 +0,0 @@
-import type { GitAccess } from '../../core/types.js';
-import { type CliSettings } from './catalogue.js';
-import { type ToolEnv } from './common.js';
-/** gh keeps `gh auth login` here, under the agent state (persists like Claude's own login; never copied from the PC). */
-export declare const ghConfigDir: () => string;
-/**
- * Installs the tools toolchains.cli asks for. Settings still "auto" here (normally the host decides) use the same
- * rules on the workspace as the host would. The gh rule is enforced here again, whatever the host sent.
- */
-export declare const setupCli: (env: ToolEnv, settings: CliSettings, gitAccess: GitAccess, refresh?: boolean) => Promise<void>;

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

@@ -1,54 +0,0 @@
-import { type ReleaseAsset } from '../../shared/download.js';
-/** What the toolchains contribute to the agent's environment. */
-export interface ToolEnv {
-    vars: Record<string, string>;
-    prepend: string[];
-    append: string[];
-    summary: string[];
-}
-export declare const emptyEnv: () => ToolEnv;
-export declare const arch: string;
-export declare const tool: (...parts: string[]) => string;
-/** First x.y.z in a tool's `--version` output. */
-export declare const versionOf: (exe: string, args?: string[], options?: {}) => string;
-/**
- * Resolves a version online and remembers it for a day (provisioning.refresh looks again), so most boots make no
- * lookups and an offline boot reuses what was installed last time. After a network failure the remaining lookups go
- * straight to the remembered versions instead of each waiting for the network; other errors (no such version) do not.
- */
-export declare const resolveCached: (key: string, resolve: () => Promise<string>) => Promise<string>;
-/** A single file download that lands as `file` only when complete (and checksum-verified): a cut-off one never looks finished. */
-export declare const downloadFile: (url: string, file: string, sha256?: string | null) => Promise<void>;
-interface GithubInstall {
-    /** The folder the archive is unpacked into (replaced atomically). */
-    dest: string;
-    /** What the progress line says is being downloaded, with its size; a function gets the release asset. */
-    what: string | ((asset: ReleaseAsset) => string);
-    /** Look past the latest release for a matching asset. */
-    searchOlder?: boolean;
-    /** installArchive's `locate` / `up`: keep only the folder holding this file. */
-    locate?: string;
-    up?: number;
-}
-/** The newest GitHub release asset matching `pattern`, checksum-verified, unpacked into `dest`. */
-export declare const installFromGithub: (repo: string, pattern: RegExp, o: GithubInstall) => Promise<void>;
-/** Runs one installer; a failure is reported and skipped so it never blocks the other toolchains. */
-export declare const step: (name: string, env: ToolEnv, work: () => Promise<void>) => Promise<void>;
-/** File names in the project's folder and its direct sub-folders ("api/go.mod"); read once per project. */
-export declare const workspaceEntries: () => string[];
-/**
- * true / false as configured. The host already turns "auto" into a decision at launch (core/detect-toolchains.ts);
- * this only applies when a session file still says "auto": the workspace has one of the marker files.
- */
-export declare const wanted: (setting: boolean | "auto", toolchain: string) => boolean;
-/** The first of these version files in the workspace root, parsed (e.g. .ruby-version "3.3.1"). */
-export declare const versionFromFiles: (files: string[], parse?: (text: string, name: string) => string | null) => {
-    spec: string;
-    source: string;
-} | null;
-/**
- * Installs each package that is not installed yet (remembered in tools\installed-packages.json under `group`, e.g.
- * "npm@22.11.0"). One failing package is reported and skipped; it is tried again next boot.
- */
-export declare const installOnce: (env: ToolEnv, group: string, packages: string[], install: (pkg: string) => void | Promise<void>) => Promise<void>;
-export {};

package/dist/guest/toolchains/common.js

@@ -1,147 +0,0 @@
-// Shared plumbing for the toolchain installers. Everything lives in C:\AgentData\tools (persistent), so only the first
-// boot downloads; later boots only put things on PATH.
-import fs from 'node:fs';
-import path from 'node:path';
-import { z } from 'zod';
-import { download, githubAsset, installArchive } from '../../shared/download.js';
-import { writeJsonAtomic } from '../../shared/rundir.js';
-import { errMsg, execOutput, exists, log, session, toolsDir, warn } from '../env.js';
-import { projectWorkspace } from '../project-context.js';
-import { MARKERS } from '../../core/detect-toolchains.js';
-import { projectUses, specFromVersionFile } from './versions.js';
-export const emptyEnv = () => ({ vars: {}, prepend: [], append: [], summary: [] });
-export const arch = process.arch === 'arm64' ? 'arm64' : 'x64';
-export const tool = (...parts) => path.join(toolsDir, ...parts);
-/** First x.y.z in a tool's `--version` output. */
-export const versionOf = (exe, args = ['--version'], options = {}) => /\d+\.\d+\.\d+\S*/.exec(execOutput(exe, args, options))?.[0] ?? 'installed';
-/** Small JSON state files in tools\: read with zod (a half-written file is just empty), written atomically. */
-const readState = (file, schema, empty) => {
-    try {
-        return schema.safeParse(JSON.parse(fs.readFileSync(file, 'utf8').replace(/^/, ''))).data ?? empty;
-    }
-    catch {
-        return empty;
-    }
-};
-/** A remembered lookup; plain strings are what older versions wrote (treated as stale, still usable offline). */
-const Resolved = z.record(z.string(), z.union([z.string(), z.strictObject({ value: z.string(), at: z.number() })]));
-const resolvedFile = () => tool('resolved-versions.json');
-const remembered = () => Object.fromEntries(Object.entries(readState(resolvedFile(), Resolved, {})).map(([k, v]) => [k, typeof v === 'string' ? { value: v, at: 0 } : v]));
-/** How long a looked-up version is trusted: boots within a day make no version lookups at all. */
-const FRESH_MS = 24 * 60 * 60 * 1000;
-let offline = false;
-const networkError = (e) => /fetch failed|timed? ?out|aborted|ENOTFOUND|EAI_AGAIN|ECONN|ENETUNREACH|EHOSTUNREACH|HTTP 5\d\d|socket/i.test(errMsg(e) + ' ' + String(e?.cause ?? ''));
-/**
- * Resolves a version online and remembers it for a day (provisioning.refresh looks again), so most boots make no
- * lookups and an offline boot reuses what was installed last time. After a network failure the remaining lookups go
- * straight to the remembered versions instead of each waiting for the network; other errors (no such version) do not.
- */
-export const resolveCached = async (key, resolve) => {
-    const cached = remembered()[key];
-    if (cached && (offline || (!session.provisioning.refresh && Date.now() - cached.at < FRESH_MS)))
-        return cached.value;
-    try {
-        const value = await resolve();
-        fs.mkdirSync(toolsDir, { recursive: true });
-        writeJsonAtomic(resolvedFile(), { ...remembered(), [key]: { value, at: Date.now() } });
-        return value;
-    }
-    catch (e) {
-        if (networkError(e))
-            offline = true;
-        if (!cached)
-            throw e;
-        warn('Could not look up the latest ' + key + ' online (' + errMsg(e) + '); using ' + cached.value + ' from an earlier start.');
-        return cached.value;
-    }
-};
-/** A single file download that lands as `file` only when complete (and checksum-verified): a cut-off one never looks finished. */
-export const downloadFile = async (url, file, sha256 = null) => {
-    const part = file + '.part';
-    try {
-        await download(url, part, sha256);
-        fs.rmSync(file, { force: true });
-        fs.renameSync(part, file);
-    }
-    finally {
-        fs.rmSync(part, { force: true });
-    }
-};
-/** The newest GitHub release asset matching `pattern`, checksum-verified, unpacked into `dest`. */
-export const installFromGithub = async (repo, pattern, o) => {
-    const asset = await githubAsset(repo, pattern, o.searchOlder);
-    log('Downloading ' + (typeof o.what === 'string' ? o.what : o.what(asset)) + ' ...');
-    await installArchive(asset.url, o.dest, { sha256: asset.sha256, fileName: asset.name, ...(o.locate ? { locate: o.locate } : {}), ...(o.up ? { up: o.up } : {}) });
-};
-/** Runs one installer; a failure is reported and skipped so it never blocks the other toolchains. */
-export const step = async (name, env, work) => {
-    try {
-        await work();
-    }
-    catch (e) {
-        warn(name + ' could not be set up and is skipped; everything else still works, and the next start tries again. Reason: ' + errMsg(e));
-        env.summary.push(name + ': FAILED');
-    }
-};
-// ---- which toolchains a project needs ------------------------------------------------------------------------------
-const SKIP_DIRS = new Set(['node_modules', '.git', 'target', 'bin', 'obj', 'dist', 'build', 'vendor', '.venv', 'venv']);
-const entries = new Map();
-/** File names in the project's folder and its direct sub-folders ("api/go.mod"); read once per project. */
-export const workspaceEntries = () => {
-    const workspace = projectWorkspace();
-    const known = entries.get(workspace.toLowerCase());
-    if (known)
-        return known;
-    const list = (dir) => { try {
-        return fs.readdirSync(dir, { withFileTypes: true });
-    }
-    catch {
-        return [];
-    } };
-    const top = list(workspace);
-    const below = top.filter((d) => d.isDirectory() && !d.name.startsWith('.') && !SKIP_DIRS.has(d.name.toLowerCase()))
-        .flatMap((d) => list(path.join(workspace, d.name)).filter((f) => f.isFile()).map((f) => d.name + '/' + f.name));
-    const found = [...top.filter((d) => d.isFile()).map((d) => d.name), ...below];
-    entries.set(workspace.toLowerCase(), found);
-    return found;
-};
-/**
- * true / false as configured. The host already turns "auto" into a decision at launch (core/detect-toolchains.ts);
- * this only applies when a session file still says "auto": the workspace has one of the marker files.
- */
-export const wanted = (setting, toolchain) => setting === 'auto' ? projectUses(workspaceEntries(), MARKERS[toolchain] ?? []) : setting;
-/** The first of these version files in the workspace root, parsed (e.g. .ruby-version "3.3.1"). */
-export const versionFromFiles = (files, parse = (t) => specFromVersionFile(t)) => {
-    for (const name of files) {
-        const file = path.join(projectWorkspace(), name);
-        if (!exists(file))
-            continue;
-        const spec = parse(fs.readFileSync(file, 'utf8'), name);
-        if (spec)
-            return { spec, source: name };
-    }
-    return null;
-};
-// ---- global packages, installed once -------------------------------------------------------------------------------
-const installedFile = () => tool('installed-packages.json');
-const installed = () => readState(installedFile(), z.record(z.string(), z.string()), {});
-/**
- * Installs each package that is not installed yet (remembered in tools\installed-packages.json under `group`, e.g.
- * "npm@22.11.0"). One failing package is reported and skipped; it is tried again next boot.
- */
-export const installOnce = async (env, group, packages, install) => {
-    const todo = packages.filter((p) => !installed()[group + ':' + p]);
-    for (const pkg of todo) {
-        try {
-            log('Installing ' + pkg + ' (' + group + ') ...');
-            await install(pkg);
-            writeJsonAtomic(installedFile(), { ...installed(), [group + ':' + pkg]: new Date().toISOString() });
-        }
-        catch (e) {
-            warn(pkg + ' (' + group + ') could not be installed and is skipped; the next start tries again. Reason: ' + errMsg(e));
-        }
-    }
-    const ok = packages.filter((p) => installed()[group + ':' + p]);
-    if (ok.length)
-        env.summary.push(group.split('@')[0] + ' packages: ' + ok.join(', '));
-};

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

@@ -1,8 +0,0 @@
-import type { DatabasePlan } from '../../../core/types.js';
-import { type ToolEnv } from '../common.js';
-/**
- * Amazon's DynamoDB Local (a Java program; the Java toolchain step runs first, else this installs the LTS JDK) and
- * dynamodb-admin, the web UI to browse and edit tables, installed with the runner's own npm. Every AWS SDK picks the
- * local endpoint up from AWS_ENDPOINT_URL_DYNAMODB, with dummy credentials (real ones never reach the sandbox).
- */
-export declare const setupDynamo: (env: ToolEnv, plan: DatabasePlan) => Promise<void>;

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

@@ -1,52 +0,0 @@
-// DynamoDB Local + dynamodb-admin.
-import fs from 'node:fs';
-import path from 'node:path';
-import { spawn } from 'node:child_process';
-import { fetchText, installArchive } from '../../../shared/download.js';
-import { execAsync, exists, log, logsDir, mkdirp } from '../../env.js';
-import { ensureJdk } from '../java.js';
-import { tool } from '../common.js';
-import { portOpen, waitForPort } from '../../ports.js';
-import { dataFor, startServer } from './server.js';
-const DYNAMO_ZIP = 'https://d1ni2b6xgvw0s0.cloudfront.net/v2.x/dynamodb_local_latest.zip';
-/**
- * Amazon's DynamoDB Local (a Java program; the Java toolchain step runs first, else this installs the LTS JDK) and
- * dynamodb-admin, the web UI to browse and edit tables, installed with the runner's own npm. Every AWS SDK picks the
- * local endpoint up from AWS_ENDPOINT_URL_DYNAMODB, with dummy credentials (real ones never reach the sandbox).
- */
-export const setupDynamo = async (env, plan) => {
-    const java = path.join(await ensureJdk(), 'bin', 'java.exe');
-    const home = tool('dynamodb-local');
-    if (!exists(path.join(home, 'DynamoDBLocal.jar'))) {
-        log('Downloading DynamoDB Local (~60 MB once) ...');
-        const sha256 = (await fetchText(DYNAMO_ZIP + '.sha256')).trim().split(/\s+/)[0];
-        await installArchive(DYNAMO_ZIP, home, { sha256, locate: 'DynamoDBLocal.jar', fileName: 'dynamodb_local.zip' });
-    }
-    const data = mkdirp(dataFor('dynamodb'));
-    // -sharedDb: one database whatever region/credentials a client uses, so the admin UI and the app see the same tables.
-    await startServer('dynamodb', java, ['-Djava.library.path=' + path.join(home, 'DynamoDBLocal_lib'), '-jar', path.join(home, 'DynamoDBLocal.jar'), '-sharedDb', '-dbPath', data, '-port', String(plan.port)], plan.port);
-    const endpoint = 'http://localhost:' + plan.port;
-    const aws = { AWS_ENDPOINT_URL_DYNAMODB: endpoint, DYNAMO_ENDPOINT: endpoint, AWS_ACCESS_KEY_ID: 'local', AWS_SECRET_ACCESS_KEY: 'local', AWS_REGION: 'us-east-1', AWS_DEFAULT_REGION: 'us-east-1' };
-    Object.assign(env.vars, aws);
-    env.summary.push('dynamodb (DynamoDB Local): ' + endpoint + ' (AWS SDKs use it automatically via AWS_ENDPOINT_URL_DYNAMODB; dummy credentials)');
-    if (!plan.adminPort)
-        return;
-    const prefix = tool('dynamodb-admin');
-    const script = path.join(prefix, 'node_modules', 'dynamodb-admin', 'dist', 'dynamodb-admin.js');
-    if (!exists(script)) {
-        log('Installing dynamodb-admin, the DynamoDB web UI (~20 MB once) ...');
-        const npmCli = path.join(path.dirname(process.execPath), 'node_modules', 'npm', 'bin', 'npm-cli.js');
-        await execAsync(process.execPath, [npmCli, 'install', '--global', '--prefix', prefix, 'dynamodb-admin', '--no-fund', '--no-audit'], { stdio: 'ignore' });
-    }
-    // The database matters more than its UI: a taken port is reported, not fatal.
-    if (await portOpen(plan.adminPort)) {
-        env.summary.push('dynamodb-admin: NOT started, port ' + plan.adminPort + ' is in use (change databases.dynamodb.adminPort)');
-        return;
-    }
-    const out = fs.openSync(path.join(logsDir, 'dynamodb-admin.log'), 'a');
-    spawn(process.execPath, [script, '--port', String(plan.adminPort), '--dynamo-endpoint', endpoint, '--skip-default-credentials'], { detached: true, stdio: ['ignore', out, out], windowsHide: true, env: { ...process.env, ...aws } }).unref();
-    fs.closeSync(out);
-    if (!(await waitForPort(plan.adminPort, 30)))
-        throw new Error('dynamodb-admin did not start; see ' + path.join(logsDir, 'dynamodb-admin.log'));
-    env.summary.push('dynamodb-admin: http://localhost:' + plan.adminPort + ' (browse and edit tables in the sandbox\'s browser)');
-};

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

@@ -1,6 +0,0 @@
-import type { DatabasePlan } from '../../../core/types.js';
-import { type ToolEnv } from '../common.js';
-export declare const DATABASE_NAMES: Record<DatabasePlan['database'], string>;
-/** Stops a database (and DynamoDB's admin UI). PostgreSQL shuts down cleanly through pg_ctl; the others are ended. */
-export declare const stopDatabase: (plan: DatabasePlan) => Promise<boolean>;
-export declare const setupDatabase: (env: ToolEnv, plan: DatabasePlan) => Promise<void>;

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

@@ -1,62 +0,0 @@
-// Databases inside the sandbox: PostgreSQL, MariaDB (MySQL-compatible), MongoDB, Redis and DynamoDB Local. Binaries
-// live in C:\AgentData\tools, data in C:\AgentData\databases (both persist), and every server listens on localhost only.
-// Which ones run was decided on the host (session.databases): only what the project needs.
-import fs from 'node:fs';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { SYSTEM } from '../../../shared/system.js';
-import { dryRun, execAsync, exists, log } from '../../env.js';
-import { tool } from '../common.js';
-import { setupDynamo } from './dynamodb.js';
-import { setupMongo } from './mongodb.js';
-import { setupMysql } from './mysql.js';
-import { postgresData, setupPostgres } from './postgres.js';
-import { setupRedis } from './redis.js';
-import { portOpen } from '../../ports.js';
-import { duringSession } from '../../project-context.js';
-const SETUP = { postgres: setupPostgres, mysql: setupMysql, mongodb: setupMongo, redis: setupRedis, dynamodb: setupDynamo };
-export const DATABASE_NAMES = { postgres: 'PostgreSQL', mysql: 'MySQL (MariaDB)', mongodb: 'MongoDB', redis: 'Redis', dynamodb: 'DynamoDB Local', sqlserver: 'SQL Server' };
-/** The process listening on a local TCP port (netstat: no PowerShell start-up cost), or null. */
-const listenerPid = (port) => {
-    const out = spawnSync(SYSTEM.netstat(), ['-ano', '-p', 'TCP'], { encoding: 'utf8', windowsHide: true }).stdout ?? '';
-    const hit = out.split(/\r?\n/).map((l) => /^\s*TCP\s+\S+:(\d+)\s+\S+\s+LISTENING\s+(\d+)/.exec(l)).find((m) => m && Number(m[1]) === port);
-    return hit ? Number(hit[2]) : null;
-};
-/** Stops a database (and DynamoDB's admin UI). PostgreSQL shuts down cleanly through pg_ctl; the others are ended. */
-export const stopDatabase = async (plan) => {
-    if (!(await portOpen(plan.port)))
-        return false;
-    if (plan.database === 'postgres' && exists(tool('postgres'))) {
-        for (const version of fs.readdirSync(tool('postgres'))) {
-            const data = postgresData(version);
-            const pgCtl = path.join(tool('postgres', version), 'bin', 'pg_ctl.exe');
-            if (exists(path.join(data, 'postmaster.pid')) && exists(pgCtl))
-                await execAsync(pgCtl, ['stop', '-D', data, '-m', 'fast', '-w'], { stdio: 'ignore' });
-        }
-    }
-    for (const port of [plan.port, plan.adminPort ?? 0]) {
-        const pid = port && listenerPid(port);
-        if (pid)
-            try {
-                process.kill(pid);
-            }
-            catch { /* already gone */ }
-    }
-    return true;
-};
-export const setupDatabase = async (env, plan) => {
-    if (plan.database === 'sqlserver') {
-        env.summary.push('sqlserver: NOT available (SQL Server cannot start inside Windows Sandbox). Switch the project to Postgres or SQLite for local work');
-        return;
-    }
-    if (dryRun) {
-        log('(dry run) would run ' + DATABASE_NAMES[plan.database] + ' on port ' + plan.port + ' (' + plan.reasons.join('; ') + ')');
-        return;
-    }
-    // A project that joined later, while another project's server already listens there: they share it.
-    if (duringSession() && (await portOpen(plan.port))) {
-        env.summary.push(plan.database + ': shared, already running on port ' + plan.port);
-        return;
-    }
-    await SETUP[plan.database](env, plan);
-};

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

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

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

@@ -1,31 +0,0 @@
-// MongoDB Community, with mongosh.
-import path from 'node:path';
-import { fetchJson, installArchive } from '../../../shared/download.js';
-import { exists, log, mkdirp } from '../../env.js';
-import { installFromGithub, resolveCached, tool } from '../common.js';
-import { clearStaleLocks, dataFor, startServer } from './server.js';
-export const setupMongo = async (env, plan) => {
-    const find = async () => {
-        const { versions } = await fetchJson('https://downloads.mongodb.org/full.json');
-        const prod = versions.filter((v) => v.production_release);
-        const hit = plan.version === 'latest' ? prod[0] : prod.find((v) => v.version === plan.version || v.version.startsWith(plan.version + '.'));
-        const archive = hit?.downloads.find((d) => d.target === 'windows' && d.arch === 'x86_64' && d.edition === 'base')?.archive;
-        return hit && archive ? { version: hit.version, archive } : Promise.reject(new Error('No MongoDB ' + plan.version + ' for Windows'));
-    };
-    const version = await resolveCached('mongodb:' + plan.version, async () => (await find()).version);
-    const home = tool('mongodb', version);
-    if (!exists(path.join(home, 'bin', 'mongod.exe'))) {
-        const { archive } = await find();
-        log('Downloading MongoDB ' + version + ' (~400 MB once) ...');
-        await installArchive(archive.url, home, { sha256: archive.sha256, locate: 'mongod.exe', up: 1 });
-    }
-    const shell = tool('mongosh');
-    if (!exists(path.join(shell, 'mongosh.exe'))) {
-        await installFromGithub('mongodb-js/mongosh', /^mongosh-[\d.]+-win32-x64\.zip$/, { dest: shell, what: 'mongosh, the MongoDB shell (~50 MB once)', locate: 'mongosh.exe' });
-    }
-    const data = mkdirp(dataFor('mongodb'));
-    await clearStaleLocks(data, ['mongod.lock'], plan.port);
-    await startServer('mongodb', path.join(home, 'bin', 'mongod.exe'), ['--dbpath', data, '--bind_ip', '127.0.0.1', '--port', String(plan.port)], plan.port);
-    env.prepend.push(path.join(home, 'bin'), shell);
-    env.summary.push('mongodb ' + version + ': mongodb://127.0.0.1:' + plan.port + ' (mongosh on PATH)');
-};

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

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

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

@@ -1,38 +0,0 @@
-// MariaDB, the MySQL-compatible server.
-import path from 'node:path';
-import { fetchJson, installArchive } from '../../../shared/download.js';
-import { execAsync, exists, log } from '../../env.js';
-import { resolveCached, tool } from '../common.js';
-import { createOnce, dataFor, startServer } from './server.js';
-const MARIA = 'https://downloads.mariadb.org/rest-api/mariadb/';
-export const setupMysql = async (env, plan) => {
-    const series = await resolveCached('mariadb:' + plan.version, async () => {
-        if (plan.version !== 'lts')
-            return plan.version;
-        const { major_releases: all } = await fetchJson(MARIA);
-        return all.find((r) => r.release_status === 'Stable' && r.release_support_type === 'Long Term Support')?.release_id ?? Promise.reject(new Error('No MariaDB LTS release found'));
-    });
-    const latest = async () => {
-        const { releases } = await fetchJson(MARIA + series + '/latest/');
-        const [version, release] = Object.entries(releases)[0] ?? [];
-        const zip = release?.files.find((f) => /-winx64\.zip$/.test(f.file_name));
-        return zip ? { version, zip } : Promise.reject(new Error('No MariaDB ' + series + ' zip for Windows'));
-    };
-    const version = await resolveCached('mariadb-version:' + series, async () => (await latest()).version);
-    const home = tool('mariadb', version);
-    const bin = path.join(home, 'bin');
-    if (!exists(path.join(bin, 'mariadbd.exe'))) {
-        const { zip } = await latest();
-        log('Downloading MariaDB ' + version + ' (~90 MB once) ...');
-        await installArchive(zip.file_download_url.replace(/^http:/, 'https:'), home, { sha256: zip.checksum?.sha256sum ?? null, locate: 'mariadbd.exe', up: 1, fileName: zip.file_name });
-    }
-    const data = dataFor('mariadb');
-    await createOnce(data, 'mysql', async () => {
-        log('Creating the MariaDB database (first start) ...');
-        await execAsync(path.join(bin, 'mariadb-install-db.exe'), ['--datadir=' + data, '--port=' + plan.port], { stdio: 'ignore' });
-    });
-    await startServer('mysql', path.join(bin, 'mariadbd.exe'), ['--datadir=' + data, '--port=' + plan.port, '--bind-address=127.0.0.1', '--console'], plan.port);
-    Object.assign(env.vars, { MYSQL_HOST: '127.0.0.1', MYSQL_TCP_PORT: String(plan.port) });
-    env.prepend.push(bin);
-    env.summary.push('mysql (MariaDB ' + version + '): 127.0.0.1:' + plan.port + ', user root, no password (mysql://root@127.0.0.1:' + plan.port + ')');
-};

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

@@ -1,5 +0,0 @@
-import type { DatabasePlan } from '../../../core/types.js';
-import { type ToolEnv } from '../common.js';
-/** The data folder of a PostgreSQL major version (one cluster per major). */
-export declare const postgresData: (version: string) => string;
-export declare const setupPostgres: (env: ToolEnv, plan: DatabasePlan) => Promise<void>;

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>;