@a5c-ai/genty-platform 5.1.1-staging.583e3d9a6ed7

package/dist/mcp/channels/outbound.js

@@ -0,0 +1,94 @@
+"use strict";
+/**
+ * GAP-MCPC-002: Outbound Channel Sender.
+ *
+ * Sends messages to channels via MCP server tools.
+ * Supports template-based message formatting.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutboundChannelSender = exports.DEFAULT_CHANNEL_TOOL_MAPPINGS = void 0;
+exports.formatTemplate = formatTemplate;
+exports.DEFAULT_CHANNEL_TOOL_MAPPINGS = {
+    slack: { sendToolName: "slack_send_message", channelArg: "channel", textArg: "text" },
+    discord: { sendToolName: "discord_send_message", channelArg: "channel_id", textArg: "content" },
+    email: { sendToolName: "gmail_create_draft", channelArg: "to", textArg: "body" },
+};
+// ---------------------------------------------------------------------------
+// Template formatting
+// ---------------------------------------------------------------------------
+/** Format a message with simple {{var}} template substitution. */
+function formatTemplate(template, vars) {
+    return template.replace(/\{\{(\w+)\}\}/g, (_match, key) => vars[key] ?? `{{${key}}}`);
+}
+// ---------------------------------------------------------------------------
+// OutboundChannelSender
+// ---------------------------------------------------------------------------
+class OutboundChannelSender {
+    _clientManager;
+    _toolMappings;
+    constructor(clientManager, toolMappings = exports.DEFAULT_CHANNEL_TOOL_MAPPINGS) {
+        this._clientManager = clientManager;
+        this._toolMappings = toolMappings;
+    }
+    /**
+     * Send a message to a channel.
+     * Resolves the channel source (serverName:channelId) to determine
+     * which MCP server and tool to use.
+     */
+    async send(request) {
+        const colonIdx = request.channelSource.indexOf(":");
+        if (colonIdx < 0) {
+            return {
+                success: false,
+                error: `Invalid channel source "${request.channelSource}" — expected "serverName:channelId"`,
+            };
+        }
+        const serverName = request.channelSource.slice(0, colonIdx);
+        const channelId = request.channelSource.slice(colonIdx + 1);
+        // Resolve text: apply template if provided
+        let text = request.text;
+        if (request.template && request.templateVars) {
+            text = formatTemplate(request.template, request.templateVars);
+        }
+        // Find tool mapping by trying to detect channel type from server tools
+        const mapping = await this._resolveToolMapping(serverName);
+        if (!mapping) {
+            return {
+                success: false,
+                error: `No send-message tool mapping found for server "${serverName}"`,
+            };
+        }
+        try {
+            const args = {
+                [mapping.channelArg]: channelId,
+                [mapping.textArg]: text,
+            };
+            const result = await this._clientManager.callTool(serverName, mapping.sendToolName, args);
+            return {
+                success: result.success,
+                messageId: result.content[0]?.text,
+                error: result.error,
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return { success: false, error: message };
+        }
+    }
+    async _resolveToolMapping(serverName) {
+        try {
+            const tools = await this._clientManager.listTools(serverName);
+            const toolNames = tools.map((t) => t.name);
+            for (const [_type, mapping] of Object.entries(this._toolMappings)) {
+                if (toolNames.includes(mapping.sendToolName)) {
+                    return mapping;
+                }
+            }
+        }
+        catch {
+            // Server not connected or tools unavailable
+        }
+        return undefined;
+    }
+}
+exports.OutboundChannelSender = OutboundChannelSender;

package/dist/mcp/channels/permissionRelay.d.ts

@@ -0,0 +1,62 @@
+/**
+ * GAP-MCPC-003: Channel Permission Relay.
+ *
+ * Routes breakpoint approval prompts through messaging channels.
+ * Uses a racing claim() pattern: channel response races against
+ * local interaction, first resolver wins.
+ */
+import type { ChannelApprovalRequest, ChannelApprovalResponse, ApprovalClaim, ChannelApprovalSecurityConfig } from "./types";
+import type { OutboundChannelSender } from "./outbound";
+export interface PermissionRelayOptions {
+    /** Outbound sender for dispatching approval requests to channels. */
+    sender: OutboundChannelSender;
+    /** Security configuration for channel approvals. */
+    security?: ChannelApprovalSecurityConfig;
+}
+/** Result of a relay attempt. */
+export interface RelayResult {
+    /** Whether the relay was dispatched (false if blocked by security). */
+    relayed: boolean;
+    /** Reason if not relayed. */
+    reason?: string;
+    /** Request ID for tracking. */
+    requestId?: string;
+}
+/**
+ * Creates a claimable approval slot.
+ * Multiple resolvers can race to claim it; only the first wins.
+ */
+export declare function createApprovalRace(): {
+    claim: (source: string, response?: ChannelApprovalResponse) => ApprovalClaim;
+    getWinner: () => ApprovalClaim | undefined;
+    promise: Promise<ApprovalClaim>;
+};
+export declare class ChannelPermissionRelay {
+    private readonly _sender;
+    private readonly _security;
+    private readonly _pendingRequests;
+    constructor(options: PermissionRelayOptions);
+    /**
+     * Check whether a breakpoint can be relayed through channels.
+     * Returns false for terminal-only breakpoints or when relay is disabled.
+     */
+    canRelay(breakpointId: string, tags?: string[]): boolean;
+    /**
+     * Relay a breakpoint approval request to all active channels.
+     * Returns relay result. Does NOT wait for responses — use handleResponse()
+     * to process incoming channel approvals.
+     */
+    relay(request: ChannelApprovalRequest, channelSources: string[], tags?: string[]): Promise<RelayResult>;
+    /**
+     * Handle a response from a channel.
+     * Returns the matched request if it was still pending (not expired).
+     */
+    handleResponse(response: ChannelApprovalResponse): ChannelApprovalRequest | undefined;
+    /** Get a pending request by ID (returns undefined if expired). */
+    getPendingRequest(requestId: string): ChannelApprovalRequest | undefined;
+    /** Get all pending (non-expired) requests. */
+    getPendingRequests(): ChannelApprovalRequest[];
+    /** Get the security configuration. */
+    get security(): ChannelApprovalSecurityConfig;
+}
+//# sourceMappingURL=permissionRelay.d.ts.map

package/dist/mcp/channels/permissionRelay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permissionRelay.d.ts","sourceRoot":"","sources":["../../../src/mcp/channels/permissionRelay.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EACV,sBAAsB,EACtB,uBAAuB,EACvB,aAAa,EACb,6BAA6B,EAC9B,MAAM,SAAS,CAAC;AAEjB,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAMxD,MAAM,WAAW,sBAAsB;IACrC,qEAAqE;IACrE,MAAM,EAAE,qBAAqB,CAAC;IAC9B,oDAAoD;IACpD,QAAQ,CAAC,EAAE,6BAA6B,CAAC;CAC1C;AAED,iCAAiC;AACjC,MAAM,WAAW,WAAW;IAC1B,uEAAuE;IACvE,OAAO,EAAE,OAAO,CAAC;IACjB,6BAA6B;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,+BAA+B;IAC/B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAMD;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI;IACpC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,uBAAuB,KAAK,aAAa,CAAC;IAC7E,SAAS,EAAE,MAAM,aAAa,GAAG,SAAS,CAAC;IAC3C,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC;CACjC,CAwBA;AAMD,qBAAa,sBAAsB;IACjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAwB;IAChD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAgC;IAC1D,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAA6C;gBAElE,OAAO,EAAE,sBAAsB;IAK3C;;;OAGG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,OAAO;IAsBxD;;;;OAIG;IACG,KAAK,CACT,OAAO,EAAE,sBAAsB,EAC/B,cAAc,EAAE,MAAM,EAAE,EACxB,IAAI,CAAC,EAAE,MAAM,EAAE,GACd,OAAO,CAAC,WAAW,CAAC;IAuCvB;;;OAGG;IACH,cAAc,CAAC,QAAQ,EAAE,uBAAuB,GAAG,sBAAsB,GAAG,SAAS;IAerF,kEAAkE;IAClE,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,sBAAsB,GAAG,SAAS;IAWxE,8CAA8C;IAC9C,kBAAkB,IAAI,sBAAsB,EAAE;IAc9C,sCAAsC;IACtC,IAAI,QAAQ,IAAI,6BAA6B,CAE5C;CACF"}

package/dist/mcp/channels/permissionRelay.js

@@ -0,0 +1,159 @@
+"use strict";
+/**
+ * GAP-MCPC-003: Channel Permission Relay.
+ *
+ * Routes breakpoint approval prompts through messaging channels.
+ * Uses a racing claim() pattern: channel response races against
+ * local interaction, first resolver wins.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelPermissionRelay = void 0;
+exports.createApprovalRace = createApprovalRace;
+const types_1 = require("./types");
+// ---------------------------------------------------------------------------
+// Approval claim racing
+// ---------------------------------------------------------------------------
+/**
+ * Creates a claimable approval slot.
+ * Multiple resolvers can race to claim it; only the first wins.
+ */
+function createApprovalRace() {
+    let winner;
+    let resolvePromise;
+    const promise = new Promise((resolve) => {
+        resolvePromise = resolve;
+    });
+    function claim(source, response) {
+        if (winner) {
+            return { claimed: false, source };
+        }
+        winner = { claimed: true, source, response };
+        if (resolvePromise) {
+            resolvePromise(winner);
+        }
+        return winner;
+    }
+    return {
+        claim,
+        getWinner: () => winner,
+        promise,
+    };
+}
+// ---------------------------------------------------------------------------
+// ChannelPermissionRelay
+// ---------------------------------------------------------------------------
+class ChannelPermissionRelay {
+    _sender;
+    _security;
+    _pendingRequests = new Map();
+    constructor(options) {
+        this._sender = options.sender;
+        this._security = options.security ?? types_1.DEFAULT_APPROVAL_SECURITY;
+    }
+    /**
+     * Check whether a breakpoint can be relayed through channels.
+     * Returns false for terminal-only breakpoints or when relay is disabled.
+     */
+    canRelay(breakpointId, tags) {
+        if (!this._security.enabled)
+            return false;
+        // Check terminal-only tags
+        if (tags) {
+            for (const tag of tags) {
+                if (this._security.terminalOnlyTags.includes(tag)) {
+                    return false;
+                }
+            }
+        }
+        // Check breakpoint ID prefixes for terminal-only categories
+        for (const restrictedTag of this._security.terminalOnlyTags) {
+            if (breakpointId.startsWith(`${restrictedTag}.`)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Relay a breakpoint approval request to all active channels.
+     * Returns relay result. Does NOT wait for responses — use handleResponse()
+     * to process incoming channel approvals.
+     */
+    async relay(request, channelSources, tags) {
+        if (!this.canRelay(request.breakpointId, tags)) {
+            return {
+                relayed: false,
+                reason: `Breakpoint "${request.breakpointId}" is restricted to terminal-only approval`,
+            };
+        }
+        if (channelSources.length === 0) {
+            return { relayed: false, reason: "No active channels to relay to" };
+        }
+        this._pendingRequests.set(request.requestId, request);
+        // Send to all channels
+        const template = `Breakpoint approval needed:\n**{{description}}**\nRun: {{runId}}\nOptions: {{options}}\n\nReply to approve or reject.`;
+        const templateVars = {
+            description: request.description,
+            runId: request.runId,
+            options: request.options.join(", "),
+        };
+        // formatTemplate is applied by OutboundChannelSender when both template and templateVars are present.
+        // text is set as fallback in case template rendering fails.
+        const fallbackText = `Approval needed: ${request.description} (${request.options.join(", ")})`;
+        await Promise.allSettled(channelSources.map((source) => this._sender.send({
+            channelSource: source,
+            text: fallbackText,
+            template,
+            templateVars,
+        })));
+        return { relayed: true, requestId: request.requestId };
+    }
+    /**
+     * Handle a response from a channel.
+     * Returns the matched request if it was still pending (not expired).
+     */
+    handleResponse(response) {
+        const request = this._pendingRequests.get(response.requestId);
+        if (!request)
+            return undefined;
+        // Check if the request has expired
+        const elapsed = Date.now() - new Date(request.createdAt).getTime();
+        if (elapsed > request.timeoutMs) {
+            this._pendingRequests.delete(response.requestId);
+            return undefined;
+        }
+        this._pendingRequests.delete(response.requestId);
+        return request;
+    }
+    /** Get a pending request by ID (returns undefined if expired). */
+    getPendingRequest(requestId) {
+        const request = this._pendingRequests.get(requestId);
+        if (!request)
+            return undefined;
+        const elapsed = Date.now() - new Date(request.createdAt).getTime();
+        if (elapsed > request.timeoutMs) {
+            this._pendingRequests.delete(requestId);
+            return undefined;
+        }
+        return request;
+    }
+    /** Get all pending (non-expired) requests. */
+    getPendingRequests() {
+        const now = Date.now();
+        const results = [];
+        for (const [id, request] of this._pendingRequests) {
+            const elapsed = now - new Date(request.createdAt).getTime();
+            if (elapsed > request.timeoutMs) {
+                this._pendingRequests.delete(id);
+            }
+            else {
+                results.push(request);
+            }
+        }
+        return results;
+    }
+    /** Get the security configuration. */
+    get security() {
+        return this._security;
+    }
+}
+exports.ChannelPermissionRelay = ChannelPermissionRelay;

package/dist/mcp/channels/types.d.ts

@@ -0,0 +1,135 @@
+/**
+ * GAP-MCPC-001/002/003: MCP Channel types.
+ *
+ * Defines types for messaging channels backed by MCP servers.
+ * Channels enable inbound/outbound messaging and breakpoint approval
+ * routing through external platforms (Slack, Discord, email, etc.).
+ */
+/** Channel capability declaration from an MCP server. */
+export interface ChannelCapability {
+    /** Whether the server supports channel notifications. */
+    inbound: boolean;
+    /** Whether the server supports outbound messaging tools. */
+    outbound: boolean;
+    /** Whether the server supports permission relay. */
+    permissionRelay: boolean;
+    /** Human-readable channel type (slack, discord, email, etc.). */
+    channelType?: string;
+}
+/** Configuration for a channel binding. */
+export interface ChannelConfig {
+    /** MCP server name (matches McpServerConfig.name). */
+    serverName: string;
+    /** Display name shown in notifications. */
+    displayName: string;
+    /** Channel identifier (e.g. Slack channel ID). */
+    channelId: string;
+    /** Channel type for routing. */
+    channelType: string;
+    /** Whether the channel is currently enabled. */
+    enabled: boolean;
+}
+/** A message received from a channel. */
+export interface ChannelMessage {
+    /** Unique message identifier. */
+    messageId: string;
+    /** Channel source identifier (serverName:channelId). */
+    source: string;
+    /** Sender identifier (platform-specific). */
+    sender: string;
+    /** Message content. */
+    content: string;
+    /** ISO timestamp of when the message was received. */
+    receivedAt: string;
+    /** Optional metadata from the channel platform. */
+    metadata?: Record<string, unknown>;
+}
+/** Binding of a channel to a specific run. */
+export interface ChannelBinding {
+    /** Channel source (serverName:channelId). */
+    channelSource: string;
+    /** Run ID this channel is bound to. */
+    runId: string;
+    /** ISO timestamp of when the binding was created. */
+    boundAt: string;
+}
+/** Request to send an outbound message through a channel. */
+export interface OutboundMessageRequest {
+    /** Target channel source (serverName:channelId). */
+    channelSource: string;
+    /** Message text. */
+    text: string;
+    /** Optional template name for formatting. */
+    template?: string;
+    /** Template variables for substitution. */
+    templateVars?: Record<string, string>;
+}
+/** Result of sending an outbound message. */
+export interface OutboundMessageResult {
+    success: boolean;
+    /** Platform-specific message ID if available. */
+    messageId?: string;
+    error?: string;
+}
+/** A breakpoint approval request sent to a channel. */
+export interface ChannelApprovalRequest {
+    /** Unique request identifier. */
+    requestId: string;
+    /** Breakpoint ID being approved. */
+    breakpointId: string;
+    /** Run ID. */
+    runId: string;
+    /** Effect ID. */
+    effectId: string;
+    /** Human-readable description of the breakpoint. */
+    description: string;
+    /** Options available (e.g. ["approve", "reject"]). */
+    options: string[];
+    /** ISO timestamp of when the request was created. */
+    createdAt: string;
+    /** Timeout in ms for the channel response. */
+    timeoutMs: number;
+}
+/** Response to a breakpoint approval request from a channel. */
+export interface ChannelApprovalResponse {
+    /** Request ID being responded to. */
+    requestId: string;
+    /** Whether the breakpoint was approved. */
+    approved: boolean;
+    /** Optional feedback text. */
+    feedback?: string;
+    /** Who responded (platform-specific identifier). */
+    respondedBy: string;
+    /** Which channel the response came from. */
+    channelSource: string;
+    /** ISO timestamp of the response. */
+    respondedAt: string;
+}
+/**
+ * An approval claim. Multiple resolvers race; the first to claim() wins.
+ */
+export interface ApprovalClaim {
+    /** Whether this claim was the winning one. */
+    claimed: boolean;
+    /** Source of the claim (e.g. "channel:slack:general", "local:terminal"). */
+    source: string;
+    /** The response if this claim won. */
+    response?: ChannelApprovalResponse;
+}
+/** Persisted channel allowlist. */
+export interface ChannelAllowlistFile {
+    schemaVersion: string;
+    channels: ChannelConfig[];
+}
+export declare const CHANNEL_ALLOWLIST_SCHEMA_VERSION = "2026.01.channel-allowlist-v1";
+/** Per-tag or per-level security constraints for channel approvals. */
+export interface ChannelApprovalSecurityConfig {
+    /** Tags that require terminal-only approval (no channel relay). */
+    terminalOnlyTags: string[];
+    /** Whether channel approval is enabled at all. */
+    enabled: boolean;
+    /** Default timeout for channel approval requests (ms). */
+    defaultTimeoutMs: number;
+}
+export declare const DEFAULT_APPROVAL_SECURITY: ChannelApprovalSecurityConfig;
+//# sourceMappingURL=types.d.ts.map

package/dist/mcp/channels/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/mcp/channels/types.ts"],"names":[],"mappings":"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"}

package/dist/mcp/channels/types.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * GAP-MCPC-001/002/003: MCP Channel types.
+ *
+ * Defines types for messaging channels backed by MCP servers.
+ * Channels enable inbound/outbound messaging and breakpoint approval
+ * routing through external platforms (Slack, Discord, email, etc.).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_APPROVAL_SECURITY = exports.CHANNEL_ALLOWLIST_SCHEMA_VERSION = void 0;
+exports.CHANNEL_ALLOWLIST_SCHEMA_VERSION = "2026.01.channel-allowlist-v1";
+exports.DEFAULT_APPROVAL_SECURITY = {
+    terminalOnlyTags: ["destroy", "auth", "credential"],
+    enabled: false,
+    defaultTimeoutMs: 300_000, // 5 minutes
+};

package/dist/mcp/client/config.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Status: Integrated with agent-platform MCP orchestration wiring.
+ * Moved from @a5c-ai/babysitter-sdk.
+ * GAP-REMOTE-006: MCP server configuration persistence.
+ *
+ * Read/write/merge server configurations from mcp-servers.json.
+ * Uses the same atomic temp-file + rename pattern as session modules.
+ */
+import type { McpServerConfig, McpServersFile } from "./types";
+/** Resolve the path to mcp-servers.json within a state directory. */
+export declare function getMcpServersConfigPath(stateDir: string): string;
+/** Read server configurations. Returns empty list on missing/corrupt file. */
+export declare function readMcpServersConfig(stateDir: string): Promise<McpServersFile>;
+/** Write server configurations atomically. */
+export declare function writeMcpServersConfig(stateDir: string, config: McpServersFile): Promise<void>;
+/**
+ * Add or update a server configuration.
+ * If a server with the same name exists, it is replaced.
+ */
+export declare function upsertServerConfig(stateDir: string, server: McpServerConfig): Promise<McpServersFile>;
+/** Remove a server configuration by name. Returns true if removed. */
+export declare function removeServerConfig(stateDir: string, serverName: string): Promise<boolean>;
+/**
+ * Merge an array of server configs into the existing configuration.
+ * Servers with matching names are replaced; new ones are appended.
+ */
+export declare function mergeMcpServersConfig(stateDir: string, incoming: McpServerConfig[]): Promise<McpServersFile>;
+//# sourceMappingURL=config.d.ts.map

package/dist/mcp/client/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/mcp/client/config.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAe/D,qEAAqE;AACrE,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEhE;AAED,8EAA8E;AAC9E,wBAAsB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAqBpF;AAED,8CAA8C;AAC9C,wBAAsB,qBAAqB,CACzC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,cAAc,GACrB,OAAO,CAAC,IAAI,CAAC,CAOf;AAED;;;GAGG;AACH,wBAAsB,kBAAkB,CACtC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,eAAe,GACtB,OAAO,CAAC,cAAc,CAAC,CAUzB;AAED,sEAAsE;AACtE,wBAAsB,kBAAkB,CACtC,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,OAAO,CAAC,CAOlB;AAED;;;GAGG;AACH,wBAAsB,qBAAqB,CACzC,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,eAAe,EAAE,GAC1B,OAAO,CAAC,cAAc,CAAC,CAYzB"}

package/dist/mcp/client/config.js

@@ -0,0 +1,144 @@
+"use strict";
+/**
+ * Status: Integrated with agent-platform MCP orchestration wiring.
+ * Moved from @a5c-ai/babysitter-sdk.
+ * GAP-REMOTE-006: MCP server configuration persistence.
+ *
+ * Read/write/merge server configurations from mcp-servers.json.
+ * Uses the same atomic temp-file + rename pattern as session modules.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMcpServersConfigPath = getMcpServersConfigPath;
+exports.readMcpServersConfig = readMcpServersConfig;
+exports.writeMcpServersConfig = writeMcpServersConfig;
+exports.upsertServerConfig = upsertServerConfig;
+exports.removeServerConfig = removeServerConfig;
+exports.mergeMcpServersConfig = mergeMcpServersConfig;
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+const types_1 = require("./types");
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function emptyServersFile() {
+    return { schemaVersion: types_1.MCP_SERVERS_SCHEMA_VERSION, servers: [] };
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/** Resolve the path to mcp-servers.json within a state directory. */
+function getMcpServersConfigPath(stateDir) {
+    return path.join(stateDir, "mcp-servers.json");
+}
+/** Read server configurations. Returns empty list on missing/corrupt file. */
+async function readMcpServersConfig(stateDir) {
+    const filePath = getMcpServersConfigPath(stateDir);
+    let raw;
+    try {
+        raw = await node_fs_1.promises.readFile(filePath, "utf8");
+    }
+    catch (error) {
+        const err = error;
+        if (err.code === "ENOENT")
+            return emptyServersFile();
+        process.stderr.write(`[babysitter] MCP config read error (${err.code}): ${filePath}\n`);
+        return emptyServersFile();
+    }
+    try {
+        const data = JSON.parse(raw);
+        return {
+            schemaVersion: typeof data.schemaVersion === "string" ? data.schemaVersion : types_1.MCP_SERVERS_SCHEMA_VERSION,
+            servers: Array.isArray(data.servers) ? data.servers : [],
+        };
+    }
+    catch (e) {
+        process.stderr.write(`[babysitter] MCP config parse error: ${filePath}: ${e instanceof Error ? e.message : String(e)}\n`);
+        return emptyServersFile();
+    }
+}
+/** Write server configurations atomically. */
+async function writeMcpServersConfig(stateDir, config) {
+    const filePath = getMcpServersConfigPath(stateDir);
+    const dir = path.dirname(filePath);
+    const tempPath = `${filePath}.tmp.${process.pid}`;
+    await node_fs_1.promises.mkdir(dir, { recursive: true });
+    await node_fs_1.promises.writeFile(tempPath, JSON.stringify(config, null, 2), "utf8");
+    await node_fs_1.promises.rename(tempPath, filePath);
+}
+/**
+ * Add or update a server configuration.
+ * If a server with the same name exists, it is replaced.
+ */
+async function upsertServerConfig(stateDir, server) {
+    const config = await readMcpServersConfig(stateDir);
+    const idx = config.servers.findIndex((s) => s.name === server.name);
+    if (idx >= 0) {
+        config.servers[idx] = server;
+    }
+    else {
+        config.servers.push(server);
+    }
+    await writeMcpServersConfig(stateDir, config);
+    return config;
+}
+/** Remove a server configuration by name. Returns true if removed. */
+async function removeServerConfig(stateDir, serverName) {
+    const config = await readMcpServersConfig(stateDir);
+    const before = config.servers.length;
+    config.servers = config.servers.filter((s) => s.name !== serverName);
+    if (config.servers.length === before)
+        return false;
+    await writeMcpServersConfig(stateDir, config);
+    return true;
+}
+/**
+ * Merge an array of server configs into the existing configuration.
+ * Servers with matching names are replaced; new ones are appended.
+ */
+async function mergeMcpServersConfig(stateDir, incoming) {
+    const config = await readMcpServersConfig(stateDir);
+    for (const server of incoming) {
+        const idx = config.servers.findIndex((s) => s.name === server.name);
+        if (idx >= 0) {
+            config.servers[idx] = server;
+        }
+        else {
+            config.servers.push(server);
+        }
+    }
+    await writeMcpServersConfig(stateDir, config);
+    return config;
+}