@stage-labs/metro 0.1.0-beta.69 → 0.1.0-beta.70

package/package.json

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

@@ -32,7 +32,6 @@
   "scripts": {
     "start": "bun src/server.ts",
     "build": "tsc",
-    "db:generate": "drizzle-kit generate",
     "db:migrate": "drizzle-kit migrate",
     "test": "tsc --noEmit && DYLD_FALLBACK_LIBRARY_PATH=/usr/lib METRO_STATE_DIR=\"$(mktemp -d /tmp/metro-test.XXXXXX)\" bun test test/"
   },

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

@@ -1,4 +1,3 @@
-import type { ConnectorSummary } from '../db/connectors.js';
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import { errMsg, log } from './log.js';
 import {
@@ -12,7 +11,6 @@ import {
   type ApiSession,
 } from './api-http.js';
 import { parseId } from '../db/ids.js';
-import type { RelayServerEntry } from './connector-json.js';
 import {
   handleCallback,
   handleConnect,
@@ -35,8 +33,6 @@ const asText = (value: unknown): string =>
 
 export interface ConnectorApiDeps extends OAuthRouteDeps {
   listConnectors: (subject: string, project: string) => Promise<Connector[]>;
-  connectorSummariesByIds: (ids: string[]) => Promise<ConnectorSummary[]>;
-  connectorNamesByIds: (ids: string[]) => Promise<RelayServerEntry[]>;
   createConnector: (
     subject: string,
     project: string,

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

@@ -4,14 +4,12 @@ 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';
+const PATH = '/api/cli/mcp';
 
 export interface LocalCliDeps {
   agentName: (agentId: string) => string | null;
   connectorEntries: (agentId: string) => Promise<RelayServerEntry[]>;
-  connectorSummaries: (agentId: string) => Promise<ConnectorSummary[]>;
 }
 
 function keyOf(req: IncomingMessage): string {
@@ -27,25 +25,18 @@ export function keyIdentity(req: IncomingMessage): AgentIdentity | null {
   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 { 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 (path !== PATH && !path.startsWith('/api/cli/')) return false;
   if (req.method === 'OPTIONS') {
     res.writeHead(204, cors(req)).end();
     return true;
   }
-  if (![`${PREFIX}/mcp`, `${PREFIX}/session`, `${PREFIX}/connectors`].includes(path)) {
+  if (path !== PATH) {
     sendJson(req, res, 404, { error: 'not on a local daemon' });
     return true;
   }
@@ -58,9 +49,11 @@ export function handleLocalCliRequest(
     sendJson(req, res, 401, { error: 'unauthorized' });
     return true;
   }
-  answer(path, keyOf(req), who.agentId, deps)
-    .then((body) => {
-      sendJson(req, res, 200, body);
+  deps
+    .connectorEntries(who.agentId)
+    .then((entries) => {
+      const agent = deps.agentName(who.agentId) ?? '';
+      sendJson(req, res, 200, { json: relayServersJson(entries, publicBaseOrDefault(), keyOf(req)), agent });
     })
     .catch((err: unknown) => {
       log.warn({ err: errMsg(err) }, 'local cli: request failed');

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

@@ -3,7 +3,6 @@ import { errMsg, log } from './log.js';
 import { AttachSessions } from './attach-session.js';
 import type { AgentApiDeps } from './agent-api.js';
 import { ATTACHABLE, type AccountApiDeps } from './account-api.js';
-import type { AgentConnectorApiDeps } from './agent-connector-api.js';
 import type { SessionApis } from './session-apis.js';
 import type { ModeInfo } from './mode-api.js';
 import { loadedAgentOf, type AgentBundle, type BundleApiDeps } from './bundle-api.js';
@@ -15,10 +14,7 @@ import type { RelayApiDeps } from './relay.js';
 import {
   readLocalConnectors,
   localImportConnectors,
-  localAddConnector,
-  localAgentConnectors,
   localConnectorNamesByIds,
-  localConnectorSummariesByIds,
   localCreateConnector,
   localCreatePendingConnector,
   localDeleteConnector,
@@ -27,13 +23,11 @@ import {
   localListConnectors,
   localReconnectConnector,
   localRelayTarget,
-  localRemoveConnector,
   localRenameConnector,
   localVerifyConnector,
 } from '../db/local-connectors.js';
 import {
   assertLocalOwner,
-  connectorIdsOfLocalAgent,
   LOCAL_PROJECT_ID,
   localAttachAccount,
   localCreateAgent,
@@ -106,20 +100,15 @@ function agentApi(deps: LocalModeDeps): AgentApiDeps {
   };
 }
 
+const allConnectorIds = (): string[] => readLocalConnectors().map((c) => c.id);
+
 function connectorIdsOfLocalAgents(ids: string[]): Promise<Map<string, string[]>> {
-  return Promise.resolve(new Map(ids.map((id) => [id, connectorIdsOfLocalAgent(id) ?? []] as const)));
+  const all = allConnectorIds();
+  return Promise.resolve(new Map(ids.map((id) => [id, all] as const)));
 }
 
-const agentConnectorApi: AgentConnectorApiDeps = {
-  agentConnectors: localAgentConnectors,
-  addConnector: localAddConnector,
-  removeConnector: localRemoveConnector,
-};
-
 const connectorApi: ConnectorApiDeps = {
   listConnectors: localListConnectors,
-  connectorSummariesByIds: (ids) => localConnectorSummariesByIds(ids),
-  connectorNamesByIds: (ids) => localConnectorNamesByIds(ids),
   createConnector: localCreateConnector,
   verifyConnector: localVerifyConnector,
   disconnectConnector: localDisconnectConnector,
@@ -131,7 +120,7 @@ const connectorApi: ConnectorApiDeps = {
 };
 
 const relayApi: RelayApiDeps = {
-  target: (agentId, connectorId, force) => localRelayTarget(agentId, connectorId, force),
+  target: (connectorId, force) => localRelayTarget(connectorId, force),
   identify: keyIdentity,
 };
 
@@ -143,8 +132,7 @@ function agentNameOf(agentId: string): string | null {
 
 const localCli: LocalCliDeps = {
   agentName: agentNameOf,
-  connectorEntries: (agentId) => localConnectorNamesByIds(connectorIdsOfLocalAgent(agentId) ?? []),
-  connectorSummaries: (agentId) => localConnectorSummariesByIds(connectorIdsOfLocalAgent(agentId) ?? []),
+  connectorEntries: () => localConnectorNamesByIds(allConnectorIds()),
 };
 
 function bundleApi(deps: LocalModeDeps): BundleApiDeps {
@@ -152,13 +140,10 @@ function bundleApi(deps: LocalModeDeps): BundleApiDeps {
     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 } })),
+        connectors: readLocalConnectors().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;
@@ -184,7 +169,6 @@ export function localSessionApis(deps: LocalModeDeps): SessionApis {
   allowLocalConnectors(true);
   return {
     agentApi: agentApi(deps),
-    agentConnectorApi,
     bundleApi: bundleApi(deps),
     connectorApi,
     relayApi,

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

@@ -5,11 +5,7 @@ import { ApiError } from './api-error.js';
 import { errMsg, log } from './log.js';
 
 export interface RelayApiDeps {
-  target: (
-    agentId: string,
-    connectorId: string,
-    force: boolean,
-  ) => Promise<RelayTarget>;
+  target: (connectorId: string, force: boolean) => Promise<RelayTarget>;
   identify: (req: IncomingMessage) => AgentIdentity | null;
 }
 
@@ -197,18 +193,17 @@ type Exchanged =
 
 async function exchange(
   req: IncomingMessage,
-  agentId: string,
   connectorId: string,
   deps: RelayApiDeps,
   body: Uint8Array<ArrayBuffer> | null,
   signal: AbortSignal,
 ): Promise<Exchanged> {
-  const target = await deps.target(agentId, connectorId, false);
+  const target = await deps.target(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(agentId, connectorId, true);
+  const fresh = await deps.target(connectorId, true);
   if (fresh.kind !== 'ok') return { kind: 'signin' };
   upstream = await forward(req, fresh, body, signal);
   if (!authFailed(upstream.status)) return { kind: 'response', upstream };
@@ -219,7 +214,6 @@ async function exchange(
 async function relayExchange(
   req: IncomingMessage,
   res: ServerResponse,
-  agentId: string,
   connectorId: string,
   deps: RelayApiDeps,
 ): Promise<void> {
@@ -235,7 +229,6 @@ async function relayExchange(
   const body = req.method === 'POST' ? await readCapped(req) : null;
   const out = await exchange(
     req,
-    agentId,
     connectorId,
     deps,
     body,
@@ -268,7 +261,7 @@ function dispatch(
     answer(res, 401, { error: 'unauthorized' });
     return;
   }
-  relayExchange(req, res, who.agentId, connectorId, deps)
+  relayExchange(req, res, connectorId, deps)
     .catch((err: unknown) => {
       if (err instanceof ApiError) {
         answer(res, err.status, { error: err.message });

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

@@ -6,10 +6,6 @@ import {
   type ConnectorApiDeps,
 } from './connector-api.js';
 import type { RelayApiDeps } from './relay.js';
-import {
-  handleAgentConnectorRequest,
-  type AgentConnectorApiDeps,
-} from './agent-connector-api.js';
 import type { IdentityRouteDeps } from './identity-routes.js';
 import { handleLocalCliRequest, type LocalCliDeps } from './local-cli-api.js';
 import { handleClaudeRequest, type ClaudeApiDeps } from './claude-api.js';
@@ -24,7 +20,6 @@ import { handleTerminalRequest, type TerminalApiDeps } from './terminal-api.js';
 
 export interface SessionApis {
   agentApi?: AgentApiDeps;
-  agentConnectorApi?: AgentConnectorApiDeps;
   bundleApi?: BundleApiDeps;
   vaultApi?: VaultApiDeps;
   serversApi?: ServersApiDeps;
@@ -60,7 +55,6 @@ export function handleSessionApis(
     ...when(apis.machineApi, (d) => handleMachineRequest(req, res, d)),
     ...when(apis.terminalApi, (d) => handleTerminalRequest(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/db/connectors.ts

@@ -58,14 +58,6 @@ export function connectorFromRow(row: ConnectorLike): Connector {
   };
 }
 
-export interface ConnectorSummary {
-  id: string;
-  name: string;
-  url: string;
-  transport: string;
-  signIn: ConnectorSignIn;
-}
-
 export const UNVERIFIED = {
   at: '',
   server: '',

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

@@ -267,42 +267,6 @@ export function readLocalAgentFile(agentId: string, dir = agentsDir()): AgentFil
   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;
-}
-
-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 localHoldEverywhere(connectorId: string, dir = agentsDir()): void {
-  for (const stored of storedAgents(dir)) {
-    if (stored.file.connectors.includes(connectorId)) continue;
-    stored.file.connectors = [...stored.file.connectors, connectorId];
-    save(stored);
-  }
-}
-
-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

@@ -70,14 +70,8 @@ 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;
-}
+const connectorsOf = (raw: unknown): string[] =>
+  Array.isArray(raw) ? raw.filter((id): id is string => typeof id === 'string' && ID_RE.test(id)) : [];
 
 export function parseAgentFile(raw: string, path: string): AgentFile {
   let parsed: unknown;
@@ -108,7 +102,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),
+    connectors: connectorsOf(parsed.connectors),
   };
 }
 

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

@@ -16,7 +16,6 @@ import {
   connectorAuth,
   connectorName,
   readConfig,
-  signInState,
   stamp,
   type ConnectorConfig,
 } from './connector-config.js';
@@ -32,21 +31,10 @@ import {
   type Connector,
   type ConnectorCheck,
   type ConnectorInput,
-  type ConnectorSummary,
   type DeletedConnector,
 } from './connectors.js';
-import type { AgentConnectors } from '../daemon/agent-connector-api.js';
 import { agentsDir } from './file-source.js';
-import {
-  assertLocalOwner,
-  connectorIdsOfLocalAgent,
-  localAgentConnectorIds,
-  localDropConnectorEverywhere,
-  localHoldEverywhere,
-  localOwnedAgentOrThrow,
-  localSetAgentConnectors,
-  LOCAL_PROJECT_ID,
-} from './file-admin.js';
+import { assertLocalOwner, LOCAL_PROJECT_ID } from './file-admin.js';
 import { newId } from './ids.js';
 import type { LoadedConnector } from './materialize.js';
 
@@ -130,7 +118,6 @@ export function localImportConnectors(rows: LoadedConnector[], dir = agentsDir()
   }));
   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;
 }
 
@@ -155,7 +142,6 @@ function insert(dir: string, name: string, url: URL, config: ConnectorConfig): C
   assertNameFree(name, null, dir);
   const row: LocalConnectorRow = { id: newId(), name, url: connectorUrlText(url), transport: 'http', config };
   writeRows(dir, [...readLocalConnectors(dir), row]);
-  localHoldEverywhere(row.id, dir);
   return connectorFromRow(row);
 }
 
@@ -239,44 +225,16 @@ export async function localRenameConnector(subject: string, id: string, raw: str
 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)) 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> {
@@ -306,13 +264,10 @@ async function oauthTarget(row: LocalConnectorRow, auth: OAuthAuth, force: boole
 }
 
 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);

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.69"
+  "version": "0.1.0-beta.70"
 }

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

@@ -1,138 +0,0 @@
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import { errMsg, log } from './log.js';
-import {
-  apiFailure,
-  apiSession,
-  bodyField,
-  cors,
-  readJsonBody,
-  sendJson,
-  type ApiSession,
-} from './api-http.js';
-import { parseId } from '../db/ids.js';
-
-const PREFIX = '/api/agents';
-
-export interface AgentConnectors {
-  id: string;
-  name: string;
-  connectorIds: string[];
-}
-
-export interface AgentConnectorApiDeps {
-  agentConnectors: (subject: string, agentId: string) => Promise<AgentConnectors>;
-  addConnector: (
-    subject: string,
-    agentId: string,
-    connectorId: string,
-  ) => Promise<AgentConnectors>;
-  removeConnector: (
-    subject: string,
-    agentId: string,
-    connectorId: string,
-  ) => Promise<AgentConnectors>;
-}
-
-type Routable =
-  | { kind: 'connectors'; id: string }
-  | { kind: 'connector'; id: string; connectorId: string };
-
-type Target = Routable | { kind: 'unknown' } | null;
-
-const ALLOWED: Record<Routable['kind'], string[]> = {
-  connectors: ['GET', 'POST'],
-  connector: ['DELETE'],
-};
-
-function connectorTarget(id: string, rest: string[]): Target {
-  if (rest.length === 1) return { kind: 'connectors', id };
-  if (rest.length > 2) return { kind: 'unknown' };
-  const connectorId = parseId(rest[1] ?? '');
-  return connectorId === null
-    ? { kind: 'unknown' }
-    : { kind: 'connector', id, connectorId };
-}
-
-export function target(path: string): Target {
-  if (!path.startsWith(`${PREFIX}/`)) return null;
-  const segments = path.slice(PREFIX.length + 1).split('/').filter(Boolean);
-  const id = parseId(segments[0] ?? '');
-  const head = segments[1];
-  if (id === null || head === undefined) return null;
-  if (head === 'connectors') return connectorTarget(id, segments.slice(1));
-  return null;
-}
-
-async function handleConnectors(
-  req: IncomingMessage,
-  res: ServerResponse,
-  deps: AgentConnectorApiDeps,
-  session: ApiSession,
-  id: string,
-): Promise<void> {
-  if (req.method === 'GET') {
-    sendJson(req, res, 200, await deps.agentConnectors(session.subject, id));
-    return;
-  }
-  const connectorId = bodyField(await readJsonBody(req), 'connectorId');
-  if (typeof connectorId !== 'string' || parseId(connectorId) === null) {
-    sendJson(req, res, 400, { error: 'connectorId is required' });
-    return;
-  }
-  sendJson(req, res, 200, await deps.addConnector(session.subject, id, connectorId));
-}
-
-async function route(
-  req: IncomingMessage,
-  res: ServerResponse,
-  deps: AgentConnectorApiDeps,
-  session: ApiSession,
-  tgt: Routable,
-): Promise<void> {
-  try {
-    if (tgt.kind === 'connectors') await handleConnectors(req, res, deps, session, tgt.id);
-    else
-      sendJson(
-        req,
-        res,
-        200,
-        await deps.removeConnector(session.subject, tgt.id, tgt.connectorId),
-      );
-  } catch (err) {
-    apiFailure(req, res, err, 'agent-api');
-  }
-}
-
-export function handleAgentConnectorRequest(
-  req: IncomingMessage,
-  res: ServerResponse,
-  deps: AgentConnectorApiDeps,
-): 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 connector' });
-    return true;
-  }
-  if (!ALLOWED[tgt.kind].includes(req.method ?? '')) {
-    sendJson(req, res, 405, { error: 'method not allowed' });
-    return true;
-  }
-  apiSession(req)
-    .then((session) => {
-      if (!session) {
-        sendJson(req, res, 401, { error: 'unauthorized' });
-        return;
-      }
-      return route(req, res, deps, session, tgt);
-    })
-    .catch((err: unknown) => {
-    log.warn({ err: errMsg(err) }, 'agent-api: unhandled error');
-    if (!res.headersSent) sendJson(req, res, 500, { error: 'agent api failed' });
-  });
-  return true;
-}