@stage-labs/metro 0.1.0-beta.32 → 0.1.0-beta.321

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

@@ -1,71 +0,0 @@
-export type AgentMap = Record<string, string>;
-export type AgentNameMap = Record<string, string>;
-export type AllowlistMap = Record<string, string[]>;
-
-const mapKey = (station: string, accountId: string): string =>
-  `${station}/${accountId}`;
-
-let agentMap: AgentMap = {};
-let agentNames: AgentNameMap = {};
-let allowlistMap: AllowlistMap = {};
-
-export function setAgentMap(map: AgentMap, names: AgentNameMap): void {
-  agentMap = map;
-  agentNames = names;
-}
-
-export function setAllowlistMap(map: AllowlistMap): void {
-  allowlistMap = map;
-}
-
-export function accountFromLine(
-  line: string,
-): { station: string; accountId: string } | undefined {
-  const parts = line.split('/');
-  const station = parts[2];
-  const accountId = parts[3];
-  if (!station || !accountId) return undefined;
-  return { station, accountId };
-}
-
-export function agentIdForAccount(
-  station: string,
-  accountId: string,
-): string | undefined {
-  return agentMap[mapKey(station, accountId)];
-}
-
-export function agentIdForLine(line: string): string | undefined {
-  const a = accountFromLine(line);
-  return a ? agentIdForAccount(a.station, a.accountId) : undefined;
-}
-
-export function agentForLine(line: string): string | undefined {
-  const id = agentIdForLine(line);
-  return id === undefined ? undefined : agentNames[id];
-}
-
-export function stationAgentIds(station: string): string[] {
-  const prefix = `${station}/`;
-  return Object.entries(agentMap)
-    .filter(([key]) => key.startsWith(prefix))
-    .map(([, id]) => id);
-}
-
-export function allowlistForLine(line: string): string[] | undefined {
-  const a = accountFromLine(line);
-  return a ? allowlistMap[mapKey(a.station, a.accountId)] : undefined;
-}
-
-export function senderMatchesAllowlist(
-  allowlist: string[],
-  from: string,
-): boolean {
-  if (allowlist.length === 0 || allowlist.includes('*')) return true;
-  const f = (from ?? '').toLowerCase();
-  const id = f.split('/').pop() ?? f;
-  return allowlist.some((a) => {
-    const v = a.toLowerCase();
-    return v === f || v === id;
-  });
-}

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

@@ -1,37 +0,0 @@
-import { drizzle, type PostgresJsDatabase } from 'drizzle-orm/postgres-js';
-import postgres from 'postgres';
-import { log } from '../daemon/log.js';
-import * as schema from './schema.js';
-
-export type Db = PostgresJsDatabase<typeof schema>;
-
-let sql: ReturnType<typeof postgres> | null = null;
-let db: Db | null = null;
-
-export function databaseUrl(): string | undefined {
-  const url = process.env.DATABASE_URL?.trim();
-  if (!url) return undefined;
-  return url;
-}
-
-export function getDb(): Db {
-  const url = databaseUrl();
-  if (!url) throw new Error('DATABASE_URL is not set');
-  if (!db) {
-    sql = postgres(url, {
-      max: 4,
-      prepare: false,
-      onnotice: (notice) => {
-        log.debug({ notice: notice.message }, 'postgres notice');
-      },
-    });
-    db = drizzle(sql, { schema });
-  }
-  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-config.ts

@@ -1,147 +0,0 @@
-import { ApiError } from '../daemon/api-error.js';
-import type {
-  ConnectorAuth,
-  VerifiedRecord,
-  VerifiedServer,
-} from '../daemon/connector-verify.js';
-import { readStoredTools } from '../daemon/connector-tools.js';
-
-const CONNECTOR_NAME_MAX = 64;
-const HEADER_NAME_RE = /^[A-Za-z0-9!#$%&'*+.^_`|~-]{1,64}$/;
-const HEADER_VALUE_RE = /^[\x20-\x7e]{1,4096}$/;
-const DEFAULT_HEADER = 'Authorization';
-
-export class ConnectorError extends ApiError {}
-
-export type ConnectorSignIn = 'connected' | 'disconnected' | null;
-
-export interface ConnectorConfig {
-  auth: ConnectorAuth;
-  createdAt: string;
-  verified: VerifiedRecord;
-  oauth: boolean;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
-function text(value: unknown): string {
-  return typeof value === 'string' ? value : '';
-}
-
-function hasControlChar(value: string): boolean {
-  for (const ch of value) {
-    const code = ch.codePointAt(0) ?? 0;
-    if (code < 0x20 || code === 0x7f) return true;
-  }
-  return false;
-}
-
-export function connectorName(raw: unknown): string {
-  const name = typeof raw === 'string' ? raw.trim() : '';
-  if (name === '') throw new ConnectorError('a connector needs a name', 400);
-  if (name.length > CONNECTOR_NAME_MAX)
-    throw new ConnectorError(
-      `a connector name must be ${String(CONNECTOR_NAME_MAX)} characters or fewer`,
-      400,
-    );
-  if (hasControlChar(name))
-    throw new ConnectorError(
-      'a connector name must not contain control characters',
-      400,
-    );
-  return name;
-}
-
-export function connectorAuth(
-  rawHeader: unknown,
-  rawValue: unknown,
-): ConnectorAuth {
-  const header = text(rawHeader).trim();
-  const value = text(rawValue).trim();
-  if (header === '' && value === '') return { kind: 'none' };
-  if (value === '')
-    throw new ConnectorError(
-      'that header has no value — give both a header name and its value, or neither',
-      400,
-    );
-  const name = header === '' ? DEFAULT_HEADER : header;
-  if (!HEADER_NAME_RE.test(name))
-    throw new ConnectorError('that is not a valid HTTP header name', 400);
-  if (!HEADER_VALUE_RE.test(value))
-    throw new ConnectorError('that header value is not sendable', 400);
-  return { kind: 'header', name, value };
-}
-
-function readOAuth(raw: Record<string, unknown>): ConnectorAuth {
-  const accessToken = text(raw.accessToken);
-  const clientId = text(raw.clientId);
-  const tokenEndpoint = text(raw.tokenEndpoint);
-  if (accessToken === '' || clientId === '' || tokenEndpoint === '')
-    return { kind: 'none' };
-  const refreshToken = text(raw.refreshToken);
-  const clientSecret = text(raw.clientSecret);
-  return {
-    kind: 'oauth',
-    accessToken,
-    clientId,
-    tokenEndpoint,
-    issuer: text(raw.issuer),
-    ...(refreshToken === '' ? {} : { refreshToken }),
-    ...(clientSecret === '' ? {} : { clientSecret }),
-    ...(typeof raw.expiresAt === 'number' ? { expiresAt: raw.expiresAt } : {}),
-  };
-}
-
-function readAuth(raw: unknown): ConnectorAuth {
-  if (!isRecord(raw)) return { kind: 'none' };
-  if (raw.kind === 'oauth') return readOAuth(raw);
-  if (raw.kind !== 'header') return { kind: 'none' };
-  const name = text(raw.name);
-  const value = text(raw.value);
-  if (name === '' || value === '') return { kind: 'none' };
-  return { kind: 'header', name, value };
-}
-
-function readVerified(raw: unknown): VerifiedRecord {
-  const record = isRecord(raw) ? raw : {};
-  const catalog = readStoredTools(record.catalog);
-  return {
-    at: text(record.at),
-    server: text(record.server),
-    version: text(record.version),
-    protocol: text(record.protocol),
-    icon: text(record.icon),
-    tools: typeof record.tools === 'number' ? record.tools : 0,
-    catalog,
-  };
-}
-
-export function readConfig(raw: unknown): ConnectorConfig {
-  const record = isRecord(raw) ? raw : {};
-  const auth = readAuth(record.auth);
-  return {
-    auth,
-    createdAt: text(record.createdAt),
-    verified: readVerified(record.verified),
-    oauth: record.oauth === true || auth.kind === 'oauth',
-  };
-}
-
-export function signInState(config: ConnectorConfig): ConnectorSignIn {
-  if (config.auth.kind === 'oauth') return 'connected';
-  return config.oauth ? 'disconnected' : null;
-}
-
-export function stamp(server: VerifiedServer): VerifiedRecord {
-  return {
-    at: new Date().toISOString(),
-    server: server.server,
-    version: server.version,
-    protocol: server.protocol,
-    icon: server.icon,
-    tools: server.tools,
-    catalog: server.catalog,
-  };
-}

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

@@ -1,126 +0,0 @@
-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';
-
-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}`,
-});
-
-export function staleUsable(auth: OAuthAuth, now = Date.now()): boolean {
-  return auth.expiresAt === undefined || auth.expiresAt > now;
-}
-
-export 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,
-  force: boolean,
-  now = Date.now(),
-): RelayTarget {
-  if (force) return { kind: 'signin' };
-  if (staleUsable(auth, now))
-    return { kind: 'ok', url, headers: bearerHeaders(auth.accessToken) };
-  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>,
-  force: boolean,
-): RelayTarget {
-  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,308 +0,0 @@
-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';
-
-export interface Connector {
-  id: string;
-  name: string;
-  url: string;
-  transport: ConnectorTransport;
-  auth: ConnectorAuth['kind'];
-  header: string | null;
-  secret: string | null;
-  bearer: string | null;
-  expiresAt: number | null;
-  signIn: ConnectorSignIn;
-  verified: VerifiedRecord;
-}
-
-export interface ConnectorInput {
-  name: unknown;
-  url: unknown;
-  header: unknown;
-  value: unknown;
-}
-
-export type ConnectorCheck =
-  | { id: string; name: string; ok: true; verified: VerifiedRecord }
-  | { id: string; name: string; ok: false; reason: string };
-
-export interface DeletedConnector {
-  id: string;
-  name: string;
-}
-
-type ConnectorRow = typeof connectors.$inferSelect;
-
-function toConnector(row: ConnectorRow): Connector {
-  const config = readConfig(row.config);
-  const auth = config.auth;
-  return {
-    id: row.id,
-    name: row.name,
-    url: row.url,
-    transport: row.transport,
-    auth: auth.kind,
-    header: auth.kind === 'header' ? auth.name : null,
-    secret: auth.kind === 'header' ? auth.value : null,
-    bearer: auth.kind === 'oauth' ? auth.accessToken : null,
-    expiresAt: auth.kind === 'oauth' ? (auth.expiresAt ?? null) : null,
-    signIn: signInState(config),
-    verified: config.verified,
-  };
-}
-
-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 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);
-}
-
-const UNVERIFIED = {
-  at: '',
-  server: '',
-  version: '',
-  protocol: '',
-  icon: '',
-  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;
-}