@stage-labs/metro 0.1.0-beta.21 → 0.1.0-beta.211

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

@@ -1,105 +0,0 @@
-import { and, eq, isNull } from 'drizzle-orm';
-import { getDb } from './client.js';
-import { newId } from './ids.js';
-import { agents, runtimes } from './schema.js';
-import { ApiError } from '../daemon/api-error.js';
-
-export interface RuntimeLease {
-  runtimeId: string;
-  agentId: string;
-  label: string;
-}
-
-export interface RuntimeView {
-  id: string;
-  label: string;
-  lastSeenAt: string | null;
-}
-
-const nowIso = (): string => new Date().toISOString();
-
-const stale = (): ApiError =>
-  new ApiError('this runtime no longer holds the agent', 409);
-
-export async function claimRuntime(
-  agentId: string,
-  label: string,
-): Promise<RuntimeLease> {
-  const db = getDb();
-  const id = newId();
-  return db.transaction(async (tx) => {
-    await tx
-      .insert(runtimes)
-      .values({ id, agentId, label, createdAt: nowIso(), lastSeenAt: nowIso() });
-    const rows = await tx
-      .update(agents)
-      .set({ runtimeId: id })
-      .where(eq(agents.id, agentId))
-      .returning({ id: agents.id });
-    if (rows[0] === undefined) throw new ApiError('no such agent', 404);
-    return { runtimeId: id, agentId, label };
-  });
-}
-
-export async function fenceRuntime(
-  runtimeId: string,
-  agentId: string,
-): Promise<void> {
-  const rows = await getDb()
-    .select({ holder: agents.runtimeId })
-    .from(agents)
-    .innerJoin(runtimes, eq(runtimes.id, agents.runtimeId))
-    .where(
-      and(
-        eq(agents.id, agentId),
-        eq(agents.runtimeId, runtimeId),
-        isNull(runtimes.revokedAt),
-      ),
-    );
-  if (rows[0] === undefined) throw stale();
-}
-
-export async function touchRuntime(runtimeId: string): Promise<void> {
-  await getDb()
-    .update(runtimes)
-    .set({ lastSeenAt: nowIso() })
-    .where(eq(runtimes.id, runtimeId));
-}
-
-export async function releaseRuntime(agentId: string): Promise<void> {
-  const db = getDb();
-  await db.transaction(async (tx) => {
-    await tx
-      .update(runtimes)
-      .set({ revokedAt: nowIso() })
-      .where(and(eq(runtimes.agentId, agentId), isNull(runtimes.revokedAt)));
-    await tx
-      .update(agents)
-      .set({ runtimeId: null })
-      .where(eq(agents.id, agentId));
-  });
-}
-
-export async function runtimeLabels(
-  agentIds: string[],
-): Promise<Map<string, string>> {
-  const out = new Map<string, string>();
-  for (const id of agentIds) {
-    const found = await runtimeFor(id);
-    if (found !== null) out.set(id, found.label);
-  }
-  return out;
-}
-
-export async function runtimeFor(agentId: string): Promise<RuntimeView | null> {
-  const rows = await getDb()
-    .select({
-      id: runtimes.id,
-      label: runtimes.label,
-      lastSeenAt: runtimes.lastSeenAt,
-    })
-    .from(runtimes)
-    .innerJoin(agents, eq(agents.runtimeId, runtimes.id))
-    .where(and(eq(agents.id, agentId), isNull(runtimes.revokedAt)));
-  return rows[0] ?? null;
-}

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

@@ -1,131 +0,0 @@
-import {
-  boolean,
-  jsonb,
-  pgTable,
-  text,
-  unique,
-} from 'drizzle-orm/pg-core';
-
-export const STATIONS = [
-  'xmtp',
-  'telegram',
-  'telegram-user',
-  'discord',
-  'whatsapp',
-  'webhook',
-] as const;
-
-export type StationName = (typeof STATIONS)[number];
-
-export const users = pgTable('users', {
-  id: text('id').primaryKey(),
-  email: text('email').notNull().unique(),
-});
-
-export const PROJECT_ROLES = ['admin', 'member'] as const;
-
-export type ProjectRole = (typeof PROJECT_ROLES)[number];
-
-export const projects = pgTable('projects', {
-  id: text('id').primaryKey(),
-  name: text('name').notNull(),
-  ownerId: text('owner_id')
-    .notNull()
-    .references(() => users.id, { onDelete: 'restrict' }),
-  isDefault: boolean('is_default').notNull().default(false),
-});
-
-export const projectMembers = pgTable(
-  'project_members',
-  {
-    id: text('id').primaryKey(),
-    projectId: text('project_id')
-      .notNull()
-      .references(() => projects.id, { onDelete: 'cascade' }),
-    userId: text('user_id')
-      .notNull()
-      .references(() => users.id, { onDelete: 'restrict' }),
-    role: text('role').$type<ProjectRole>().notNull(),
-  },
-  (t) => [unique('project_members_project_id_user_id_unique').on(t.projectId, t.userId)],
-);
-
-export const agents = pgTable('agents', {
-  id: text('id').primaryKey(),
-  name: text('name').notNull(),
-  projectId: text('project_id')
-    .notNull()
-    .references(() => projects.id, { onDelete: 'restrict' }),
-  key: text('key').unique(),
-  runtimeId: text('runtime_id'),
-});
-
-export const runtimes = pgTable('runtimes', {
-  id: text('id').primaryKey(),
-  agentId: text('agent_id')
-    .notNull()
-    .references(() => agents.id, { onDelete: 'cascade' }),
-  label: text('label').notNull(),
-  createdAt: text('created_at').notNull(),
-  lastSeenAt: text('last_seen_at'),
-  revokedAt: text('revoked_at'),
-});
-
-export const stations = pgTable('stations', {
-  id: text('id').primaryKey(),
-  agentId: text('agent_id').notNull(),
-  station: text('station').$type<StationName>().notNull(),
-  allowlist: text('allowlist').array().default(['*']),
-  config: jsonb('config').notNull(),
-});
-
-export const CONNECTOR_TRANSPORTS = ['http', 'sse'] as const;
-
-export type ConnectorTransport = (typeof CONNECTOR_TRANSPORTS)[number];
-
-export const connectors = pgTable(
-  'connectors',
-  {
-    id: text('id').primaryKey(),
-    projectId: text('project_id')
-      .notNull()
-      .references(() => projects.id, { onDelete: 'restrict' }),
-    name: text('name').notNull(),
-    url: text('url').notNull(),
-    transport: text('transport').$type<ConnectorTransport>().notNull(),
-    config: jsonb('config').notNull(),
-  },
-);
-
-export const collections = pgTable(
-  'collections',
-  {
-    id: text('id').primaryKey(),
-    projectId: text('project_id')
-      .notNull()
-      .references(() => projects.id, { onDelete: 'restrict' }),
-    name: text('name').notNull(),
-  },
-  (t) => [
-    unique('collections_project_id_name_unique').on(t.projectId, t.name),
-  ],
-);
-
-export const collectionItems = pgTable(
-  'collection_items',
-  {
-    id: text('id').primaryKey(),
-    collectionId: text('collection_id')
-      .notNull()
-      .references(() => collections.id, { onDelete: 'cascade' }),
-    connectorId: text('connector_id')
-      .notNull()
-      .references(() => connectors.id, { onDelete: 'cascade' }),
-  },
-  (t) => [
-    unique('collection_items_collection_id_connector_id_unique').on(
-      t.collectionId,
-      t.connectorId,
-    ),
-  ],
-);

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

@@ -1,45 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { tokenStorePath } from '@metro-labs/whatsapp/tokens';
-import { errMsg, log } from '../daemon/log.js';
-import { writeSecure } from '../daemon/secure-fs.js';
-
-export const PREVIOUS_ACCOUNT_ID = 'previousAccountId';
-
-export interface CarriedStation {
-  station: string;
-  id: string;
-  config: Record<string, unknown>;
-}
-
-export function previousAccountId(
-  config: Record<string, unknown>,
-): string | undefined {
-  const raw = config[PREVIOUS_ACCOUNT_ID];
-  return typeof raw === 'string' && raw !== '' ? raw : undefined;
-}
-
-export function carryTokenStores(list: CarriedStation[]): number {
-  let carried = 0;
-  for (const s of list) {
-    if (s.station !== 'whatsapp') continue;
-    const previous = previousAccountId(s.config);
-    if (previous === undefined || previous === s.id) continue;
-    const from = tokenStorePath(previous);
-    const to = tokenStorePath(s.id);
-    if (!existsSync(from) || existsSync(to)) continue;
-    try {
-      writeSecure(to, readFileSync(from, 'utf8'));
-      carried += 1;
-      log.info(
-        { from: previous, to: s.id },
-        'db: carried the whatsapp token store to the station id',
-      );
-    } catch (err) {
-      log.error(
-        { from: previous, to: s.id, err: errMsg(err) },
-        'db: could not carry the whatsapp token store',
-      );
-    }
-  }
-  return carried;
-}

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

@@ -1,57 +0,0 @@
-import { eq } from 'drizzle-orm';
-import { ApiError } from '../daemon/api-error.js';
-import { getDb } from './client.js';
-import { newId } from './ids.js';
-import { users } from './schema.js';
-
-const UNIQUE_VIOLATION = '23505';
-
-export class UserError extends ApiError {}
-
-export function isUniqueViolation(err: unknown): boolean {
-  return (
-    typeof err === 'object' &&
-    err !== null &&
-    (err as { code?: unknown }).code === UNIQUE_VIOLATION
-  );
-}
-
-export function normalizeEmail(raw: string): string {
-  return raw.trim().toLowerCase();
-}
-
-export async function userIdForEmail(rawEmail: string): Promise<string | null> {
-  const email = normalizeEmail(rawEmail);
-  const rows = await getDb()
-    .select({ id: users.id })
-    .from(users)
-    .where(eq(users.email, email));
-  return rows[0]?.id ?? null;
-}
-
-export async function resolveUserId(
-  insert: () => Promise<string | undefined>,
-  lookup: () => Promise<string | null>,
-): Promise<string> {
-  const inserted = await insert();
-  if (inserted !== undefined) return inserted;
-  const existing = await lookup();
-  if (existing === null)
-    throw new UserError('user lookup returned no id', 500);
-  return existing;
-}
-
-export async function ensureUser(rawEmail: string): Promise<string> {
-  const email = normalizeEmail(rawEmail);
-  return resolveUserId(
-    async () => {
-      const rows = await getDb()
-        .insert(users)
-        .values({ id: newId(), email })
-        .onConflictDoNothing({ target: users.email })
-        .returning({ id: users.id });
-      return rows[0]?.id;
-    },
-    () => userIdForEmail(email),
-  );
-}

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

@@ -1,18 +0,0 @@
-import { and, eq, sql } from 'drizzle-orm';
-import { getDb } from './client.js';
-import { stations } from './schema.js';
-
-export async function writeWhatsappCredentials(
-  accountId: string,
-  credentials: unknown,
-): Promise<void> {
-  const db = getDb();
-  await db
-    .update(stations)
-    .set({
-      config: sql`${stations.config} || ${JSON.stringify({ credentials })}::jsonb`,
-    })
-    .where(
-      and(eq(stations.station, 'whatsapp'), eq(stations.id, accountId)),
-    );
-}

package/runtime/node_modules/@metro-labs/mcp/src/mcp/channel-owner.ts

@@ -1,29 +0,0 @@
-import { eventInScope } from '../db/agent-scope.js';
-import { allowedAgents, type RequestIdentity } from './request-identity.js';
-import { sessionScopeKey } from './session-route.js';
-
-export class ChannelOwner {
-  private stream: RequestIdentity | undefined;
-
-  bindStream(identity: RequestIdentity): void {
-    this.stream = identity;
-  }
-
-  releaseStream(): void {
-    this.stream = undefined;
-  }
-
-  scope(): Set<string> {
-    return allowedAgents(this.stream);
-  }
-
-  streamBelongsTo(identity: RequestIdentity): boolean {
-    if (this.stream === undefined) return false;
-    return sessionScopeKey(this.stream) === sessionScopeKey(identity);
-  }
-
-  inScope(line: string): boolean {
-    if (this.stream === undefined) return false;
-    return eventInScope(this.scope(), line);
-  }
-}

package/runtime/node_modules/@metro-labs/mcp/src/mcp/frame-scope.ts

@@ -1,21 +0,0 @@
-import type { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
-import { eventInScope } from '../db/agent-scope.js';
-import { str } from './str.js';
-
-export interface FrameOrigin {
-  line: string | undefined;
-  owner: Set<string>;
-}
-
-export function frameLine(message: JSONRPCMessage): string | undefined {
-  const params: unknown = (message as { params?: unknown }).params;
-  if (typeof params !== 'object' || params === null) return undefined;
-  const meta: unknown = (params as { meta?: unknown }).meta;
-  if (typeof meta !== 'object' || meta === null) return undefined;
-  return str((meta as { line?: unknown }).line) || undefined;
-}
-
-export function frameInScope(scope: Set<string>, origin: FrameOrigin): boolean {
-  if (origin.line !== undefined) return eventInScope(scope, origin.line);
-  return origin.owner.size > 0 && [...origin.owner].every((id) => scope.has(id));
-}

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

@@ -1,66 +0,0 @@
-import type { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { z } from 'zod';
-import type { InboundRelay } from '../channels/inbound.js';
-import type { ChannelOwner } from './channel-owner.js';
-import { metroCall } from './ctx.js';
-
-const PermissionRequestSchema = z.object({
-  method: z.literal('notifications/claude/channel/permission_request'),
-  params: z.object({
-    request_id: z.string(),
-    tool_name: z.string(),
-    description: z.string(),
-    input_preview: z.string(),
-  }),
-});
-
-type PermissionRequest = z.infer<typeof PermissionRequestSchema>;
-
-const trainOf = (line: string): string => line.split('/')[2] ?? '';
-
-async function metroSend(line: string, text: string): Promise<void> {
-  await metroCall(trainOf(line), 'send', { line, text });
-}
-
-function promptBody(params: PermissionRequest['params']): string {
-  return (
-    `Claude wants to run ${params.tool_name}: ${params.description}\n` +
-    (params.input_preview ? `\n${params.input_preview}\n` : '') +
-    `\nReply "yes ${params.request_id}" or "no ${params.request_id}"`
-  );
-}
-
-export interface PermissionRelayDeps {
-  mcp: Server;
-  relay: InboundRelay;
-  owner: ChannelOwner;
-  log: (...a: unknown[]) => void;
-}
-
-export function registerPermissionRelay(deps: PermissionRelayDeps): void {
-  const { mcp, relay, owner, log } = deps;
-  mcp.setNotificationHandler(
-    PermissionRequestSchema as never,
-    async (n: PermissionRequest) => {
-      const { params } = n;
-      const line = relay.knownLine;
-      if (!line) {
-        log('permission_request but no known line to relay to', params.request_id);
-        return;
-      }
-      if (!owner.inScope(line)) {
-        log(
-          'permission_request: known line is outside the channel session scope',
-          params.request_id,
-        );
-        return;
-      }
-      relay.registerPermission(params.request_id);
-      try {
-        await metroSend(line, promptBody(params));
-      } catch (e) {
-        log('relay send failed', e);
-      }
-    },
-  );
-}

package/runtime/node_modules/@metro-labs/mcp/src/mcp/request-identity.ts

@@ -1,73 +0,0 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
-import type { IncomingMessage } from 'node:http';
-import { verifySession } from '../daemon/session.js';
-import { agentIdForKey } from '../db/key-map.js';
-
-export type RequestIdentity =
-  | { kind: 'agent'; agentId: string }
-  | { kind: 'google'; email: string; agentIds: string[] };
-
-const storage = new AsyncLocalStorage<RequestIdentity>();
-
-export function runWithIdentity<T>(
-  identity: RequestIdentity,
-  fn: () => Promise<T>,
-): Promise<T> {
-  return storage.run(identity, fn);
-}
-
-export function currentIdentity(): RequestIdentity | undefined {
-  return storage.getStore();
-}
-
-export interface AuthConfig {
-  sessionSecret: string;
-}
-
-export function authConfigFromEnv(): AuthConfig {
-  return { sessionSecret: process.env.METRO_SESSION_SECRET?.trim() ?? '' };
-}
-
-export function extractToken(req: IncomingMessage): string | undefined {
-  const header = req.headers.authorization;
-  if (header?.startsWith('Bearer ')) {
-    const t = header.slice(7).trim();
-    if (t) return t;
-  }
-  const qt = new URL(req.url ?? '/', 'http://localhost').searchParams.get(
-    'token',
-  );
-  return qt ?? undefined;
-}
-
-const looksLikeJwt = (token: string): boolean =>
-  /^[\w-]+\.[\w-]+\.[\w-]+$/.test(token);
-
-export function authenticate(
-  req: IncomingMessage,
-  cfg: AuthConfig,
-): RequestIdentity | null {
-  const token = extractToken(req);
-  if (!token) return null;
-
-  const agentId = agentIdForKey(token);
-  if (agentId !== undefined) return { kind: 'agent', agentId };
-
-  if (cfg.sessionSecret !== '' && looksLikeJwt(token)) {
-    try {
-      const { email, agentIds } = verifySession(token, cfg.sessionSecret);
-      return { kind: 'google', email, agentIds };
-    } catch {
-      return null;
-    }
-  }
-  return null;
-}
-
-export function allowedAgents(
-  identity: RequestIdentity | undefined,
-): Set<string> {
-  if (identity?.kind === 'google') return new Set(identity.agentIds);
-  if (identity?.kind === 'agent') return new Set([identity.agentId]);
-  return new Set();
-}