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

package/package.json

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

@@ -14,6 +14,7 @@ import { allowLocalConnectors } from './connector-url.js';
 import { keyIdentity, type LocalCliDeps } from './local-cli-api.js';
 import type { RelayApiDeps } from './relay.js';
 import {
+  localImportConnectors,
   localAddConnector,
   localAgentConnectors,
   localConnectorNamesByIds,
@@ -164,6 +165,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 +173,7 @@ function importApi(deps: LocalModeDeps): ImportApiDeps {
             'import: station reload failed, the change lands at the next boot',
           );
         });
-      return made;
+      return { ...made, connectors };
     },
   };
 }

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,
     );

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;
@@ -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/runtime.json

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