@stage-labs/metro 0.1.0-beta.32 → 0.1.0-beta.320

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

@@ -1,250 +0,0 @@
-import {
-  closeSync,
-  existsSync,
-  openSync,
-  readFileSync,
-  rmdirSync,
-  rmSync,
-  writeSync,
-} from 'node:fs';
-import { join } from 'node:path';
-import { ApiError } from '../daemon/api-error.js';
-import { ensureSecureDir, writeSecure } from '../daemon/secure-fs.js';
-import {
-  AgentAdminError,
-  newApiKey,
-  normalizeAgentName,
-  type AgentSummary,
-  type CreatedAgent,
-  type DeletedAgent,
-  type OwnedAgent,
-  type ResetAgentKey,
-} from './agent-admin.js';
-import type { AccountRef } from './account-attach.js';
-import {
-  AGENT_FILE,
-  agentsDir,
-  listAgentFiles,
-  readAgentFile,
-  type AgentFile,
-} from './file-source.js';
-import { newId } from './ids.js';
-import { registerKey, rotateAgentKey, unregisterAgentKey } from './key-map.js';
-import { MOVABLE_STATIONS } from './materialize.js';
-import type { StationName } from './schema.js';
-import { normalizeAddress } from './users.js';
-
-export const LOCAL_PROJECT_ID = 'localdaemon';
-const OWNER_FILE = '.owner';
-
-interface Stored {
-  path: string;
-  file: AgentFile;
-}
-
-const missing = (): AgentAdminError => new AgentAdminError('no such agent', 404);
-
-export function localOwner(dir = agentsDir()): string | null {
-  try {
-    return normalizeAddress(readFileSync(join(dir, OWNER_FILE), 'utf8'));
-  } catch {
-    return null;
-  }
-}
-
-function writeOwnerOnce(path: string, address: string): boolean {
-  let fd: number;
-  try {
-    fd = openSync(path, 'wx', 0o600);
-  } catch (err) {
-    if ((err as NodeJS.ErrnoException).code === 'EEXIST') return false;
-    throw err;
-  }
-  writeSync(fd, `${address}\n`);
-  closeSync(fd);
-  return true;
-}
-
-export function claimLocalOwner(raw: string, dir = agentsDir()): Promise<string> {
-  const address = normalizeAddress(raw);
-  if (address === null)
-    return Promise.reject(new ApiError('an Ethereum address is required', 400));
-  ensureSecureDir(dir);
-  if (writeOwnerOnce(join(dir, OWNER_FILE), address))
-    return Promise.resolve(address);
-  if (localOwner(dir) !== address)
-    return Promise.reject(
-      new ApiError('this machine belongs to another wallet', 403),
-    );
-  return Promise.resolve(address);
-}
-
-function isOwner(subject: string, dir: string): boolean {
-  const owner = localOwner(dir);
-  return owner !== null && owner === normalizeAddress(subject);
-}
-
-function storedAgents(dir: string): Stored[] {
-  return listAgentFiles(dir).map((path) => ({ path, file: readAgentFile(path) }));
-}
-
-function save(stored: Stored): void {
-  writeSecure(stored.path, `${JSON.stringify(stored.file, null, 2)}\n`);
-}
-
-function ownedOrThrow(subject: string, id: string, dir: string): Stored {
-  if (!isOwner(subject, dir)) throw missing();
-  const found = storedAgents(dir).find((s) => s.file.id === id);
-  if (found === undefined) throw missing();
-  return found;
-}
-
-export async function localOwnedAgentOrThrow(
-  subject: string,
-  id: string,
-  dir = agentsDir(),
-): Promise<{ agent: OwnedAgent }> {
-  const { file } = ownedOrThrow(subject, id, dir);
-  return Promise.resolve({ agent: { id: file.id, name: file.name } });
-}
-
-export async function localListAgents(
-  subject: string,
-  project: string,
-  dir = agentsDir(),
-): Promise<AgentSummary[]> {
-  if (project !== LOCAL_PROJECT_ID || !isOwner(subject, dir))
-    throw new AgentAdminError('no such project', 404);
-  return Promise.resolve(
-    storedAgents(dir)
-      .map(({ file }) => ({ id: file.id, name: file.name, owned: true, key: file.key }))
-      .sort((a, b) => a.name.localeCompare(b.name) || a.id.localeCompare(b.id)),
-  );
-}
-
-function freshId(taken: Set<string>): string {
-  for (let attempt = 0; attempt < 5; attempt += 1) {
-    const id = newId();
-    if (!taken.has(id)) return id;
-  }
-  throw new AgentAdminError('could not allocate a free id', 500);
-}
-
-export async function localCreateAgent(
-  subject: string,
-  project: string,
-  rawName: string,
-  dir = agentsDir(),
-): Promise<CreatedAgent> {
-  if (project !== LOCAL_PROJECT_ID || !isOwner(subject, dir))
-    throw new AgentAdminError('no such project', 404);
-  const name = normalizeAgentName(rawName);
-  const folder = join(dir, name);
-  if (existsSync(join(folder, AGENT_FILE)))
-    throw new AgentAdminError(
-      `an agent named '${name}' already exists on this machine`,
-      409,
-    );
-  const existing = storedAgents(dir);
-  const id = freshId(new Set(existing.map((s) => s.file.id)));
-  const key = newApiKey();
-  ensureSecureDir(folder);
-  save({
-    path: join(folder, AGENT_FILE),
-    file: { version: 1, id, name, key, owner: localOwner(dir), stations: [] },
-  });
-  registerKey(key, id);
-  return Promise.resolve({ id, name, key });
-}
-
-export async function localResetAgentKey(
-  subject: string,
-  id: string,
-  dir = agentsDir(),
-): Promise<ResetAgentKey> {
-  const stored = ownedOrThrow(subject, id, dir);
-  const key = newApiKey();
-  stored.file.key = key;
-  save(stored);
-  rotateAgentKey(id, key);
-  return Promise.resolve({ id, name: stored.file.name, key });
-}
-
-export async function localDeleteAgent(
-  subject: string,
-  id: string,
-  dir = agentsDir(),
-): Promise<DeletedAgent> {
-  const stored = ownedOrThrow(subject, id, dir);
-  const attached = stored.file.stations.length;
-  if (attached > 0)
-    throw new AgentAdminError(
-      `agent '${stored.file.name}' still has ${String(attached)} station account(s) attached — detach them first`,
-      409,
-    );
-  rmSync(stored.path);
-  removeIfEmpty(join(stored.path, '..'));
-  unregisterAgentKey(id);
-  return Promise.resolve({ id, name: stored.file.name });
-}
-
-function removeIfEmpty(folder: string): void {
-  try {
-    rmdirSync(folder);
-  } catch {
-    return;
-  }
-}
-
-function assertTokenFree(all: Stored[], station: StationName, token: string): void {
-  const taken = all.some((s) =>
-    s.file.stations.some(
-      (a) => a.station === station && a.config.token === token,
-    ),
-  );
-  if (taken)
-    throw new AgentAdminError(
-      'that bot token is already attached to an agent on this machine',
-      409,
-    );
-}
-
-export async function localAttachAccount(
-  subject: string,
-  agentId: string,
-  station: StationName,
-  config: Record<string, unknown>,
-  dir = agentsDir(),
-): Promise<AccountRef> {
-  const stored = ownedOrThrow(subject, agentId, dir);
-  if (!MOVABLE_STATIONS.has(station))
-    throw new AgentAdminError(
-      `a ${station} endpoint needs a public url and cannot live on a local daemon`,
-      400,
-    );
-  const token = config.token;
-  if (typeof token === 'string') assertTokenFree(storedAgents(dir), station, token);
-  const taken = new Set(stored.file.stations.map((a) => a.id));
-  const accountId = freshId(taken);
-  stored.file.stations.push({ station, id: accountId, allowlist: ['*'], config });
-  save(stored);
-  return Promise.resolve({ agentId, station, accountId });
-}
-
-export async function localDetachAccount(
-  subject: string,
-  agentId: string,
-  station: StationName,
-  accountId: string,
-  dir = agentsDir(),
-): Promise<AccountRef> {
-  const stored = ownedOrThrow(subject, agentId, dir);
-  const before = stored.file.stations.length;
-  stored.file.stations = stored.file.stations.filter(
-    (a) => !(a.station === station && a.id === accountId),
-  );
-  if (stored.file.stations.length === before)
-    throw new AgentAdminError('no such account on this agent', 404);
-  save(stored);
-  return Promise.resolve({ agentId, station, accountId });
-}

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);
-
-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(
-  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();
-}
-
-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(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;
-}
-
-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;
-}