ask-user-question-plus 1.0.0

package/dist/ws-service.js

@@ -0,0 +1,186 @@
+import { WebSocket } from "ws";
+export class WebSocketService {
+    wss;
+    sessions = new Map();
+    sessionTimeoutMs;
+    port;
+    constructor(wss, sessionTimeoutMs = 600000, port = 3456) {
+        this.wss = wss;
+        this.sessionTimeoutMs = sessionTimeoutMs;
+        this.port = port;
+        this.setupWebSocket();
+    }
+    setupWebSocket() {
+        this.wss.on("connection", (ws, req) => {
+            this.handleConnection(ws, req);
+        });
+        this.wss.on("error", (error) => {
+            console.error("[WebSocket] Server error:", error);
+        });
+    }
+    handleConnection(ws, req) {
+        const url = new URL(req.url || "", `http://localhost:${this.port}`);
+        const sessionId = url.searchParams.get("sessionId");
+        if (!sessionId) {
+            console.error("[WebSocket] Connection missing sessionId, closing");
+            ws.close();
+            return;
+        }
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            console.error("[WebSocket] Session not found:", sessionId);
+            ws.close();
+            return;
+        }
+        console.error("[WebSocket] Client connected:", sessionId);
+        session.ws = ws;
+        // Clear connection timeout
+        if (session.timeout) {
+            clearTimeout(session.timeout);
+            session.timeout = null;
+        }
+        // Send questions to client
+        this.sendMessage(ws, {
+            type: "NEW_QUESTION",
+            payload: session.questions,
+        });
+        console.error("[WebSocket] Questions sent to client:", sessionId);
+        // Set response timeout
+        session.timeout = setTimeout(() => {
+            console.error("[WebSocket] Session timeout:", sessionId);
+            this.handleSessionError(sessionId, new Error(`Timeout: No response within ${this.sessionTimeoutMs / 1000}s`));
+        }, this.sessionTimeoutMs);
+        // Handle messages
+        ws.on("message", (rawMessage) => {
+            this.handleMessage(sessionId, rawMessage);
+        });
+        // Handle disconnect
+        ws.on("close", () => {
+            console.error("[WebSocket] Client disconnected:", sessionId);
+        });
+        // Handle errors
+        ws.on("error", (error) => {
+            console.error("[WebSocket] Connection error:", sessionId, error);
+            this.handleSessionError(sessionId, new Error("WebSocket connection error"));
+        });
+    }
+    handleMessage(sessionId, rawMessage) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            console.error("[WebSocket] Message received but session not found:", sessionId);
+            return;
+        }
+        try {
+            const message = JSON.parse(rawMessage.toString());
+            console.error("[WebSocket] Message received:", message.type, "from", sessionId);
+            if (message.type === "SUBMIT_ANSWERS") {
+                // Clear timeout
+                if (session.timeout) {
+                    clearTimeout(session.timeout);
+                    session.timeout = null;
+                }
+                // Resolve promise
+                session.resolve(message.payload);
+                console.error("[WebSocket] Answers submitted:", sessionId);
+                // Send close message
+                if (session.ws && session.ws.readyState === WebSocket.OPEN) {
+                    this.sendMessage(session.ws, { type: "CLOSE" });
+                }
+                // Cleanup session
+                this.sessions.delete(sessionId);
+            }
+            else if (message.type === "ERROR") {
+                this.handleSessionError(sessionId, new Error(`Client error: ${message.error}`));
+            }
+        }
+        catch (error) {
+            console.error("[WebSocket] Message parse error:", sessionId, error);
+            this.handleSessionError(sessionId, new Error("Invalid message format"));
+        }
+    }
+    sendMessage(ws, message) {
+        if (ws.readyState === WebSocket.OPEN) {
+            ws.send(JSON.stringify(message));
+        }
+        else {
+            throw new Error("WebSocket not ready");
+        }
+    }
+    handleSessionError(sessionId, error) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return;
+        console.error("[WebSocket] Session error:", sessionId, error.message);
+        // Clear timeout
+        if (session.timeout) {
+            clearTimeout(session.timeout);
+            session.timeout = null;
+        }
+        // Send error message to client before closing
+        if (session.ws && session.ws.readyState === WebSocket.OPEN) {
+            try {
+                this.sendMessage(session.ws, {
+                    type: "ERROR",
+                    error: error.message,
+                });
+            }
+            catch (e) {
+                console.error("[WebSocket] Failed to send error to client:", e);
+            }
+            session.ws.close();
+        }
+        // Reject promise - this will notify the MCP client (AI)
+        session.reject(error);
+        // Cleanup session
+        this.sessions.delete(sessionId);
+    }
+    // Create session and open browser
+    async createSession(sessionId, questions, resolve, reject) {
+        console.error("[WebSocket] Creating session:", sessionId);
+        const session = {
+            id: sessionId,
+            questions,
+            resolve,
+            reject,
+            ws: null,
+            timeout: null,
+            createdAt: Date.now(),
+        };
+        // Set initial timeout (waiting for client connection)
+        session.timeout = setTimeout(() => {
+            console.error("[WebSocket] Session timeout (client not connected):", sessionId);
+            this.handleSessionError(sessionId, new Error(`Timeout: Client not connected within ${this.sessionTimeoutMs / 1000}s`));
+        }, this.sessionTimeoutMs);
+        this.sessions.set(sessionId, session);
+        // Open browser
+        const url = `http://localhost:${this.port}/?sessionId=${sessionId}`;
+        console.error("[WebSocket] Opening browser:", url);
+        try {
+            const open = (await import("open")).default;
+            await open(url);
+            console.error("[WebSocket] Browser opened:", sessionId);
+        }
+        catch (error) {
+            console.error("[WebSocket] Failed to open browser:", error);
+            this.handleSessionError(sessionId, new Error("Cannot open browser"));
+            throw error;
+        }
+    }
+    async cleanup() {
+        console.error("[WebSocket] Cleaning up...");
+        // Clear all sessions
+        for (const [sessionId] of this.sessions.entries()) {
+            this.handleSessionError(sessionId, new Error("Server shutting down"));
+        }
+        // Close WebSocket server
+        return new Promise((resolve) => {
+            this.wss.close(() => {
+                console.error("[WebSocket] Server closed");
+                resolve();
+            });
+        });
+    }
+    getSessionCount() {
+        return this.sessions.size;
+    }
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "ask-user-question-plus",
+  "version": "1.0.0",
+  "description": "A TUI-style MCP server for asking user questions via a web interface.",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "ask-user-question-plus": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "claude",
+    "codex",
+    "gemini-cli",
+    "AskUserQuestion"
+  ],
+  "author": "JoJoJotarou",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/JoJoJotarou/AskUserQuestionPlus.git"
+  },
+  "homepage": "https://github.com/JoJoJotarou/AskUserQuestionPlus#readme",
+  "bugs": {
+    "url": "https://github.com/JoJoJotarou/AskUserQuestionPlus/issues"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.1",
+    "dotenv": "^17.2.3",
+    "express": "^4.21.1",
+    "open": "^10.1.0",
+    "uuid": "^11.0.3",
+    "ws": "^8.18.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.0",
+    "@types/node": "^22.9.0",
+    "@types/uuid": "^10.0.0",
+    "@types/ws": "^8.5.12",
+    "tsx": "^4.19.2",
+    "typescript": "^5.6.3"
+  }
+}