@stage-labs/metro 0.1.0-beta.50 → 0.1.0-beta.52

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

@@ -1,14 +1,6 @@
 import { randomBytes } from 'node:crypto';
-import { and, asc, eq, inArray } from 'drizzle-orm';
 import { ApiError } from '../daemon/api-error.js';
-import { getDb } from './client.js';
-import { registerKey, rotateAgentKey, unregisterAgentKey } from './key-map.js';
-import { AGENT_NAME_RE, newId, parseId } from './ids.js';
-import { agents, stations } from './schema.js';
-import { isUniqueViolation } from './users.js';
-import { projectIdOrThrow } from './projects.js';
-
-const KEY_ATTEMPTS = 5;
+import { AGENT_NAME_RE } from './ids.js';
 
 export class AgentAdminError extends ApiError {}
 
@@ -49,166 +41,3 @@ export function normalizeAgentName(raw: unknown): string {
 export function newApiKey(): string {
   return `mk_${randomBytes(32).toString('base64url')}`;
 }
-
-const agentPin = (): string => process.env.METRO_AGENT?.trim() ?? '';
-
-export function servesEveryAgent(): boolean {
-  return agentPin() === '';
-}
-
-export function daemonServesAgent(id: string): boolean {
-  const pin = agentPin();
-  return pin === '' || pin === id;
-}
-
-interface AgentRow {
-  id: string;
-  name: string;
-  projectId: string;
-}
-
-interface KeyRow {
-  agentId: string;
-  key: string | null;
-}
-
-export function toAgentSummaries(
-  rows: AgentRow[],
-  keyRows: KeyRow[],
-): AgentSummary[] {
-  return rows.map((r) => ({
-    id: r.id,
-    name: r.name,
-    owned: true,
-    key: keyRows.find((k) => k.agentId === r.id)?.key ?? null,
-  }));
-}
-
-async function selectKeyRows(ids: string[]): Promise<KeyRow[]> {
-  if (ids.length === 0) return [];
-  return getDb()
-    .select({ agentId: agents.id, key: agents.key })
-    .from(agents)
-    .where(inArray(agents.id, ids));
-}
-
-export async function listAgentsForUser(
-  subject: string,
-  project: string,
-): Promise<AgentSummary[]> {
-  const projectId = await projectIdOrThrow(subject, project);
-  const rows = await getDb()
-    .select({ id: agents.id, name: agents.name, projectId: agents.projectId })
-    .from(agents)
-    .where(eq(agents.projectId, projectId))
-    .orderBy(asc(agents.name), asc(agents.id));
-  if (rows.length === 0) return [];
-  const keyRows = await selectKeyRows(rows.map((r) => r.id));
-  return toAgentSummaries(rows, keyRows);
-}
-
-async function insertAgent(
-  projectId: string,
-  name: string,
-  key: string,
-): Promise<string> {
-  const inserted = await getDb()
-    .insert(agents)
-    .values({ id: newId(), name, projectId, key })
-    .returning({ id: agents.id });
-  const id = inserted[0]?.id;
-  if (id === undefined)
-    throw new AgentAdminError('agent insert returned no id', 500);
-  return id;
-}
-
-export async function createAgentForUser(
-  subject: string,
-  project: string,
-  rawName: string,
-): Promise<CreatedAgent> {
-  const name = normalizeAgentName(rawName);
-  const key = newApiKey();
-  const id = await insertAgent(await projectIdOrThrow(subject, project), name, key);
-  if (servesEveryAgent()) registerKey(key, id);
-  return { id, name, key };
-}
-
-export function parseAgentId(raw: string): string | null {
-  return parseId(raw);
-}
-
-interface Deletable {
-  agent: DeletedAgent;
-  projectId: string;
-}
-
-export async function ownedAgentOrThrow(
-  subject: string,
-  id: string,
-): Promise<Deletable> {
-  const rows = await getDb().select().from(agents).where(eq(agents.id, id));
-  const row = rows[0];
-  const missing = new AgentAdminError('no such agent', 404);
-  if (!row) throw missing;
-  try {
-    await projectIdOrThrow(subject, row.projectId);
-  } catch {
-    throw missing;
-  }
-  return { agent: { id: row.id, name: row.name }, projectId: row.projectId };
-}
-
-async function writeNewKey(id: string, projectId: string): Promise<string> {
-  for (let attempt = 0; attempt < KEY_ATTEMPTS; attempt += 1) {
-    const key = newApiKey();
-    try {
-      const changed = await getDb()
-        .update(agents)
-        .set({ key })
-        .where(and(eq(agents.id, id), eq(agents.projectId, projectId)))
-        .returning({ id: agents.id });
-      if (changed.length === 0)
-        throw new AgentAdminError('no such agent', 404);
-      return key;
-    } catch (err) {
-      if (!isUniqueViolation(err)) throw err;
-    }
-  }
-  throw new AgentAdminError('could not allocate a free api key', 500);
-}
-
-export async function resetAgentKeyForUser(
-  subject: string,
-  id: string,
-): Promise<ResetAgentKey> {
-  const { agent, projectId } = await ownedAgentOrThrow(subject, id);
-  const key = await writeNewKey(agent.id, projectId);
-  rotateAgentKey(agent.id, daemonServesAgent(agent.id) ? key : null);
-  return { id: agent.id, name: agent.name, key };
-}
-
-export async function deleteAgentForUser(
-  subject: string,
-  id: string,
-): Promise<DeletedAgent> {
-  const { agent, projectId } = await ownedAgentOrThrow(subject, id);
-  await getDb().transaction(async (tx) => {
-    const attached = await tx
-      .select({ id: stations.id })
-      .from(stations)
-      .where(eq(stations.agentId, id));
-    if (attached.length > 0)
-      throw new AgentAdminError(
-        `agent '${agent.name}' still has ${attached.length} station account(s) attached — an operator must remove them first`,
-        409,
-      );
-    const gone = await tx
-      .delete(agents)
-      .where(and(eq(agents.id, id), eq(agents.projectId, projectId)))
-      .returning({ id: agents.id });
-    if (gone.length === 0) throw new AgentAdminError('no such agent', 404);
-  });
-  unregisterAgentKey(id);
-  return agent;
-}

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

@@ -30,8 +30,3 @@ export function getDb(): Db {
   return db;
 }
 
-export async function closeDb(): Promise<void> {
-  if (sql) await sql.end({ timeout: 5 });
-  sql = null;
-  db = null;
-}

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

@@ -1,22 +1,10 @@
-import { and, eq } from 'drizzle-orm';
-import { oauthExpired, refreshOAuth } from '../daemon/connector-oauth.js';
-import {
-  parseConnectorUrl,
-  type ConnectorAuth,
-  type OAuthAuth,
-} from '../daemon/connector-verify.js';
-import { errMsg, log } from '../daemon/log.js';
-import { readConfig, type ConnectorConfig } from './connector-config.js';
-import { getDb } from './client.js';
-import { agentConnectors, connectors } from './schema.js';
+import type { ConnectorAuth, OAuthAuth } from '../daemon/connector-verify.js';
 
 export type RelayTarget =
   | { kind: 'ok'; url: string; headers: Record<string, string> }
   | { kind: 'missing' }
   | { kind: 'signin' };
 
-type ConnectorRow = typeof connectors.$inferSelect;
-
 export const bearerHeaders = (token: string): Record<string, string> => ({
   Authorization: `Bearer ${token}`,
 });
@@ -25,54 +13,10 @@ export function staleUsable(auth: OAuthAuth, now = Date.now()): boolean {
   return auth.expiresAt === undefined || auth.expiresAt > now;
 }
 
-function headerAuthHeaders(
-  auth: ConnectorAuth,
-): Record<string, string> | null {
+function headerAuthHeaders(auth: ConnectorAuth): Record<string, string> | null {
   return auth.kind === 'header' ? { [auth.name]: auth.value } : null;
 }
 
-async function memberRow(
-  agentId: string,
-  connectorId: string,
-): Promise<ConnectorRow | undefined> {
-  const rows = await getDb()
-    .select({ connector: connectors })
-    .from(agentConnectors)
-    .innerJoin(connectors, eq(agentConnectors.connectorId, connectors.id))
-    .where(
-      and(
-        eq(agentConnectors.agentId, agentId),
-        eq(agentConnectors.connectorId, connectorId),
-      ),
-    );
-  return rows[0]?.connector;
-}
-
-const inflight = new Map<string, Promise<OAuthAuth>>();
-
-function refreshOnce(
-  row: ConnectorRow,
-  config: ConnectorConfig,
-  auth: OAuthAuth,
-): Promise<OAuthAuth> {
-  const running = inflight.get(row.id);
-  if (running !== undefined) return running;
-  const resource = parseConnectorUrl(row.url).toString();
-  const job = refreshOAuth(auth, resource)
-    .then(async (fresh) => {
-      await getDb()
-        .update(connectors)
-        .set({ config: { ...config, auth: fresh } })
-        .where(eq(connectors.id, row.id));
-      return fresh;
-    })
-    .finally(() => {
-      inflight.delete(row.id);
-    });
-  inflight.set(row.id, job);
-  return job;
-}
-
 export function unrefreshedTarget(
   url: string,
   auth: OAuthAuth,
@@ -85,23 +29,6 @@ export function unrefreshedTarget(
   return { kind: 'ok', url, headers: {} };
 }
 
-async function oauthTarget(
-  row: ConnectorRow,
-  config: ConnectorConfig,
-  auth: OAuthAuth,
-  force: boolean,
-): Promise<RelayTarget> {
-  if (!force && !oauthExpired(auth))
-    return { kind: 'ok', url: row.url, headers: bearerHeaders(auth.accessToken) };
-  try {
-    const fresh = await refreshOnce(row, config, auth);
-    return { kind: 'ok', url: row.url, headers: bearerHeaders(fresh.accessToken) };
-  } catch (err) {
-    log.warn({ id: row.id, err: errMsg(err) }, 'relay: token refresh failed');
-    return unrefreshedTarget(row.url, auth, force);
-  }
-}
-
 export function fixedTarget(
   url: string,
   auth: Exclude<ConnectorAuth, OAuthAuth>,
@@ -110,17 +37,3 @@ export function fixedTarget(
   if (force) return { kind: 'signin' };
   return { kind: 'ok', url, headers: headerAuthHeaders(auth) ?? {} };
 }
-
-export async function relayTarget(
-  agentId: string,
-  connectorId: string,
-  force: boolean,
-): Promise<RelayTarget> {
-  const row = await memberRow(agentId, connectorId);
-  if (row === undefined) return { kind: 'missing' };
-  parseConnectorUrl(row.url);
-  const config = readConfig(row.config);
-  const auth = config.auth;
-  if (auth.kind === 'oauth') return oauthTarget(row, config, auth, force);
-  return fixedTarget(row.url, auth, force);
-}

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

@@ -1,30 +1,6 @@
-import { assertRenameFreeOfClash } from './agent-connectors.js';
-import { projectIdOrThrow } from './projects.js';
-import { and, asc, eq, inArray } from 'drizzle-orm';
-import {
-  connectorUrlText,
-  ConnectorVerifyError,
-  parseConnectorUrl,
-  verifyRemoteMcp,
-  type ConnectorAuth,
-  type OAuthAuth,
-  type VerifiedRecord,
-} 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,
-  type ConnectorSignIn,
-} from './connector-config.js';
-import { newId } from './ids.js';
-import { getDb } from './client.js';
-import { connectors, type ConnectorTransport } from './schema.js';
+import type { ConnectorAuth, VerifiedRecord } from '../daemon/connector-verify.js';
+import { readConfig, signInState, type ConnectorSignIn } from './connector-config.js';
+import type { ConnectorTransport } from './schema.js';
 
 export interface Connector {
   id: string;
@@ -56,8 +32,6 @@ export interface DeletedConnector {
   name: string;
 }
 
-type ConnectorRow = typeof connectors.$inferSelect;
-
 export interface ConnectorLike {
   id: string;
   name: string;
@@ -84,71 +58,6 @@ export function connectorFromRow(row: ConnectorLike): Connector {
   };
 }
 
-const toConnector = (row: ConnectorRow): Connector => connectorFromRow(row);
-
-const missing = (): ConnectorError =>
-  new ConnectorError('no such connector', 404);
-
-async function ownedConnectorOrThrow(
-  subject: string,
-  id: string,
-): Promise<ConnectorRow> {
-  const rows = await getDb()
-    .select()
-    .from(connectors)
-    .where(eq(connectors.id, id));
-  const row = rows[0];
-  if (row === undefined) throw missing();
-  try {
-    await projectIdOrThrow(subject, row.projectId);
-  } catch {
-    throw missing();
-  }
-  return row;
-}
-
-async function saveConfig(
-  row: ConnectorRow,
-  config: ConnectorConfig,
-): Promise<Connector> {
-  const rows = await getDb()
-    .update(connectors)
-    .set({ config })
-    .where(and(eq(connectors.id, row.id), eq(connectors.projectId, row.projectId)))
-    .returning();
-  const saved = rows[0];
-  if (saved === undefined) throw missing();
-  return toConnector(saved);
-}
-
-async function connectorRowsFor(
-  subject: string,
-  project: string,
-): Promise<ConnectorRow[]> {
-  const projectId = await projectIdOrThrow(subject, project);
-  return getDb()
-    .select()
-    .from(connectors)
-    .where(eq(connectors.projectId, projectId))
-    .orderBy(asc(connectors.id));
-}
-
-export async function listConnectorsForUser(
-  subject: string,
-  project: string,
-): Promise<Connector[]> {
-  return (await connectorRowsFor(subject, project)).map(toConnector);
-}
-
-async function rowsByIds(ids: string[]): Promise<ConnectorRow[]> {
-  if (ids.length === 0) return [];
-  return getDb()
-    .select()
-    .from(connectors)
-    .where(inArray(connectors.id, ids))
-    .orderBy(asc(connectors.id));
-}
-
 export interface ConnectorSummary {
   id: string;
   name: string;
@@ -157,52 +66,6 @@ export interface ConnectorSummary {
   signIn: ConnectorSignIn;
 }
 
-export async function connectorSummariesByIds(ids: string[]): Promise<ConnectorSummary[]> {
-  return (await rowsByIds(ids)).map((row) => ({
-    id: row.id,
-    name: row.name,
-    url: row.url,
-    transport: row.transport,
-    signIn: signInState(readConfig(row.config)),
-  }));
-}
-
-export async function connectorNamesByIds(
-  ids: string[],
-): Promise<{ id: string; name: string }[]> {
-  return (await rowsByIds(ids)).map((row) => ({ id: row.id, name: row.name }));
-}
-
-export async function getConnectorForUser(
-  subject: string,
-  id: string,
-): Promise<Connector> {
-  return toConnector(await ownedConnectorOrThrow(subject, id));
-}
-
-async function insertConnector(
-  projectId: string,
-  name: string,
-  url: URL,
-  config: ConnectorConfig,
-): Promise<Connector> {
-  const rows = await getDb()
-    .insert(connectors)
-    .values({
-      id: newId(),
-      projectId,
-      name,
-      url: connectorUrlText(url),
-      transport: 'http',
-      config,
-    })
-    .returning();
-  const row = rows[0];
-  if (row === undefined)
-    throw new ConnectorError('connector insert returned no row', 500);
-  return toConnector(row);
-}
-
 export const UNVERIFIED = {
   at: '',
   server: '',
@@ -212,125 +75,3 @@ export const UNVERIFIED = {
   tools: 0,
   catalog: [],
 };
-
-export async function createPendingConnectorForUser(
-  subject: string,
-  project: string,
-  input: { name: unknown; url: unknown },
-): Promise<Connector> {
-  const name = connectorName(input.name);
-  const url = parseConnectorUrl(input.url);
-  const projectId = await projectIdOrThrow(subject, project);
-  return insertConnector(projectId, name, url, {
-    auth: { kind: 'none' },
-    createdAt: new Date().toISOString(),
-    verified: UNVERIFIED,
-    oauth: true,
-  });
-}
-
-export async function createConnectorForUser(
-  subject: string,
-  project: string,
-  input: ConnectorInput,
-): Promise<Connector> {
-  const name = connectorName(input.name);
-  const url = parseConnectorUrl(input.url);
-  const auth = connectorAuth(input.header, input.value);
-  const projectId = await projectIdOrThrow(subject, project);
-  const verified = stamp(await verifyRemoteMcp(url, auth));
-  return insertConnector(projectId, name, url, {
-    auth,
-    createdAt: new Date().toISOString(),
-    verified,
-    oauth: await oauthCapable(url, auth),
-  });
-}
-
-async function oauthCapable(url: URL, auth: ConnectorAuth): Promise<boolean> {
-  if (auth.kind === 'oauth') return true;
-  if (auth.kind === 'header') return false;
-  return advertisesOAuth(url);
-}
-
-async function freshAuth(
-  auth: ConnectorAuth,
-  resource: string,
-): Promise<ConnectorAuth> {
-  if (auth.kind !== 'oauth' || !oauthExpired(auth)) return auth;
-  return refreshOAuth(auth, resource);
-}
-
-export async function reconnectConnectorForUser(
-  subject: string,
-  id: string,
-  auth: OAuthAuth,
-): Promise<Connector> {
-  const row = await ownedConnectorOrThrow(subject, id);
-  const config = readConfig(row.config);
-  const url = parseConnectorUrl(row.url);
-  const verified = stamp(await verifyRemoteMcp(url, auth));
-  return saveConfig(row, { ...config, auth, verified, oauth: true });
-}
-
-export async function disconnectConnectorForUser(
-  subject: string,
-  id: string,
-): Promise<Connector> {
-  const row = await ownedConnectorOrThrow(subject, id);
-  const config = readConfig(row.config);
-  if (config.auth.kind !== 'oauth')
-    throw new ConnectorError('that connector is not signed in', 400);
-  return saveConfig(row, { ...config, auth: { kind: 'none' }, oauth: true });
-}
-
-export async function verifyConnectorForUser(
-  subject: string,
-  id: string,
-): Promise<ConnectorCheck> {
-  const row = await ownedConnectorOrThrow(subject, id);
-  const config = readConfig(row.config);
-  try {
-    const url = parseConnectorUrl(row.url);
-    const auth = await freshAuth(config.auth, url.toString());
-    const verified = stamp(await verifyRemoteMcp(url, auth));
-    const oauth = config.oauth || (await oauthCapable(url, auth));
-    await saveConfig(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 };
-  }
-}
-
-export async function renameConnectorForUser(
-  subject: string,
-  id: string,
-  raw: string,
-): Promise<Connector> {
-  const name = connectorName(raw);
-  const row = await ownedConnectorOrThrow(subject, id);
-  await assertRenameFreeOfClash(row.id, name);
-  const rows = await getDb()
-    .update(connectors)
-    .set({ name })
-    .where(and(eq(connectors.id, row.id), eq(connectors.projectId, row.projectId)))
-    .returning();
-  const saved = rows[0];
-  if (saved === undefined) throw missing();
-  return toConnector(saved);
-}
-
-export async function deleteConnectorForUser(
-  subject: string,
-  id: string,
-): Promise<DeletedConnector> {
-  const row = await ownedConnectorOrThrow(subject, id);
-  const gone = await getDb()
-    .delete(connectors)
-    .where(eq(connectors.id, row.id))
-    .returning({ id: connectors.id, name: connectors.name });
-  const deleted = gone[0];
-  if (deleted === undefined) throw missing();
-  return deleted;
-}

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

@@ -35,7 +35,7 @@ import {
   type ConnectorSummary,
   type DeletedConnector,
 } from './connectors.js';
-import type { AgentConnectors } from './agent-connectors.js';
+import type { AgentConnectors } from '../daemon/agent-connector-api.js';
 import { agentsDir } from './file-source.js';
 import {
   assertLocalOwner,