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

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

@@ -0,0 +1,89 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { log } from './log.js';
+import {
+  apiFailure,
+  bodyField,
+  cors,
+  readJsonBody,
+  sendJson,
+} from './api-http.js';
+import { mintNonce, takeNonce } from './siwe-nonces.js';
+import { verifySiweLogin } from './siwe-auth.js';
+import { signSession } from './session.js';
+import { sessionTtlFromEnv } from './session-config.js';
+import { ensureUserWithProject } from '../db/projects.js';
+
+const NONCE_PATH = '/auth/siwe/nonce';
+const VERIFY_PATH = '/auth/siwe/verify';
+
+export interface SiweRouteDeps {
+  ensureUser: (address: string) => Promise<string>;
+}
+
+const defaultDeps: SiweRouteDeps = { ensureUser: ensureUserWithProject };
+
+async function handleVerify(
+  req: IncomingMessage,
+  res: ServerResponse,
+  secret: string,
+  deps: SiweRouteDeps,
+): Promise<void> {
+  const body = await readJsonBody(req);
+  const message = bodyField(body, 'message');
+  const signature = bodyField(body, 'signature');
+  if (typeof message !== 'string' || typeof signature !== 'string') {
+    sendJson(req, res, 400, { error: 'message and signature are required' });
+    return;
+  }
+  const address = await verifySiweLogin({ message, signature }, { takeNonce });
+  const userId = await deps.ensureUser(address);
+  log.info({ userId, address }, 'siwe: session issued');
+  const session = signSession({ subject: address, agentIds: [] }, secret, {
+    ttlSec: sessionTtlFromEnv(),
+  });
+  sendJson(req, res, 200, { session, address });
+}
+
+const ROUTES: Record<string, string> = {
+  [NONCE_PATH]: 'GET',
+  [VERIFY_PATH]: 'POST',
+};
+
+function refused(
+  req: IncomingMessage,
+  res: ServerResponse,
+  path: string,
+): boolean {
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204, cors(req)).end();
+    return true;
+  }
+  if (req.method !== ROUTES[path]) {
+    sendJson(req, res, 405, { error: 'method not allowed' });
+    return true;
+  }
+  return false;
+}
+
+export function handleSiweAuthRequest(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: SiweRouteDeps = defaultDeps,
+): boolean {
+  const path = (req.url ?? '').split('?')[0] ?? '';
+  if (ROUTES[path] === undefined) return false;
+  if (refused(req, res, path)) return true;
+  const secret = process.env.METRO_SESSION_SECRET?.trim() ?? '';
+  if (secret === '') {
+    sendJson(req, res, 503, { error: 'sign-in is not configured' });
+    return true;
+  }
+  if (path === NONCE_PATH) {
+    sendJson(req, res, 200, { nonce: mintNonce() });
+    return true;
+  }
+  handleVerify(req, res, secret, deps).catch((err: unknown) => {
+    apiFailure(req, res, err, 'siwe');
+  });
+  return true;
+}

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

@@ -1,5 +1,4 @@
 import { mkdirSync, statSync, type FSWatcher } from 'node:fs';
-import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { errMsg, log } from './log.js';
 import { daemonSelf } from './events.js';
@@ -22,9 +21,7 @@ import {
   startWatcher,
   type TrainState,
 } from './supervisor-io.js';
-
-export const TRAINS_DIR =
-  process.env.METRO_TRAINS_DIR ?? join(homedir(), '.metro', 'trains');
+import { trainsDir } from './paths.js';
 
 const DYLD_FALLBACK_ENV: Record<string, string> =
   process.platform === 'darwin'
@@ -45,7 +42,7 @@ export class TrainSupervisor {
   private watcher: FSWatcher | null = null;
   private reloadTimers = new Map<string, ReturnType<typeof setTimeout>>();
 
-  constructor(private dir: string = TRAINS_DIR) {}
+  constructor(private dir: string = trainsDir()) {}
 
   running(): string[] {
     return [...this.trains.keys()];

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

@@ -3,12 +3,11 @@ import { and, asc, eq, inArray } from 'drizzle-orm';
 import { ApiError } from '../daemon/api-error.js';
 import { getDb } from './client.js';
 import { registerKey, rotateAgentKey, unregisterAgentKey } from './key-map.js';
-import { newId, parseId } from './ids.js';
+import { AGENT_NAME_RE, newId, parseId } from './ids.js';
 import { agents, stations } from './schema.js';
 import { isUniqueViolation } from './users.js';
 import { projectIdOrThrow } from './projects.js';
 
-export const AGENT_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9_-]{1,31}$/;
 const KEY_ATTEMPTS = 5;
 
 export class AgentAdminError extends ApiError {}
@@ -93,11 +92,11 @@ async function selectKeyRows(ids: string[]): Promise<KeyRow[]> {
     .where(inArray(agents.id, ids));
 }
 
-export async function listAgentsForEmail(
-  email: string,
+export async function listAgentsForUser(
+  subject: string,
   project: string,
 ): Promise<AgentSummary[]> {
-  const projectId = await projectIdOrThrow(email, project);
+  const projectId = await projectIdOrThrow(subject, project);
   const rows = await getDb()
     .select({ id: agents.id, name: agents.name, projectId: agents.projectId })
     .from(agents)
@@ -123,14 +122,14 @@ async function insertAgent(
   return id;
 }
 
-export async function createAgentForEmail(
-  email: string,
+export async function createAgentForUser(
+  subject: string,
   project: string,
   rawName: string,
 ): Promise<CreatedAgent> {
   const name = normalizeAgentName(rawName);
   const key = newApiKey();
-  const id = await insertAgent(await projectIdOrThrow(email, project), name, key);
+  const id = await insertAgent(await projectIdOrThrow(subject, project), name, key);
   if (servesEveryAgent()) registerKey(key, id);
   return { id, name, key };
 }
@@ -145,7 +144,7 @@ interface Deletable {
 }
 
 export async function ownedAgentOrThrow(
-  email: string,
+  subject: string,
   id: string,
 ): Promise<Deletable> {
   const rows = await getDb().select().from(agents).where(eq(agents.id, id));
@@ -153,7 +152,7 @@ export async function ownedAgentOrThrow(
   const missing = new AgentAdminError('no such agent', 404);
   if (!row) throw missing;
   try {
-    await projectIdOrThrow(email, row.projectId);
+    await projectIdOrThrow(subject, row.projectId);
   } catch {
     throw missing;
   }
@@ -179,21 +178,21 @@ async function writeNewKey(id: string, projectId: string): Promise<string> {
   throw new AgentAdminError('could not allocate a free api key', 500);
 }
 
-export async function resetAgentKeyForEmail(
-  email: string,
+export async function resetAgentKeyForUser(
+  subject: string,
   id: string,
 ): Promise<ResetAgentKey> {
-  const { agent, projectId } = await ownedAgentOrThrow(email, id);
+  const { agent, projectId } = await ownedAgentOrThrow(subject, id);
   const key = await writeNewKey(agent.id, projectId);
   rotateAgentKey(agent.id, daemonServesAgent(agent.id) ? key : null);
   return { id: agent.id, name: agent.name, key };
 }
 
-export async function deleteAgentForEmail(
-  email: string,
+export async function deleteAgentForUser(
+  subject: string,
   id: string,
 ): Promise<DeletedAgent> {
-  const { agent, projectId } = await ownedAgentOrThrow(email, id);
+  const { agent, projectId } = await ownedAgentOrThrow(subject, id);
   await getDb().transaction(async (tx) => {
     const attached = await tx
       .select({ id: stations.id })

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

@@ -86,11 +86,11 @@ export async function connectorIdsByAgent(
   return out;
 }
 
-export async function agentConnectorsForEmail(
-  email: string,
+export async function agentConnectorsForUser(
+  subject: string,
   agentId: string,
 ): Promise<AgentConnectors> {
-  const { agent } = await ownedAgentOrThrow(email, agentId);
+  const { agent } = await ownedAgentOrThrow(subject, agentId);
   return { ...agent, connectorIds: await connectorIdsOfAgent(agent.id) };
 }
 
@@ -105,12 +105,12 @@ async function connectorNameIn(
   return rows[0]?.name ?? null;
 }
 
-export async function addConnectorToAgentForEmail(
-  email: string,
+export async function addConnectorToAgentForUser(
+  subject: string,
   agentId: string,
   connectorId: string,
 ): Promise<AgentConnectors> {
-  const { agent, projectId } = await ownedAgentOrThrow(email, agentId);
+  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);
@@ -125,12 +125,12 @@ export async function addConnectorToAgentForEmail(
   return { ...agent, connectorIds: await connectorIdsOfAgent(agent.id) };
 }
 
-export async function removeConnectorFromAgentForEmail(
-  email: string,
+export async function removeConnectorFromAgentForUser(
+  subject: string,
   agentId: string,
   connectorId: string,
 ): Promise<AgentConnectors> {
-  const { agent } = await ownedAgentOrThrow(email, agentId);
+  const { agent } = await ownedAgentOrThrow(subject, agentId);
   await getDb()
     .delete(agentConnectors)
     .where(

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

@@ -80,7 +80,7 @@ const missing = (): ConnectorError =>
   new ConnectorError('no such connector', 404);
 
 async function ownedConnectorOrThrow(
-  email: string,
+  subject: string,
   id: string,
 ): Promise<ConnectorRow> {
   const rows = await getDb()
@@ -90,7 +90,7 @@ async function ownedConnectorOrThrow(
   const row = rows[0];
   if (row === undefined) throw missing();
   try {
-    await projectIdOrThrow(email, row.projectId);
+    await projectIdOrThrow(subject, row.projectId);
   } catch {
     throw missing();
   }
@@ -112,10 +112,10 @@ async function saveConfig(
 }
 
 async function connectorRowsFor(
-  email: string,
+  subject: string,
   project: string,
 ): Promise<ConnectorRow[]> {
-  const projectId = await projectIdOrThrow(email, project);
+  const projectId = await projectIdOrThrow(subject, project);
   return getDb()
     .select()
     .from(connectors)
@@ -123,11 +123,11 @@ async function connectorRowsFor(
     .orderBy(asc(connectors.id));
 }
 
-export async function listConnectorsForEmail(
-  email: string,
+export async function listConnectorsForUser(
+  subject: string,
   project: string,
 ): Promise<Connector[]> {
-  return (await connectorRowsFor(email, project)).map(toConnector);
+  return (await connectorRowsFor(subject, project)).map(toConnector);
 }
 
 async function rowsByIds(ids: string[]): Promise<ConnectorRow[]> {
@@ -145,11 +145,11 @@ export async function connectorNamesByIds(
   return (await rowsByIds(ids)).map((row) => ({ id: row.id, name: row.name }));
 }
 
-export async function getConnectorForEmail(
-  email: string,
+export async function getConnectorForUser(
+  subject: string,
   id: string,
 ): Promise<Connector> {
-  return toConnector(await ownedConnectorOrThrow(email, id));
+  return toConnector(await ownedConnectorOrThrow(subject, id));
 }
 
 async function insertConnector(
@@ -185,14 +185,14 @@ const UNVERIFIED = {
   catalog: [],
 };
 
-export async function createPendingConnectorForEmail(
-  email: string,
+export async function createPendingConnectorForUser(
+  subject: string,
   project: string,
   input: { name: unknown; url: unknown },
 ): Promise<Connector> {
   const name = connectorName(input.name);
   const url = parseConnectorUrl(input.url);
-  const projectId = await projectIdOrThrow(email, project);
+  const projectId = await projectIdOrThrow(subject, project);
   return insertConnector(projectId, name, url, {
     auth: { kind: 'none' },
     createdAt: new Date().toISOString(),
@@ -201,15 +201,15 @@ export async function createPendingConnectorForEmail(
   });
 }
 
-export async function createConnectorForEmail(
-  email: string,
+export async function createConnectorForUser(
+  subject: string,
   project: string,
   input: ConnectorInput,
 ): Promise<Connector> {
   const name = connectorName(input.name);
   const url = parseConnectorUrl(input.url);
   const auth = connectorAuth(input.header, input.value);
-  const projectId = await projectIdOrThrow(email, project);
+  const projectId = await projectIdOrThrow(subject, project);
   const verified = stamp(await verifyRemoteMcp(url, auth));
   return insertConnector(projectId, name, url, {
     auth,
@@ -233,34 +233,34 @@ async function freshAuth(
   return refreshOAuth(auth, resource);
 }
 
-export async function reconnectConnectorForEmail(
-  email: string,
+export async function reconnectConnectorForUser(
+  subject: string,
   id: string,
   auth: OAuthAuth,
 ): Promise<Connector> {
-  const row = await ownedConnectorOrThrow(email, id);
+  const row = await ownedConnectorOrThrow(subject, id);
   const config = readConfig(row.config);
   const url = parseConnectorUrl(row.url);
   const verified = stamp(await verifyRemoteMcp(url, auth));
   return saveConfig(row, { ...config, auth, verified, oauth: true });
 }
 
-export async function disconnectConnectorForEmail(
-  email: string,
+export async function disconnectConnectorForUser(
+  subject: string,
   id: string,
 ): Promise<Connector> {
-  const row = await ownedConnectorOrThrow(email, id);
+  const row = await ownedConnectorOrThrow(subject, id);
   const config = readConfig(row.config);
   if (config.auth.kind !== 'oauth')
     throw new ConnectorError('that connector is not signed in', 400);
   return saveConfig(row, { ...config, auth: { kind: 'none' }, oauth: true });
 }
 
-export async function verifyConnectorForEmail(
-  email: string,
+export async function verifyConnectorForUser(
+  subject: string,
   id: string,
 ): Promise<ConnectorCheck> {
-  const row = await ownedConnectorOrThrow(email, id);
+  const row = await ownedConnectorOrThrow(subject, id);
   const config = readConfig(row.config);
   try {
     const url = parseConnectorUrl(row.url);
@@ -275,13 +275,13 @@ export async function verifyConnectorForEmail(
   }
 }
 
-export async function renameConnectorForEmail(
-  email: string,
+export async function renameConnectorForUser(
+  subject: string,
   id: string,
   raw: string,
 ): Promise<Connector> {
   const name = connectorName(raw);
-  const row = await ownedConnectorOrThrow(email, id);
+  const row = await ownedConnectorOrThrow(subject, id);
   await assertRenameFreeOfClash(row.id, name);
   const rows = await getDb()
     .update(connectors)
@@ -293,11 +293,11 @@ export async function renameConnectorForEmail(
   return toConnector(saved);
 }
 
-export async function deleteConnectorForEmail(
-  email: string,
+export async function deleteConnectorForUser(
+  subject: string,
   id: string,
 ): Promise<DeletedConnector> {
-  const row = await ownedConnectorOrThrow(email, id);
+  const row = await ownedConnectorOrThrow(subject, id);
   const gone = await getDb()
     .delete(connectors)
     .where(eq(connectors.id, row.id))

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

@@ -0,0 +1,250 @@
+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 });
+}