@agent-deck/backend 1.1.0

package/dist/mcp-server.js

@@ -0,0 +1,1121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentDeckMCPServer = void 0;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+const shared_1 = require("@agent-deck/shared");
+const express_1 = __importDefault(require("express"));
+const node_crypto_1 = require("node:crypto");
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const zod_1 = require("zod");
+const repo_deck_1 = require("./scope/repo-deck");
+const shared_2 = require("@agent-deck/shared");
+const version_1 = require("./lib/version");
+const agentClientHeaders = {
+    [shared_1.AGENT_DECK_CLIENT_HEADER]: shared_1.AGENT_DECK_AGENT_CLIENT,
+    Accept: 'application/json',
+};
+class AgentDeckMCPServer {
+    port;
+    server;
+    transport;
+    app;
+    backendUrl;
+    /** Workspace root per MCP session → resolves `.agent-deck/deck.yaml`. */
+    workspaceBySession = new Map();
+    activeSessionId;
+    constructor(port = 3001, backendUrl = 'http://localhost:8000') {
+        this.port = port;
+        this.backendUrl = backendUrl;
+        // Create Express app
+        this.app = (0, express_1.default)();
+        this.app.use(express_1.default.json());
+        // Create MCP server with official SDK
+        this.server = new mcp_js_1.McpServer({
+            name: "agent-deck-server",
+            version: (0, version_1.getAgentDeckVersion)(),
+        });
+        // Create HTTP transport
+        this.transport = new streamableHttp_js_1.StreamableHTTPServerTransport({
+            sessionIdGenerator: () => (0, node_crypto_1.randomUUID)(),
+            enableJsonResponse: true
+        });
+        this.setupTools();
+        this.setupResources();
+        this.setupRoutes();
+        const envWorkspace = process.env.AGENT_DECK_WORKSPACE?.trim();
+        if (envWorkspace) {
+            this.workspaceBySession.set('default', envWorkspace);
+        }
+    }
+    getSessionId() {
+        return this.activeSessionId ?? 'default';
+    }
+    getBoundWorkspace() {
+        const sessionId = this.getSessionId();
+        return this.workspaceBySession.get(sessionId) ?? process.env.AGENT_DECK_WORKSPACE?.trim();
+    }
+    getAgentHeaders() {
+        const workspace = this.getBoundWorkspace();
+        return {
+            ...agentClientHeaders,
+            ...(workspace ? { [shared_1.AGENT_DECK_WORKSPACE_HEADER]: workspace } : {}),
+        };
+    }
+    async callBackendAPI(endpoint, init = {}) {
+        try {
+            const response = await fetch(`${this.backendUrl}${endpoint}`, {
+                ...init,
+                headers: {
+                    ...this.getAgentHeaders(),
+                    ...(init.headers ?? {}),
+                },
+            });
+            if (!response.ok) {
+                const text = await response.text();
+                let message = `Backend API error: ${response.status} ${response.statusText}`;
+                try {
+                    const body = JSON.parse(text);
+                    if (body.error)
+                        message = String(body.error);
+                }
+                catch {
+                    if (text.trim())
+                        message = text;
+                }
+                throw new Error(message);
+            }
+            const body = await response.json();
+            // Unwrap ApiResponse shape { success, data?, error? }
+            if (typeof body === 'object' && body !== null && 'success' in body) {
+                if (body.success) {
+                    // Some endpoints return the raw data (legacy); fallback to body if data missing
+                    return 'data' in body ? body.data : body;
+                }
+                const message = 'error' in body ? body.error : 'Unknown backend error';
+                throw new Error(String(message));
+            }
+            // Fallback: return as-is if not wrapped
+            return body;
+        }
+        catch (error) {
+            console.error(`Failed to call backend API ${endpoint}:`, error);
+            throw error;
+        }
+    }
+    async getBoundDeckId() {
+        const deck = await this.callBackendAPI('/api/scope/deck');
+        if (!deck?.id) {
+            throw new Error('No bound deck — call bind_workspace or setup_repo_deck first');
+        }
+        return deck.id;
+    }
+    toolResult(data) {
+        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    }
+    toolError(error) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }] };
+    }
+    setupTools() {
+        this.server.registerTool("bind_workspace", {
+            title: "Bind Workspace",
+            description: "Bind an MCP session to a repo workspace root. Reads .agent-deck/deck.yaml to resolve the deck for this project.",
+            inputSchema: { workspaceRoot: zod_1.z.string() },
+        }, async ({ workspaceRoot }) => {
+            try {
+                const sessionId = this.getSessionId();
+                this.workspaceBySession.set(sessionId, workspaceRoot);
+                const resolved = await fetch(`${this.backendUrl}/api/scope/resolve`, {
+                    method: 'POST',
+                    headers: { ...agentClientHeaders, 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ workspaceRoot }),
+                });
+                const body = (await resolved.json());
+                if (!body.success || !body.data) {
+                    throw new Error(body.error ?? 'Failed to resolve workspace deck');
+                }
+                const { data } = body;
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                workspaceRoot,
+                                manifestPath: data.manifestPath,
+                                deck_id: data.manifest.deck_id,
+                                deck_name: data.deck.name,
+                            }, null, 2),
+                        }],
+                };
+            }
+            catch (error) {
+                const message = String(error);
+                const hint = message.includes('deck.yaml')
+                    ? ' Call setup_repo_deck with workspaceRoot and deckId to create .agent-deck/deck.yaml, or get_repo_deck_status to diagnose.'
+                    : '';
+                return {
+                    content: [{ type: "text", text: JSON.stringify({ error: message + hint }, null, 2) }],
+                };
+            }
+        });
+        this.server.registerTool("get_repo_deck_status", {
+            title: "Get Repo Deck Status",
+            description: "Check whether .agent-deck/deck.yaml exists in a workspace and whether it links to a valid deck",
+            inputSchema: { workspaceRoot: zod_1.z.string() },
+        }, async ({ workspaceRoot }) => {
+            try {
+                const filePath = (0, repo_deck_1.repoDeckManifestFilePath)(workspaceRoot);
+                const manifest = await (0, repo_deck_1.loadRepoDeckManifest)(workspaceRoot);
+                if (!manifest) {
+                    const decks = await this.callBackendAPI('/api/decks');
+                    return {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify({
+                                    status: 'missing',
+                                    workspaceRoot,
+                                    expectedPath: shared_2.REPO_DECK_MANIFEST_PATH,
+                                    message: 'No .agent-deck/deck.yaml found. Use setup_repo_deck to create one.',
+                                    availableDecks: Array.isArray(decks)
+                                        ? decks.map((d) => ({ id: d.id, name: d.name }))
+                                        : decks,
+                                }, null, 2),
+                            }],
+                    };
+                }
+                const resolved = await fetch(`${this.backendUrl}/api/scope/resolve`, {
+                    method: 'POST',
+                    headers: { ...agentClientHeaders, 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ workspaceRoot }),
+                });
+                const body = (await resolved.json());
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                status: body.success ? 'ok' : 'invalid',
+                                workspaceRoot,
+                                filePath,
+                                manifest,
+                                deck: body.data?.deck,
+                                error: body.success ? undefined : body.error,
+                            }, null, 2),
+                        }],
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }],
+                };
+            }
+        });
+        this.server.registerTool("setup_repo_deck", {
+            title: "Setup Repo Deck",
+            description: "Create or verify .agent-deck/deck.yaml in a repo. Links the workspace to an Agent Deck by deck_id. Optionally writes the file.",
+            inputSchema: {
+                workspaceRoot: zod_1.z.string(),
+                deckId: zod_1.z.string().uuid().optional(),
+                deckName: zod_1.z.string().optional(),
+                writeFile: zod_1.z.boolean().optional(),
+            },
+        }, async ({ workspaceRoot, deckId, deckName, writeFile = true }) => {
+            try {
+                const sessionId = this.getSessionId();
+                const existing = await (0, repo_deck_1.loadRepoDeckManifest)(workspaceRoot);
+                if (existing) {
+                    this.workspaceBySession.set(sessionId, workspaceRoot);
+                    const resolved = await fetch(`${this.backendUrl}/api/scope/resolve`, {
+                        method: 'POST',
+                        headers: { ...agentClientHeaders, 'Content-Type': 'application/json' },
+                        body: JSON.stringify({ workspaceRoot }),
+                    });
+                    const body = (await resolved.json());
+                    if (!body.success || !body.data) {
+                        throw new Error(body.error ?? 'Existing manifest is invalid');
+                    }
+                    return {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify({
+                                    status: 'existing',
+                                    workspaceRoot,
+                                    manifestPath: body.data.manifestPath,
+                                    deck_id: body.data.manifest.deck_id,
+                                    deck_name: body.data.deck.name,
+                                    message: 'Workspace already linked. Session bound to this deck.',
+                                }, null, 2),
+                            }],
+                    };
+                }
+                if (!deckId) {
+                    const decks = await this.callBackendAPI('/api/decks');
+                    return {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify({
+                                    status: 'needs_deck_id',
+                                    workspaceRoot,
+                                    expectedPath: shared_2.REPO_DECK_MANIFEST_PATH,
+                                    message: 'Pick a deck id from the dashboard (My Decks → copy icon) and call setup_repo_deck again with deckId.',
+                                    availableDecks: Array.isArray(decks)
+                                        ? decks.map((d) => ({ id: d.id, name: d.name }))
+                                        : decks,
+                                }, null, 2),
+                            }],
+                    };
+                }
+                const deck = await this.callBackendAPI(`/api/decks/${deckId}`);
+                if (!deck?.id) {
+                    throw new Error(`Deck not found: ${deckId}`);
+                }
+                const content = (0, repo_deck_1.formatRepoDeckManifest)(deckId, deckName ?? deck.name);
+                const dirPath = node_path_1.default.join(node_path_1.default.resolve(workspaceRoot), '.agent-deck');
+                const filePath = (0, repo_deck_1.repoDeckManifestFilePath)(workspaceRoot);
+                if (writeFile) {
+                    await promises_1.default.mkdir(dirPath, { recursive: true });
+                    await promises_1.default.writeFile(filePath, content, 'utf8');
+                }
+                this.workspaceBySession.set(sessionId, workspaceRoot);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                status: writeFile ? 'created' : 'preview',
+                                workspaceRoot,
+                                filePath,
+                                deck_id: deckId,
+                                deck_name: deck.name,
+                                manifestContent: content,
+                                message: writeFile
+                                    ? 'Created .agent-deck/deck.yaml and bound this session to the deck.'
+                                    : 'Preview only — set writeFile true to write the file.',
+                            }, null, 2),
+                        }],
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }],
+                };
+            }
+        });
+        // Get all decks (metadata only; credentials stripped unless bound)
+        this.server.registerTool("get_decks", {
+            title: "Get Decks",
+            description: "Get all available decks from Agent Deck",
+            inputSchema: {}
+        }, async () => {
+            try {
+                const decks = await this.callBackendAPI('/api/decks');
+                return {
+                    content: [{ type: "text", text: JSON.stringify(decks, null, 2) }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }]
+                };
+            }
+        });
+        this.server.registerTool("get_bound_deck", {
+            title: "Get Bound Deck",
+            description: "Get the deck bound to this session via bind_workspace or AGENT_DECK_WORKSPACE (.agent-deck/deck.yaml)",
+            inputSchema: {},
+        }, async () => {
+            try {
+                const deck = await this.callBackendAPI('/api/scope/deck');
+                return {
+                    content: [{ type: "text", text: JSON.stringify(deck, null, 2) }],
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }],
+                };
+            }
+        });
+        // Deprecated alias
+        this.server.registerTool("get_active_deck", {
+            title: "Get Active Deck (deprecated)",
+            description: "Deprecated — use get_bound_deck. Returns the workspace-bound deck.",
+            inputSchema: {},
+        }, async () => {
+            try {
+                const deck = await this.callBackendAPI('/api/scope/deck');
+                return {
+                    content: [{ type: "text", text: JSON.stringify(deck, null, 2) }],
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }],
+                };
+            }
+        });
+        this.server.registerTool("list_bound_deck_services", {
+            title: "List Bound Deck Services",
+            description: "List MCP services on the workspace-bound deck",
+            inputSchema: {},
+        }, async () => {
+            try {
+                const deck = await this.callBackendAPI('/api/scope/deck');
+                const services = deck?.services ?? [];
+                return { content: [{ type: "text", text: JSON.stringify(services, null, 2) }] };
+            }
+            catch (error) {
+                return { content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }] };
+            }
+        });
+        this.server.registerTool("list_active_deck_services", {
+            title: "List Active Deck Services (deprecated)",
+            description: "Deprecated — use list_bound_deck_services",
+            inputSchema: {},
+        }, async () => {
+            try {
+                const deck = await this.callBackendAPI('/api/scope/deck');
+                const services = deck?.services ?? [];
+                return { content: [{ type: "text", text: JSON.stringify(services, null, 2) }] };
+            }
+            catch (error) {
+                return { content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }] };
+            }
+        });
+        this.server.registerTool("list_bound_deck_credentials", {
+            title: "List Bound Deck Credentials",
+            description: "List API key metadata on the workspace-bound deck",
+            inputSchema: {},
+        }, async () => {
+            try {
+                const credentials = await this.callBackendAPI('/api/credentials');
+                return { content: [{ type: "text", text: JSON.stringify(credentials, null, 2) }] };
+            }
+            catch (error) {
+                return { content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }] };
+            }
+        });
+        this.server.registerTool("list_active_deck_credentials", {
+            title: "List Active Deck Credentials (deprecated)",
+            description: "Deprecated — use list_bound_deck_credentials",
+            inputSchema: {},
+        }, async () => {
+            try {
+                const credentials = await this.callBackendAPI('/api/credentials');
+                return { content: [{ type: "text", text: JSON.stringify(credentials, null, 2) }] };
+            }
+            catch (error) {
+                return { content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }] };
+            }
+        });
+        this.server.registerTool("list_playbooks", {
+            title: "List Playbooks",
+            description: "List playbook cards on the bound deck (id, title, triggers)",
+            inputSchema: {},
+        }, async () => {
+            try {
+                const playbooks = await this.callBackendAPI('/api/playbooks/summaries');
+                return { content: [{ type: "text", text: JSON.stringify(playbooks, null, 2) }] };
+            }
+            catch (error) {
+                return { content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }] };
+            }
+        });
+        this.server.registerTool("get_playbook", {
+            title: "Get Playbook",
+            description: "Get full markdown body, metadata, and dependencies for a playbook card by id",
+            inputSchema: { playbook_id: zod_1.z.string() },
+        }, async ({ playbook_id }) => {
+            try {
+                const playbook = await this.callBackendAPI(`/api/playbooks/${encodeURIComponent(playbook_id)}`);
+                return { content: [{ type: "text", text: JSON.stringify(playbook, null, 2) }] };
+            }
+            catch (error) {
+                return { content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }] };
+            }
+        });
+        this.server.registerTool("register_playbook", {
+            title: "Register Playbook",
+            description: "Create a playbook card, auto-detect API key and MCP dependencies from the content, and add it to the bound deck by default",
+            inputSchema: {
+                title: zod_1.z.string(),
+                body: zod_1.z.string(),
+                triggers: zod_1.z.array(zod_1.z.string()).optional(),
+                playbook_id: zod_1.z.string().optional(),
+                exec: zod_1.z.string().optional(),
+                skill: zod_1.z.string().optional(),
+                depends_on_credential_ids: zod_1.z.array(zod_1.z.string()).optional(),
+                depends_on_service_ids: zod_1.z.array(zod_1.z.string()).optional(),
+                add_to_bound_deck: zod_1.z.boolean().optional(),
+                auto_detect_dependencies: zod_1.z.boolean().optional(),
+            },
+        }, async (args) => {
+            try {
+                const playbook = await this.callBackendAPI("/api/playbooks", {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({
+                        title: args.title,
+                        body: args.body,
+                        triggers: args.triggers,
+                        id: args.playbook_id,
+                        exec: args.exec,
+                        skill: args.skill,
+                        dependsOnCredentialIds: args.depends_on_credential_ids,
+                        dependsOnServiceIds: args.depends_on_service_ids,
+                        addToBoundDeck: args.add_to_bound_deck,
+                        autoDetectDependencies: args.auto_detect_dependencies,
+                    }),
+                });
+                return { content: [{ type: "text", text: JSON.stringify(playbook, null, 2) }] };
+            }
+            catch (error) {
+                return { content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }] };
+            }
+        });
+        this.server.registerTool("update_playbook", {
+            title: "Update Playbook",
+            description: "Update a playbook on the bound deck. Dependencies are re-detected from the updated content by default.",
+            inputSchema: {
+                playbook_id: zod_1.z.string(),
+                title: zod_1.z.string().optional(),
+                body: zod_1.z.string().optional(),
+                triggers: zod_1.z.array(zod_1.z.string()).optional(),
+                exec: zod_1.z.string().optional(),
+                skill: zod_1.z.string().optional(),
+                depends_on_credential_ids: zod_1.z.array(zod_1.z.string()).optional(),
+                depends_on_service_ids: zod_1.z.array(zod_1.z.string()).optional(),
+                auto_detect_dependencies: zod_1.z.boolean().optional(),
+            },
+        }, async ({ playbook_id, ...args }) => {
+            try {
+                const playbook = await this.callBackendAPI(`/api/playbooks/${encodeURIComponent(playbook_id)}`, {
+                    method: "PUT",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({
+                        title: args.title,
+                        body: args.body,
+                        triggers: args.triggers,
+                        exec: args.exec,
+                        skill: args.skill,
+                        dependsOnCredentialIds: args.depends_on_credential_ids,
+                        dependsOnServiceIds: args.depends_on_service_ids,
+                        autoDetectDependencies: args.auto_detect_dependencies,
+                    }),
+                });
+                return { content: [{ type: "text", text: JSON.stringify(playbook, null, 2) }] };
+            }
+            catch (error) {
+                return { content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }] };
+            }
+        });
+        this.server.registerTool("list_collection_services", {
+            title: "List Collection Services",
+            description: "List all registered MCP services in the collection (metadata only)",
+            inputSchema: {},
+        }, async () => {
+            try {
+                const services = await this.callBackendAPI('/api/services');
+                return this.toolResult(services);
+            }
+            catch (error) {
+                return this.toolError(error);
+            }
+        });
+        this.server.registerTool("register_service", {
+            title: "Register Service",
+            description: "Register an MCP service in the collection. Optionally add it to the bound deck. OAuth setup still requires the dashboard browser flow.",
+            inputSchema: {
+                name: zod_1.z.string(),
+                type: zod_1.z.enum(['mcp', 'a2a', 'local-mcp']),
+                url: zod_1.z.string(),
+                description: zod_1.z.string().optional(),
+                cardColor: zod_1.z.string().optional(),
+                credentialId: zod_1.z.string().optional(),
+                headers: zod_1.z.record(zod_1.z.string()).optional(),
+                localCommand: zod_1.z.string().optional(),
+                localArgs: zod_1.z.array(zod_1.z.string()).optional(),
+                localWorkingDir: zod_1.z.string().optional(),
+                localEnv: zod_1.z.record(zod_1.z.string()).optional(),
+                add_to_bound_deck: zod_1.z.boolean().optional(),
+                position: zod_1.z.number().optional(),
+            },
+        }, async (args) => {
+            try {
+                const { add_to_bound_deck, position, ...serviceInput } = args;
+                const service = await this.callBackendAPI('/api/services', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(serviceInput),
+                });
+                if (add_to_bound_deck !== false) {
+                    const deckId = await this.getBoundDeckId();
+                    await this.callBackendAPI(`/api/decks/${deckId}/services`, {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({ serviceId: service.id, position }),
+                    });
+                }
+                return this.toolResult(service);
+            }
+            catch (error) {
+                return this.toolError(error);
+            }
+        });
+        this.server.registerTool("update_service", {
+            title: "Update Service",
+            description: "Update MCP service metadata in the collection (not OAuth tokens — use dashboard for OAuth)",
+            inputSchema: {
+                service_id: zod_1.z.string(),
+                name: zod_1.z.string().optional(),
+                type: zod_1.z.enum(['mcp', 'a2a', 'local-mcp']).optional(),
+                url: zod_1.z.string().optional(),
+                description: zod_1.z.string().optional(),
+                cardColor: zod_1.z.string().optional(),
+                credentialId: zod_1.z.string().optional(),
+                headers: zod_1.z.record(zod_1.z.string()).optional(),
+                localCommand: zod_1.z.string().optional(),
+                localArgs: zod_1.z.array(zod_1.z.string()).optional(),
+                localWorkingDir: zod_1.z.string().optional(),
+                localEnv: zod_1.z.record(zod_1.z.string()).optional(),
+            },
+        }, async ({ service_id, ...updates }) => {
+            try {
+                const service = await this.callBackendAPI(`/api/services/${service_id}`, {
+                    method: 'PUT',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(updates),
+                });
+                return this.toolResult(service);
+            }
+            catch (error) {
+                return this.toolError(error);
+            }
+        });
+        this.server.registerTool("delete_service", {
+            title: "Delete Service",
+            description: "Remove an MCP service from the collection entirely",
+            inputSchema: { service_id: zod_1.z.string() },
+        }, async ({ service_id }) => {
+            try {
+                await this.callBackendAPI(`/api/services/${service_id}`, { method: 'DELETE' });
+                return this.toolResult({ success: true, service_id });
+            }
+            catch (error) {
+                return this.toolError(error);
+            }
+        });
+        this.server.registerTool("add_service_to_bound_deck", {
+            title: "Add Service To Bound Deck",
+            description: "Link an existing MCP service from the collection onto the bound deck",
+            inputSchema: {
+                service_id: zod_1.z.string(),
+                position: zod_1.z.number().optional(),
+            },
+        }, async ({ service_id, position }) => {
+            try {
+                const deckId = await this.getBoundDeckId();
+                await this.callBackendAPI(`/api/decks/${deckId}/services`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ serviceId: service_id, position }),
+                });
+                return this.toolResult({ success: true, deck_id: deckId, service_id });
+            }
+            catch (error) {
+                return this.toolError(error);
+            }
+        });
+        this.server.registerTool("remove_service_from_bound_deck", {
+            title: "Remove Service From Bound Deck",
+            description: "Unlink an MCP service from the bound deck (service stays in the collection)",
+            inputSchema: { service_id: zod_1.z.string() },
+        }, async ({ service_id }) => {
+            try {
+                const deckId = await this.getBoundDeckId();
+                await this.callBackendAPI(`/api/decks/${deckId}/services`, {
+                    method: 'DELETE',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ serviceId: service_id }),
+                });
+                return this.toolResult({ success: true, deck_id: deckId, service_id });
+            }
+            catch (error) {
+                return this.toolError(error);
+            }
+        });
+        this.server.registerTool("update_service_tool_settings", {
+            title: "Update Service Tool Settings",
+            description: "Enable or disable individual tools for an MCP service on the bound deck",
+            inputSchema: {
+                service_id: zod_1.z.string(),
+                disabled_tools: zod_1.z.array(zod_1.z.string()),
+            },
+        }, async ({ service_id, disabled_tools }) => {
+            try {
+                const service = await this.callBackendAPI(`/api/services/${service_id}/tool-settings`, {
+                    method: 'PUT',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ disabledTools: disabled_tools }),
+                });
+                return this.toolResult(service);
+            }
+            catch (error) {
+                return this.toolError(error);
+            }
+        });
+        this.server.registerTool("list_collection_credentials", {
+            title: "List Collection Credentials",
+            description: "List all API key metadata in the collection (no secret values). Use credential ids to link keys to the bound deck after the user stores the secret in the dashboard.",
+            inputSchema: {},
+        }, async () => {
+            try {
+                const credentials = await this.callBackendAPI('/api/credentials/collection');
+                return this.toolResult(credentials);
+            }
+            catch (error) {
+                return this.toolError(error);
+            }
+        });
+        this.server.registerTool("add_credential_to_bound_deck", {
+            title: "Add Credential To Bound Deck",
+            description: "Link an existing API key (by credential id) to the bound deck. The secret must already be stored via the dashboard or CLI.",
+            inputSchema: {
+                credential_id: zod_1.z.string(),
+                position: zod_1.z.number().optional(),
+            },
+        }, async ({ credential_id, position }) => {
+            try {
+                const deckId = await this.getBoundDeckId();
+                await this.callBackendAPI(`/api/decks/${deckId}/credentials`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ credentialId: credential_id, position }),
+                });
+                return this.toolResult({ success: true, deck_id: deckId, credential_id });
+            }
+            catch (error) {
+                return this.toolError(error);
+            }
+        });
+        this.server.registerTool("remove_credential_from_bound_deck", {
+            title: "Remove Credential From Bound Deck",
+            description: "Unlink an API key from the bound deck (credential stays in the vault)",
+            inputSchema: { credential_id: zod_1.z.string() },
+        }, async ({ credential_id }) => {
+            try {
+                const deckId = await this.getBoundDeckId();
+                await this.callBackendAPI(`/api/decks/${deckId}/credentials`, {
+                    method: 'DELETE',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ credentialId: credential_id }),
+                });
+                return this.toolResult({ success: true, deck_id: deckId, credential_id });
+            }
+            catch (error) {
+                return this.toolError(error);
+            }
+        });
+        this.server.registerTool("list_collection_playbooks", {
+            title: "List Collection Playbooks",
+            description: "List all playbook cards in the collection (for linking existing playbooks to the bound deck)",
+            inputSchema: {},
+        }, async () => {
+            try {
+                const playbooks = await this.callBackendAPI('/api/playbooks/collection');
+                return this.toolResult(playbooks);
+            }
+            catch (error) {
+                return this.toolError(error);
+            }
+        });
+        this.server.registerTool("add_playbook_to_bound_deck", {
+            title: "Add Playbook To Bound Deck",
+            description: "Link an existing playbook card from the collection onto the bound deck",
+            inputSchema: {
+                playbook_id: zod_1.z.string(),
+                position: zod_1.z.number().optional(),
+            },
+        }, async ({ playbook_id, position }) => {
+            try {
+                const deckId = await this.getBoundDeckId();
+                await this.callBackendAPI(`/api/decks/${deckId}/playbooks`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ playbookId: playbook_id, position }),
+                });
+                return this.toolResult({ success: true, deck_id: deckId, playbook_id });
+            }
+            catch (error) {
+                return this.toolError(error);
+            }
+        });
+        this.server.registerTool("remove_playbook_from_bound_deck", {
+            title: "Remove Playbook From Bound Deck",
+            description: "Unlink a playbook from the bound deck (playbook stays in the collection)",
+            inputSchema: { playbook_id: zod_1.z.string() },
+        }, async ({ playbook_id }) => {
+            try {
+                const deckId = await this.getBoundDeckId();
+                await this.callBackendAPI(`/api/decks/${deckId}/playbooks`, {
+                    method: 'DELETE',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ playbookId: playbook_id }),
+                });
+                return this.toolResult({ success: true, deck_id: deckId, playbook_id });
+            }
+            catch (error) {
+                return this.toolError(error);
+            }
+        });
+        this.server.registerTool("delete_playbook", {
+            title: "Delete Playbook",
+            description: "Delete a playbook from the collection (must be on the bound deck for agent clients)",
+            inputSchema: { playbook_id: zod_1.z.string() },
+        }, async ({ playbook_id }) => {
+            try {
+                await this.callBackendAPI(`/api/playbooks/${encodeURIComponent(playbook_id)}`, {
+                    method: 'DELETE',
+                });
+                return this.toolResult({ success: true, playbook_id });
+            }
+            catch (error) {
+                return this.toolError(error);
+            }
+        });
+        this.server.registerTool("create_deck", {
+            title: "Create Deck",
+            description: "Create a new deck in Agent Deck",
+            inputSchema: {
+                name: zod_1.z.string(),
+                description: zod_1.z.string().optional(),
+            },
+        }, async ({ name, description }) => {
+            try {
+                const deck = await this.callBackendAPI('/api/decks', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ name, description }),
+                });
+                return this.toolResult(deck);
+            }
+            catch (error) {
+                return this.toolError(error);
+            }
+        });
+        // Remove duplicate old tools block - list_service_tools follows
+        this.server.registerTool("list_service_tools", {
+            title: "List Service Tools",
+            description: "List all available tools for a specific service in the active deck",
+            inputSchema: { serviceId: zod_1.z.string() }
+        }, async ({ serviceId }) => {
+            try {
+                const tools = await this.callBackendAPI(`/api/services/${serviceId}/tools`);
+                return { content: [{ type: "text", text: JSON.stringify(tools, null, 2) }] };
+            }
+            catch (error) {
+                return { content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }] };
+            }
+        });
+        // Call a tool on a service in the active deck
+        this.server.registerTool("call_service_tool", {
+            title: "Call Service Tool",
+            description: "Call a tool on a service from the active deck",
+            inputSchema: {
+                serviceId: zod_1.z.string(),
+                toolName: zod_1.z.string(),
+                arguments: zod_1.z.union([zod_1.z.record(zod_1.z.any()), zod_1.z.string()]).optional()
+            }
+        }, async ({ serviceId, toolName, arguments: args = {} }) => {
+            try {
+                // Support both object and JSON string inputs for arguments
+                let normalizedArgs = args;
+                if (typeof normalizedArgs === 'string' && normalizedArgs.length > 0) {
+                    try {
+                        normalizedArgs = JSON.parse(normalizedArgs);
+                    }
+                    catch (e) {
+                        return { content: [{ type: "text", text: JSON.stringify({ error: `Invalid JSON in arguments: ${String(e)}` }, null, 2) }] };
+                    }
+                }
+                const res = await fetch(`${this.backendUrl}/api/services/${serviceId}/call`, {
+                    method: 'POST',
+                    headers: { ...this.getAgentHeaders(), 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ toolName, arguments: normalizedArgs ?? {} })
+                });
+                if (!res.ok) {
+                    const text = await res.text();
+                    throw new Error(`Backend API error ${res.status}: ${text}`);
+                }
+                const body = await res.json();
+                const data = (body && body.success) ? (body.data ?? body.result ?? body) : body;
+                return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+            }
+            catch (error) {
+                return { content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }] };
+            }
+        });
+    }
+    setupResources() {
+        this.server.resource("bound_deck_services", "agent-deck://bound-deck/services", {
+            name: "Bound Deck Services",
+            description: "MCP services on the workspace-bound deck",
+            mimeType: "application/json"
+        }, async () => {
+            try {
+                const deck = await this.callBackendAPI('/api/scope/deck');
+                const services = deck?.services ?? [];
+                return {
+                    contents: [{
+                            uri: "agent-deck://bound-deck/services",
+                            mimeType: "application/json",
+                            text: JSON.stringify(services, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    contents: [{
+                            uri: "agent-deck://bound-deck/services",
+                            mimeType: "application/json",
+                            text: JSON.stringify({ error: `Failed to get bound deck services: ${error}` }, null, 2)
+                        }]
+                };
+            }
+        });
+        this.server.resource("active_deck_services", "agent-deck://active-deck/services", {
+            name: "Active Deck Services (deprecated)",
+            description: "Deprecated — use agent-deck://bound-deck/services",
+            mimeType: "application/json"
+        }, async () => {
+            try {
+                const deck = await this.callBackendAPI('/api/scope/deck');
+                const services = deck?.services ?? [];
+                return {
+                    contents: [{
+                            uri: "agent-deck://active-deck/services",
+                            mimeType: "application/json",
+                            text: JSON.stringify(services, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    contents: [{
+                            uri: "agent-deck://active-deck/services",
+                            mimeType: "application/json",
+                            text: JSON.stringify({ error: `Failed to get bound deck services: ${error}` }, null, 2)
+                        }]
+                };
+            }
+        });
+        this.server.resource("bound_deck_credentials", "agent-deck://bound-deck/credentials", {
+            name: "Bound Deck Credentials",
+            description: "API key metadata on the workspace-bound deck",
+            mimeType: "application/json"
+        }, async () => {
+            try {
+                const credentials = await this.callBackendAPI('/api/credentials');
+                return {
+                    contents: [{
+                            uri: "agent-deck://bound-deck/credentials",
+                            mimeType: "application/json",
+                            text: JSON.stringify(credentials, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    contents: [{
+                            uri: "agent-deck://bound-deck/credentials",
+                            mimeType: "application/json",
+                            text: JSON.stringify({ error: `Failed to get bound deck credentials: ${error}` }, null, 2)
+                        }]
+                };
+            }
+        });
+        this.server.resource("active_deck_credentials", "agent-deck://active-deck/credentials", {
+            name: "Active Deck Credentials (deprecated)",
+            description: "Deprecated — use agent-deck://bound-deck/credentials",
+            mimeType: "application/json"
+        }, async () => {
+            try {
+                const credentials = await this.callBackendAPI('/api/credentials');
+                return {
+                    contents: [{
+                            uri: "agent-deck://active-deck/credentials",
+                            mimeType: "application/json",
+                            text: JSON.stringify(credentials, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    contents: [{
+                            uri: "agent-deck://active-deck/credentials",
+                            mimeType: "application/json",
+                            text: JSON.stringify({ error: `Failed to get bound deck credentials: ${error}` }, null, 2)
+                        }]
+                };
+            }
+        });
+        this.server.resource("bound_deck", "agent-deck://bound-deck", {
+            name: "Bound Deck",
+            description: "Deck bound via .agent-deck/deck.yaml in the workspace",
+            mimeType: "application/json"
+        }, async () => {
+            try {
+                const deck = await this.callBackendAPI('/api/scope/deck');
+                return {
+                    contents: [{
+                            uri: "agent-deck://bound-deck",
+                            mimeType: "application/json",
+                            text: JSON.stringify(deck, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    contents: [{
+                            uri: "agent-deck://bound-deck",
+                            mimeType: "application/json",
+                            text: JSON.stringify({ error: `Failed to get bound deck: ${error}` }, null, 2)
+                        }]
+                };
+            }
+        });
+        this.server.resource("active_deck", "agent-deck://active-deck", {
+            name: "Active Deck (deprecated)",
+            description: "Deprecated — use agent-deck://bound-deck",
+            mimeType: "application/json"
+        }, async () => {
+            try {
+                const deck = await this.callBackendAPI('/api/scope/deck');
+                return {
+                    contents: [{
+                            uri: "agent-deck://active-deck",
+                            mimeType: "application/json",
+                            text: JSON.stringify(deck, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    contents: [{
+                            uri: "agent-deck://active-deck",
+                            mimeType: "application/json",
+                            text: JSON.stringify({ error: `Failed to get bound deck: ${error}` }, null, 2)
+                        }]
+                };
+            }
+        });
+        // Register resource for all decks
+        this.server.resource("decks", "agent-deck://decks", {
+            name: "Agent Deck Decks",
+            description: "List of all available decks",
+            mimeType: "application/json"
+        }, async () => {
+            try {
+                const decks = await this.callBackendAPI('/api/decks');
+                return {
+                    contents: [{
+                            uri: "agent-deck://decks",
+                            mimeType: "application/json",
+                            text: JSON.stringify(decks, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    contents: [{
+                            uri: "agent-deck://decks",
+                            mimeType: "application/json",
+                            text: JSON.stringify({ error: `Failed to get decks: ${error}` }, null, 2)
+                        }]
+                };
+            }
+        });
+    }
+    setupRoutes() {
+        // Handle MCP requests
+        this.app.post('/mcp', async (req, res) => {
+            const sessionHeader = req.headers['mcp-session-id'];
+            this.activeSessionId = typeof sessionHeader === 'string' ? sessionHeader : 'default';
+            await this.transport.handleRequest(req, res, req.body);
+        });
+        // Health check endpoint
+        this.app.get('/health', (req, res) => {
+            res.json({
+                status: 'ok',
+                service: 'agent-deck-mcp-server',
+                backendUrl: this.backendUrl
+            });
+        });
+        // Backend connectivity check
+        this.app.get('/backend-status', async (req, res) => {
+            try {
+                const response = await fetch(`${this.backendUrl}/health`);
+                const backendStatus = await response.json();
+                res.json({
+                    mcpServer: 'ok',
+                    backend: backendStatus,
+                    connected: response.ok
+                });
+            }
+            catch (error) {
+                res.json({
+                    mcpServer: 'ok',
+                    backend: 'unreachable',
+                    connected: false,
+                    error: error instanceof Error ? error.message : String(error)
+                });
+            }
+        });
+    }
+    async start() {
+        try {
+            console.log(`🚀 Starting Agent Deck MCP Server on port ${this.port}...`);
+            console.log(`🔗 Backend API URL: ${this.backendUrl}`);
+            // Connect the server to the transport (this will start the transport)
+            await this.server.connect(this.transport);
+            // Start the Express server
+            this.app.listen(this.port, () => {
+                console.log(`✅ Agent Deck MCP Server is ready to accept connections`);
+                console.log(`📋 Available tools:`);
+                console.log(`   - bind_workspace: Bind session to repo via .agent-deck/deck.yaml`);
+                console.log(`   - get_repo_deck_status: Check repo deck manifest`);
+                console.log(`   - setup_repo_deck: Create .agent-deck/deck.yaml for a repo`);
+                console.log(`   - get_bound_deck: Get workspace-bound deck`);
+                console.log(`   - list_service_tools: List tools for a specific service`);
+                console.log(`   - call_service_tool: Call a tool on a service`);
+                console.log(`📋 Available resources:`);
+                console.log(`   - agent-deck://decks: List of all available decks`);
+                console.log(`   - agent-deck://active-deck: The currently active deck`);
+                console.log(`   - agent-deck://active-deck/credentials: API keys on the active deck`);
+                console.log(`   - agent-deck://active-deck/services: Services in the active deck`);
+                console.log(`🌐 Server running on http://localhost:${this.port}`);
+                console.log(`🔧 MCP endpoint: http://localhost:${this.port}/mcp`);
+                console.log(`❤️  Health check: http://localhost:${this.port}/health`);
+                console.log(`🔗 Backend status: http://localhost:${this.port}/backend-status`);
+                console.log(`📝 Architecture: MCP Server → Backend API → Active Deck Services`);
+            });
+            return this.app;
+        }
+        catch (error) {
+            console.error(`❌ Failed to start MCP server:`, error);
+            throw error;
+        }
+    }
+    async stop() {
+        try {
+            await this.transport.close();
+            console.log(`🛑 MCP server stopped`);
+        }
+        catch (error) {
+            console.error(`❌ Error stopping MCP server:`, error);
+        }
+    }
+}
+exports.AgentDeckMCPServer = AgentDeckMCPServer;
+//# sourceMappingURL=mcp-server.js.map