@stage-labs/metro 0.1.0-beta.50 → 0.1.0-beta.52

package/dist/tail.js

@@ -1,5 +1,5 @@
-import { runConfigKey } from './api.js';
-import { assertAgentId, localUrl, readRunToken } from './runtime.js';
+import { localAgents } from './local.js';
+import { assertAgentId, localUrl } from './runtime.js';
 const BACKOFF_MS = [1_000, 2_000, 5_000];
 const STALL_MS = 90_000;
 export const backoffAt = (attempt) => BACKOFF_MS[Math.min(attempt, BACKOFF_MS.length - 1)] ?? 5_000;
@@ -22,11 +22,10 @@ function keySource(agentId) {
         return { resolve: () => Promise.resolve(fromEnv), fixed: true };
     return {
         resolve: () => {
-            const token = readRunToken(agentId);
-            if (token === null)
-                throw new Error(`this machine is not authorized for ${agentId} — ` +
-                    `run 'metro start ${agentId}' once, or set METRO_AGENT_KEY`);
-            return runConfigKey(token);
+            const agent = localAgents().find((a) => a.id === agentId);
+            if (agent === undefined)
+                throw new Error(`no agent ${agentId} on this machine — create or restore it in the web UI of metro serve, or set METRO_AGENT_KEY`);
+            return Promise.resolve(agent.key);
         },
         fixed: false,
     };
@@ -98,7 +97,7 @@ async function settle(end, source, key, agentId, state) {
         return source.resolve();
     }
     if (end === 'unreachable')
-        note(state, `no metro daemon on ${localUrl()} — run 'metro start ${agentId}'`);
+        note(state, `no metro daemon on ${localUrl()} — run 'metro serve' (agent ${agentId})`);
     else
         note(state, 'stream ended — reconnecting');
     return key;

package/dist/update.js

@@ -9,7 +9,19 @@ export function installArgs(manager, version) {
         ? ['add', '--global', spec]
         : ['install', '--global', spec];
 }
-export async function update() {
+export const checkReport = (current, latest) => ({
+    current,
+    latest,
+    newer: latest !== '' && isNewer(latest, current),
+});
+export async function updateCheck() {
+    return checkReport(currentVersion(), await publishedVersion());
+}
+export async function update(argv = []) {
+    if (argv.includes('--check')) {
+        process.stdout.write(`${JSON.stringify(await updateCheck())}\n`);
+        return 0;
+    }
     const current = currentVersion();
     const newest = await publishedVersion();
     if (newest === '') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.50",
+  "version": "0.1.0-beta.52",
   "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/package.json

@@ -27,8 +27,7 @@
     "./stations/station-runtime": "./src/stations/station-runtime.ts",
     "./stations/account-store": "./src/stations/account-store.ts",
     "./stations/attachments": "./src/stations/attachments.ts",
-    "./stations/messaging-normalize": "./src/stations/messaging-normalize.ts",
-    "./db/whatsapp-login": "./src/db/whatsapp-login.ts"
+    "./stations/messaging-normalize": "./src/stations/messaging-normalize.ts"
   },
   "scripts": {
     "start": "bun src/server.ts",

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

@@ -1,7 +1,7 @@
 import { webhookPort } from './tunnel.js';
 import type { IncomingMessage, ServerResponse } from 'node:http';
+import { parseId } from '../db/ids.js';
 import { errMsg, log } from './log.js';
-import { publicBaseOrDefault } from './attach-serve.js';
 import {
   apiFailure,
   apiSession,
@@ -20,7 +20,6 @@ import {
   type AccountRoute,
 } from './account-api.js';
 import {
-  parseAgentId,
   type AgentSummary,
   type CreatedAgent,
   type DeletedAgent,
@@ -52,8 +51,6 @@ export interface AgentApiDeps extends AccountApiDeps {
   capabilities: () => Record<string, string[]>;
   attachable?: string[];
   liveness: () => Map<string, { connected: boolean; lastSeenAt: number }>;
-  releaseRuntime: (subject: string, agentId: string) => Promise<void>;
-  runtimes: (agentIds: string[]) => Promise<Map<string, string>>;
   connectorIds: (agentIds: string[]) => Promise<Map<string, string[]>>;
 }
 
@@ -61,7 +58,6 @@ type Routable =
   | { kind: 'collection' }
   | { kind: 'agent'; id: string }
   | { kind: 'key'; id: string }
-  | { kind: 'runtime'; id: string }
   | { kind: 'accounts'; id: string; route: AccountRoute };
 
 type Target = Routable | { kind: 'unknown' } | null;
@@ -69,8 +65,6 @@ type Target = Routable | { kind: 'unknown' } | null;
 function subTarget(id: string, rest: string[]): Target {
   if (rest.length === 0) return { kind: 'agent', id };
   if (rest.length === 1 && rest[0] === 'key') return { kind: 'key', id };
-  if (rest.length === 1 && rest[0] === 'runtime')
-    return { kind: 'runtime', id };
   if (rest[0] !== 'accounts') return { kind: 'unknown' };
   const route = accountRoute(rest.slice(1));
   return route === null ? { kind: 'unknown' } : { kind: 'accounts', id, route };
@@ -82,14 +76,10 @@ export function target(path: string): Target {
   const segments = path.slice(PREFIX.length + 1).split('/').filter(Boolean);
   const head = segments[0];
   if (head === undefined) return { kind: 'collection' };
-  const id = parseAgentId(head);
+  const id = parseId(head);
   return id === null ? { kind: 'unknown' } : subTarget(id, segments.slice(1));
 }
 
-export function mcpEndpoint(): string {
-  return `${publicBaseOrDefault()}/mcp`;
-}
-
 const localMcpEndpoint = (): string => `http://127.0.0.1:${String(webhookPort())}/mcp`;
 
 export function mcpAddCommand(key: string): string {
@@ -132,14 +122,12 @@ function livenessPayload(
 function agentPayload(
   agent: AgentSummary,
   live: Map<string, { connected: boolean; lastSeenAt: number }>,
-  runtimes: Map<string, string>,
   connectors: Map<string, string[]>,
 ): Record<string, unknown> {
   return {
     id: agent.id,
     name: agent.name,
     owned: agent.owned,
-    runtime: agent.owned ? (runtimes.get(agent.id) ?? null) : null,
     connector_ids: connectors.get(agent.id) ?? [],
     ...livenessPayload(agent, live),
     ...keyPayload(agent),
@@ -164,14 +152,9 @@ async function handleList(
   }
   const list = await deps.listAgents(session.subject, project);
   const live = deps.liveness();
-  const held = await deps.runtimes(
-    list.filter((a) => a.owned).map((a) => a.id),
-  );
   const connectors = await deps.connectorIds(list.map((a) => a.id));
   const base = {
-    subject: session.subject,
-    endpoint: mcpEndpoint(),
-    agents: list.map((a) => agentPayload(a, live, held, connectors)),
+    agents: list.map((a) => agentPayload(a, live, connectors)),
     capabilities: deps.capabilities(),
     attachable: deps.attachable ?? ATTACHABLE,
   };
@@ -185,18 +168,6 @@ async function handleList(
   sendJson(req, res, 200, { ...base, accounts, unavailable });
 }
 
-async function handleRuntime(
-  req: IncomingMessage,
-  res: ServerResponse,
-  deps: AgentApiDeps,
-  session: ApiSession,
-  id: string,
-): Promise<void> {
-  await deps.releaseRuntime(session.subject, id);
-  log.info({ agent: id }, 'agent-api: runtime released');
-  sendJson(req, res, 200, { agent: id, runtime: null });
-}
-
 async function handleCreate(
   req: IncomingMessage,
   res: ServerResponse,
@@ -268,8 +239,6 @@ async function routeAgent(
 ): Promise<void> {
   try {
     if (tgt.kind === 'key') await handleResetKey(req, res, deps, session, tgt.id);
-    else if (tgt.kind === 'runtime')
-      await handleRuntime(req, res, deps, session, tgt.id);
     else if (tgt.kind === 'agent')
       await handleDelete(req, res, deps, session, tgt.id);
     else if (req.method === 'GET') await handleList(req, res, deps, session);
@@ -283,7 +252,6 @@ const ALLOWED: Record<AgentTarget['kind'], string[]> = {
   collection: ['GET', 'POST'],
   agent: ['DELETE'],
   key: ['POST'],
-  runtime: ['DELETE'],
 };
 
 function methodAllowed(tgt: Routable, method: string | undefined): boolean {

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

@@ -10,10 +10,15 @@ import {
   type ApiSession,
 } from './api-http.js';
 import { parseId } from '../db/ids.js';
-import type { AgentConnectors } from '../db/agent-connectors.js';
 
 const PREFIX = '/api/agents';
 
+export interface AgentConnectors {
+  id: string;
+  name: string;
+  connectorIds: string[];
+}
+
 export interface AgentConnectorApiDeps {
   agentConnectors: (subject: string, agentId: string) => Promise<AgentConnectors>;
   addConnector: (
@@ -26,23 +31,17 @@ export interface AgentConnectorApiDeps {
     agentId: string,
     connectorId: string,
   ) => Promise<AgentConnectors>;
-  mintCode: (
-    subject: string,
-    agentId: string,
-  ) => Promise<{ code: string; expiresAt: number; agent: string }>;
 }
 
 type Routable =
   | { kind: 'connectors'; id: string }
-  | { kind: 'connector'; id: string; connectorId: string }
-  | { kind: 'code'; id: string };
+  | { kind: 'connector'; id: string; connectorId: string };
 
 type Target = Routable | { kind: 'unknown' } | null;
 
 const ALLOWED: Record<Routable['kind'], string[]> = {
   connectors: ['GET', 'POST'],
   connector: ['DELETE'],
-  code: ['POST'],
 };
 
 function connectorTarget(id: string, rest: string[]): Target {
@@ -61,7 +60,6 @@ export function target(path: string): Target {
   const head = segments[1];
   if (id === null || head === undefined) return null;
   if (head === 'connectors') return connectorTarget(id, segments.slice(1));
-  if (head === 'code' && segments.length === 2) return { kind: 'code', id };
   return null;
 }
 
@@ -84,18 +82,6 @@ async function handleConnectors(
   sendJson(req, res, 200, await deps.addConnector(session.subject, id, connectorId));
 }
 
-async function handleCode(
-  req: IncomingMessage,
-  res: ServerResponse,
-  deps: AgentConnectorApiDeps,
-  session: ApiSession,
-  id: string,
-): Promise<void> {
-  const minted = await deps.mintCode(session.subject, id);
-  log.info({ agent: id, subject: session.subject }, 'agent-api: minted pairing code');
-  sendJson(req, res, 201, minted);
-}
-
 async function route(
   req: IncomingMessage,
   res: ServerResponse,
@@ -105,7 +91,6 @@ async function route(
 ): Promise<void> {
   try {
     if (tgt.kind === 'connectors') await handleConnectors(req, res, deps, session, tgt.id);
-    else if (tgt.kind === 'code') await handleCode(req, res, deps, session, tgt.id);
     else
       sendJson(
         req,

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

@@ -1,13 +1,7 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import { ApiError } from './api-error.js';
 import { errMsg, log } from './log.js';
-import {
-  verifyAgentToken,
-  verifyRunToken,
-  verifySession,
-  type AgentClaims,
-  type RunClaims,
-} from './session.js';
+import { verifySession } from './session.js';
 import { extractToken } from '../mcp/request-identity.js';
 
 const BODY_MAX = 4 * 1024;
@@ -54,53 +48,9 @@ export function apiSession(req: IncomingMessage): ApiSession | null {
   }
 }
 
-export function runIdentity(req: IncomingMessage): RunClaims | null {
-  const secret = process.env.METRO_SESSION_SECRET?.trim() ?? '';
-  if (secret === '') return null;
-  const token = extractToken(req) ?? '';
-  if (token === '') return null;
-  try {
-    const claims = verifyRunToken(token, secret);
-    return { ...claims, subject: claims.subject.toLowerCase() };
-  } catch {
-    return null;
-  }
-}
-
-export interface AgentIdentity extends AgentClaims {
-  runtimeId?: string;
-}
-
-export function agentIdentity(req: IncomingMessage): AgentIdentity | null {
-  const secret = process.env.METRO_SESSION_SECRET?.trim() ?? '';
-  if (secret === '') return null;
-  const token = extractToken(req) ?? '';
-  if (token === '') return null;
-  try {
-    const { subject, agentId } = verifyAgentToken(token, secret);
-    return { subject: subject.toLowerCase(), agentId };
-  } catch {
-    const run = runIdentity(req);
-    if (run === null) return null;
-    return { subject: run.subject, agentId: run.agentId, runtimeId: run.runtimeId };
-  }
-}
-
-export type Fence = (runtimeId: string, agentId: string) => Promise<void>;
-
-const RELEASED = 'this machine no longer holds the agent';
-
-export async function assertLease(
-  who: AgentIdentity,
-  fence: Fence,
-): Promise<void> {
-  if (who.runtimeId === undefined) return;
-  try {
-    await fence(who.runtimeId, who.agentId);
-  } catch (err) {
-    if (err instanceof ApiError) throw new ApiError(RELEASED, 401);
-    throw err;
-  }
+export interface AgentIdentity {
+  subject: string;
+  agentId: string;
 }
 
 export function projectParam(req: IncomingMessage): string | null {

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

@@ -34,8 +34,7 @@ export function publicBaseUrl(): string | null {
   return currentTunnelUrl();
 }
 
-const servesLocally = (): boolean =>
-  (process.env.METRO_RUN_TOKEN?.trim() ?? '') !== '' || isLocalMode();
+const servesLocally = (): boolean => isLocalMode();
 
 const localBase = (): string | null =>
   servesLocally() ? `http://127.0.0.1:${String(webhookPort())}` : null;

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

@@ -1,4 +1,3 @@
-import type { ProjectApiDeps } from './project-api.js';
 import { join } from 'node:path';
 import { type Server } from 'node:http';
 import { userSelf } from './events.js';
@@ -19,19 +18,7 @@ import {
   startWebhookServer,
   trainEventToMetroEvent,
 } from './http.js';
-import { type RunApiDeps } from './run-api.js';
-import {
-  claimRuntime,
-  fenceRuntime,
-  runtimeLabels,
-  touchRuntime,
-} from '../db/runtimes.js';
-import {
-  blockedStationsFor,
-  mintAgentCodeForUser,
-  releaseRuntimeForUser,
-} from '../db/runtime-admin.js';
-import { loadAgentForRuntime, localAgentKey } from '../db/materialize.js';
+import { localAgentKey } from '../db/materialize.js';
 import { fileSource } from '../db/file-source.js';
 import { ensureLocalSessionSecret } from './local-secret.js';
 import { applyLocalOwner } from './local-owner.js';
@@ -51,60 +38,15 @@ import {
   stationByName,
 } from '../stations/registry.js';
 import { prepareAccount } from '../stations/attach.js';
+import { materializeFrom, reloadFrom } from '../db/materialize.js';
 import {
-  materializeFrom,
-  materializeFromDb,
-  reloadAccountsFromDb,
-  reloadFrom,
-  type ReloadedStations,
-} from '../db/materialize.js';
-import {
-  httpSource,
-  runtimeConfigFromEnv,
-  startRuntimePoller,
-} from './runtime-source.js';
-import {  createAgentForUser,  deleteAgentForUser,  listAgentsForUser,  ownedAgentOrThrow,  resetAgentKeyForUser,    type ResetAgentKey,} from '../db/agent-admin.js';
-import {
-  attachAccountToAgent,
-  detachAccountFromAgent,
-} from '../db/account-attach.js';
-import {
-  createConnectorForUser,
-  createPendingConnectorForUser,
-  deleteConnectorForUser,
-  disconnectConnectorForUser,
-  connectorNamesByIds,
-  connectorSummariesByIds,
-  getConnectorForUser,
-  listConnectorsForUser,
-  renameConnectorForUser,
-  reconnectConnectorForUser,
-  verifyConnectorForUser,
-} from '../db/connectors.js';
-import { relayTarget } from '../db/connector-relay.js';
-import {
-  addMemberForUser,
-  createProjectForUser,
-  deleteProjectForUser,
-  listMembersForUser,
-  listProjectsForUser,
-  removeMemberForUser,
-  renameProjectForUser,
-  setMemberRoleForUser,
-} from '../db/projects.js';
-import {
-  addConnectorToAgentForUser,
-  agentConnectorsForUser,
-  connectorIdsByAgent,
-  removeConnectorFromAgentForUser,
-} from '../db/agent-connectors.js';
-import type { AgentConnectorApiDeps } from './agent-connector-api.js';
+  deleteVaultForOwner,
+  getVaultForOwner,
+  listVaultForOwner,
+  putVaultForOwner,
+} from '../db/vault.js';
 import type { StationName } from '../db/schema.js';
-import { AttachSessions } from './attach-session.js';
 import { startUploadReaper } from './upload-store.js';
-import type { AgentApiDeps } from './agent-api.js';
-import type { ConnectorApiDeps } from './connector-api.js';
-import { deleteVaultForOwner, getVaultForOwner, listVaultForOwner, putVaultForOwner } from '../db/vault.js';
 
 installCrashGuard();
 acquireLock(join(STATE_DIR, '.tail-lock'));
@@ -135,19 +77,13 @@ setTrainCallBackend((train, action, args) =>
   supervisor.call(train, action, args),
 );
 
-const runtime = runtimeConfigFromEnv();
-const linkedSource = runtime === null ? null : httpSource(runtime);
-const localSource = linkedSource ?? (isLocalMode() ? fileSource : null);
-
 function announceLocalEndpoint(): void {
-  if (isLocalMode())
-    process.stderr.write(
-      `\n${tunnel === null ? localConnectHint(webhookPort(), localOwner()) : tunnelPendingHint()}`,
-    );
+  process.stderr.write(
+    `\n${tunnel === null ? localConnectHint(webhookPort(), localOwner()) : tunnelPendingHint()}`,
+  );
   const key = localAgentKey();
   if (key === null) {
-    if (isLocalMode()) log.info('no agent on this machine yet');
-    else log.warn('this agent has no key — reset it in the web UI to connect an agent');
+    log.info('no agent on this machine yet');
     return;
   }
   const url = `http://127.0.0.1:${String(webhookPort())}/mcp?token=${key}`;
@@ -156,131 +92,15 @@ function announceLocalEndpoint(): void {
   );
 }
 
-async function applyStations(removed: StationName[]): Promise<void> {
-  for (const station of removed) await supervisor.stopTrain(station);
-}
-
-async function syncLocal(): Promise<void> {
-  if (localSource === null) return;
-  const { removed, changed } = await reloadFrom(localSource);
-  await applyStations(removed);
-  for (const station of changed) supervisor.requestReload(station);
-}
-
-async function stopLocalStations(): Promise<void> {
-  for (const station of supervisor.running()) await supervisor.stopTrain(station);
-}
-
-const reloadStations = (): Promise<ReloadedStations> =>
-  localSource === null ? reloadAccountsFromDb() : reloadFrom(localSource);
-
 async function syncStations(station: StationName): Promise<void> {
-  const { removed } = await reloadStations();
+  const { removed } = await reloadFrom(fileSource);
   if (stationByName(station)?.hasTrain === false) return;
   if (removed.includes(station)) await supervisor.stopTrain(station);
   else supervisor.requestReload(station);
 }
 
-const attachSessions = new AttachSessions({
-  authorize: async (owner) => {
-    await ownedAgentOrThrow(owner.subject, owner.agentId);
-  },
-  complete: async (owner, station, config) => {
-    const ref = await attachAccountToAgent(
-      owner.subject,
-      owner.agentId,
-      station,
-      config,
-    );
-    const activated = await syncStations(station).then(
-      () => true,
-      (err: unknown) => {
-        log.warn(
-          { station, err: errMsg(err) },
-          'attach-session: station reload failed, the change lands at the next boot',
-        );
-        return false;
-      },
-    );
-    return { accountId: ref.accountId, activated };
-  },
-});
-
-async function resetAgentKey(
-  subject: string,
-  id: string,
-): Promise<ResetAgentKey> {
-  const reset = await resetAgentKeyForUser(subject, id);
-  const closed = await closeAgentSession(id);
-  log.info(
-    { agent: reset.name, id: reset.id, sessionClosed: closed },
-    'agent-api: key rotated, live session dropped',
-  );
-  return reset;
-}
-
-const agentApi: AgentApiDeps = {
-  attachSessions,
-  listAgents: listAgentsForUser,
-  createAgent: createAgentForUser,
-  deleteAgent: deleteAgentForUser,
-  resetKey: resetAgentKey,
-  gatherAccounts: gatherAccountsForAgents,
-  capabilities: accountStationCapabilities,
-  liveness: agentLiveness,
-  releaseRuntime: releaseRuntimeForUser,
-  connectorIds: connectorIdsByAgent,
-  runtimes: runtimeLabels,
-  prepareAccount,
-  attachAccount: attachAccountToAgent,
-  detachAccount: detachAccountFromAgent,
-  syncStations,
-};
-
-const runApi: RunApiDeps = {
-  claimRuntime,
-  fenceRuntime,
-  touchRuntime,
-  loadAgent: loadAgentForRuntime,
-  blockedStations: blockedStationsFor,
-};
-
-const agentConnectorApi: AgentConnectorApiDeps = {
-  agentConnectors: agentConnectorsForUser,
-  addConnector: addConnectorToAgentForUser,
-  removeConnector: removeConnectorFromAgentForUser,
-  mintCode: mintAgentCodeForUser,
-};
-
-const projectApi: ProjectApiDeps = {
-  listProjects: listProjectsForUser,
-  createProject: createProjectForUser,
-  renameProject: renameProjectForUser,
-  deleteProject: deleteProjectForUser,
-  listMembers: listMembersForUser,
-  addMember: addMemberForUser,
-  setMemberRole: setMemberRoleForUser,
-  removeMember: removeMemberForUser,
-};
-
-const connectorApi: ConnectorApiDeps = {
-  listConnectors: listConnectorsForUser,
-  connectorNamesByIds,
-  connectorSummariesByIds,
-  agentConnectors: agentConnectorsForUser,
-  fenceRuntime,
-  renameConnector: renameConnectorForUser,
-  createConnector: createConnectorForUser,
-  createPendingConnector: createPendingConnectorForUser,
-  reconnectConnector: reconnectConnectorForUser,
-  getConnector: getConnectorForUser,
-  verifyConnector: verifyConnectorForUser,
-  disconnectConnector: disconnectConnectorForUser,
-  deleteConnector: deleteConnectorForUser,
-};
-
 const hostedMode = (): ModeInfo => ({
-  mode: linkedSource === null ? 'hosted' : 'linked',
+  mode: 'hosted',
   owner: null,
   project: null,
   version: METRO_VERSION,
@@ -290,6 +110,10 @@ function sessionApis(): SessionApis {
   if (isLocalMode())
     return localSessionApis({
       syncStations,
+      restart: () => {
+        exitCode = RESTART_EXIT;
+        onShutdown();
+      },
       closeAgentSession,
       gatherAccounts: gatherAccountsForAgents,
       capabilities: accountStationCapabilities,
@@ -297,13 +121,12 @@ function sessionApis(): SessionApis {
       prepareAccount,
     });
   return {
-    agentApi,
-    agentConnectorApi,
-    connectorApi,
-    projectApi,
-    runApi,
-    relayApi: { target: relayTarget, fence: fenceRuntime },
-    vaultApi: { list: listVaultForOwner, put: putVaultForOwner, get: getVaultForOwner, remove: deleteVaultForOwner },
+    vaultApi: {
+      list: listVaultForOwner,
+      put: putVaultForOwner,
+      get: getVaultForOwner,
+      remove: deleteVaultForOwner,
+    },
     mode: hostedMode,
   };
 }
@@ -312,9 +135,8 @@ async function main(): Promise<void> {
   if (isLocalMode()) {
     ensureLocalSessionSecret();
     applyLocalOwner();
+    await materializeFrom(fileSource, { allowEmpty: true });
   }
-  if (localSource === null) await materializeFromDb();
-  else await materializeFrom(localSource, { allowEmpty: linkedSource === null });
   supervisor.start();
   const metroMcp = await createMetroMcp();
   webhookServer = await startWebhookServer(
@@ -325,18 +147,18 @@ async function main(): Promise<void> {
   );
   metroMcp.startInbound();
   startUploadReaper();
-  if (linkedSource !== null)
-    startRuntimePoller({ sync: syncLocal, stopAll: stopLocalStations });
-  if (localSource !== null) announceLocalEndpoint();
+  if (isLocalMode()) announceLocalEndpoint();
   tunnel?.start();
   log.info(
-    { tunnel: !!tunnel, trainsDir: trainsDir(), mcp: '/' },
+    { tunnel: !!tunnel, trainsDir: trainsDir(), mcp: '/', version: METRO_VERSION },
     'dispatcher ready',
   );
   markDaemonReady();
 }
 
 const SHUTDOWN_TIMEOUT_MS = 3_000;
+const RESTART_EXIT = 75;
+let exitCode = 0;
 let shuttingDown = false;
 async function shutdown(): Promise<void> {
   if (shuttingDown) return;
@@ -356,9 +178,8 @@ async function shutdown(): Promise<void> {
       }),
     ]);
   }
-  await attachSessions.stop();
   await supervisor.stop();
-  process.exit(0);
+  process.exit(exitCode);
 }
 const onShutdown = (): void => {
   shutdown().catch((err: unknown) => {