@stage-labs/metro 0.1.0-beta.30 → 0.1.0-beta.31

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

@@ -1,202 +0,0 @@
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import { errMsg, log } from './log.js';
-import {
-  apiFailure,
-  apiSession,
-  projectParam,
-  bodyField,
-  cors,
-  readJsonBody,
-  sendJson,
-  type ApiSession,
-} from './api-http.js';
-import { parseId } from '../db/ids.js';
-import { mintCliCode } from './cli-pair.js';
-import type { ConnectorApiDeps } from './connector-api.js';
-
-const PREFIX = '/api/collections';
-
-type Routable =
-  | { kind: 'index' }
-  | { kind: 'collection'; id: string }
-  | { kind: 'rename'; id: string }
-  | { kind: 'code'; id: string }
-  | { kind: 'items'; id: string }
-  | { kind: 'item'; id: string; connectorId: string };
-
-type Target = Routable | { kind: 'unknown' } | null;
-
-const ALLOWED: Record<Routable['kind'], string[]> = {
-  index: ['GET', 'POST'],
-  collection: ['GET', 'DELETE'],
-  rename: ['POST'],
-  code: ['POST'],
-  items: ['POST'],
-  item: ['DELETE'],
-};
-
-function itemTarget(id: string, rest: string[]): Target {
-  if (rest.length === 1) return { kind: 'items', id };
-  if (rest.length > 2) return { kind: 'unknown' };
-  const connectorId = parseId(rest[1] ?? '');
-  return connectorId === null
-    ? { kind: 'unknown' }
-    : { kind: 'item', id, connectorId };
-}
-
-function subTarget(id: string, rest: string[]): Target {
-  if (rest.length === 0) return { kind: 'collection', id };
-  const head = rest[0];
-  if (head === 'items') return itemTarget(id, rest);
-  if (rest.length > 1) return { kind: 'unknown' };
-  if (head === 'rename') return { kind: 'rename', id };
-  if (head === 'code') return { kind: 'code', id };
-  return { kind: 'unknown' };
-}
-
-function target(path: string): Target {
-  if (path === PREFIX || path === `${PREFIX}/`) return { kind: 'index' };
-  if (!path.startsWith(`${PREFIX}/`)) return null;
-  const segments = path.slice(PREFIX.length + 1).split('/').filter(Boolean);
-  const head = segments[0];
-  if (head === undefined) return { kind: 'index' };
-  const id = parseId(head);
-  return id === null ? { kind: 'unknown' } : subTarget(id, segments.slice(1));
-}
-
-async function nameFrom(req: IncomingMessage): Promise<string | null> {
-  const name = bodyField(await readJsonBody(req), 'name');
-  return typeof name === 'string' ? name : null;
-}
-
-async function handleIndex(
-  req: IncomingMessage,
-  res: ServerResponse,
-  deps: ConnectorApiDeps,
-  session: ApiSession,
-): Promise<void> {
-  const project = projectParam(req);
-  if (project === null) {
-    sendJson(req, res, 400, { error: 'a project is required' });
-    return;
-  }
-  if (req.method === 'GET') {
-    sendJson(req, res, 200, {
-      collections: await deps.listCollections(session.email, project),
-    });
-    return;
-  }
-  const name = await nameFrom(req);
-  if (name === null) {
-    sendJson(req, res, 400, { error: 'name is required' });
-    return;
-  }
-  const list = await deps.createCollection(session.email, project, name);
-  log.info({ id: list.id, name: list.name }, 'collection-api: created collection');
-  sendJson(req, res, 201, list);
-}
-
-async function handleRename(
-  req: IncomingMessage,
-  res: ServerResponse,
-  deps: ConnectorApiDeps,
-  session: ApiSession,
-  id: string,
-): Promise<void> {
-  const name = await nameFrom(req);
-  if (name === null) {
-    sendJson(req, res, 400, { error: 'name is required' });
-    return;
-  }
-  sendJson(req, res, 200, await deps.renameCollection(session.email, id, name));
-}
-
-async function handleItems(
-  req: IncomingMessage,
-  res: ServerResponse,
-  deps: ConnectorApiDeps,
-  session: ApiSession,
-  id: string,
-): Promise<void> {
-  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.addToCollection(session.email, id, connectorId));
-}
-
-async function handleCode(
-  req: IncomingMessage,
-  res: ServerResponse,
-  deps: ConnectorApiDeps,
-  session: ApiSession,
-  id: string,
-): Promise<void> {
-  const collection = await deps.getCollection(session.email, id);
-  const minted = mintCliCode({ email: session.email, collectionId: collection.id });
-  log.info({ id: collection.id, email: session.email }, 'collection-api: minted cli code');
-  sendJson(req, res, 200, { ...minted, collection: collection.name });
-}
-
-async function route(
-  req: IncomingMessage,
-  res: ServerResponse,
-  deps: ConnectorApiDeps,
-  session: ApiSession,
-  tgt: Routable,
-): Promise<void> {
-  try {
-    if (tgt.kind === 'index')
-      await handleIndex(req, res, deps, session);
-    else if (tgt.kind === 'rename')
-      await handleRename(req, res, deps, session, tgt.id);
-    else if (tgt.kind === 'code')
-      await handleCode(req, res, deps, session, tgt.id);
-    else if (tgt.kind === 'items')
-      await handleItems(req, res, deps, session, tgt.id);
-    else if (tgt.kind === 'item')
-      sendJson(
-        req,
-        res,
-        200,
-        await deps.removeFromCollection(session.email, tgt.id, tgt.connectorId),
-      );
-    else if (req.method === 'DELETE')
-      sendJson(req, res, 200, await deps.deleteCollection(session.email, tgt.id));
-    else sendJson(req, res, 200, await deps.getCollection(session.email, tgt.id));
-  } catch (err) {
-    apiFailure(req, res, err, 'collection-api');
-  }
-}
-
-export function handleCollectionApiRequest(
-  req: IncomingMessage,
-  res: ServerResponse,
-  deps: ConnectorApiDeps,
-): 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 collection' });
-    return true;
-  }
-  if (!ALLOWED[tgt.kind].includes(req.method ?? '')) {
-    sendJson(req, res, 405, { error: 'method not allowed' });
-    return true;
-  }
-  const session = apiSession(req);
-  if (!session) {
-    sendJson(req, res, 401, { error: 'unauthorized' });
-    return true;
-  }
-  route(req, res, deps, session, tgt).catch((err: unknown) => {
-    log.warn({ err: errMsg(err) }, 'list-api: unhandled error');
-    if (!res.headersSent) sendJson(req, res, 500, { error: 'list api failed' });
-  });
-  return true;
-}

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

@@ -1,18 +0,0 @@
-import { makeCodeStore } from './pair-codes.js';
-
-export interface RunCode {
-  email: string;
-  agentId: string;
-}
-
-const store = makeCodeStore<RunCode>('mr');
-
-export const RUN_CODE_RE = store.pattern;
-
-export const mintRunCode = (
-  entry: RunCode,
-  now?: number,
-): { code: string; expiresAt: number } => store.mint(entry, now);
-
-export const takeRunCode = (code: string, now?: number): RunCode | undefined =>
-  store.take(code, now);

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

@@ -1,218 +0,0 @@
-import { isUniqueViolation } from './users.js';
-import { projectIdOrThrow } from './projects.js';
-import { and, asc, eq, inArray, ne } from 'drizzle-orm';
-import { getDb } from './client.js';
-import { newId } from './ids.js';
-import { ConnectorError, connectorName } from './connector-config.js';
-import { collectionItems, collections, connectors } from './schema.js';
-
-export interface ConnectorCollectionRow {
-  id: string;
-  name: string;
-  connectorIds: string[];
-}
-
-interface CollectionRow {
-  id: string;
-  projectId: string;
-  name: string;
-}
-
-const missing = (): ConnectorError =>
-  new ConnectorError('no such collection', 404);
-
-const duplicate = (name: string): ConnectorError =>
-  new ConnectorError(`you already have a collection named '${name}'`, 409);
-
-const nameClash = (name: string, collection: string): ConnectorError =>
-  new ConnectorError(
-    `the collection '${collection}' already has a connector named '${name}'`,
-    409,
-  );
-
-async function collidingCollection(
-  collectionIds: string[],
-  name: string,
-  exceptConnectorId: string,
-): Promise<string | null> {
-  if (collectionIds.length === 0) return null;
-  const rows = await getDb()
-    .select({ collection: collections.name })
-    .from(collectionItems)
-    .innerJoin(connectors, eq(connectors.id, collectionItems.connectorId))
-    .innerJoin(collections, eq(collections.id, collectionItems.collectionId))
-    .where(
-      and(
-        inArray(collectionItems.collectionId, collectionIds),
-        eq(connectors.name, name),
-        ne(connectors.id, exceptConnectorId),
-      ),
-    )
-    .limit(1);
-  return rows[0]?.collection ?? null;
-}
-
-export async function assertRenameFreeOfClash(
-  connectorId: string,
-  name: string,
-): Promise<void> {
-  const rows = await getDb()
-    .select({ collectionId: collectionItems.collectionId })
-    .from(collectionItems)
-    .where(eq(collectionItems.connectorId, connectorId));
-  const clash = await collidingCollection(
-    rows.map((r) => r.collectionId),
-    name,
-    connectorId,
-  );
-  if (clash !== null) throw nameClash(name, clash);
-}
-
-async function ownedCollectionOrThrow(
-  email: string,
-  id: string,
-): Promise<CollectionRow> {
-  const rows = await getDb()
-    .select()
-    .from(collections)
-    .where(eq(collections.id, id));
-  const row = rows[0];
-  if (row === undefined) throw missing();
-  try {
-    await projectIdOrThrow(email, row.projectId);
-  } catch {
-    throw missing();
-  }
-  return row;
-}
-
-async function itemsOf(collectionId: string): Promise<string[]> {
-  const rows = await getDb()
-    .select({ connectorId: collectionItems.connectorId })
-    .from(collectionItems)
-    .where(eq(collectionItems.collectionId, collectionId))
-    .orderBy(asc(collectionItems.id));
-  return rows.map((r) => r.connectorId);
-}
-
-async function withItems(row: CollectionRow): Promise<ConnectorCollectionRow> {
-  return { id: row.id, name: row.name, connectorIds: await itemsOf(row.id) };
-}
-
-export async function listCollectionsForEmail(
-  email: string,
-  project: string,
-): Promise<ConnectorCollectionRow[]> {
-  const projectId = await projectIdOrThrow(email, project);
-  const rows = await getDb()
-    .select()
-    .from(collections)
-    .where(eq(collections.projectId, projectId))
-    .orderBy(asc(collections.id));
-  return Promise.all(rows.map(withItems));
-}
-
-export async function getCollectionForEmail(
-  email: string,
-  id: string,
-): Promise<ConnectorCollectionRow> {
-  return withItems(await ownedCollectionOrThrow(email, id));
-}
-
-export async function createCollectionForEmail(
-  email: string,
-  project: string,
-  raw: string,
-): Promise<ConnectorCollectionRow> {
-  const name = connectorName(raw);
-  const projectId = await projectIdOrThrow(email, project);
-  try {
-    const rows = await getDb()
-      .insert(collections)
-      .values({ id: newId(), projectId, name })
-      .returning();
-    const row = rows[0];
-    if (row === undefined)
-      throw new ConnectorError('collection insert returned no row', 500);
-    return { id: row.id, name: row.name, connectorIds: [] };
-  } catch (err) {
-    if (!isUniqueViolation(err)) throw err;
-    throw duplicate(name);
-  }
-}
-
-export async function renameCollectionForEmail(
-  email: string,
-  id: string,
-  raw: string,
-): Promise<ConnectorCollectionRow> {
-  const name = connectorName(raw);
-  const row = await ownedCollectionOrThrow(email, id);
-  try {
-    await getDb()
-      .update(collections)
-      .set({ name })
-      .where(eq(collections.id, row.id));
-  } catch (err) {
-    if (!isUniqueViolation(err)) throw err;
-    throw duplicate(name);
-  }
-  return withItems({ ...row, name });
-}
-
-export async function deleteCollectionForEmail(
-  email: string,
-  id: string,
-): Promise<{ id: string; name: string }> {
-  const row = await ownedCollectionOrThrow(email, id);
-  await getDb().delete(collections).where(eq(collections.id, row.id));
-  return { id: row.id, name: row.name };
-}
-
-async function connectorNameIn(
-  projectId: string,
-  connectorId: string,
-): Promise<string | null> {
-  const rows = await getDb()
-    .select({ name: connectors.name })
-    .from(connectors)
-    .where(and(eq(connectors.id, connectorId), eq(connectors.projectId, projectId)));
-  return rows[0]?.name ?? null;
-}
-
-export async function addToCollectionForEmail(
-  email: string,
-  id: string,
-  connectorId: string,
-): Promise<ConnectorCollectionRow> {
-  const row = await ownedCollectionOrThrow(email, id);
-  const name = await connectorNameIn(row.projectId, connectorId);
-  if (name === null) throw new ConnectorError('no such connector', 404);
-  const clash = await collidingCollection([row.id], name, connectorId);
-  if (clash !== null) throw nameClash(name, clash);
-  try {
-    await getDb()
-      .insert(collectionItems)
-      .values({ id: newId(), collectionId: row.id, connectorId });
-  } catch (err) {
-    if (!isUniqueViolation(err)) throw err;
-  }
-  return withItems(row);
-}
-
-export async function removeFromCollectionForEmail(
-  email: string,
-  id: string,
-  connectorId: string,
-): Promise<ConnectorCollectionRow> {
-  const row = await ownedCollectionOrThrow(email, id);
-  await getDb()
-    .delete(collectionItems)
-    .where(
-      and(
-        eq(collectionItems.collectionId, row.id),
-        eq(collectionItems.connectorId, connectorId),
-      ),
-    );
-  return withItems(row);
-}