@stage-labs/metro 0.1.0-beta.47 → 0.1.0-beta.49

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.47",
+  "version": "0.1.0-beta.49",
   "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/api-http.ts

@@ -11,7 +11,6 @@ import {
 import { extractToken } from '../mcp/request-identity.js';
 
 const BODY_MAX = 4 * 1024;
-const DRAIN_MAX = 2 * BODY_MAX;
 
 export interface ApiSession {
   subject: string;
@@ -111,16 +110,16 @@ export function projectParam(req: IncomingMessage): string | null {
   return raw === null || raw === '' ? null : raw;
 }
 
-export async function readJsonBody(req: IncomingMessage): Promise<unknown> {
+export async function readJsonBody(req: IncomingMessage, max = BODY_MAX): Promise<unknown> {
   const chunks: Buffer[] = [];
   let total = 0;
   let over = false;
   for await (const c of req) {
     const buf = c as Buffer;
     total += buf.length;
-    if (total > BODY_MAX) over = true;
+    if (total > max) over = true;
     if (!over) chunks.push(buf);
-    else if (total > DRAIN_MAX) break;
+    else if (total > 2 * max) break;
   }
   if (over) throw new ApiError('request body too large', 413);
   const raw = Buffer.concat(chunks).toString('utf8').trim();

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

@@ -103,6 +103,7 @@ 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'));
@@ -300,6 +301,7 @@ function sessionApis(): SessionApis {
     projectApi,
     runApi,
     relayApi: { target: relayTarget, fence: fenceRuntime },
+    vaultApi: { list: listVaultForOwner, put: putVaultForOwner, get: getVaultForOwner, remove: deleteVaultForOwner },
     mode: hostedMode,
   };
 }

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

@@ -0,0 +1,112 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { errMsg, log } from './log.js';
+import { apiFailure, apiSession, cors, readJsonBody, sendJson } from './api-http.js';
+import { ApiError } from './api-error.js';
+import { isRecord } from './is-record.js';
+import { parseId } from '../db/ids.js';
+import type { LoadedAccount, LoadedAgent, LoadedConnector } from '../db/materialize.js';
+import { STATIONS } from '../db/schema.js';
+
+const AGENTS = '/api/agents';
+const RESTORE_PATH = `${AGENTS}/restore`;
+const BUNDLE_MAX = 2 * 1024 * 1024;
+const STATION_NAMES = new Set<string>(STATIONS);
+
+export interface AgentBundle {
+  version: 1;
+  agent: { id: string; name: string; key: string; stations: LoadedAccount[] };
+  connectors: LoadedConnector[];
+}
+
+export const loadedAgentOf = (bundle: AgentBundle): LoadedAgent => ({
+  id: bundle.agent.id,
+  name: bundle.agent.name,
+  key: bundle.agent.key,
+  accounts: bundle.agent.stations,
+  connectors: [],
+});
+
+export interface RestoredAgent {
+  id: string;
+  name: string;
+  stations: number;
+  connectors: number;
+}
+
+export interface BundleApiDeps {
+  bundle: (subject: string, agentId: string) => Promise<AgentBundle>;
+  restore: (subject: string, bundle: AgentBundle) => Promise<RestoredAgent>;
+}
+
+const bad = (what: string): ApiError => new ApiError(`bundle: ${what}`, 400);
+
+function stationOf(raw: unknown): LoadedAccount {
+  if (!isRecord(raw) || typeof raw.station !== 'string' || !STATION_NAMES.has(raw.station))
+    throw bad('a station is not a known station');
+  if (typeof raw.id !== 'string' || !isRecord(raw.config)) throw bad('a station has no id or config');
+  const allowlist = Array.isArray(raw.allowlist)
+    ? raw.allowlist.filter((s): s is string => typeof s === 'string')
+    : null;
+  return { station: raw.station as LoadedAccount['station'], id: raw.id, allowlist, config: raw.config };
+}
+
+function connectorOf(raw: unknown): LoadedConnector {
+  if (!isRecord(raw) || typeof raw.id !== 'string' || typeof raw.name !== 'string' || typeof raw.url !== 'string')
+    throw bad('a connector is missing its id, name or url');
+  if (!isRecord(raw.config)) throw bad('a connector has no config');
+  return { id: raw.id, name: raw.name, url: raw.url, transport: 'http', config: raw.config };
+}
+
+function agentOf(raw: unknown): AgentBundle['agent'] {
+  if (!isRecord(raw)) throw bad('not a v1 agent bundle');
+  const { id, name, key, stations } = raw;
+  if (typeof id !== 'string' || parseId(id) === null) throw bad('agent id is not an id');
+  if (typeof name !== 'string' || typeof key !== 'string' || key === '') throw bad('agent has no name or key');
+  if (!Array.isArray(stations)) throw bad('agent has no station list');
+  return { id, name, key, stations: stations.map(stationOf) };
+}
+
+export function parseBundle(raw: unknown): AgentBundle {
+  if (!isRecord(raw) || raw.version !== 1) throw bad('not a v1 agent bundle');
+  const connectors = Array.isArray(raw.connectors) ? raw.connectors : [];
+  return { version: 1, agent: agentOf(raw.agent), connectors: connectors.map(connectorOf) };
+}
+
+async function answer(req: IncomingMessage, deps: BundleApiDeps, subject: string, path: string): Promise<unknown> {
+  if (path === RESTORE_PATH) return deps.restore(subject, parseBundle(await readJsonBody(req, BUNDLE_MAX)));
+  const id = parseId(path.slice(AGENTS.length + 1).split('/')[0] ?? '');
+  if (id === null) throw new ApiError('no such agent', 404);
+  return deps.bundle(subject, id);
+}
+
+export function handleBundleRequest(req: IncomingMessage, res: ServerResponse, deps: BundleApiDeps): boolean {
+  const path = (req.url ?? '').split('?')[0] ?? '';
+  const isRestore = path === RESTORE_PATH;
+  const isBundle = /^\/api\/agents\/[^/]+\/bundle$/.test(path);
+  if (!isRestore && !isBundle) return false;
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204, cors(req)).end();
+    return true;
+  }
+  if (req.method !== (isRestore ? 'POST' : 'GET')) {
+    sendJson(req, res, 405, { error: 'method not allowed' });
+    return true;
+  }
+  const session = apiSession(req);
+  if (!session) {
+    sendJson(req, res, 401, { error: 'unauthorized' });
+    return true;
+  }
+  answer(req, deps, session.subject, path)
+    .then((body) => {
+      sendJson(req, res, isRestore ? 201 : 200, body);
+    })
+    .catch((err: unknown) => {
+      if (err instanceof ApiError) apiFailure(req, res, err, 'bundle-api');
+      else {
+        log.warn({ err: errMsg(err) }, 'bundle-api: request failed');
+        if (!res.headersSent) sendJson(req, res, 500, { error: 'bundle api failed' });
+      }
+    });
+  return true;
+}

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

@@ -15,6 +15,7 @@ const PATH = '/api/agents/import';
 
 export interface ImportedAgent extends CreatedAgent {
   stations: number;
+  connectors: number;
 }
 
 export interface ImportApiDeps {
@@ -31,7 +32,7 @@ async function handle(
     const code = parsePairingCode(bodyField(await readJsonBody(req), 'code'));
     const made = await deps.importAgent(subject, code);
     log.info(
-      { agent: made.name, id: made.id, stations: made.stations },
+      { agent: made.name, id: made.id, stations: made.stations, connectors: made.connectors },
       'import-api: agent imported from metro',
     );
     sendJson(req, res, 201, made);

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

@@ -8,12 +8,15 @@ 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 { 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';
 import type { RelayApiDeps } from './relay.js';
 import {
+  readLocalConnectors,
+  localImportConnectors,
   localAddConnector,
   localAgentConnectors,
   localConnectorNamesByIds,
@@ -32,7 +35,6 @@ import {
 } from '../db/local-connectors.js';
 import {
   assertLocalOwner,
-  ownerSignIn,
   connectorIdsOfLocalAgent,
   LOCAL_PROJECT_ID,
   localAttachAccount,
@@ -44,6 +46,8 @@ import {
   localOwnedAgentOrThrow,
   localOwner,
   localResetAgentKey,
+  ownerSignIn,
+  readLocalAgentFile,
 } from '../db/file-admin.js';
 import { listAgentFiles, readAgentFile } from '../db/file-source.js';
 import type { StationName } from '../db/schema.js';
@@ -157,6 +161,35 @@ const localCli: LocalCliDeps = {
   connectorSummaries: (agentId) => localConnectorSummariesByIds(connectorIdsOfLocalAgent(agentId) ?? []),
 };
 
+function bundleApi(deps: LocalModeDeps): BundleApiDeps {
+  return {
+    bundle: async (subject, agentId) => {
+      const { agent } = await localOwnedAgentOrThrow(subject, agentId);
+      const file = readLocalAgentFile(agentId);
+      const held = new Set(file.connectors);
+      const bundle: AgentBundle = {
+        version: 1,
+        agent: { id: file.id, name: file.name, key: file.key ?? '', stations: file.stations },
+        connectors: readLocalConnectors()
+          .filter((c) => held.has(c.id))
+          .map((c) => ({ id: c.id, name: c.name, url: c.url, transport: c.transport, config: { ...c.config } })),
+      };
+      if (bundle.agent.key === '') throw new ApiError(`agent '${agent.name}' has no key to bundle`, 400);
+      return bundle;
+    },
+    restore: async (subject, bundle) => {
+      assertLocalOwner(subject);
+      const made = await localImportAgent(subject, loadedAgentOf(bundle));
+      const connectors = localImportConnectors(bundle.connectors);
+      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 };
+    },
+  };
+}
+
 function importApi(deps: LocalModeDeps): ImportApiDeps {
   const fetchAgent = deps.fetchAgent ?? fetchAgentWithCode;
   return {
@@ -164,6 +197,7 @@ function importApi(deps: LocalModeDeps): ImportApiDeps {
       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(
@@ -171,7 +205,7 @@ function importApi(deps: LocalModeDeps): ImportApiDeps {
             'import: station reload failed, the change lands at the next boot',
           );
         });
-      return made;
+      return { ...made, connectors };
     },
   };
 }
@@ -186,6 +220,7 @@ export function localSessionApis(deps: LocalModeDeps): SessionApis {
     agentApi: agentApi(deps),
     agentConnectorApi,
     importApi: importApi(deps),
+    bundleApi: bundleApi(deps),
     connectorApi,
     relayApi,
     localCli,

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

@@ -21,11 +21,15 @@ 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';
 
 export interface SessionApis {
   agentApi?: AgentApiDeps;
   agentConnectorApi?: AgentConnectorApiDeps;
   importApi?: ImportApiDeps;
+  bundleApi?: BundleApiDeps;
+  vaultApi?: VaultApiDeps;
   localCli?: LocalCliDeps;
   claudeApi?: ClaudeApiDeps;
   connectorApi?: ConnectorApiDeps;
@@ -36,27 +40,27 @@ export interface SessionApis {
   mode?: () => ModeInfo;
 }
 
+const when = <T>(dep: T | undefined, run: (dep: T) => boolean): (() => boolean)[] =>
+  dep === undefined ? [] : [() => run(dep)];
+
 export function handleSessionApis(
   req: IncomingMessage,
   res: ServerResponse,
   apis: SessionApis,
 ): boolean {
-  const { agentApi, agentConnectorApi, connectorApi, projectApi, runApi, importApi } = apis;
-  const { localCli, claudeApi } = apis;
-  const routes: (() => boolean)[] = [() => handleSessionApiRequest(req, res)];
-  if (localCli) routes.push(() => handleLocalCliRequest(req, res, localCli));
-  if (runApi) routes.push(() => handleRunApiRequest(req, res, runApi));
-  if (projectApi)
-    routes.push(() => handleProjectApiRequest(req, res, projectApi));
-  if (connectorApi)
-    routes.push(
-      () => handleCliPairRequest(req, res, connectorApi),
-      () => handleConnectorApiRequest(req, res, connectorApi),
-    );
-  if (importApi) routes.push(() => handleImportRequest(req, res, importApi));
-  if (claudeApi) routes.push(() => handleClaudeRequest(req, res, claudeApi));
-  if (agentConnectorApi)
-    routes.push(() => handleAgentConnectorRequest(req, res, agentConnectorApi));
-  if (agentApi) routes.push(() => handleAgentApiRequest(req, res, agentApi));
+  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.claudeApi, (d) => handleClaudeRequest(req, res, d)),
+    ...when(apis.agentConnectorApi, (d) => handleAgentConnectorRequest(req, res, d)),
+    ...when(apis.agentApi, (d) => handleAgentApiRequest(req, res, d)),
+  ];
   return routes.some((run) => run());
 }

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

@@ -0,0 +1,78 @@
+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 { 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;
+
+export interface VaultApiDeps {
+  list: (subject: string) => Promise<VaultEntry[]>;
+  put: (subject: string, id: string, body: unknown) => Promise<VaultEntry>;
+  get: (subject: string, id: string) => Promise<VaultBundle>;
+  remove: (subject: string, id: string) => Promise<{ id: string; name: string }>;
+}
+
+type Target = { kind: 'index' } | { kind: 'bundle'; id: string } | { kind: 'unknown' } | null;
+
+function target(path: string): Target {
+  if (path === PREFIX || path === `${PREFIX}/`) return { kind: 'index' };
+  if (!path.startsWith(`${PREFIX}/`)) return null;
+  const segments = path.slice(PREFIX.length + 1).split('/').filter(Boolean);
+  const id = parseId(segments[0] ?? '');
+  return id === null || segments.length !== 1 ? { kind: 'unknown' } : { kind: 'bundle', id };
+}
+
+const ALLOWED: Record<'index' | 'bundle', string[]> = { index: ['GET'], bundle: ['GET', 'PUT', 'DELETE'] };
+
+async function route(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: VaultApiDeps,
+  session: ApiSession,
+  tgt: { kind: 'index' } | { kind: 'bundle'; id: string },
+): Promise<void> {
+  try {
+    if (tgt.kind === 'index') {
+      sendJson(req, res, 200, { entries: await deps.list(session.subject) });
+      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));
+    else {
+      const saved = await deps.put(session.subject, tgt.id, await readJsonBody(req, BODY_MAX));
+      log.info({ id: saved.id, name: saved.name }, 'vault-api: bundle stored');
+      sendJson(req, res, 200, saved);
+    }
+  } catch (err) {
+    apiFailure(req, res, err, 'vault-api');
+  }
+}
+
+export function handleVaultApiRequest(req: IncomingMessage, res: ServerResponse, deps: VaultApiDeps): boolean {
+  const tgt = target((req.url ?? '').split('?')[0] ?? '');
+  if (tgt === null) return false;
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204, cors(req)).end();
+    return true;
+  }
+  if (tgt.kind === 'unknown') {
+    sendJson(req, res, 404, { error: 'no such bundle' });
+    return true;
+  }
+  if (!ALLOWED[tgt.kind].includes(req.method ?? '')) {
+    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) => {
+    log.warn({ err: errMsg(err) }, 'vault-api: unhandled error');
+    if (!res.headersSent) sendJson(req, res, 500, { error: 'vault api failed' });
+  });
+  return true;
+}

package/runtime/node_modules/@metro-labs/mcp/src/db/file-admin.ts

@@ -187,12 +187,7 @@ export function assertLocalOwner(subject: string, dir = agentsDir()): void {
   if (!isOwner(subject, dir)) throw new AgentAdminError('no such project', 404);
 }
 
-export async function localImportAgent(
-  subject: string,
-  agent: LoadedAgent,
-  dir = agentsDir(),
-): Promise<{ id: string; name: string; key: string; stations: number }> {
-  assertLocalOwner(subject, dir);
+function assertImportable(agent: LoadedAgent): asserts agent is LoadedAgent & { key: string } {
   const immovable = agent.accounts.find((a) => !MOVABLE_STATIONS.has(a.station));
   if (immovable !== undefined)
     throw new AgentAdminError(
@@ -201,37 +196,71 @@ export async function localImportAgent(
     );
   if (agent.key === null)
     throw new AgentAdminError('that agent has no key; reset it on metro.box first', 400);
-  const folder = join(dir, agent.name);
-  const path = join(folder, AGENT_FILE);
-  if (existsSync(path))
+}
+
+interface ImportTarget {
+  path: string;
+  previous: AgentFile | undefined;
+}
+
+function importTarget(dir: string, agent: LoadedAgent & { key: string }): ImportTarget {
+  const existing = storedAgents(dir);
+  const same = existing.find((s) => s.file.id === agent.id);
+  const fresh = join(dir, agent.name, AGENT_FILE);
+  if (same === undefined && existsSync(fresh))
     throw new AgentAdminError(
       `an agent named '${agent.name}' already exists on this machine`,
       409,
     );
-  assertUnclaimed(storedAgents(dir), agent);
-  const file = fileFor(agent, localOwner(dir), path);
-  ensureSecureDir(folder);
+  assertUnclaimed(existing.filter((s) => s !== same), agent);
+  return { path: same?.path ?? fresh, previous: same?.file };
+}
+
+export async function localImportAgent(
+  subject: string,
+  agent: LoadedAgent,
+  dir = agentsDir(),
+): Promise<{ id: string; name: string; key: string; stations: number }> {
+  assertLocalOwner(subject, dir);
+  assertImportable(agent);
+  const { path, previous } = importTarget(dir, agent);
+  const file = fileFor(agent, localOwner(dir), path, previous);
+  ensureSecureDir(join(path, '..'));
   save({ path, file });
+  if (previous !== undefined && previous.key !== agent.key) unregisterAgentKey(agent.id);
   registerKey(agent.key, agent.id);
   return Promise.resolve({
     id: agent.id,
     name: agent.name,
     key: agent.key,
-    stations: agent.accounts.length,
+    stations: file.stations.length,
   });
 }
 
-function fileFor(agent: LoadedAgent, owner: string | null, path: string): AgentFile {
+function mergedStations(agent: LoadedAgent, previous: AgentFile | undefined): AgentFile['stations'] {
+  const fromMetro = agent.accounts.map((a) => ({ ...a, allowlist: a.allowlist ?? ['*'] }));
+  const kept = (previous?.stations ?? []).filter(
+    (s) => !fromMetro.some((m) => m.station === s.station && m.id === s.id),
+  );
+  return [...fromMetro, ...kept];
+}
+
+function fileFor(
+  agent: LoadedAgent,
+  owner: string | null,
+  path: string,
+  previous?: AgentFile,
+): AgentFile {
   try {
     return parseAgentFile(
       JSON.stringify({
         version: 1,
         id: agent.id,
-        name: agent.name,
+        name: previous?.name ?? agent.name,
         key: agent.key,
         owner,
-        stations: agent.accounts.map((a) => ({ ...a, allowlist: a.allowlist ?? ['*'] })),
-        connectors: [],
+        stations: mergedStations(agent, previous),
+        connectors: previous?.connectors ?? [],
       }),
       path,
     );
@@ -242,6 +271,12 @@ function fileFor(agent: LoadedAgent, owner: string | null, path: string): AgentF
   }
 }
 
+export function readLocalAgentFile(agentId: string, dir = agentsDir()): AgentFile {
+  const found = storedAgents(dir).find((s) => s.file.id === agentId);
+  if (found === undefined) throw missing();
+  return found.file;
+}
+
 export function connectorIdsOfLocalAgent(agentId: string, dir = agentsDir()): string[] | null {
   const found = storedAgents(dir).find((s) => s.file.id === agentId);
   return found === undefined ? null : found.file.connectors;

package/runtime/node_modules/@metro-labs/mcp/src/db/local-connectors.ts

@@ -48,6 +48,7 @@ import {
   LOCAL_PROJECT_ID,
 } from './file-admin.js';
 import { newId } from './ids.js';
+import type { LoadedConnector } from './materialize.js';
 
 export interface LocalConnectorRow {
   id: string;
@@ -70,7 +71,7 @@ const isRow = (v: unknown): v is { id: string; name: string; url: string; config
 const asList = (value: unknown): unknown[] =>
   Array.isArray(value) ? value.map((item: unknown) => item) : [];
 
-function readLocalConnectors(dir = agentsDir()): LocalConnectorRow[] {
+export function readLocalConnectors(dir = agentsDir()): LocalConnectorRow[] {
   const raw = readJson<{ connectors?: unknown }>(filePath(dir), {}, {
     warn: 'connectors.json: malformed, ignoring',
   });
@@ -113,6 +114,26 @@ async function oauthCapable(url: URL, auth: ConnectorAuth): Promise<boolean> {
   return advertisesOAuth(url);
 }
 
+export function localImportConnectors(rows: LoadedConnector[], dir = agentsDir()): number {
+  const current = readLocalConnectors(dir);
+  for (const row of rows) {
+    const other = current.find((r) => r.id !== row.id && r.name === row.name);
+    if (other !== undefined)
+      throw new ConnectorError(`a connector named '${row.name}' already exists on this daemon; rename it first`, 409);
+  }
+  const imported: LocalConnectorRow[] = rows.map((row) => ({
+    id: row.id,
+    name: row.name,
+    url: row.url,
+    transport: 'http',
+    config: readConfig(row.config),
+  }));
+  const ids = new Set(imported.map((r) => r.id));
+  writeRows(dir, [...current.filter((r) => !ids.has(r.id)), ...imported]);
+  for (const row of imported) localHoldEverywhere(row.id, dir);
+  return imported.length;
+}
+
 export async function localListConnectors(
   subject: string,
   project: string,

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

@@ -21,7 +21,14 @@ import {
   type AllowlistMap,
 } from './agent-map.js';
 import { setKeyMap } from './key-map.js';
-import { STATIONS, stations, agents, type StationName } from './schema.js';
+import {
+  agentConnectors,
+  agents,
+  connectors,
+  stations,
+  STATIONS,
+  type StationName,
+} from './schema.js';
 
 interface StationTarget {
   file: string;
@@ -36,11 +43,20 @@ export interface LoadedAccount {
   config: Record<string, unknown>;
 }
 
+export interface LoadedConnector {
+  id: string;
+  name: string;
+  url: string;
+  transport: 'http';
+  config: Record<string, unknown>;
+}
+
 export interface LoadedAgent {
   id: string;
   name: string;
   accounts: LoadedAccount[];
   key: string | null;
+  connectors?: LoadedConnector[];
 }
 
 const METRO_DIR = join(homedir(), '.metro');
@@ -133,10 +149,22 @@ export async function loadAgentForRuntime(
     .select()
     .from(stations)
     .where(eq(stations.agentId, a.id));
+  const held = await db
+    .select({ id: connectors.id, name: connectors.name, url: connectors.url, config: connectors.config })
+    .from(agentConnectors)
+    .innerJoin(connectors, eq(connectors.id, agentConnectors.connectorId))
+    .where(eq(agentConnectors.agentId, a.id));
   return {
     id: a.id,
     name: a.name,
     key: a.key,
+    connectors: held.map((c) => ({
+      id: c.id,
+      name: c.name,
+      url: c.url,
+      transport: 'http' as const,
+      config: c.config as Record<string, unknown>,
+    })),
     accounts: acctRows
       .filter((r) => MOVABLE_STATIONS.has(r.station))
       .map((r) => ({

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

@@ -1,10 +1,4 @@
-import {
-  boolean,
-  jsonb,
-  pgTable,
-  text,
-  unique,
-} from 'drizzle-orm/pg-core';
+import { boolean, index, jsonb, pgTable, text, unique } from 'drizzle-orm/pg-core';
 
 export const STATIONS = [
   'xmtp',
@@ -114,3 +108,16 @@ export const agentConnectors = pgTable(
     ),
   ],
 );
+
+export const vault = pgTable(
+  'vault',
+  {
+    id: text('id').primaryKey(),
+    owner: text('owner').notNull(),
+    name: text('name').notNull(),
+    stations: jsonb('stations').notNull(),
+    envelope: jsonb('envelope').notNull(),
+    syncedAt: text('synced_at').notNull(),
+  },
+  (t) => [index('vault_owner_idx').on(t.owner)],
+);

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

@@ -0,0 +1,119 @@
+import { and, asc, eq } from 'drizzle-orm';
+import { ApiError } from '../daemon/api-error.js';
+import { isRecord } from '../daemon/is-record.js';
+import { getDb } from './client.js';
+import { AGENT_NAME_RE, parseId } from './ids.js';
+import { STATIONS, vault } from './schema.js';
+import { normalizeAddress } from './users.js';
+
+export class VaultError extends ApiError {}
+
+export interface VaultEntry {
+  id: string;
+  name: string;
+  stations: string[];
+  syncedAt: string;
+}
+
+export interface VaultBundle extends VaultEntry {
+  envelope: Record<string, unknown>;
+}
+
+export interface VaultInput {
+  name: string;
+  stations: string[];
+  envelope: Record<string, unknown>;
+}
+
+export const ENVELOPE_MAX = 2 * 1024 * 1024;
+const STATION_NAMES = new Set<string>(STATIONS);
+
+const missing = (): VaultError => new VaultError('no such bundle', 404);
+
+function ownerOf(subject: string): string {
+  const address = normalizeAddress(subject);
+  if (address === null) throw new VaultError('the vault needs a wallet sign-in', 403);
+  return address;
+}
+
+function stationsOf(raw: unknown): string[] {
+  if (!Array.isArray(raw)) throw new VaultError('stations must be a list of station names', 400);
+  const list = raw.map((s: unknown) => (typeof s === 'string' ? s : ''));
+  const bad = list.find((s) => !STATION_NAMES.has(s));
+  if (bad !== undefined) throw new VaultError(`'${bad}' is not a station`, 400);
+  return [...new Set(list)];
+}
+
+function envelopeOf(raw: unknown, id: string, owner: string): Record<string, unknown> {
+  if (!isRecord(raw) || raw.v !== 1 || raw.agentId !== id)
+    throw new VaultError('envelope must be a v1 envelope for this agent', 400);
+  const key = raw.key;
+  if (!isRecord(key) || key.recipient !== owner)
+    throw new VaultError('envelope must be sealed to the signed-in wallet', 400);
+  if (typeof raw.ciphertext !== 'string' || typeof raw.nonce !== 'string')
+    throw new VaultError('envelope carries no ciphertext', 400);
+  if (JSON.stringify(raw).length > ENVELOPE_MAX)
+    throw new VaultError(`envelope is over ${String(ENVELOPE_MAX)} bytes`, 413);
+  return raw;
+}
+
+export function parseVaultInput(subject: string, id: string, body: unknown): VaultInput & { owner: string } {
+  const owner = ownerOf(subject);
+  if (parseId(id) === null) throw missing();
+  if (!isRecord(body)) throw new VaultError('body must be an object', 400);
+  const name = typeof body.name === 'string' ? body.name.trim() : '';
+  if (!AGENT_NAME_RE.test(name)) throw new VaultError('name is not an agent name', 400);
+  return { owner, name, stations: stationsOf(body.stations), envelope: envelopeOf(body.envelope, id, owner) };
+}
+
+const entryOf = (row: { id: string; name: string; stations: unknown; syncedAt: string }): VaultEntry => ({
+  id: row.id,
+  name: row.name,
+  stations: Array.isArray(row.stations) ? row.stations.filter((s): s is string => typeof s === 'string') : [],
+  syncedAt: row.syncedAt,
+});
+
+export async function listVaultForOwner(subject: string): Promise<VaultEntry[]> {
+  const owner = ownerOf(subject);
+  const rows = await getDb()
+    .select({ id: vault.id, name: vault.name, stations: vault.stations, syncedAt: vault.syncedAt })
+    .from(vault)
+    .where(eq(vault.owner, owner))
+    .orderBy(asc(vault.name));
+  return rows.map(entryOf);
+}
+
+export async function putVaultForOwner(subject: string, id: string, body: unknown): Promise<VaultEntry> {
+  const input = parseVaultInput(subject, id, body);
+  const syncedAt = new Date().toISOString();
+  const values = { id, owner: input.owner, name: input.name, stations: input.stations, envelope: input.envelope, syncedAt };
+  const db = getDb();
+  const held = await db.select({ owner: vault.owner }).from(vault).where(eq(vault.id, id));
+  if (held[0] !== undefined && held[0].owner !== input.owner) throw missing();
+  await db
+    .insert(vault)
+    .values(values)
+    .onConflictDoUpdate({ target: vault.id, set: { name: input.name, stations: input.stations, envelope: input.envelope, syncedAt } });
+  return entryOf(values);
+}
+
+export async function getVaultForOwner(subject: string, id: string): Promise<VaultBundle> {
+  const owner = ownerOf(subject);
+  if (parseId(id) === null) throw missing();
+  const rows = await getDb().select().from(vault).where(and(eq(vault.id, id), eq(vault.owner, owner)));
+  const row = rows[0];
+  if (row === undefined) throw missing();
+  return { ...entryOf(row), envelope: isRecord(row.envelope) ? row.envelope : {} };
+}
+
+export async function deleteVaultForOwner(subject: string, id: string): Promise<{ id: string; name: string }> {
+  const owner = ownerOf(subject);
+  if (parseId(id) === null) throw missing();
+  const gone = await getDb()
+    .delete(vault)
+    .where(and(eq(vault.id, id), eq(vault.owner, owner)))
+    .returning({ id: vault.id, name: vault.name });
+  const row = gone[0];
+  if (row === undefined) throw missing();
+  return row;
+}

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.47"
+  "version": "0.1.0-beta.49"
 }