@stage-labs/metro 0.1.0-beta.50 → 0.1.0-beta.52

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

@@ -1,105 +0,0 @@
-import { errMsg, log } from './log.js';
-import type { LoadedAgent, StationSource } from '../db/materialize.js';
-
-const POLL_MS = 30_000;
-const BACKOFF_MS = 5 * 60_000;
-const FETCH_TIMEOUT_MS = 15_000;
-
-export class RuntimeRevoked extends Error {}
-
-const LOOPBACK = new Set(['127.0.0.1', '::1', 'localhost']);
-
-export function carriesSecretsSafely(base: string): boolean {
-  let url: URL;
-  try {
-    url = new URL(base);
-  } catch {
-    return false;
-  }
-  if (url.protocol === 'https:') return true;
-  return url.protocol === 'http:' && LOOPBACK.has(url.hostname);
-}
-
-export interface RuntimeConfig {
-  url: string;
-  token: string;
-}
-
-export function runtimeConfigFromEnv(): RuntimeConfig | null {
-  const token = process.env.METRO_RUN_TOKEN?.trim() ?? '';
-  if (token === '') return null;
-  const raw = (process.env.METRO_URL?.trim() ?? '').replace(/\/+$/, '');
-  const url = raw === '' ? 'https://mcp.metro.box' : raw;
-  if (!carriesSecretsSafely(url))
-    throw new Error(
-      `refusing to fetch station credentials from ${url} in the clear — ` +
-        'use https, or a loopback address',
-    );
-  return { url, token };
-}
-
-export function httpSource(cfg: RuntimeConfig): StationSource {
-  return async () => {
-    const res = await fetch(`${cfg.url}/api/run/config`, {
-      headers: { authorization: `Bearer ${cfg.token}` },
-      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
-      redirect: 'manual',
-    });
-    if (res.status === 401 || res.status === 403 || res.status === 409)
-      throw new RuntimeRevoked(
-        `metro no longer recognises this machine as the holder (${String(res.status)})`,
-      );
-    if (!res.ok)
-      throw new Error(`metro answered ${String(res.status)} for the run config`);
-    const body = (await res.json()) as { agent?: LoadedAgent };
-    if (!body.agent) throw new Error('metro returned no agent');
-    return [body.agent];
-  };
-}
-
-export interface PollerDeps {
-  sync: () => Promise<void>;
-  stopAll: () => Promise<void>;
-  everyMs?: number;
-  backoffMs?: number;
-}
-
-export function startRuntimePoller(deps: PollerDeps): () => void {
-  const everyMs = deps.everyMs ?? POLL_MS;
-  const backoffMs = deps.backoffMs ?? BACKOFF_MS;
-  let stopped = false;
-  let timer: ReturnType<typeof setTimeout> | null = null;
-
-  const arm = (ms: number): void => {
-    if (stopped) return;
-    timer = setTimeout(() => {
-      tick().catch((err: unknown) => {
-        log.error({ err: errMsg(err) }, 'runtime: poller failed');
-      });
-    }, ms);
-    timer.unref?.();
-  };
-
-  async function tick(): Promise<void> {
-    if (stopped) return;
-    try {
-      await deps.sync();
-      arm(everyMs);
-    } catch (err) {
-      if (err instanceof RuntimeRevoked) {
-        stopped = true;
-        log.error({ reason: err.message }, 'runtime: revoked — stopping stations');
-        await deps.stopAll();
-        return;
-      }
-      log.warn({ err: errMsg(err) }, 'runtime: could not reach metro; retrying');
-      arm(backoffMs);
-    }
-  }
-
-  arm(everyMs);
-  return () => {
-    stopped = true;
-    if (timer !== null) clearTimeout(timer);
-  };
-}

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

@@ -1,143 +0,0 @@
-import { and, asc, eq, inArray, ne } from 'drizzle-orm';
-import { getDb } from './client.js';
-import { newId } from './ids.js';
-import { isUniqueViolation } from './users.js';
-import { ownedAgentOrThrow } from './agent-admin.js';
-import { ConnectorError } from './connector-config.js';
-import { agentConnectors, agents, connectors } from './schema.js';
-
-export interface AgentConnectors {
-  id: string;
-  name: string;
-  connectorIds: string[];
-}
-
-const nameClash = (name: string, agent: string): ConnectorError =>
-  new ConnectorError(
-    `the agent '${agent}' already has a connector named '${name}'`,
-    409,
-  );
-
-async function collidingAgent(
-  agentIds: string[],
-  name: string,
-  exceptConnectorId: string,
-): Promise<string | null> {
-  if (agentIds.length === 0) return null;
-  const rows = await getDb()
-    .select({ agent: agents.name })
-    .from(agentConnectors)
-    .innerJoin(connectors, eq(connectors.id, agentConnectors.connectorId))
-    .innerJoin(agents, eq(agents.id, agentConnectors.agentId))
-    .where(
-      and(
-        inArray(agentConnectors.agentId, agentIds),
-        eq(connectors.name, name),
-        ne(connectors.id, exceptConnectorId),
-      ),
-    )
-    .limit(1);
-  return rows[0]?.agent ?? null;
-}
-
-export async function assertRenameFreeOfClash(
-  connectorId: string,
-  name: string,
-): Promise<void> {
-  const rows = await getDb()
-    .select({ agentId: agentConnectors.agentId })
-    .from(agentConnectors)
-    .where(eq(agentConnectors.connectorId, connectorId));
-  const clash = await collidingAgent(
-    rows.map((r) => r.agentId),
-    name,
-    connectorId,
-  );
-  if (clash !== null) throw nameClash(name, clash);
-}
-
-async function connectorIdsOfAgent(agentId: string): Promise<string[]> {
-  const rows = await getDb()
-    .select({ connectorId: agentConnectors.connectorId })
-    .from(agentConnectors)
-    .where(eq(agentConnectors.agentId, agentId))
-    .orderBy(asc(agentConnectors.id));
-  return rows.map((r) => r.connectorId);
-}
-
-export async function connectorIdsByAgent(
-  agentIds: string[],
-): Promise<Map<string, string[]>> {
-  const out = new Map<string, string[]>();
-  if (agentIds.length === 0) return out;
-  const rows = await getDb()
-    .select({
-      agentId: agentConnectors.agentId,
-      connectorId: agentConnectors.connectorId,
-    })
-    .from(agentConnectors)
-    .where(inArray(agentConnectors.agentId, agentIds))
-    .orderBy(asc(agentConnectors.id));
-  for (const row of rows) {
-    const list = out.get(row.agentId) ?? [];
-    list.push(row.connectorId);
-    out.set(row.agentId, list);
-  }
-  return out;
-}
-
-export async function agentConnectorsForUser(
-  subject: string,
-  agentId: string,
-): Promise<AgentConnectors> {
-  const { agent } = await ownedAgentOrThrow(subject, agentId);
-  return { ...agent, connectorIds: await connectorIdsOfAgent(agent.id) };
-}
-
-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 addConnectorToAgentForUser(
-  subject: string,
-  agentId: string,
-  connectorId: string,
-): Promise<AgentConnectors> {
-  const { agent, projectId } = await ownedAgentOrThrow(subject, agentId);
-  const name = await connectorNameIn(projectId, connectorId);
-  if (name === null) throw new ConnectorError('no such connector', 404);
-  const clash = await collidingAgent([agent.id], name, connectorId);
-  if (clash !== null) throw nameClash(name, clash);
-  try {
-    await getDb()
-      .insert(agentConnectors)
-      .values({ id: newId(), agentId: agent.id, connectorId });
-  } catch (err) {
-    if (!isUniqueViolation(err)) throw err;
-  }
-  return { ...agent, connectorIds: await connectorIdsOfAgent(agent.id) };
-}
-
-export async function removeConnectorFromAgentForUser(
-  subject: string,
-  agentId: string,
-  connectorId: string,
-): Promise<AgentConnectors> {
-  const { agent } = await ownedAgentOrThrow(subject, agentId);
-  await getDb()
-    .delete(agentConnectors)
-    .where(
-      and(
-        eq(agentConnectors.agentId, agent.id),
-        eq(agentConnectors.connectorId, connectorId),
-      ),
-    );
-  return { ...agent, connectorIds: await connectorIdsOfAgent(agent.id) };
-}

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

@@ -1,309 +0,0 @@
-import {
-  ensureUserByAddress,
-  normalizeAddress,
-  userIdForSubject,
-} 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;
-  address: string | null;
-  email: string | null;
-  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);
-
-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;
-}
-
-async function memberAccessOrThrow(
-  subject: string,
-  projectId: string,
-): Promise<Access> {
-  const userId = await userIdForSubject(subject);
-  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(
-  subject: string,
-  projectId: string,
-): Promise<string> {
-  return (await memberAccessOrThrow(subject, projectId)).projectId;
-}
-
-async function addMemberRow(
-  projectId: string,
-  userId: string,
-  role: ProjectRole,
-): Promise<void> {
-  await getDb()
-    .insert(projectMembers)
-    .values({ id: newId(), projectId, userId, role })
-    .onConflictDoNothing();
-}
-
-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(address: string): Promise<string> {
-  const userId = await ensureUserByAddress(address);
-  await ensureDefaultProject(userId);
-  return userId;
-}
-
-export async function listProjectsForUser(subject: string): Promise<Project[]> {
-  const userId = await userIdForSubject(subject);
-  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 createProjectForUser(
-  subject: string,
-  raw: unknown,
-): Promise<Project> {
-  const name = projectName(raw);
-  const userId = await userIdForSubject(subject);
-  if (userId === null) throw new ProjectError('unknown account', 401);
-  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 renameProjectForUser(
-  subject: string,
-  projectId: string,
-  raw: unknown,
-): Promise<Project> {
-  const name = projectName(raw);
-  const access = await memberAccessOrThrow(subject, 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 deleteProjectForUser(
-  subject: string,
-  projectId: string,
-): Promise<{ id: string; name: string }> {
-  const access = await memberAccessOrThrow(subject, 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 listMembersForUser(
-  subject: string,
-  projectId: string,
-): Promise<Member[]> {
-  const access = await memberAccessOrThrow(subject, projectId);
-  const rows = await getDb()
-    .select({
-      id: projectMembers.id,
-      address: users.address,
-      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,
-    address: r.address,
-    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(
-  subject: string,
-  projectId: string,
-): Promise<Access> {
-  const access = await memberAccessOrThrow(subject, projectId);
-  if (access.role !== 'admin')
-    throw forbidden('only an admin can manage members');
-  return access;
-}
-
-export async function addMemberForUser(
-  subject: string,
-  projectId: string,
-  raw: unknown,
-  rawRole: unknown,
-): Promise<Member[]> {
-  const access = await adminAccessOrThrow(subject, projectId);
-  const role = readRole(rawRole);
-  const invited = normalizeAddress(typeof raw === 'string' ? raw : '');
-  if (invited === null)
-    throw new ProjectError('an Ethereum address is required', 400);
-  const invitedId = await ensureUserByAddress(invited);
-  await ensureDefaultProject(invitedId);
-  await addMemberRow(access.projectId, invitedId, role);
-  return listMembersForUser(subject, 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 setMemberRoleForUser(
-  subject: string,
-  projectId: string,
-  memberId: string,
-  rawRole: unknown,
-): Promise<Member[]> {
-  const access = await adminAccessOrThrow(subject, 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 listMembersForUser(subject, projectId);
-}
-
-export async function removeMemberForUser(
-  subject: string,
-  projectId: string,
-  memberId: string,
-): Promise<Member[]> {
-  const access = await adminAccessOrThrow(subject, 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 listMembersForUser(subject, 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 mintAgentCodeForUser(
-  subject: string,
-  agentId: string,
-): Promise<{ code: string; expiresAt: number; agent: string }> {
-  const { agent } = await ownedAgentOrThrow(subject, agentId);
-  return { ...mintAgentCode({ subject, agentId: agent.id }), agent: agent.name };
-}
-
-export async function blockedStationsFor(agentId: string): Promise<string[]> {
-  return unmovableStations(await loadAllStationsFor(agentId));
-}
-
-export async function releaseRuntimeForUser(
-  subject: string,
-  agentId: string,
-): Promise<void> {
-  const { agent } = await ownedAgentOrThrow(subject, 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;
-}
-
-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/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)),
-    );
-}