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

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

@@ -1,300 +0,0 @@
-import { ensureUser, normalizeEmail, userIdForEmail } from './users.js';
-import { and, asc, eq } from 'drizzle-orm';
-import { ApiError } from '../daemon/api-error.js';
-import { getDb } from './client.js';
-import { newId } from './ids.js';
-import { projectMembers, projects, users, type ProjectRole } from './schema.js';
-
-export class ProjectError extends ApiError {}
-
-export interface Project {
-  id: string;
-  name: string;
-  isDefault: boolean;
-  owner: boolean;
-  role: ProjectRole;
-}
-
-export interface Member {
-  id: string;
-  email: string;
-  role: ProjectRole;
-  owner: boolean;
-}
-
-const NAME_MAX = 64;
-const CONTROL = /[\u0000-\u001f\u007f]/;
-
-const missing = (): ProjectError => new ProjectError('no such project', 404);
-const forbidden = (why: string): ProjectError => new ProjectError(why, 403);
-
-export function projectName(raw: unknown): string {
-  const name = typeof raw === 'string' ? raw.trim() : '';
-  if (name === '' || name.length > NAME_MAX)
-    throw new ProjectError(
-      `a project name is 1-${String(NAME_MAX)} characters`,
-      400,
-    );
-  if (CONTROL.test(name))
-    throw new ProjectError('a project name cannot carry control characters', 400);
-  return name;
-}
-
-export interface Access {
-  userId: string;
-  projectId: string;
-  ownerId: string;
-  isDefault: boolean;
-  name: string;
-  role: ProjectRole;
-}
-
-export async function memberAccessOrThrow(
-  email: string,
-  projectId: string,
-): Promise<Access> {
-  const userId = await userIdForEmail(email);
-  if (userId === null) throw missing();
-  const rows = await getDb()
-    .select({
-      id: projects.id,
-      name: projects.name,
-      ownerId: projects.ownerId,
-      isDefault: projects.isDefault,
-      role: projectMembers.role,
-    })
-    .from(projects)
-    .innerJoin(projectMembers, eq(projectMembers.projectId, projects.id))
-    .where(and(eq(projects.id, projectId), eq(projectMembers.userId, userId)));
-  const row = rows[0];
-  if (row === undefined) throw missing();
-  return {
-    userId,
-    projectId: row.id,
-    ownerId: row.ownerId,
-    isDefault: row.isDefault,
-    name: row.name,
-    role: row.role,
-  };
-}
-
-export async function projectIdOrThrow(
-  email: string,
-  projectId: string,
-): Promise<string> {
-  return (await memberAccessOrThrow(email, projectId)).projectId;
-}
-
-async function addMemberRow(
-  projectId: string,
-  userId: string,
-  role: ProjectRole,
-): Promise<void> {
-  await getDb()
-    .insert(projectMembers)
-    .values({ id: newId(), projectId, userId, role })
-    .onConflictDoNothing();
-}
-
-export async function ensureDefaultProject(userId: string): Promise<string> {
-  const existing = await getDb()
-    .select({ id: projects.id })
-    .from(projects)
-    .where(and(eq(projects.ownerId, userId), eq(projects.isDefault, true)));
-  const found = existing[0];
-  if (found !== undefined) return found.id;
-  const id = newId();
-  await getDb()
-    .insert(projects)
-    .values({ id, name: 'Personal', ownerId: userId, isDefault: true });
-  await addMemberRow(id, userId, 'admin');
-  return id;
-}
-
-export async function ensureUserWithProject(rawEmail: string): Promise<string> {
-  const userId = await ensureUser(rawEmail);
-  await ensureDefaultProject(userId);
-  return userId;
-}
-
-export async function listProjectsForEmail(email: string): Promise<Project[]> {
-  const userId = await userIdForEmail(email);
-  if (userId === null) return [];
-  const rows = await getDb()
-    .select({
-      id: projects.id,
-      name: projects.name,
-      isDefault: projects.isDefault,
-      ownerId: projects.ownerId,
-      role: projectMembers.role,
-    })
-    .from(projects)
-    .innerJoin(projectMembers, eq(projectMembers.projectId, projects.id))
-    .where(eq(projectMembers.userId, userId))
-    .orderBy(asc(projects.id));
-  return rows.map((r) => ({
-    id: r.id,
-    name: r.name,
-    isDefault: r.isDefault,
-    owner: r.ownerId === userId,
-    role: r.role,
-  }));
-}
-
-export async function createProjectForEmail(
-  email: string,
-  raw: unknown,
-): Promise<Project> {
-  const name = projectName(raw);
-  const userId = await ensureUser(email);
-  const id = newId();
-  await getDb().insert(projects).values({ id, name, ownerId: userId });
-  await addMemberRow(id, userId, 'admin');
-  return { id, name, isDefault: false, owner: true, role: 'admin' };
-}
-
-export async function renameProjectForEmail(
-  email: string,
-  projectId: string,
-  raw: unknown,
-): Promise<Project> {
-  const name = projectName(raw);
-  const access = await memberAccessOrThrow(email, projectId);
-  if (access.role !== 'admin')
-    throw forbidden('only an admin can rename a project');
-  await getDb()
-    .update(projects)
-    .set({ name })
-    .where(eq(projects.id, access.projectId));
-  return {
-    id: access.projectId,
-    name,
-    isDefault: access.isDefault,
-    owner: access.ownerId === access.userId,
-    role: access.role,
-  };
-}
-
-export async function deleteProjectForEmail(
-  email: string,
-  projectId: string,
-): Promise<{ id: string; name: string }> {
-  const access = await memberAccessOrThrow(email, projectId);
-  if (access.ownerId !== access.userId)
-    throw forbidden('only the owner can delete a project');
-  if (access.isDefault)
-    throw forbidden('your default project cannot be deleted');
-  try {
-    await getDb().delete(projects).where(eq(projects.id, access.projectId));
-  } catch {
-    throw new ProjectError(
-      'this project still holds agents or connectors',
-      409,
-    );
-  }
-  return { id: access.projectId, name: access.name };
-}
-
-export async function listMembersForEmail(
-  email: string,
-  projectId: string,
-): Promise<Member[]> {
-  const access = await memberAccessOrThrow(email, projectId);
-  const rows = await getDb()
-    .select({
-      id: projectMembers.id,
-      email: users.email,
-      role: projectMembers.role,
-      userId: projectMembers.userId,
-    })
-    .from(projectMembers)
-    .innerJoin(users, eq(users.id, projectMembers.userId))
-    .where(eq(projectMembers.projectId, access.projectId))
-    .orderBy(asc(projectMembers.id));
-  return rows.map((r) => ({
-    id: r.id,
-    email: r.email,
-    role: r.role,
-    owner: r.userId === access.ownerId,
-  }));
-}
-
-function readRole(raw: unknown): ProjectRole {
-  if (raw === 'admin' || raw === 'member') return raw;
-  throw new ProjectError("a role is 'admin' or 'member'", 400);
-}
-
-async function adminAccessOrThrow(
-  email: string,
-  projectId: string,
-): Promise<Access> {
-  const access = await memberAccessOrThrow(email, projectId);
-  if (access.role !== 'admin')
-    throw forbidden('only an admin can manage members');
-  return access;
-}
-
-export async function addMemberForEmail(
-  email: string,
-  projectId: string,
-  raw: unknown,
-  rawRole: unknown,
-): Promise<Member[]> {
-  const access = await adminAccessOrThrow(email, projectId);
-  const role = readRole(rawRole);
-  const invited = normalizeEmail(typeof raw === 'string' ? raw : '');
-  if (invited === '') throw new ProjectError('an email is required', 400);
-  const invitedId = await ensureUser(invited);
-  await ensureDefaultProject(invitedId);
-  await addMemberRow(access.projectId, invitedId, role);
-  return listMembersForEmail(email, projectId);
-}
-
-async function memberRowOrThrow(
-  projectId: string,
-  memberId: string,
-): Promise<{ userId: string }> {
-  const rows = await getDb()
-    .select({ userId: projectMembers.userId })
-    .from(projectMembers)
-    .where(
-      and(
-        eq(projectMembers.id, memberId),
-        eq(projectMembers.projectId, projectId),
-      ),
-    );
-  const row = rows[0];
-  if (row === undefined) throw new ProjectError('no such member', 404);
-  return row;
-}
-
-export async function setMemberRoleForEmail(
-  email: string,
-  projectId: string,
-  memberId: string,
-  rawRole: unknown,
-): Promise<Member[]> {
-  const access = await adminAccessOrThrow(email, projectId);
-  const role = readRole(rawRole);
-  const member = await memberRowOrThrow(access.projectId, memberId);
-  if (member.userId === access.ownerId)
-    throw forbidden('the owner is always an admin');
-  await getDb()
-    .update(projectMembers)
-    .set({ role })
-    .where(eq(projectMembers.id, memberId));
-  return listMembersForEmail(email, projectId);
-}
-
-export async function removeMemberForEmail(
-  email: string,
-  projectId: string,
-  memberId: string,
-): Promise<Member[]> {
-  const access = await adminAccessOrThrow(email, projectId);
-  const member = await memberRowOrThrow(access.projectId, memberId);
-  if (member.userId === access.ownerId)
-    throw forbidden('the owner cannot be removed from their own project');
-  await getDb().delete(projectMembers).where(eq(projectMembers.id, memberId));
-  return listMembersForEmail(email, projectId);
-}

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

@@ -1,24 +0,0 @@
-import { ownedAgentOrThrow } from './agent-admin.js';
-import { mintAgentCode } from '../daemon/agent-pair.js';
-import { loadAllStationsFor, unmovableStations } from './materialize.js';
-import { releaseRuntime } from './runtimes.js';
-
-export async function mintAgentCodeForEmail(
-  email: string,
-  agentId: string,
-): Promise<{ code: string; expiresAt: number; agent: string }> {
-  const { agent } = await ownedAgentOrThrow(email, agentId);
-  return { ...mintAgentCode({ email, agentId: agent.id }), agent: agent.name };
-}
-
-export async function blockedStationsFor(agentId: string): Promise<string[]> {
-  return unmovableStations(await loadAllStationsFor(agentId));
-}
-
-export async function releaseRuntimeForEmail(
-  email: string,
-  agentId: string,
-): Promise<void> {
-  const { agent } = await ownedAgentOrThrow(email, agentId);
-  await releaseRuntime(agent.id);
-}

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,117 +0,0 @@
-import {
-  boolean,
-  jsonb,
-  pgTable,
-  text,
-  unique,
-} from 'drizzle-orm/pg-core';
-
-export const STATIONS = [
-  'xmtp',
-  'telegram-bot',
-  'telegram',
-  'discord-bot',
-  '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 agentConnectors = pgTable(
-  'agent_connectors',
-  {
-    id: text('id').primaryKey(),
-    agentId: text('agent_id')
-      .notNull()
-      .references(() => agents.id, { onDelete: 'cascade' }),
-    connectorId: text('connector_id')
-      .notNull()
-      .references(() => connectors.id, { onDelete: 'cascade' }),
-  },
-  (t) => [
-    unique('agent_connectors_agent_id_connector_id_unique').on(
-      t.agentId,
-      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,62 +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 {}
-
-const CAUSE_DEPTH = 5;
-
-export function isUniqueViolation(err: unknown): boolean {
-  let current: unknown = err;
-  for (let depth = 0; depth < CAUSE_DEPTH; depth += 1) {
-    if (typeof current !== 'object' || current === null) return false;
-    const { code, cause } = current as { code?: unknown; cause?: unknown };
-    if (code === UNIQUE_VIOLATION) return true;
-    current = cause;
-  }
-  return false;
-}
-
-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);
-  }
-}