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

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

@@ -0,0 +1,124 @@
+import { parsePolicy } from '../policy/policy.js';
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { errMsg, log } from '@metro-labs/core/log';
+import { apiFailure, apiSession, cors, readJsonBody, requireAdmin, sendJson } from '@metro-labs/http/api-http';
+import { ApiError } from '@metro-labs/http/api-error';
+import { isRecord } from '@metro-labs/core/is-record';
+import { parseId } from '@metro-labs/core/ids';
+import type { LoadedAccount, LoadedAgent } from '../stations/materialize.js';
+import { STATIONS } from '@metro-labs/core/station-names';
+import { approversOf } from './files.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; stations: LoadedAccount[] };
+  connectors: [];
+}
+
+export const loadedAgentOf = (bundle: AgentBundle): LoadedAgent => ({
+  id: bundle.agent.id,
+  name: bundle.agent.name,
+  key: null,
+  accounts: bundle.agent.stations,
+});
+
+interface RestoredAgent {
+  id: string;
+  name: string;
+  stations: number;
+  connectors: number;
+}
+
+type ImportMode = 'append' | 'overwrite';
+
+export interface BundleApiDeps {
+  bundle: (agentId: string) => Promise<AgentBundle>;
+  restore: (bundle: AgentBundle, mode: ImportMode) => Promise<RestoredAgent>;
+}
+
+function parseMode(raw: unknown): ImportMode {
+  const mode = isRecord(raw) && typeof raw.mode === 'string' ? raw.mode : 'overwrite';
+  if (mode !== 'append' && mode !== 'overwrite') throw bad("mode is 'append' or 'overwrite'");
+  return mode;
+}
+
+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;
+  const policy = parsePolicy(raw.policy, `bundle ${raw.station}/${raw.id}`);
+  return {
+    station: raw.station as LoadedAccount['station'],
+    id: raw.id,
+    allowlist,
+    ...approversOf(raw.approvers),
+    enabled: raw.enabled !== false,
+    ...(policy === undefined ? {} : { policy }),
+    config: raw.config,
+  };
+}
+
+function agentOf(raw: unknown): AgentBundle['agent'] {
+  if (!isRecord(raw)) throw bad('not a v1 agent bundle');
+  const { id, name, stations } = raw;
+  if (typeof id !== 'string' || parseId(id) === null) throw bad('agent id is not an id');
+  if (!Array.isArray(stations)) throw bad('agent has no station list');
+  return { id, name: typeof name === 'string' ? name : '', stations: stations.map(stationOf) };
+}
+
+export function parseBundle(raw: unknown): AgentBundle {
+  if (!isRecord(raw) || raw.version !== 1) throw bad('not a v1 agent bundle');
+  return { version: 1, agent: agentOf(raw.agent), connectors: [] };
+}
+
+async function answer(req: IncomingMessage, deps: BundleApiDeps, path: string): Promise<unknown> {
+  if (path === RESTORE_PATH) {
+    const body: unknown = await readJsonBody(req, BUNDLE_MAX);
+    return deps.restore(parseBundle(body), parseMode(body));
+  }
+  const id = parseId(path.slice(AGENTS.length + 1).split('/')[0] ?? '');
+  if (id === null) throw new ApiError('no such agent', 404);
+  return deps.bundle(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;
+  }
+  apiSession(req)
+    .then((session) => {
+      if (!session) throw new ApiError('unauthorized', 401);
+      requireAdmin(session);
+      return answer(req, deps, 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/daemon/src/agents/file-admin.ts

@@ -0,0 +1,334 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { ApiError } from '@metro-labs/http/api-error';
+import { isOrganizationId } from '@metro-labs/http/workos-token';
+import { ensureSecureDir, writeSecure } from '@metro-labs/core/secure-fs';
+import {
+  newApiKey,
+  AgentAdminError,
+  normalizeAgentName,
+  type AgentSummary,
+  type CreatedAgent,
+} from './admin.js';
+import type { AccountRef } from './account-attach.js';
+import {
+  agentFilePath,
+  AgentFileError,
+  agentsDir,
+  listAgentFiles,
+  parseAgentFile,
+  readAgentFile,
+  type AgentFile,
+} from './files.js';
+import { newId } from '@metro-labs/core/ids';
+import { registerKey } from './keys.js';
+import { MOVABLE_STATIONS, type LoadedAgent } from '../stations/materialize.js';
+import type { StationName } from '@metro-labs/core/station-names';
+import type { ToolPolicy } from '../policy/policy.js';
+
+const OWNER_FILE = '.owner';
+
+interface Stored {
+  path: string;
+  file: AgentFile;
+}
+
+const missing = (): AgentAdminError => new AgentAdminError('no such agent', 404);
+
+function parseOwner(raw: string): string | null {
+  const text = raw.trim();
+  return isOrganizationId(text) ? text : null;
+}
+
+export function localOwner(dir = agentsDir()): string | null {
+  try {
+    return parseOwner(readFileSync(join(dir, OWNER_FILE), 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+export function setLocalOwner(raw: string, dir = agentsDir()): string {
+  const owner = parseOwner(raw);
+  if (owner === null) throw new ApiError(`'${raw}' is not an organization id`, 400);
+  ensureSecureDir(dir);
+  writeSecure(join(dir, OWNER_FILE), `${owner}\n`);
+  return owner;
+}
+
+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 agentOrThrow(id: string, dir: string): Stored {
+  const found = storedAgents(dir).find((s) => s.file.id === id);
+  if (found === undefined) throw missing();
+  return found;
+}
+
+export async function localListAgents(dir = agentsDir()): Promise<AgentSummary[]> {
+  return Promise.resolve(storedAgents(dir).map(({ file }) => ({ id: file.id, name: file.name })));
+}
+
+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(rawName?: string, dir = agentsDir()): Promise<CreatedAgent> {
+  const name = rawName === undefined ? null : normalizeAgentName(rawName);
+  const existing = storedAgents(dir);
+  if (existing.length > 0) throw new AgentAdminError('this box already has its agent', 409);
+  const id = freshId(new Set());
+  const key = newApiKey();
+  ensureSecureDir(dir);
+  save({
+    path: agentFilePath(dir),
+    file: { version: 1, id, name, key, stations: [] },
+  });
+  registerKey(key, id);
+  return Promise.resolve({ id, name, key });
+}
+
+export type Ensured = 'created' | 'present' | 'no-owner';
+
+export async function ensureLocalAgent(dir = agentsDir()): Promise<Ensured> {
+  if (storedAgents(dir).length > 0) return 'present';
+  if (localOwner(dir) === null) return 'no-owner';
+  await localCreateAgent(undefined, dir);
+  return 'created';
+}
+
+function assertUnclaimed(existing: Stored[], agent: LoadedAgent): void {
+  for (const { file } of existing) {
+    if (file.id === agent.id)
+      throw new AgentAdminError(`agent ${agent.id} is already on this machine`, 409);
+    if (agent.key !== null && file.key === agent.key)
+      throw new AgentAdminError('that agent key is already on this machine', 409);
+  }
+}
+
+function assertImportable(agent: LoadedAgent): void {
+  if (agent.accounts.some((a) => a.station === 'gmail' && a.config.managed === true)) throw new AgentAdminError('Managed Gmail cannot be imported. Connect the mailbox again on this box.', 400);
+  const immovable = agent.accounts.find((a) => !MOVABLE_STATIONS.has(a.station));
+  if (immovable !== undefined)
+    throw new AgentAdminError(
+      `a ${immovable.station} endpoint needs a public url and cannot live on a local daemon`,
+      400,
+    );
+}
+
+interface ImportTarget {
+  path: string;
+  previous: AgentFile | undefined;
+}
+
+function importTarget(dir: string, agent: LoadedAgent): ImportTarget {
+  const existing = storedAgents(dir);
+  const same = existing.find((s) => s.file.id === agent.id);
+  if (same === undefined && existing.length > 0)
+    throw new AgentAdminError('this box already has its agent; import into it rather than bringing another', 409);
+  assertUnclaimed(existing.filter((s) => s !== same), agent);
+  return { path: same?.path ?? agentFilePath(dir), previous: same?.file };
+}
+
+export type ImportMode = 'append' | 'overwrite';
+
+export async function localImportAgent(
+  agent: LoadedAgent,
+  dir = agentsDir(),
+  mode: ImportMode = 'overwrite',
+): Promise<{ id: string; name: string; key: string; stations: number }> {
+  assertImportable(agent);
+  const { path, previous } = importTarget(dir, agent);
+  const key = previous?.key ?? agent.key ?? newApiKey();
+  const file = fileFor({ ...agent, key }, path, previous, mode);
+  ensureSecureDir(join(path, '..'));
+  save({ path, file });
+  registerKey(key, agent.id);
+  return Promise.resolve({
+    id: agent.id,
+    name: agent.name,
+    key,
+    stations: file.stations.length,
+  });
+}
+
+function mergedStations(
+  agent: LoadedAgent,
+  previous: AgentFile | undefined,
+  mode: ImportMode,
+): AgentFile['stations'] {
+  const before = previous?.stations ?? [];
+  const here = (station: string, id: string): boolean => before.some((s) => s.station === station && s.id === id);
+  const fromMetro = agent.accounts
+    .map((a) => ({ ...a, allowlist: a.allowlist ?? ['*'] }))
+    .filter((m) => mode === 'overwrite' || !here(m.station, m.id));
+  if (fromMetro.some((m) => m.station === 'gmail' && before.some((s) => s.station === 'gmail' && s.id === m.id && s.config.managed === true))) throw new AgentAdminError('Managed Gmail cannot be overwritten by an import. Delete the connection first.', 400);
+  const kept = before.filter((s) => !fromMetro.some((m) => m.station === s.station && m.id === s.id));
+  return [...fromMetro, ...kept];
+}
+
+function fileFor(
+  agent: LoadedAgent,
+  path: string,
+  previous: AgentFile | undefined,
+  mode: ImportMode,
+): AgentFile {
+  try {
+    return parseAgentFile(
+      JSON.stringify({
+        version: 1,
+        id: agent.id,
+        name: previous?.name ?? null,
+        key: agent.key,
+        stations: mergedStations(agent, previous, mode),
+      }),
+      path,
+    );
+  } catch (err) {
+    if (err instanceof AgentFileError)
+      throw new AgentAdminError(`metro's copy of this agent cannot be written here: ${err.message}`, 400);
+    throw err;
+  }
+}
+
+export function localRenewGmail(agentId: string, accountId: string, previous: string, config: Record<string, unknown>, dir = agentsDir()): AccountRef {
+  const stored = agentOrThrow(agentId, dir);
+  const account = stored.file.stations.find((s) => s.station === 'gmail' && s.id === accountId);
+  if (account === undefined || (account.config.authorizationId ?? account.config.refreshToken) !== previous) throw new AgentAdminError('This Gmail connection changed. Start again.', 409);
+  if (account.config.accountEmail !== config.accountEmail) throw new AgentAdminError('The Gmail mailbox did not match. Nothing was changed.', 400);
+  account.config = { ...account.config, ...config };
+  save(stored);
+  return { agentId, station: 'gmail', accountId };
+}
+
+const sameIdentity = (a: unknown, b: unknown): boolean =>
+  typeof a === 'string' && typeof b === 'string' && a.replace(/[\s()+-]/g, '').toLowerCase() === b.replace(/[\s()+-]/g, '').toLowerCase();
+
+const shownIdentity = (value: unknown): string => (typeof value === 'string' && value !== '' ? value : 'unknown');
+
+export function localPairAgain(agentId: string, station: StationName, accountId: string, identity: string, config: Record<string, unknown>, dir = agentsDir()): AccountRef {
+  const stored = agentOrThrow(agentId, dir);
+  const account = stored.file.stations.find((s) => s.station === station && s.id === accountId);
+  if (account === undefined) throw new AgentAdminError('This channel is gone. Nothing was changed.', 404);
+  const before = account.config[identity];
+  const after = config[identity];
+  if (!sameIdentity(before, after)) throw new AgentAdminError(`This channel is ${shownIdentity(before)}, not ${shownIdentity(after)}. Nothing was changed.`, 400);
+  account.config = { ...account.config, ...config };
+  save(stored);
+  return { agentId, station, accountId };
+}
+
+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;
+}
+
+const UNIQUE_CREDENTIALS: Record<string, string> = {
+  token: 'that bot token is already attached to an agent on this machine',
+  accountEmail: 'that mailbox is already connected to an agent on this machine',
+};
+
+function assertCredentialFree(all: Stored[], station: StationName, config: Record<string, unknown>): void {
+  for (const [key, refusal] of Object.entries(UNIQUE_CREDENTIALS)) {
+    const value = config[key];
+    if (typeof value !== 'string') continue;
+    const taken = all.some((s) => s.file.stations.some((a) => a.station === station && a.config[key] === value));
+    if (taken) throw new AgentAdminError(refusal, 409);
+  }
+}
+
+export async function localAttachAccount(
+  agentId: string,
+  station: StationName,
+  config: Record<string, unknown>,
+  dir = agentsDir(),
+): Promise<AccountRef> {
+  const stored = agentOrThrow(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,
+    );
+  assertCredentialFree(storedAgents(dir), station, config);
+  const taken = new Set(stored.file.stations.map((a) => a.id));
+  const accountId = freshId(taken);
+  stored.file.stations.push({ station, id: accountId, allowlist: ['*'], enabled: true, ...(station === 'gmail' && config.sendEnabled === false ? { policy: { write: 'deny' as const } } : {}), config });
+  save(stored);
+  return Promise.resolve({ agentId, station, accountId });
+}
+
+export async function localSetAllowlist(
+  agentId: string,
+  station: StationName,
+  accountId: string,
+  allowlist: string[],
+  approvers: string[] = [],
+  dir = agentsDir(),
+): Promise<string[]> {
+  const stored = agentOrThrow(agentId, dir);
+  const account = stored.file.stations.find((a) => a.station === station && a.id === accountId);
+  if (account === undefined) throw new AgentAdminError('no such account on this agent', 404);
+  account.allowlist = allowlist;
+  if (approvers.length === 0) delete account.approvers;
+  else account.approvers = approvers;
+  save(stored);
+  return Promise.resolve(allowlist);
+}
+
+export async function localSetPolicy(
+  agentId: string,
+  station: StationName,
+  accountId: string,
+  policy: ToolPolicy,
+  dir = agentsDir(),
+): Promise<ToolPolicy> {
+  const stored = agentOrThrow(agentId, dir);
+  const account = stored.file.stations.find((a) => a.station === station && a.id === accountId);
+  if (account === undefined) throw new AgentAdminError('no such account on this agent', 404);
+  if (policy.read === undefined && policy.write === undefined && policy.tools === undefined) delete account.policy;
+  else account.policy = policy;
+  save(stored);
+  return Promise.resolve(policy);
+}
+
+export async function localSetAccountEnabled(
+  agentId: string,
+  station: StationName,
+  accountId: string,
+  enabled: boolean,
+  dir = agentsDir(),
+): Promise<boolean> {
+  const stored = agentOrThrow(agentId, dir);
+  const account = stored.file.stations.find((a) => a.station === station && a.id === accountId);
+  if (account === undefined) throw new AgentAdminError('no such account on this agent', 404);
+  account.enabled = enabled;
+  save(stored);
+  return Promise.resolve(enabled);
+}
+
+export async function localDetachAccount(
+  agentId: string,
+  station: StationName,
+  accountId: string,
+  dir = agentsDir(),
+): Promise<AccountRef> {
+  const stored = agentOrThrow(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/file-source.ts → daemon/src/agents/files.ts}

@@ -1,14 +1,15 @@
-import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
-import { AGENT_NAME_RE, ID_RE } from './ids.js';
-import { STATIONS, type StationName } from './schema.js';
-import type { LoadedAccount, LoadedAgent, StationSource } from './materialize.js';
+import { AGENT_NAME_RE, ID_RE } from '@metro-labs/core/ids';
+import { STATIONS, type StationName } from '@metro-labs/core/station-names';
+import type { LoadedAccount, LoadedAgent, StationSource } from '../stations/materialize.js';
+import { isRecord } from '@metro-labs/core/is-record';
+import { parsePolicy } from '../policy/policy.js';
 
-export const AGENT_FILE = 'agent.json';
+const AGENT_FILE = 'agent.json';
 
-const KEY_RE = /^mk_[A-Za-z0-9_-]{43}$/;
-const ADDRESS_RE = /^0x[0-9a-f]{40}$/;
+const KEY_RE = /^[A-Za-z0-9_-]{16,128}$/;
 const STATION_NAMES = new Set<string>(STATIONS);
 
 export class AgentFileError extends Error {}
@@ -16,12 +17,13 @@ export class AgentFileError extends Error {}
 export interface AgentFile {
   version: 1;
   id: string;
-  name: string;
+  name: string | null;
   key: string | null;
-  owner: string | null;
   stations: LoadedAccount[];
 }
 
+export const agentFilePath = (dir = agentsDir()): string => join(dir, AGENT_FILE);
+
 export function agentsDir(): string {
   const explicit = process.env.METRO_AGENTS_DIR?.trim();
   return explicit !== undefined && explicit !== ''
@@ -29,9 +31,6 @@ export function agentsDir(): string {
     : join(homedir(), '.metro', 'agents');
 }
 
-const isRecord = (v: unknown): v is Record<string, unknown> =>
-  typeof v === 'object' && v !== null && !Array.isArray(v);
-
 function fail(path: string, reason: string): never {
   throw new AgentFileError(`${path}: ${reason}`);
 }
@@ -49,6 +48,12 @@ function allowlistOf(raw: unknown, path: string, where: string): string[] | null
   return list;
 }
 
+export function approversOf(raw: unknown): { approvers?: string[] } {
+  if (!Array.isArray(raw)) return {};
+  const list = raw.filter((entry): entry is string => typeof entry === 'string' && entry !== '*' && entry.trim() !== '');
+  return list.length === 0 ? {} : { approvers: list };
+}
+
 function stationOf(raw: unknown, path: string, index: number): LoadedAccount {
   const where = `stations[${String(index)}]`;
   if (!isRecord(raw)) fail(path, `${where} is not an object`);
@@ -57,7 +62,16 @@ function stationOf(raw: unknown, path: string, index: number): LoadedAccount {
   if (typeof id !== 'string' || !ID_RE.test(id))
     fail(path, `${where}.id is not an 11-character id`);
   if (!isRecord(config)) fail(path, `${where}.config is not an object`);
-  return { station, id, allowlist: allowlistOf(raw.allowlist, path, where), config };
+  const policy = parsePolicy(raw.policy, `${path} ${where}`);
+  return {
+    station,
+    id,
+    allowlist: allowlistOf(raw.allowlist, path, where),
+    ...approversOf(raw.approvers),
+    enabled: raw.enabled !== false,
+    ...(policy === undefined ? {} : { policy }),
+    config,
+  };
 }
 
 function optionalMatch(
@@ -71,6 +85,12 @@ function optionalMatch(
   return value;
 }
 
+function nameOf(raw: unknown, path: string): string | null {
+  if (raw === undefined || raw === null) return null;
+  if (typeof raw !== 'string' || !AGENT_NAME_RE.test(raw)) fail(path, 'name is not a valid agent name');
+  return raw;
+}
+
 export function parseAgentFile(raw: string, path: string): AgentFile {
   let parsed: unknown;
   try {
@@ -83,22 +103,14 @@ export function parseAgentFile(raw: string, path: string): AgentFile {
   const { id, name, stations } = parsed;
   if (typeof id !== 'string' || !ID_RE.test(id))
     fail(path, 'id is not an 11-character id');
-  if (typeof name !== 'string' || !AGENT_NAME_RE.test(name))
-    fail(path, 'name is not a valid agent name');
-  const key = optionalMatch(parsed.key, KEY_RE, path, 'key is not an mk_ key');
-  const owner = optionalMatch(
-    parsed.owner,
-    ADDRESS_RE,
-    path,
-    'owner is not a lowercase Ethereum address',
-  );
+  const label = nameOf(name, path);
+  const key = optionalMatch(parsed.key, KEY_RE, path, 'key is not an agent key');
   if (!Array.isArray(stations)) fail(path, 'stations is not a list');
   return {
     version: 1,
     id,
-    name,
+    name: label,
     key,
-    owner,
     stations: stations.map((s, i) => stationOf(s, path, i)),
   };
 }
@@ -114,36 +126,14 @@ export function readAgentFile(path: string): AgentFile {
 }
 
 export function listAgentFiles(dir = agentsDir()): string[] {
-  if (!existsSync(dir)) return [];
-  return readdirSync(dir, { withFileTypes: true })
-    .filter((entry) => entry.isDirectory())
-    .map((entry) => join(dir, entry.name, AGENT_FILE))
-    .filter((path) => existsSync(path))
-    .sort();
-}
-
-function assertUnique(agents: AgentFile[], paths: string[]): void {
-  const ids = new Map<string, string>();
-  const keys = new Map<string, string>();
-  agents.forEach((agent, i) => {
-    const path = paths[i] ?? '';
-    const sameId = ids.get(agent.id);
-    if (sameId !== undefined) fail(path, `id ${agent.id} is already used by ${sameId}`);
-    ids.set(agent.id, path);
-    if (agent.key === null) return;
-    const sameKey = keys.get(agent.key);
-    if (sameKey !== undefined) fail(path, `its key is already used by ${sameKey}`);
-    keys.set(agent.key, path);
-  });
+  const fixed = agentFilePath(dir);
+  return existsSync(fixed) ? [fixed] : [];
 }
 
 export function loadFileAgents(dir = agentsDir()): LoadedAgent[] {
-  const paths = listAgentFiles(dir);
-  const agents = paths.map(readAgentFile);
-  assertUnique(agents, paths);
-  return agents.map((agent) => ({
+  return listAgentFiles(dir).map(readAgentFile).map((agent) => ({
     id: agent.id,
-    name: agent.name,
+    name: agent.name ?? agent.id,
     key: agent.key,
     accounts: agent.stations,
   }));

package/runtime/node_modules/@metro-labs/{mcp/src/db/key-map.ts → daemon/src/agents/keys.ts}

@@ -1,5 +1,5 @@
 import { createHash } from 'node:crypto';
-import { ID_RE } from './ids.js';
+import { ID_RE } from '@metro-labs/core/ids';
 
 const digest = (token: string): string =>
   createHash('sha256').update(token).digest('hex');
@@ -25,16 +25,6 @@ export function registerKey(key: string, agentId: string): void {
   agentIdByKeyHash.set(digest(key), agentId);
 }
 
-export function unregisterAgentKey(agentId: string): void {
-  for (const [hash, id] of agentIdByKeyHash)
-    if (id === agentId) agentIdByKeyHash.delete(hash);
-}
-
-export function rotateAgentKey(agentId: string, key: string | null): void {
-  unregisterAgentKey(agentId);
-  if (key !== null) registerKey(key, agentId);
-}
-
 export function agentIdForKey(token: string): string | undefined {
   if (token === '') return undefined;
   return agentIdByKeyHash.get(digest(token));