@stage-labs/metro 0.1.0-beta.3 → 0.1.0-beta.300

package/dist/cli.js

@@ -1,266 +1,117 @@
 #!/usr/bin/env node
-import { spawn } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import pkg from '../package.json' with { type: 'json' };
-import * as discord from './channels/discord.js';
-import * as telegram from './channels/telegram.js';
-import { readDotenv, writeDotenv } from './lib/dotenv.js';
-import { errMsg } from './log.js';
-import { CONFIG_ENV_FILE, configuredPlatforms, loadMetroEnv, STATE_DIR } from './paths.js';
-const USAGE = `metro — Telegram + Discord bridge for your Claude Code / Codex agent
+import { whoisAuthorized } from './api.js';
+import { stopAll } from './control.js';
+import { tailEvents } from './tail.js';
+import { agentSession } from './agent.js';
+import { automationCommand } from './automation.js';
+import { launchClaude } from './claude.js';
+import { memoryPaths, memoryRoutine } from './memory.js';
+import { update } from './update.js';
+import { serve } from './serve.js';
+import { service, serviceStopHint } from './service.js';
+import { currentVersion } from './version.js';
+import { voiceSession } from './voice.js';
+const USAGE = `metro: run your agent on this machine
 
-Usage:
-  metro                                       Run the orchestrator daemon.
-                                              Each chat conversation gets its own
-                                              codex session, with streaming responses.
-  metro setup                                 Show config status (tokens).
-  metro setup telegram <token>                Save TELEGRAM_BOT_TOKEN (validated via getMe).
-  metro setup discord <token>                 Save DISCORD_BOT_TOKEN (validated via getMe).
-  metro setup clear [telegram|discord|all]    Remove tokens.
-  metro doctor                                Health check: tokens + gateway reachability.
-  metro update                                Upgrade in place (npm/bun/pnpm auto-detected).
-  metro --version, -v                         Print version.
-  metro --help, -h                            This help.
+  metro serve [--port <n>] [--owner <organization id>]
+                  run the daemon: the agent, its channels and its connectors live in
+                  ~/.metro/agents here, and it is published through Tailscale Funnel at a
+                  permanent https://<machine>.<tailnet>.ts.net (Tailscale installed and
+                  signed in on this machine); the page at metro.box manages it through the
+                  link it prints; --owner names the organization whose members may sign
+                  in, needed on the first start only; Stop on the page parks the daemon and keeps the
+                  address, so Start works from the page too
+  metro service install [--port <n>] [--owner <organization id>] [--user metro]
+                  run metro serve as a service (systemd on Linux, launchd on macOS): it
+                  starts at boot and after a crash, so the page can stop, start and
+                  restart it with no shell; on Linux, root passes --user metro so Metro
+                  runs as its own user and Claude Code as the user agent;
+                  metro service uninstall and status as well
+  metro stop      stop metro on this machine, metro serve included
+  metro tail [agent-id]
+                  follow this machine's inbound events, one JSON line each
+  metro whoami    print the agent this machine runs
+  metro claude [args...]
+                  open Claude Code with the metro channel and the metro MCP server, its
+                  inference routed through the daemon's model gateway (the Model page);
+                  every argument is passed through the same
+  metro agent     run chat, calls and background workers in one Agent SDK conversation,
+                  when the Harness runner is Agent SDK, using the Model page's model;
+                  resume it after a restart; call audio runs independently
+  metro agent --prepare [cli|sdk]
+                  check the runner before selecting it; install the SDK runtime if needed,
+                  without starting a session or connecting to chat
+  metro task submit <routine> <prompt-file> [--slot <UTC ISO timestamp>] [--dry-run]
+  metro task status [routine]
+  metro task finish <uuid> <token> completed|blocked
+                  queue work without starting a session, or read safe local task metadata;
+                  default slot is the current UTC hour; use --slot for other cadences;
+                  accepted is saved, not executed; finish awaits runner verification;
+                  --dry-run writes nothing; local authorization is not fresh owner approval
+  metro memory [skill file]
+                  run the memory routine once: when Claude Code transcripts changed since
+                  the last run, Claude Code reads the memory skill (or the file given) and
+                  files them into its memory, with no metro tools and writes only inside
+                  the memory folder
+  metro voice --model <model>
+                  the agent's side of a voice call, which the daemon starts when a call
+                  comes in: Claude Code reads the call's words as stream-json on stdin and
+                  streams its replies on stdout, with the agent's memory, skills, plugin,
+                  connectors and metro tools (on /mcp/voice, so the chat session keeps its
+                  slot) but no metro channel; tool approvals come back on stdout
+  metro update    update to the newest published version (--check only reports)
+  metro version   print this CLI's version
 
-Exit codes:
-  0 success · 1 usage · 2 config (no tokens — run \`metro setup\`) · 3 upstream
+  METRO_WEBHOOK_PORT the daemon's port (default 8420)
+  METRO_AGENTS_DIR   where the agents live (default ~/.metro/agents)
+  METRO_AGENT_KEY    the key metro tail presents, instead of the agent file's
+  METRO_RUNTIME_DIR  run the daemon from this directory instead of the bundled one
 `;
-function exitErr(msg, code) { return Object.assign(new Error(msg), { code }); }
-function parseArgs(argv) {
-    const positional = [];
-    const flags = {};
-    for (let i = 0; i < argv.length; i++) {
-        const a = argv[i];
-        if (!a.startsWith('--')) {
-            positional.push(a);
-            continue;
-        }
-        const eq = a.indexOf('=');
-        if (eq !== -1) {
-            flags[a.slice(2, eq)] = a.slice(eq + 1);
-            continue;
-        }
-        const key = a.slice(2);
-        const next = argv[i + 1];
-        if (next !== undefined && !next.startsWith('--')) {
-            flags[key] = next;
-            i++;
-        }
-        else
-            flags[key] = true;
-    }
-    return { positional, flags };
-}
-const isJson = (f) => f.json === true;
-const emitResult = (f, human, structured) => {
-    process.stdout.write(isJson(f) ? JSON.stringify(structured) + '\n' : human + '\n');
-};
-function maskToken(t) {
-    if (!t)
-        return '';
-    if (t.length <= 8)
-        return '••••';
-    return `${t.slice(0, 6)}…${t.slice(-2)}`;
-}
-const TOKEN_KEYS = { telegram: 'TELEGRAM_BOT_TOKEN', discord: 'DISCORD_BOT_TOKEN' };
-async function cmdSetup(positional, flags) {
-    const [sub, value] = positional;
-    if (!sub)
-        return cmdSetupStatus(flags);
-    if (sub === 'telegram' || sub === 'discord') {
-        if (!value)
-            throw new Error(`metro setup ${sub} <token> — token is required`);
-        const trimmed = value.trim();
-        let identity;
-        if (!flags['no-validate']) {
-            process.env[TOKEN_KEYS[sub]] = trimmed;
-            try {
-                identity = sub === 'telegram' ? `@${(await telegram.getMe()).username}` : (await discord.getMe()).username;
-            }
-            catch (err) {
-                delete process.env[TOKEN_KEYS[sub]];
-                throw exitErr(`token rejected by ${sub}: ${errMsg(err)} (use --no-validate to save anyway)`, 3);
-            }
-        }
-        const env = readDotenv(CONFIG_ENV_FILE);
-        env[TOKEN_KEYS[sub]] = trimmed;
-        writeDotenv(CONFIG_ENV_FILE, env);
-        const human = identity
-            ? `saved ${TOKEN_KEYS[sub]} (verified as ${identity}) to ${CONFIG_ENV_FILE} (chmod 0600)`
-            : `saved ${TOKEN_KEYS[sub]} to ${CONFIG_ENV_FILE} (chmod 0600)`;
-        emitResult(flags, human, { ok: true, saved: TOKEN_KEYS[sub], verified_as: identity ?? null });
-        return;
-    }
-    if (sub === 'clear') {
-        const target = value ?? 'all';
-        const env = readDotenv(CONFIG_ENV_FILE);
-        if (target === 'all') {
-            delete env.TELEGRAM_BOT_TOKEN;
-            delete env.DISCORD_BOT_TOKEN;
-        }
-        else if (target === 'telegram' || target === 'discord')
-            delete env[TOKEN_KEYS[target]];
-        else
-            throw new Error(`metro setup clear <telegram|discord|all> — got '${target}'`);
-        writeDotenv(CONFIG_ENV_FILE, env);
-        emitResult(flags, `cleared ${target === 'all' ? 'all metro tokens' : TOKEN_KEYS[target]}`, { ok: true, cleared: target });
-        return;
-    }
-    throw new Error(`unknown setup subcommand '${sub}' (try: telegram, discord, clear)`);
-}
-async function cmdSetupStatus(flags) {
-    loadMetroEnv();
-    const tg = process.env.TELEGRAM_BOT_TOKEN ?? '';
-    const dc = process.env.DISCORD_BOT_TOKEN ?? '';
-    if (isJson(flags)) {
-        process.stdout.write(JSON.stringify({
-            version: pkg.version,
-            config_env_file: CONFIG_ENV_FILE,
-            tokens: {
-                telegram: { set: !!tg, masked: maskToken(tg) },
-                discord: { set: !!dc, masked: maskToken(dc) },
-            },
-        }) + '\n');
-        return;
-    }
-    process.stdout.write(`metro ${pkg.version}\n\n` +
-        `config:  ${CONFIG_ENV_FILE}${existsSync(CONFIG_ENV_FILE) ? '' : ' (not yet written)'}\n\n` +
-        `  TELEGRAM_BOT_TOKEN  ${tg ? `set (${maskToken(tg)})` : 'not set'}\n` +
-        `  DISCORD_BOT_TOKEN   ${dc ? `set (${maskToken(dc)})` : 'not set'}\n\n`);
-    if (!tg && !dc) {
-        process.stdout.write('Get started:\n' +
-            '  1. metro setup telegram <token>    # https://t.me/BotFather\n' +
-            '     metro setup discord <token>     # https://discord.com/developers/applications\n' +
-            '  2. metro doctor                    # verify\n' +
-            '  3. metro                           # run the orchestrator\n');
-    }
-    else {
-        process.stdout.write('Run `metro` to start the orchestrator, or `metro doctor` to verify.\n');
-    }
-}
-async function cmdDoctor(flags) {
-    loadMetroEnv();
-    const checks = [];
-    const cfg = configuredPlatforms();
-    checks.push({
-        name: 'tokens',
-        ok: cfg.telegram || cfg.discord,
-        detail: cfg.telegram || cfg.discord
-            ? `loaded from ${existsSync(CONFIG_ENV_FILE) ? CONFIG_ENV_FILE : 'process env'}`
-            : 'no platform configured — run `metro setup telegram|discord <token>`',
-    });
-    for (const [platform, getMe] of [['telegram', telegram.getMe], ['discord', discord.getMe]]) {
-        if (!cfg[platform]) {
-            checks.push({ name: platform, ok: null, detail: 'not configured' });
-            continue;
-        }
-        try {
-            const me = await getMe();
-            checks.push({ name: platform, ok: true, detail: `getMe → ${platform === 'telegram' ? '@' : ''}${me.username}` });
-        }
-        catch (err) {
-            checks.push({ name: platform, ok: false, detail: errMsg(err) });
-        }
-    }
-    const lockFile = join(STATE_DIR, '.tail-lock');
-    if (!existsSync(lockFile)) {
-        checks.push({ name: 'orchestrator', ok: null, detail: 'not running' });
-    }
-    else {
-        try {
-            const pid = Number(readFileSync(lockFile, 'utf8').trim());
-            if (!Number.isInteger(pid) || pid <= 0)
-                throw new Error('invalid pid');
-            process.kill(pid, 0);
-            checks.push({ name: 'orchestrator', ok: true, detail: `running (pid ${pid})` });
-        }
-        catch {
-            checks.push({ name: 'orchestrator', ok: null, detail: 'stale lockfile (will auto-reclaim on next start)' });
-        }
-    }
-    if (isJson(flags)) {
-        process.stdout.write(JSON.stringify({ checks }) + '\n');
-    }
-    else {
-        process.stdout.write('metro doctor\n\n');
-        for (const c of checks) {
-            const icon = c.ok === true ? '✓' : c.ok === false ? '✗' : '–';
-            process.stdout.write(`  ${icon} ${c.name.padEnd(15)} ${c.detail}\n`);
-        }
-        process.stdout.write('\n');
-    }
-    if (checks.some(c => c.ok === false))
-        throw exitErr('one or more checks failed', 3);
-}
-async function cmdUpdate(flags) {
-    const tag = pkg.version.includes('-') ? 'beta' : 'latest';
-    const res = await fetch('https://registry.npmjs.org/@stage-labs/metro', { signal: AbortSignal.timeout(15_000) });
-    if (!res.ok)
-        throw new Error(`npm registry: ${res.status}`);
-    const data = (await res.json());
-    const latest = data['dist-tags']?.[tag];
-    if (!latest)
-        throw new Error(`no '${tag}' dist-tag for @stage-labs/metro`);
-    if (latest === pkg.version) {
-        emitResult(flags, `already on ${pkg.version} (latest ${tag})`, { ok: true, current: pkg.version, latest, upgraded: false });
-        return;
-    }
-    const argv1 = process.argv[1] ?? '';
-    const spec = `@stage-labs/metro@${tag}`;
-    const argv = argv1.includes('/.bun/') || argv1.includes('\\bun\\') ? ['bun', 'add', '-g', spec]
-        : argv1.includes('/pnpm/') || argv1.includes('\\pnpm\\') ? ['pnpm', 'add', '-g', spec]
-            : ['npm', 'install', '-g', spec];
-    if (isJson(flags)) {
-        process.stdout.write(JSON.stringify({ ok: true, current: pkg.version, latest, command: argv.join(' ') }) + '\n');
-    }
-    else {
-        process.stdout.write(`metro ${pkg.version} → ${latest}\n$ ${argv.join(' ')}\n`);
-    }
-    await new Promise((resolve, reject) => {
-        const child = spawn(argv[0], argv.slice(1), { stdio: isJson(flags) ? 'ignore' : 'inherit' });
-        child.on('exit', code => (code === 0 ? resolve() : reject(new Error(`${argv[0]} exited ${code}`))));
-        child.on('error', reject);
-    });
+async function stopDaemon() {
+    const stopped = await stopAll();
+    if (stopped.length === 0) {
+        process.stderr.write('no metro daemon is running on this machine\n');
+        return 1;
+    }
+    for (const d of stopped)
+        process.stderr.write(`Stopped metro (pid ${String(d.pid)}, via ${d.via})\n`);
+    const hint = serviceStopHint();
+    if (hint !== null)
+        process.stderr.write(`${hint}\n`);
+    return 0;
 }
+const HELP = new Set([undefined, 'help', '--help', '-h']);
 const COMMANDS = {
-    setup: cmdSetup,
-    doctor: (_, f) => cmdDoctor(f),
-    update: (_, f) => cmdUpdate(f),
+    whoami: async () => {
+        const { agent, where } = await whoisAuthorized();
+        process.stdout.write(`agent ${agent} on ${where}\n`);
+        return 0;
+    },
+    serve: () => serve(process.argv.slice(3)),
+    service: () => service(process.argv.slice(3)),
+    stop: stopDaemon,
+    tail: () => tailEvents(process.argv.slice(3)),
+    claude: () => launchClaude(process.argv.slice(3)),
+    agent: () => agentSession(process.argv.slice(3)),
+    task: () => automationCommand(process.argv.slice(3)),
+    memory: () => memoryRoutine(memoryPaths(process.env, process.argv[3])),
+    voice: () => voiceSession(process.argv.slice(3)),
+    update: () => update(process.argv.slice(3)),
+    version: async () => {
+        process.stdout.write(`${currentVersion()}\n`);
+        return Promise.resolve(0);
+    },
 };
-async function main() {
-    const cmd = process.argv[2];
-    if (cmd === '--version' || cmd === '-v') {
-        process.stdout.write(`${pkg.version}\n`);
-        return;
-    }
-    if (cmd === '--help' || cmd === '-h') {
-        process.stdout.write(USAGE);
-        return;
-    }
-    // Bare `metro` runs the orchestrator (the daemon's the default).
-    if (!cmd) {
-        await import('./orchestrator.js');
-        return;
-    }
-    const handler = COMMANDS[cmd];
-    if (!handler) {
-        process.stderr.write(`unknown command '${cmd}'\n\n${USAGE}`);
-        process.exit(1);
-    }
-    const { positional, flags } = parseArgs(process.argv.slice(3));
-    try {
-        await handler(positional, flags);
-    }
-    catch (err) {
-        const code = err.code;
-        if (isJson(flags)) {
-            process.stdout.write(JSON.stringify({ ok: false, error: errMsg(err), code: code ?? 1 }) + '\n');
-        }
-        else {
-            process.stderr.write(`error: ${errMsg(err)}\n`);
-        }
-        process.exit(typeof code === 'number' ? code : 1);
-    }
+async function run(command) {
+    const handler = command === undefined ? undefined : COMMANDS[command];
+    if (handler !== undefined)
+        return handler();
+    process.stderr.write(USAGE);
+    return Promise.resolve(HELP.has(command) ? 0 : 1);
 }
-await main();
+const code = await run(process.argv[2]).catch((err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`metro: ${message}\n`);
+    return 1;
+});
+process.exit(code);

package/dist/control.js

@@ -0,0 +1,74 @@
+import { execFileSync } from 'node:child_process';
+import { readFileSync, rmSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+export function serveStateDir() {
+    const xdg = process.env.XDG_CACHE_HOME?.trim();
+    const base = xdg === undefined || xdg === '' ? join(homedir(), '.cache') : xdg;
+    return join(base, 'metro', 'serve');
+}
+const serveLockPath = () => join(serveStateDir(), '.tail-lock');
+function isAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function stopPid(pid, waitMs) {
+    process.kill(pid, 'SIGTERM');
+    const until = Date.now() + waitMs;
+    while (Date.now() < until) {
+        if (!isAlive(pid))
+            return;
+        await new Promise((r) => setTimeout(r, 100));
+    }
+    process.kill(pid, 'SIGKILL');
+}
+const lockPath = () => process.env.METRO_STATE_DIR?.trim()
+    ? join(process.env.METRO_STATE_DIR.trim(), '.tail-lock')
+    : join(homedir(), '.cache', 'metro', '.tail-lock');
+function commandOf(pid) {
+    try {
+        return execFileSync('ps', ['-o', 'command=', '-p', String(pid)], {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+    }
+    catch {
+        return '';
+    }
+}
+const looksLikeMetro = (command) => command.includes('server.ts') || command.includes('metro');
+function holderOf(lockFile) {
+    let pid;
+    try {
+        pid = Number(readFileSync(lockFile, 'utf8').trim());
+    }
+    catch {
+        return null;
+    }
+    if (!Number.isInteger(pid) || pid <= 0 || !isAlive(pid))
+        return null;
+    return looksLikeMetro(commandOf(pid)) ? pid : null;
+}
+export const lockedBy = () => holderOf(lockPath());
+export const serveLockedBy = () => holderOf(serveLockPath());
+export async function stopAll(waitMs = 10_000) {
+    const stopped = [];
+    const holder = lockedBy();
+    if (holder !== null) {
+        await stopPid(holder, waitMs);
+        rmSync(lockPath(), { force: true });
+        stopped.push({ pid: holder, via: 'the machine lock' });
+    }
+    const served = serveLockedBy();
+    if (served !== null && served !== holder) {
+        await stopPid(served, waitMs);
+        rmSync(serveLockPath(), { force: true });
+        stopped.push({ pid: served, via: 'metro serve' });
+    }
+    return stopped;
+}

package/dist/hold.js

@@ -0,0 +1,210 @@
+import { spawn } from 'node:child_process';
+import { readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { createServer } from 'node:http';
+const FUNNEL_RETRY_MS = 2_000;
+const FUNNEL_EXIT_WAIT_MS = 5_000;
+const LISTEN_ATTEMPTS = 10;
+const LISTEN_RETRY_MS = 500;
+const STOPPED = 503;
+export const STOPPED_MESSAGE = 'metro is stopped on this machine. Start it from the Server page on metro.box, or run metro serve.';
+const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+function corsHeaders(req) {
+    return {
+        'access-control-allow-origin': req.headers.origin ?? '*',
+        'access-control-allow-methods': 'GET, POST, PUT, DELETE, OPTIONS',
+        'access-control-allow-headers': 'Authorization, Content-Type',
+        'access-control-allow-private-network': 'true',
+        'access-control-max-age': '86400',
+        vary: 'Origin',
+    };
+}
+function sendJson(req, res, status, body) {
+    res.writeHead(status, {
+        'content-type': 'application/json',
+        'cache-control': 'no-store',
+        ...corsHeaders(req),
+    });
+    res.end(JSON.stringify(body));
+}
+function holdRequest(req, res, info, onStart) {
+    const path = (req.url ?? '').split('?')[0] ?? '';
+    if (req.method === 'OPTIONS') {
+        res.writeHead(204, corsHeaders(req)).end();
+        return;
+    }
+    if (path === '/api/mode' && req.method === 'GET') {
+        sendJson(req, res, 200, {
+            mode: 'local',
+            owner: info.owner,
+            version: info.version,
+            stopped: true,
+        });
+        return;
+    }
+    if (path === '/api/start') {
+        if (req.method !== 'POST') {
+            sendJson(req, res, 405, { error: 'method not allowed' });
+            return;
+        }
+        sendJson(req, res, 200, { starting: true });
+        onStart();
+        return;
+    }
+    if (path === '/health' || path === '/healthz') {
+        sendJson(req, res, STOPPED, { status: 'stopped', version: info.version });
+        return;
+    }
+    sendJson(req, res, STOPPED, { error: STOPPED_MESSAGE, stopped: true });
+}
+export const holdServer = (info, onStart) => createServer((req, res) => {
+    holdRequest(req, res, info, onStart);
+});
+const lastLine = (chunk) => String(chunk).trim().split('\n').at(-1) ?? '';
+class HeldFunnel {
+    bin;
+    port;
+    log;
+    child = null;
+    closed = false;
+    timer = null;
+    exits = 0;
+    constructor(bin, port, log) {
+        this.bin = bin;
+        this.port = port;
+        this.log = log;
+    }
+    start() {
+        if (this.closed)
+            return;
+        const child = spawn(this.bin, ['funnel', String(this.port)], { stdio: ['ignore', 'pipe', 'pipe'] });
+        this.child = child;
+        let last = '';
+        const read = (chunk) => {
+            const line = lastLine(chunk);
+            if (line !== '')
+                last = line;
+        };
+        child.stdout?.on('data', read);
+        child.stderr?.on('data', read);
+        child.on('error', (err) => {
+            this.child = null;
+            this.closed = true;
+            this.log(`funnel could not start (${err.message}); the loopback address is still held`);
+        });
+        child.on('exit', () => {
+            this.child = null;
+            if (this.closed)
+                return;
+            this.exits += 1;
+            if (this.exits > 1)
+                this.log(`funnel exited (${last}); retrying in ${String(FUNNEL_RETRY_MS / 1000)}s`);
+            this.timer = setTimeout(() => {
+                this.start();
+            }, FUNNEL_RETRY_MS);
+        });
+    }
+    async stop() {
+        this.closed = true;
+        if (this.timer !== null)
+            clearTimeout(this.timer);
+        const child = this.child;
+        this.child = null;
+        if (child === null)
+            return;
+        if (child.exitCode !== null || child.signalCode !== null)
+            return;
+        await new Promise((resolve) => {
+            const kill = setTimeout(() => {
+                child.kill('SIGKILL');
+            }, FUNNEL_EXIT_WAIT_MS);
+            child.once('exit', () => {
+                clearTimeout(kill);
+                resolve();
+            });
+            child.kill('SIGINT');
+        });
+    }
+}
+async function listen(server, info) {
+    for (let attempt = 1;; attempt += 1) {
+        try {
+            await new Promise((resolve, reject) => {
+                server.once('error', reject);
+                server.listen(info.port, info.host, () => {
+                    server.off('error', reject);
+                    resolve();
+                });
+            });
+            return;
+        }
+        catch (err) {
+            if (attempt >= LISTEN_ATTEMPTS)
+                throw err;
+            await wait(LISTEN_RETRY_MS);
+        }
+    }
+}
+const CLOSE_WAIT_MS = 2_000;
+const close = (server) => new Promise((resolve) => {
+    const timer = setTimeout(resolve, CLOSE_WAIT_MS);
+    server.close(() => {
+        clearTimeout(timer);
+        resolve();
+    });
+    server.closeAllConnections();
+});
+function releaseLock(lockFile) {
+    try {
+        if (readFileSync(lockFile, 'utf8').trim() === String(process.pid))
+            rmSync(lockFile, { force: true });
+    }
+    catch {
+        return;
+    }
+}
+function armFunnel(info, log, ending) {
+    if (info.funnel === null || ending !== null)
+        return null;
+    const funnel = new HeldFunnel(info.funnel, info.port, log);
+    funnel.start();
+    return funnel;
+}
+export const holdBanner = (info) => `metro is stopped. Holding http://${info.host}:${String(info.port)}${info.funnel === null ? '' : ' and the Funnel address'} ` +
+    'until Start on the Server page; Ctrl-C or metro stop ends metro serve';
+export async function holdUntilStart(info, deps = {}) {
+    const signals = deps.signals ?? process;
+    const log = deps.log ??
+        ((line) => {
+            process.stderr.write(`${line}\n`);
+        });
+    let finish = () => undefined;
+    let ending = null;
+    const ended = new Promise((resolve) => {
+        finish = (end) => {
+            ending ??= end;
+            resolve(end);
+        };
+    });
+    const server = holdServer(info, () => {
+        finish('start');
+    });
+    const onSignal = () => {
+        finish('exit');
+    };
+    signals.on('SIGINT', onSignal);
+    signals.on('SIGTERM', onSignal);
+    if (info.lockFile !== null)
+        writeFileSync(info.lockFile, String(process.pid));
+    await listen(server, info);
+    const funnel = armFunnel(info, log, ending);
+    if (ending === null)
+        log(holdBanner(info));
+    const end = await ended;
+    signals.off('SIGINT', onSignal);
+    signals.off('SIGTERM', onSignal);
+    await funnel?.stop();
+    await close(server);
+    if (info.lockFile !== null)
+        releaseLock(info.lockFile);
+    return end;
+}