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

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

@@ -10,10 +10,8 @@ import {
   readJsonBody,
   sendJson,
   type ApiSession,
-  type Fence,
 } from './api-http.js';
 import { parseId } from '../db/ids.js';
-import type { AgentConnectors } from '../db/agent-connectors.js';
 import type { RelayServerEntry } from './connector-json.js';
 import {
   handleCallback,
@@ -39,8 +37,6 @@ export interface ConnectorApiDeps extends OAuthRouteDeps {
   listConnectors: (subject: string, project: string) => Promise<Connector[]>;
   connectorSummariesByIds: (ids: string[]) => Promise<ConnectorSummary[]>;
   connectorNamesByIds: (ids: string[]) => Promise<RelayServerEntry[]>;
-  agentConnectors: (subject: string, agentId: string) => Promise<AgentConnectors>;
-  fenceRuntime: Fence;
   createConnector: (
     subject: string,
     project: string,

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

@@ -1,4 +1,3 @@
-import { hostname } from 'node:os';
 import { ApiError } from './api-error.js';
 import { errMsg, log } from './log.js';
 import { AttachSessions } from './attach-session.js';
@@ -7,10 +6,8 @@ import { ATTACHABLE, type AccountApiDeps } from './account-api.js';
 import type { AgentConnectorApiDeps } from './agent-connector-api.js';
 import type { SessionApis } from './session-apis.js';
 import type { ModeInfo } from './mode-api.js';
-import type { ImportApiDeps } from './import-api.js';
 import { loadedAgentOf, type AgentBundle, type BundleApiDeps } from './bundle-api.js';
 import { METRO_VERSION } from './version.js';
-import { fetchAgentWithCode } from './agent-import.js';
 import type { ConnectorApiDeps } from './connector-api.js';
 import { allowLocalConnectors } from './connector-url.js';
 import { keyIdentity, type LocalCliDeps } from './local-cli-api.js';
@@ -55,7 +52,7 @@ import type { StationName } from '../db/schema.js';
 
 export interface LocalModeDeps {
   syncStations: (station: StationName) => Promise<void>;
-  fetchAgent?: (code: string, label: string) => ReturnType<typeof fetchAgentWithCode>;
+  restart: () => void;
   closeAgentSession: (id: string) => Promise<boolean>;
   gatherAccounts: AgentApiDeps['gatherAccounts'];
   capabilities: AgentApiDeps['capabilities'];
@@ -63,11 +60,6 @@ export interface LocalModeDeps {
   prepareAccount: AccountApiDeps['prepareAccount'];
 }
 
-const notHere = (what: string): Promise<never> =>
-  Promise.reject(
-    new ApiError(`${what} are managed on metro.box, not on a local daemon`, 400),
-  );
-
 function attachSessions(deps: LocalModeDeps): AttachSessions {
   return new AttachSessions({
     authorize: async (owner) => {
@@ -106,8 +98,6 @@ function agentApi(deps: LocalModeDeps): AgentApiDeps {
     capabilities: deps.capabilities,
     attachable: ATTACHABLE.filter((s) => s !== 'webhook'),
     liveness: deps.liveness,
-    releaseRuntime: () => notHere('runtime leases'),
-    runtimes: () => Promise.resolve(new Map()),
     connectorIds: connectorIdsOfLocalAgents,
     prepareAccount: deps.prepareAccount,
     attachAccount: localAttachAccount,
@@ -124,16 +114,12 @@ const agentConnectorApi: AgentConnectorApiDeps = {
   agentConnectors: localAgentConnectors,
   addConnector: localAddConnector,
   removeConnector: localRemoveConnector,
-  mintCode: () =>
-    Promise.reject(new ApiError('a local daemon has no pairing codes', 400)),
 };
 
 const connectorApi: ConnectorApiDeps = {
   listConnectors: localListConnectors,
   connectorSummariesByIds: (ids) => localConnectorSummariesByIds(ids),
   connectorNamesByIds: (ids) => localConnectorNamesByIds(ids),
-  agentConnectors: localAgentConnectors,
-  fenceRuntime: () => Promise.resolve(),
   createConnector: localCreateConnector,
   verifyConnector: localVerifyConnector,
   disconnectConnector: localDisconnectConnector,
@@ -146,7 +132,6 @@ const connectorApi: ConnectorApiDeps = {
 
 const relayApi: RelayApiDeps = {
   target: (agentId, connectorId, force) => localRelayTarget(agentId, connectorId, force),
-  fence: () => Promise.resolve(),
   identify: keyIdentity,
 };
 
@@ -191,26 +176,6 @@ function bundleApi(deps: LocalModeDeps): BundleApiDeps {
   };
 }
 
-function importApi(deps: LocalModeDeps): ImportApiDeps {
-  const fetchAgent = deps.fetchAgent ?? fetchAgentWithCode;
-  return {
-    importAgent: async (subject, code) => {
-      assertLocalOwner(subject);
-      const agent = await fetchAgent(code, hostname());
-      const made = await localImportAgent(subject, agent);
-      const connectors = localImportConnectors(agent.connectors ?? []);
-      for (const station of new Set(agent.accounts.map((a) => a.station)))
-        await deps.syncStations(station).catch((err: unknown) => {
-          log.warn(
-            { station, err: errMsg(err) },
-            'import: station reload failed, the change lands at the next boot',
-          );
-        });
-      return { ...made, connectors };
-    },
-  };
-}
-
 function localModeInfo(): ModeInfo {
   return { mode: 'local', owner: localOwner(), project: LOCAL_PROJECT_ID, version: METRO_VERSION };
 }
@@ -220,12 +185,12 @@ export function localSessionApis(deps: LocalModeDeps): SessionApis {
   return {
     agentApi: agentApi(deps),
     agentConnectorApi,
-    importApi: importApi(deps),
     bundleApi: bundleApi(deps),
     connectorApi,
     relayApi,
     localCli,
     claudeApi: { authorize: (subject) => { assertLocalOwner(subject); } },
+    updateApi: { authorize: (subject) => { assertLocalOwner(subject); }, restart: deps.restart },
     siwe: { ensureUser: ownerSignIn },
     mode: localModeInfo,
   };

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

@@ -16,9 +16,6 @@ export const STATE_DIR =
   process.env.METRO_STATE_DIR ?? join(homedir(), '.cache', 'metro');
 mkdirSync(STATE_DIR, { recursive: true });
 
-export const configDir = (): string =>
-  process.env.METRO_CONFIG_DIR ??
-  join(process.env.XDG_CONFIG_HOME ?? join(homedir(), '.config'), 'metro');
 
 export function trainsDir(): string {
   const env = process.env.METRO_TRAINS_DIR?.trim();

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

@@ -1,6 +1,6 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import type { RelayTarget } from '../db/connector-relay.js';
-import { agentIdentity, assertLease, type AgentIdentity, type Fence } from './api-http.js';
+import type { AgentIdentity } from './api-http.js';
 import { ApiError } from './api-error.js';
 import { errMsg, log } from './log.js';
 
@@ -10,8 +10,7 @@ export interface RelayApiDeps {
     connectorId: string,
     force: boolean,
   ) => Promise<RelayTarget>;
-  fence: Fence;
-  identify?: (req: IncomingMessage) => AgentIdentity | null;
+  identify: (req: IncomingMessage) => AgentIdentity | null;
 }
 
 const ID_PATH_RE = /^\/relay\/([A-Za-z0-9][A-Za-z0-9_-]{10})$/;
@@ -264,13 +263,12 @@ function dispatch(
   connectorId: string,
   deps: RelayApiDeps,
 ): void {
-  const who = (deps.identify ?? agentIdentity)(req);
+  const who = deps.identify(req);
   if (who === null) {
     answer(res, 401, { error: 'unauthorized' });
     return;
   }
-  assertLease(who, deps.fence)
-    .then(() => relayExchange(req, res, who.agentId, connectorId, deps))
+  relayExchange(req, res, who.agentId, connectorId, deps)
     .catch((err: unknown) => {
       if (err instanceof ApiError) {
         answer(res, err.status, { error: err.message });

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

@@ -5,36 +5,28 @@ import {
   handleConnectorApiRequest,
   type ConnectorApiDeps,
 } from './connector-api.js';
-import { handleCliPairRequest } from './cli-pair-api.js';
-import { handleRunApiRequest, type RunApiDeps } from './run-api.js';
 import type { RelayApiDeps } from './relay.js';
-import {
-  handleProjectApiRequest,
-  type ProjectApiDeps,
-} from './project-api.js';
 import {
   handleAgentConnectorRequest,
   type AgentConnectorApiDeps,
 } from './agent-connector-api.js';
 import type { SiweRouteDeps } from './siwe-routes.js';
-import { handleImportRequest, type ImportApiDeps } from './import-api.js';
 import { handleLocalCliRequest, type LocalCliDeps } from './local-cli-api.js';
 import { handleClaudeRequest, type ClaudeApiDeps } from './claude-api.js';
 import type { ModeInfo } from './mode-api.js';
 import { handleVaultApiRequest, type VaultApiDeps } from './vault-api.js';
 import { handleBundleRequest, type BundleApiDeps } from './bundle-api.js';
+import { handleUpdateRequest, type UpdateApiDeps } from './update-api.js';
 
 export interface SessionApis {
   agentApi?: AgentApiDeps;
   agentConnectorApi?: AgentConnectorApiDeps;
-  importApi?: ImportApiDeps;
   bundleApi?: BundleApiDeps;
   vaultApi?: VaultApiDeps;
+  updateApi?: UpdateApiDeps;
   localCli?: LocalCliDeps;
   claudeApi?: ClaudeApiDeps;
   connectorApi?: ConnectorApiDeps;
-  projectApi?: ProjectApiDeps;
-  runApi?: RunApiDeps;
   relayApi?: RelayApiDeps;
   siwe?: SiweRouteDeps;
   mode?: () => ModeInfo;
@@ -51,13 +43,10 @@ export function handleSessionApis(
   const routes: (() => boolean)[] = [
     () => handleSessionApiRequest(req, res),
     ...when(apis.localCli, (d) => handleLocalCliRequest(req, res, d)),
-    ...when(apis.runApi, (d) => handleRunApiRequest(req, res, d)),
-    ...when(apis.projectApi, (d) => handleProjectApiRequest(req, res, d)),
-    ...when(apis.connectorApi, (d) => handleCliPairRequest(req, res, d)),
     ...when(apis.connectorApi, (d) => handleConnectorApiRequest(req, res, d)),
-    ...when(apis.importApi, (d) => handleImportRequest(req, res, d)),
     ...when(apis.bundleApi, (d) => handleBundleRequest(req, res, d)),
     ...when(apis.vaultApi, (d) => handleVaultApiRequest(req, res, d)),
+    ...when(apis.updateApi, (d) => handleUpdateRequest(req, res, d)),
     ...when(apis.claudeApi, (d) => handleClaudeRequest(req, res, d)),
     ...when(apis.agentConnectorApi, (d) => handleAgentConnectorRequest(req, res, d)),
     ...when(apis.agentApi, (d) => handleAgentApiRequest(req, res, d)),

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

@@ -58,17 +58,6 @@ interface SessionClaims {
   agentIds: string[];
 }
 
-export interface AgentClaims {
-  subject: string;
-  agentId: string;
-}
-
-export interface RunClaims {
-  subject: string;
-  agentId: string;
-  runtimeId: string;
-}
-
 export function signSession(
   claims: SessionClaims,
   secret: string,
@@ -105,73 +94,3 @@ export function verifySession(
     throw new SessionError('malformed session');
   return { subject: p.sub, agentIds: ids as string[] };
 }
-
-export function signAgentToken(
-  claims: AgentClaims,
-  secret: string,
-  opts: { ttlSec?: number; now?: number } = {},
-): string {
-  const iat = nowSec(opts.now);
-  return sign(
-    {
-      typ: 'agent',
-      sub: claims.subject,
-      agent: claims.agentId,
-      iat,
-      exp: iat + (opts.ttlSec ?? 30 * 24 * 3600),
-    },
-    secret,
-  );
-}
-
-export function verifyAgentToken(
-  token: string,
-  secret: string,
-  now?: number,
-): AgentClaims {
-  const p = verify(token, secret);
-  if (p.typ !== 'agent') throw new SessionError('wrong token type');
-  if (typeof p.exp !== 'number' || p.exp < nowSec(now))
-    throw new SessionError('agent token expired');
-  if (typeof p.sub !== 'string' || typeof p.agent !== 'string')
-    throw new SessionError('malformed agent token');
-  return { subject: p.sub, agentId: p.agent };
-}
-
-export function signRunToken(
-  claims: RunClaims,
-  secret: string,
-  opts: { ttlSec?: number; now?: number } = {},
-): string {
-  const iat = nowSec(opts.now);
-  return sign(
-    {
-      typ: 'run',
-      sub: claims.subject,
-      agent: claims.agentId,
-      rt: claims.runtimeId,
-      iat,
-      exp: iat + (opts.ttlSec ?? 365 * 24 * 3600),
-    },
-    secret,
-  );
-}
-
-export function verifyRunToken(
-  token: string,
-  secret: string,
-  now?: number,
-): RunClaims {
-  const p = verify(token, secret);
-  if (p.typ !== 'run') throw new SessionError('wrong token type');
-  if (typeof p.exp !== 'number' || p.exp < nowSec(now))
-    throw new SessionError('run token expired');
-  if (
-    typeof p.sub !== 'string' ||
-    typeof p.agent !== 'string' ||
-    typeof p.rt !== 'string' ||
-    !ID_RE.test(p.agent)
-  )
-    throw new SessionError('malformed run token');
-  return { subject: p.sub, agentId: p.agent, runtimeId: p.rt };
-}

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

@@ -11,7 +11,7 @@ import { mintNonce, takeNonce } from './siwe-nonces.js';
 import { verifySiweLogin } from './siwe-auth.js';
 import { signSession } from './session.js';
 import { SESSION_TTL_SEC } from './session-config.js';
-import { ensureUserWithProject } from '../db/projects.js';
+import { ensureUserByAddress } from '../db/users.js';
 
 const NONCE_PATH = '/auth/siwe/nonce';
 const VERIFY_PATH = '/auth/siwe/verify';
@@ -20,7 +20,7 @@ export interface SiweRouteDeps {
   ensureUser: (address: string) => Promise<string>;
 }
 
-const defaultDeps: SiweRouteDeps = { ensureUser: ensureUserWithProject };
+const defaultDeps: SiweRouteDeps = { ensureUser: ensureUserByAddress };
 
 async function handleVerify(
   req: IncomingMessage,

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

@@ -0,0 +1,119 @@
+import { execFile } from 'node:child_process';
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { errMsg, log } from './log.js';
+import { ApiError } from './api-error.js';
+import { apiFailure, apiSession, cors, sendJson } from './api-http.js';
+import { isRecord } from './is-record.js';
+import { METRO_VERSION } from './version.js';
+
+const PATH = '/api/update';
+const CHECK_TTL_MS = 10 * 60_000;
+const CHECK_TIMEOUT_MS = 30_000;
+const UPDATE_TIMEOUT_MS = 5 * 60_000;
+const RESTART_DELAY_MS = 500;
+const OUTPUT_TAIL = 800;
+
+export interface UpdateCheck {
+  current: string;
+  latest: string;
+  newer: boolean;
+}
+
+export interface UpdateResult {
+  updated: boolean;
+  version: string;
+  restarting: boolean;
+}
+
+export interface UpdateApiDeps {
+  authorize: (subject: string) => void;
+  restart: () => void;
+  cliBin?: () => string;
+}
+
+const cliBinFromEnv = (): string => process.env.METRO_CLI_BIN?.trim() ?? '';
+
+function runCli(bin: string, args: string[], timeout: number): Promise<{ stdout: string; stderr: string }> {
+  return new Promise((resolve, reject) => {
+    execFile(process.execPath, [bin, ...args], { timeout, maxBuffer: 4 * 1024 * 1024 }, (err, stdout, stderr) => {
+      if (err === null) resolve({ stdout, stderr });
+      else reject(new ApiError(`metro update failed: ${(stderr || err.message).trim().slice(-OUTPUT_TAIL)}`, 502));
+    });
+  });
+}
+
+let cached: { at: number; check: UpdateCheck } | null = null;
+
+function parseCheck(raw: string): UpdateCheck {
+  let body: unknown;
+  try {
+    body = JSON.parse(raw.trim().split('\n').at(-1) ?? '');
+  } catch {
+    throw new ApiError('metro update --check returned no report', 502);
+  }
+  if (!isRecord(body) || typeof body.current !== 'string' || typeof body.latest !== 'string')
+    throw new ApiError('metro update --check returned an unexpected report', 502);
+  return { current: body.current, latest: body.latest, newer: body.newer === true };
+}
+
+async function check(bin: string, now = Date.now()): Promise<UpdateCheck> {
+  if (cached !== null && now - cached.at < CHECK_TTL_MS) return cached.check;
+  const out = await runCli(bin, ['update', '--check'], CHECK_TIMEOUT_MS);
+  cached = { at: now, check: parseCheck(out.stdout) };
+  return cached.check;
+}
+
+async function apply(bin: string, deps: UpdateApiDeps): Promise<UpdateResult> {
+  const before = await check(bin);
+  if (!before.newer) return { updated: false, version: before.current, restarting: false };
+  const out = await runCli(bin, ['update'], UPDATE_TIMEOUT_MS);
+  cached = null;
+  log.info({ from: before.current, to: before.latest, output: out.stderr.trim().slice(-OUTPUT_TAIL) }, 'update-api: metro updated, restarting');
+  setTimeout(() => {
+    deps.restart();
+  }, RESTART_DELAY_MS).unref();
+  return { updated: true, version: before.latest, restarting: true };
+}
+
+function binOrThrow(deps: UpdateApiDeps): string {
+  const bin = (deps.cliBin ?? cliBinFromEnv)();
+  if (bin === '')
+    throw new ApiError('this daemon was not started by metro serve, so it cannot update itself: run metro update on the machine', 400);
+  return bin;
+}
+
+export function handleUpdateRequest(req: IncomingMessage, res: ServerResponse, deps: UpdateApiDeps): boolean {
+  const path = (req.url ?? '').split('?')[0] ?? '';
+  if (path !== PATH) return false;
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204, cors(req)).end();
+    return true;
+  }
+  if (req.method !== 'GET' && req.method !== 'POST') {
+    sendJson(req, res, 405, { error: 'method not allowed' });
+    return true;
+  }
+  const session = apiSession(req);
+  if (!session) {
+    sendJson(req, res, 401, { error: 'unauthorized' });
+    return true;
+  }
+  Promise.resolve()
+    .then(async (): Promise<unknown> => {
+      deps.authorize(session.subject);
+      const bin = binOrThrow(deps);
+      if (req.method === 'GET') return { ...(await check(bin)), running: METRO_VERSION };
+      return apply(bin, deps);
+    })
+    .then((body) => {
+      sendJson(req, res, 200, body);
+    })
+    .catch((err: unknown) => {
+      if (err instanceof ApiError) apiFailure(req, res, err, 'update-api');
+      else {
+        log.warn({ err: errMsg(err) }, 'update-api: request failed');
+        if (!res.headersSent) sendJson(req, res, 500, { error: 'update api failed' });
+      }
+    });
+  return true;
+}

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

@@ -1,11 +1,42 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import { errMsg, log } from './log.js';
-import { apiFailure, apiSession, cors, readJsonBody, sendJson, type ApiSession } from './api-http.js';
+import { verifyMessage } from 'viem';
+import { apiFailure, cors, readJsonBody, sendJson } from './api-http.js';
+import { normalizeAddress } from '../db/users.js';
 import { parseId } from '../db/ids.js';
 import { ENVELOPE_MAX, type VaultBundle, type VaultEntry } from '../db/vault.js';
 
 const PREFIX = '/api/vault';
 const BODY_MAX = ENVELOPE_MAX + 64 * 1024;
+const SKEW_MS = 5 * 60_000;
+const SIGNATURE_RE = /^0x[0-9a-fA-F]{130}$/;
+
+export const vaultChallenge = (method: string, path: string, at: number): string =>
+  `metro-vault\n${method} ${path}\n${String(at)}`;
+
+interface VaultProof {
+  address: string;
+  at: number;
+  signature: `0x${string}`;
+}
+
+function parseVaultHeader(header: string): VaultProof | null {
+  const [scheme, rawAddress, rawAt, signature] = header.trim().split(/\s+/);
+  if (scheme !== 'Vault' || rawAddress === undefined || rawAt === undefined || signature === undefined) return null;
+  const address = normalizeAddress(rawAddress);
+  const at = Number(rawAt);
+  if (address === null || !Number.isFinite(at) || !SIGNATURE_RE.test(signature)) return null;
+  return { address, at, signature: signature as `0x${string}` };
+}
+
+export async function vaultIdentity(req: IncomingMessage, now = Date.now()): Promise<string | null> {
+  const proof = parseVaultHeader(req.headers.authorization ?? '');
+  if (proof === null || Math.abs(now - proof.at) > SKEW_MS) return null;
+  const path = (req.url ?? '').split('?')[0] ?? '';
+  const message = vaultChallenge(req.method ?? '', path, proof.at);
+  const ok = await verifyMessage({ address: proof.address as `0x${string}`, message, signature: proof.signature }).catch(() => false);
+  return ok ? proof.address : null;
+}
 
 export interface VaultApiDeps {
   list: (subject: string) => Promise<VaultEntry[]>;
@@ -30,18 +61,22 @@ async function route(
   req: IncomingMessage,
   res: ServerResponse,
   deps: VaultApiDeps,
-  session: ApiSession,
   tgt: { kind: 'index' } | { kind: 'bundle'; id: string },
 ): Promise<void> {
   try {
+    const owner = await vaultIdentity(req);
+    if (owner === null) {
+      sendJson(req, res, 401, { error: 'unauthorized' });
+      return;
+    }
     if (tgt.kind === 'index') {
-      sendJson(req, res, 200, { entries: await deps.list(session.subject) });
+      sendJson(req, res, 200, { entries: await deps.list(owner) });
       return;
     }
-    if (req.method === 'GET') sendJson(req, res, 200, await deps.get(session.subject, tgt.id));
-    else if (req.method === 'DELETE') sendJson(req, res, 200, await deps.remove(session.subject, tgt.id));
+    if (req.method === 'GET') sendJson(req, res, 200, await deps.get(owner, tgt.id));
+    else if (req.method === 'DELETE') sendJson(req, res, 200, await deps.remove(owner, tgt.id));
     else {
-      const saved = await deps.put(session.subject, tgt.id, await readJsonBody(req, BODY_MAX));
+      const saved = await deps.put(owner, tgt.id, await readJsonBody(req, BODY_MAX));
       log.info({ id: saved.id, name: saved.name }, 'vault-api: bundle stored');
       sendJson(req, res, 200, saved);
     }
@@ -65,12 +100,7 @@ export function handleVaultApiRequest(req: IncomingMessage, res: ServerResponse,
     sendJson(req, res, 405, { error: 'method not allowed' });
     return true;
   }
-  const session = apiSession(req);
-  if (!session) {
-    sendJson(req, res, 401, { error: 'unauthorized' });
-    return true;
-  }
-  route(req, res, deps, session, tgt).catch((err: unknown) => {
+  route(req, res, deps, tgt).catch((err: unknown) => {
     log.warn({ err: errMsg(err) }, 'vault-api: unhandled error');
     if (!res.headersSent) sendJson(req, res, 500, { error: 'vault api failed' });
   });

package/runtime/node_modules/@metro-labs/mcp/src/db/account-attach.ts

@@ -1,12 +1,6 @@
-import { isUniqueViolation } from './users.js';
-import { and, eq, sql } from 'drizzle-orm';
-import { newId } from './ids.js';
-import { getDb } from './client.js';
-import {  AgentAdminError,    ownedAgentOrThrow,  } from './agent-admin.js';
-import { stations, STATIONS, type StationName } from './schema.js';
+import { STATIONS, type StationName } from './schema.js';
 
 const ACCOUNT_ID_RE = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/;
-const ID_ATTEMPTS = 5;
 
 export interface AccountRef {
   agentId: string;
@@ -23,69 +17,3 @@ export function isStationName(raw: unknown): raw is StationName {
 export function parseAccountId(raw: string): string | null {
   return ACCOUNT_ID_RE.test(raw) ? raw : null;
 }
-
-async function assertTokenFree(
-  station: StationName,
-  token: string,
-): Promise<void> {
-  const rows = await getDb()
-    .select({ id: stations.id })
-    .from(stations)
-    .where(
-      and(
-        eq(stations.station, station),
-        sql`${stations.config}->>'token' = ${token}`,
-      ),
-    );
-  if (rows.length > 0)
-    throw new AgentAdminError(
-      'that bot token is already attached to a Metro account',
-      409,
-    );
-}
-
-export async function attachAccountToAgent(
-  email: string,
-  agentId: string,
-  station: StationName,
-  config: Record<string, unknown>,
-): Promise<AccountRef> {
-  const { agent } = await ownedAgentOrThrow(email, agentId);
-  const token = config.token;
-  if (typeof token === 'string') await assertTokenFree(station, token);
-  const db = getDb();
-  for (let attempt = 0; attempt < ID_ATTEMPTS; attempt++) {
-    const accountId = newId();
-    try {
-      await db
-        .insert(stations)
-        .values({ id: accountId, agentId: agent.id, station, config });
-      return { agentId: agent.id, station, accountId };
-    } catch (err) {
-      if (!isUniqueViolation(err)) throw err;
-    }
-  }
-  throw new AgentAdminError('could not allocate a free account id', 500);
-}
-
-export async function detachAccountFromAgent(
-  email: string,
-  agentId: string,
-  station: StationName,
-  accountId: string,
-): Promise<AccountRef> {
-  const { agent } = await ownedAgentOrThrow(email, agentId);
-  const gone = await getDb()
-    .delete(stations)
-    .where(
-      and(
-        eq(stations.agentId, agent.id),
-        eq(stations.station, station),
-        eq(stations.id, accountId),
-      ),
-    )
-    .returning({ id: stations.id });
-  if (gone.length === 0)
-    throw new AgentAdminError('no such account on this agent', 404);
-  return { agentId: agent.id, station, accountId };
-}