@wolpertingerlabs/drawlatch 1.0.0-alpha.4 → 1.0.0-alpha.40

package/dist/connections/{hex.json → developer-tools/hex.json}

@@ -1,5 +1,7 @@
 {
   "name": "Hex API",
+  "stability": "dev",
+  "category": "developer-tools",
   "description": "Hex API — projects, runs, users, groups, collections, and data connections. Auth is handled automatically via the HEX_TOKEN environment variable.",
   "docsUrl": "https://learn.hex.tech/docs/api/api-overview",
   "headers": {

package/dist/connections/{linear.json → developer-tools/linear.json}

@@ -1,5 +1,7 @@
 {
   "name": "Linear API",
+  "stability": "beta",
+  "category": "developer-tools",
   "description": "Linear GraphQL API — issues, projects, teams, cycles, and more. Auth is handled automatically via the LINEAR_API_KEY environment variable. All requests are GraphQL queries sent as POST to https://api.linear.app/graphql. Includes a poll ingestor that periodically fetches recently updated issues — use poll_events to retrieve them.",
   "docsUrl": "https://developers.linear.app/docs/graphql/working-with-the-graphql-api",
   "headers": {

package/dist/connections/{lichess.json → gaming/lichess.json}

@@ -1,5 +1,7 @@
 {
   "name": "Lichess API",
+  "stability": "stable",
+  "category": "gaming",
   "description": "Lichess Opening Explorer, Cloud Evaluation, and authenticated API — query master and rated game statistics by opening move sequence, get cached Stockfish engine evaluations by FEN position, and access authenticated endpoints (account info, game history, player-specific opening analysis, etc.). Set LICHESS_API_TOKEN to a personal access token for authenticated routes; public endpoints (Opening Explorer, Cloud Eval) work without it.",
   "docsUrl": "https://lichess.org/api",
   "headers": {

package/dist/connections/messaging/agentmail.json

@@ -0,0 +1,21 @@
+{
+  "name": "AgentMail API",
+  "stability": "beta",
+  "category": "messaging",
+  "description": "AgentMail API — email infrastructure for AI agents. Create and manage inboxes, send and reply to messages, browse threads, and manage drafts and attachments. Auth is handled automatically via the AGENTMAIL_API_KEY environment variable using a Bearer token. All endpoints are under the /v0 path. Create an API key in the AgentMail Console (https://console.agentmail.to).",
+  "docsUrl": "https://docs.agentmail.to/api-reference",
+  "headers": {
+    "Authorization": "Bearer ${AGENTMAIL_API_KEY}",
+    "Content-Type": "application/json"
+  },
+  "secrets": {
+    "AGENTMAIL_API_KEY": "${AGENTMAIL_API_KEY}"
+  },
+  "allowedEndpoints": [
+    "https://api.agentmail.to/**"
+  ],
+  "testConnection": {
+    "url": "https://api.agentmail.to/v0/inboxes",
+    "description": "Lists inboxes to verify the API key"
+  }
+}

package/dist/connections/{discord-bot.json → messaging/discord-bot.json}

@@ -1,5 +1,7 @@
 {
   "name": "Discord Bot API",
+  "stability": "stable",
+  "category": "messaging",
   "description": "Discord Bot API (v10) — guilds, channels, messages, users, roles, and more. Auth is handled automatically via the DISCORD_BOT_TOKEN environment variable. Uses the 'Bot' authorization prefix. For OAuth2 user-scoped access, use the 'discord-oauth' connection instead. Includes a Gateway ingestor for real-time events (messages, reactions, etc.) — use poll_events to retrieve them.",
   "docsUrl": "https://discord.com/developers/docs/intro",
   "openApiUrl": "https://raw.githubusercontent.com/discord/discord-api-spec/main/specs/openapi.json",

package/dist/connections/{discord-oauth.json → messaging/discord-oauth.json}

@@ -1,5 +1,7 @@
 {
   "name": "Discord OAuth2 API",
+  "stability": "dev",
+  "category": "messaging",
   "description": "Discord OAuth2 API (v10) — user identity, guilds, connections, and other user-scoped data. Auth is handled automatically via the DISCORD_OAUTH_TOKEN environment variable (OAuth2 Bearer access token). Access is limited to the scopes the user authorized. For full bot access, use the 'discord-bot' connection instead.",
   "docsUrl": "https://discord.com/developers/docs/topics/oauth2",
   "openApiUrl": "https://raw.githubusercontent.com/discord/discord-api-spec/main/specs/openapi.json",

package/dist/connections/{slack.json → messaging/slack.json}

@@ -1,5 +1,7 @@
 {
   "name": "Slack API",
+  "stability": "stable",
+  "category": "messaging",
   "description": "Slack Web API — messages, channels, users, reactions, files, and more. Auth is handled automatically via the SLACK_BOT_TOKEN environment variable. Real-time events via Socket Mode require SLACK_APP_TOKEN.",
   "docsUrl": "https://docs.slack.dev/apis/web-api",
   "openApiUrl": "https://raw.githubusercontent.com/slackapi/slack-api-specs/master/web-api/slack_web_openapi_v2.json",

package/dist/connections/{telegram.json → messaging/telegram.json}

@@ -1,5 +1,7 @@
 {
   "name": "Telegram Bot API",
+  "stability": "beta",
+  "category": "messaging",
   "description": "Telegram Bot API — messages, chats, users, inline queries, payments, and more. Auth uses a bot token embedded in the URL path — include /bot${TELEGRAM_BOT_TOKEN}/ in your request URLs. The placeholder is resolved automatically from the route's secrets. Create a bot via @BotFather on Telegram to obtain a token. Includes a poll ingestor that fetches new updates via getUpdates — use poll_events to retrieve them.",
   "docsUrl": "https://core.telegram.org/bots/api",
   "headers": {

package/dist/connections/{google.json → productivity/google.json}

@@ -1,5 +1,7 @@
 {
   "name": "Google APIs",
+  "stability": "dev",
+  "category": "productivity",
   "description": "Google APIs — Sheets, Docs, Drive, Calendar, Gmail, and more. Auth is handled automatically via the GOOGLE_API_TOKEN environment variable (OAuth2 access token or service account token). Multiple Google API domains are allowlisted.",
   "docsUrl": "https://developers.google.com/apis-explorer",
   "headers": {

package/dist/connections/{notion.json → productivity/notion.json}

@@ -1,5 +1,7 @@
 {
   "name": "Notion API",
+  "stability": "beta",
+  "category": "productivity",
   "description": "Notion API — pages, databases, blocks, users, search, and more. Auth is handled automatically via the NOTION_API_KEY environment variable (internal integration token). The Notion-Version header is set to 2022-06-28. Includes a poll ingestor that periodically searches for recently edited pages — use poll_events to retrieve them.",
   "docsUrl": "https://developers.notion.com/reference",
   "headers": {

package/dist/connections/{stripe.json → productivity/stripe.json}

@@ -1,5 +1,7 @@
 {
   "name": "Stripe API",
+  "stability": "beta",
+  "category": "productivity",
   "description": "Stripe payments API — customers, charges, payment intents, subscriptions, invoices, and more. Auth is handled automatically via the STRIPE_SECRET_KEY environment variable. Includes a webhook ingestor for real-time events (payment_intent.succeeded, invoice.paid, etc.) — set STRIPE_WEBHOOK_SECRET and use poll_events to retrieve them. Note: Stripe uses application/x-www-form-urlencoded for request bodies, not JSON.",
   "docsUrl": "https://docs.stripe.com/api",
   "openApiUrl": "https://raw.githubusercontent.com/stripe/openapi/master/openapi/spec3.json",

package/dist/connections/{trello.json → productivity/trello.json}

@@ -1,5 +1,7 @@
 {
   "name": "Trello API",
+  "stability": "stable",
+  "category": "productivity",
   "description": "Trello boards, lists, and cards API. Authentication uses query parameters — include ?key=${TRELLO_API_KEY}&token=${TRELLO_TOKEN} in your request URLs. The placeholders are resolved automatically from the route's secrets. Includes a webhook ingestor for real-time events (card updates, list changes, board activity, etc.) — set TRELLO_API_SECRET and TRELLO_CALLBACK_URL, then use poll_events to retrieve them.",
   "docsUrl": "https://developer.atlassian.com/cloud/trello/rest/",
   "headers": {},

package/dist/connections/{bluesky.json → social-media/bluesky.json}

@@ -1,5 +1,7 @@
 {
   "name": "Bluesky API (AT Protocol)",
+  "stability": "beta",
+  "category": "social-media",
   "description": "Bluesky API via the AT Protocol — posts, feeds, profiles, notifications, social graph, and more. Auth is handled automatically via the BLUESKY_ACCESS_TOKEN environment variable (JWT Bearer token). Obtain a token by POSTing to com.atproto.server.createSession with your handle and an App Password. Tokens expire after ~2 hours — rotate externally using the refresh token. Both bsky.social (authenticated PDS) and public.api.bsky.app (public read-only API) are allowlisted. For self-hosted PDS instances, override with a custom connector. Includes a poll ingestor that fetches notifications — use poll_events to retrieve them.",
   "docsUrl": "https://docs.bsky.app/",
   "headers": {

package/dist/connections/{mastodon.json → social-media/mastodon.json}

@@ -1,5 +1,7 @@
 {
   "name": "Mastodon API",
+  "stability": "beta",
+  "category": "social-media",
   "description": "Mastodon API — statuses (toots), timelines, notifications, accounts, search, and more. Auth is handled automatically via the MASTODON_ACCESS_TOKEN environment variable (OAuth2 Bearer token from your instance's Development settings). This template targets mastodon.social — for other instances, override with a custom connector using the same auth pattern but different allowedEndpoints. Includes a poll ingestor that fetches the home timeline — use poll_events to retrieve them.",
   "docsUrl": "https://docs.joinmastodon.org/api/",
   "headers": {

package/dist/connections/{reddit.json → social-media/reddit.json}

@@ -1,5 +1,7 @@
 {
   "name": "Reddit API",
+  "stability": "beta",
+  "category": "social-media",
   "description": "Reddit API — subreddits, posts, comments, users, search, and more. Auth is handled automatically via the REDDIT_ACCESS_TOKEN environment variable (OAuth2 Bearer token). A User-Agent header is required by Reddit and set via REDDIT_USER_AGENT. Obtain an OAuth2 token by registering a 'script' app at https://www.reddit.com/prefs/apps and using the client credentials grant. Tokens expire after 1 hour — rotate externally. Includes a poll ingestor that fetches new posts from a configurable subreddit — set REDDIT_SUBREDDIT and use poll_events to retrieve them.",
   "docsUrl": "https://www.reddit.com/dev/api/",
   "headers": {

package/dist/connections/{twitch.json → social-media/twitch.json}

@@ -1,5 +1,7 @@
 {
   "name": "Twitch API",
+  "stability": "beta",
+  "category": "social-media",
   "description": "Twitch Helix API — streams, users, channels, clips, videos, chat, and more. Auth requires both a Bearer token and Client-Id header, handled automatically via TWITCH_ACCESS_TOKEN and TWITCH_CLIENT_ID environment variables. Register an application at https://dev.twitch.tv/console/apps to obtain credentials. Includes a poll ingestor that fetches followed live streams — set TWITCH_USER_ID and use poll_events to retrieve them.",
   "docsUrl": "https://dev.twitch.tv/docs/api/reference/",
   "headers": {

package/dist/connections/{x.json → social-media/x.json}

@@ -1,5 +1,7 @@
 {
   "name": "X (Twitter) API",
+  "stability": "beta",
+  "category": "social-media",
   "description": "X (formerly Twitter) API v2 — tweets, users, spaces, lists, and more. Auth is handled automatically via the X_BEARER_TOKEN environment variable (App-only Bearer token from the X Developer Portal). Both api.x.com and api.twitter.com domains are allowlisted. Includes a poll ingestor that searches recent tweets matching a configurable query — set X_SEARCH_QUERY and use poll_events to retrieve them.",
   "docsUrl": "https://developer.x.com/en/docs/x-api",
   "headers": {

package/dist/mcp/server.js

@@ -13,38 +13,81 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
 import crypto from 'node:crypto';
-import { loadProxyConfig } from '../shared/config.js';
-import { loadKeyBundle, loadPublicKeys, EncryptedChannel } from '../shared/crypto/index.js';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { loadProxyConfig, resolveCallerKeyAlias, getCallerKeysDir, getServerKeysDir, getProxyConfigPath, } from '../shared/config.js';
+import { loadKeyBundle, loadPublicKeys, EncryptedChannel, extractPublicKeys, fingerprint, } from '../shared/crypto/index.js';
+import { existsSync } from 'node:fs';
 import { HandshakeInitiator, } from '../shared/protocol/index.js';
 // ── State ──────────────────────────────────────────────────────────────────
 let channel = null;
 let remoteUrl;
 // ── Handshake ──────────────────────────────────────────────────────────────
 async function establishChannel() {
+    // Pre-flight validation
+    if (!existsSync(getProxyConfigPath())) {
+        throw new Error(`No proxy config found at ${getProxyConfigPath()}. Run: drawlatch init`);
+    }
     const config = loadProxyConfig();
     remoteUrl = config.remoteUrl;
-    // Log which key identity is being used
-    const envAlias = process.env.MCP_KEY_ALIAS?.trim();
-    if (envAlias) {
-        console.error(`[mcp-proxy] Using key alias from MCP_KEY_ALIAS: "${envAlias}"`);
+    // Resolve key paths from config dir + alias
+    const alias = resolveCallerKeyAlias();
+    const callerKeysDir = path.join(getCallerKeysDir(), alias);
+    const serverKeysDir = getServerKeysDir();
+    console.error(`[mcp-proxy] Using caller alias: "${alias}"`);
+    console.error(`[mcp-proxy] Caller keys dir: ${callerKeysDir}`);
+    // Validate key paths before attempting to load
+    if (!existsSync(callerKeysDir)) {
+        throw new Error(`Caller keys not found at ${callerKeysDir}. Run: drawlatch generate-keys caller ${alias}`);
+    }
+    if (!existsSync(serverKeysDir)) {
+        throw new Error(`Server public keys not found at ${serverKeysDir}. Run: drawlatch sync`);
+    }
+    let ownKeys, remotePub;
+    try {
+        ownKeys = loadKeyBundle(callerKeysDir);
     }
-    else if (config.localKeyAlias) {
-        console.error(`[mcp-proxy] Using key alias from config: "${config.localKeyAlias}"`);
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(`Failed to load caller keys from ${callerKeysDir}: ${msg}. Run: drawlatch generate-keys caller ${alias}`);
+    }
+    try {
+        remotePub = loadPublicKeys(serverKeysDir);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(`Failed to load server public keys from ${serverKeysDir}: ${msg}. Run: drawlatch sync`);
     }
-    console.error(`[mcp-proxy] Local keys dir: ${config.localKeysDir}`);
-    const ownKeys = loadKeyBundle(config.localKeysDir);
-    const remotePub = loadPublicKeys(config.remotePublicKeysDir);
     const initiator = new HandshakeInitiator(ownKeys, remotePub);
     // Step 1: Send HandshakeInit
     const initMsg = initiator.createInit();
-    const initResp = await fetch(`${remoteUrl}/handshake/init`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(initMsg),
-        signal: AbortSignal.timeout(config.connectTimeout),
-    });
+    let initResp;
+    try {
+        initResp = await fetch(`${remoteUrl}/handshake/init`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(initMsg),
+            signal: AbortSignal.timeout(config.connectTimeout),
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.includes('ECONNREFUSED')) {
+            throw new Error(`Remote server is not running at ${remoteUrl}. Start it with: drawlatch start`);
+        }
+        if ((err instanceof DOMException && err.name === 'AbortError') || msg.includes('timed out')) {
+            throw new Error(`Remote server at ${remoteUrl} is not responding (timed out after ${config.connectTimeout}ms)`);
+        }
+        throw new Error(`Failed to connect to remote server at ${remoteUrl}: ${msg}`);
+    }
     if (!initResp.ok) {
         const errText = await initResp.text();
+        const localFp = fingerprint(extractPublicKeys(ownKeys));
+        if (initResp.status === 401 || initResp.status === 403) {
+            console.error(`[mcp-proxy] Handshake rejected by server. Your key fingerprint: ${localFp}`);
+            console.error('[mcp-proxy] Ensure this fingerprint matches an authorized peer on the remote server.');
+            throw new Error(`Handshake rejected (${initResp.status}). Your fingerprint: ${localFp}. Check that public keys are correctly exchanged. See: drawlatch init`);
+        }
         throw new Error(`Handshake init failed: ${initResp.status} ${errText}`);
     }
     const reply = await initResp.json();
@@ -85,21 +128,42 @@ async function sendEncryptedRequest(toolName, toolInput) {
     };
     // Encrypt the entire request
     const encrypted = ch.encryptJSON(request);
-    const resp = await fetch(`${remoteUrl}/request`, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/octet-stream',
-            'X-Session-Id': ch.sessionId,
-        },
-        body: new Uint8Array(encrypted),
-        signal: AbortSignal.timeout(config.requestTimeout),
-    });
+    let resp;
+    try {
+        resp = await fetch(`${remoteUrl}/request`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/octet-stream',
+                'X-Session-Id': ch.sessionId,
+            },
+            body: new Uint8Array(encrypted),
+            signal: AbortSignal.timeout(config.requestTimeout),
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.includes('ECONNREFUSED')) {
+            channel = null;
+            throw new Error(`Remote server is not running at ${remoteUrl}. Start it with: drawlatch start`);
+        }
+        if ((err instanceof DOMException && err.name === 'AbortError') || msg.includes('timed out')) {
+            throw new Error(`Remote server at ${remoteUrl} is not responding (timed out after ${config.requestTimeout}ms)`);
+        }
+        channel = null;
+        throw new Error(`Failed to reach remote server at ${remoteUrl}: ${msg}`);
+    }
     if (!resp.ok) {
         // If session expired, re-establish
         if (resp.status === 401) {
             console.error('[mcp-proxy] Session expired, re-establishing...');
             channel = null;
-            return sendEncryptedRequest(toolName, toolInput);
+            try {
+                return await sendEncryptedRequest(toolName, toolInput);
+            }
+            catch (reEstErr) {
+                const msg = reEstErr instanceof Error ? reEstErr.message : String(reEstErr);
+                throw new Error(`Session re-establishment failed: ${msg}`);
+            }
         }
         throw new Error(`Request failed: ${resp.status} ${await resp.text()}`);
     }
@@ -129,14 +193,54 @@ server.tool('secure_request', "Make an authenticated HTTP request through the en
         .optional()
         .describe('Request headers, may contain ${VAR} placeholders'),
     body: z.any().optional().describe('Request body (object for JSON, string for raw)'),
-}, async ({ method, url, headers, body }) => {
+    files: z
+        .array(z.object({
+        field: z.string().describe('Form field name (e.g., "files[0]", "file", "attachment")'),
+        path: z.string().describe('Absolute path to the file on the local filesystem'),
+        filename: z.string().describe('Filename to use in the upload'),
+        contentType: z.string().describe('MIME type (e.g., "image/png", "application/pdf")'),
+    }))
+        .optional()
+        .describe('File attachments for multipart/form-data uploads. When present, the request is sent as multipart with the JSON body as "payload_json". Use bodyFieldName to change the JSON part name.'),
+    bodyFieldName: z
+        .string()
+        .optional()
+        .describe('Form field name for the JSON body part in multipart requests (default: "payload_json"). Only used when files are present.'),
+}, async ({ method, url, headers, body, files, bodyFieldName }) => {
     try {
-        const result = await sendEncryptedRequest('http_request', {
+        const toolInput = {
             method,
             url,
             headers: headers ?? {},
             body,
-        });
+        };
+        // Read and base64-encode files from the local filesystem before sending
+        // through the encrypted channel (remote server can't access local files)
+        if (files?.length) {
+            const MAX_FILE_SIZE = 25 * 1024 * 1024; // 25 MB per file
+            const encodedFiles = await Promise.all(files.map(async ({ field, path: filePath, filename, contentType }) => {
+                if (!path.isAbsolute(filePath)) {
+                    throw new Error(`File path must be absolute: ${filePath}`);
+                }
+                let stat;
+                try {
+                    stat = await fs.stat(filePath);
+                }
+                catch {
+                    throw new Error(`File not found: ${filePath}`);
+                }
+                if (stat.size > MAX_FILE_SIZE) {
+                    throw new Error(`File too large (${(stat.size / 1024 / 1024).toFixed(1)} MB): ${filePath} — max ${MAX_FILE_SIZE / 1024 / 1024} MB`);
+                }
+                const buffer = await fs.readFile(filePath);
+                return { field, data: buffer.toString('base64'), filename, contentType };
+            }));
+            toolInput.files = encodedFiles;
+            if (bodyFieldName) {
+                toolInput.bodyFieldName = bodyFieldName;
+            }
+        }
+        const result = await sendEncryptedRequest('http_request', toolInput);
         return {
             content: [
                 {
@@ -339,7 +443,10 @@ server.tool('resolve_listener_options', 'Fetch dynamic options for a listener co
     paramKey: z.string().describe('The field key to resolve options for (e.g., "boardId")'),
 }, async ({ connection, paramKey }) => {
     try {
-        const result = await sendEncryptedRequest('resolve_listener_options', { connection, paramKey });
+        const result = await sendEncryptedRequest('resolve_listener_options', {
+            connection,
+            paramKey,
+        });
         return {
             content: [
                 {
@@ -371,7 +478,11 @@ server.tool('control_listener', 'Start, stop, or restart an event listener for a
         .describe('Instance ID for multi-instance listeners. Omit to control all instances.'),
 }, async ({ connection, action, instance_id }) => {
     try {
-        const result = await sendEncryptedRequest('control_listener', { connection, action, instance_id });
+        const result = await sendEncryptedRequest('control_listener', {
+            connection,
+            action,
+            instance_id,
+        });
         return {
             content: [
                 {
@@ -425,7 +536,7 @@ server.tool('get_listener_params', 'Read current listener parameter overrides fo
  * Merges params into existing config. Supports creating new multi-instance listeners.
  */
 // eslint-disable-next-line @typescript-eslint/no-deprecated -- registerTool is not available in this SDK version
-server.tool('set_listener_params', "Add or edit listener parameter overrides for a connection. Merges params into existing config. Set create_instance to true to create a new multi-instance listener.", {
+server.tool('set_listener_params', 'Add or edit listener parameter overrides for a connection. Merges params into existing config. Set create_instance to true to create a new multi-instance listener.', {
     connection: z.string().describe('Connection alias (e.g., "trello")'),
     instance_id: z
         .string()
@@ -523,11 +634,135 @@ server.tool('delete_listener_instance', 'Remove a multi-instance listener instan
         };
     }
 });
+/**
+ * List all available connection templates with caller-specific status.
+ * Returns which connections are enabled and which secrets are configured.
+ */
+// eslint-disable-next-line @typescript-eslint/no-deprecated -- registerTool is not available in this SDK version
+server.tool('list_connection_templates', 'List all available connection templates (built-in + custom). Returns template metadata, which connections are enabled for this caller, and which secrets are configured (boolean only, never values).', { _: z.string().optional().describe('unused') }, async () => {
+    try {
+        const result = await sendEncryptedRequest('list_connection_templates', {});
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: typeof result === 'string' ? result : JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            content: [{ type: 'text', text: `Error: ${message}` }],
+            isError: true,
+        };
+    }
+});
+/**
+ * Enable or disable a connection for the authenticated caller.
+ */
+// eslint-disable-next-line @typescript-eslint/no-deprecated -- registerTool is not available in this SDK version
+server.tool('set_connection_enabled', 'Enable or disable a connection for the authenticated caller. When disabling, any running ingestors for the connection are stopped.', {
+    connection: z.string().describe('Connection alias (e.g., "github", "discord-bot")'),
+    enabled: z.boolean().describe('Whether to enable (true) or disable (false) the connection'),
+}, async ({ connection, enabled }) => {
+    try {
+        const result = await sendEncryptedRequest('set_connection_enabled', { connection, enabled });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: typeof result === 'string' ? result : JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            content: [{ type: 'text', text: `Error: ${message}` }],
+            isError: true,
+        };
+    }
+});
+/**
+ * Set or delete secrets for the authenticated caller.
+ * Uses prefixed env vars for caller isolation. Never returns secret values.
+ */
+// eslint-disable-next-line @typescript-eslint/no-deprecated -- registerTool is not available in this SDK version
+server.tool('set_secrets', 'Set or delete secrets for the authenticated caller. Pass secret name → value pairs. Use empty string to delete a secret. Returns boolean status per secret (never values).', {
+    secrets: z
+        .record(z.string(), z.string())
+        .describe('Secret name → value pairs. Empty string deletes the secret.'),
+}, async ({ secrets }) => {
+    try {
+        const result = await sendEncryptedRequest('set_secrets', { secrets });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: typeof result === 'string' ? result : JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            content: [{ type: 'text', text: `Error: ${message}` }],
+            isError: true,
+        };
+    }
+});
+/**
+ * Check which secrets are set for the authenticated caller (never returns values).
+ */
+// eslint-disable-next-line @typescript-eslint/no-deprecated -- registerTool is not available in this SDK version
+server.tool('get_secret_status', 'Check which secrets are configured for a connection. Returns boolean status for each required and optional secret (never returns values).', {
+    connection: z.string().describe('Connection alias to check secrets for (e.g., "github")'),
+}, async ({ connection }) => {
+    try {
+        const result = await sendEncryptedRequest('get_secret_status', { connection });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: typeof result === 'string' ? result : JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            content: [{ type: 'text', text: `Error: ${message}` }],
+            isError: true,
+        };
+    }
+});
 // ── Start ──────────────────────────────────────────────────────────────────
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
     console.error('[mcp-proxy] MCP Secure Proxy server started (stdio transport)');
+    // Non-blocking health check: advise user if the remote server is not reachable
+    try {
+        const config = loadProxyConfig();
+        const resp = await fetch(`${config.remoteUrl}/health`, {
+            signal: AbortSignal.timeout(3000),
+        });
+        if (resp.ok) {
+            console.error(`[mcp-proxy] Remote server reachable at ${config.remoteUrl}`);
+        }
+        else {
+            console.error(`[mcp-proxy] WARNING: Remote server at ${config.remoteUrl} returned ${resp.status}. Check server health.`);
+        }
+    }
+    catch {
+        const config = loadProxyConfig();
+        console.error(`[mcp-proxy] WARNING: Remote server at ${config.remoteUrl} is not reachable. Start it with: drawlatch start`);
+    }
 }
 main().catch((err) => {
     console.error('[mcp-proxy] Fatal error:', err);

package/dist/remote/admin-mutations.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Mutating admin API (item A), mounted behind `requireAuth` at `/api/admin/*`
+ * alongside the read-only endpoints in `admin.ts`.
+ *
+ * Every mutation reuses the canonical tool-dispatch (item D) so there is exactly
+ * one implementation of connection/secret/listener logic. Caller create/delete
+ * uses the programmatic bootstrap (item E).
+ *
+ * Security invariants (same as the read-only side):
+ *   - Secret values are write-only: set via PUT, read back only as booleans.
+ *   - No secret value, AES channel key, or process.env value is ever serialized.
+ *   - After any config mutation, the daemon's live-reload path runs so ingestors
+ *     and routes pick up the change (replacing callboard's restart banner).
+ */
+import express from 'express';
+import { type RemoteServerConfig, type ResolvedRoute } from '../shared/config.js';
+import type { IngestorManager } from './ingestors/index.js';
+export interface AdminMutationDeps {
+    ingestorManager: () => IngestorManager;
+    loadConfig: () => RemoteServerConfig;
+    /** Resolve the live routes for a caller (with secrets) for tool dispatch. */
+    resolveRoutesForCaller: (alias: string) => ResolvedRoute[];
+    /** Re-resolve routes for all active sessions of a caller (live reload). */
+    refreshCaller: (alias: string) => void;
+    /** Register/refresh the authorized peer for a newly-created caller. */
+    reloadPeer: (alias: string) => void;
+    /** Drop the authorized peer + active sessions for a deleted caller. */
+    removePeer: (alias: string) => void;
+    /** Audit-log a sensitive admin mutation (credential issuance). Optional so
+     *  tests can omit it; the daemon wires it to the request audit log. */
+    audit?: (action: string, details?: Record<string, unknown>) => void;
+    /** Endpoint URL to pin in an issued bundle when the request omits one
+     *  (the public tunnel URL, or the daemon's own host:port). */
+    defaultEndpointUrl?: () => string;
+}
+/**
+ * Mount the mutating routes onto an existing admin router.
+ *
+ * The router is already behind `requireAuth` (wired in server.ts), so these
+ * handlers can assume the request is authenticated.
+ */
+export declare function mountAdminMutations(router: express.Router, deps: AdminMutationDeps): void;
+//# sourceMappingURL=admin-mutations.d.ts.map