windows-development-sandbox 1.4.1 → 1.4.3

package/dist/guest/daemon/relays.js

@@ -2,8 +2,10 @@
 // sandbox's own subnet, i.e. the PC: see the firewall rule in setup/network.ts) and passing each connection on to
 // localhost:<sandbox port>. So a dev server that only listens on localhost is reachable from the PC too.
 import net from 'node:net';
-import { relayPort } from '../../shared/netpolicy.js';
-import { errMsg, log, session, warn } from '../env.js';
+import { relayPort } from '../../shared/network/policy.js';
+import { log, warn } from '../runtime/log.js';
+import { session } from '../runtime/session.js';
+import { errMsg } from '../../core/util/errors.js';
 export const startRelays = () => {
     (session.network.forwardPorts ?? []).forEach((f, i) => {
         const server = net.createServer((client) => {
@@ -13,6 +15,6 @@ export const startRelays = () => {
             client.on('error', () => target.destroy());
         });
         server.on('error', (e) => warn('Port forward ' + f.pc + ' -> ' + f.sandbox + ' could not start: ' + errMsg(e)));
-        server.listen(relayPort(i), '0.0.0.0', () => log('Port forward: the PC\'s localhost:' + f.pc + ' reaches localhost:' + f.sandbox + ' here.'));
+        server.listen(relayPort(i), '0.0.0.0', () => log("Port forward: the PC's localhost:" + f.pc + ' reaches localhost:' + f.sandbox + ' here.'));
     });
 };

package/dist/guest/daemon/{session.js → sessions.js}

@@ -3,21 +3,25 @@
 import path from 'node:path';
 import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
-import { FrameType, sendControl } from '../../shared/pty-client.js';
-import { isWithin } from '../../shared/projects.js';
-import { now } from '../../shared/rundir.js';
+import { FrameType, sendControl } from '../../shared/pty/index.js';
+import { isWithin } from '../../shared/paths/projects.js';
+import { now } from '../../shared/channel/run-dir.js';
 import { SYSTEM } from '../../shared/system.js';
-import { commandLine } from '../cmdline.js';
-import { freePort } from '../ports.js';
-import { primaryProject } from '../project-status.js';
-import { ensurePtyHost, ptyHostLogTail, startPtyHost, waitForPtyHost } from '../ptyhost.js';
-import { provisionHarness, resolveLaunch } from '../setup/agents.js';
-import { saveClaudeMem } from '../setup/claude.js';
+import { commandLine } from '../sessions/cmdline.js';
+import { freePort } from '../runtime/ports.js';
+import { primaryProject } from '../boot/project-status.js';
+import { ensurePtyHost, ptyHostLogTail, startPtyHost, waitForPtyHost } from '../sessions/pty-host.js';
+import { provisionHarness, resolveLaunch } from '../agents/agent-installer.js';
+import { saveClaudeMem } from '../setup/claude-mem.js';
 import { projectHooks, runHooks, runHooksAsync } from '../setup/hooks.js';
-import { guestAddresses } from '../setup/network.js';
-import { dataDir, errMsg, exists, log, session, toolsDir, warn, workspace } from '../env.js';
-import { provisionProject } from './project.js';
-import { maybeShutdown } from './shutdown.js';
+import { guestAddresses } from '../network/addresses.js';
+import { dataDir, toolsDir } from '../runtime/paths.js';
+import { exists } from '../runtime/fs.js';
+import { log, warn } from '../runtime/log.js';
+import { session, workspace } from '../runtime/session.js';
+import { errMsg } from '../../core/util/errors.js';
+import { provisionProject } from './project-provisioner.js';
+import { maybeShutdown } from './idle-shutdown.js';
 import { insidePrimary, live, pending, respond, safely, saveStatus } from './state.js';
 const terminalTab = (id, title, cwd) => {
     const view = [process.execPath, path.join(path.dirname(process.argv[1]), 'view.js'), id];
@@ -30,7 +34,13 @@ const terminalTab = (id, title, cwd) => {
 const onExit = (running, place) => (code) => {
     live.delete(running.id);
     const tail = code === 0 ? '' : ptyHostLogTail(running.id, 6);
-    saveStatus({ ...running, phase: 'exited', message: running.harness + ' exited with code ' + code + (tail ? '. Last output:\n' + tail : ''), exitCode: code ?? 1, attach: undefined });
+    saveStatus({
+        ...running,
+        phase: 'exited',
+        message: running.harness + ' exited with code ' + code + (tail ? '. Last output:\n' + tail : ''),
+        exitCode: code ?? 1,
+        attach: undefined,
+    });
     log('Session ' + running.id + ' ended (exit ' + code + ')');
     if (place.hooks)
         void runHooksAsync('post-agent', place.env, place.hooks).catch((e) => warn('post-agent hooks failed: ' + errMsg(e)));
@@ -62,15 +72,27 @@ const launchPtyHost = async (req, remote, env, say) => {
     const port = await freePort();
     const token = crypto.randomBytes(24).toString('base64url');
     const child = startPtyHost({
-        exe: ensurePtyHost(), port, token, cols: 120, rows: 32, id: req.id, cwd: req.cwd, env: { ...env, ...harness.environment }, remote,
-        command: commandLine(launch.file, [...base, ...req.args]), restartCommand: commandLine(launch.file, [...base, ...(harness.resumeArguments ?? [])]),
+        exe: ensurePtyHost(),
+        port,
+        token,
+        cols: 120,
+        rows: 32,
+        id: req.id,
+        cwd: req.cwd,
+        env: { ...env, ...harness.environment },
+        remote,
+        command: commandLine(launch.file, [...base, ...req.args]),
+        restartCommand: commandLine(launch.file, [...base, ...(harness.resumeArguments ?? [])]),
     });
     try {
         await waitForPtyHost(child, port, 15000);
     }
     catch (e) {
         const tail = ptyHostLogTail(req.id);
-        throw new Error(errMsg(e) + (tail ? '. From its log:\n' + tail : '') + '\nLog: ' + path.join(dataDir, 'logs', 'ptyhost-' + req.id + '.log'));
+        throw new Error(errMsg(e) +
+            (tail ? '. From its log:\n' + tail : '') +
+            '\nLog: ' +
+            path.join(dataDir, 'logs', 'ptyhost-' + req.id + '.log'));
     }
     return { child, port, token };
 };
@@ -86,13 +108,30 @@ const placeFor = async (req, say) => {
     const ready = await provisionProject(req.project, say);
     if (!exists(req.cwd))
         throw new Error('Folder does not exist in the sandbox: ' + req.cwd);
-    return { env: ready.env, hooks: req.project.hooks ? projectHooks(req.project.name, req.project.workspace) : null, project: req.project.name };
+    return {
+        env: ready.env,
+        hooks: req.project.hooks ? projectHooks(req.project.name, req.project.workspace) : null,
+        project: req.project.name,
+    };
 };
 export const startSession = async (req) => {
-    let status = { id: req.id, launchId: session.launchId, harness: req.harness, cwd: req.cwd, ...(req.project ? { project: req.project.name } : {}), phase: 'starting', message: 'Starting ' + req.harness, updatedAt: now(), startedAt: now() };
+    let status = {
+        id: req.id,
+        launchId: session.launchId,
+        harness: req.harness,
+        cwd: req.cwd,
+        ...(req.project ? { project: req.project.name } : {}),
+        phase: 'starting',
+        message: 'Starting ' + req.harness,
+        updatedAt: now(),
+        startedAt: now(),
+    };
     saveStatus(status);
     // Progress goes into the session's status: the host prints it while it waits, and the tab inside shows it.
-    const say = (message) => { status = { ...status, message }; saveStatus(status); };
+    const say = (message) => {
+        status = { ...status, message };
+        saveStatus(status);
+    };
     pending.starting++;
     // Sessions after the first get their own tab right away (it shows the setup progress until the agent starts).
     if (req.id !== session.launchId && process.env.AGENT_NO_TABS !== '1')
@@ -101,11 +140,27 @@ export const startSession = async (req) => {
         const place = await placeFor(req, say);
         const remote = session.networking && session.attach.enabled;
         const { child, port, token } = await launchPtyHost(req, remote, place.env, say);
-        const running = { ...status, project: place.project, phase: 'running', message: req.harness + ' is running', attach: { addresses: remote ? guestAddresses() : [], port, token } };
+        const running = {
+            ...status,
+            project: place.project,
+            phase: 'running',
+            message: req.harness + ' is running',
+            attach: { addresses: remote ? guestAddresses() : [], port, token },
+        };
         live.set(req.id, { status: running, child });
         child.once('exit', onExit(running, place));
         saveStatus(running);
-        log('Session ' + req.id + ' started (' + req.harness + ' in ' + req.cwd + ', project ' + place.project + ', port ' + port + ')');
+        log('Session ' +
+            req.id +
+            ' started (' +
+            req.harness +
+            ' in ' +
+            req.cwd +
+            ', project ' +
+            place.project +
+            ', port ' +
+            port +
+            ')');
     }
     catch (e) {
         saveStatus({ ...status, phase: 'failed', message: errMsg(e) });
@@ -121,7 +176,10 @@ export const prepareProject = async (req) => {
     pending.starting++;
     try {
         const ready = await provisionProject(req.project, () => undefined);
-        respond(req.id, { ok: true, message: 'Project ' + req.project.name + ' is ready in ' + req.project.workspace + '\n' + ready.summary.join('\n') });
+        respond(req.id, {
+            ok: true,
+            message: 'Project ' + req.project.name + ' is ready in ' + req.project.workspace + '\n' + ready.summary.join('\n'),
+        });
     }
     catch (e) {
         respond(req.id, { ok: false, message: 'Project ' + req.project.name + ' could not be set up: ' + errMsg(e) });
@@ -132,7 +190,9 @@ export const prepareProject = async (req) => {
     }
 };
 export const restartSessions = async (req) => {
-    const targets = [...live.values()].filter((s) => s.status.attach && (req.harness === null || s.status.harness === req.harness) && (!req.cwd || isWithin(req.cwd, s.status.cwd)));
+    const targets = [...live.values()].filter((s) => s.status.attach &&
+        (req.harness === null || s.status.harness === req.harness) &&
+        (!req.cwd || isWithin(req.cwd, s.status.cwd)));
     for (const s of targets)
         await sendControl({ addresses: ['127.0.0.1'], port: s.status.attach.port, token: s.status.attach.token }, FrameType.Restart);
     respond(req.id, { ok: true, message: 'restarted ' + targets.length + ' session(s)' });

package/dist/guest/daemon/state.d.ts

@@ -10,7 +10,10 @@ export declare const pending: {
 };
 /** Inside the launch folder's workspace. */
 export declare const insidePrimary: (cwd: string) => boolean;
-/** Inside any project of this sandbox: the launch folder, a project root, or C:\Projects\<name> (older launch folders: only the first). */
+/**
+ * Inside any project of this sandbox: the launch folder, a project root, or C:\Projects\<name> (older launch folders:
+ * only the first).
+ */
 export declare const insideWorkspace: (cwd: string) => boolean;
 export declare const respond: (id: string, result: Omit<GuestResponse, "id" | "finishedAt">) => void;
 export declare const saveStatus: (status: SessionStatus) => void;

package/dist/guest/daemon/state.js

@@ -1,8 +1,12 @@
 // What the daemon's request handlers share: the running sessions and best-effort status/response writes.
 import path from 'node:path';
-import { now, writeJsonAtomic } from '../../shared/rundir.js';
-import { insideProjects } from '../../shared/projects.js';
-import { errMsg, run, session, warn, workspace } from '../env.js';
+import { now } from '../../shared/channel/run-dir.js';
+import { writeJsonAtomic } from '../../shared/io/json.js';
+import { insideProjects } from '../../shared/paths/projects.js';
+import { run } from '../runtime/paths.js';
+import { session, workspace } from '../runtime/session.js';
+import { warn } from '../runtime/log.js';
+import { errMsg } from '../../core/util/errors.js';
 const MAX_MESSAGE = 3500;
 export const live = new Map();
 /** Sessions being started right now (a headless sandbox must not shut down under them). */
@@ -12,20 +16,30 @@ export const insidePrimary = (cwd) => {
     const rel = path.relative(workspace.toLowerCase(), path.resolve(cwd).toLowerCase());
     return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
 };
-/** Inside any project of this sandbox: the launch folder, a project root, or C:\Projects\<name> (older launch folders: only the first). */
-export const insideWorkspace = (cwd) => insidePrimary(cwd) || (session.projectsDir !== undefined && insideProjects(path.resolve(cwd), session.roots ?? [], session.projectsDir));
-/** Status/response writes are best-effort: a briefly locked file (antivirus, the host's sync) must not kill the daemon. */
-const tryWrite = (file, value) => { try {
-    writeJsonAtomic(file, value);
-}
-catch (e) {
-    warn('Could not write ' + file + ': ' + errMsg(e));
-} };
-export const respond = (id, result) => tryWrite(run.response(id), { id, ...result, message: result.message.slice(0, MAX_MESSAGE), finishedAt: now() });
-export const saveStatus = (status) => tryWrite(run.session(status.id), { ...status, message: status.message.slice(0, MAX_MESSAGE), updatedAt: now() });
-export const safely = (what, work) => { try {
-    work();
-}
-catch (e) {
-    warn(what + ' failed: ' + errMsg(e));
-} };
+/**
+ * Inside any project of this sandbox: the launch folder, a project root, or C:\Projects\<name> (older launch folders:
+ * only the first).
+ */
+export const insideWorkspace = (cwd) => insidePrimary(cwd) ||
+    (session.projectsDir !== undefined && insideProjects(path.resolve(cwd), session.roots ?? [], session.projectsDir));
+/**
+ * Status/response writes are best-effort: a briefly locked file (antivirus, the host's sync) must not kill the daemon.
+ */
+const tryWrite = (file, value) => {
+    try {
+        writeJsonAtomic(file, value);
+    }
+    catch (e) {
+        warn('Could not write ' + file + ': ' + errMsg(e));
+    }
+};
+export const respond = (id, result) => tryWrite(run.responseFile(id), { id, ...result, message: result.message.slice(0, MAX_MESSAGE), finishedAt: now() });
+export const saveStatus = (status) => tryWrite(run.sessionFile(status.id), { ...status, message: status.message.slice(0, MAX_MESSAGE), updatedAt: now() });
+export const safely = (what, work) => {
+    try {
+        work();
+    }
+    catch (e) {
+        warn(what + ' failed: ' + errMsg(e));
+    }
+};

package/dist/guest/databases/database-server.d.ts

@@ -0,0 +1,13 @@
+import type { DatabasePlan } from '../../core/types.js';
+import type { ToolEnv } from '../toolchains/tool-env.js';
+import { type ServedDatabase } from './names.js';
+/** Ends the processes listening on a database's port and its admin UI's port. */
+export declare function killListeners(plan: DatabasePlan): void;
+export declare abstract class DatabaseServer {
+    abstract readonly id: ServedDatabase;
+    get label(): string;
+    /** Installs the server once, creates its data folder once, starts it, and adds its variables and tools to `env`. */
+    abstract start(env: ToolEnv, plan: DatabasePlan): Promise<void>;
+    /** Ends whatever listens on the server's port (and its admin UI's port). */
+    stop(plan: DatabasePlan): Promise<void>;
+}

package/dist/guest/databases/database-server.js

@@ -0,0 +1,35 @@
+// One database server in the sandbox: started by the boot (or sbx-db start), stopped by sbx-db stop.
+import { spawnSync } from 'node:child_process';
+import { SYSTEM } from '../../shared/system.js';
+import { DATABASE_NAMES } from './names.js';
+/** The process listening on a local TCP port (netstat: no PowerShell start-up cost), or null. */
+function 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;
+}
+/** Ends the processes listening on a database's port and its admin UI's port. */
+export function killListeners(plan) {
+    for (const port of [plan.port, plan.adminPort ?? 0]) {
+        const pid = port && listenerPid(port);
+        if (pid)
+            try {
+                process.kill(pid);
+            }
+            catch {
+                /* already gone */
+            }
+    }
+}
+export class DatabaseServer {
+    get label() {
+        return DATABASE_NAMES[this.id];
+    }
+    /** Ends whatever listens on the server's port (and its admin UI's port). */
+    async stop(plan) {
+        killListeners(plan);
+    }
+}

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

@@ -0,0 +1,12 @@
+import type { DatabasePlan } from '../../core/types.js';
+import { type ToolEnv } from '../toolchains/tool-env.js';
+import { DatabaseServer } from './database-server.js';
+export declare class DynamoServer extends DatabaseServer {
+    readonly id = "dynamodb";
+    /**
+     * 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).
+     */
+    start(env: ToolEnv, plan: DatabasePlan): Promise<void>;
+}

package/dist/guest/databases/dynamodb.js

@@ -0,0 +1,81 @@
+// DynamoDB Local + dynamodb-admin.
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { downloader, fetchText } from '../../shared/download/index.js';
+import { execAsync } from '../runtime/process.js';
+import { exists, mkdirp } from '../runtime/fs.js';
+import { log } from '../runtime/log.js';
+import { logsDir } from '../runtime/paths.js';
+import { ensureJdk } from '../toolchains/languages/java.js';
+import { tool } from '../toolchains/tool-env.js';
+import { portOpen, waitForPort } from '../runtime/ports.js';
+import { dataFor, startServer } from './server.js';
+import { DatabaseServer } from './database-server.js';
+const DYNAMO_ZIP = 'https://d1ni2b6xgvw0s0.cloudfront.net/v2.x/dynamodb_local_latest.zip';
+export class DynamoServer extends DatabaseServer {
+    id = 'dynamodb';
+    /**
+     * 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).
+     */
+    async start(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 downloader.archive(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: 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/databases/index.d.ts

@@ -0,0 +1,2 @@
+export { DATABASE_NAMES } from './names.js';
+export { setupDatabase, stopDatabase } from './registry.js';

package/dist/guest/databases/index.js

@@ -0,0 +1,2 @@
+export { DATABASE_NAMES } from './names.js';
+export { setupDatabase, stopDatabase } from './registry.js';

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

@@ -0,0 +1,7 @@
+import type { DatabasePlan } from '../../core/types.js';
+import { type ToolEnv } from '../toolchains/tool-env.js';
+import { DatabaseServer } from './database-server.js';
+export declare class MongoServer extends DatabaseServer {
+    readonly id = "mongodb";
+    start(env: ToolEnv, plan: DatabasePlan): Promise<void>;
+}

package/dist/guest/databases/mongodb.js

@@ -0,0 +1,46 @@
+// MongoDB Community, with mongosh.
+import path from 'node:path';
+import { downloader, fetchJson } from '../../shared/download/index.js';
+import { exists, mkdirp } from '../runtime/fs.js';
+import { log } from '../runtime/log.js';
+import { installFromGithub } from '../toolchains/install.js';
+import { resolveCached } from '../toolchains/version-cache.js';
+import { tool } from '../toolchains/tool-env.js';
+import { clearStaleLocks, dataFor, startServer } from './server.js';
+import { DatabaseServer } from './database-server.js';
+export class MongoServer extends DatabaseServer {
+    id = 'mongodb';
+    async start(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 downloader.archive(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/databases/mysql.d.ts

@@ -0,0 +1,7 @@
+import type { DatabasePlan } from '../../core/types.js';
+import { type ToolEnv } from '../toolchains/tool-env.js';
+import { DatabaseServer } from './database-server.js';
+export declare class MysqlServer extends DatabaseServer {
+    readonly id = "mysql";
+    start(env: ToolEnv, plan: DatabasePlan): Promise<void>;
+}

package/dist/guest/databases/mysql.js

@@ -0,0 +1,59 @@
+// MariaDB, the MySQL-compatible server.
+import path from 'node:path';
+import { downloader, fetchJson } from '../../shared/download/index.js';
+import { execAsync } from '../runtime/process.js';
+import { exists } from '../runtime/fs.js';
+import { log } from '../runtime/log.js';
+import { resolveCached } from '../toolchains/version-cache.js';
+import { tool } from '../toolchains/tool-env.js';
+import { createOnce, dataFor, startServer } from './server.js';
+import { DatabaseServer } from './database-server.js';
+const MARIA = 'https://downloads.mariadb.org/rest-api/mariadb/';
+export class MysqlServer extends DatabaseServer {
+    id = 'mysql';
+    async start(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 downloader.archive(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/databases/names.d.ts

@@ -0,0 +1,5 @@
+import type { DatabasePlan } from '../../core/types.js';
+export type DatabaseId = DatabasePlan['database'];
+/** The databases a server can run for (SQL Server cannot start inside Windows Sandbox). */
+export type ServedDatabase = Exclude<DatabaseId, 'sqlserver'>;
+export declare const DATABASE_NAMES: Record<DatabasePlan['database'], string>;

package/dist/guest/databases/names.js

@@ -0,0 +1,8 @@
+export const DATABASE_NAMES = {
+    postgres: 'PostgreSQL',
+    mysql: 'MySQL (MariaDB)',
+    mongodb: 'MongoDB',
+    redis: 'Redis',
+    dynamodb: 'DynamoDB Local',
+    sqlserver: 'SQL Server',
+};

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

@@ -0,0 +1,9 @@
+import type { DatabasePlan } from '../../core/types.js';
+import { type ToolEnv } from '../toolchains/tool-env.js';
+import { DatabaseServer } from './database-server.js';
+export declare class PostgresServer extends DatabaseServer {
+    readonly id = "postgres";
+    start(env: ToolEnv, plan: DatabasePlan): Promise<void>;
+    /** Every installed version's cluster shuts down cleanly through pg_ctl first. */
+    stop(plan: DatabasePlan): Promise<void>;
+}