@wolpertingerlabs/drawlatch 1.0.0-alpha.2 → 1.0.0-alpha.29

package/dist/shared/crypto/key-manager.js

@@ -0,0 +1,152 @@
+/**
+ * High-level key management API.
+ *
+ * Provides CRUD operations over the drawlatch key directory structure
+ * so that callboard (and other consumers) can manage keys programmatically
+ * without touching the filesystem directly.
+ *
+ * Key layout:
+ *   keys/callers/<alias>/  — Caller keypairs (one per alias)
+ *   keys/server/           — Server keypair (single, flat)
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { generateKeyBundle, saveKeyBundle, loadKeyBundle, loadPublicKeys, extractPublicKeys, serializePublicKeys, deserializePublicKeys, fingerprint, } from './keys.js';
+import { getCallerKeysDir, getServerKeysDir, getConfigDir } from '../config.js';
+function resolveConfigDir(opts) {
+    if (opts?.configDir)
+        return opts.configDir;
+    return getConfigDir();
+}
+function callerKeysDir(opts) {
+    if (opts?.configDir)
+        return path.join(opts.configDir, 'keys', 'callers');
+    return getCallerKeysDir();
+}
+function serverKeysDir(opts) {
+    if (opts?.configDir)
+        return path.join(opts.configDir, 'keys', 'server');
+    return getServerKeysDir();
+}
+/**
+ * Create a new caller identity (Ed25519 + X25519 keypairs).
+ * Saves under `keys/callers/<alias>/`.
+ * Throws if the alias already exists.
+ */
+export function createCaller(alias, opts) {
+    const dir = path.join(callerKeysDir(opts), alias);
+    if (fs.existsSync(path.join(dir, 'signing.key.pem'))) {
+        throw new Error(`Caller "${alias}" already exists at ${dir}`);
+    }
+    fs.mkdirSync(resolveConfigDir(opts), { recursive: true, mode: 0o700 });
+    const bundle = generateKeyBundle();
+    saveKeyBundle(bundle, dir);
+    const pub = extractPublicKeys(bundle);
+    return {
+        publicKeys: serializePublicKeys(pub),
+        fingerprint: fingerprint(pub),
+    };
+}
+/**
+ * Export public keys for a caller identity.
+ * Reads from `keys/callers/<alias>/`.
+ */
+export function exportCallerPublicKeys(alias, opts) {
+    const dir = path.join(callerKeysDir(opts), alias);
+    const pub = loadPublicKeys(dir);
+    return serializePublicKeys(pub);
+}
+/**
+ * Export public keys for the server.
+ * Reads from `keys/server/`.
+ */
+export function exportServerPublicKeys(opts) {
+    const dir = serverKeysDir(opts);
+    const pub = loadPublicKeys(dir);
+    return serializePublicKeys(pub);
+}
+/**
+ * Import a caller's public keys. Saves under `keys/callers/<alias>/`.
+ * Used by the server to store received caller public keys (e.g., via sync).
+ */
+export function importCallerPublicKeys(alias, keys, opts) {
+    const dir = path.join(callerKeysDir(opts), alias);
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    // Validate the keys are parseable before writing
+    deserializePublicKeys(keys);
+    fs.writeFileSync(path.join(dir, 'signing.pub.pem'), keys.signing, { mode: 0o644 });
+    fs.writeFileSync(path.join(dir, 'exchange.pub.pem'), keys.exchange, { mode: 0o644 });
+}
+/**
+ * Save server public keys. Writes to `keys/server/`.
+ * Used by callboard to store the remote server's public keys (e.g., via sync).
+ */
+export function saveServerPublicKeys(keys, opts) {
+    const dir = serverKeysDir(opts);
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    // Validate the keys are parseable before writing
+    deserializePublicKeys(keys);
+    fs.writeFileSync(path.join(dir, 'signing.pub.pem'), keys.signing, { mode: 0o644 });
+    fs.writeFileSync(path.join(dir, 'exchange.pub.pem'), keys.exchange, { mode: 0o644 });
+}
+/**
+ * List all caller aliases (scans `keys/callers/`).
+ */
+export function listCallers(opts) {
+    const dir = callerKeysDir(opts);
+    if (!fs.existsSync(dir))
+        return [];
+    return fs
+        .readdirSync(dir, { withFileTypes: true })
+        .filter((d) => d.isDirectory() &&
+        (fs.existsSync(path.join(dir, d.name, 'signing.key.pem')) ||
+            fs.existsSync(path.join(dir, d.name, 'signing.pub.pem'))))
+        .map((d) => d.name);
+}
+/**
+ * Check if a caller identity exists (has at least public keys).
+ */
+export function callerExists(alias, opts) {
+    const dir = path.join(callerKeysDir(opts), alias);
+    return (fs.existsSync(path.join(dir, 'signing.key.pem')) ||
+        fs.existsSync(path.join(dir, 'signing.pub.pem')));
+}
+/**
+ * Check if server keys exist.
+ */
+export function serverExists(opts) {
+    const dir = serverKeysDir(opts);
+    return (fs.existsSync(path.join(dir, 'signing.key.pem')) ||
+        fs.existsSync(path.join(dir, 'signing.pub.pem')));
+}
+/**
+ * Get the fingerprint of a caller's keys.
+ */
+export function callerFingerprint(alias, opts) {
+    const dir = path.join(callerKeysDir(opts), alias);
+    // Try full bundle first (has private keys), fall back to public-only
+    try {
+        const bundle = loadKeyBundle(dir);
+        return fingerprint(extractPublicKeys(bundle));
+    }
+    catch {
+        const pub = loadPublicKeys(dir);
+        return fingerprint(pub);
+    }
+}
+/**
+ * Get the fingerprint of the server's keys.
+ */
+export function serverFingerprint(opts) {
+    const dir = serverKeysDir(opts);
+    // Try full bundle first (has private keys), fall back to public-only
+    try {
+        const bundle = loadKeyBundle(dir);
+        return fingerprint(extractPublicKeys(bundle));
+    }
+    catch {
+        const pub = loadPublicKeys(dir);
+        return fingerprint(pub);
+    }
+}
+//# sourceMappingURL=key-manager.js.map

package/dist/shared/env-utils.d.ts

@@ -0,0 +1,42 @@
+/**
+ * .env file and secret-status utilities.
+ *
+ * Shared between the remote server (tool handlers) and callboard (local mode).
+ * All functions use getEnvFilePath() from shared/config for path resolution.
+ */
+import { type RemoteServerConfig } from './config.js';
+/** Convert caller alias to env var prefix: "default" → "DEFAULT", "my-agent" → "MY_AGENT" */
+export declare function callerToPrefix(callerAlias: string): string;
+/** Get prefixed env var name: ("default", "GITHUB_TOKEN") → "DEFAULT_GITHUB_TOKEN" */
+export declare function prefixedEnvVar(callerAlias: string, secretName: string): string;
+/** Load all vars from the .env file into a map (does NOT set process.env). */
+export declare function loadEnvFile(): Record<string, string>;
+/** Load .env file into process.env (for startup). */
+export declare function loadEnvIntoProcess(): void;
+/**
+ * Write key-value pairs to .env. Empty string = delete.
+ * Also sets process.env immediately for in-process use.
+ */
+export declare function setEnvVars(updates: Record<string, string>): void;
+/**
+ * Check if a secret is set for a caller.
+ * Resolution: caller env mapping → prefixed env var.
+ * Bare env var fallback intentionally removed to prevent cross-caller leakage.
+ */
+export declare function isSecretSetForCaller(secretName: string, callerAlias: string, callerEnv?: Record<string, string>): boolean;
+/**
+ * Regex for valid secret names: uppercase letters, digits, and underscores;
+ * must start with a letter. Prevents injection of system env vars
+ * (e.g., PATH, NODE_OPTIONS, LD_PRELOAD).
+ */
+export declare const SECRET_NAME_REGEX: RegExp;
+/**
+ * Set secrets for a caller with prefixed env vars.
+ * Updates .env file, process.env, and caller's env mapping in config.
+ * Returns boolean status per secret name.
+ */
+export declare function setCallerSecrets(secrets: Record<string, string>, callerAlias: string, config: RemoteServerConfig): {
+    config: RemoteServerConfig;
+    status: Record<string, boolean>;
+};
+//# sourceMappingURL=env-utils.d.ts.map

package/dist/shared/env-utils.js

@@ -0,0 +1,150 @@
+/**
+ * .env file and secret-status utilities.
+ *
+ * Shared between the remote server (tool handlers) and callboard (local mode).
+ * All functions use getEnvFilePath() from shared/config for path resolution.
+ */
+import fs from 'node:fs';
+import { getEnvFilePath } from './config.js';
+// ── Caller prefix helpers ────────────────────────────────────────────────────
+/** Convert caller alias to env var prefix: "default" → "DEFAULT", "my-agent" → "MY_AGENT" */
+export function callerToPrefix(callerAlias) {
+    return callerAlias.toUpperCase().replace(/-/g, '_');
+}
+/** Get prefixed env var name: ("default", "GITHUB_TOKEN") → "DEFAULT_GITHUB_TOKEN" */
+export function prefixedEnvVar(callerAlias, secretName) {
+    return `${callerToPrefix(callerAlias)}_${secretName}`;
+}
+// ── .env file I/O ────────────────────────────────────────────────────────────
+/** Load all vars from the .env file into a map (does NOT set process.env). */
+export function loadEnvFile() {
+    const envPath = getEnvFilePath();
+    if (!fs.existsSync(envPath))
+        return {};
+    const content = fs.readFileSync(envPath, 'utf-8');
+    const vars = {};
+    for (const line of content.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        const eqIdx = trimmed.indexOf('=');
+        if (eqIdx === -1)
+            continue;
+        const key = trimmed.slice(0, eqIdx).trim();
+        let value = trimmed.slice(eqIdx + 1).trim();
+        // Strip surrounding quotes (single or double)
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        vars[key] = value;
+    }
+    return vars;
+}
+/** Load .env file into process.env (for startup). */
+export function loadEnvIntoProcess() {
+    const vars = loadEnvFile();
+    for (const [key, value] of Object.entries(vars)) {
+        process.env[key] ??= value;
+    }
+}
+/**
+ * Write key-value pairs to .env. Empty string = delete.
+ * Also sets process.env immediately for in-process use.
+ */
+export function setEnvVars(updates) {
+    const envPath = getEnvFilePath();
+    let existing = loadEnvFile();
+    // Apply updates
+    for (const [key, value] of Object.entries(updates)) {
+        if (value === '') {
+            // Remove key by rebuilding without it
+            const { [key]: _removed, ...rest } = existing;
+            existing = rest;
+            process.env[key] = undefined;
+        }
+        else {
+            existing[key] = value;
+            process.env[key] = value;
+        }
+    }
+    // Serialize back to .env format
+    const lines = Object.entries(existing).map(([key, value]) => {
+        // Quote values that contain spaces, #, or special characters
+        if (/[\s#"'\\]/.test(value)) {
+            return `${key}="${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+        }
+        return `${key}=${value}`;
+    });
+    const dir = envPath.replace(/\/[^/]+$/, '');
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    fs.writeFileSync(envPath, lines.join('\n') + '\n', { mode: 0o600 });
+}
+// ── Secret status checks ─────────────────────────────────────────────────────
+/**
+ * Check if a secret is set for a caller.
+ * Resolution: caller env mapping → prefixed env var.
+ * Bare env var fallback intentionally removed to prevent cross-caller leakage.
+ */
+export function isSecretSetForCaller(secretName, callerAlias, callerEnv) {
+    // 1. Check caller's env mapping (e.g., "GITHUB_TOKEN": "${DEFAULT_GITHUB_TOKEN}")
+    if (callerEnv && secretName in callerEnv) {
+        const mapping = callerEnv[secretName];
+        const envMatch = /^\$\{(.+)\}$/.exec(mapping);
+        if (envMatch) {
+            // It's an env var reference — check if that var is set
+            const varName = envMatch[1];
+            return process.env[varName] !== undefined && process.env[varName] !== '';
+        }
+        // It's a literal value
+        return mapping !== '';
+    }
+    // 2. Check prefixed env var (e.g., DEFAULT_GITHUB_TOKEN)
+    const prefixed = prefixedEnvVar(callerAlias, secretName);
+    return process.env[prefixed] !== undefined && process.env[prefixed] !== '';
+}
+/**
+ * Regex for valid secret names: uppercase letters, digits, and underscores;
+ * must start with a letter. Prevents injection of system env vars
+ * (e.g., PATH, NODE_OPTIONS, LD_PRELOAD).
+ */
+export const SECRET_NAME_REGEX = /^[A-Z][A-Z0-9_]*$/;
+/**
+ * Set secrets for a caller with prefixed env vars.
+ * Updates .env file, process.env, and caller's env mapping in config.
+ * Returns boolean status per secret name.
+ */
+export function setCallerSecrets(secrets, callerAlias, config) {
+    const caller = config.callers[callerAlias];
+    if (!caller) {
+        throw new Error(`Unknown caller: ${callerAlias}`);
+    }
+    const envUpdates = {};
+    const status = {};
+    // Ensure caller has an env mapping
+    caller.env ??= {};
+    for (const [secretName, value] of Object.entries(secrets)) {
+        if (!SECRET_NAME_REGEX.test(secretName)) {
+            throw new Error(`Invalid secret name "${secretName}": must match ${SECRET_NAME_REGEX} ` +
+                `(uppercase letters, digits, underscores; must start with a letter)`);
+        }
+        const prefixed = prefixedEnvVar(callerAlias, secretName);
+        if (value === '') {
+            // Delete: remove from .env and caller env mapping
+            envUpdates[prefixed] = '';
+            const { [secretName]: _removed, ...rest } = caller.env;
+            caller.env = rest;
+            status[secretName] = false;
+        }
+        else {
+            // Set: write prefixed env var and update caller env mapping
+            envUpdates[prefixed] = value;
+            caller.env[secretName] = `\${${prefixed}}`;
+            status[secretName] = true;
+        }
+    }
+    // Write to .env file and set process.env
+    setEnvVars(envUpdates);
+    return { config, status };
+}
+//# sourceMappingURL=env-utils.js.map

package/dist/shared/listener-config.d.ts

@@ -0,0 +1,157 @@
+/**
+ * Shared types for connection testing, ingestor testing, and listener
+ * configuration schemas.
+ *
+ * These types are used in connection templates (JSON), the Route interface,
+ * ResolvedRoute, and the tool handlers that expose testing and configuration
+ * functionality to MCP clients.
+ */
+/**
+ * Pre-configured test request for verifying connection credentials.
+ * Must be a non-destructive, read-only endpoint with zero side effects.
+ * Stored in connection templates and carried through to ResolvedRoute.
+ */
+export interface TestConnectionConfig {
+    /** HTTP method (default: 'GET'). Should always be non-destructive. */
+    method?: string;
+    /** URL to test against. May contain ${VAR} placeholders. */
+    url: string;
+    /** Optional headers beyond the route's auto-injected headers.
+     *  Values may contain ${VAR} placeholders. */
+    headers?: Record<string, string>;
+    /** Optional request body (for APIs that require POST for reads, e.g., GraphQL). */
+    body?: unknown;
+    /** Human-readable description of what this test does (e.g., "Fetches authenticated user"). */
+    description?: string;
+    /** Expected HTTP status code(s) that indicate success. Default: [200] */
+    expectedStatus?: number[];
+}
+/**
+ * Pre-configured test for verifying event listener / ingestor configuration.
+ *
+ * The semantics vary by strategy:
+ *   - 'websocket_auth' — Hit an API endpoint that verifies the token is valid for gateway access
+ *   - 'webhook_verify' — Verify that required webhook secrets are configured
+ *   - 'poll_once'      — Execute a single poll request and verify the response shape
+ *   - 'http_request'   — Execute a custom HTTP request to verify listener setup
+ *
+ * Set to null in a connection template to explicitly indicate that the
+ * listener cannot be independently tested.
+ */
+export interface TestIngestorConfig {
+    /** Human-readable description of what this test verifies. */
+    description: string;
+    /** Strategy for testing. */
+    strategy: 'websocket_auth' | 'webhook_verify' | 'poll_once' | 'http_request';
+    /** For 'http_request' or 'websocket_auth': the HTTP request to execute. */
+    request?: {
+        method?: string;
+        url: string;
+        headers?: Record<string, string>;
+        body?: unknown;
+        expectedStatus?: number[];
+    };
+    /** For 'webhook_verify': secret names that must be present and non-empty. */
+    requireSecrets?: string[];
+}
+/**
+ * A single configurable field for an event listener.
+ * Provides enough metadata for any UI (web dashboard, CLI, AI agent)
+ * to dynamically render the right input control.
+ */
+export interface ListenerConfigField {
+    /** Machine-readable key (e.g., "boardId", "eventFilter", "guildIds"). */
+    key: string;
+    /** Human-readable label for display (e.g., "Trello Board ID"). */
+    label: string;
+    /** Help text / description shown below the field. */
+    description?: string;
+    /** Whether this field must be provided before the listener can start. Default: false */
+    required?: boolean;
+    /**
+     * The field type — determines how UIs should render this.
+     *   - 'text'        — single text input
+     *   - 'number'      — numeric input (respects min/max)
+     *   - 'boolean'     — toggle / checkbox
+     *   - 'select'      — single-choice dropdown (uses options)
+     *   - 'multiselect' — multi-choice checklist (uses options)
+     *   - 'secret'      — masked text input (for sensitive values)
+     *   - 'text[]'      — list of text values (e.g., guild IDs, channel IDs)
+     */
+    type: 'text' | 'number' | 'boolean' | 'select' | 'multiselect' | 'secret' | 'text[]';
+    /** Default value if not set by the user. */
+    default?: string | number | boolean | string[];
+    /** For 'select' and 'multiselect': the available options. */
+    options?: ListenerConfigOption[];
+    /** For 'text': placeholder text. */
+    placeholder?: string;
+    /** For 'number': minimum allowed value. */
+    min?: number;
+    /** For 'number': maximum allowed value. */
+    max?: number;
+    /** For 'text': regex pattern for validation. */
+    pattern?: string;
+    /**
+     * For dynamic options that must be fetched from the API at configure-time.
+     * A UI calls `resolve_listener_options` with the connection alias and
+     * this param key, and the server executes this request to populate options.
+     */
+    dynamicOptions?: {
+        /** URL to fetch options from. ${VAR} placeholders resolved. */
+        url: string;
+        /** HTTP method (default: 'GET'). */
+        method?: string;
+        /** Request body (for POST requests). */
+        body?: unknown;
+        /** Dot-path to the array in the response. Omit if top-level array. */
+        responsePath?: string;
+        /** Field in each item to use as the display label. */
+        labelField: string;
+        /** Field in each item to use as the value. */
+        valueField: string;
+    };
+    /**
+     * Which IngestorOverrides key this maps to for automatic merging.
+     * If omitted, the field's `key` is used directly as the override key.
+     */
+    overrideKey?: string;
+    /**
+     * Marks this field as the instance-identifying key for multi-instance support.
+     * When true, each unique value of this field creates a separate listener instance
+     * (e.g., boardId for Trello, subreddit for Reddit).
+     * At most one field per listenerConfig should have instanceKey: true.
+     */
+    instanceKey?: boolean;
+    /** Group label for organizing fields in UIs (e.g., "Filtering", "Connection", "Advanced"). */
+    group?: string;
+}
+/** An option for select/multiselect fields. */
+export interface ListenerConfigOption {
+    /** Machine-readable value. */
+    value: string | number | boolean;
+    /** Human-readable label. */
+    label: string;
+    /** Optional description for this option. */
+    description?: string;
+}
+/**
+ * Complete listener configuration schema for a connection.
+ * Stored in connection templates alongside the `ingestor` config.
+ */
+export interface ListenerConfigSchema {
+    /** Human-readable name (e.g., "Discord Gateway Listener"). */
+    name: string;
+    /** Description of what this listener does. */
+    description?: string;
+    /** The configurable fields. */
+    fields: ListenerConfigField[];
+    /**
+     * Whether this listener supports multiple concurrent instances.
+     * When true, callers can define `listenerInstances` in their config to spawn
+     * N ingestors per connection with different parameter values (e.g., watching
+     * multiple Trello boards or multiple Reddit subreddits simultaneously).
+     * Default: false
+     */
+    supportsMultiInstance?: boolean;
+}
+//# sourceMappingURL=listener-config.d.ts.map

package/dist/shared/listener-config.js

@@ -0,0 +1,10 @@
+/**
+ * Shared types for connection testing, ingestor testing, and listener
+ * configuration schemas.
+ *
+ * These types are used in connection templates (JSON), the Route interface,
+ * ResolvedRoute, and the tool handlers that expose testing and configuration
+ * functionality to MCP clients.
+ */
+export {};
+//# sourceMappingURL=listener-config.js.map

package/dist/shared/migrations.d.ts

@@ -0,0 +1,40 @@
+/**
+ * On-disk layout migrations — drawlatch owns the evolution of its own config dir.
+ *
+ * The config-dir contract (stable, documented):
+ *
+ *   $MCP_CONFIG_DIR/                 (default: ~/.drawlatch)
+ *     remote.config.json             — RemoteServerConfig (callers, connectors, port…)
+ *     proxy.config.json              — ProxyConfig (local MCP proxy → remote URL)
+ *     .env                           — secret values (prefixed per caller)
+ *     keys/
+ *       server/                      — the daemon's own Ed25519 + X25519 keypair
+ *       callers/<alias>/             — one keypair per caller alias
+ *
+ * Historically the key directories used a different layout
+ * (`keys/local`, `keys/remote`, `keys/peers/*`). These migrations move any
+ * legacy layout to the current one. They were previously implemented in
+ * callboard (`migrateKeyDirectories`); drawlatch now owns them so it controls
+ * its own layout evolution and callboard can delete the duplicate.
+ *
+ * All functions are idempotent and safe to call on every startup.
+ */
+/**
+ * Migrate the legacy key directory layout to the current callers/server layout.
+ *
+ *   keys/local/<alias>/        → keys/callers/<alias>/
+ *   keys/remote/               → keys/server/
+ *   keys/peers/remote-server/  → keys/server/  (public keys only)
+ *   keys/peers/<alias>/        → keys/callers/<alias>/  (public keys only)
+ *
+ * Idempotent: only renames when the old dir exists and the new one does not.
+ *
+ * @param keysDir  The keys directory to migrate. Defaults to `getKeysDir()`.
+ */
+export declare function migrateKeyLayout(keysDir?: string): void;
+/**
+ * Run every config-dir layout migration for the active `MCP_CONFIG_DIR`.
+ * Call once at daemon startup before keys/config are loaded.
+ */
+export declare function migrateConfigDir(): void;
+//# sourceMappingURL=migrations.d.ts.map

package/dist/shared/migrations.js

@@ -0,0 +1,122 @@
+/**
+ * On-disk layout migrations — drawlatch owns the evolution of its own config dir.
+ *
+ * The config-dir contract (stable, documented):
+ *
+ *   $MCP_CONFIG_DIR/                 (default: ~/.drawlatch)
+ *     remote.config.json             — RemoteServerConfig (callers, connectors, port…)
+ *     proxy.config.json              — ProxyConfig (local MCP proxy → remote URL)
+ *     .env                           — secret values (prefixed per caller)
+ *     keys/
+ *       server/                      — the daemon's own Ed25519 + X25519 keypair
+ *       callers/<alias>/             — one keypair per caller alias
+ *
+ * Historically the key directories used a different layout
+ * (`keys/local`, `keys/remote`, `keys/peers/*`). These migrations move any
+ * legacy layout to the current one. They were previously implemented in
+ * callboard (`migrateKeyDirectories`); drawlatch now owns them so it controls
+ * its own layout evolution and callboard can delete the duplicate.
+ *
+ * All functions are idempotent and safe to call on every startup.
+ */
+import { existsSync, mkdirSync, renameSync, readdirSync, rmSync, copyFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { getKeysDir } from './config.js';
+import { createLogger } from './logger.js';
+const log = createLogger('migrations');
+/** Copy *.pub.pem files from src to dest, creating dest if needed. */
+function copyPublicKeys(src, dest) {
+    if (!existsSync(src))
+        return;
+    mkdirSync(dest, { recursive: true, mode: 0o700 });
+    const files = readdirSync(src).filter((f) => f.endsWith('.pub.pem'));
+    for (const file of files) {
+        const destFile = join(dest, file);
+        if (!existsSync(destFile)) {
+            copyFileSync(join(src, file), destFile);
+        }
+    }
+}
+/**
+ * Migrate the legacy key directory layout to the current callers/server layout.
+ *
+ *   keys/local/<alias>/        → keys/callers/<alias>/
+ *   keys/remote/               → keys/server/
+ *   keys/peers/remote-server/  → keys/server/  (public keys only)
+ *   keys/peers/<alias>/        → keys/callers/<alias>/  (public keys only)
+ *
+ * Idempotent: only renames when the old dir exists and the new one does not.
+ *
+ * @param keysDir  The keys directory to migrate. Defaults to `getKeysDir()`.
+ */
+export function migrateKeyLayout(keysDir = getKeysDir()) {
+    if (!existsSync(keysDir))
+        return;
+    const oldLocal = join(keysDir, 'local');
+    const oldRemote = join(keysDir, 'remote');
+    const oldPeers = join(keysDir, 'peers');
+    const newCallers = join(keysDir, 'callers');
+    const newServer = join(keysDir, 'server');
+    try {
+        // keys/local/ → keys/callers/
+        if (existsSync(oldLocal) && !existsSync(newCallers)) {
+            renameSync(oldLocal, newCallers);
+            log.info(`Migrated ${oldLocal} -> ${newCallers}`);
+        }
+        // keys/remote/ → keys/server/
+        if (existsSync(oldRemote) && !existsSync(newServer)) {
+            renameSync(oldRemote, newServer);
+            log.info(`Migrated ${oldRemote} -> ${newServer}`);
+        }
+        // keys/peers/ — merge individual peer dirs into callers/server
+        if (existsSync(oldPeers)) {
+            const entries = readdirSync(oldPeers, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                if (entry.name === 'remote-server') {
+                    // peers/remote-server/ → server/ (copy .pub.pem files)
+                    copyPublicKeys(join(oldPeers, entry.name), newServer);
+                    log.info(`Migrated ${join(oldPeers, entry.name)} -> ${newServer}`);
+                }
+                else {
+                    // peers/<alias>/ → callers/<alias>/ (copy .pub.pem files)
+                    const targetDir = join(newCallers, entry.name);
+                    copyPublicKeys(join(oldPeers, entry.name), targetDir);
+                    log.info(`Migrated ${join(oldPeers, entry.name)} -> ${targetDir}`);
+                }
+            }
+            // Remove the now-merged peers directory
+            try {
+                rmSync(oldPeers, { recursive: true });
+                log.info(`Removed old ${oldPeers} directory`);
+            }
+            catch {
+                // Not critical — may still have unexpected files
+            }
+        }
+        // Clean up empty old directories
+        for (const dir of [oldLocal, oldRemote]) {
+            if (existsSync(dir)) {
+                try {
+                    if (readdirSync(dir).length === 0)
+                        rmSync(dir);
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+    }
+    catch (err) {
+        log.warn(`Failed to migrate key directories in ${keysDir}: ${String(err)}`);
+    }
+}
+/**
+ * Run every config-dir layout migration for the active `MCP_CONFIG_DIR`.
+ * Call once at daemon startup before keys/config are loaded.
+ */
+export function migrateConfigDir() {
+    migrateKeyLayout();
+}
+//# sourceMappingURL=migrations.js.map