@stage-labs/metro 0.1.0-beta.48 → 0.1.0-beta.49

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.48",
+  "version": "0.1.0-beta.49",
   "description": "The metro command line. Sign in once per machine, then hand your MCP connector list to Claude Code without the credentials touching disk, argv or shell history.",
   "license": "MIT",
   "repository": {

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

@@ -11,7 +11,6 @@ import {
 import { extractToken } from '../mcp/request-identity.js';
 
 const BODY_MAX = 4 * 1024;
-const DRAIN_MAX = 2 * BODY_MAX;
 
 export interface ApiSession {
   subject: string;
@@ -111,16 +110,16 @@ export function projectParam(req: IncomingMessage): string | null {
   return raw === null || raw === '' ? null : raw;
 }
 
-export async function readJsonBody(req: IncomingMessage): Promise<unknown> {
+export async function readJsonBody(req: IncomingMessage, max = BODY_MAX): Promise<unknown> {
   const chunks: Buffer[] = [];
   let total = 0;
   let over = false;
   for await (const c of req) {
     const buf = c as Buffer;
     total += buf.length;
-    if (total > BODY_MAX) over = true;
+    if (total > max) over = true;
     if (!over) chunks.push(buf);
-    else if (total > DRAIN_MAX) break;
+    else if (total > 2 * max) break;
   }
   if (over) throw new ApiError('request body too large', 413);
   const raw = Buffer.concat(chunks).toString('utf8').trim();

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

@@ -103,6 +103,7 @@ import { AttachSessions } from './attach-session.js';
 import { startUploadReaper } from './upload-store.js';
 import type { AgentApiDeps } from './agent-api.js';
 import type { ConnectorApiDeps } from './connector-api.js';
+import { deleteVaultForOwner, getVaultForOwner, listVaultForOwner, putVaultForOwner } from '../db/vault.js';
 
 installCrashGuard();
 acquireLock(join(STATE_DIR, '.tail-lock'));
@@ -300,6 +301,7 @@ function sessionApis(): SessionApis {
     projectApi,
     runApi,
     relayApi: { target: relayTarget, fence: fenceRuntime },
+    vaultApi: { list: listVaultForOwner, put: putVaultForOwner, get: getVaultForOwner, remove: deleteVaultForOwner },
     mode: hostedMode,
   };
 }

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

@@ -0,0 +1,112 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { errMsg, log } from './log.js';
+import { apiFailure, apiSession, cors, readJsonBody, sendJson } from './api-http.js';
+import { ApiError } from './api-error.js';
+import { isRecord } from './is-record.js';
+import { parseId } from '../db/ids.js';
+import type { LoadedAccount, LoadedAgent, LoadedConnector } from '../db/materialize.js';
+import { STATIONS } from '../db/schema.js';
+
+const AGENTS = '/api/agents';
+const RESTORE_PATH = `${AGENTS}/restore`;
+const BUNDLE_MAX = 2 * 1024 * 1024;
+const STATION_NAMES = new Set<string>(STATIONS);
+
+export interface AgentBundle {
+  version: 1;
+  agent: { id: string; name: string; key: string; stations: LoadedAccount[] };
+  connectors: LoadedConnector[];
+}
+
+export const loadedAgentOf = (bundle: AgentBundle): LoadedAgent => ({
+  id: bundle.agent.id,
+  name: bundle.agent.name,
+  key: bundle.agent.key,
+  accounts: bundle.agent.stations,
+  connectors: [],
+});
+
+export interface RestoredAgent {
+  id: string;
+  name: string;
+  stations: number;
+  connectors: number;
+}
+
+export interface BundleApiDeps {
+  bundle: (subject: string, agentId: string) => Promise<AgentBundle>;
+  restore: (subject: string, bundle: AgentBundle) => Promise<RestoredAgent>;
+}
+
+const bad = (what: string): ApiError => new ApiError(`bundle: ${what}`, 400);
+
+function stationOf(raw: unknown): LoadedAccount {
+  if (!isRecord(raw) || typeof raw.station !== 'string' || !STATION_NAMES.has(raw.station))
+    throw bad('a station is not a known station');
+  if (typeof raw.id !== 'string' || !isRecord(raw.config)) throw bad('a station has no id or config');
+  const allowlist = Array.isArray(raw.allowlist)
+    ? raw.allowlist.filter((s): s is string => typeof s === 'string')
+    : null;
+  return { station: raw.station as LoadedAccount['station'], id: raw.id, allowlist, config: raw.config };
+}
+
+function connectorOf(raw: unknown): LoadedConnector {
+  if (!isRecord(raw) || typeof raw.id !== 'string' || typeof raw.name !== 'string' || typeof raw.url !== 'string')
+    throw bad('a connector is missing its id, name or url');
+  if (!isRecord(raw.config)) throw bad('a connector has no config');
+  return { id: raw.id, name: raw.name, url: raw.url, transport: 'http', config: raw.config };
+}
+
+function agentOf(raw: unknown): AgentBundle['agent'] {
+  if (!isRecord(raw)) throw bad('not a v1 agent bundle');
+  const { id, name, key, stations } = raw;
+  if (typeof id !== 'string' || parseId(id) === null) throw bad('agent id is not an id');
+  if (typeof name !== 'string' || typeof key !== 'string' || key === '') throw bad('agent has no name or key');
+  if (!Array.isArray(stations)) throw bad('agent has no station list');
+  return { id, name, key, stations: stations.map(stationOf) };
+}
+
+export function parseBundle(raw: unknown): AgentBundle {
+  if (!isRecord(raw) || raw.version !== 1) throw bad('not a v1 agent bundle');
+  const connectors = Array.isArray(raw.connectors) ? raw.connectors : [];
+  return { version: 1, agent: agentOf(raw.agent), connectors: connectors.map(connectorOf) };
+}
+
+async function answer(req: IncomingMessage, deps: BundleApiDeps, subject: string, path: string): Promise<unknown> {
+  if (path === RESTORE_PATH) return deps.restore(subject, parseBundle(await readJsonBody(req, BUNDLE_MAX)));
+  const id = parseId(path.slice(AGENTS.length + 1).split('/')[0] ?? '');
+  if (id === null) throw new ApiError('no such agent', 404);
+  return deps.bundle(subject, id);
+}
+
+export function handleBundleRequest(req: IncomingMessage, res: ServerResponse, deps: BundleApiDeps): boolean {
+  const path = (req.url ?? '').split('?')[0] ?? '';
+  const isRestore = path === RESTORE_PATH;
+  const isBundle = /^\/api\/agents\/[^/]+\/bundle$/.test(path);
+  if (!isRestore && !isBundle) return false;
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204, cors(req)).end();
+    return true;
+  }
+  if (req.method !== (isRestore ? 'POST' : 'GET')) {
+    sendJson(req, res, 405, { error: 'method not allowed' });
+    return true;
+  }
+  const session = apiSession(req);
+  if (!session) {
+    sendJson(req, res, 401, { error: 'unauthorized' });
+    return true;
+  }
+  answer(req, deps, session.subject, path)
+    .then((body) => {
+      sendJson(req, res, isRestore ? 201 : 200, body);
+    })
+    .catch((err: unknown) => {
+      if (err instanceof ApiError) apiFailure(req, res, err, 'bundle-api');
+      else {
+        log.warn({ err: errMsg(err) }, 'bundle-api: request failed');
+        if (!res.headersSent) sendJson(req, res, 500, { error: 'bundle api failed' });
+      }
+    });
+  return true;
+}

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

@@ -8,12 +8,14 @@ import type { AgentConnectorApiDeps } from './agent-connector-api.js';
 import type { SessionApis } from './session-apis.js';
 import type { ModeInfo } from './mode-api.js';
 import type { ImportApiDeps } from './import-api.js';
+import { loadedAgentOf, type AgentBundle, type BundleApiDeps } from './bundle-api.js';
 import { fetchAgentWithCode } from './agent-import.js';
 import type { ConnectorApiDeps } from './connector-api.js';
 import { allowLocalConnectors } from './connector-url.js';
 import { keyIdentity, type LocalCliDeps } from './local-cli-api.js';
 import type { RelayApiDeps } from './relay.js';
 import {
+  readLocalConnectors,
   localImportConnectors,
   localAddConnector,
   localAgentConnectors,
@@ -33,7 +35,6 @@ import {
 } from '../db/local-connectors.js';
 import {
   assertLocalOwner,
-  ownerSignIn,
   connectorIdsOfLocalAgent,
   LOCAL_PROJECT_ID,
   localAttachAccount,
@@ -45,6 +46,8 @@ import {
   localOwnedAgentOrThrow,
   localOwner,
   localResetAgentKey,
+  ownerSignIn,
+  readLocalAgentFile,
 } from '../db/file-admin.js';
 import { listAgentFiles, readAgentFile } from '../db/file-source.js';
 import type { StationName } from '../db/schema.js';
@@ -158,6 +161,35 @@ const localCli: LocalCliDeps = {
   connectorSummaries: (agentId) => localConnectorSummariesByIds(connectorIdsOfLocalAgent(agentId) ?? []),
 };
 
+function bundleApi(deps: LocalModeDeps): BundleApiDeps {
+  return {
+    bundle: async (subject, agentId) => {
+      const { agent } = await localOwnedAgentOrThrow(subject, agentId);
+      const file = readLocalAgentFile(agentId);
+      const held = new Set(file.connectors);
+      const bundle: AgentBundle = {
+        version: 1,
+        agent: { id: file.id, name: file.name, key: file.key ?? '', stations: file.stations },
+        connectors: readLocalConnectors()
+          .filter((c) => held.has(c.id))
+          .map((c) => ({ id: c.id, name: c.name, url: c.url, transport: c.transport, config: { ...c.config } })),
+      };
+      if (bundle.agent.key === '') throw new ApiError(`agent '${agent.name}' has no key to bundle`, 400);
+      return bundle;
+    },
+    restore: async (subject, bundle) => {
+      assertLocalOwner(subject);
+      const made = await localImportAgent(subject, loadedAgentOf(bundle));
+      const connectors = localImportConnectors(bundle.connectors);
+      for (const station of new Set(bundle.agent.stations.map((a) => a.station)))
+        await deps.syncStations(station).catch((err: unknown) => {
+          log.warn({ station, err: errMsg(err) }, 'restore: station reload failed, the change lands at the next boot');
+        });
+      return { id: made.id, name: made.name, stations: made.stations, connectors };
+    },
+  };
+}
+
 function importApi(deps: LocalModeDeps): ImportApiDeps {
   const fetchAgent = deps.fetchAgent ?? fetchAgentWithCode;
   return {
@@ -188,6 +220,7 @@ export function localSessionApis(deps: LocalModeDeps): SessionApis {
     agentApi: agentApi(deps),
     agentConnectorApi,
     importApi: importApi(deps),
+    bundleApi: bundleApi(deps),
     connectorApi,
     relayApi,
     localCli,

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

@@ -21,11 +21,15 @@ import { handleImportRequest, type ImportApiDeps } from './import-api.js';
 import { handleLocalCliRequest, type LocalCliDeps } from './local-cli-api.js';
 import { handleClaudeRequest, type ClaudeApiDeps } from './claude-api.js';
 import type { ModeInfo } from './mode-api.js';
+import { handleVaultApiRequest, type VaultApiDeps } from './vault-api.js';
+import { handleBundleRequest, type BundleApiDeps } from './bundle-api.js';
 
 export interface SessionApis {
   agentApi?: AgentApiDeps;
   agentConnectorApi?: AgentConnectorApiDeps;
   importApi?: ImportApiDeps;
+  bundleApi?: BundleApiDeps;
+  vaultApi?: VaultApiDeps;
   localCli?: LocalCliDeps;
   claudeApi?: ClaudeApiDeps;
   connectorApi?: ConnectorApiDeps;
@@ -36,27 +40,27 @@ export interface SessionApis {
   mode?: () => ModeInfo;
 }
 
+const when = <T>(dep: T | undefined, run: (dep: T) => boolean): (() => boolean)[] =>
+  dep === undefined ? [] : [() => run(dep)];
+
 export function handleSessionApis(
   req: IncomingMessage,
   res: ServerResponse,
   apis: SessionApis,
 ): boolean {
-  const { agentApi, agentConnectorApi, connectorApi, projectApi, runApi, importApi } = apis;
-  const { localCli, claudeApi } = apis;
-  const routes: (() => boolean)[] = [() => handleSessionApiRequest(req, res)];
-  if (localCli) routes.push(() => handleLocalCliRequest(req, res, localCli));
-  if (runApi) routes.push(() => handleRunApiRequest(req, res, runApi));
-  if (projectApi)
-    routes.push(() => handleProjectApiRequest(req, res, projectApi));
-  if (connectorApi)
-    routes.push(
-      () => handleCliPairRequest(req, res, connectorApi),
-      () => handleConnectorApiRequest(req, res, connectorApi),
-    );
-  if (importApi) routes.push(() => handleImportRequest(req, res, importApi));
-  if (claudeApi) routes.push(() => handleClaudeRequest(req, res, claudeApi));
-  if (agentConnectorApi)
-    routes.push(() => handleAgentConnectorRequest(req, res, agentConnectorApi));
-  if (agentApi) routes.push(() => handleAgentApiRequest(req, res, agentApi));
+  const routes: (() => boolean)[] = [
+    () => handleSessionApiRequest(req, res),
+    ...when(apis.localCli, (d) => handleLocalCliRequest(req, res, d)),
+    ...when(apis.runApi, (d) => handleRunApiRequest(req, res, d)),
+    ...when(apis.projectApi, (d) => handleProjectApiRequest(req, res, d)),
+    ...when(apis.connectorApi, (d) => handleCliPairRequest(req, res, d)),
+    ...when(apis.connectorApi, (d) => handleConnectorApiRequest(req, res, d)),
+    ...when(apis.importApi, (d) => handleImportRequest(req, res, d)),
+    ...when(apis.bundleApi, (d) => handleBundleRequest(req, res, d)),
+    ...when(apis.vaultApi, (d) => handleVaultApiRequest(req, res, d)),
+    ...when(apis.claudeApi, (d) => handleClaudeRequest(req, res, d)),
+    ...when(apis.agentConnectorApi, (d) => handleAgentConnectorRequest(req, res, d)),
+    ...when(apis.agentApi, (d) => handleAgentApiRequest(req, res, d)),
+  ];
   return routes.some((run) => run());
 }

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

@@ -0,0 +1,78 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { errMsg, log } from './log.js';
+import { apiFailure, apiSession, cors, readJsonBody, sendJson, type ApiSession } from './api-http.js';
+import { parseId } from '../db/ids.js';
+import { ENVELOPE_MAX, type VaultBundle, type VaultEntry } from '../db/vault.js';
+
+const PREFIX = '/api/vault';
+const BODY_MAX = ENVELOPE_MAX + 64 * 1024;
+
+export interface VaultApiDeps {
+  list: (subject: string) => Promise<VaultEntry[]>;
+  put: (subject: string, id: string, body: unknown) => Promise<VaultEntry>;
+  get: (subject: string, id: string) => Promise<VaultBundle>;
+  remove: (subject: string, id: string) => Promise<{ id: string; name: string }>;
+}
+
+type Target = { kind: 'index' } | { kind: 'bundle'; id: string } | { kind: 'unknown' } | null;
+
+function target(path: string): Target {
+  if (path === PREFIX || path === `${PREFIX}/`) return { kind: 'index' };
+  if (!path.startsWith(`${PREFIX}/`)) return null;
+  const segments = path.slice(PREFIX.length + 1).split('/').filter(Boolean);
+  const id = parseId(segments[0] ?? '');
+  return id === null || segments.length !== 1 ? { kind: 'unknown' } : { kind: 'bundle', id };
+}
+
+const ALLOWED: Record<'index' | 'bundle', string[]> = { index: ['GET'], bundle: ['GET', 'PUT', 'DELETE'] };
+
+async function route(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: VaultApiDeps,
+  session: ApiSession,
+  tgt: { kind: 'index' } | { kind: 'bundle'; id: string },
+): Promise<void> {
+  try {
+    if (tgt.kind === 'index') {
+      sendJson(req, res, 200, { entries: await deps.list(session.subject) });
+      return;
+    }
+    if (req.method === 'GET') sendJson(req, res, 200, await deps.get(session.subject, tgt.id));
+    else if (req.method === 'DELETE') sendJson(req, res, 200, await deps.remove(session.subject, tgt.id));
+    else {
+      const saved = await deps.put(session.subject, tgt.id, await readJsonBody(req, BODY_MAX));
+      log.info({ id: saved.id, name: saved.name }, 'vault-api: bundle stored');
+      sendJson(req, res, 200, saved);
+    }
+  } catch (err) {
+    apiFailure(req, res, err, 'vault-api');
+  }
+}
+
+export function handleVaultApiRequest(req: IncomingMessage, res: ServerResponse, deps: VaultApiDeps): boolean {
+  const tgt = target((req.url ?? '').split('?')[0] ?? '');
+  if (tgt === null) return false;
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204, cors(req)).end();
+    return true;
+  }
+  if (tgt.kind === 'unknown') {
+    sendJson(req, res, 404, { error: 'no such bundle' });
+    return true;
+  }
+  if (!ALLOWED[tgt.kind].includes(req.method ?? '')) {
+    sendJson(req, res, 405, { error: 'method not allowed' });
+    return true;
+  }
+  const session = apiSession(req);
+  if (!session) {
+    sendJson(req, res, 401, { error: 'unauthorized' });
+    return true;
+  }
+  route(req, res, deps, session, tgt).catch((err: unknown) => {
+    log.warn({ err: errMsg(err) }, 'vault-api: unhandled error');
+    if (!res.headersSent) sendJson(req, res, 500, { error: 'vault api failed' });
+  });
+  return true;
+}

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

@@ -271,6 +271,12 @@ function fileFor(
   }
 }
 
+export function readLocalAgentFile(agentId: string, dir = agentsDir()): AgentFile {
+  const found = storedAgents(dir).find((s) => s.file.id === agentId);
+  if (found === undefined) throw missing();
+  return found.file;
+}
+
 export function connectorIdsOfLocalAgent(agentId: string, dir = agentsDir()): string[] | null {
   const found = storedAgents(dir).find((s) => s.file.id === agentId);
   return found === undefined ? null : found.file.connectors;

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

@@ -71,7 +71,7 @@ const isRow = (v: unknown): v is { id: string; name: string; url: string; config
 const asList = (value: unknown): unknown[] =>
   Array.isArray(value) ? value.map((item: unknown) => item) : [];
 
-function readLocalConnectors(dir = agentsDir()): LocalConnectorRow[] {
+export function readLocalConnectors(dir = agentsDir()): LocalConnectorRow[] {
   const raw = readJson<{ connectors?: unknown }>(filePath(dir), {}, {
     warn: 'connectors.json: malformed, ignoring',
   });

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

@@ -1,10 +1,4 @@
-import {
-  boolean,
-  jsonb,
-  pgTable,
-  text,
-  unique,
-} from 'drizzle-orm/pg-core';
+import { boolean, index, jsonb, pgTable, text, unique } from 'drizzle-orm/pg-core';
 
 export const STATIONS = [
   'xmtp',
@@ -114,3 +108,16 @@ export const agentConnectors = pgTable(
     ),
   ],
 );
+
+export const vault = pgTable(
+  'vault',
+  {
+    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('vault_owner_idx').on(t.owner)],
+);

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

@@ -0,0 +1,119 @@
+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 { STATIONS, vault } from './schema.js';
+import { normalizeAddress } from './users.js';
+
+export class VaultError extends ApiError {}
+
+export interface VaultEntry {
+  id: string;
+  name: string;
+  stations: string[];
+  syncedAt: string;
+}
+
+export interface VaultBundle extends VaultEntry {
+  envelope: Record<string, unknown>;
+}
+
+export interface VaultInput {
+  name: string;
+  stations: string[];
+  envelope: Record<string, unknown>;
+}
+
+export const ENVELOPE_MAX = 2 * 1024 * 1024;
+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 wallet sign-in', 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, owner: 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) || key.recipient !== owner)
+    throw new VaultError('envelope must be sealed to the signed-in wallet', 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, owner) };
+}
+
+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: vault.id, name: vault.name, stations: vault.stations, syncedAt: vault.syncedAt })
+    .from(vault)
+    .where(eq(vault.owner, owner))
+    .orderBy(asc(vault.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: vault.owner }).from(vault).where(eq(vault.id, id));
+  if (held[0] !== undefined && held[0].owner !== input.owner) throw missing();
+  await db
+    .insert(vault)
+    .values(values)
+    .onConflictDoUpdate({ target: vault.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(vault).where(and(eq(vault.id, id), eq(vault.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(vault)
+    .where(and(eq(vault.id, id), eq(vault.owner, owner)))
+    .returning({ id: vault.id, name: vault.name });
+  const row = gone[0];
+  if (row === undefined) throw missing();
+  return row;
+}

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.48"
+  "version": "0.1.0-beta.49"
 }