@stage-labs/metro 0.1.0-beta.31 → 0.1.0-beta.310

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

@@ -0,0 +1,120 @@
+import { ApiError } from '@metro-labs/http/api-error';
+import { isRecord } from '@metro-labs/core/is-record';
+import { log } from '@metro-labs/core/log';
+import type { ToolGroup } from '@metro-labs/core/stations/types';
+
+export type Access = 'allow' | 'ask' | 'deny';
+
+const ACCESS: readonly Access[] = ['allow', 'ask', 'deny'];
+
+export interface ToolPolicy {
+  read?: Access;
+  write?: Access;
+  tools?: Record<string, Access>;
+}
+
+export interface PolicyTarget {
+  kind: 'channel';
+  station: string;
+  account: string;
+}
+
+export interface PolicyTool {
+  name: string;
+  group: ToolGroup;
+}
+
+const TOOL_NAME_RE = /^[A-Za-z0-9_.-]{1,128}$/;
+const MAX_TOOLS = 500;
+const RANK: Record<Access, number> = { allow: 0, ask: 1, deny: 2 };
+
+const isAccess = (value: unknown): value is Access => typeof value === 'string' && (ACCESS as readonly string[]).includes(value);
+
+export const targetKey = (target: PolicyTarget): string => `channel:${target.station}/${target.account}`;
+
+export function decide(policy: ToolPolicy | undefined, tool: PolicyTool): Access {
+  const byTool = policy?.tools !== undefined && Object.hasOwn(policy.tools, tool.name) ? policy.tools[tool.name] : undefined;
+  return byTool ?? policy?.[tool.group] ?? 'allow';
+}
+
+export function strictest(list: readonly Access[]): Access {
+  return list.reduce<Access>((worst, a) => (RANK[a] > RANK[worst] ? a : worst), 'allow');
+}
+
+function tolerantTools(raw: unknown, where: string): Record<string, Access> | undefined {
+  const kept: Record<string, Access> = {};
+  for (const [name, value] of Object.entries(isRecord(raw) ? raw : {})) {
+    if (TOOL_NAME_RE.test(name) && isAccess(value)) kept[name] = value;
+    else log.warn({ where, tool: name }, 'policy: a tool entry is not valid, ignored');
+  }
+  return Object.keys(kept).length > 0 ? kept : undefined;
+}
+
+export function parsePolicy(raw: unknown, where: string): ToolPolicy | undefined {
+  if (raw === undefined || raw === null) return undefined;
+  if (!isRecord(raw)) {
+    log.warn({ where }, 'policy: not an object, ignored');
+    return undefined;
+  }
+  const out: ToolPolicy = {};
+  for (const group of ['read', 'write'] as const) {
+    const value = raw[group];
+    if (isAccess(value)) out[group] = value;
+    else if (value !== undefined) log.warn({ where, group, value }, 'policy: a group value is not allow, ask or deny, ignored');
+  }
+  const tools = tolerantTools(raw.tools, where);
+  if (tools !== undefined) out.tools = tools;
+  return out;
+}
+
+function strictAccess(value: unknown, what: string): Access | undefined {
+  if (value === undefined || value === null) return undefined;
+  if (!isAccess(value)) throw new ApiError(`${what} must be allow, ask or deny`, 400);
+  return value;
+}
+
+function strictTools(raw: unknown): Record<string, Access> | undefined {
+  if (raw === undefined || raw === null) return undefined;
+  if (!isRecord(raw)) throw new ApiError('policy.tools must be an object', 400);
+  const entries = Object.entries(raw);
+  if (entries.length > MAX_TOOLS) throw new ApiError(`policy.tools holds at most ${String(MAX_TOOLS)} tools`, 400);
+  const tools: Record<string, Access> = {};
+  for (const [name, value] of entries) {
+    if (!TOOL_NAME_RE.test(name)) throw new ApiError(`'${name}' is not a tool name`, 400);
+    const access = strictAccess(value, name);
+    if (access !== undefined) tools[name] = access;
+  }
+  return Object.keys(tools).length > 0 ? tools : undefined;
+}
+
+export function normalizePolicy(raw: unknown): ToolPolicy {
+  if (!isRecord(raw)) throw new ApiError('policy must be an object', 400);
+  const read = strictAccess(raw.read, 'read');
+  const write = strictAccess(raw.write, 'write');
+  const tools = strictTools(raw.tools);
+  return {
+    ...(read === undefined ? {} : { read }),
+    ...(write === undefined ? {} : { write }),
+    ...(tools === undefined ? {} : { tools }),
+  };
+}
+
+const stored = new Map<string, { target: PolicyTarget; policy: ToolPolicy }>();
+const listeners = new Set<() => void>();
+
+export function onPoliciesChanged(listener: () => void): () => void {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+
+export function setPolicies(kind: PolicyTarget['kind'], entries: readonly (readonly [PolicyTarget, ToolPolicy])[]): void {
+  for (const key of [...stored.keys()]) if (key.startsWith(`${kind}:`)) stored.delete(key);
+  for (const [target, policy] of entries) if (target.kind === kind) stored.set(targetKey(target), { target, policy });
+  for (const listener of listeners) listener();
+}
+
+export const storedPolicies = (): { target: PolicyTarget; policy: ToolPolicy }[] => [...stored.values()];
+
+export const storedPolicy = (target: PolicyTarget): ToolPolicy | undefined => stored.get(targetKey(target))?.policy;
+
+export const policyFor = (target: PolicyTarget, tool: PolicyTool): Access => decide(storedPolicy(target), tool);

package/runtime/node_modules/@metro-labs/daemon/src/routes/bearer.ts

@@ -0,0 +1,35 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { ApiError } from '@metro-labs/http/api-error';
+import { setBearerSessions, type ApiSession } from '@metro-labs/http/api-http';
+import { bearerSession, clientId, jwksUrl, SigningKeys, workosBase, type KeyStore } from '@metro-labs/http/workos-token';
+import { ensureSecureDir, writeSecure } from '@metro-labs/core/secure-fs';
+
+const KEYS_FILE = '.jwks';
+
+export function jwksStore(dir: string): KeyStore {
+  const path = join(dir, KEYS_FILE);
+  return {
+    read: () => (existsSync(path) ? readFileSync(path, 'utf8') : null),
+    write: (text) => {
+      ensureSecureDir(dir);
+      writeSecure(path, text);
+    },
+  };
+}
+
+export function bearerSessionsFor(owner: () => string | null, keys: SigningKeys): (req: Parameters<typeof bearerSession>[0]) => Promise<ApiSession | null> {
+  return async (req) => {
+    const session = await bearerSession(req, keys);
+    if (session === null) return null;
+    const held = owner();
+    if (held === null || session.organization === null || session.organization !== held)
+      throw new ApiError('this machine belongs to another organization', 403);
+    return { subject: held, userId: session.userId, sessionId: session.sessionId, role: session.role === 'admin' ? 'admin' : 'member' };
+  };
+}
+
+export function installBearerSessions(dir: string, owner: () => string | null, env: NodeJS.ProcessEnv = process.env): void {
+  const keys = new SigningKeys(jwksUrl(clientId(env), workosBase(env)), jwksStore(dir));
+  setBearerSessions(bearerSessionsFor(owner, keys));
+}

package/runtime/node_modules/@metro-labs/daemon/src/routes/body.ts

@@ -0,0 +1,24 @@
+import type { IncomingMessage } from 'node:http';
+
+export const WEBHOOK_BODY_MAX = 25 * 1024 * 1024;
+
+export class BodyTooLargeError extends Error {
+  constructor(readonly limit: number) {
+    super(`request body exceeds ${limit} bytes`);
+  }
+}
+
+export async function readBody(
+  req: IncomingMessage,
+  maxBytes: number,
+): Promise<Buffer> {
+  const chunks: Buffer[] = [];
+  let total = 0;
+  for await (const c of req) {
+    const buf = c as Buffer;
+    total += buf.length;
+    if (total > maxBytes) throw new BodyTooLargeError(maxBytes);
+    chunks.push(buf);
+  }
+  return Buffer.concat(chunks);
+}

package/runtime/node_modules/@metro-labs/daemon/src/routes/gmail-attach.ts

@@ -0,0 +1,67 @@
+import { randomUUID } from 'node:crypto';
+import { ApiError } from '@metro-labs/http/api-error';
+import { stringOf } from '@metro-labs/http/api-http';
+import { publicBaseUrl } from '../files/attach-serve.js';
+import { localOwner, readLocalAgentFile, localRenewGmail } from '../agents/file-admin.js';
+import { startManagedGmail } from '../stations/attach-gmail.js';
+import { startGmail } from '../stations/attach-browser.js';
+import type { AttachOwner, StartAttach } from '../stations/attach-session.js';
+import type { AttachOutcome, DriverHooks } from '../stations/attach-driver.js';
+import { assertGmailNotDeleting } from './gmail-detach.js';
+
+export function assertAttachOwner(owner: AttachOwner): void {
+  readLocalAgentFile(owner.agentId);
+  if (owner.organization !== undefined && owner.organization !== localOwner()) throw new ApiError('This box changed organization. Start again.', 403);
+}
+
+function gmailHost(): string {
+  const raw = publicBaseUrl();
+  const url = raw === null ? null : new URL(raw);
+  if (url === null || url.protocol !== 'https:' || url.username || url.password || url.pathname !== '/' || url.search || url.hash) throw new ApiError('Managed Gmail needs this box registered in Metro with its HTTPS address.', 400);
+  return url.host;
+}
+
+interface Upgrade {
+  accountId: string;
+  previous: string;
+}
+
+function gmailInput(owner: AttachOwner, input: Record<string, unknown>): { fields: Record<string, unknown>; upgrade?: Upgrade } {
+  if (input.mode !== 'upgrade') return { fields: { ...input, sendEnabled: false } };
+  const accountId = stringOf(input.accountId);
+  assertGmailNotDeleting(owner.agentId, accountId);
+  const account = readLocalAgentFile(owner.agentId).stations.find((s) => s.station === 'gmail' && s.id === accountId);
+  if (account === undefined) throw new ApiError('No such Gmail connection.', 404);
+  if (account.config.sendEnabled !== false) throw new ApiError('Sending is already authorized for this Gmail connection.', 409);
+  return {
+    fields: { clientId: account.config.clientId, clientSecret: account.config.clientSecret, mailbox: account.config.accountEmail, sendEnabled: true, mode: account.config.managed === true ? 'managed' : 'byo' },
+    upgrade: { accountId, previous: stringOf(account.config.authorizationId ?? account.config.refreshToken) },
+  };
+}
+
+export const startGmailAttach: StartAttach = async (_station, input, hooks, owner) => {
+  assertAttachOwner(owner);
+  const { fields, upgrade } = gmailInput(owner, input);
+  const bound: DriverHooks = {
+    ...hooks,
+    done: (outcome: AttachOutcome) => {
+      hooks.done({ ...outcome, config: { ...outcome.config, authorizationId: randomUUID(), ...(upgrade === undefined ? {} : { gmailUpgrade: upgrade }) } });
+    },
+  };
+  if (fields.mode !== 'managed') return startGmail(fields, bound);
+  const host = gmailHost();
+  return startManagedGmail({ host, owner, mailbox: fields.mailbox, sendEnabled: fields.sendEnabled === true, check: () => {
+    assertAttachOwner(owner);
+    if (gmailHost() !== host) throw new ApiError('This box changed address. Start again.', 409);
+  } }, bound);
+};
+
+export function finishGmailUpgrade(owner: AttachOwner, config: Record<string, unknown>): ReturnType<typeof localRenewGmail> | null {
+  const value = config.gmailUpgrade;
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) return null;
+  const upgrade = value as Record<string, unknown>;
+  assertGmailNotDeleting(owner.agentId, stringOf(upgrade.accountId));
+  const saved = { ...config };
+  delete saved.gmailUpgrade;
+  return localRenewGmail(owner.agentId, stringOf(upgrade.accountId), stringOf(upgrade.previous), saved);
+}

package/runtime/node_modules/@metro-labs/daemon/src/routes/gmail-detach.ts

@@ -0,0 +1,37 @@
+import { ApiError } from '@metro-labs/http/api-error';
+import { localDetachAccount, localOwner, readLocalAgentFile } from '../agents/file-admin.js';
+import { forwardTrainCall } from '../stations/train-call.js';
+
+const deleting = new Set<string>();
+const keyOf = (agentId: string, accountId: string): string => `${agentId}/${accountId}`;
+
+export function assertGmailNotDeleting(agentId: string, accountId: string): void {
+  if (deleting.has(keyOf(agentId, accountId))) throw new ApiError('This Gmail connection is being deleted. Try again after it finishes.', 409);
+}
+
+async function revokeConnection(accountId: string, authorizationId: unknown): Promise<void> {
+  try {
+    const response = await forwardTrainCall('gmail', 'disconnect', { account: accountId, authorizationId });
+    const result = response.result as { revoked?: unknown } | undefined;
+    if (response.error !== undefined || result?.revoked !== true) throw new Error('revocation not confirmed');
+  } catch {
+    throw new ApiError('Google access could not be revoked. The Gmail channel was kept. Keep the Gmail service running and try deleting again.', 503);
+  }
+}
+
+export const detachWithGmailRevocation: typeof localDetachAccount = async (agentId, station, accountId, dir) => {
+  const config = station === 'gmail' ? readLocalAgentFile(agentId, dir).stations.find((a) => a.station === station && a.id === accountId)?.config : undefined;
+  if (config?.managed !== true) return localDetachAccount(agentId, station, accountId, dir);
+  assertGmailNotDeleting(agentId, accountId);
+  const key = keyOf(agentId, accountId);
+  const owner = localOwner(dir);
+  deleting.add(key);
+  try {
+    await revokeConnection(accountId, config.authorizationId);
+    const current = readLocalAgentFile(agentId, dir).stations.find((a) => a.station === station && a.id === accountId)?.config;
+    if (localOwner(dir) !== owner || current?.authorizationId !== config.authorizationId) throw new ApiError('This box or Gmail connection changed during deletion. Google access was revoked; review the connection before trying again.', 409);
+    return await localDetachAccount(agentId, station, accountId, dir);
+  } finally {
+    deleting.delete(key);
+  }
+};

package/runtime/node_modules/@metro-labs/{mcp/src/daemon → daemon/src/routes}/http.ts

@@ -1,13 +1,18 @@
 import { handleSessionApis, type SessionApis } from './session-apis.js';
-import { handleRelayRequest } from './relay.js';
+import { handleGatewayRequest } from '../gateway/gateway.js';
+import { handleThreemaCallback } from './threema-callback.js';
+import { BodyTooLargeError, readBody, WEBHOOK_BODY_MAX } from './body.js';
+
+export { BodyTooLargeError, readBody } from './body.js';
 import {
   createServer,
   type IncomingMessage,
   type Server,
   type ServerResponse,
 } from 'node:http';
-import { Line } from '../stations/lines.js';
-import { errMsg, log } from './log.js';
+import { Line } from '@metro-labs/core/lines';
+import { MCP_STATUS_PATH } from '../mcp/diagnostics.js';
+import { errMsg, log } from '@metro-labs/core/log';
 import {
   classifyEvent,
   formatDisplay,
@@ -15,30 +20,25 @@ import {
   publishEvent,
   userSelf,
   type MetroEvent,
-} from './events.js';
-import type { TrainEvent } from './protocol.js';
-import { agentForLine, agentIdForLine } from '../db/agent-map.js';
-import {
-  findEndpointByWebhookId,
-  listEndpoints,
-  tokenMatches,
-  webhookPort,
-  type Endpoint,
-} from './tunnel.js';
-import { attachmentEventUrl, handleAttachRequest } from './attach-serve.js';
+} from '@metro-labs/core/events';
+import type { TrainEvent } from '@metro-labs/core/trains/protocol';
+import { agentForLine, agentIdForLine, lineReceives } from '../agents/map.js';
+import type { Endpoint } from '@metro-labs/core/endpoints';
+import { findEndpointByWebhookId, listEndpoints, tokenMatches } from '../stations/webhook-endpoints.js';
+import { attachmentEventUrl, handleAttachRequest, webhookPort } from '../files/attach-serve.js';
 import { webhookEntry } from '@metro-labs/webhook';
-import { handleGoogleAuthRequest } from './google-oauth.js';
-import { handleUploadRequest } from './upload-api.js';
+import { attachTerminalSockets } from '../terminal/socket.js';
+import { tmuxCommand } from '../terminal/api.js';
+import { handleModeRequest } from '@metro-labs/http/mode-api';
+import { handleUploadRequest } from '../files/upload-api.js';
 import {
   handleMonitorRequest,
-  type MonitorCall,
 } from '../monitor/api.js';
-import { applyMcpCors, handleMcpPreflight } from './cors.js';
+import { applyMcpCors, handleMcpPreflight } from '@metro-labs/http/cors';
+import { METRO_VERSION } from '@metro-labs/core/version';
 
 const LRU_CAP = 2_000;
 
-const METRO_VERSION = process.env.npm_package_version ?? '0.1.0-beta.15';
-
 function dedupKey(
   e: Pick<MetroEvent, 'station' | 'line' | 'messageId'>,
 ): string | null {
@@ -107,6 +107,10 @@ type Emit = (entry: MetroEvent) => void;
 export function makeEmit(dedupSeq?: DedupSeq): Emit {
   const tracker = dedupSeq ?? makeDedupSeq();
   return function emit(entry: MetroEvent): void {
+    if (!lineReceives(entry.line)) {
+      log.debug({ line: entry.line }, 'emit: dropped, this channel does not receive messages');
+      return;
+    }
     const seq = tracker.admit(entry);
     if (seq === null) return;
     const enriched: MetroEvent = withAttachmentUrl({
@@ -126,6 +130,18 @@ function eventText(env: TrainEvent): string | undefined {
   return env.emoji ? `[react ${env.emoji}]` : undefined;
 }
 
+function addressingFacts(
+  env: TrainEvent,
+  isPrivate: boolean,
+): Pick<MetroEvent, 'isPrivate' | 'mentionsSelf' | 'replyToSelf' | 'senderVerified'> {
+  return {
+    ...(isPrivate ? { isPrivate: true } : {}),
+    ...(env.mentions_self === true ? { mentionsSelf: true } : {}),
+    ...(env.reply_to_self === true ? { replyToSelf: true } : {}),
+    ...(typeof env.sender_verified === 'boolean' ? { senderVerified: env.sender_verified } : {}),
+  };
+}
+
 export function trainEventToMetroEvent(
   env: TrainEvent,
   trainName: string,
@@ -153,6 +169,7 @@ export function trainEventToMetroEvent(
     text,
     messageId: env.message_id,
     replyTo: env.reply_to,
+    ...addressingFacts(env, isPrivate),
     payload: env.payload,
   };
 }
@@ -163,16 +180,18 @@ export async function startWebhookServer(
   emit: Emit,
   apis: SessionApis = {},
   mcp?: McpHandler,
-  monitorCall?: MonitorCall,
+  monitor = false,
 ): Promise<Server> {
   const port = webhookPort();
   const server = createServer((req, res) => {
-    handleRequest(req, res, emit, apis, mcp, monitorCall).catch(
+    handleRequest(req, res, emit, apis, mcp, monitor).catch(
       (err: unknown) => {
       log.warn({ err: errMsg(err) }, 'webhook handler error');
       if (!res.headersSent) res.writeHead(500).end();
     });
   });
+  if (apis.terminalApi !== undefined)
+    attachTerminalSockets(server, { command: apis.terminalApi.command ?? tmuxCommand });
   await new Promise<void>((resolve, reject) => {
     server.once('error', reject);
     const host = process.env.METRO_HTTP_HOST ?? '127.0.0.1';
@@ -194,30 +213,7 @@ export async function startWebhookServer(
 
 function isMcpPath(req: IncomingMessage): boolean {
   const path = (req.url ?? '').split('?')[0];
-  return path === '/' || path === '/mcp';
-}
-
-export const WEBHOOK_BODY_MAX = 25 * 1024 * 1024;
-
-export class BodyTooLargeError extends Error {
-  constructor(readonly limit: number) {
-    super(`request body exceeds ${limit} bytes`);
-  }
-}
-
-export async function readBody(
-  req: IncomingMessage,
-  maxBytes: number,
-): Promise<Buffer> {
-  const chunks: Buffer[] = [];
-  let total = 0;
-  for await (const c of req) {
-    const buf = c as Buffer;
-    total += buf.length;
-    if (total > maxBytes) throw new BodyTooLargeError(maxBytes);
-    chunks.push(buf);
-  }
-  return Buffer.concat(chunks);
+  return path === '/' || path === '/mcp' || path === MCP_STATUS_PATH;
 }
 
 function flatHeaders(req: IncomingMessage): Record<string, string> {
@@ -323,21 +319,34 @@ async function handleWebhookRoute(
   return true;
 }
 
+function handleSignInRoutes(
+  req: IncomingMessage,
+  res: ServerResponse,
+  apis: SessionApis,
+): boolean {
+  return apis.mode !== undefined && handleModeRequest(req, res, apis.mode);
+}
+
+function handleEarlyRoutes(req: IncomingMessage, res: ServerResponse, apis: SessionApis): boolean {
+  if (handleHealth(req, res)) return true;
+  if (apis.gateway !== undefined && handleGatewayRequest(req, res, apis.gateway)) return true;
+  if (handleSignInRoutes(req, res, apis)) return true;
+  return handleSessionApis(req, res, apis);
+}
+
 async function handlePreMcpRoutes(
   req: IncomingMessage,
   res: ServerResponse,
   emit: Emit,
   apis: SessionApis,
-  monitorCall?: MonitorCall,
+  monitor = false,
 ): Promise<boolean> {
-  if (handleHealth(req, res)) return true;
-  if (await handleGoogleAuthRequest(req, res)) return true;
-  if (handleSessionApis(req, res, apis)) return true;
+  if (handleEarlyRoutes(req, res, apis)) return true;
   if (handleUploadRequest(req, res)) return true;
   if (handleAttachRequest(req, res)) return true;
-  if (apis.relayApi && handleRelayRequest(req, res, apis.relayApi)) return true;
   if (await handleWebhookRoute(req, res, emit)) return true;
-  return Boolean(monitorCall && handleMonitorRequest(req, res, monitorCall));
+  if (await handleThreemaCallback(req, res)) return true;
+  return monitor && handleMonitorRequest(req, res);
 }
 
 async function handleRequest(
@@ -346,9 +355,9 @@ async function handleRequest(
   emit: Emit,
   apis: SessionApis = {},
   mcp?: McpHandler,
-  monitorCall?: MonitorCall,
+  monitor = false,
 ): Promise<void> {
-  if (await handlePreMcpRoutes(req, res, emit, apis, monitorCall)) return;
+  if (await handlePreMcpRoutes(req, res, emit, apis, monitor)) return;
   if (mcp && isMcpPath(req)) {
     applyMcpCors(req, res);
     if (handleMcpPreflight(req, res)) return;

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

@@ -0,0 +1,149 @@
+import { ApiError } from '@metro-labs/http/api-error';
+import { errMsg, log } from '@metro-labs/core/log';
+import { AttachSessions } from '../stations/attach-session.js';
+import { startInteractiveAttach } from '../stations/attach-interactive.js';
+import { assertAttachOwner, finishGmailUpgrade, startGmailAttach } from './gmail-attach.js';
+import { detachWithGmailRevocation } from './gmail-detach.js';
+import { recentSenders } from '../agents/senders.js';
+import { forwardTrainCall } from '../stations/train-call.js';
+import type { AgentApiDeps } from '../agents/api.js';
+import { ATTACHABLE, type AccountApiDeps } from '../agents/accounts-api.js';
+import type { SessionApis } from './session-apis.js';
+import type { ModeInfo } from '@metro-labs/http/mode-api';
+import { loadedAgentOf, type AgentBundle, type BundleApiDeps } from '../agents/bundle.js';
+import { METRO_VERSION } from '@metro-labs/core/version';
+import {
+  setLocalOwner,
+  localAttachAccount,
+  localSetAllowlist,
+  localSetPolicy,
+  localSetAccountEnabled,
+  localImportAgent,
+  localListAgents,
+  localOwner,
+  readLocalAgentFile,
+} from '../agents/file-admin.js';
+import { effectiveSetup } from '../gateway/effective.js';
+import type { StationName } from '@metro-labs/core/station-names';
+
+export interface LocalModeDeps {
+  syncStations: (station: StationName) => Promise<void>;
+  reloadAgents: () => Promise<void>;
+  restart: () => void;
+  stop: () => void;
+  gatherAccounts: AgentApiDeps['gatherAccounts'];
+  capabilities: AgentApiDeps['capabilities'];
+  toolGroups?: AgentApiDeps['toolGroups'];
+  prepareAccount: AccountApiDeps['prepareAccount'];
+  liveEvents?: (on: boolean) => void;
+}
+
+function attachSessions(deps: LocalModeDeps): AttachSessions {
+  return new AttachSessions({
+    authorize: (owner) => {
+      assertAttachOwner(owner);
+      return Promise.resolve();
+    },
+    start: (station, input, hooks, owner) => station === 'gmail' ? startGmailAttach(station, input, hooks, owner) : startInteractiveAttach(station, input, hooks),
+    complete: async (owner, station, config, active) => {
+      assertAttachOwner(owner);
+      if (!active()) throw new ApiError('This sign-in was cancelled or expired.', 409);
+      const ref = (station === 'gmail' ? finishGmailUpgrade(owner, config) : null) ?? await localAttachAccount(owner.agentId, station, config);
+      const activated = await deps.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 };
+    },
+  });
+}
+
+function agentApi(deps: LocalModeDeps): AgentApiDeps {
+  return {
+    attachSessions: attachSessions(deps),
+    listAgents: localListAgents,
+    gatherAccounts: deps.gatherAccounts,
+    capabilities: deps.capabilities,
+    ...(deps.toolGroups === undefined ? {} : { toolGroups: deps.toolGroups }),
+    attachable: ATTACHABLE.filter((s) => s !== 'webhook'),
+    features: ['gmail-managed'],
+    prepareAccount: deps.prepareAccount,
+    attachAccount: localAttachAccount,
+    detachAccount: detachWithGmailRevocation,
+    syncStations: deps.syncStations,
+    setAllowlist: localSetAllowlist,
+    setPolicy: localSetPolicy,
+    setAccountEnabled: localSetAccountEnabled,
+    recentSenders,
+    resolveSender: (station, accountId, query) => accountCall(station, 'resolve_sender', { account: accountId, query }),
+    accountCall,
+    reloadAgents: deps.reloadAgents,
+  };
+}
+
+function bundleApi(deps: LocalModeDeps): BundleApiDeps {
+  return {
+    bundle: (agentId) => {
+      const file = readLocalAgentFile(agentId);
+      const bundle: AgentBundle = {
+        version: 1,
+        agent: { id: file.id, name: file.name ?? '', stations: file.stations.filter((a) => a.station !== 'gmail' || a.config.managed !== true) },
+        connectors: [],
+      };
+      return Promise.resolve(bundle);
+    },
+    restore: async (bundle, mode) => {
+      const made = await localImportAgent(loadedAgentOf(bundle), undefined, mode);
+      for (const station of new Set(bundle.agent.stations.map((a) => a.station)))
+        await deps.syncStations(station).catch((err: unknown) => {
+          log.warn({ station, err: errMsg(err) }, 'restore: station reload failed, the change lands at the next boot');
+        });
+      return { id: made.id, name: made.name, stations: made.stations, connectors: 0 };
+    },
+  };
+}
+
+function localModeInfo(): ModeInfo {
+  return { mode: 'local', owner: localOwner(), version: METRO_VERSION };
+}
+
+async function accountCall(
+  station: StationName,
+  action: string,
+  args: Record<string, unknown>,
+): Promise<unknown> {
+  let response;
+  try {
+    response = await forwardTrainCall(station, action, args);
+  } catch (err) {
+    throw new ApiError(
+      `metro could not reach the ${station} train: ${errMsg(err)}`,
+      503,
+    );
+  }
+  if (response.error !== undefined) throw new ApiError(response.error, 400);
+  return response.result;
+}
+
+export function localSessionApis(deps: LocalModeDeps): SessionApis {
+  return {
+    agentApi: agentApi(deps),
+    bundleApi: bundleApi(deps),
+    enrollApi: { owner: () => localOwner() },
+    claudeApi: { liveEvents: deps.liveEvents },
+    updateApi: { restart: deps.restart },
+    controlApi: { restart: deps.restart, stop: deps.stop },
+    ownerApi: { setOwner: setLocalOwner },
+    machineApi: {},
+    modelApi: {},
+    gateway: { setup: () => effectiveSetup() },
+    terminalApi: {},
+    mode: localModeInfo,
+  };
+}