agent-desk-mcp 0.1.4 → 1.0.0

package/README.md

@@ -1,6 +1,6 @@
 # agent-desk-mcp
 
-npx wrapper for Agent Desk MCP Server - enables multi-agent blocking question capability with message queue management.
+MCP server for multi-agent interaction with users - enables blocking question capability with message queue management.
 
 ## Installation
 
@@ -9,6 +9,11 @@ npx wrapper for Agent Desk MCP Server - enables multi-agent blocking question ca
 npx agent-desk-mcp --api-url http://localhost:8080
 ```
 
+## Requirements
+
+- Node.js >= 18.0.0
+- API Server running (see [agent-desk](https://github.com/weidwonder/agent-desk))
+
 ## Usage
 
 ### Basic Usage
@@ -18,31 +23,21 @@ npx agent-desk-mcp --api-url http://localhost:8080
 npx agent-desk-mcp --api-url http://localhost:8080
 ```
 
-### With Custom Database
-
-```bash
-# Use custom database path
-npx agent-desk-mcp --api-url http://localhost:8080 --db-path /path/to/data.db
-```
-
-### Environment Variables
+### With Claude Desktop
 
-- `AGENT_DESK_SOURCE`: Path to agent-desk source directory (if not using installed package)
+Add to your Claude Desktop configuration:
 
-## Requirements
-
-- Node.js >= 18.0.0
-- Python >= 3.10
-- agent-desk package installed (or source available)
-
-## For Development
+```json
+{
+  "mcpServers": {
+    "agent-desk": {
+      "command": "npx",
+      "args": ["agent-desk-mcp", "--api-url", "http://localhost:8080"]
+    }
+  }
+}
+```
 
-```bash
-# Clone and link
-git clone https://github.com/weidwonder/agent-desk.git
-cd agent-desk/mcp-wrapper
-npm link
+## License
 
-# Now you can run directly
-agent-desk-mcp --api-url http://localhost:8080
-```
+MIT

package/bin/agent-desk-mcp.js

@@ -2,7 +2,7 @@
 /**
  * agent-desk-mcp
  *
- * npx wrapper for Agent Desk MCP Server
+ * MCP Server for multi-agent interaction with users
  * Usage: npx agent-desk-mcp --api-url http://localhost:8080
  */
 
@@ -10,83 +10,22 @@ const { spawn } = require('child_process');
 const path = require('path');
 const fs = require('fs');
 
-// Find Python interpreter
-function findPython() {
-  // Check for python3 first, then python
-  const candidates = ['python3', 'python'];
-
-  for (const candidate of candidates) {
-    try {
-      const result = require('child_process').execSync(`which ${candidate}`, { encoding: 'utf8' }).trim();
-      if (result) return candidate;
-    } catch (e) {
-      // Continue to next candidate
-    }
-  }
-
-  // Try common paths
-  const commonPaths = [
-    '/usr/bin/python3',
-    '/usr/local/bin/python3',
-    '/opt/homebrew/bin/python3',
-  ];
-
-  for (const p of commonPaths) {
-    if (fs.existsSync(p)) return p;
-  }
-
-  return 'python3';
-}
-
-// Find agent-desk source directory
-function findAgentDeskSource() {
-  // First check AGENT_DESK_SOURCE env variable
-  if (process.env.AGENT_DESK_SOURCE) {
-    return process.env.AGENT_DESK_SOURCE;
-  }
-
-  // Look for src/cli.py relative to this script
-  const scriptDir = path.dirname(__filename);
-  const wrapperDir = path.dirname(scriptDir);
-  const projectDir = path.dirname(wrapperDir);
-  const cliPath = path.join(projectDir, 'src', 'cli.py');
-
-  if (fs.existsSync(cliPath)) {
-    return projectDir;
-  }
-
-  // Check current working directory
-  const cwdCliPath = path.join(process.cwd(), 'src', 'cli.py');
-  if (fs.existsSync(cwdCliPath)) {
-    return process.cwd();
-  }
-
-  // Return default (assumes agent-desk is installed as a package)
-  return process.cwd();
-}
-
 function main() {
   const args = process.argv.slice(2);
-  const python = findPython();
-  const sourceDir = findAgentDeskSource();
 
-  // Build command arguments
-  const cliPath = path.join(sourceDir, 'src', 'cli.py');
-  const commandArgs = ['-m', 'src.cli', 'mcp', ...args];
+  // Find the dist/index.js
+  const scriptDir = path.dirname(__filename);
+  const distPath = path.join(scriptDir, '..', 'dist', 'index.js');
 
-  console.error(`Agent Desk MCP Server`);
-  console.error(`Python: ${python}`);
-  console.error(`Source: ${sourceDir}`);
-  console.error(`Command: ${python} ${commandArgs.join(' ')}`);
+  if (!fs.existsSync(distPath)) {
+    console.error("Error: agent-desk-mcp not built. Run 'npm install && npm run build' first.");
+    process.exit(1);
+  }
 
-  // Spawn MCP server
-  const proc = spawn(python, commandArgs, {
-    cwd: sourceDir,
+  // Spawn the server
+  const proc = spawn(process.execPath, [distPath, ...args], {
     stdio: 'inherit',
-    env: {
-      ...process.env,
-      PYTHONPATH: sourceDir,
-    },
+    env: { ...process.env },
   });
 
   proc.on('error', (err) => {
@@ -98,7 +37,6 @@ function main() {
     process.exit(code || 0);
   });
 
-  // Handle signals
   process.on('SIGINT', () => proc.kill('SIGINT'));
   process.on('SIGTERM', () => proc.kill('SIGTERM'));
 }

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,209 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import axios from "axios";
+class APIClient {
+    client;
+    constructor(baseUrl) {
+        this.client = axios.create({
+            baseURL: baseUrl.replace(/\/$/, ""),
+        });
+    }
+    async healthCheck() {
+        try {
+            const resp = await this.client.get("/api/health");
+            return resp.status === 200;
+        }
+        catch {
+            return false;
+        }
+    }
+    async addAgent(sessionId, agentSummary, context, questions, timeoutSeconds) {
+        await this.client.post("/api/agents", {
+            session_id: sessionId,
+            agent_summary: agentSummary,
+            context: context.slice(0, 1000),
+            questions,
+            timeout_seconds: timeoutSeconds,
+        });
+    }
+    async getAgent(sessionId) {
+        try {
+            const resp = await this.client.get(`/api/agents/${sessionId}`);
+            return resp.data;
+        }
+        catch (e) {
+            if (axios.isAxiosError(e) && e.response?.status === 404) {
+                return null;
+            }
+            throw e;
+        }
+    }
+}
+class AgentDeskServer {
+    server;
+    apiClient = null;
+    apiUrl;
+    constructor(apiUrl) {
+        this.apiUrl = apiUrl;
+        this.server = new Server({
+            name: "agent-desk",
+            version: "1.0.0",
+        });
+        this.setupHandlers();
+    }
+    setupHandlers() {
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+            return {
+                tools: [
+                    {
+                        name: "ask_user",
+                        description: `Ask user questions, block and wait for answer.
+
+Arguments:
+- agent_summary: Brief summary of your role/identity.
+- context: Brief context (max 1000 chars) explaining why you are asking these questions.
+- questions: List of questions with id, content, and optional options.
+- timeout_seconds: Timeout in seconds. None means no timeout.
+
+Returns: User's answers concatenated with newlines, or timeout message.`,
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                agent_summary: {
+                                    type: "string",
+                                    description: "Brief summary of your role/identity",
+                                },
+                                context: {
+                                    type: "string",
+                                    description: "Brief context explaining why you are asking these questions",
+                                },
+                                questions: {
+                                    type: "array",
+                                    description: "List of questions",
+                                    items: {
+                                        type: "object",
+                                        properties: {
+                                            id: {
+                                                type: "string",
+                                                description: "Unique question identifier",
+                                            },
+                                            content: {
+                                                type: "string",
+                                                description: "Question text",
+                                            },
+                                            options: {
+                                                type: "array",
+                                                description: "Optional list of choices",
+                                                items: {
+                                                    type: "object",
+                                                    properties: {
+                                                        value: { type: "string" },
+                                                        label: { type: "string" },
+                                                    },
+                                                },
+                                            },
+                                        },
+                                        required: ["id", "content"],
+                                    },
+                                },
+                                timeout_seconds: {
+                                    type: "number",
+                                    description: "Timeout in seconds",
+                                },
+                            },
+                            required: ["agent_summary", "context", "questions"],
+                        },
+                    },
+                ],
+            };
+        });
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            if (name !== "ask_user") {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Unknown tool: ${name}`,
+                        },
+                    ],
+                };
+            }
+            return this.handleAskUser(args ?? {});
+        });
+    }
+    async handleAskUser(args) {
+        const { agent_summary, context, questions, timeout_seconds, } = args;
+        const sessionId = crypto.randomUUID();
+        // Ensure questions have IDs
+        const processedQuestions = questions.map((q, i) => ({
+            ...q,
+            id: q.id || `Q${i + 1}`,
+        }));
+        await this.apiClient.addAgent(sessionId, agent_summary, context, processedQuestions, timeout_seconds);
+        // Poll for answer
+        const pollInterval = 1000; // 1 second
+        const startTime = Date.now();
+        while (true) {
+            // Check timeout
+            if (timeout_seconds && (Date.now() - startTime) >= timeout_seconds * 1000) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "User did not respond within the timeout period.",
+                        },
+                    ],
+                };
+            }
+            // Check for answer
+            const agent = await this.apiClient.getAgent(sessionId);
+            if (agent && agent.status === "answered") {
+                const answers = agent.questions
+                    .filter((q) => q.answer)
+                    .map((q) => `${q.id}: ${q.answer}`);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: answers.join("\n"),
+                        },
+                    ],
+                };
+            }
+            await new Promise((resolve) => setTimeout(resolve, pollInterval));
+        }
+    }
+    async run() {
+        this.apiClient = new APIClient(this.apiUrl);
+        // Check API health
+        const healthy = await this.apiClient.healthCheck();
+        if (!healthy) {
+            console.error(`Error: API Server at ${this.apiUrl} is not available.`);
+            console.error("Please ensure the API Server is running.");
+            process.exit(1);
+        }
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        console.error("Agent Desk MCP Server started");
+    }
+}
+// CLI entry point
+async function main() {
+    const args = process.argv.slice(2);
+    let apiUrl = "http://localhost:8080";
+    // Parse arguments
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === "--api-url" && i + 1 < args.length) {
+            apiUrl = args[i + 1];
+            i++;
+        }
+    }
+    const server = new AgentDeskServer(apiUrl);
+    await server.run();
+}
+main().catch((err) => {
+    console.error("Fatal error:", err);
+    process.exit(1);
+});

package/package.json

@@ -1,11 +1,16 @@
 {
   "name": "agent-desk-mcp",
-  "version": "0.1.4",
-  "description": "MCP server for multi-agent interaction with users - npx wrapper",
-  "main": "bin/agent-desk-mcp.js",
+  "version": "1.0.0",
+  "description": "MCP server for multi-agent interaction with users",
+  "main": "dist/index.js",
+  "type": "module",
   "bin": {
     "agent-desk-mcp": "bin/agent-desk-mcp.js"
   },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
   "keywords": [
     "mcp",
     "agent",
@@ -14,9 +19,13 @@
   ],
   "author": "weidwonder",
   "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/weidwonder/agent-desk"
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "axios": "^1.7.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
   },
   "engines": {
     "node": ">=18.0.0"

package/src/index.ts

@@ -0,0 +1,276 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+import axios, { AxiosInstance } from "axios";
+
+interface Question {
+  id: string;
+  content: string;
+  options?: Array<{ value: string; label: string }>;
+  answer?: string;
+}
+
+interface AgentData {
+  session_id: string;
+  agent_summary: string;
+  context: string;
+  questions: Question[];
+  status: "pending" | "answered" | "ignored";
+}
+
+class APIClient {
+  private client: AxiosInstance;
+
+  constructor(baseUrl: string) {
+    this.client = axios.create({
+      baseURL: baseUrl.replace(/\/$/, ""),
+    });
+  }
+
+  async healthCheck(): Promise<boolean> {
+    try {
+      const resp = await this.client.get("/api/health");
+      return resp.status === 200;
+    } catch {
+      return false;
+    }
+  }
+
+  async addAgent(
+    sessionId: string,
+    agentSummary: string,
+    context: string,
+    questions: Question[],
+    timeoutSeconds?: number
+  ): Promise<void> {
+    await this.client.post("/api/agents", {
+      session_id: sessionId,
+      agent_summary: agentSummary,
+      context: context.slice(0, 1000),
+      questions,
+      timeout_seconds: timeoutSeconds,
+    });
+  }
+
+  async getAgent(sessionId: string): Promise<AgentData | null> {
+    try {
+      const resp = await this.client.get(`/api/agents/${sessionId}`);
+      return resp.data;
+    } catch (e) {
+      if (axios.isAxiosError(e) && e.response?.status === 404) {
+        return null;
+      }
+      throw e;
+    }
+  }
+}
+
+class AgentDeskServer {
+  private server: Server;
+  private apiClient: APIClient | null = null;
+  private apiUrl: string;
+
+  constructor(apiUrl: string) {
+    this.apiUrl = apiUrl;
+    this.server = new Server({
+      name: "agent-desk",
+      version: "1.0.0",
+    });
+    this.setupHandlers();
+  }
+
+  private setupHandlers(): void {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+      return {
+        tools: [
+          {
+            name: "ask_user",
+            description: `Ask user questions, block and wait for answer.
+
+Arguments:
+- agent_summary: Brief summary of your role/identity.
+- context: Brief context (max 1000 chars) explaining why you are asking these questions.
+- questions: List of questions with id, content, and optional options.
+- timeout_seconds: Timeout in seconds. None means no timeout.
+
+Returns: User's answers concatenated with newlines, or timeout message.`,
+            inputSchema: {
+              type: "object",
+              properties: {
+                agent_summary: {
+                  type: "string",
+                  description: "Brief summary of your role/identity",
+                },
+                context: {
+                  type: "string",
+                  description: "Brief context explaining why you are asking these questions",
+                },
+                questions: {
+                  type: "array",
+                  description: "List of questions",
+                  items: {
+                    type: "object",
+                    properties: {
+                      id: {
+                        type: "string",
+                        description: "Unique question identifier",
+                      },
+                      content: {
+                        type: "string",
+                        description: "Question text",
+                      },
+                      options: {
+                        type: "array",
+                        description: "Optional list of choices",
+                        items: {
+                          type: "object",
+                          properties: {
+                            value: { type: "string" },
+                            label: { type: "string" },
+                          },
+                        },
+                      },
+                    },
+                    required: ["id", "content"],
+                  },
+                },
+                timeout_seconds: {
+                  type: "number",
+                  description: "Timeout in seconds",
+                },
+              },
+              required: ["agent_summary", "context", "questions"],
+            },
+          },
+        ],
+      };
+    });
+
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+
+      if (name !== "ask_user") {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Unknown tool: ${name}`,
+            },
+          ],
+        };
+      }
+
+      return this.handleAskUser(args ?? {});
+    });
+  }
+
+  private async handleAskUser(args: Record<string, unknown>): Promise<{
+    content: Array<{ type: string; text: string }>;
+  }> {
+    const {
+      agent_summary,
+      context,
+      questions,
+      timeout_seconds,
+    } = args as {
+      agent_summary: string;
+      context: string;
+      questions: Question[];
+      timeout_seconds?: number;
+    };
+
+    const sessionId = crypto.randomUUID();
+
+    // Ensure questions have IDs
+    const processedQuestions = questions.map((q, i) => ({
+      ...q,
+      id: q.id || `Q${i + 1}`,
+    }));
+
+    await this.apiClient!.addAgent(
+      sessionId,
+      agent_summary,
+      context,
+      processedQuestions,
+      timeout_seconds
+    );
+
+    // Poll for answer
+    const pollInterval = 1000; // 1 second
+    const startTime = Date.now();
+
+    while (true) {
+      // Check timeout
+      if (timeout_seconds && (Date.now() - startTime) >= timeout_seconds * 1000) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "User did not respond within the timeout period.",
+            },
+          ],
+        };
+      }
+
+      // Check for answer
+      const agent = await this.apiClient!.getAgent(sessionId);
+      if (agent && agent.status === "answered") {
+        const answers = agent.questions
+          .filter((q) => q.answer)
+          .map((q) => `${q.id}: ${q.answer}`);
+        return {
+          content: [
+            {
+              type: "text",
+              text: answers.join("\n"),
+            },
+          ],
+        };
+      }
+
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+  }
+
+  async run(): Promise<void> {
+    this.apiClient = new APIClient(this.apiUrl);
+
+    // Check API health
+    const healthy = await this.apiClient.healthCheck();
+    if (!healthy) {
+      console.error(`Error: API Server at ${this.apiUrl} is not available.`);
+      console.error("Please ensure the API Server is running.");
+      process.exit(1);
+    }
+
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+
+    console.error("Agent Desk MCP Server started");
+  }
+}
+
+// CLI entry point
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+  let apiUrl = "http://localhost:8080";
+
+  // Parse arguments
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--api-url" && i + 1 < args.length) {
+      apiUrl = args[i + 1];
+      i++;
+    }
+  }
+
+  const server = new AgentDeskServer(apiUrl);
+  await server.run();
+}
+
+main().catch((err) => {
+  console.error("Fatal error:", err);
+  process.exit(1);
+});

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "strict": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"]
+}