@stage-labs/metro 0.1.0-beta.76 → 0.1.0-beta.78

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

@@ -1,33 +0,0 @@
-import { index, jsonb, pgTable, text, uniqueIndex } from 'drizzle-orm/pg-core';
-
-import { STATIONS, type ConnectorTransport, type StationName } from './stations.js';
-
-export { STATIONS, type ConnectorTransport, type StationName };
-
-export type ProjectRole = 'admin' | 'member';
-
-
-export const vaults = pgTable(
-  'vaults',
-  {
-    id: text('id').primaryKey(),
-    owner: text('owner').notNull(),
-    name: text('name').notNull(),
-    stations: jsonb('stations').notNull(),
-    envelope: jsonb('envelope').notNull(),
-    syncedAt: text('synced_at').notNull(),
-  },
-  (t) => [index('vaults_owner_idx').on(t.owner)],
-);
-
-export const servers = pgTable(
-  'servers',
-  {
-    id: text('id').primaryKey(),
-    owner: text('owner').notNull(),
-    host: text('host').notNull(),
-    name: text('name'),
-    addedAt: text('added_at').notNull(),
-  },
-  (t) => [uniqueIndex('servers_owner_host_idx').on(t.owner, t.host), index('servers_owner_idx').on(t.owner)],
-);

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

@@ -1,83 +0,0 @@
-import { and, asc, eq } from 'drizzle-orm';
-import { ApiError } from '../daemon/api-error.js';
-import { isRecord } from '../daemon/is-record.js';
-import { getDb } from './client.js';
-import { newId, parseId } from './ids.js';
-import { servers } from './schema.js';
-import { normalizeAddress } from './address.js';
-import { parseServerHost, parseServerName, type ServerEntry } from '../daemon/server-types.js';
-
-export class ServerListError extends ApiError {}
-
-const missing = (): ServerListError => new ServerListError('no such server', 404);
-
-function ownerOf(subject: string): string {
-  const address = normalizeAddress(subject);
-  if (address === null) throw new ServerListError('the server list needs a signed identity', 403);
-  return address;
-}
-
-function idOf(raw: string): string {
-  const id = parseId(raw);
-  if (id === null) throw missing();
-  return id;
-}
-
-const entryOf = (row: { id: string; host: string; name: string | null; addedAt: string }): ServerEntry => ({
-  id: row.id,
-  host: row.host,
-  name: row.name,
-  addedAt: row.addedAt,
-});
-
-const columns = { id: servers.id, host: servers.host, name: servers.name, addedAt: servers.addedAt };
-
-export async function listServersForOwner(subject: string): Promise<ServerEntry[]> {
-  const owner = ownerOf(subject);
-  const rows = await getDb().select(columns).from(servers).where(eq(servers.owner, owner)).orderBy(asc(servers.addedAt));
-  return rows.map(entryOf);
-}
-
-export async function addServerForOwner(subject: string, body: unknown): Promise<ServerEntry> {
-  const owner = ownerOf(subject);
-  const host = parseServerHost(isRecord(body) && typeof body.host === 'string' ? body.host : '');
-  if (host === null) throw new ServerListError('host is not a server address', 400);
-  const name = parseServerName(isRecord(body) ? body.name : undefined);
-  const db = getDb();
-  const held = await db.select(columns).from(servers).where(and(eq(servers.owner, owner), eq(servers.host, host)));
-  const row = held[0];
-  if (row !== undefined) {
-    if (name === null) return entryOf(row);
-    await db.update(servers).set({ name }).where(eq(servers.id, row.id));
-    return entryOf({ ...row, name });
-  }
-  const next = { id: newId(), owner, host, name, addedAt: new Date().toISOString() };
-  await db.insert(servers).values(next);
-  return entryOf(next);
-}
-
-export async function renameServerForOwner(subject: string, rawId: string, body: unknown): Promise<ServerEntry> {
-  const owner = ownerOf(subject);
-  const id = idOf(rawId);
-  const name = parseServerName(isRecord(body) ? body.name : undefined);
-  const rows = await getDb()
-    .update(servers)
-    .set({ name })
-    .where(and(eq(servers.id, id), eq(servers.owner, owner)))
-    .returning(columns);
-  const row = rows[0];
-  if (row === undefined) throw missing();
-  return entryOf(row);
-}
-
-export async function deleteServerForOwner(subject: string, rawId: string): Promise<{ id: string; host: string }> {
-  const owner = ownerOf(subject);
-  const id = idOf(rawId);
-  const gone = await getDb()
-    .delete(servers)
-    .where(and(eq(servers.id, id), eq(servers.owner, owner)))
-    .returning({ id: servers.id, host: servers.host });
-  const row = gone[0];
-  if (row === undefined) throw missing();
-  return row;
-}

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

@@ -1,109 +0,0 @@
-import { and, asc, eq } from 'drizzle-orm';
-import { ApiError } from '../daemon/api-error.js';
-import { isRecord } from '../daemon/is-record.js';
-import { getDb } from './client.js';
-import { AGENT_NAME_RE, parseId } from './ids.js';
-import { vaults } from './schema.js';
-import { STATIONS } from './stations.js';
-import { normalizeAddress } from './address.js';
-
-export class VaultError extends ApiError {}
-
-import { ENVELOPE_MAX, type VaultBundle, type VaultEntry } from '../daemon/vault-types.js';
-
-export interface VaultInput {
-  name: string;
-  stations: string[];
-  envelope: Record<string, unknown>;
-}
-const STATION_NAMES = new Set<string>(STATIONS);
-
-const missing = (): VaultError => new VaultError('no such bundle', 404);
-
-function ownerOf(subject: string): string {
-  const address = normalizeAddress(subject);
-  if (address === null) throw new VaultError('the vault needs a vault identity', 403);
-  return address;
-}
-
-function stationsOf(raw: unknown): string[] {
-  if (!Array.isArray(raw)) throw new VaultError('stations must be a list of station names', 400);
-  const list = raw.map((s: unknown) => (typeof s === 'string' ? s : ''));
-  const bad = list.find((s) => !STATION_NAMES.has(s));
-  if (bad !== undefined) throw new VaultError(`'${bad}' is not a station`, 400);
-  return [...new Set(list)];
-}
-
-function envelopeOf(raw: unknown, id: string): Record<string, unknown> {
-  if (!isRecord(raw) || raw.v !== 1 || raw.agentId !== id)
-    throw new VaultError('envelope must be a v1 envelope for this agent', 400);
-  const key = raw.key;
-  if (!isRecord(key) || normalizeAddress(typeof key.recipient === 'string' ? key.recipient : '') === null)
-    throw new VaultError('envelope must name the wallet it was sealed to', 400);
-  if (typeof raw.ciphertext !== 'string' || typeof raw.nonce !== 'string')
-    throw new VaultError('envelope carries no ciphertext', 400);
-  if (JSON.stringify(raw).length > ENVELOPE_MAX)
-    throw new VaultError(`envelope is over ${String(ENVELOPE_MAX)} bytes`, 413);
-  return raw;
-}
-
-export function parseVaultInput(subject: string, id: string, body: unknown): VaultInput & { owner: string } {
-  const owner = ownerOf(subject);
-  if (parseId(id) === null) throw missing();
-  if (!isRecord(body)) throw new VaultError('body must be an object', 400);
-  const name = typeof body.name === 'string' ? body.name.trim() : '';
-  if (!AGENT_NAME_RE.test(name)) throw new VaultError('name is not an agent name', 400);
-  return { owner, name, stations: stationsOf(body.stations), envelope: envelopeOf(body.envelope, id) };
-}
-
-const entryOf = (row: { id: string; name: string; stations: unknown; syncedAt: string }): VaultEntry => ({
-  id: row.id,
-  name: row.name,
-  stations: Array.isArray(row.stations) ? row.stations.filter((s): s is string => typeof s === 'string') : [],
-  syncedAt: row.syncedAt,
-});
-
-export async function listVaultForOwner(subject: string): Promise<VaultEntry[]> {
-  const owner = ownerOf(subject);
-  const rows = await getDb()
-    .select({ id: vaults.id, name: vaults.name, stations: vaults.stations, syncedAt: vaults.syncedAt })
-    .from(vaults)
-    .where(eq(vaults.owner, owner))
-    .orderBy(asc(vaults.name));
-  return rows.map(entryOf);
-}
-
-export async function putVaultForOwner(subject: string, id: string, body: unknown): Promise<VaultEntry> {
-  const input = parseVaultInput(subject, id, body);
-  const syncedAt = new Date().toISOString();
-  const values = { id, owner: input.owner, name: input.name, stations: input.stations, envelope: input.envelope, syncedAt };
-  const db = getDb();
-  const held = await db.select({ owner: vaults.owner }).from(vaults).where(eq(vaults.id, id));
-  if (held[0] !== undefined && held[0].owner !== input.owner) throw missing();
-  await db
-    .insert(vaults)
-    .values(values)
-    .onConflictDoUpdate({ target: vaults.id, set: { name: input.name, stations: input.stations, envelope: input.envelope, syncedAt } });
-  return entryOf(values);
-}
-
-export async function getVaultForOwner(subject: string, id: string): Promise<VaultBundle> {
-  const owner = ownerOf(subject);
-  if (parseId(id) === null) throw missing();
-  const rows = await getDb().select().from(vaults).where(and(eq(vaults.id, id), eq(vaults.owner, owner)));
-  const row = rows[0];
-  if (row === undefined) throw missing();
-  return { ...entryOf(row), envelope: isRecord(row.envelope) ? row.envelope : {} };
-}
-
-export async function deleteVaultForOwner(subject: string, id: string): Promise<{ id: string; name: string }> {
-  const owner = ownerOf(subject);
-  if (parseId(id) === null) throw missing();
-  const gone = await getDb()
-    .delete(vaults)
-    .where(and(eq(vaults.id, id), eq(vaults.owner, owner)))
-    .returning({ id: vaults.id, name: vaults.name });
-  const row = gone[0];
-  if (row === undefined) throw missing();
-  return row;
-}

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

@@ -1,2 +0,0 @@
-#!/usr/bin/env bun
-import './daemon/boot.js';