@minionry/minion 0.7.36

package/dist/server/services/apps/serve.js

@@ -0,0 +1,665 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { createReadStream, lstatSync, readdirSync, readFileSync, realpathSync, rmSync } from 'node:fs';
+import { createServer } from 'node:http';
+import { dirname, extname, join, resolve } from 'node:path';
+import { writeFileAtomic } from '../../utils/file-store.js';
+import { findAvailablePort } from '../../utils/port.js';
+import { registerLocalAppBinding, unregisterLocalAppBinding, } from '../sdk/local-app-bindings.js';
+import { isValidAppId, resolveWithinRoot } from '../sdk/sandbox.js';
+import { spacePath } from '../space-layout.js';
+import { executeGitCommand } from '../websocket/git-utils.js';
+import { errorText, getAppStatePaths, isRealDirectory } from './layout.js';
+const APP_SERVE_PORT_START = 4310;
+const MAX_BIND_ATTEMPTS = 3;
+const FULL_SHA_PATTERN = /^[0-9a-f]{40}$/;
+const NETWORK_GIT_TIMEOUT_MS = 10 * 60 * 1000;
+const LOCAL_GIT_TIMEOUT_MS = 2 * 60 * 1000;
+const UNATTENDED_GIT_ENV = { GIT_TERMINAL_PROMPT: '0', GIT_ASKPASS: '' };
+const HARDENED_GIT_CONFIG = ['-c', 'protocol.ext.allow=never', '-c', 'credential.helper='];
+const CONTENT_TYPES = {
+    '.html': 'text/html; charset=utf-8',
+    '.js': 'text/javascript; charset=utf-8',
+    '.mjs': 'text/javascript; charset=utf-8',
+    '.css': 'text/css; charset=utf-8',
+    '.json': 'application/json; charset=utf-8',
+    '.map': 'application/json; charset=utf-8',
+    '.svg': 'image/svg+xml',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.ico': 'image/x-icon',
+    '.txt': 'text/plain; charset=utf-8',
+    '.wasm': 'application/wasm',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+    '.ttf': 'font/ttf',
+};
+const records = new Map();
+const resumedSpaces = new Set();
+const resumeInFlight = new Map();
+function resolveSpace(workingDir) {
+    try {
+        return realpathSync(resolve(workingDir));
+    }
+    catch {
+        return null;
+    }
+}
+function originForPort(port) {
+    return `http://127.0.0.1:${port}`;
+}
+function gitTail(result) {
+    const text = (result.stderr || result.stdout).trim();
+    return text.length > 400 ? `…${text.slice(-400)}` : text;
+}
+function sanitizeManifest(raw) {
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
+        return undefined;
+    const m = raw;
+    if (typeof m.hash !== 'string' || m.hash === '')
+        return undefined;
+    if (!Array.isArray(m.scopes) || !m.scopes.every((s) => typeof s === 'string'))
+        return undefined;
+    if (!Array.isArray(m.optionalScopes) || !m.optionalScopes.every((s) => typeof s === 'string'))
+        return undefined;
+    return { hash: m.hash, scopes: [...m.scopes], optionalScopes: [...m.optionalScopes] };
+}
+function readServeFile(serveFile) {
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(serveFile, 'utf8'));
+    }
+    catch {
+        return {};
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+        return {};
+    const raw = parsed;
+    const shape = {};
+    if (typeof raw.port === 'number' && Number.isInteger(raw.port) && raw.port >= 1 && raw.port <= 65535) {
+        shape.port = raw.port;
+    }
+    if (typeof raw.stopped === 'boolean')
+        shape.stopped = raw.stopped;
+    if (typeof raw.commitSha === 'string' && FULL_SHA_PATTERN.test(raw.commitSha))
+        shape.commitSha = raw.commitSha;
+    if (typeof raw.repoUrl === 'string' && raw.repoUrl !== '')
+        shape.repoUrl = raw.repoUrl;
+    const manifest = sanitizeManifest(raw.manifest);
+    if (manifest)
+        shape.manifest = manifest;
+    return shape;
+}
+function writeServeFile(serveFile, shape) {
+    writeFileAtomic(serveFile, `${JSON.stringify(shape, null, 2)}\n`, { mode: 0o600 });
+}
+function refuse(res, status, message) {
+    res.writeHead(status, { 'Content-Type': 'text/plain; charset=utf-8', 'Cache-Control': 'no-store' });
+    res.end(message);
+}
+function handleAppRequest(port, buildDir, req, res) {
+    const host = (req.headers.host ?? '').trim().toLowerCase();
+    if (host !== `127.0.0.1:${port}`) {
+        refuse(res, 403, 'Forbidden: unrecognized Host header');
+        return;
+    }
+    if (req.method !== 'GET' && req.method !== 'HEAD') {
+        res.writeHead(405, { Allow: 'GET, HEAD', 'Content-Type': 'text/plain; charset=utf-8' });
+        res.end('Method not allowed');
+        return;
+    }
+    let pathname;
+    try {
+        pathname = decodeURIComponent(new URL(req.url ?? '/', originForPort(port)).pathname);
+    }
+    catch {
+        refuse(res, 400, 'Bad request');
+        return;
+    }
+    if (pathname.includes('\0')) {
+        refuse(res, 400, 'Bad request');
+        return;
+    }
+    const relative = pathname.replace(/^\/+/, '');
+    const guard = resolveWithinRoot(buildDir, relative === '' ? '.' : relative);
+    if (!guard.valid) {
+        refuse(res, 404, 'Not found');
+        return;
+    }
+    let filePath = guard.resolvedPath;
+    try {
+        if (lstatSync(filePath).isDirectory()) {
+            filePath = join(filePath, 'index.html');
+        }
+        const stat = lstatSync(filePath);
+        if (!stat.isFile()) {
+            refuse(res, 404, 'Not found');
+            return;
+        }
+        res.writeHead(200, {
+            'Content-Type': CONTENT_TYPES[extname(filePath).toLowerCase()] ?? 'application/octet-stream',
+            'Content-Length': stat.size,
+            'Cache-Control': 'no-store',
+            'X-Content-Type-Options': 'nosniff',
+        });
+        if (req.method === 'HEAD') {
+            res.end();
+            return;
+        }
+        const stream = createReadStream(filePath);
+        stream.on('error', () => res.destroy());
+        stream.pipe(res);
+    }
+    catch {
+        refuse(res, 404, 'Not found');
+        return;
+    }
+}
+function bindLoopbackServer(port, buildDir) {
+    return new Promise((resolvePromise, rejectPromise) => {
+        const server = createServer((req, res) => {
+            try {
+                handleAppRequest(port, buildDir, req, res);
+            }
+            catch (err) {
+                console.error('[apps/serve] request handler failed:', err);
+                try {
+                    refuse(res, 500, 'Internal error');
+                }
+                catch {   }
+            }
+        });
+        const onError = (err) => {
+            server.close();
+            if (err.code === 'EADDRINUSE') {
+                resolvePromise('occupied');
+            }
+            else {
+                rejectPromise(err);
+            }
+        };
+        server.once('error', onError);
+        server.listen(port, '127.0.0.1', () => {
+            server.removeListener('error', onError);
+            server.unref();
+            resolvePromise(server);
+        });
+    });
+}
+function closeServer(server) {
+    try {
+        server.close();
+        server.closeAllConnections?.();
+    }
+    catch {   }
+}
+function toEntry(record) {
+    const entry = { appId: record.appId, state: record.state };
+    if (record.port !== undefined)
+        entry.port = record.port;
+    if (record.server && record.port !== undefined)
+        entry.origin = originForPort(record.port);
+    if (record.commitSha !== undefined)
+        entry.commitSha = record.commitSha;
+    if (record.state === 'error' && record.error !== undefined)
+        entry.error = record.error;
+    return entry;
+}
+function isInstalledOnDisk(paths) {
+    return isRealDirectory(paths.srcDir) || isRealDirectory(paths.buildDir);
+}
+export async function startAppServe(request) {
+    let paths;
+    try {
+        paths = getAppStatePaths(request.workingDir, request.appId);
+    }
+    catch (err) {
+        return { ok: false, code: 'BAD_REQUEST', error: errorText(err) };
+    }
+    if (!isRealDirectory(paths.buildDir)) {
+        return { ok: false, code: 'BAD_REQUEST', error: `nothing to serve for '${request.appId}': no build/ output — the build step (IS-029) must land first` };
+    }
+    const existing = records.get(paths.root);
+    if (existing?.server && existing.port !== undefined) {
+        try {
+            registerLocalAppBinding({ port: existing.port, appId: request.appId, manifest: request.manifest, source: 'workshop' });
+        }
+        catch (err) {
+            return { ok: false, code: 'INTERNAL', error: `failed to refresh the port binding: ${errorText(err)}` };
+        }
+        existing.state = 'running';
+        existing.commitSha = request.commitSha;
+        existing.repoUrl = request.repoUrl;
+        existing.manifest = request.manifest;
+        existing.error = undefined;
+        writeServeFile(paths.serveFile, {
+            port: existing.port,
+            stopped: false,
+            commitSha: request.commitSha,
+            repoUrl: request.repoUrl,
+            manifest: request.manifest,
+        });
+        return { ok: true, entry: toEntry(existing) };
+    }
+    const record = {
+        appId: request.appId,
+        root: paths.root,
+        state: 'starting',
+        commitSha: request.commitSha,
+        repoUrl: request.repoUrl,
+        manifest: request.manifest,
+    };
+    records.set(paths.root, record);
+    const persisted = readServeFile(paths.serveFile);
+    try {
+        let server = 'occupied';
+        let port = persisted.port ?? (await findAvailablePort(APP_SERVE_PORT_START));
+        for (let attempt = 0; attempt < MAX_BIND_ATTEMPTS && server === 'occupied'; attempt++) {
+            if (attempt > 0) {
+                port = await findAvailablePort(APP_SERVE_PORT_START);
+            }
+            server = await bindLoopbackServer(port, paths.buildDir);
+        }
+        if (server === 'occupied') {
+            throw new Error(`could not bind a loopback port after ${MAX_BIND_ATTEMPTS} attempts`);
+        }
+        try {
+            registerLocalAppBinding({ port, appId: request.appId, manifest: request.manifest, source: 'workshop' });
+        }
+        catch (err) {
+            closeServer(server);
+            throw err;
+        }
+        record.server = server;
+        record.port = port;
+        record.state = 'running';
+        record.error = undefined;
+        writeServeFile(paths.serveFile, {
+            port,
+            stopped: false,
+            commitSha: request.commitSha,
+            repoUrl: request.repoUrl,
+            manifest: request.manifest,
+        });
+        return { ok: true, entry: toEntry(record) };
+    }
+    catch (err) {
+        record.state = 'error';
+        record.error = `failed to serve '${request.appId}': ${errorText(err)}`;
+        return { ok: false, code: 'INTERNAL', error: record.error };
+    }
+}
+export async function stopAppServe(workingDir, appId) {
+    let paths;
+    try {
+        paths = getAppStatePaths(workingDir, appId);
+    }
+    catch (err) {
+        return { ok: false, code: 'BAD_REQUEST', error: errorText(err) };
+    }
+    const record = records.get(paths.root);
+    if (!record && !isInstalledOnDisk(paths)) {
+        return { ok: false, code: 'BAD_REQUEST', error: `no installed app '${appId}' in this Space — nothing to stop` };
+    }
+    if (record?.server) {
+        closeServer(record.server);
+        record.server = undefined;
+        if (record.port !== undefined)
+            unregisterLocalAppBinding(record.port);
+    }
+    if (record) {
+        record.state = 'stopped';
+        record.error = undefined;
+    }
+    else {
+        records.set(paths.root, { appId, root: paths.root, state: 'stopped', ...readSteadyStateHints(paths) });
+    }
+    try {
+        const persisted = readServeFile(paths.serveFile);
+        writeServeFile(paths.serveFile, { ...persisted, stopped: true });
+    }
+    catch (err) {
+        return { ok: false, code: 'INTERNAL', error: `stopped, but failed to persist the stop: ${errorText(err)}` };
+    }
+    return { ok: true };
+}
+function readSteadyStateHints(paths) {
+    const persisted = readServeFile(paths.serveFile);
+    const hints = {};
+    if (persisted.port !== undefined)
+        hints.port = persisted.port;
+    if (persisted.commitSha !== undefined)
+        hints.commitSha = persisted.commitSha;
+    return hints;
+}
+export function markAppPipelineState(workingDir, appId, state) {
+    let paths;
+    try {
+        paths = getAppStatePaths(workingDir, appId);
+    }
+    catch {
+        return;
+    }
+    const record = records.get(paths.root);
+    if (record) {
+        record.state = state;
+        record.error = undefined;
+    }
+    else {
+        records.set(paths.root, { appId, root: paths.root, state, ...readSteadyStateHints(paths) });
+    }
+}
+export function markAppErrorState(workingDir, appId, error) {
+    let paths;
+    try {
+        paths = getAppStatePaths(workingDir, appId);
+    }
+    catch {
+        return;
+    }
+    const record = records.get(paths.root);
+    if (!isInstalledOnDisk(paths) && !record?.server) {
+        records.delete(paths.root);
+        return;
+    }
+    if (record) {
+        record.state = 'error';
+        record.error = error;
+    }
+    else {
+        records.set(paths.root, { appId, root: paths.root, state: 'error', error, ...readSteadyStateHints(paths) });
+    }
+}
+export function settleAppSteadyState(workingDir, appId) {
+    let paths;
+    try {
+        paths = getAppStatePaths(workingDir, appId);
+    }
+    catch {
+        return;
+    }
+    const record = records.get(paths.root);
+    if (record?.server) {
+        record.state = 'running';
+        record.error = undefined;
+        return;
+    }
+    if (!isInstalledOnDisk(paths)) {
+        records.delete(paths.root);
+        return;
+    }
+    if (record) {
+        record.state = 'stopped';
+        record.error = undefined;
+    }
+}
+export function isAppServing(workingDir, appId) {
+    try {
+        return records.get(getAppStatePaths(workingDir, appId).root)?.server !== undefined;
+    }
+    catch {
+        return false;
+    }
+}
+export function getStoredBindingManifest(workingDir, appId) {
+    let paths;
+    try {
+        paths = getAppStatePaths(workingDir, appId);
+    }
+    catch {
+        return null;
+    }
+    return records.get(paths.root)?.manifest ?? readServeFile(paths.serveFile).manifest ?? null;
+}
+export function persistServedCommitSha(workingDir, appId, commitSha) {
+    let paths;
+    try {
+        paths = getAppStatePaths(workingDir, appId);
+    }
+    catch {
+        return;
+    }
+    const persisted = readServeFile(paths.serveFile);
+    writeServeFile(paths.serveFile, { ...persisted, commitSha });
+    const record = records.get(paths.root);
+    if (record)
+        record.commitSha = commitSha;
+}
+export function getServeRoster(workingDir) {
+    const space = resolveSpace(workingDir);
+    if (!space)
+        return { apps: [] };
+    const appsDir = spacePath(space, 'apps');
+    const entries = new Map();
+    let names = [];
+    try {
+        names = readdirSync(appsDir, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory() && isValidAppId(entry.name))
+            .map((entry) => entry.name);
+    }
+    catch {
+    }
+    for (const appId of names) {
+        const root = join(appsDir, appId);
+        if (!isRealDirectory(join(root, 'src')) && !isRealDirectory(join(root, 'build')))
+            continue;
+        const persisted = readServeFile(join(root, 'serve.json'));
+        const entry = { appId, state: 'stopped' };
+        if (persisted.port !== undefined)
+            entry.port = persisted.port;
+        if (persisted.commitSha !== undefined)
+            entry.commitSha = persisted.commitSha;
+        entries.set(appId, entry);
+    }
+    for (const record of records.values()) {
+        if (dirname(record.root) !== appsDir)
+            continue;
+        entries.set(record.appId, toEntry(record));
+    }
+    return { apps: [...entries.values()].sort((a, b) => a.appId.localeCompare(b.appId)) };
+}
+export function resumeSpaceServes(workingDir) {
+    const space = resolveSpace(workingDir);
+    if (!space)
+        return Promise.resolve(false);
+    if (resumedSpaces.has(space))
+        return Promise.resolve(false);
+    const inflight = resumeInFlight.get(space);
+    if (inflight)
+        return inflight;
+    const pass = (async () => {
+        const appsDir = spacePath(space, 'apps');
+        let names = [];
+        try {
+            names = readdirSync(appsDir, { withFileTypes: true })
+                .filter((entry) => entry.isDirectory() && isValidAppId(entry.name))
+                .map((entry) => entry.name);
+        }
+        catch {
+            return false;
+        }
+        let resumedAny = false;
+        for (const appId of names) {
+            if (await resumeOneServe(appsDir, appId, space))
+                resumedAny = true;
+        }
+        return resumedAny;
+    })().finally(() => {
+        resumedSpaces.add(space);
+        resumeInFlight.delete(space);
+    });
+    resumeInFlight.set(space, pass);
+    return pass;
+}
+async function resumeOneServe(appsDir, appId, space) {
+    const root = join(appsDir, appId);
+    if (records.has(root))
+        return false;
+    const persisted = readServeFile(join(root, 'serve.json'));
+    if (persisted.stopped || !persisted.manifest || !persisted.commitSha || !persisted.repoUrl)
+        return false;
+    if (!isRealDirectory(join(root, 'build')))
+        return false;
+    const result = await startAppServe({
+        workingDir: space,
+        appId,
+        commitSha: persisted.commitSha,
+        repoUrl: persisted.repoUrl,
+        manifest: persisted.manifest,
+    });
+    if (!result.ok) {
+        console.error(`[apps/serve] failed to resume serve for '${appId}': ${result.error}`);
+    }
+    return result.ok;
+}
+export async function prepareAppUpdate(workingDir, appId) {
+    let paths;
+    try {
+        paths = getAppStatePaths(workingDir, appId);
+    }
+    catch (err) {
+        return { ok: false, code: 'BAD_REQUEST', error: errorText(err) };
+    }
+    if (!isRealDirectory(paths.srcDir)) {
+        return { ok: false, code: 'BAD_REQUEST', error: `no installed app '${appId}' in this Space — nothing to update` };
+    }
+    const remote = await executeGitCommand(['remote', 'get-url', 'origin'], paths.srcDir, {
+        timeoutMs: LOCAL_GIT_TIMEOUT_MS,
+        env: UNATTENDED_GIT_ENV,
+    });
+    const repoUrl = remote.stdout.trim();
+    if (remote.exitCode !== 0 || repoUrl === '') {
+        return { ok: false, code: 'INTERNAL', error: `cannot resolve the clone's origin remote: ${gitTail(remote) || 'git remote get-url failed'}` };
+    }
+    const lsRemote = await executeGitCommand([...HARDENED_GIT_CONFIG, 'ls-remote', 'origin', 'HEAD'], paths.srcDir, {
+        timeoutMs: NETWORK_GIT_TIMEOUT_MS,
+        env: UNATTENDED_GIT_ENV,
+    });
+    const remoteSha = lsRemote.stdout.match(/^([0-9a-f]{40})\tHEAD$/m)?.[1]?.toLowerCase() ?? null;
+    if (lsRemote.exitCode !== 0 || !remoteSha) {
+        return { ok: false, code: 'INTERNAL', error: `could not resolve the remote HEAD of ${repoUrl}: ${gitTail(lsRemote) || 'git ls-remote failed'}` };
+    }
+    const currentSha = await resolveCurrentSha(paths);
+    if (!currentSha) {
+        return { ok: false, code: 'INTERNAL', error: `cannot resolve the installed SHA for '${appId}'` };
+    }
+    const missing = await ensureUpdateTargetPresent(paths.srcDir, currentSha, remoteSha, repoUrl);
+    if (missing) {
+        return { ok: false, code: 'INTERNAL', error: missing };
+    }
+    return { ok: true, repoUrl, currentSha, remoteSha };
+}
+async function resolveCurrentSha(paths) {
+    const persisted = readServeFile(paths.serveFile).commitSha;
+    if (persisted)
+        return persisted;
+    const head = await executeGitCommand(['rev-parse', 'HEAD'], paths.srcDir, { timeoutMs: LOCAL_GIT_TIMEOUT_MS, env: UNATTENDED_GIT_ENV });
+    const sha = head.stdout.trim();
+    return head.exitCode === 0 && FULL_SHA_PATTERN.test(sha) ? sha : null;
+}
+async function ensureUpdateTargetPresent(srcDir, currentSha, remoteSha, repoUrl) {
+    if (remoteSha === currentSha)
+        return null;
+    const have = await executeGitCommand(['cat-file', '-e', `${remoteSha}^{commit}`], srcDir, {
+        timeoutMs: LOCAL_GIT_TIMEOUT_MS,
+        env: UNATTENDED_GIT_ENV,
+    });
+    if (have.exitCode === 0)
+        return null;
+    const fetch = await executeGitCommand([...HARDENED_GIT_CONFIG, 'fetch', '--tags', 'origin'], srcDir, {
+        timeoutMs: NETWORK_GIT_TIMEOUT_MS,
+        env: UNATTENDED_GIT_ENV,
+    });
+    if (fetch.exitCode !== 0) {
+        return `failed to fetch ${repoUrl}: ${gitTail(fetch) || 'git fetch failed'}`;
+    }
+    const haveNow = await executeGitCommand(['cat-file', '-e', `${remoteSha}^{commit}`], srcDir, {
+        timeoutMs: LOCAL_GIT_TIMEOUT_MS,
+        env: UNATTENDED_GIT_ENV,
+    });
+    if (haveNow.exitCode !== 0) {
+        return `fetched ${repoUrl}, but its HEAD ${remoteSha} is still not present locally`;
+    }
+    return null;
+}
+export async function applyAppUpdate(workingDir, appId, commitSha) {
+    let paths;
+    try {
+        paths = getAppStatePaths(workingDir, appId);
+    }
+    catch (err) {
+        return errorText(err);
+    }
+    const sha = commitSha.trim().toLowerCase();
+    if (!FULL_SHA_PATTERN.test(sha)) {
+        return `update target must be a full 40-hex commit SHA, got '${commitSha}'`;
+    }
+    const checkout = await executeGitCommand(['-c', 'advice.detachedHead=false', 'checkout', '--detach', sha], paths.srcDir, { timeoutMs: LOCAL_GIT_TIMEOUT_MS, env: UNATTENDED_GIT_ENV });
+    if (checkout.exitCode !== 0) {
+        return `failed to check out ${sha}: ${gitTail(checkout) || 'git checkout failed'}`;
+    }
+    const head = await executeGitCommand(['rev-parse', 'HEAD'], paths.srcDir, { timeoutMs: LOCAL_GIT_TIMEOUT_MS, env: UNATTENDED_GIT_ENV });
+    if (head.exitCode !== 0 || head.stdout.trim() !== sha) {
+        return `post-checkout verification failed: HEAD is '${head.stdout.trim() || 'unknown'}', expected ${sha}`;
+    }
+    return null;
+}
+export async function uninstallLocalApp(workingDir, appId) {
+    let paths;
+    try {
+        paths = getAppStatePaths(workingDir, appId);
+    }
+    catch (err) {
+        return { ok: false, code: 'BAD_REQUEST', error: errorText(err) };
+    }
+    let resolvedRoot;
+    try {
+        resolvedRoot = realpathSync(paths.root);
+    }
+    catch {
+        resolvedRoot = null;
+    }
+    if (resolvedRoot !== null && resolvedRoot !== paths.root) {
+        return {
+            ok: false,
+            code: 'INTERNAL',
+            error: `refusing to delete ${paths.root}: it resolves through a symlink to ${resolvedRoot}`,
+        };
+    }
+    const record = records.get(paths.root);
+    if (record?.server) {
+        closeServer(record.server);
+        if (record.port !== undefined)
+            unregisterLocalAppBinding(record.port);
+    }
+    records.delete(paths.root);
+    if (resolvedRoot === null)
+        return { ok: true };
+    try {
+        rmSync(paths.root, { recursive: true, force: true });
+    }
+    catch (err) {
+        return { ok: false, code: 'INTERNAL', error: `failed to remove ${paths.root}: ${errorText(err)}` };
+    }
+    return { ok: true };
+}
+export function stopAllAppServes() {
+    for (const record of records.values()) {
+        if (record.server) {
+            closeServer(record.server);
+            record.server = undefined;
+            if (record.port !== undefined)
+                unregisterLocalAppBinding(record.port);
+            record.state = 'stopped';
+        }
+    }
+}
+export function resetAppServeRegistryForTests() {
+    stopAllAppServes();
+    records.clear();
+    resumedSpaces.clear();
+    resumeInFlight.clear();
+}