@multiplayer-app/agent 0.1.20 → 0.1.22

package/dist/app/app-host.test.js

@@ -0,0 +1,639 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_fs_1 = require("node:fs");
+const node_http_1 = __importDefault(require("node:http"));
+const node_net_1 = __importDefault(require("node:net"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_test_1 = require("node:test");
+const protocol_1 = require("../transport/protocol");
+const preview_proxy_1 = require("../runtime/preview-proxy");
+const app_host_1 = require("./app-host");
+const runner_1 = require("./runner");
+const env_1 = require("./env");
+const FAST = { backoff: { initialMs: 20, maxMs: 50, resetAfterMs: 60000 }, readyPollMs: 50 };
+function freePort() {
+    return new Promise((resolve) => {
+        const server = node_net_1.default.createServer();
+        server.listen(0, '127.0.0.1', () => {
+            const { port } = server.address();
+            server.close(() => resolve(port));
+        });
+    });
+}
+async function writeFiles(dir, files) {
+    for (const [name, content] of Object.entries(files)) {
+        await node_fs_1.promises.mkdir(node_path_1.default.dirname(node_path_1.default.join(dir, name)), { recursive: true });
+        await node_fs_1.promises.writeFile(node_path_1.default.join(dir, name), content);
+    }
+}
+function request(port, url, headers = {}) {
+    return new Promise((resolve, reject) => {
+        node_http_1.default.get({ host: '127.0.0.1', port, path: url, headers: { [protocol_1.PREVIEW_PORT_HEADER]: 'app', ...headers } }, (res) => {
+            let body = '';
+            res.on('data', (chunk) => (body += chunk));
+            res.on('end', () => { var _a; return resolve({ status: (_a = res.statusCode) !== null && _a !== void 0 ? _a : 0, headers: res.headers, body }); });
+        }).on('error', reject);
+    });
+}
+const API_SERVER = `require('http').createServer((req, res) => {
+  res.setHeader('Content-Type', 'application/json')
+  res.end(JSON.stringify({ url: req.url, port: process.env.PORT, secret: process.env.OPENROUTER_API_KEY ?? null }))
+}).listen(Number(process.env.PORT), '127.0.0.1')`;
+(0, node_test_1.describe)('app host (session VM, dev mode)', () => {
+    let dir;
+    let apiPort;
+    let host;
+    let proxy;
+    let proxyPort;
+    (0, node_test_1.before)(async () => {
+        dir = await node_fs_1.promises.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'builder-app-'));
+        apiPort = await freePort();
+        await writeFiles(dir, {
+            'server.js': API_SERVER,
+            'public/index.html': '<h1>web</h1>',
+            'public/assets/app.js': 'console.log(1)',
+            '.builder/builder.json': JSON.stringify({
+                services: {
+                    // No devCommand: served from its output directory by the guest.
+                    web: {
+                        outputDirectory: 'public',
+                        rewrites: [{ source: '/((?!assets/).*)', destination: '/index.html' }],
+                        headers: [{ source: '/assets/(.*)', headers: [{ key: 'Cache-Control', value: 'public, max-age=31536000, immutable' }] }],
+                    },
+                    api: { devCommand: [process.execPath, 'server.js'], port: apiPort },
+                },
+                rewrites: [
+                    { source: '/api/(.*)', destination: { service: 'api' } },
+                    { source: '/(.*)', destination: { service: 'web' } },
+                ],
+                daemons: { worker: { command: [process.execPath, '-e', 'process.exit(3)'] } },
+            }),
+        });
+        host = new app_host_1.AppHost({ dir, mode: 'dev', env: (0, env_1.sessionAppEnv)({ ...process.env, OPENROUTER_API_KEY: 'model-key' }), ...FAST });
+        (0, preview_proxy_1.setAppHandler)(host);
+        proxy = (0, preview_proxy_1.startPreviewServer)(0);
+        await new Promise((resolve) => proxy.once('listening', resolve));
+        proxyPort = proxy.address().port;
+        await host.start();
+    });
+    (0, node_test_1.after)(async () => {
+        await host.stop();
+        proxy.closeAllConnections();
+        proxy.close();
+        await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+    });
+    (0, node_test_1.it)('runs every service and reports them', async () => {
+        const status = await host.settled(10000);
+        strict_1.default.equal(status === null || status === void 0 ? void 0 : status.phase, 'running');
+        const api = status === null || status === void 0 ? void 0 : status.processes.find((process) => process.name === 'api');
+        strict_1.default.deepEqual([api === null || api === void 0 ? void 0 : api.state, api === null || api === void 0 ? void 0 : api.port, api === null || api === void 0 ? void 0 : api.log], ['running', apiPort, '.builder/logs/api.log']);
+    });
+    (0, node_test_1.it)('routes the session URL by the rewrites', async () => {
+        const api = await request(proxyPort, '/api/hello?x=1');
+        strict_1.default.deepEqual(JSON.parse(api.body), { url: '/api/hello?x=1', port: String(apiPort), secret: null });
+        const page = await request(proxyPort, '/dashboard/settings');
+        strict_1.default.deepEqual([page.status, page.body], [200, '<h1>web</h1>']);
+        const asset = await request(proxyPort, '/assets/app.js');
+        strict_1.default.equal(asset.headers['cache-control'], 'public, max-age=31536000, immutable');
+        strict_1.default.equal((await request(proxyPort, '/assets/missing.js')).status, 404);
+    });
+    (0, node_test_1.it)('never serves dotfiles from a static service', async () => {
+        await writeFiles(dir, { 'public/.env': 'SECRET=1' });
+        strict_1.default.equal((await request(proxyPort, '/.env')).body, '<h1>web</h1>');
+    });
+    (0, node_test_1.it)('restarts a process that exits, and says how it exited', async () => {
+        var _a, _b;
+        await new Promise((resolve) => setTimeout(resolve, 300));
+        const worker = (_a = host.status()) === null || _a === void 0 ? void 0 : _a.processes.find((process) => process.name === 'worker');
+        strict_1.default.equal(worker === null || worker === void 0 ? void 0 : worker.kind, 'daemon');
+        strict_1.default.equal(worker === null || worker === void 0 ? void 0 : worker.exitCode, 3);
+        strict_1.default.ok(((_b = worker === null || worker === void 0 ? void 0 : worker.restarts) !== null && _b !== void 0 ? _b : 0) >= 1);
+    });
+});
+(0, node_test_1.describe)('app host failures', () => {
+    let dir;
+    (0, node_test_1.before)(async () => {
+        dir = await node_fs_1.promises.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'builder-app-'));
+    });
+    (0, node_test_1.after)(() => node_fs_1.promises.rm(dir, { recursive: true, force: true }));
+    (0, node_test_1.it)('serves why an invalid builder.json cannot run', async () => {
+        var _a;
+        await writeFiles(dir, { '.builder/builder.json': JSON.stringify({ services: { a: { devCommand: 'x' }, b: { devCommand: 'y' } } }) });
+        const host = new app_host_1.AppHost({ dir, mode: 'dev', env: {}, ...FAST });
+        const status = await host.start();
+        strict_1.default.equal(status === null || status === void 0 ? void 0 : status.phase, 'failed');
+        strict_1.default.match((_a = status === null || status === void 0 ? void 0 : status.error) !== null && _a !== void 0 ? _a : '', /rewrites: are needed/);
+    });
+    (0, node_test_1.it)('stops at a failed install and points at its log', async () => {
+        await writeFiles(dir, { '.builder/builder.json': JSON.stringify({ services: { web: { installCommand: 'echo no network; exit 4', devCommand: 'true' } } }) });
+        const host = new app_host_1.AppHost({ dir, mode: 'dev', env: { PATH: process.env.PATH }, ...FAST });
+        const status = await host.start();
+        strict_1.default.equal(status === null || status === void 0 ? void 0 : status.phase, 'failed');
+        strict_1.default.equal(status === null || status === void 0 ? void 0 : status.error, 'Install failed in . (exit 4); see .builder/logs/install.log');
+        strict_1.default.match(await node_fs_1.promises.readFile(node_path_1.default.join(dir, '.builder/logs/install.log'), 'utf8'), /no network/);
+    });
+    (0, node_test_1.it)('has no app without a builder.json', async () => {
+        await node_fs_1.promises.rm(node_path_1.default.join(dir, '.builder/builder.json'));
+        strict_1.default.equal(await new app_host_1.AppHost({ dir, mode: 'dev', env: {} }).start(), null);
+    });
+});
+(0, node_test_1.describe)('app host (session VM, no builder.json)', () => {
+    let dir;
+    let host;
+    let proxy;
+    let proxyPort;
+    (0, node_test_1.before)(async () => {
+        dir = await node_fs_1.promises.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'builder-app-'));
+        host = new app_host_1.AppHost({ dir, mode: 'dev', env: { PATH: process.env.PATH }, ...FAST });
+        (0, preview_proxy_1.setAppHandler)(host);
+        proxy = (0, preview_proxy_1.startPreviewServer)(0);
+        await new Promise((resolve) => proxy.once('listening', resolve));
+        proxyPort = proxy.address().port;
+    });
+    (0, node_test_1.after)(async () => {
+        await host.stop();
+        proxy.closeAllConnections();
+        proxy.close();
+        await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+    });
+    (0, node_test_1.it)('serves static files it detects, and writes their builder.json', async () => {
+        await writeFiles(dir, { 'public/index.html': '<h1>dashboard</h1>', 'public/package.json': 'on purpose', 'build-data.js': '' });
+        const status = await host.start();
+        strict_1.default.deepEqual([status === null || status === void 0 ? void 0 : status.phase, status === null || status === void 0 ? void 0 : status.framework, status === null || status === void 0 ? void 0 : status.source], ['running', null, 'detected']);
+        strict_1.default.equal((await request(proxyPort, '/')).body, '<h1>dashboard</h1>');
+        // An output folder holds what is meant to be served.
+        strict_1.default.equal((await request(proxyPort, '/package.json')).body, 'on purpose');
+        const { $generated, ...written } = JSON.parse(await node_fs_1.promises.readFile(node_path_1.default.join(dir, '.builder/builder.json'), 'utf8'));
+        strict_1.default.equal(typeof $generated, 'string');
+        strict_1.default.deepEqual(written, {
+            services: { web: { root: '.', framework: null, outputDirectory: 'public' } },
+            rewrites: [{ source: '/(.*)', destination: { service: 'web' } }],
+        });
+    });
+    (0, node_test_1.it)('after a turn, starts the server the workspace now holds', async () => {
+        var _a, _b;
+        const port = await freePort();
+        await writeFiles(dir, {
+            'package.json': JSON.stringify({ scripts: { start: `node server.js` } }),
+            'server.js': API_SERVER.replace('Number(process.env.PORT)', String(port)),
+        });
+        // A start script: the package's own ("Other"), so the guest gives it $PORT; this server keeps its own.
+        await writeFiles(dir, { '.builder/builder.json': JSON.stringify({ services: { app: { port, installCommand: 'true', devCommand: [process.execPath, 'server.js'] } } }, null, 2) });
+        await host.refresh();
+        const status = await host.settled(10000);
+        strict_1.default.equal(status === null || status === void 0 ? void 0 : status.phase, 'running');
+        strict_1.default.equal(status === null || status === void 0 ? void 0 : status.source, 'builder.json');
+        strict_1.default.equal(JSON.parse((await request(proxyPort, '/hello')).body).url, '/hello');
+        // Unchanged since: the running app is left alone.
+        const before = (_a = host.status()) === null || _a === void 0 ? void 0 : _a.processes[0];
+        await host.refresh();
+        strict_1.default.equal((_b = host.status()) === null || _b === void 0 ? void 0 : _b.processes[0].restarts, before === null || before === void 0 ? void 0 : before.restarts);
+    });
+});
+(0, node_test_1.describe)('app host (services in packages/, no builder.json)', () => {
+    let dir;
+    let host;
+    let proxy;
+    let proxyPort;
+    (0, node_test_1.before)(async () => {
+        var _a;
+        dir = await node_fs_1.promises.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'builder-app-'));
+        await writeFiles(dir, {
+            'README.md': 'not part of any service',
+            'packages/web/index.html': '<h1>web</h1>',
+            'packages/web/styles.css': 'web styles',
+            'packages/web/package.json': JSON.stringify({ name: 'web', private: true }),
+            'packages/web/package-lock.json': JSON.stringify({ name: 'web', lockfileVersion: 3, requires: true, packages: {} }),
+            'packages/web/docs/package.json': 'the site\'s own file',
+            'packages/admin/index.html': '<h1>admin</h1>',
+            'packages/admin/styles.css': 'admin styles',
+            'packages/api/package.json': JSON.stringify({ scripts: { start: 'node server.js' } }),
+            'packages/api/server.js': API_SERVER,
+        });
+        host = new app_host_1.AppHost({ dir, mode: 'dev', env: { PATH: process.env.PATH }, ...FAST });
+        (0, preview_proxy_1.setAppHandler)(host);
+        proxy = (0, preview_proxy_1.startPreviewServer)(0);
+        await new Promise((resolve) => proxy.once('listening', resolve));
+        proxyPort = proxy.address().port;
+        await host.start();
+        strict_1.default.equal((_a = (await host.settled(30000))) === null || _a === void 0 ? void 0 : _a.phase, 'running');
+    });
+    (0, node_test_1.after)(async () => {
+        await host.stop();
+        proxy.closeAllConnections();
+        proxy.close();
+        await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+    });
+    (0, node_test_1.it)('serves the main site at the root of the URL, and the server below /api', async () => {
+        strict_1.default.equal((await request(proxyPort, '/')).body, '<h1>web</h1>');
+        strict_1.default.equal((await request(proxyPort, '/styles.css')).body, 'web styles');
+        const api = JSON.parse((await request(proxyPort, '/api/filings')).body);
+        strict_1.default.equal(api.url, '/api/filings');
+    });
+    (0, node_test_1.it)('serves a second frontend below its name, with its own relative files', async () => {
+        const bare = await request(proxyPort, '/admin');
+        strict_1.default.deepEqual([bare.status, bare.headers.location], [307, '/admin/']);
+        strict_1.default.equal((await request(proxyPort, '/admin/')).body, '<h1>admin</h1>');
+        strict_1.default.equal((await request(proxyPort, '/admin/styles.css')).body, 'admin styles');
+    });
+    (0, node_test_1.it)('opens nothing around the services', async () => {
+        for (const url of ['/packages/api/server.js', '/README.md', '/server.js']) {
+            strict_1.default.equal((await request(proxyPort, url)).status, 404, url);
+        }
+    });
+    (0, node_test_1.it)('keeps a service\'s project files out of its site, and serves the site\'s own', async () => {
+        for (const url of ['/package.json', '/package-lock.json', '/PACKAGE.JSON', '/%2Fpackage.json', '/admin/package.json']) {
+            strict_1.default.equal((await request(proxyPort, url)).status, 404, url);
+        }
+        strict_1.default.equal((await request(proxyPort, '/docs/package.json')).body, 'the site\'s own file');
+    });
+});
+(0, node_test_1.describe)('app host (a site beside a server still starting)', () => {
+    const html = { accept: 'text/html,application/xhtml+xml,*/*;q=0.8' };
+    let dir;
+    let host;
+    let proxy;
+    let proxyPort;
+    const startWith = async (server) => {
+        dir = await node_fs_1.promises.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'builder-app-'));
+        await writeFiles(dir, {
+            'packages/web/index.html': '<h1>web</h1>',
+            'packages/web/app.js': 'the script',
+            'packages/api/package.json': JSON.stringify({ scripts: { start: 'node server.js' } }),
+            'packages/api/server.js': server,
+        });
+        host = new app_host_1.AppHost({ dir, mode: 'dev', env: { PATH: process.env.PATH }, ...FAST });
+        (0, preview_proxy_1.setAppHandler)(host);
+        proxy = (0, preview_proxy_1.startPreviewServer)(0);
+        await new Promise((resolve) => proxy.once('listening', resolve));
+        proxyPort = proxy.address().port;
+        await host.start();
+    };
+    (0, node_test_1.afterEach)(async () => {
+        await host.stop();
+        proxy.closeAllConnections();
+        proxy.close();
+        await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+    });
+    const until = async (url, headers, wanted) => {
+        const deadline = Date.now() + 15000;
+        for (;;) {
+            const answer = await request(proxyPort, url, headers);
+            if (answer.status === wanted || Date.now() > deadline)
+                return answer;
+            await new Promise((resolve) => setTimeout(resolve, 50));
+        }
+    };
+    (0, node_test_1.it)('holds a page load until the server is up, and never its assets', async () => {
+        await startWith(`setTimeout(() => require('http').createServer((req, res) => res.end('ok')).listen(Number(process.env.PORT), '127.0.0.1'), 2500)`);
+        const held = await until('/', html, 503);
+        strict_1.default.equal(held.status, 503);
+        strict_1.default.match(held.body, /http-equiv="refresh"/);
+        strict_1.default.equal((await request(proxyPort, '/app.js', { accept: '*/*' })).body, 'the script');
+        const page = await until('/', html, 200);
+        strict_1.default.equal(page.body, '<h1>web</h1>');
+        strict_1.default.equal((await request(proxyPort, '/api/x')).body, 'ok');
+    });
+    (0, node_test_1.it)('stops holding it once the server has crashed: the site doesn\'t wait for what may never start', async () => {
+        await startWith(`process.exit(1)`);
+        const page = await until('/', html, 200);
+        strict_1.default.equal(page.status, 200);
+        strict_1.default.equal(page.body, '<h1>web</h1>');
+    });
+});
+(0, node_test_1.describe)('app host (vercel.json\'s routing)', () => {
+    let dir;
+    let host;
+    let proxy;
+    let proxyPort;
+    const noRedirect = async (url) => request(proxyPort, url);
+    const start = async (files, env = { PATH: process.env.PATH }) => {
+        await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+        await node_fs_1.promises.mkdir(dir, { recursive: true });
+        await writeFiles(dir, files);
+        await (host === null || host === void 0 ? void 0 : host.stop());
+        host = new app_host_1.AppHost({ dir, mode: 'dev', env, ...FAST });
+        (0, preview_proxy_1.setAppHandler)(host);
+        await host.start();
+        return host.settled(15000);
+    };
+    (0, node_test_1.before)(async () => {
+        dir = await node_fs_1.promises.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'builder-app-'));
+        proxy = (0, preview_proxy_1.startPreviewServer)(0);
+        await new Promise((resolve) => proxy.once('listening', resolve));
+        proxyPort = proxy.address().port;
+    });
+    (0, node_test_1.after)(async () => {
+        await (host === null || host === void 0 ? void 0 : host.stop());
+        proxy.closeAllConnections();
+        proxy.close();
+        await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+    });
+    (0, node_test_1.it)('applies clean URLs and redirects to a static site', async () => {
+        await start({
+            'about.html': 'about page',
+            'index.html': 'home',
+            '.builder/builder.json': JSON.stringify({ services: { site: { outputDirectory: '.', cleanUrls: true, redirects: [{ source: '/old', destination: '/about', permanent: false }] } } }),
+        });
+        strict_1.default.equal((await noRedirect('/about')).body, 'about page');
+        const clean = await noRedirect('/about.html?a=1');
+        strict_1.default.deepEqual([clean.status, clean.headers.location], [308, '/about?a=1']);
+        const old = await noRedirect('/old');
+        strict_1.default.deepEqual([old.status, old.headers.location], [307, '/about']);
+    });
+    (0, node_test_1.it)('rewrites requests to a server and sets headers on its answers', async () => {
+        const port = await freePort();
+        const status = await start({
+            'server.js': API_SERVER,
+            '.builder/builder.json': JSON.stringify({
+                services: {
+                    app: {
+                        devCommand: [process.execPath, 'server.js'],
+                        port,
+                        rewrites: [{ source: '/v1/(.*)', destination: '/api/$1' }],
+                        headers: [{ source: '/(.*)', headers: [{ key: 'X-Frame-Options', value: 'DENY' }, { key: 'Content-Type', value: 'application/x-custom' }] }],
+                        redirects: [{ source: '/gone', destination: '/v1/here' }],
+                        trailingSlash: false,
+                    },
+                },
+            }),
+        });
+        strict_1.default.equal(status === null || status === void 0 ? void 0 : status.phase, 'running');
+        const rewritten = await noRedirect('/v1/users?a=1');
+        strict_1.default.equal(JSON.parse(rewritten.body).url, '/api/users?a=1');
+        strict_1.default.equal(rewritten.headers['x-frame-options'], 'DENY');
+        strict_1.default.equal(rewritten.headers['content-type'], 'application/x-custom', 'over the server\'s own');
+        strict_1.default.equal(JSON.parse((await noRedirect('/plain')).body).url, '/plain');
+        strict_1.default.deepEqual([(await noRedirect('/gone')).status, (await noRedirect('/gone')).headers.location], [308, '/v1/here']);
+        strict_1.default.equal((await noRedirect('/plain/')).headers.location, '/plain');
+    });
+    (0, node_test_1.it)('leaves a dev server standing in for a static site to route for itself', async () => {
+        const port = await freePort();
+        const status = await start({
+            'server.js': API_SERVER,
+            '.builder/builder.json': JSON.stringify({
+                services: {
+                    app: {
+                        devCommand: [process.execPath, 'server.js'],
+                        port,
+                        outputDirectory: 'dist',
+                        rewrites: [{ source: '/(.*)', destination: '/index.html' }],
+                        trailingSlash: true,
+                    },
+                },
+            }),
+        });
+        strict_1.default.equal(status === null || status === void 0 ? void 0 : status.phase, 'running');
+        const asset = await noRedirect('/@vite/client');
+        strict_1.default.equal(asset.status, 200, 'no trailing slash forced on it');
+        strict_1.default.equal(JSON.parse(asset.body).url, '/@vite/client', 'no SPA fallback in front of it');
+    });
+    (0, node_test_1.it)('passes what a static service has no file for to the next match: api + static files', async () => {
+        const port = await freePort();
+        const status = await start({
+            'server.js': API_SERVER,
+            'public/index.html': 'home',
+            'public/logo.txt': 'logo',
+            '.builder/builder.json': JSON.stringify({
+                services: { web: { outputDirectory: 'public' }, api: { devCommand: [process.execPath, 'server.js'], port } },
+                rewrites: [
+                    { source: '/(.*)', destination: { service: 'web' } },
+                    { source: '/(.*)', destination: { service: 'api' } },
+                ],
+            }),
+        });
+        strict_1.default.equal(status === null || status === void 0 ? void 0 : status.phase, 'running', JSON.stringify(status));
+        strict_1.default.equal((await noRedirect('/')).body, 'home');
+        strict_1.default.equal((await noRedirect('/logo.txt')).body, 'logo');
+        strict_1.default.equal(JSON.parse((await noRedirect('/users?a=1')).body).url, '/users?a=1');
+        // What static files can't answer goes on too, with its body.
+        const posted = await new Promise((resolve, reject) => {
+            const req = node_http_1.default.request({ host: '127.0.0.1', port: proxyPort, path: '/logo.txt', method: 'POST', headers: { [protocol_1.PREVIEW_PORT_HEADER]: 'app' } }, (res) => {
+                let body = '';
+                res.setEncoding('utf8');
+                res.on('data', (chunk) => (body += chunk));
+                res.on('end', () => resolve({ status: res.statusCode, body }));
+            });
+            req.on('error', reject);
+            req.end('payload');
+        });
+        strict_1.default.equal(posted.status, 200);
+        strict_1.default.equal(JSON.parse(posted.body).url, '/logo.txt');
+    });
+    (0, node_test_1.it)('answers 404 once a static service is the last to match, and for a path no rule matches', async () => {
+        await start({
+            'site/index.html': 'home',
+            '.builder/builder.json': JSON.stringify({ services: { site: { outputDirectory: 'site' } }, rewrites: [{ source: '/docs/(.*)', destination: { service: 'site' } }] }),
+        });
+        strict_1.default.equal((await noRedirect('/docs/missing')).status, 404);
+        strict_1.default.equal((await noRedirect('/elsewhere')).status, 404);
+    });
+    const withFunctionsBin = async () => {
+        const bin = await node_fs_1.promises.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'builder-bin-'));
+        await node_fs_1.promises.symlink(node_path_1.default.join(__dirname, 'functions-cli.js'), node_path_1.default.join(bin, 'builder-functions'));
+        await node_fs_1.promises.chmod(node_path_1.default.join(__dirname, 'functions-cli.js'), 0o755);
+        return bin;
+    };
+    (0, node_test_1.it)('runs functions from the folder and URL builder.json names, and ignores an api/ folder it does not', async () => {
+        const bin = await withFunctionsBin();
+        const status = await start({
+            'index.html': 'home',
+            'api/ignored.js': `export default (req, res) => res.send('should not run')`,
+            'backend/handlers/ping.js': `export default (req, res) => res.send('pong')`,
+            '.builder/builder.json': JSON.stringify({
+                services: { web: { outputDirectory: '.' }, handlers: { functions: { directory: 'backend/handlers', path: '/svc' } } },
+                rewrites: [
+                    { source: '/svc/(.*)', destination: { service: 'handlers' } },
+                    { source: '/(.*)', destination: { service: 'web' } },
+                ],
+            }),
+        }, { PATH: `${bin}${node_path_1.default.delimiter}${node_path_1.default.dirname(process.execPath)}${node_path_1.default.delimiter}${process.env.PATH}` });
+        try {
+            strict_1.default.equal(status === null || status === void 0 ? void 0 : status.phase, 'running', JSON.stringify(status));
+            strict_1.default.equal((await noRedirect('/svc/ping')).body, 'pong');
+            strict_1.default.equal((await noRedirect('/')).body, 'home');
+            strict_1.default.equal((await noRedirect('/backend/handlers/ping.js')).status, 404, 'never the source');
+            strict_1.default.notEqual((await noRedirect('/api/ignored')).body, 'should not run');
+        }
+        finally {
+            await host.stop();
+            await node_fs_1.promises.rm(bin, { recursive: true, force: true });
+        }
+    });
+    (0, node_test_1.it)('runs functions from an api/ folder beside a static site, through the real command', async () => {
+        var _a;
+        const bin = await withFunctionsBin();
+        const status = await start({
+            'index.html': 'home',
+            'api/hello.js': `export default function handler(req, res) { res.json({ hello: req.query.name ?? 'world', port: process.env.PORT }) }`,
+        }, { PATH: `${bin}${node_path_1.default.delimiter}${node_path_1.default.dirname(process.execPath)}${node_path_1.default.delimiter}${process.env.PATH}` });
+        try {
+            strict_1.default.equal(status === null || status === void 0 ? void 0 : status.phase, 'running', JSON.stringify(status));
+            strict_1.default.equal((await noRedirect('/')).body, 'home');
+            strict_1.default.equal(JSON.parse((await noRedirect('/api/hello?name=ada')).body).hello, 'ada');
+            strict_1.default.equal((await noRedirect('/api/missing')).status, 404);
+            // Restarted on a change to a handler it has loaded (--watch).
+            await node_fs_1.promises.writeFile(node_path_1.default.join(dir, 'api/hello.js'), `export default function handler(req, res) { res.json({ hello: 'changed' }) }`);
+            let changed = '';
+            for (let attempt = 0; attempt < 50 && changed !== 'changed'; attempt++) {
+                await new Promise((resolve) => setTimeout(resolve, 100));
+                const answer = await noRedirect('/api/hello').catch(() => undefined);
+                if ((answer === null || answer === void 0 ? void 0 : answer.status) === 200)
+                    changed = JSON.parse(answer.body).hello;
+            }
+            strict_1.default.equal(changed, 'changed');
+        }
+        finally {
+            await host.stop();
+            await node_fs_1.promises.rm(bin, { recursive: true, force: true });
+        }
+        // Stopping the app stopped node --watch and the server under it.
+        const port = (_a = status === null || status === void 0 ? void 0 : status.processes.find((process) => process.name === 'functions')) === null || _a === void 0 ? void 0 : _a.port;
+        await strict_1.default.rejects(() => fetch(`http://127.0.0.1:${port}/api/hello`));
+    });
+});
+(0, node_test_1.describe)('app runner steps', () => {
+    let dir;
+    const FILES = {
+        'web/package.json': JSON.stringify({ scripts: {} }),
+        'api/server.js': API_SERVER,
+    };
+    const config = {
+        services: {
+            web: { root: 'web', installCommand: 'node -e "require(\\"fs\\").writeFileSync(\\"installed\\",\\"\\")"', buildCommand: 'node -e "require(\\"fs\\").writeFileSync(\\"built\\",\\"\\")"', outputDirectory: '.' },
+            api: { root: 'api', installCommand: 'node -e "require(\\"fs\\").writeFileSync(\\"installed\\",\\"\\")"', buildCommand: 'node -e "require(\\"fs\\").writeFileSync(\\"built\\",\\"\\")"', startCommand: 'node server.js' },
+        },
+        rewrites: [{ source: '/api/(.*)', destination: { service: 'api' } }, { source: '/(.*)', destination: { service: 'web' } }],
+    };
+    const exists = (file) => node_fs_1.promises.access(node_path_1.default.join(dir, file)).then(() => true, () => false);
+    (0, node_test_1.before)(async () => {
+        dir = await node_fs_1.promises.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'builder-app-'));
+        await writeFiles(dir, FILES);
+    });
+    (0, node_test_1.after)(() => node_fs_1.promises.rm(dir, { recursive: true, force: true }));
+    (0, node_test_1.it)('prepare installs and builds every service, and starts nothing', async () => {
+        const runner = new runner_1.AppRunner(config, { dir, mode: 'production', env: { PATH: process.env.PATH }, ...FAST });
+        strict_1.default.equal(await runner.prepare(), true);
+        for (const file of ['web/installed', 'web/built', 'api/installed', 'api/built'])
+            strict_1.default.ok(await exists(file), file);
+        strict_1.default.deepEqual(runner.status().processes, []);
+        await runner.stop();
+    });
+    (0, node_test_1.it)('a release built ahead of time installs and builds nothing, as it brought both; a static service\'s folder needn\'t be there', async () => {
+        await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+        await writeFiles(dir, { 'api/server.js': API_SERVER });
+        const runner = new runner_1.AppRunner(config, { dir, mode: 'production', env: { PATH: process.env.PATH }, prebuilt: true, ...FAST });
+        strict_1.default.equal(await runner.prepare(), true);
+        strict_1.default.ok(!(await exists('api/installed')));
+        strict_1.default.ok(!(await exists('api/built')));
+        strict_1.default.ok(!(await exists('web')));
+        strict_1.default.equal(runner.status().error, undefined);
+        await runner.stop();
+    });
+    (0, node_test_1.it)('a release built ahead of time is starting from the first, and not running until something is', async () => {
+        await writeFiles(dir, { 'api/server.js': API_SERVER });
+        const runner = new runner_1.AppRunner(config, { dir, mode: 'production', env: { PATH: process.env.PATH }, prebuilt: true, ...FAST });
+        strict_1.default.equal(runner.status().phase, 'starting');
+        await runner.prepare();
+        strict_1.default.equal(runner.status().phase, 'starting');
+        await runner.stop();
+    });
+    (0, node_test_1.it)('a release built ahead of time runs its start script, and not what surrounds it', async () => {
+        const mark = (file) => `node -e \\"require('fs').writeFileSync('${file}','')\\"`;
+        const files = {
+            'api/server.js': API_SERVER,
+            'api/package.json': `{ "scripts": { "prestart": "${mark('prestarted')}", "start": "${mark('started')} && node server.js" } }`,
+        };
+        const app = { services: { api: { root: 'api', startCommand: 'npm run start' } } };
+        const run = async (prebuilt) => {
+            await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+            await writeFiles(dir, files);
+            const runner = new runner_1.AppRunner(app, { dir, mode: 'production', env: { PATH: process.env.PATH, HOME: process.env.HOME }, prebuilt, ...FAST });
+            await runner.start();
+            for (let waited = 0; waited < 100 && runner.status().phase !== 'running'; waited++)
+                await new Promise((resolve) => setTimeout(resolve, 100));
+            const answer = { phase: runner.status().phase, prestarted: await exists('api/prestarted'), started: await exists('api/started') };
+            await runner.stop();
+            return answer;
+        };
+        strict_1.default.deepEqual(await run(true), { phase: 'running', prestarted: false, started: true });
+        strict_1.default.deepEqual(await run(false), { phase: 'running', prestarted: true, started: true });
+    });
+    (0, node_test_1.it)('stop ends a build that is running', async () => {
+        const slow = { services: { web: { root: 'slow', buildCommand: 'node -e "setTimeout(() => {}, 60000)"', outputDirectory: '.' } } };
+        await writeFiles(dir, { 'slow/index.html': '' });
+        const runner = new runner_1.AppRunner(slow, { dir, mode: 'production', env: { PATH: process.env.PATH }, ...FAST });
+        const preparing = runner.prepare();
+        await new Promise((resolve) => setTimeout(resolve, 300));
+        await runner.stop();
+        strict_1.default.equal(await preparing, false);
+    });
+});
+(0, node_test_1.describe)('app host (deployment, production mode)', () => {
+    (0, node_test_1.it)('builds once per release and serves the built output', async () => {
+        var _a, _b;
+        const dir = await node_fs_1.promises.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'builder-app-'));
+        const build = `${JSON.stringify(process.execPath)} -e "const fs=require('fs');fs.appendFileSync('builds','x');fs.mkdirSync('dist',{recursive:true});fs.writeFileSync('dist/index.html','built')"`;
+        await writeFiles(dir, { '.builder/builder.json': JSON.stringify({ services: { web: { buildCommand: build, outputDirectory: 'dist' } } }) });
+        const options = { dir, mode: 'production', env: { PATH: process.env.PATH }, buildId: 'rel1', ...FAST };
+        const first = new app_host_1.AppHost(options);
+        strict_1.default.equal((_a = (await first.start())) === null || _a === void 0 ? void 0 : _a.phase, 'running');
+        const status = await new Promise((resolve) => {
+            const res = Object.assign(new node_http_1.default.ServerResponse(new node_http_1.default.IncomingMessage(new node_net_1.default.Socket())), {
+                end(body) {
+                    resolve(body);
+                    return this;
+                },
+            });
+            first.handleRequest(Object.assign(new node_http_1.default.IncomingMessage(new node_net_1.default.Socket()), { url: protocol_1.APP_STATUS_PATH }), res);
+        });
+        strict_1.default.equal(JSON.parse(status).app.phase, 'running');
+        await first.stop();
+        // Restarted on the same disk: the marker skips the build.
+        const second = new app_host_1.AppHost(options);
+        strict_1.default.equal((_b = (await second.start())) === null || _b === void 0 ? void 0 : _b.phase, 'running');
+        strict_1.default.equal(await node_fs_1.promises.readFile(node_path_1.default.join(dir, 'builds'), 'utf8'), 'x');
+        await second.stop();
+        await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+    });
+});
+(0, node_test_1.describe)('a request nothing should be able to answer badly', () => {
+    const request = (url) => Object.assign(new node_http_1.default.IncomingMessage(new node_net_1.default.Socket()), { url, method: 'GET', headers: {} });
+    (0, node_test_1.it)('never takes the host down: a bad path fails the request, not the guest', async () => {
+        const host = new app_host_1.AppHost({ dir: '/nonexistent', mode: 'production', env: {} });
+        host.current = { phase: 'running', processes: [] };
+        for (const url of ['//', '///', '//[', '//foo:bar']) {
+            const res = new node_http_1.default.ServerResponse(request(url));
+            strict_1.default.doesNotThrow(() => host.handleRequest(request(url), res), url);
+            const socket = new node_net_1.default.Socket();
+            strict_1.default.doesNotThrow(() => host.handleUpgrade(request(url), socket, Buffer.alloc(0)), url);
+            socket.destroy();
+        }
+    });
+    (0, node_test_1.it)('fails only that request when a handler throws anyway', () => {
+        const boom = () => {
+            throw new Error('boom');
+        };
+        const logged = console.error;
+        console.error = () => undefined;
+        try {
+            const req = request('/');
+            const res = new node_http_1.default.ServerResponse(req);
+            strict_1.default.doesNotThrow(() => (0, preview_proxy_1.guardRequests)(boom)(req, res));
+            strict_1.default.equal(res.statusCode, 500);
+            strict_1.default.equal(res.writableEnded, true);
+            const socket = new node_net_1.default.Socket();
+            strict_1.default.doesNotThrow(() => (0, preview_proxy_1.guardUpgrades)(boom)(req, socket, Buffer.alloc(0)));
+            strict_1.default.equal(socket.destroyed, true);
+        }
+        finally {
+            console.error = logged;
+        }
+    });
+});
+//# sourceMappingURL=app-host.test.js.map