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

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,15 @@ 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 },
     mode: localModeInfo,

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,17 +18,16 @@ 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';
 
 export interface SessionApis {
   agentApi?: AgentApiDeps;
   agentConnectorApi?: AgentConnectorApiDeps;
   importApi?: ImportApiDeps;
-  localConnectors?: LocalConnectorsDeps;
+  localCli?: LocalCliDeps;
+  claudeApi?: ClaudeApiDeps;
   connectorApi?: ConnectorApiDeps;
   projectApi?: ProjectApiDeps;
   runApi?: RunApiDeps;
@@ -43,8 +42,9 @@ export function handleSessionApis(
   apis: SessionApis,
 ): boolean {
   const { agentApi, agentConnectorApi, connectorApi, projectApi, runApi, importApi } = apis;
-  const { localConnectors } = 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));
@@ -54,8 +54,7 @@ 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));
   if (agentApi) routes.push(() => handleAgentApiRequest(req, res, agentApi));

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