@stage-labs/metro 0.1.0-beta.13 → 0.1.0-beta.131

package/runtime/node_modules/@metro-labs/daemon/src/connectors/store.ts

@@ -0,0 +1,286 @@
+import { join } from 'node:path';
+import { readJson, writeSecure } from '@metro-labs/core/secure-fs';
+import { errMsg, log } from '@metro-labs/core/log';
+import {
+  connectorUrlText,
+  ConnectorVerifyError,
+  parseConnectorUrl,
+  verifyRemoteMcp,
+  type ConnectorAuth,
+  type OAuthAuth,
+} from './verify.js';
+import { oauthExpired, refreshOAuth } from './oauth.js';
+import { advertisesOAuth } from './oauth-discovery.js';
+import {
+  ConnectorError,
+  connectorAuth,
+  connectorClient,
+  connectorName,
+  readConfig,
+  stamp,
+  type ConnectorConfig,
+} from './config.js';
+import {
+  bearerHeaders,
+  fixedTarget,
+  unrefreshedTarget,
+  type RelayTarget,
+} from './relay-target.js';
+import {
+  connectorFromRow,
+  UNVERIFIED,
+  type Connector,
+  type ConnectorCheck,
+  type ConnectorInput,
+  type DeletedConnector,
+  type PendingConnectorInput,
+} from './model.js';
+import { agentsDir } from '../agents/files.js';
+import { assertLocalOwner, LOCAL_PROJECT_ID } from '../agents/file-admin.js';
+import { newId } from '@metro-labs/core/ids';
+import type { LoadedConnector } from '../stations/materialize.js';
+
+export interface LocalConnectorRow {
+  id: string;
+  name: string;
+  url: string;
+  transport: 'http';
+  config: ConnectorConfig;
+}
+
+const FILE = 'connectors.json';
+const filePath = (dir: string): string => join(dir, FILE);
+
+const isRow = (v: unknown): v is { id: string; name: string; url: string; config?: unknown } =>
+  typeof v === 'object' &&
+  v !== null &&
+  typeof (v as { id?: unknown }).id === 'string' &&
+  typeof (v as { name?: unknown }).name === 'string' &&
+  typeof (v as { url?: unknown }).url === 'string';
+
+const asList = (value: unknown): unknown[] =>
+  Array.isArray(value) ? value.map((item: unknown) => item) : [];
+
+export function readLocalConnectors(dir = agentsDir()): LocalConnectorRow[] {
+  const raw = readJson<{ connectors?: unknown }>(filePath(dir), {}, {
+    warn: 'connectors.json: malformed, ignoring',
+  });
+  return asList(raw.connectors).filter(isRow).map((r) => ({
+    id: r.id,
+    name: r.name,
+    url: r.url,
+    transport: 'http' as const,
+    config: readConfig(r.config),
+  }));
+}
+
+function writeRows(dir: string, rows: LocalConnectorRow[]): void {
+  writeSecure(filePath(dir), `${JSON.stringify({ version: 1, connectors: rows }, null, 2)}\n`);
+}
+
+const missing = (): ConnectorError => new ConnectorError('no such connector', 404);
+
+function ownedRows(subject: string, project: string, dir: string): LocalConnectorRow[] {
+  assertLocalOwner(subject, dir);
+  if (project !== LOCAL_PROJECT_ID) throw new ConnectorError('no such project', 404);
+  return readLocalConnectors(dir);
+}
+
+function rowOrThrow(subject: string, id: string, dir: string): LocalConnectorRow {
+  assertLocalOwner(subject, dir);
+  const row = readLocalConnectors(dir).find((r) => r.id === id);
+  if (row === undefined) throw missing();
+  return row;
+}
+
+function replace(dir: string, row: LocalConnectorRow): Connector {
+  writeRows(dir, readLocalConnectors(dir).map((r) => (r.id === row.id ? row : r)));
+  return connectorFromRow(row);
+}
+
+async function oauthCapable(url: URL, auth: ConnectorAuth): Promise<boolean> {
+  if (auth.kind === 'oauth') return true;
+  if (auth.kind === 'header') return false;
+  return advertisesOAuth(url);
+}
+
+export function localImportConnectors(
+  rows: LoadedConnector[],
+  dir = agentsDir(),
+  mode: 'append' | 'overwrite' = 'overwrite',
+): number {
+  const current = readLocalConnectors(dir);
+  const fresh =
+    mode === 'overwrite'
+      ? rows
+      : rows.filter((row) => !current.some((r) => r.id === row.id || r.name === row.name));
+  const imported: LocalConnectorRow[] = fresh.map((row) => ({
+    id: row.id,
+    name: row.name,
+    url: row.url,
+    transport: 'http',
+    config: readConfig(row.config),
+  }));
+  const ids = new Set(imported.map((r) => r.id));
+  const names = new Set(imported.map((r) => r.name));
+  writeRows(dir, [...current.filter((r) => !ids.has(r.id) && !names.has(r.name)), ...imported]);
+  return imported.length;
+}
+
+export async function localListConnectors(
+  subject: string,
+  project: string,
+  dir = agentsDir(),
+): Promise<Connector[]> {
+  return Promise.resolve(ownedRows(subject, project, dir).map(connectorFromRow));
+}
+
+export async function localGetConnector(subject: string, id: string, dir = agentsDir()): Promise<Connector> {
+  return Promise.resolve(connectorFromRow(rowOrThrow(subject, id, dir)));
+}
+
+function assertNameFree(name: string, exceptId: string | null, dir: string): void {
+  if (readLocalConnectors(dir).some((r) => r.id !== exceptId && r.name === name))
+    throw new ConnectorError(`a connector named '${name}' already exists on this daemon`, 409);
+}
+
+function insert(dir: string, name: string, url: URL, config: ConnectorConfig): Connector {
+  assertNameFree(name, null, dir);
+  const row: LocalConnectorRow = { id: newId(), name, url: connectorUrlText(url), transport: 'http', config };
+  writeRows(dir, [...readLocalConnectors(dir), row]);
+  return connectorFromRow(row);
+}
+
+export async function localCreateConnector(
+  subject: string,
+  project: string,
+  input: ConnectorInput,
+  dir = agentsDir(),
+): Promise<Connector> {
+  ownedRows(subject, project, dir);
+  const name = connectorName(input.name);
+  const url = parseConnectorUrl(input.url);
+  const auth = connectorAuth(input.header, input.value);
+  const client = connectorClient(input.clientId, input.clientSecret);
+  const verified = stamp(await verifyRemoteMcp(url, auth));
+  return insert(dir, name, url, {
+    auth,
+    createdAt: new Date().toISOString(),
+    verified,
+    oauth: await oauthCapable(url, auth),
+    client,
+  });
+}
+
+export async function localCreatePendingConnector(
+  subject: string,
+  project: string,
+  input: PendingConnectorInput,
+  dir = agentsDir(),
+): Promise<Connector> {
+  ownedRows(subject, project, dir);
+  const name = connectorName(input.name);
+  const url = parseConnectorUrl(input.url);
+  const client = connectorClient(input.clientId, input.clientSecret);
+  return Promise.resolve(
+    insert(dir, name, url, { auth: { kind: 'none' }, createdAt: new Date().toISOString(), verified: UNVERIFIED, oauth: true, client }),
+  );
+}
+
+export async function localReconnectConnector(
+  subject: string,
+  id: string,
+  auth: OAuthAuth,
+  dir = agentsDir(),
+): Promise<Connector> {
+  const row = rowOrThrow(subject, id, dir);
+  const verified = stamp(await verifyRemoteMcp(parseConnectorUrl(row.url), auth));
+  return replace(dir, { ...row, config: { ...row.config, auth, verified, oauth: true } });
+}
+
+export async function localDisconnectConnector(subject: string, id: string, dir = agentsDir()): Promise<Connector> {
+  const row = rowOrThrow(subject, id, dir);
+  if (row.config.auth.kind !== 'oauth') throw new ConnectorError('that connector is not signed in', 400);
+  return Promise.resolve(replace(dir, { ...row, config: { ...row.config, auth: { kind: 'none' }, oauth: true } }));
+}
+
+async function freshAuth(auth: ConnectorAuth, resource: string): Promise<ConnectorAuth> {
+  if (auth.kind !== 'oauth' || !oauthExpired(auth)) return auth;
+  return refreshOAuth(auth, resource);
+}
+
+export async function localVerifyConnector(subject: string, id: string, dir = agentsDir()): Promise<ConnectorCheck> {
+  const row = rowOrThrow(subject, id, dir);
+  try {
+    const url = parseConnectorUrl(row.url);
+    const auth = await freshAuth(row.config.auth, url.toString());
+    const verified = stamp(await verifyRemoteMcp(url, auth));
+    const oauth = row.config.oauth || (await oauthCapable(url, auth));
+    replace(dir, { ...row, config: { ...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 localRenameConnector(subject: string, id: string, raw: string, dir = agentsDir()): Promise<Connector> {
+  const name = connectorName(raw);
+  const row = rowOrThrow(subject, id, dir);
+  assertNameFree(name, id, dir);
+  return Promise.resolve(replace(dir, { ...row, name }));
+}
+
+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));
+  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 localConnectorNamesByIds(ids: string[], dir = agentsDir()): Promise<{ id: string; name: string }[]> {
+  return Promise.resolve(byIds(ids, dir).map((r) => ({ id: r.id, name: r.name })));
+}
+
+const inflight = new Map<string, Promise<OAuthAuth>>();
+
+function refreshOnce(row: LocalConnectorRow, auth: OAuthAuth, dir: string): Promise<OAuthAuth> {
+  const running = inflight.get(row.id);
+  if (running !== undefined) return running;
+  const job = refreshOAuth(auth, parseConnectorUrl(row.url).toString())
+    .then((fresh) => {
+      replace(dir, { ...row, config: { ...row.config, auth: fresh } });
+      return fresh;
+    })
+    .finally(() => {
+      inflight.delete(row.id);
+    });
+  inflight.set(row.id, job);
+  return job;
+}
+
+async function oauthTarget(row: LocalConnectorRow, auth: OAuthAuth, force: boolean, dir: string): Promise<RelayTarget> {
+  if (!force && !oauthExpired(auth)) return { kind: 'ok', url: row.url, headers: bearerHeaders(auth.accessToken) };
+  try {
+    const fresh = await refreshOnce(row, auth, dir);
+    return { kind: 'ok', url: row.url, headers: bearerHeaders(fresh.accessToken) };
+  } catch (err) {
+    log.warn({ id: row.id, err: errMsg(err) }, 'local relay: token refresh failed');
+    return unrefreshedTarget(row.url, auth, force);
+  }
+}
+
+export async function localRelayTarget(
+  connectorId: string,
+  force: boolean,
+  dir = agentsDir(),
+): Promise<RelayTarget> {
+  const row = readLocalConnectors(dir).find((r) => r.id === connectorId);
+  if (row === undefined) return { kind: 'missing' };
+  parseConnectorUrl(row.url);
+  const auth = row.config.auth;
+  if (auth.kind === 'oauth') return oauthTarget(row, auth, force, dir);
+  return fixedTarget(row.url, auth, force);
+}

package/runtime/node_modules/@metro-labs/daemon/src/connectors/tools.ts

@@ -0,0 +1,98 @@
+import { isRecord } from '@metro-labs/core/is-record';
+
+export const TOOL_KINDS = ['read', 'write'] as const;
+
+export type ToolKind = (typeof TOOL_KINDS)[number];
+
+export interface ToolInfo {
+  name: string;
+  title: string;
+  description: string;
+  kind: ToolKind;
+  annotated: boolean;
+  destructive: boolean;
+  idempotent: boolean;
+  openWorld: boolean;
+}
+
+const MAX_TOOLS = 500;
+const MAX_DESCRIPTION = 400;
+
+const str = (value: unknown, cap: number): string =>
+  typeof value === 'string' ? value.slice(0, cap) : '';
+
+const flag = (value: unknown, fallback: boolean): boolean =>
+  typeof value === 'boolean' ? value : fallback;
+
+export function classifyTool(annotations: unknown): ToolKind {
+  return isRecord(annotations) && annotations.readOnlyHint === true
+    ? 'read'
+    : 'write';
+}
+
+export function isDestructive(annotations: unknown): boolean {
+  if (!isRecord(annotations)) return true;
+  if (annotations.readOnlyHint === true) return false;
+  return annotations.destructiveHint !== false;
+}
+
+export function toToolInfo(raw: unknown): ToolInfo | null {
+  if (!isRecord(raw)) return null;
+  const name = str(raw.name, 200);
+  if (name === '') return null;
+  const annotations = isRecord(raw.annotations) ? raw.annotations : undefined;
+  return {
+    name,
+    title: str(annotations?.title ?? raw.title, 200),
+    description: str(raw.description, MAX_DESCRIPTION),
+    kind: classifyTool(raw.annotations),
+    annotated: annotations !== undefined,
+    destructive: isDestructive(raw.annotations),
+    idempotent: flag(annotations?.idempotentHint, false),
+    openWorld: flag(annotations?.openWorldHint, true),
+  };
+}
+
+export function toToolList(raw: unknown): ToolInfo[] {
+  if (!Array.isArray(raw)) return [];
+  const out: ToolInfo[] = [];
+  for (const entry of raw) {
+    if (out.length >= MAX_TOOLS) break;
+    const tool = toToolInfo(entry);
+    if (tool !== null) out.push(tool);
+  }
+  return out;
+}
+
+function toStoredTool(raw: unknown): ToolInfo | null {
+  if (!isRecord(raw)) return null;
+  const name = str(raw.name, 200);
+  if (name === '') return null;
+  return {
+    name,
+    title: str(raw.title, 200),
+    description: str(raw.description, MAX_DESCRIPTION),
+    kind: raw.kind === 'read' ? 'read' : 'write',
+    annotated: raw.annotated === true,
+    destructive: raw.destructive !== false,
+    idempotent: raw.idempotent === true,
+    openWorld: raw.openWorld !== false,
+  };
+}
+
+export function readStoredTools(raw: unknown): ToolInfo[] {
+  if (!Array.isArray(raw)) return [];
+  const out: ToolInfo[] = [];
+  for (const entry of raw) {
+    if (out.length >= MAX_TOOLS) break;
+    const tool = toStoredTool(entry);
+    if (tool !== null) out.push(tool);
+  }
+  return out;
+}
+
+export function countByKind(tools: ToolInfo[]): Record<ToolKind, number> {
+  const counts: Record<ToolKind, number> = { read: 0, write: 0 };
+  for (const tool of tools) counts[tool.kind] += 1;
+  return counts;
+}

package/runtime/node_modules/@metro-labs/daemon/src/connectors/url.ts

@@ -0,0 +1,70 @@
+import { ApiError } from '@metro-labs/http/api-error';
+
+export class ConnectorVerifyError extends ApiError {}
+
+export class ConnectorUnauthorized extends ConnectorVerifyError {}
+
+export class ConnectorNotMcp extends ConnectorVerifyError {}
+
+export const POLICY_MESSAGE =
+  'Metro connects from its own server, so it cannot reach a URL on your machine. localhost and private addresses are not usable as connectors.';
+
+let localAllowed = false;
+
+export function allowLocalConnectors(on: boolean): void {
+  localAllowed = on;
+}
+
+const IPV4 = /^\d{1,3}(?:\.\d{1,3}){3}$/;
+const PRIVATE_SUFFIX = /(?:^|\.)(?:localhost|local|internal|flycast)$/;
+
+export function refused(message: string): ConnectorVerifyError {
+  return new ConnectorVerifyError(message, 400);
+}
+
+function hostAllowed(host: string): boolean {
+  if (host === '' || host.startsWith('[')) return false;
+  if (IPV4.test(host) || !host.includes('.')) return false;
+  return !PRIVATE_SUFFIX.test(host);
+}
+
+function schemeAllowed(url: URL): boolean {
+  return url.protocol === 'https:' || (localAllowed && url.protocol === 'http:');
+}
+
+function refuseShape(url: URL): void {
+  if (!schemeAllowed(url)) throw refused('a connector url must start with https://');
+  if (url.username !== '' || url.password !== '')
+    throw refused('a connector url must not carry a user:password');
+  if (url.hash !== '')
+    throw refused('a connector url must not carry a #fragment');
+  if (!localAllowed && !hostAllowed(url.hostname.toLowerCase())) throw refused(POLICY_MESSAGE);
+}
+
+export function parseConnectorUrl(raw: unknown): URL {
+  const text = typeof raw === 'string' ? raw.trim() : '';
+  if (text === '') throw refused('a connector url is required');
+  let url: URL;
+  try {
+    url = new URL(text);
+  } catch {
+    throw refused('that is not a valid url');
+  }
+  refuseShape(url);
+  return url;
+}
+
+export function connectorUrlText(url: URL): string {
+  const text = url.toString();
+  if (url.pathname !== '/' || url.search !== '') return text;
+  return text.endsWith('/') ? text.slice(0, -1) : text;
+}
+
+export function safeIconSrc(raw: unknown): string {
+  if (typeof raw !== 'string' || raw === '') return '';
+  try {
+    return new URL(raw).protocol === 'https:' ? raw.slice(0, 500) : '';
+  } catch {
+    return '';
+  }
+}