whalecode-mcp 0.0.1

package/README.md

@@ -0,0 +1,136 @@
+# whalecode-mcp
+
+WhaleCode MCP 服务器：把主机（Cursor 等）的工具调用转发到本机已打开的 WhaleCode 窗口。运行路径与侧栏 Composer 相同，审批、hooks、行内审阅仍然生效。
+
+前提：
+
+- Node.js >= 18
+- 本机已启动带 WhaleCode 扩展的 IDE，且至少打开一个工作区（扩展会在 `onStartupFinished` 后拉起 localhost bridge）
+
+本包零运行时依赖，只用 Node 内置模块（`http` / `fs` / `path` / `os`）。
+
+## 安装
+
+```bash
+npm install -g whalecode-mcp
+```
+
+## 配置 MCP 主机
+
+Cursor（`.cursor/mcp.json` 可用 npx：
+
+```json
+{
+  "mcpServers": {
+    "whalecode": {
+      "command": "npx",
+      "args": ["-y", "whalecode-mcp"]
+    }
+  }
+}
+```
+
+传输为 **JSON-RPC 2.0、按行分隔的 STDIO**（`protocolVersion: 2024-11-05`，`serverInfo.name: whalecode`）。配置完成后主机会发现下面三个工具。
+
+## 可用工具
+
+### `list_sessions`
+
+列出当前存活的 WhaleCode 窗口。无参数。
+多窗口时先用这个拿 `sessionId`，再交给 `run_agent`。
+
+### `run_agent`
+
+向一个已打开的窗口发聊天，并**同步轮询直到终态、取消、出错或超时**（轮询间隔 500ms）。成功后会聚焦 WhaleCode 聊天视图。
+
+```json
+{
+  "text": "请解释这个函数的实现逻辑",
+  "workspace": "/path/to/project",
+  "mode": "agent",
+  "model": "deepseek-v4-flash",
+  "newChat": true
+}
+```
+
+| 参数 | 类型 | 必填 | 说明 |
+|------|------|------|------|
+| `text` | string | 是 | 发给 WhaleCode 的内容（空串会报错） |
+| `mode` | string | 否 | `agent` / `ask` / `plan` / `multitask` / `project` / `debug`。省略则用窗口当前模式 |
+| `model` | string | 否 | 模型 id 或显示名。省略则用「推荐」列表里第一个**当前可用**的模型 |
+| `workspace` | string | 否 | 按工作区路径选窗口，默认 MCP 进程 `cwd` |
+| `sessionId` | string | 否 | 精确指定窗口，优先于 `workspace` |
+| `conversationId` | string | 否 | 切到已有会话再发；会话不存在则失败 |
+| `newChat` | boolean | 否 | `true` 时先开新会话（优先于 `conversationId`） |
+| `timeoutMs` | number | 否 | 等待终态的上限，默认 `900000`（15 分钟）。须 `> 0` |
+
+**窗口路由**（`pickSession`，多匹配时不猜）：
+
+1. 传了 `sessionId` → 精确匹配，否则报错并带上候选窗口
+2. 否则用 `workspace`（默认 `cwd`）匹配：目标路径等于某 `workspaceFolders` 项，或是其子路径（`/proj` 能匹配 `/proj/src`，不能匹配 `/proj-extra`）
+3. 命中 1 个 → 使用；0 个 → 报「没有打开的窗口」；多个 → 报错，要求传入 `sessionId`，`sessions` 里是候选公开信息
+
+**模型解析**：
+
+- 传了 `model`：按 picker 的完整 id、`modelId`、裸 id、名称（忽略大小写）匹配；对不上则 `模型不可用：…`
+- 未传：按推荐顺序取第一个可用项：`deepseek-v4-flash` → `qwen3-5-397B` → `kimi-26`。一个都没有则报错，提示在设置里启用其中一个
+- `auto` 不会被选中
+
+**会话**：`newChat` → 新建；否则若给了 `conversationId` 必须已存在；再否则用当前会话，没有当前会话则新建。
+
+终态返回：
+
+```json
+{
+  "runId": "run_1710000000000_ab12cd",
+  "conversationId": "conv_456",
+  "sessionId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
+  "status": "finished",
+  "model": "provider::deepseek-v4-flash",
+  "assistantText": "……",
+  "toolSummary": ["search ok: 找到 3 个结果", "read failed: …"],
+  "needsApproval": false
+}
+```
+
+| `status` | 含义 |
+|----------|------|
+| `finished` | 正常结束 |
+| `cancelled` | 被 `cancel_run` 或 IDE 取消 |
+| `error` | 启动失败或运行出错，见 `error` |
+| `timeout` | 超过 `timeoutMs` 仍为 `running`（工具结果标 `isError`） |
+
+超时额外带 `pendingApproval`。若窗口在等用户点审批，`needsApproval` 为 `true`；MCP **不会**代批，需要人在 IDE 里处理，否则会一直 `running` 直到超时。`toolSummary` 来自已完成的 tool-call（`name ok/failed: 首行摘要`）。
+
+### `cancel_run`
+
+取消一次仍在跑的 `run_agent`。
+
+```json
+{ "runId": "run_1710000000000_ab12cd" }
+```
+
+| 参数 | 类型 | 必填 | 说明 |
+|------|------|------|------|
+| `runId` | string | 是 | `run_agent` 返回的 id |
+| `sessionId` | string | 否 | 目标窗口。省略则先查本 MCP 进程启动过的 run，再向各活窗口探测 |
+
+定位顺序：显式 `sessionId` → 本进程 `runId` 缓存 → 对其余窗口 `GET /v1/runs/:id`（404 跳过）。找不到则 `{ "error": "run not found: …" }`。
+
+成功：`{ "ok": true, "runId": "…", "status": "cancelled", "sessionId": "…" }`。已经结束的 run 会原样返回其当前 `status`。
+
+## 工作原理
+
+```
+MCP Host
+  │  JSON-RPC 2.0（一行一条）over STDIO
+  ▼
+whalecode-mcp
+  │  读 ~/.whalecode/sessions/*.json
+  │  HTTP 127.0.0.1:<port>  +  Authorization: Bearer <token>
+  ▼
+WhaleCode 扩展 bridge
+  │  与 Composer 同一条 runExternal
+  ▼
+侧栏 / 编辑器聊天
+```

package/dist/client.js

@@ -0,0 +1,137 @@
+"use strict";
+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.BridgeHttpError = void 0;
+exports.getHealth = getHealth;
+exports.startRun = startRun;
+exports.getRun = getRun;
+exports.cancelRun = cancelRun;
+exports.findRunSession = findRunSession;
+const http = __importStar(require("http"));
+class BridgeHttpError extends Error {
+    status;
+    body;
+    constructor(message, status, body) {
+        super(message);
+        this.status = status;
+        this.body = body;
+    }
+}
+exports.BridgeHttpError = BridgeHttpError;
+function request(session, method, pathname, body) {
+    return new Promise((resolve, reject) => {
+        const payload = body === undefined ? undefined : JSON.stringify(body);
+        const req = http.request({
+            host: "127.0.0.1",
+            port: session.port,
+            path: pathname,
+            method,
+            headers: {
+                Authorization: `Bearer ${session.token}`,
+                Accept: "application/json",
+                ...(payload
+                    ? {
+                        "Content-Type": "application/json",
+                        "Content-Length": Buffer.byteLength(payload),
+                    }
+                    : {}),
+            },
+        }, (res) => {
+            const chunks = [];
+            res.on("data", (c) => chunks.push(c));
+            res.on("end", () => {
+                const raw = Buffer.concat(chunks).toString("utf8");
+                let parsed = undefined;
+                if (raw) {
+                    try {
+                        parsed = JSON.parse(raw);
+                    }
+                    catch {
+                        parsed = raw;
+                    }
+                }
+                const status = res.statusCode || 500;
+                if (status >= 400) {
+                    const errMsg = parsed &&
+                        typeof parsed === "object" &&
+                        parsed !== null &&
+                        "error" in parsed
+                        ? String(parsed.error)
+                        : `HTTP ${status}`;
+                    reject(new BridgeHttpError(errMsg, status, parsed));
+                    return;
+                }
+                resolve(parsed);
+            });
+        });
+        req.on("error", reject);
+        req.setTimeout(30_000, () => {
+            req.destroy(new Error("bridge request timed out"));
+        });
+        if (payload)
+            req.write(payload);
+        req.end();
+    });
+}
+function getHealth(session) {
+    return request(session, "GET", "/v1/health");
+}
+function startRun(session, body) {
+    return request(session, "POST", "/v1/run", body);
+}
+function getRun(session, runId) {
+    return request(session, "GET", `/v1/runs/${encodeURIComponent(runId)}`);
+}
+function cancelRun(session, runId) {
+    return request(session, "POST", `/v1/runs/${encodeURIComponent(runId)}/cancel`);
+}
+async function findRunSession(sessions, runId, known) {
+    const ordered = known
+        ? [known, ...sessions.filter((s) => s.sessionId !== known.sessionId)]
+        : sessions;
+    for (const session of ordered) {
+        try {
+            await getRun(session, runId);
+            return session;
+        }
+        catch (err) {
+            if (err instanceof BridgeHttpError && err.status === 404)
+                continue;
+            if (err instanceof BridgeHttpError)
+                return session;
+        }
+    }
+    return undefined;
+}

package/dist/index.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const server_1 = require("./server");
+(0, server_1.startMcpStdio)();

package/dist/registry.js

@@ -0,0 +1,169 @@
+"use strict";
+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.BRIDGE_MODES = exports.BRIDGE_STALE_MS = void 0;
+exports.toPublicSession = toPublicSession;
+exports.sessionsDir = sessionsDir;
+exports.isPidAlive = isPidAlive;
+exports.isSessionLive = isSessionLive;
+exports.workspaceContains = workspaceContains;
+exports.pickSession = pickSession;
+exports.listLiveSessions = listLiveSessions;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+exports.BRIDGE_STALE_MS = 90_000;
+exports.BRIDGE_MODES = [
+    "agent",
+    "ask",
+    "plan",
+    "multitask",
+    "project",
+    "debug",
+];
+function toPublicSession(record) {
+    return {
+        sessionId: record.sessionId,
+        workspaceFolders: record.workspaceFolders,
+        workspaceName: record.workspaceName,
+        busy: record.busy,
+    };
+}
+function sessionsDir(home = os.homedir()) {
+    return path.join(home, ".whalecode", "sessions");
+}
+function isPidAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return err?.code === "EPERM";
+    }
+}
+function isSessionLive(record, now = Date.now(), staleMs = exports.BRIDGE_STALE_MS) {
+    if (!isPidAlive(record.pid))
+        return false;
+    const beat = record.heartbeatAt || record.startedAt;
+    return now - beat <= staleMs;
+}
+function workspaceContains(folders, target) {
+    if (!target)
+        return false;
+    const resolved = path.resolve(target);
+    return folders.some((folder) => {
+        const root = path.resolve(folder);
+        return resolved === root || resolved.startsWith(root + path.sep);
+    });
+}
+function pickSession(sessions, opts) {
+    if (opts.sessionId) {
+        const hit = sessions.find((s) => s.sessionId === opts.sessionId);
+        if (!hit) {
+            return {
+                ok: false,
+                error: `没有匹配的 WhaleCode 窗口：sessionId=${opts.sessionId}`,
+                candidates: sessions,
+            };
+        }
+        return { ok: true, session: hit };
+    }
+    const workspace = opts.workspace?.trim();
+    const matched = workspace
+        ? sessions.filter((s) => workspaceContains(s.workspaceFolders, workspace))
+        : sessions;
+    if (matched.length === 1)
+        return { ok: true, session: matched[0] };
+    if (matched.length === 0) {
+        return {
+            ok: false,
+            error: workspace
+                ? `没有打开的 WhaleCode 窗口包含工作区：${workspace}`
+                : "没有打开的 WhaleCode 窗口",
+            candidates: sessions,
+        };
+    }
+    return {
+        ok: false,
+        error: `匹配到 ${matched.length} 个 WhaleCode 窗口，请传入 sessionId`,
+        candidates: matched,
+    };
+}
+function readSessionFile(file) {
+    try {
+        const raw = JSON.parse(fs.readFileSync(file, "utf8"));
+        if (!raw?.sessionId || !raw.port || !raw.token)
+            return undefined;
+        return raw;
+    }
+    catch {
+        return undefined;
+    }
+}
+function listLiveSessions(home = os.homedir(), opts) {
+    const dir = sessionsDir(home);
+    let names;
+    try {
+        names = fs.readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    const now = opts?.now ?? Date.now();
+    const live = [];
+    for (const name of names) {
+        if (!name.endsWith(".json"))
+            continue;
+        const file = path.join(dir, name);
+        const rec = readSessionFile(file);
+        if (!rec)
+            continue;
+        if (isSessionLive(rec, now)) {
+            live.push(rec);
+            continue;
+        }
+        if (opts?.prune) {
+            try {
+                fs.unlinkSync(file);
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    }
+    return live;
+}

package/dist/server.js

@@ -0,0 +1,278 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startMcpStdio = startMcpStdio;
+const registry_1 = require("./registry");
+const client_1 = require("./client");
+const DEFAULT_TIMEOUT_MS = 15 * 60_000;
+const POLL_MS = 500;
+const tools = [
+    {
+        name: "list_sessions",
+        description: "List live WhaleCode IDE windows (workspace, sessionId, busy). Use sessionId to target a specific window.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "run_agent",
+        description: "Run WhaleCode in an open IDE window with the given mode and chat text. Blocks until the run finishes, is cancelled, errors, or times out. Route by workspace path or sessionId; if several windows match, pass sessionId.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                text: {
+                    type: "string",
+                    description: "Chat prompt to send to WhaleCode.",
+                },
+                mode: {
+                    type: "string",
+                    enum: [...registry_1.BRIDGE_MODES],
+                    description: "Agent mode. Defaults to the window's current mode.",
+                },
+                model: {
+                    type: "string",
+                    description: "Model id or name (e.g. qwen3-5-397B, kimi-26, deepseek-v4-flash). Omit to use the first available model in WhaleCode's 推荐 list.",
+                },
+                workspace: {
+                    type: "string",
+                    description: "Workspace path used to pick a window. Defaults to the MCP process cwd.",
+                },
+                sessionId: {
+                    type: "string",
+                    description: "Explicit WhaleCode window id from list_sessions.",
+                },
+                conversationId: {
+                    type: "string",
+                    description: "Existing conversation to continue. Omit to use current.",
+                },
+                newChat: {
+                    type: "boolean",
+                    description: "Start a new conversation before sending.",
+                },
+                timeoutMs: {
+                    type: "number",
+                    description: `How long to wait for a terminal status (default ${DEFAULT_TIMEOUT_MS}).`,
+                },
+            },
+            required: ["text"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "cancel_run",
+        description: "Cancel an in-flight WhaleCode run started via run_agent.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                runId: { type: "string", description: "Run id returned by run_agent." },
+                sessionId: {
+                    type: "string",
+                    description: "Optional window id if the run is not in this MCP process.",
+                },
+            },
+            required: ["runId"],
+            additionalProperties: false,
+        },
+    },
+];
+const runSessions = new Map();
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+function textResult(data, isError = false) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: typeof data === "string" ? data : JSON.stringify(data, null, 2),
+            },
+        ],
+        isError,
+    };
+}
+function writeMessage(msg) {
+    process.stdout.write(`${JSON.stringify(msg)}\n`);
+}
+async function callTool(name, args) {
+    if (name === "list_sessions") {
+        const sessions = (0, registry_1.listLiveSessions)(undefined, { prune: true });
+        const enriched = await Promise.all(sessions.map(async (s) => {
+            try {
+                const health = await (0, client_1.getHealth)(s);
+                return {
+                    ...(0, registry_1.toPublicSession)(s),
+                    busy: health.busy,
+                    conversationId: health.conversationId,
+                };
+            }
+            catch {
+                return (0, registry_1.toPublicSession)(s);
+            }
+        }));
+        return textResult({ sessions: enriched });
+    }
+    if (name === "run_agent") {
+        const text = typeof args.text === "string" ? args.text.trim() : "";
+        if (!text)
+            return textResult({ error: "text is required" }, true);
+        const mode = typeof args.mode === "string" ? args.mode : undefined;
+        if (mode &&
+            !registry_1.BRIDGE_MODES.includes(mode)) {
+            return textResult({ error: `invalid mode: ${mode}` }, true);
+        }
+        const sessions = (0, registry_1.listLiveSessions)(undefined, { prune: true });
+        const workspace = typeof args.workspace === "string" && args.workspace.trim()
+            ? args.workspace.trim()
+            : process.cwd();
+        const picked = (0, registry_1.pickSession)(sessions, {
+            sessionId: typeof args.sessionId === "string" ? args.sessionId : undefined,
+            workspace,
+        });
+        if (!picked.ok) {
+            return textResult({
+                error: picked.error,
+                sessions: picked.candidates.map(registry_1.toPublicSession),
+            }, true);
+        }
+        const accepted = await (0, client_1.startRun)(picked.session, {
+            text,
+            mode,
+            model: typeof args.model === "string" && args.model.trim()
+                ? args.model.trim()
+                : undefined,
+            conversationId: typeof args.conversationId === "string"
+                ? args.conversationId
+                : undefined,
+            newChat: args.newChat === true,
+        });
+        runSessions.set(accepted.runId, picked.session);
+        const timeoutMs = typeof args.timeoutMs === "number" && args.timeoutMs > 0
+            ? args.timeoutMs
+            : DEFAULT_TIMEOUT_MS;
+        const deadline = Date.now() + timeoutMs;
+        let last;
+        while (Date.now() < deadline) {
+            last = await (0, client_1.getRun)(picked.session, accepted.runId);
+            if (last.status !== "running") {
+                return textResult({
+                    runId: last.runId,
+                    conversationId: last.conversationId,
+                    sessionId: picked.session.sessionId,
+                    status: last.status,
+                    model: last.model ?? accepted.model,
+                    assistantText: last.assistantText,
+                    toolSummary: last.toolSummary,
+                    error: last.error,
+                    needsApproval: last.needsApproval,
+                });
+            }
+            await sleep(POLL_MS);
+        }
+        const pending = last?.pendingApproval || last?.needsApproval;
+        return textResult({
+            runId: accepted.runId,
+            conversationId: accepted.conversationId,
+            sessionId: picked.session.sessionId,
+            status: "timeout",
+            model: last?.model ?? accepted.model,
+            assistantText: last?.assistantText ?? "",
+            toolSummary: last?.toolSummary ?? [],
+            error: last?.error,
+            needsApproval: !!pending,
+            pendingApproval: !!last?.pendingApproval,
+        }, true);
+    }
+    if (name === "cancel_run") {
+        const runId = typeof args.runId === "string" ? args.runId.trim() : "";
+        if (!runId)
+            return textResult({ error: "runId is required" }, true);
+        const sessions = (0, registry_1.listLiveSessions)(undefined, { prune: true });
+        const known = typeof args.sessionId === "string"
+            ? sessions.find((s) => s.sessionId === args.sessionId) ||
+                runSessions.get(runId)
+            : runSessions.get(runId);
+        const session = await (0, client_1.findRunSession)(sessions, runId, known);
+        if (!session) {
+            return textResult({ error: `run not found: ${runId}` }, true);
+        }
+        const result = await (0, client_1.cancelRun)(session, runId);
+        return textResult({ ...result, sessionId: session.sessionId });
+    }
+    return textResult({ error: `unknown tool: ${name}` }, true);
+}
+async function handle(req) {
+    const id = req.id ?? null;
+    const method = req.method || "";
+    if (method === "initialize") {
+        writeMessage({
+            jsonrpc: "2.0",
+            id,
+            result: {
+                protocolVersion: "2024-11-05",
+                capabilities: { tools: {} },
+                serverInfo: { name: "whalecode", version: "0.0.1" },
+            },
+        });
+        return;
+    }
+    if (method === "notifications/initialized" || method.startsWith("notifications/")) {
+        return;
+    }
+    if (method === "ping") {
+        writeMessage({ jsonrpc: "2.0", id, result: {} });
+        return;
+    }
+    if (method === "tools/list") {
+        writeMessage({ jsonrpc: "2.0", id, result: { tools } });
+        return;
+    }
+    if (method === "tools/call") {
+        const params = (req.params || {});
+        try {
+            const result = await callTool(params.name || "", params.arguments || {});
+            writeMessage({ jsonrpc: "2.0", id, result });
+        }
+        catch (err) {
+            writeMessage({
+                jsonrpc: "2.0",
+                id,
+                result: textResult({ error: err instanceof Error ? err.message : String(err) }, true),
+            });
+        }
+        return;
+    }
+    if (id === null || id === undefined)
+        return;
+    writeMessage({
+        jsonrpc: "2.0",
+        id,
+        error: { code: -32601, message: `Method not found: ${method}` },
+    });
+}
+function startMcpStdio() {
+    process.stdin.setEncoding("utf8");
+    let buffer = "";
+    process.stdin.on("data", (chunk) => {
+        buffer += chunk;
+        let nl;
+        while ((nl = buffer.indexOf("\n")) !== -1) {
+            const line = buffer.slice(0, nl).trim();
+            buffer = buffer.slice(nl + 1);
+            if (!line)
+                continue;
+            let req;
+            try {
+                req = JSON.parse(line);
+            }
+            catch {
+                process.stderr.write(`whalecode-mcp: invalid JSON: ${line}\n`);
+                continue;
+            }
+            void handle(req).catch((err) => {
+                process.stderr.write(`whalecode-mcp: ${err instanceof Error ? err.message : String(err)}\n`);
+            });
+        }
+    });
+    process.stdin.on("end", () => process.exit(0));
+}

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "whalecode-mcp",
+  "version": "0.0.1",
+  "description": "WhaleCode MCP 服务器，将 MCP 主机（Cursor 等）的工具调用转发到本机已打开的 WhaleCode IDE 窗口。通过 WhaleCode 扩展的 localhost bridge 通信，支持按工作区路径或 sessionId 路由会话，提供多种 Agent 模式和模型选择，同步轮询运行状态直至完成、取消、出错或超时。",
+  "bin": {
+    "whalecode-mcp": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p ./tsconfig.json",
+    "check-types": "tsc --noEmit -p ./tsconfig.json"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "MIT"
+}