@stage-labs/metro 0.1.0-beta.42 → 0.1.0-beta.43

package/dist/api.js

@@ -1,4 +1,6 @@
 import { metroUrl, readRunTokens, readToken } from './store.js';
+import { localAgents, localDaemonUp, localMcpServers, pickLocalAgent } from './local.js';
+import { localUrl } from './runtime.js';
 export class NotSignedIn extends Error {
 }
 const TIMEOUT_MS = 20_000;
@@ -115,13 +117,28 @@ export async function claimRuntime(code, label) {
         throw new Error('metro returned an unexpected response');
     return { token: body.token, agent: body.agent, label: body.label };
 }
-export async function mcpServers() {
+export async function mcpServers(wanted) {
+    if (await localDaemonUp()) {
+        const agents = localAgents();
+        if (agents.length > 0)
+            return localMcpServers(pickLocalAgent(agents, wanted));
+    }
     const body = await get('/api/cli/mcp');
     if (!isRecord(body) || typeof body.json !== 'string')
         throw new Error('metro returned an unexpected response');
     return body.json;
 }
-export async function whoisAuthorized() {
+export async function whoisAuthorized(wanted) {
+    if (await localDaemonUp()) {
+        const agents = localAgents();
+        if (agents.length > 0) {
+            const agent = pickLocalAgent(agents, wanted);
+            return { email: 'this machine', agent: agent.name, where: `${localUrl()} (local)` };
+        }
+    }
+    return { ...(await hostedIdentity()), where: metroUrl() };
+}
+async function hostedIdentity() {
     const body = await get('/api/cli/session');
     if (!isRecord(body) ||
         typeof body.email !== 'string' ||

package/dist/cli.js

@@ -2,7 +2,7 @@
 import { hostname } from 'node:os';
 import { claimCode, claimRuntime, mcpServers, NotSignedIn, whoisAuthorized, } from './api.js';
 import { askSecret } from './prompt.js';
-import { clearToken, credentialsPath, metroUrl, metroWebUrl, writeToken, } from './store.js';
+import { clearToken, credentialsPath, metroWebUrl, writeToken, } from './store.js';
 import { detach, lockedBy, probe, runningPid, stopAll, tail } from './control.js';
 import { tailEvents } from './tail.js';
 import { assertAgentId, daemonPlan, localUrl, readRunToken, runDaemon, runtimeDir, runTokenState, writeRunToken, } from './runtime.js';
@@ -32,8 +32,11 @@ const USAGE = `metro — the command line for your MCP connectors
   metro login [code]
                   authorize this machine for one agent with a code from its page
   metro logout    forget this machine's sign-in
-  metro whoami    print the account and agent this machine may read
-  metro mcp       print the mcpServers block of the authorized agent's connectors
+  metro whoami [agent]
+                  print the account and agent this machine may read
+  metro mcp [agent]
+                  print the mcpServers block of the agent's connectors; with a local daemon
+                  running, its agent's connectors (name one if several)
   metro plugin    set up the Claude Code plugin (connector servers + /metro:login)
   metro claude [args...]
                   open Claude Code with the metro channel; every argument is passed through
@@ -142,9 +145,9 @@ async function login(given) {
         process.stderr.write('Claude Code plugin refreshed — new sessions have the connectors; ' +
             'run /reload-plugins in any session already open.\n');
 }
-async function whoami() {
-    const { email, agent } = await whoisAuthorized();
-    process.stdout.write(`${email} · agent '${agent}' on ${metroUrl()}\n`);
+async function whoami(wanted) {
+    const { email, agent, where } = await whoisAuthorized(wanted);
+    process.stdout.write(`${email} · agent '${agent}' on ${where}\n`);
 }
 const HELP = new Set([undefined, 'help', '--help', '-h']);
 const COMMANDS = {
@@ -158,7 +161,7 @@ const COMMANDS = {
         return Promise.resolve(0);
     },
     whoami: async () => {
-        await whoami();
+        await whoami(process.argv[3]);
         return 0;
     },
     start: () => start(process.argv.slice(3)),
@@ -168,7 +171,7 @@ const COMMANDS = {
     logs: () => logs(process.argv.slice(3)),
     tail: () => tailEvents(process.argv.slice(3)),
     mcp: async () => {
-        process.stdout.write(`${await mcpServers()}\n`);
+        process.stdout.write(`${await mcpServers(process.argv[3])}\n`);
         return 0;
     },
     plugin: installPlugin,

package/dist/local.js

@@ -0,0 +1,67 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { localUrl } from './runtime.js';
+const PROBE_MS = 3_000;
+const READ_MS = 20_000;
+export function agentsDir() {
+    const explicit = process.env.METRO_AGENTS_DIR?.trim();
+    return explicit !== undefined && explicit !== '' ? explicit : join(homedir(), '.metro', 'agents');
+}
+export function localAgents(dir = agentsDir()) {
+    if (!existsSync(dir))
+        return [];
+    const out = [];
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const path = join(dir, entry.name, 'agent.json');
+        if (!existsSync(path))
+            continue;
+        try {
+            const file = JSON.parse(readFileSync(path, 'utf8'));
+            if (typeof file.id === 'string' && typeof file.name === 'string' && typeof file.key === 'string')
+                out.push({ id: file.id, name: file.name, key: file.key });
+        }
+        catch {
+            continue;
+        }
+    }
+    return out.sort((a, b) => a.name.localeCompare(b.name));
+}
+export function pickLocalAgent(agents, wanted) {
+    if (wanted !== undefined && wanted !== '') {
+        const found = agents.find((a) => a.name === wanted || a.id === wanted);
+        if (found === undefined)
+            throw new Error(`no local agent named '${wanted}'`);
+        return found;
+    }
+    const only = agents[0];
+    if (only !== undefined && agents.length === 1)
+        return only;
+    throw new Error(agents.length === 0
+        ? 'no agent on this machine yet'
+        : `several agents on this machine — name one: ${agents.map((a) => a.name).join(', ')}`);
+}
+export async function localDaemonUp(base = localUrl()) {
+    try {
+        const res = await fetch(`${base}/api/mode`, { signal: AbortSignal.timeout(PROBE_MS) });
+        const body = (await res.json());
+        return res.ok && body.mode === 'local';
+    }
+    catch {
+        return false;
+    }
+}
+export async function localMcpServers(agent, base = localUrl()) {
+    const res = await fetch(`${base}/api/cli/mcp`, {
+        headers: { authorization: `Bearer ${agent.key}` },
+        signal: AbortSignal.timeout(READ_MS),
+    });
+    if (!res.ok)
+        throw new Error(`the local daemon answered ${String(res.status)} for the connectors`);
+    const body = (await res.json());
+    if (typeof body.json !== 'string')
+        throw new Error('the local daemon returned an unexpected response');
+    return body.json;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.42",
+  "version": "0.1.0-beta.43",
   "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/connector-url.ts

@@ -9,6 +9,12 @@ export class ConnectorNotMcp extends ConnectorVerifyError {}
 export const POLICY_MESSAGE =
   'Metro connects from its own server, so it cannot reach a URL on your machine. localhost and private addresses are not usable as connectors.';
 
+let localAllowed = false;
+
+export function allowLocalConnectors(on: boolean): void {
+  localAllowed = on;
+}
+
 const IPV4 = /^\d{1,3}(?:\.\d{1,3}){3}$/;
 const PRIVATE_SUFFIX = /(?:^|\.)(?:localhost|local|internal|flycast)$/;
 
@@ -22,6 +28,19 @@ function hostAllowed(host: string): boolean {
   return !PRIVATE_SUFFIX.test(host);
 }
 
+function schemeAllowed(url: URL): boolean {
+  return url.protocol === 'https:' || (localAllowed && url.protocol === 'http:');
+}
+
+function refuseShape(url: URL): void {
+  if (!schemeAllowed(url)) throw refused('a connector url must start with https://');
+  if (url.username !== '' || url.password !== '')
+    throw refused('a connector url must not carry a user:password');
+  if (url.hash !== '')
+    throw refused('a connector url must not carry a #fragment');
+  if (!localAllowed && !hostAllowed(url.hostname.toLowerCase())) throw refused(POLICY_MESSAGE);
+}
+
 export function parseConnectorUrl(raw: unknown): URL {
   const text = typeof raw === 'string' ? raw.trim() : '';
   if (text === '') throw refused('a connector url is required');
@@ -31,13 +50,7 @@ export function parseConnectorUrl(raw: unknown): URL {
   } catch {
     throw refused('that is not a valid url');
   }
-  if (url.protocol !== 'https:')
-    throw refused('a connector url must start with https://');
-  if (url.username !== '' || url.password !== '')
-    throw refused('a connector url must not carry a user:password');
-  if (url.hash !== '')
-    throw refused('a connector url must not carry a #fragment');
-  if (!hostAllowed(url.hostname.toLowerCase())) throw refused(POLICY_MESSAGE);
+  refuseShape(url);
   return url;
 }
 

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

@@ -0,0 +1,70 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { errMsg, log } from './log.js';
+import { cors, sendJson, type AgentIdentity } from './api-http.js';
+import { publicBaseOrDefault } from './attach-serve.js';
+import { relayServersJson, type RelayServerEntry } from './connector-json.js';
+import { agentIdForKey } from '../db/key-map.js';
+import type { ConnectorSummary } from '../db/connectors.js';
+
+const PREFIX = '/api/cli';
+
+export interface LocalCliDeps {
+  agentName: (agentId: string) => string | null;
+  connectorEntries: (agentId: string) => Promise<RelayServerEntry[]>;
+  connectorSummaries: (agentId: string) => Promise<ConnectorSummary[]>;
+}
+
+export function keyOf(req: IncomingMessage): string {
+  const header = req.headers.authorization ?? '';
+  if (header.toLowerCase().startsWith('bearer ')) return header.slice(7).trim();
+  const query = new URLSearchParams((req.url ?? '').split('?')[1] ?? '');
+  return query.get('token')?.trim() ?? '';
+}
+
+export function keyIdentity(req: IncomingMessage): AgentIdentity | null {
+  const key = keyOf(req);
+  const agentId = key === '' ? undefined : agentIdForKey(key);
+  return agentId === undefined ? null : { subject: 'agent-key', agentId };
+}
+
+async function answer(path: string, key: string, agentId: string, deps: LocalCliDeps): Promise<unknown> {
+  const agent = deps.agentName(agentId) ?? '';
+  if (path === `${PREFIX}/session`) return { email: 'this machine', subject: 'this machine', agent };
+  if (path === `${PREFIX}/connectors`) return { agent, connectors: await deps.connectorSummaries(agentId) };
+  return { json: relayServersJson(await deps.connectorEntries(agentId), publicBaseOrDefault(), key), agent };
+}
+
+export function handleLocalCliRequest(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: LocalCliDeps,
+): boolean {
+  const path = (req.url ?? '').split('?')[0] ?? '';
+  if (path !== PREFIX && !path.startsWith(`${PREFIX}/`)) return false;
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204, cors(req)).end();
+    return true;
+  }
+  if (![`${PREFIX}/mcp`, `${PREFIX}/session`, `${PREFIX}/connectors`].includes(path)) {
+    sendJson(req, res, 404, { error: 'not on a local daemon' });
+    return true;
+  }
+  if (req.method !== 'GET') {
+    sendJson(req, res, 405, { error: 'method not allowed' });
+    return true;
+  }
+  const who = keyIdentity(req);
+  if (who === null) {
+    sendJson(req, res, 401, { error: 'unauthorized' });
+    return true;
+  }
+  answer(path, keyOf(req), who.agentId, deps)
+    .then((body) => {
+      sendJson(req, res, 200, body);
+    })
+    .catch((err: unknown) => {
+      log.warn({ err: errMsg(err) }, 'local cli: request failed');
+      if (!res.headersSent) sendJson(req, res, 500, { error: 'cli failed' });
+    });
+  return true;
+}

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

@@ -10,10 +10,31 @@ import type { SessionApis } from './session-apis.js';
 import type { ModeInfo } from './mode-api.js';
 import type { ImportApiDeps } from './import-api.js';
 import { fetchAgentWithCode } from './agent-import.js';
-import { forgetHostedConnectors, hostedConnectorsFor, type HostedConnector } from './hosted-connectors.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 {
+  localAddConnector,
+  localAgentConnectors,
+  localConnectorNamesByIds,
+  localConnectorSummariesByIds,
+  localCreateConnector,
+  localCreatePendingConnector,
+  localDeleteConnector,
+  localDisconnectConnector,
+  localGetConnector,
+  localListConnectors,
+  localReconnectConnector,
+  localRelayTarget,
+  localRemoveConnector,
+  localRenameConnector,
+  localVerifyConnector,
+} from '../db/local-connectors.js';
 import {
   assertLocalOwner,
   claimLocalOwner,
+  connectorIdsOfLocalAgent,
   LOCAL_PROJECT_ID,
   localAttachAccount,
   localCreateAgent,
@@ -26,6 +47,7 @@ import {
   localResetAgentKey,
 } from '../db/file-admin.js';
 import { normalizeAddress } from '../db/users.js';
+import { listAgentFiles, readAgentFile } from '../db/file-source.js';
 import type { Project } from '../db/projects.js';
 import type { StationName } from '../db/schema.js';
 
@@ -124,32 +146,52 @@ const projectApi: ProjectApiDeps = {
   removeMember: () => notHere('members'),
 };
 
-async function connectorIdsOfLocalAgents(ids: string[]): Promise<Map<string, string[]>> {
-  const pairs = await Promise.all(
-    ids.map(async (id) => [id, (await hostedConnectorsFor(id)).map((c) => c.id)] as const),
-  );
-  return new Map(pairs);
-}
-
-async function connectorsOfOwner(subject: string): Promise<HostedConnector[]> {
-  const agents = await localListAgents(subject, LOCAL_PROJECT_ID).catch(() => []);
-  const lists = await Promise.all(agents.map((a) => hostedConnectorsFor(a.id)));
-  const seen = new Map<string, HostedConnector>();
-  for (const c of lists.flat()) seen.set(c.id, c);
-  return [...seen.values()].sort((a, b) => a.name.localeCompare(b.name));
+function connectorIdsOfLocalAgents(ids: string[]): Promise<Map<string, string[]>> {
+  return Promise.resolve(new Map(ids.map((id) => [id, connectorIdsOfLocalAgent(id) ?? []] as const)));
 }
 
 const agentConnectorApi: AgentConnectorApiDeps = {
-  agentConnectors: async (subject, id) => {
-    const { agent } = await localOwnedAgentOrThrow(subject, id);
-    return { ...agent, connectorIds: (await hostedConnectorsFor(id)).map((c) => c.id) };
-  },
-  addConnector: () => notHere('connectors'),
-  removeConnector: () => notHere('connectors'),
+  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,
+  renameConnector: localRenameConnector,
+  deleteConnector: localDeleteConnector,
+  createPendingConnector: localCreatePendingConnector,
+  reconnectConnector: localReconnectConnector,
+  getConnector: localGetConnector,
+};
+
+const relayApi: RelayApiDeps = {
+  target: (agentId, connectorId, force) => localRelayTarget(agentId, connectorId, force),
+  fence: () => Promise.resolve(),
+  identify: keyIdentity,
+};
+
+function agentNameOf(agentId: string): string | null {
+  return listAgentFiles()
+    .map((path) => readAgentFile(path))
+    .find((file) => file.id === agentId)?.name ?? null;
+}
+
+const localCli: LocalCliDeps = {
+  agentName: agentNameOf,
+  connectorEntries: (agentId) => localConnectorNamesByIds(connectorIdsOfLocalAgent(agentId) ?? []),
+  connectorSummaries: (agentId) => localConnectorSummariesByIds(connectorIdsOfLocalAgent(agentId) ?? []),
+};
+
 function importApi(deps: LocalModeDeps): ImportApiDeps {
   const fetchAgent = deps.fetchAgent ?? fetchAgentWithCode;
   return {
@@ -157,7 +199,6 @@ function importApi(deps: LocalModeDeps): ImportApiDeps {
       assertLocalOwner(subject);
       const agent = await fetchAgent(code, hostname());
       const made = await localImportAgent(subject, agent);
-      forgetHostedConnectors();
       for (const station of new Set(agent.accounts.map((a) => a.station)))
         await deps.syncStations(station).catch((err: unknown) => {
           log.warn(
@@ -175,11 +216,14 @@ export function localModeInfo(): ModeInfo {
 }
 
 export function localSessionApis(deps: LocalModeDeps): SessionApis {
+  allowLocalConnectors(true);
   return {
     agentApi: agentApi(deps),
     agentConnectorApi,
     importApi: importApi(deps),
-    localConnectors: { listConnectors: connectorsOfOwner },
+    connectorApi,
+    relayApi,
+    localCli,
     claudeApi: { authorize: (subject) => { assertLocalOwner(subject); } },
     projectApi,
     siwe: { ensureUser: claimLocalOwner },

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 Fence } from './api-http.js';
+import { agentIdentity, assertLease, type AgentIdentity, type Fence } from './api-http.js';
 import { ApiError } from './api-error.js';
 import { errMsg, log } from './log.js';
 
@@ -11,6 +11,7 @@ export interface RelayApiDeps {
     force: boolean,
   ) => Promise<RelayTarget>;
   fence: Fence;
+  identify?: (req: IncomingMessage) => AgentIdentity | null;
 }
 
 const ID_PATH_RE = /^\/relay\/([A-Za-z0-9][A-Za-z0-9_-]{10})$/;
@@ -263,7 +264,7 @@ function dispatch(
   connectorId: string,
   deps: RelayApiDeps,
 ): void {
-  const who = agentIdentity(req);
+  const who = (deps.identify ?? agentIdentity)(req);
   if (who === null) {
     answer(res, 401, { error: 'unauthorized' });
     return;

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

@@ -18,10 +18,7 @@ import {
 } from './agent-connector-api.js';
 import type { SiweRouteDeps } from './siwe-routes.js';
 import { handleImportRequest, type ImportApiDeps } from './import-api.js';
-import {
-  handleLocalConnectorsRequest,
-  type LocalConnectorsDeps,
-} from './local-connectors-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';
 
@@ -29,7 +26,7 @@ export interface SessionApis {
   agentApi?: AgentApiDeps;
   agentConnectorApi?: AgentConnectorApiDeps;
   importApi?: ImportApiDeps;
-  localConnectors?: LocalConnectorsDeps;
+  localCli?: LocalCliDeps;
   claudeApi?: ClaudeApiDeps;
   connectorApi?: ConnectorApiDeps;
   projectApi?: ProjectApiDeps;
@@ -45,8 +42,9 @@ export function handleSessionApis(
   apis: SessionApis,
 ): boolean {
   const { agentApi, agentConnectorApi, connectorApi, projectApi, runApi, importApi } = apis;
-  const { localConnectors, claudeApi } = 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));
@@ -56,8 +54,6 @@ export function handleSessionApis(
       () => handleConnectorApiRequest(req, res, connectorApi),
     );
   if (importApi) routes.push(() => handleImportRequest(req, res, importApi));
-  if (localConnectors)
-    routes.push(() => handleLocalConnectorsRequest(req, res, localConnectors));
   if (claudeApi) routes.push(() => handleClaudeRequest(req, res, claudeApi));
   if (agentConnectorApi)
     routes.push(() => handleAgentConnectorRequest(req, res, agentConnectorApi));

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

@@ -58,7 +58,15 @@ export interface DeletedConnector {
 
 type ConnectorRow = typeof connectors.$inferSelect;
 
-function toConnector(row: ConnectorRow): Connector {
+export interface ConnectorLike {
+  id: string;
+  name: string;
+  url: string;
+  transport: ConnectorTransport;
+  config: unknown;
+}
+
+export function connectorFromRow(row: ConnectorLike): Connector {
   const config = readConfig(row.config);
   const auth = config.auth;
   return {
@@ -76,6 +84,8 @@ function toConnector(row: ConnectorRow): Connector {
   };
 }
 
+const toConnector = (row: ConnectorRow): Connector => connectorFromRow(row);
+
 const missing = (): ConnectorError =>
   new ConnectorError('no such connector', 404);
 
@@ -193,7 +203,7 @@ async function insertConnector(
   return toConnector(row);
 }
 
-const UNVERIFIED = {
+export const UNVERIFIED = {
   at: '',
   server: '',
   version: '',

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

@@ -153,7 +153,7 @@ export async function localCreateAgent(
   ensureSecureDir(folder);
   save({
     path: join(folder, AGENT_FILE),
-    file: { version: 1, id, name, key, owner: localOwner(dir), stations: [] },
+    file: { version: 1, id, name, key, owner: localOwner(dir), stations: [], connectors: [] },
   });
   registerKey(key, id);
   return Promise.resolve({ id, name, key });
@@ -247,6 +247,7 @@ function fileFor(agent: LoadedAgent, owner: string | null, path: string): AgentF
         key: agent.key,
         owner,
         stations: agent.accounts.map((a) => ({ ...a, allowlist: a.allowlist ?? ['*'] })),
+        connectors: [],
       }),
       path,
     );
@@ -257,6 +258,40 @@ function fileFor(agent: LoadedAgent, owner: string | null, path: string): AgentF
   }
 }
 
+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;
+}
+
+export function localAgentConnectorIds(subject: string, agentId: string, dir = agentsDir()): string[] {
+  return ownedOrThrow(subject, agentId, dir).file.connectors;
+}
+
+export function localSetAgentConnectors(
+  subject: string,
+  agentId: string,
+  ids: string[],
+  dir = agentsDir(),
+): void {
+  const stored = ownedOrThrow(subject, agentId, dir);
+  stored.file.connectors = ids;
+  save(stored);
+}
+
+export function localAgentsWith(connectorId: string, dir = agentsDir()): { id: string; name: string }[] {
+  return storedAgents(dir)
+    .filter((s) => s.file.connectors.includes(connectorId))
+    .map((s) => ({ id: s.file.id, name: s.file.name }));
+}
+
+export function localDropConnectorEverywhere(connectorId: string, dir = agentsDir()): void {
+  for (const stored of storedAgents(dir)) {
+    if (!stored.file.connectors.includes(connectorId)) continue;
+    stored.file.connectors = stored.file.connectors.filter((id) => id !== connectorId);
+    save(stored);
+  }
+}
+
 function removeIfEmpty(folder: string): void {
   try {
     rmdirSync(folder);

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

@@ -20,6 +20,7 @@ export interface AgentFile {
   key: string | null;
   owner: string | null;
   stations: LoadedAccount[];
+  connectors: string[];
 }
 
 export function agentsDir(): string {
@@ -71,6 +72,15 @@ function optionalMatch(
   return value;
 }
 
+function connectorsOf(raw: unknown, path: string): string[] {
+  if (raw === undefined || raw === null) return [];
+  const list: unknown[] = Array.isArray(raw) ? raw.map((item: unknown) => item) : [];
+  const ids = list.filter((id): id is string => typeof id === 'string' && ID_RE.test(id));
+  if (!Array.isArray(raw) || ids.length !== list.length)
+    fail(path, 'connectors is not a list of 11-character ids');
+  return ids;
+}
+
 export function parseAgentFile(raw: string, path: string): AgentFile {
   let parsed: unknown;
   try {
@@ -100,6 +110,7 @@ export function parseAgentFile(raw: string, path: string): AgentFile {
     key,
     owner,
     stations: stations.map((s, i) => stationOf(s, path, i)),
+    connectors: connectorsOf(parsed.connectors, path),
   };
 }
 

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

@@ -0,0 +1,312 @@
+import { join } from 'node:path';
+import { readJson, writeSecure } from '../daemon/secure-fs.js';
+import { errMsg, log } from '../daemon/log.js';
+import {
+  connectorUrlText,
+  ConnectorVerifyError,
+  parseConnectorUrl,
+  verifyRemoteMcp,
+  type ConnectorAuth,
+  type OAuthAuth,
+} from '../daemon/connector-verify.js';
+import { oauthExpired, refreshOAuth } from '../daemon/connector-oauth.js';
+import { advertisesOAuth } from '../daemon/oauth-discovery.js';
+import {
+  ConnectorError,
+  connectorAuth,
+  connectorName,
+  readConfig,
+  signInState,
+  stamp,
+  type ConnectorConfig,
+} from './connector-config.js';
+import {
+  bearerHeaders,
+  fixedTarget,
+  unrefreshedTarget,
+  type RelayTarget,
+} from './connector-relay.js';
+import {
+  connectorFromRow,
+  UNVERIFIED,
+  type Connector,
+  type ConnectorCheck,
+  type ConnectorInput,
+  type ConnectorSummary,
+  type DeletedConnector,
+} from './connectors.js';
+import type { AgentConnectors } from './agent-connectors.js';
+import { agentsDir } from './file-source.js';
+import {
+  assertLocalOwner,
+  connectorIdsOfLocalAgent,
+  localAgentConnectorIds,
+  localAgentsWith,
+  localDropConnectorEverywhere,
+  localOwnedAgentOrThrow,
+  localSetAgentConnectors,
+  LOCAL_PROJECT_ID,
+} from './file-admin.js';
+import { newId } from './ids.js';
+
+export interface LocalConnectorRow {
+  id: string;
+  name: string;
+  url: string;
+  transport: 'http';
+  config: ConnectorConfig;
+}
+
+const FILE = 'connectors.json';
+const filePath = (dir: string): string => join(dir, FILE);
+
+const isRow = (v: unknown): v is { id: string; name: string; url: string; config?: unknown } =>
+  typeof v === 'object' &&
+  v !== null &&
+  typeof (v as { id?: unknown }).id === 'string' &&
+  typeof (v as { name?: unknown }).name === 'string' &&
+  typeof (v as { url?: unknown }).url === 'string';
+
+const asList = (value: unknown): unknown[] =>
+  Array.isArray(value) ? value.map((item: unknown) => item) : [];
+
+export function readLocalConnectors(dir = agentsDir()): LocalConnectorRow[] {
+  const raw = readJson<{ connectors?: unknown }>(filePath(dir), {}, {
+    warn: 'connectors.json: malformed, ignoring',
+  });
+  return asList(raw.connectors).filter(isRow).map((r) => ({
+    id: r.id,
+    name: r.name,
+    url: r.url,
+    transport: 'http' as const,
+    config: readConfig(r.config),
+  }));
+}
+
+function writeRows(dir: string, rows: LocalConnectorRow[]): void {
+  writeSecure(filePath(dir), `${JSON.stringify({ version: 1, connectors: rows }, null, 2)}\n`);
+}
+
+const missing = (): ConnectorError => new ConnectorError('no such connector', 404);
+
+function ownedRows(subject: string, project: string, dir: string): LocalConnectorRow[] {
+  assertLocalOwner(subject, dir);
+  if (project !== LOCAL_PROJECT_ID) throw new ConnectorError('no such project', 404);
+  return readLocalConnectors(dir);
+}
+
+function rowOrThrow(subject: string, id: string, dir: string): LocalConnectorRow {
+  assertLocalOwner(subject, dir);
+  const row = readLocalConnectors(dir).find((r) => r.id === id);
+  if (row === undefined) throw missing();
+  return row;
+}
+
+function replace(dir: string, row: LocalConnectorRow): Connector {
+  writeRows(dir, readLocalConnectors(dir).map((r) => (r.id === row.id ? row : r)));
+  return connectorFromRow(row);
+}
+
+async function oauthCapable(url: URL, auth: ConnectorAuth): Promise<boolean> {
+  if (auth.kind === 'oauth') return true;
+  if (auth.kind === 'header') return false;
+  return advertisesOAuth(url);
+}
+
+export async function localListConnectors(
+  subject: string,
+  project: string,
+  dir = agentsDir(),
+): Promise<Connector[]> {
+  return Promise.resolve(ownedRows(subject, project, dir).map(connectorFromRow));
+}
+
+export async function localGetConnector(subject: string, id: string, dir = agentsDir()): Promise<Connector> {
+  return Promise.resolve(connectorFromRow(rowOrThrow(subject, id, dir)));
+}
+
+function insert(dir: string, name: string, url: URL, config: ConnectorConfig): Connector {
+  const row: LocalConnectorRow = { id: newId(), name, url: connectorUrlText(url), transport: 'http', config };
+  writeRows(dir, [...readLocalConnectors(dir), row]);
+  return connectorFromRow(row);
+}
+
+export async function localCreateConnector(
+  subject: string,
+  project: string,
+  input: ConnectorInput,
+  dir = agentsDir(),
+): Promise<Connector> {
+  ownedRows(subject, project, dir);
+  const name = connectorName(input.name);
+  const url = parseConnectorUrl(input.url);
+  const auth = connectorAuth(input.header, input.value);
+  const verified = stamp(await verifyRemoteMcp(url, auth));
+  return insert(dir, name, url, {
+    auth,
+    createdAt: new Date().toISOString(),
+    verified,
+    oauth: await oauthCapable(url, auth),
+  });
+}
+
+export async function localCreatePendingConnector(
+  subject: string,
+  project: string,
+  input: { name: unknown; url: unknown },
+  dir = agentsDir(),
+): Promise<Connector> {
+  ownedRows(subject, project, dir);
+  const name = connectorName(input.name);
+  const url = parseConnectorUrl(input.url);
+  return Promise.resolve(
+    insert(dir, name, url, { auth: { kind: 'none' }, createdAt: new Date().toISOString(), verified: UNVERIFIED, oauth: true }),
+  );
+}
+
+export async function localReconnectConnector(
+  subject: string,
+  id: string,
+  auth: OAuthAuth,
+  dir = agentsDir(),
+): Promise<Connector> {
+  const row = rowOrThrow(subject, id, dir);
+  const verified = stamp(await verifyRemoteMcp(parseConnectorUrl(row.url), auth));
+  return replace(dir, { ...row, config: { ...row.config, auth, verified, oauth: true } });
+}
+
+export async function localDisconnectConnector(subject: string, id: string, dir = agentsDir()): Promise<Connector> {
+  const row = rowOrThrow(subject, id, dir);
+  if (row.config.auth.kind !== 'oauth') throw new ConnectorError('that connector is not signed in', 400);
+  return Promise.resolve(replace(dir, { ...row, config: { ...row.config, auth: { kind: 'none' }, oauth: true } }));
+}
+
+async function freshAuth(auth: ConnectorAuth, resource: string): Promise<ConnectorAuth> {
+  if (auth.kind !== 'oauth' || !oauthExpired(auth)) return auth;
+  return refreshOAuth(auth, resource);
+}
+
+export async function localVerifyConnector(subject: string, id: string, dir = agentsDir()): Promise<ConnectorCheck> {
+  const row = rowOrThrow(subject, id, dir);
+  try {
+    const url = parseConnectorUrl(row.url);
+    const auth = await freshAuth(row.config.auth, url.toString());
+    const verified = stamp(await verifyRemoteMcp(url, auth));
+    const oauth = row.config.oauth || (await oauthCapable(url, auth));
+    replace(dir, { ...row, config: { ...row.config, auth, verified, oauth } });
+    return { id: row.id, name: row.name, ok: true, verified };
+  } catch (err) {
+    if (!(err instanceof ConnectorVerifyError)) throw err;
+    return { id: row.id, name: row.name, ok: false, reason: err.message };
+  }
+}
+
+const nameClash = (name: string, agent: string): ConnectorError =>
+  new ConnectorError(`the agent '${agent}' already has a connector named '${name}'`, 409);
+
+function clashFor(name: string, exceptId: string, agentIds: string[], dir: string): string | null {
+  const rows = readLocalConnectors(dir);
+  for (const agentId of agentIds) {
+    const held = connectorIdsOfLocalAgent(agentId, dir) ?? [];
+    const other = rows.find((r) => r.id !== exceptId && held.includes(r.id) && r.name === name);
+    if (other !== undefined) return localAgentsWith(other.id, dir).find((a) => a.id === agentId)?.name ?? agentId;
+  }
+  return null;
+}
+
+export async function localRenameConnector(subject: string, id: string, raw: string, dir = agentsDir()): Promise<Connector> {
+  const name = connectorName(raw);
+  const row = rowOrThrow(subject, id, dir);
+  const clash = clashFor(name, id, localAgentsWith(id, dir).map((a) => a.id), dir);
+  if (clash !== null) throw nameClash(name, clash);
+  return Promise.resolve(replace(dir, { ...row, name }));
+}
+
+export async function localDeleteConnector(subject: string, id: string, dir = agentsDir()): Promise<DeletedConnector> {
+  const row = rowOrThrow(subject, id, dir);
+  writeRows(dir, readLocalConnectors(dir).filter((r) => r.id !== id));
+  localDropConnectorEverywhere(id, dir);
+  return Promise.resolve({ id: row.id, name: row.name });
+}
+
+const byIds = (ids: string[], dir: string): LocalConnectorRow[] =>
+  readLocalConnectors(dir).filter((r) => ids.includes(r.id));
+
+export async function localConnectorSummariesByIds(ids: string[], dir = agentsDir()): Promise<ConnectorSummary[]> {
+  return Promise.resolve(
+    byIds(ids, dir).map((r) => ({ id: r.id, name: r.name, url: r.url, transport: r.transport, signIn: signInState(r.config) })),
+  );
+}
+
+export async function localConnectorNamesByIds(ids: string[], dir = agentsDir()): Promise<{ id: string; name: string }[]> {
+  return Promise.resolve(byIds(ids, dir).map((r) => ({ id: r.id, name: r.name })));
+}
+
+export async function localAgentConnectors(subject: string, agentId: string, dir = agentsDir()): Promise<AgentConnectors> {
+  const { agent } = await localOwnedAgentOrThrow(subject, agentId, dir);
+  return { ...agent, connectorIds: localAgentConnectorIds(subject, agentId, dir) };
+}
+
+export async function localAddConnector(subject: string, agentId: string, connectorId: string, dir = agentsDir()): Promise<AgentConnectors> {
+  const { agent } = await localOwnedAgentOrThrow(subject, agentId, dir);
+  const row = readLocalConnectors(dir).find((r) => r.id === connectorId);
+  if (row === undefined) throw missing();
+  const held = localAgentConnectorIds(subject, agentId, dir);
+  if (!held.includes(connectorId)) {
+    const clash = clashFor(row.name, connectorId, [agentId], dir);
+    if (clash !== null) throw nameClash(row.name, clash);
+    localSetAgentConnectors(subject, agentId, [...held, connectorId], dir);
+  }
+  return { ...agent, connectorIds: localAgentConnectorIds(subject, agentId, dir) };
+}
+
+export async function localRemoveConnector(subject: string, agentId: string, connectorId: string, dir = agentsDir()): Promise<AgentConnectors> {
+  const { agent } = await localOwnedAgentOrThrow(subject, agentId, dir);
+  const held = localAgentConnectorIds(subject, agentId, dir);
+  localSetAgentConnectors(subject, agentId, held.filter((id) => id !== connectorId), dir);
+  return { ...agent, connectorIds: localAgentConnectorIds(subject, agentId, dir) };
+}
+
+const inflight = new Map<string, Promise<OAuthAuth>>();
+
+function refreshOnce(row: LocalConnectorRow, auth: OAuthAuth, dir: string): Promise<OAuthAuth> {
+  const running = inflight.get(row.id);
+  if (running !== undefined) return running;
+  const job = refreshOAuth(auth, parseConnectorUrl(row.url).toString())
+    .then((fresh) => {
+      replace(dir, { ...row, config: { ...row.config, auth: fresh } });
+      return fresh;
+    })
+    .finally(() => {
+      inflight.delete(row.id);
+    });
+  inflight.set(row.id, job);
+  return job;
+}
+
+async function oauthTarget(row: LocalConnectorRow, auth: OAuthAuth, force: boolean, dir: string): Promise<RelayTarget> {
+  if (!force && !oauthExpired(auth)) return { kind: 'ok', url: row.url, headers: bearerHeaders(auth.accessToken) };
+  try {
+    const fresh = await refreshOnce(row, auth, dir);
+    return { kind: 'ok', url: row.url, headers: bearerHeaders(fresh.accessToken) };
+  } catch (err) {
+    log.warn({ id: row.id, err: errMsg(err) }, 'local relay: token refresh failed');
+    return unrefreshedTarget(row.url, auth, force);
+  }
+}
+
+export async function localRelayTarget(
+  agentId: string,
+  connectorId: string,
+  force: boolean,
+  dir = agentsDir(),
+): Promise<RelayTarget> {
+  const held = connectorIdsOfLocalAgent(agentId, dir);
+  if (!held?.includes(connectorId)) return { kind: 'missing' };
+  const row = readLocalConnectors(dir).find((r) => r.id === connectorId);
+  if (row === undefined) return { kind: 'missing' };
+  parseConnectorUrl(row.url);
+  const auth = row.config.auth;
+  if (auth.kind === 'oauth') return oauthTarget(row, auth, force, dir);
+  return fixedTarget(row.url, auth, force);
+}

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.42"
+  "version": "0.1.0-beta.43"
 }

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

@@ -1,118 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { errMsg, log } from './log.js';
-import { configDir } from './paths.js';
-import { metroBaseUrl } from './agent-import.js';
-
-const FETCH_TIMEOUT_MS = 15_000;
-const CACHE_MS = 60_000;
-
-export interface HostedConnector {
-  id: string;
-  name: string;
-  url: string;
-  transport: string;
-  signIn: 'connected' | 'disconnected' | null;
-}
-
-export interface HostedCredential {
-  token: string;
-  url: string;
-}
-
-function readJsonFile(path: string): Record<string, unknown> | null {
-  try {
-    const parsed: unknown = JSON.parse(readFileSync(path, 'utf8'));
-    return typeof parsed === 'object' && parsed !== null ? (parsed as Record<string, unknown>) : null;
-  } catch {
-    return null;
-  }
-}
-
-function agentOfToken(token: string): string | null {
-  const body = token.split('.')[1];
-  if (body === undefined) return null;
-  try {
-    const claims = JSON.parse(Buffer.from(body, 'base64url').toString('utf8')) as { agent?: unknown };
-    return typeof claims.agent === 'string' ? claims.agent : null;
-  } catch {
-    return null;
-  }
-}
-
-function credential(file: Record<string, unknown> | null): HostedCredential | null {
-  if (file === null || typeof file.token !== 'string' || file.token === '') return null;
-  return { token: file.token, url: typeof file.url === 'string' && file.url !== '' ? file.url : metroBaseUrl() };
-}
-
-export function hostedCredentialsFor(agentId: string, dir = configDir()): HostedCredential[] {
-  const out: HostedCredential[] = [];
-  const login = credential(readJsonFile(join(dir, 'credentials.json')));
-  if (login !== null && agentOfToken(login.token) === agentId) out.push(login);
-  const runtime = join(dir, `runtime-${agentId}.json`);
-  if (existsSync(runtime)) {
-    const cred = credential(readJsonFile(runtime));
-    if (cred !== null) out.push(cred);
-  }
-  return out;
-}
-
-const isConnector = (v: unknown): v is HostedConnector =>
-  typeof v === 'object' &&
-  v !== null &&
-  typeof (v as { id?: unknown }).id === 'string' &&
-  typeof (v as { name?: unknown }).name === 'string';
-
-class Refused extends Error {}
-
-async function fetchHosted(cred: HostedCredential): Promise<HostedConnector[]> {
-  const res = await fetch(`${cred.url}/api/cli/connectors`, {
-    headers: { authorization: `Bearer ${cred.token}` },
-    signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
-    redirect: 'manual',
-  });
-  if (res.status === 401 || res.status === 403 || res.status === 409) {
-    await res.arrayBuffer().catch(() => undefined);
-    throw new Refused(`metro no longer accepts this credential (${String(res.status)})`);
-  }
-  if (!res.ok) throw new Error(`metro answered ${String(res.status)} for the connectors`);
-  const body = (await res.json()) as { connectors?: unknown };
-  return Array.isArray(body.connectors) ? body.connectors.filter(isConnector) : [];
-}
-
-async function firstAccepted(agentId: string, creds: HostedCredential[]): Promise<HostedConnector[] | null> {
-  for (const cred of creds) {
-    try {
-      return await fetchHosted(cred);
-    } catch (err) {
-      if (!(err instanceof Refused)) throw err;
-      log.warn({ agent: agentId, reason: errMsg(err) }, 'hosted connectors: credential refused, trying the next');
-    }
-  }
-  return null;
-}
-
-const cache = new Map<string, { at: number; list: HostedConnector[] }>();
-
-export async function hostedConnectorsFor(agentId: string, dir = configDir()): Promise<HostedConnector[]> {
-  const hit = cache.get(agentId);
-  if (hit !== undefined && Date.now() - hit.at < CACHE_MS) return hit.list;
-  const creds = hostedCredentialsFor(agentId, dir);
-  if (creds.length === 0) return [];
-  try {
-    const list = await firstAccepted(agentId, creds);
-    if (list === null) {
-      log.warn({ agent: agentId }, 'hosted connectors: every stored credential is stale; metro login again');
-      return [];
-    }
-    cache.set(agentId, { at: Date.now(), list });
-    return list;
-  } catch (err) {
-    log.warn({ agent: agentId, err: errMsg(err) }, 'hosted connectors: unavailable, listing none');
-    return [];
-  }
-}
-
-export function forgetHostedConnectors(): void {
-  cache.clear();
-}

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

@@ -1,56 +0,0 @@
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import { errMsg, log } from './log.js';
-import { apiSession, cors, sendJson } from './api-http.js';
-import type { HostedConnector } from './hosted-connectors.js';
-
-const PATH = '/api/connectors';
-
-export interface LocalConnectorsDeps {
-  listConnectors: (subject: string) => Promise<HostedConnector[]>;
-}
-
-const payload = (c: HostedConnector): Record<string, unknown> => ({
-  id: c.id,
-  name: c.name,
-  url: c.url,
-  transport: c.transport,
-  auth: c.signIn === null ? 'none' : 'oauth',
-  header: null,
-  signIn: c.signIn,
-  verified: null,
-  managed: 'metro.box',
-});
-
-export function handleLocalConnectorsRequest(
-  req: IncomingMessage,
-  res: ServerResponse,
-  deps: LocalConnectorsDeps,
-): boolean {
-  const path = (req.url ?? '').split('?')[0] ?? '';
-  if (path !== PATH && !path.startsWith(`${PATH}/`)) return false;
-  if (req.method === 'OPTIONS') {
-    res.writeHead(204, cors(req)).end();
-    return true;
-  }
-  if (path !== PATH || req.method !== 'GET') {
-    sendJson(req, res, path === PATH ? 405 : 404, {
-      error: 'connectors are managed on metro.box, not on a local daemon',
-    });
-    return true;
-  }
-  const session = apiSession(req);
-  if (!session) {
-    sendJson(req, res, 401, { error: 'unauthorized' });
-    return true;
-  }
-  deps
-    .listConnectors(session.subject)
-    .then((list) => {
-      sendJson(req, res, 200, { connectors: list.map(payload) });
-    })
-    .catch((err: unknown) => {
-      log.warn({ err: errMsg(err) }, 'local connectors: request failed');
-      if (!res.headersSent) sendJson(req, res, 500, { error: 'connectors failed' });
-    });
-  return true;
-}