@stage-labs/metro 0.1.0-beta.65 → 0.1.0-beta.67

package/dist/cli.js

@@ -7,6 +7,7 @@ import { bedrock } from './bedrock.js';
 import { installPlugin } from './plugin.js';
 import { update } from './update.js';
 import { serve } from './serve.js';
+import { service } from './service.js';
 import { currentVersion } from './version.js';
 const USAGE = `metro — run your agent on this machine
 
@@ -16,8 +17,13 @@ const USAGE = `metro — run your agent on this machine
                   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 one wallet that may sign in, needed on
-                  the first start only
-  metro stop      stop the metro daemon on this machine
+                  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 <address>]
+                  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; 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 [agent]
@@ -64,6 +70,7 @@ const COMMANDS = {
         return 0;
     },
     serve: () => serve(process.argv.slice(3)),
+    service: () => service(process.argv.slice(3)),
     stop: stopDaemon,
     tail: () => tailEvents(process.argv.slice(3)),
     mcp: async () => {

package/dist/hold.js

@@ -0,0 +1,197 @@
+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));
+}
+export 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,
+            project: 'localdaemon',
+            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 = (server) => new Promise((resolve) => {
+    server.close(() => {
+        resolve();
+    });
+    server.closeAllConnections();
+});
+function releaseLock(lockFile) {
+    try {
+        if (readFileSync(lockFile, 'utf8').trim() === String(process.pid))
+            rmSync(lockFile, { force: true });
+    }
+    catch {
+        return;
+    }
+}
+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;
+    const ended = new Promise((resolve) => {
+        finish = resolve;
+    });
+    const server = holdServer(info, () => {
+        finish('start');
+    });
+    const onSignal = () => {
+        finish('exit');
+    };
+    if (info.lockFile !== null)
+        writeFileSync(info.lockFile, String(process.pid));
+    await listen(server, info);
+    const funnel = info.funnel === null ? null : new HeldFunnel(info.funnel, info.port, log);
+    funnel?.start();
+    signals.on('SIGINT', onSignal);
+    signals.on('SIGTERM', onSignal);
+    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;
+}

package/dist/runtime.js

@@ -32,6 +32,7 @@ export function findBun() {
 export const localPort = () => Number(process.env.METRO_WEBHOOK_PORT) || 8420;
 export const localUrl = () => `http://127.0.0.1:${String(localPort())}`;
 export const RESTART_CODE = 75;
+export const HOLD_CODE = 76;
 function spawnOnce(plan) {
     const child = spawn(plan.command, plan.args, {
         cwd: plan.cwd,
@@ -53,11 +54,17 @@ function spawnOnce(plan) {
         });
     });
 }
-export async function spawnPlan(plan) {
+export async function spawnPlan(plan, hold) {
     for (;;) {
         const code = await spawnOnce(plan());
-        if (code !== RESTART_CODE)
+        if (code === RESTART_CODE) {
+            process.stderr.write('metro was updated; restarting the daemon on the new version\n');
+            continue;
+        }
+        if (code !== HOLD_CODE || hold === undefined)
             return code;
-        process.stderr.write('metro was updated; restarting the daemon on the new version\n');
+        if ((await hold()) === 'exit')
+            return 0;
+        process.stderr.write('starting the daemon again\n');
     }
 }

package/dist/serve.js

@@ -1,5 +1,5 @@
 import { spawnSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { agentsDir } from './local.js';
 import { currentVersion } from './version.js';
@@ -7,6 +7,7 @@ import { serveLockedBy, serveStateDir } from './control.js';
 import { findBun, localPort, SERVER_ENTRY, spawnPlan } from './runtime.js';
 import { prepareRuntime } from './runtime-install.js';
 import { ensureNodeName } from './node-name.js';
+import { holdUntilStart } from './hold.js';
 const SCRUBBED = new Set(['METRO_RUN_TOKEN', 'METRO_AGENT', 'DATABASE_URL']);
 const PORT_FLAG = /^--port=(.*)$/;
 const OWNER_FLAG = /^--owner=(.*)$/;
@@ -64,6 +65,25 @@ export function requireOwner(owner, dir = agentsDir()) {
         join(dir, '.owner') +
         ':\n  metro serve --owner <address>');
 }
+export function readOwner(dir = agentsDir()) {
+    try {
+        const raw = readFileSync(join(dir, '.owner'), 'utf8').trim().toLowerCase();
+        return ADDRESS.test(raw) ? raw : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function holdInfo(port, owner, tailscaleBin) {
+    return {
+        port,
+        host: process.env.METRO_HTTP_HOST ?? '127.0.0.1',
+        owner: owner ?? readOwner(),
+        version: currentVersion(),
+        funnel: tailscaleBin,
+        lockFile: join(process.env.METRO_STATE_DIR ?? serveStateDir(), '.tail-lock'),
+    };
+}
 function tailscaleStatus(bin) {
     const run = spawnSync(bin, ['status', '--json'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
     if (run.error !== undefined || run.status !== 0)
@@ -123,5 +143,5 @@ export function serve(argv) {
     const tailscaleBin = findTailscale();
     const node = ensureNodeName(tailscaleBin);
     process.stderr.write(`Starting a metro daemon of your own on http://127.0.0.1:${String(port)}, published as ${node} on your tailnet\n`);
-    return spawnPlan(() => servePlan({ runtime: prepareRuntime(), port, owner, tailscaleBin }));
+    return spawnPlan(() => servePlan({ runtime: prepareRuntime(), port, owner, tailscaleBin }), () => holdUntilStart(holdInfo(port, owner, tailscaleBin)));
 }

package/dist/service.js

@@ -0,0 +1,224 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir, platform, userInfo } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { serveLockedBy } from './control.js';
+import { findBun } from './runtime.js';
+import { findTailscale, parseServeArgs, requireOwner } from './serve.js';
+const USAGE = 'usage: metro service install [--port <n>] [--owner <address>] | uninstall | status';
+const SERVICE = 'metro';
+const LABEL = 'box.metro.serve';
+const CARRIED = /^(METRO_.*|XDG_CACHE_HOME|PATH|HOME)$/;
+const PLAIN_WORD = /^[A-Za-z0-9_/.:=+@,-]+$/;
+const carriedEnv = (env) => Object.entries(env)
+    .filter((entry) => CARRIED.test(entry[0]) && typeof entry[1] === 'string' && entry[1] !== '')
+    .sort(([a], [b]) => a.localeCompare(b));
+const cacheDir = (host) => {
+    const xdg = host.env.XDG_CACHE_HOME?.trim();
+    return xdg === undefined || xdg === '' ? join(host.home, '.cache') : xdg;
+};
+function unitWord(arg) {
+    const escaped = arg.replaceAll('%', '%%');
+    if (PLAIN_WORD.test(arg))
+        return escaped;
+    return `"${escaped.replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`;
+}
+export function systemdUnit(host, exec, target) {
+    const env = carriedEnv(host.env).map(([key, value]) => `Environment=${unitWord(`${key}=${value}`)}`);
+    return [
+        '[Unit]',
+        'Description=Metro daemon (metro serve)',
+        'After=network-online.target tailscaled.service',
+        'Wants=network-online.target',
+        '',
+        '[Service]',
+        `ExecStart=${exec.map(unitWord).join(' ')}`,
+        'Restart=always',
+        'RestartSec=2',
+        `WorkingDirectory=${unitWord(host.home)}`,
+        ...env,
+        '',
+        '[Install]',
+        `WantedBy=${target}`,
+        '',
+    ].join('\n');
+}
+const xml = (text) => text
+    .replaceAll('&', '&amp;')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&apos;');
+export function launchdPlist(host, exec, logFile) {
+    const env = carriedEnv(host.env).map(([key, value]) => `    <key>${xml(key)}</key><string>${xml(value)}</string>`);
+    return [
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
+        '<plist version="1.0">',
+        '<dict>',
+        `  <key>Label</key><string>${LABEL}</string>`,
+        '  <key>ProgramArguments</key>',
+        '  <array>',
+        ...exec.map((arg) => `    <string>${xml(arg)}</string>`),
+        '  </array>',
+        '  <key>EnvironmentVariables</key>',
+        '  <dict>',
+        ...env,
+        '  </dict>',
+        `  <key>WorkingDirectory</key><string>${xml(host.home)}</string>`,
+        '  <key>RunAtLoad</key><true/>',
+        '  <key>KeepAlive</key><true/>',
+        `  <key>StandardOutPath</key><string>${xml(logFile)}</string>`,
+        `  <key>StandardErrorPath</key><string>${xml(logFile)}</string>`,
+        '</dict>',
+        '</plist>',
+        '',
+    ].join('\n');
+}
+function systemdPlan(host, exec) {
+    const system = host.uid === 0;
+    const ctl = system ? ['systemctl'] : ['systemctl', '--user'];
+    const file = system
+        ? `/etc/systemd/system/${SERVICE}.service`
+        : join(host.home, '.config', 'systemd', 'user', `${SERVICE}.service`);
+    return {
+        kind: 'systemd',
+        file,
+        content: systemdUnit(host, exec, system ? 'multi-user.target' : 'default.target'),
+        dirs: [],
+        install: [{ args: [...ctl, 'daemon-reload'] }, { args: [...ctl, 'enable', '--now', SERVICE] }],
+        uninstall: [{ args: [...ctl, 'disable', '--now', SERVICE], mayFail: true }],
+        reload: [{ args: [...ctl, 'daemon-reload'], mayFail: true }],
+        status: { args: [...ctl, 'is-active', SERVICE], mayFail: true },
+        hints: [
+            `Logs:  journalctl ${system ? '' : '--user '}-u ${SERVICE} -f`,
+            ...(system
+                ? []
+                : [`A user service stops with your login session; keep it up without one:  loginctl enable-linger ${host.user}`]),
+        ],
+    };
+}
+function launchdPlan(host, exec) {
+    const file = join(host.home, 'Library', 'LaunchAgents', `${LABEL}.plist`);
+    const domain = `gui/${String(host.uid)}`;
+    const logFile = join(cacheDir(host), 'metro', 'serve', 'service.log');
+    return {
+        kind: 'launchd',
+        file,
+        content: launchdPlist(host, exec, logFile),
+        dirs: [dirname(logFile)],
+        install: [
+            { args: ['launchctl', 'bootout', `${domain}/${LABEL}`], mayFail: true },
+            { args: ['launchctl', 'bootstrap', domain, file] },
+        ],
+        uninstall: [{ args: ['launchctl', 'bootout', `${domain}/${LABEL}`], mayFail: true }],
+        reload: [],
+        status: { args: ['launchctl', 'print', `${domain}/${LABEL}`], mayFail: true },
+        hints: [`Logs:  tail -f ${logFile}`],
+    };
+}
+export function servicePlan(host, serveArgs) {
+    const exec = [host.node, host.cli, 'serve', ...serveArgs];
+    if (host.platform === 'linux')
+        return systemdPlan(host, exec);
+    if (host.platform === 'darwin')
+        return launchdPlan(host, exec);
+    throw new Error(`metro service supports Linux (systemd) and macOS (launchd), not ${host.platform}`);
+}
+function install(serveArgs, deps) {
+    const { owner } = parseServeArgs(serveArgs);
+    deps.preflight(owner);
+    const pid = deps.running();
+    if (pid !== null)
+        throw new Error(`a metro serve is running on this machine (pid ${String(pid)}). Stop it first (metro stop), then install: the service takes over from there`);
+    const plan = servicePlan(deps.host, serveArgs);
+    for (const dir of plan.dirs)
+        deps.mkdir(dir);
+    deps.write(plan.file, plan.content);
+    for (const command of plan.install)
+        deps.run(command);
+    deps.out(`Installed ${plan.file}: metro serve now starts at boot and after a crash, and the Server page on metro.box can stop, start and restart it.`);
+    for (const hint of plan.hints)
+        deps.out(hint);
+    return 0;
+}
+function uninstall(deps) {
+    const plan = servicePlan(deps.host, []);
+    if (!deps.exists(plan.file)) {
+        deps.out('metro is not installed as a service on this machine');
+        return 1;
+    }
+    for (const command of plan.uninstall)
+        deps.run(command);
+    deps.remove(plan.file);
+    for (const command of plan.reload)
+        deps.run(command);
+    deps.out(`Removed ${plan.file}; a running daemon was stopped, and metro serve no longer starts on its own`);
+    return 0;
+}
+function status(deps) {
+    const plan = servicePlan(deps.host, []);
+    if (!deps.exists(plan.file)) {
+        deps.out(`not installed (metro service install writes ${plan.file})`);
+        return 1;
+    }
+    const active = deps.run(plan.status).status === 0;
+    deps.out(active
+        ? `running as a ${plan.kind} service (${plan.file})`
+        : `installed as a ${plan.kind} service (${plan.file}), not running`);
+    return active ? 0 : 1;
+}
+function realDeps() {
+    const who = userInfo();
+    return {
+        host: {
+            platform: platform(),
+            uid: who.uid,
+            user: who.username,
+            home: homedir(),
+            node: process.execPath,
+            cli: resolve(process.argv[1] ?? ''),
+            env: process.env,
+        },
+        run: (command) => {
+            const [bin = '', ...args] = command.args;
+            const result = spawnSync(bin, args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+            const code = result.status ?? 1;
+            if (code !== 0 && command.mayFail !== true) {
+                const said = [result.stderr, result.stdout, result.error?.message].find((t) => typeof t === 'string' && t.trim() !== '') ?? '';
+                throw new Error(`${command.args.join(' ')} failed (exit ${String(code)}): ${said.trim()}`);
+            }
+            return { status: code, output: `${result.stdout}${result.stderr}` };
+        },
+        running: serveLockedBy,
+        preflight: (owner) => {
+            requireOwner(owner);
+            findBun();
+            findTailscale();
+        },
+        mkdir: (dir) => {
+            mkdirSync(dir, { recursive: true });
+        },
+        write: (file, content) => {
+            mkdirSync(dirname(file), { recursive: true });
+            writeFileSync(file, content, { mode: 0o644 });
+        },
+        remove: (file) => {
+            rmSync(file, { force: true });
+        },
+        exists: existsSync,
+        out: (line) => {
+            process.stderr.write(`${line}\n`);
+        },
+    };
+}
+export function service(argv, deps = realDeps()) {
+    const [verb, ...rest] = argv;
+    if (verb === 'install')
+        return Promise.resolve(install(rest, deps));
+    if (verb === 'uninstall' && rest.length === 0)
+        return Promise.resolve(uninstall(deps));
+    if (verb === 'status' && rest.length === 0)
+        return Promise.resolve(status(deps));
+    throw new Error(USAGE);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.65",
+  "version": "0.1.0-beta.67",
   "description": "The metro command line. Sign in once per machine, then hand your MCP connector list to Claude Code without the credentials touching disk, argv or shell history.",
   "license": "MIT",
   "repository": {

package/runtime/node_modules/@metro-labs/mcp/src/daemon/boot.ts

@@ -111,6 +111,10 @@ async function sessionApis(): Promise<SessionApis> {
         exitCode = RESTART_EXIT;
         onShutdown();
       },
+      stop: () => {
+        exitCode = HOLD_EXIT;
+        onShutdown();
+      },
       closeAgentSession,
       gatherAccounts: gatherAccountsForAgents,
       capabilities: accountStationCapabilities,
@@ -162,6 +166,7 @@ async function main(): Promise<void> {
 
 const SHUTDOWN_TIMEOUT_MS = 3_000;
 const RESTART_EXIT = 75;
+const HOLD_EXIT = 76;
 let exitCode = 0;
 let shuttingDown = false;
 async function shutdown(): Promise<void> {

package/runtime/node_modules/@metro-labs/mcp/src/daemon/control-api.ts

@@ -0,0 +1,64 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { ApiError } from './api-error.js';
+import { apiFailure, apiSession, cors, sendJson } from './api-http.js';
+import { errMsg, log } from './log.js';
+
+const STOP = '/api/stop';
+const RESTART = '/api/restart';
+const EXIT_DELAY_MS = 500;
+
+export interface ControlApiDeps {
+  authorize: (subject: string) => void;
+  restart: () => void;
+  stop: () => void;
+  served?: () => boolean;
+}
+
+interface Action {
+  run: () => void;
+  body: Record<string, boolean>;
+}
+
+const servedByCli = (): boolean => (process.env.METRO_CLI_BIN?.trim() ?? '') !== '';
+
+function actionFor(path: string, deps: ControlApiDeps): Action | null {
+  if (path === STOP) return { run: deps.stop, body: { stopping: true } };
+  if (path === RESTART) return { run: deps.restart, body: { restarting: true } };
+  return null;
+}
+
+export function handleControlRequest(req: IncomingMessage, res: ServerResponse, deps: ControlApiDeps): boolean {
+  const path = (req.url ?? '').split('?')[0] ?? '';
+  const action = actionFor(path, deps);
+  if (action === null) return false;
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204, cors(req)).end();
+    return true;
+  }
+  if (req.method !== 'POST') {
+    sendJson(req, res, 405, { error: 'method not allowed' });
+    return true;
+  }
+  Promise.resolve()
+    .then(async () => {
+      const session = await apiSession(req);
+      if (!session) throw new ApiError('unauthorized', 401);
+      deps.authorize(session.subject);
+      if (!(deps.served ?? servedByCli)())
+        throw new ApiError(
+          'this daemon was not started by metro serve, so nothing on the machine would bring it back: use the shell instead',
+          400,
+        );
+      log.info({ path, subject: session.subject }, 'control-api: requested from the page');
+      setTimeout(action.run, EXIT_DELAY_MS).unref();
+      sendJson(req, res, 200, action.body);
+    })
+    .catch((err: unknown) => {
+      if (err instanceof ApiError) apiFailure(req, res, err, 'control-api');
+      else {
+        log.warn({ err: errMsg(err) }, 'control-api: request failed');
+        if (!res.headersSent) sendJson(req, res, 500, { error: 'control api failed' });
+      }
+    });
+  return true;
+}

package/runtime/node_modules/@metro-labs/mcp/src/daemon/local-mode.ts

@@ -52,6 +52,7 @@ import type { StationName } from '../db/stations.js';
 export interface LocalModeDeps {
   syncStations: (station: StationName) => Promise<void>;
   restart: () => void;
+  stop: () => void;
   closeAgentSession: (id: string) => Promise<boolean>;
   gatherAccounts: AgentApiDeps['gatherAccounts'];
   capabilities: AgentApiDeps['capabilities'];
@@ -190,6 +191,7 @@ export function localSessionApis(deps: LocalModeDeps): SessionApis {
     localCli,
     claudeApi: { authorize: (subject) => { assertLocalOwner(subject); } },
     updateApi: { authorize: (subject) => { assertLocalOwner(subject); }, restart: deps.restart },
+    controlApi: { authorize: (subject) => { assertLocalOwner(subject); }, restart: deps.restart, stop: deps.stop },
     machineApi: { authorize: (subject) => { assertLocalOwner(subject); } },
     terminalApi: { authorize: (subject) => { assertLocalOwner(subject); } },
     identity: { owner: localOwner },

package/runtime/node_modules/@metro-labs/mcp/src/daemon/session-apis.ts

@@ -18,6 +18,7 @@ import { handleVaultApiRequest, type VaultApiDeps } from './vault-api.js';
 import { handleServersApiRequest, type ServersApiDeps } from './servers-api.js';
 import { handleBundleRequest, type BundleApiDeps } from './bundle-api.js';
 import { handleUpdateRequest, type UpdateApiDeps } from './update-api.js';
+import { handleControlRequest, type ControlApiDeps } from './control-api.js';
 import { handleMachineRequest, type MachineApiDeps } from './machine-api.js';
 import { handleTerminalRequest, type TerminalApiDeps } from './terminal-api.js';
 
@@ -28,6 +29,7 @@ export interface SessionApis {
   vaultApi?: VaultApiDeps;
   serversApi?: ServersApiDeps;
   updateApi?: UpdateApiDeps;
+  controlApi?: ControlApiDeps;
   machineApi?: MachineApiDeps;
   terminalApi?: TerminalApiDeps;
   localCli?: LocalCliDeps;
@@ -54,6 +56,7 @@ export function handleSessionApis(
     ...when(apis.vaultApi, (d) => handleVaultApiRequest(req, res, d)),
     ...when(apis.serversApi, (d) => handleServersApiRequest(req, res, d)),
     ...when(apis.updateApi, (d) => handleUpdateRequest(req, res, d)),
+    ...when(apis.controlApi, (d) => handleControlRequest(req, res, d)),
     ...when(apis.machineApi, (d) => handleMachineRequest(req, res, d)),
     ...when(apis.terminalApi, (d) => handleTerminalRequest(req, res, d)),
     ...when(apis.claudeApi, (d) => handleClaudeRequest(req, res, d)),

package/runtime/node_modules/@metro-labs/mcp/src/daemon/terminal-ws.ts

@@ -1,3 +1,4 @@
+import { spawn } from 'node:child_process';
 import type { IncomingMessage, Server } from 'node:http';
 import type { Duplex } from 'node:stream';
 import { WebSocketServer, type RawData, type WebSocket } from 'ws';
@@ -19,10 +20,28 @@ export interface TerminalSocketDeps {
 const rawBytes = (data: RawData): Buffer =>
   Buffer.isBuffer(data) ? data : Array.isArray(data) ? Buffer.concat(data) : Buffer.from(data);
 
+export const resizeWindowArgs = (session: string, cols: number, rows: number): string[] => [
+  'resize-window',
+  '-t',
+  `${session}:`,
+  '-x',
+  String(cols),
+  '-y',
+  String(rows),
+];
+
+function sizeTmuxWindow(command: string[], session: string, cols: number, rows: number): void {
+  if (command[0] !== 'tmux') return;
+  const child = spawn('tmux', resizeWindowArgs(session, cols, rows), { stdio: 'ignore' });
+  child.on('error', (err) => {
+    log.debug({ err: errMsg(err) }, 'terminal: resize-window failed');
+  });
+}
+
 const dimension = (raw: unknown, fallback: number): number =>
   typeof raw === 'number' && Number.isInteger(raw) && raw > 1 && raw <= MAX_DIMENSION ? raw : fallback;
 
-function runTerminal(ws: WebSocket, command: string[], subject: string): void {
+function runTerminal(ws: WebSocket, command: string[], subject: string, session: string): void {
   const terminal = new Bun.Terminal({
     cols: DEFAULT_COLS,
     rows: DEFAULT_ROWS,
@@ -43,8 +62,12 @@ function runTerminal(ws: WebSocket, command: string[], subject: string): void {
     }
     try {
       const control: unknown = JSON.parse(bytes.toString('utf8'));
-      if (isRecord(control) && 'cols' in control)
-        terminal.resize(dimension(control.cols, DEFAULT_COLS), dimension(control.rows, DEFAULT_ROWS));
+      if (isRecord(control) && 'cols' in control) {
+        const cols = dimension(control.cols, DEFAULT_COLS);
+        const rows = dimension(control.rows, DEFAULT_ROWS);
+        terminal.resize(cols, rows);
+        sizeTmuxWindow(command, session, cols, rows);
+      }
     } catch (err) {
       log.warn({ err: errMsg(err) }, 'terminal: bad control frame');
     }
@@ -85,7 +108,7 @@ export function attachTerminalSockets(server: Server, deps: TerminalSocketDeps):
       return;
     }
     wss.handleUpgrade(req, socket, head, (ws) => {
-      runTerminal(ws, deps.command(grant.session), grant.subject);
+      runTerminal(ws, deps.command(grant.session), grant.subject, grant.session);
     });
   });
 }

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.65"
+  "version": "0.1.0-beta.67"
 }