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

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

@@ -9,9 +9,10 @@ import {
   readJsonBody,
   sendJson,
   type ApiSession,
+  type Fence,
 } from './api-http.js';
 import { parseId } from '../db/ids.js';
-import type { ConnectorCollectionRow } from '../db/connector-collections.js';
+import type { AgentConnectors } from '../db/agent-connectors.js';
 import type { RelayServerEntry } from './connector-json.js';
 import {
   handleCallback,
@@ -36,35 +37,8 @@ const asText = (value: unknown): string =>
 export interface ConnectorApiDeps extends OAuthRouteDeps {
   listConnectors: (email: string, project: string) => Promise<Connector[]>;
   connectorNamesByIds: (ids: string[]) => Promise<RelayServerEntry[]>;
-  listCollections: (
-    email: string,
-    project: string,
-  ) => Promise<ConnectorCollectionRow[]>;
-  getCollection: (email: string, id: string) => Promise<ConnectorCollectionRow>;
-  createCollection: (
-    email: string,
-    project: string,
-    name: string,
-  ) => Promise<ConnectorCollectionRow>;
-  renameCollection: (
-    email: string,
-    id: string,
-    name: string,
-  ) => Promise<ConnectorCollectionRow>;
-  deleteCollection: (
-    email: string,
-    id: string,
-  ) => Promise<{ id: string; name: string }>;
-  addToCollection: (
-    email: string,
-    id: string,
-    connectorId: string,
-  ) => Promise<ConnectorCollectionRow>;
-  removeFromCollection: (
-    email: string,
-    id: string,
-    connectorId: string,
-  ) => Promise<ConnectorCollectionRow>;
+  agentConnectors: (email: string, agentId: string) => Promise<AgentConnectors>;
+  fenceRuntime: Fence;
   createConnector: (
     email: string,
     project: string,

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

@@ -1,15 +1,16 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import type { RelayTarget } from '../db/connector-relay.js';
-import { cliIdentity } from './api-http.js';
+import { agentIdentity, assertLease, type Fence } from './api-http.js';
 import { ApiError } from './api-error.js';
 import { errMsg, log } from './log.js';
 
 export interface RelayApiDeps {
   target: (
-    collectionId: string,
+    agentId: string,
     connectorId: string,
     force: boolean,
   ) => Promise<RelayTarget>;
+  fence: Fence;
 }
 
 const ID_PATH_RE = /^\/relay\/([A-Za-z0-9][A-Za-z0-9_-]{10})$/;
@@ -196,18 +197,18 @@ type Exchanged =
 
 async function exchange(
   req: IncomingMessage,
-  collectionId: string,
+  agentId: string,
   connectorId: string,
   deps: RelayApiDeps,
   body: Uint8Array<ArrayBuffer> | null,
   signal: AbortSignal,
 ): Promise<Exchanged> {
-  const target = await deps.target(collectionId, connectorId, false);
+  const target = await deps.target(agentId, connectorId, false);
   if (target.kind !== 'ok') return { kind: target.kind };
   let upstream = await forward(req, target, body, signal);
   if (!authFailed(upstream.status)) return { kind: 'response', upstream };
   await upstream.body?.cancel();
-  const fresh = await deps.target(collectionId, connectorId, true);
+  const fresh = await deps.target(agentId, connectorId, true);
   if (fresh.kind !== 'ok') return { kind: 'signin' };
   upstream = await forward(req, fresh, body, signal);
   if (!authFailed(upstream.status)) return { kind: 'response', upstream };
@@ -218,7 +219,7 @@ async function exchange(
 async function relayExchange(
   req: IncomingMessage,
   res: ServerResponse,
-  collectionId: string,
+  agentId: string,
   connectorId: string,
   deps: RelayApiDeps,
 ): Promise<void> {
@@ -234,7 +235,7 @@ async function relayExchange(
   const body = req.method === 'POST' ? await readCapped(req) : null;
   const out = await exchange(
     req,
-    collectionId,
+    agentId,
     connectorId,
     deps,
     body,
@@ -262,13 +263,14 @@ function dispatch(
   connectorId: string,
   deps: RelayApiDeps,
 ): void {
-  const who = cliIdentity(req);
+  const who = agentIdentity(req);
   if (who === null) {
     answer(res, 401, { error: 'unauthorized' });
     return;
   }
-  relayExchange(req, res, who.collectionId, connectorId, deps).catch(
-    (err: unknown) => {
+  assertLease(who, deps.fence)
+    .then(() => relayExchange(req, res, who.agentId, connectorId, deps))
+    .catch((err: unknown) => {
       if (err instanceof ApiError) {
         answer(res, err.status, { error: err.message });
       } else {
@@ -277,8 +279,7 @@ function dispatch(
         if (!res.writableEnded) res.end();
       }
       closeIfBodyUnread(req, res);
-    },
-  );
+    });
 }
 
 export function handleRelayRequest(

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

@@ -8,7 +8,7 @@ import {
   runIdentity,
   sendJson,
 } from './api-http.js';
-import { RUN_CODE_RE, takeRunCode } from './run-pair.js';
+import { AGENT_CODE_RE, takeAgentCode } from './agent-pair.js';
 import { sessionTtlFromEnv } from './google-oauth.js';
 import { signRunToken } from './session.js';
 import type { LoadedAgent } from '../db/materialize.js';
@@ -27,6 +27,7 @@ export interface RunApiDeps {
   fenceRuntime: (runtimeId: string, agentId: string) => Promise<void>;
   touchRuntime: (runtimeId: string) => Promise<void>;
   loadAgent: (agentId: string) => Promise<LoadedAgent>;
+  blockedStations: (agentId: string) => Promise<string[]>;
 }
 
 function secretOrNull(): string | null {
@@ -53,20 +54,28 @@ async function handleClaim(
   const body = await readJsonBody(req);
   const raw = bodyField(body, 'code');
   const code = typeof raw === 'string' ? raw.trim() : '';
-  if (!RUN_CODE_RE.test(code)) {
+  if (!AGENT_CODE_RE.test(code)) {
     sendJson(req, res, 400, {
       error:
-        'that does not look like a runtime code — metro start wants the mr_… code from the agent page',
+        'that does not look like an agent code — metro start wants the ma_… code from the agent page',
     });
     return;
   }
-  const taken = takeRunCode(code);
+  const taken = takeAgentCode(code);
   if (taken === undefined) {
     sendJson(req, res, 400, {
       error: 'that code has expired or was already used',
     });
     return;
   }
+  const blocked = await deps.blockedStations(taken.agentId);
+  if (blocked.length > 0) {
+    sendJson(req, res, 409, {
+      error:
+        `this agent holds ${blocked.join(', ')}, which only runs on metro because a webhook url has to be publicly reachable. Detach it, or move it to a second agent that stays on metro, then start this one.`,
+    });
+    return;
+  }
   const lease = await deps.claimRuntime(taken.agentId, labelOf(body));
   const token = signRunToken(
     { email: taken.email, agentId: lease.agentId, runtimeId: lease.runtimeId },

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

@@ -5,7 +5,6 @@ import {
   handleConnectorApiRequest,
   type ConnectorApiDeps,
 } from './connector-api.js';
-import { handleCollectionApiRequest } from './collection-api.js';
 import { handleCliPairRequest } from './cli-pair-api.js';
 import { handleRunApiRequest, type RunApiDeps } from './run-api.js';
 import type { RelayApiDeps } from './relay.js';
@@ -13,9 +12,14 @@ import {
   handleProjectApiRequest,
   type ProjectApiDeps,
 } from './project-api.js';
+import {
+  handleAgentConnectorRequest,
+  type AgentConnectorApiDeps,
+} from './agent-connector-api.js';
 
 export interface SessionApis {
   agentApi?: AgentApiDeps;
+  agentConnectorApi?: AgentConnectorApiDeps;
   connectorApi?: ConnectorApiDeps;
   projectApi?: ProjectApiDeps;
   runApi?: RunApiDeps;
@@ -27,7 +31,7 @@ export function handleSessionApis(
   res: ServerResponse,
   apis: SessionApis,
 ): boolean {
-  const { agentApi, connectorApi, projectApi, runApi } = apis;
+  const { agentApi, agentConnectorApi, connectorApi, projectApi, runApi } = apis;
   const routes: (() => boolean)[] = [() => handleSessionApiRequest(req, res)];
   if (runApi) routes.push(() => handleRunApiRequest(req, res, runApi));
   if (projectApi)
@@ -35,9 +39,10 @@ export function handleSessionApis(
   if (connectorApi)
     routes.push(
       () => handleCliPairRequest(req, res, connectorApi),
-      () => handleCollectionApiRequest(req, res, connectorApi),
       () => handleConnectorApiRequest(req, res, connectorApi),
     );
+  if (agentConnectorApi)
+    routes.push(() => handleAgentConnectorRequest(req, res, agentConnectorApi));
   if (agentApi) routes.push(() => handleAgentApiRequest(req, res, agentApi));
   return routes.some((run) => run());
 }

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

@@ -99,9 +99,9 @@ interface SessionClaims {
   agentIds: string[];
 }
 
-export interface CliClaims {
+export interface AgentClaims {
   email: string;
-  collectionId: string;
+  agentId: string;
 }
 
 export interface RunClaims {
@@ -147,17 +147,17 @@ export function verifySession(
   return { email: p.sub, agentIds: ids as string[] };
 }
 
-export function signCliToken(
-  claims: CliClaims,
+export function signAgentToken(
+  claims: AgentClaims,
   secret: string,
   opts: { ttlSec?: number; now?: number } = {},
 ): string {
   const iat = nowSec(opts.now);
   return sign(
     {
-      typ: 'cli',
+      typ: 'agent',
       sub: claims.email,
-      collection: claims.collectionId,
+      agent: claims.agentId,
       iat,
       exp: iat + (opts.ttlSec ?? 30 * 24 * 3600),
     },
@@ -165,18 +165,18 @@ export function signCliToken(
   );
 }
 
-export function verifyCliToken(
+export function verifyAgentToken(
   token: string,
   secret: string,
   now?: number,
-): CliClaims {
+): AgentClaims {
   const p = verify(token, secret);
-  if (p.typ !== 'cli') throw new SessionError('wrong token type');
+  if (p.typ !== 'agent') throw new SessionError('wrong token type');
   if (typeof p.exp !== 'number' || p.exp < nowSec(now))
-    throw new SessionError('cli token expired');
-  if (typeof p.sub !== 'string' || typeof p.collection !== 'string')
-    throw new SessionError('malformed cli token');
-  return { email: p.sub, collectionId: p.collection };
+    throw new SessionError('agent token expired');
+  if (typeof p.sub !== 'string' || typeof p.agent !== 'string')
+    throw new SessionError('malformed agent token');
+  return { email: p.sub, agentId: p.agent };
 }
 
 export function signRunToken(

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

@@ -0,0 +1,143 @@
+import { and, asc, eq, inArray, ne } from 'drizzle-orm';
+import { getDb } from './client.js';
+import { newId } from './ids.js';
+import { isUniqueViolation } from './users.js';
+import { ownedAgentOrThrow } from './agent-admin.js';
+import { ConnectorError } from './connector-config.js';
+import { agentConnectors, agents, connectors } from './schema.js';
+
+export interface AgentConnectors {
+  id: string;
+  name: string;
+  connectorIds: string[];
+}
+
+const nameClash = (name: string, agent: string): ConnectorError =>
+  new ConnectorError(
+    `the agent '${agent}' already has a connector named '${name}'`,
+    409,
+  );
+
+async function collidingAgent(
+  agentIds: string[],
+  name: string,
+  exceptConnectorId: string,
+): Promise<string | null> {
+  if (agentIds.length === 0) return null;
+  const rows = await getDb()
+    .select({ agent: agents.name })
+    .from(agentConnectors)
+    .innerJoin(connectors, eq(connectors.id, agentConnectors.connectorId))
+    .innerJoin(agents, eq(agents.id, agentConnectors.agentId))
+    .where(
+      and(
+        inArray(agentConnectors.agentId, agentIds),
+        eq(connectors.name, name),
+        ne(connectors.id, exceptConnectorId),
+      ),
+    )
+    .limit(1);
+  return rows[0]?.agent ?? null;
+}
+
+export async function assertRenameFreeOfClash(
+  connectorId: string,
+  name: string,
+): Promise<void> {
+  const rows = await getDb()
+    .select({ agentId: agentConnectors.agentId })
+    .from(agentConnectors)
+    .where(eq(agentConnectors.connectorId, connectorId));
+  const clash = await collidingAgent(
+    rows.map((r) => r.agentId),
+    name,
+    connectorId,
+  );
+  if (clash !== null) throw nameClash(name, clash);
+}
+
+export async function connectorIdsOfAgent(agentId: string): Promise<string[]> {
+  const rows = await getDb()
+    .select({ connectorId: agentConnectors.connectorId })
+    .from(agentConnectors)
+    .where(eq(agentConnectors.agentId, agentId))
+    .orderBy(asc(agentConnectors.id));
+  return rows.map((r) => r.connectorId);
+}
+
+export async function connectorIdsByAgent(
+  agentIds: string[],
+): Promise<Map<string, string[]>> {
+  const out = new Map<string, string[]>();
+  if (agentIds.length === 0) return out;
+  const rows = await getDb()
+    .select({
+      agentId: agentConnectors.agentId,
+      connectorId: agentConnectors.connectorId,
+    })
+    .from(agentConnectors)
+    .where(inArray(agentConnectors.agentId, agentIds))
+    .orderBy(asc(agentConnectors.id));
+  for (const row of rows) {
+    const list = out.get(row.agentId) ?? [];
+    list.push(row.connectorId);
+    out.set(row.agentId, list);
+  }
+  return out;
+}
+
+export async function agentConnectorsForEmail(
+  email: string,
+  agentId: string,
+): Promise<AgentConnectors> {
+  const { agent } = await ownedAgentOrThrow(email, agentId);
+  return { ...agent, connectorIds: await connectorIdsOfAgent(agent.id) };
+}
+
+async function connectorNameIn(
+  projectId: string,
+  connectorId: string,
+): Promise<string | null> {
+  const rows = await getDb()
+    .select({ name: connectors.name })
+    .from(connectors)
+    .where(and(eq(connectors.id, connectorId), eq(connectors.projectId, projectId)));
+  return rows[0]?.name ?? null;
+}
+
+export async function addConnectorToAgentForEmail(
+  email: string,
+  agentId: string,
+  connectorId: string,
+): Promise<AgentConnectors> {
+  const { agent, projectId } = await ownedAgentOrThrow(email, agentId);
+  const name = await connectorNameIn(projectId, connectorId);
+  if (name === null) throw new ConnectorError('no such connector', 404);
+  const clash = await collidingAgent([agent.id], name, connectorId);
+  if (clash !== null) throw nameClash(name, clash);
+  try {
+    await getDb()
+      .insert(agentConnectors)
+      .values({ id: newId(), agentId: agent.id, connectorId });
+  } catch (err) {
+    if (!isUniqueViolation(err)) throw err;
+  }
+  return { ...agent, connectorIds: await connectorIdsOfAgent(agent.id) };
+}
+
+export async function removeConnectorFromAgentForEmail(
+  email: string,
+  agentId: string,
+  connectorId: string,
+): Promise<AgentConnectors> {
+  const { agent } = await ownedAgentOrThrow(email, agentId);
+  await getDb()
+    .delete(agentConnectors)
+    .where(
+      and(
+        eq(agentConnectors.agentId, agent.id),
+        eq(agentConnectors.connectorId, connectorId),
+      ),
+    );
+  return { ...agent, connectorIds: await connectorIdsOfAgent(agent.id) };
+}

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

@@ -8,7 +8,7 @@ import {
 import { errMsg, log } from '../daemon/log.js';
 import { readConfig, type ConnectorConfig } from './connector-config.js';
 import { getDb } from './client.js';
-import { collectionItems, connectors } from './schema.js';
+import { agentConnectors, connectors } from './schema.js';
 
 export type RelayTarget =
   | { kind: 'ok'; url: string; headers: Record<string, string> }
@@ -32,17 +32,17 @@ export function headerAuthHeaders(
 }
 
 async function memberRow(
-  collectionId: string,
+  agentId: string,
   connectorId: string,
 ): Promise<ConnectorRow | undefined> {
   const rows = await getDb()
     .select({ connector: connectors })
-    .from(collectionItems)
-    .innerJoin(connectors, eq(collectionItems.connectorId, connectors.id))
+    .from(agentConnectors)
+    .innerJoin(connectors, eq(agentConnectors.connectorId, connectors.id))
     .where(
       and(
-        eq(collectionItems.collectionId, collectionId),
-        eq(collectionItems.connectorId, connectorId),
+        eq(agentConnectors.agentId, agentId),
+        eq(agentConnectors.connectorId, connectorId),
       ),
     );
   return rows[0]?.connector;
@@ -112,11 +112,11 @@ export function fixedTarget(
 }
 
 export async function relayTarget(
-  collectionId: string,
+  agentId: string,
   connectorId: string,
   force: boolean,
 ): Promise<RelayTarget> {
-  const row = await memberRow(collectionId, connectorId);
+  const row = await memberRow(agentId, connectorId);
   if (row === undefined) return { kind: 'missing' };
   parseConnectorUrl(row.url);
   const config = readConfig(row.config);

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

@@ -1,4 +1,4 @@
-import { assertRenameFreeOfClash } from './connector-collections.js';
+import { assertRenameFreeOfClash } from './agent-connectors.js';
 import { projectIdOrThrow } from './projects.js';
 import { and, asc, eq, inArray } from 'drizzle-orm';
 import {

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

@@ -188,7 +188,7 @@ export async function deleteProjectForEmail(
     await getDb().delete(projects).where(eq(projects.id, access.projectId));
   } catch {
     throw new ProjectError(
-      'this project still holds agents, connectors or collections',
+      'this project still holds agents or connectors',
       409,
     );
   }

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

@@ -1,25 +1,18 @@
 import { ownedAgentOrThrow } from './agent-admin.js';
-import { ApiError } from '../daemon/api-error.js';
-import { mintRunCode } from '../daemon/run-pair.js';
+import { mintAgentCode } from '../daemon/agent-pair.js';
 import { loadAllStationsFor, unmovableStations } from './materialize.js';
 import { releaseRuntime } from './runtimes.js';
 
-export async function mintRuntimeCodeForEmail(
+export async function mintAgentCodeForEmail(
   email: string,
   agentId: string,
-): Promise<{ code: string; expiresAt: number }> {
+): Promise<{ code: string; expiresAt: number; agent: string }> {
   const { agent } = await ownedAgentOrThrow(email, agentId);
-  const blocked = unmovableStations(await loadAllStationsFor(agent.id));
-  if (blocked.length > 0)
-    throw new ApiError(
-      `'${agent.name}' holds ${blocked.join(', ')}, which only runs on metro ` +
-        'because a webhook url has to be publicly reachable. Its deliveries ' +
-        'would arrive at metro while this agent listens on your machine, so ' +
-        'they would be dropped. Detach it, or attach it to a second agent that ' +
-        'stays on metro, then authorize this one.',
-      409,
-    );
-  return mintRunCode({ email, agentId: agent.id });
+  return { ...mintAgentCode({ email, agentId: agent.id }), agent: agent.name };
+}
+
+export async function blockedStationsFor(agentId: string): Promise<string[]> {
+  return unmovableStations(await loadAllStationsFor(agentId));
 }
 
 export async function releaseRuntimeForEmail(

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

@@ -97,34 +97,20 @@ export const connectors = pgTable(
   },
 );
 
-export const collections = pgTable(
-  'collections',
+export const agentConnectors = pgTable(
+  'agent_connectors',
   {
     id: text('id').primaryKey(),
-    projectId: text('project_id')
-      .notNull()
-      .references(() => projects.id, { onDelete: 'restrict' }),
-    name: text('name').notNull(),
-  },
-  (t) => [
-    unique('collections_project_id_name_unique').on(t.projectId, t.name),
-  ],
-);
-
-export const collectionItems = pgTable(
-  'collection_items',
-  {
-    id: text('id').primaryKey(),
-    collectionId: text('collection_id')
+    agentId: text('agent_id')
       .notNull()
-      .references(() => collections.id, { onDelete: 'cascade' }),
+      .references(() => agents.id, { onDelete: 'cascade' }),
     connectorId: text('connector_id')
       .notNull()
       .references(() => connectors.id, { onDelete: 'cascade' }),
   },
   (t) => [
-    unique('collection_items_collection_id_connector_id_unique').on(
-      t.collectionId,
+    unique('agent_connectors_agent_id_connector_id_unique').on(
+      t.agentId,
       t.connectorId,
     ),
   ],

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

@@ -8,12 +8,17 @@ const UNIQUE_VIOLATION = '23505';
 
 export class UserError extends ApiError {}
 
+const CAUSE_DEPTH = 5;
+
 export function isUniqueViolation(err: unknown): boolean {
-  return (
-    typeof err === 'object' &&
-    err !== null &&
-    (err as { code?: unknown }).code === UNIQUE_VIOLATION
-  );
+  let current: unknown = err;
+  for (let depth = 0; depth < CAUSE_DEPTH; depth += 1) {
+    if (typeof current !== 'object' || current === null) return false;
+    const { code, cause } = current as { code?: unknown; cause?: unknown };
+    if (code === UNIQUE_VIOLATION) return true;
+    current = cause;
+  }
+  return false;
 }
 
 export function normalizeEmail(raw: string): string {

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.30"
+  "version": "0.1.0-beta.31"
 }

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

@@ -1,20 +0,0 @@
-import { makeCodeStore } from './pair-codes.js';
-
-export interface CliCode {
-  email: string;
-  collectionId: string;
-}
-
-const store = makeCodeStore<CliCode>('mc');
-
-export const CLI_CODE_RE = store.pattern;
-
-export const mintCliCode = (
-  entry: CliCode,
-  now?: number,
-): { code: string; expiresAt: number } => store.mint(entry, now);
-
-export const takeCliCode = (code: string, now?: number): CliCode | undefined =>
-  store.take(code, now);
-
-export const cliCodeCount = (): number => store.count();