@greatlhd/ailo-desktop 1.0.0

package/src/index.ts

@@ -0,0 +1,474 @@
+#!/usr/bin/env node
+/**
+ * Ailo Desktop — 超级端点
+ *
+ * 集成桌面能力 + 飞书 + 钉钉 + QQ + 邮件。
+ * 各平台按需配置：有完整配置才启动对应 handler 并上报对应 blueprint。
+ * 未配置的平台不会被 Ailo 感知，不影响其他能力正常工作。
+ *
+ * 子命令：ailo-desktop init [--defaults] — 初始化 config.json 与 Skills 目录（见 cli.ts）。
+ */
+
+const [, , subcommand] = process.argv;
+if (subcommand === "init") {
+  import("./cli.js")
+    .then(({ runInit }) =>
+      runInit(process.argv.includes("--defaults"))
+        .then(() => process.exit(0))
+        .catch((e) => {
+          console.error(e);
+          process.exit(1);
+        }),
+    )
+    .catch((e) => {
+      console.error("init 加载失败:", e);
+      process.exit(1);
+    });
+}
+
+import { runEndpoint, type EndpointContext } from "@greatlhd/ailo-endpoint-sdk";
+import type { ContentPart, ToolCapability } from "@greatlhd/ailo-endpoint-sdk";
+import { inferMime, classifyMedia, mediaPart } from "@greatlhd/ailo-endpoint-sdk";
+import { createInterface } from "readline";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+async function promptPort(): Promise<number> {
+  for (;;) {
+    const n = await new Promise<number | null>((resolve) => {
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      rl.question("请输入配置界面端口号: ", (answer) => {
+        rl.close();
+        const x = Number(answer.trim());
+        resolve(!Number.isNaN(x) && x > 0 && x < 65536 ? x : null);
+      });
+    });
+    if (n !== null) return n;
+    console.error("无效端口，请输入 1-65535 之间的数字");
+  }
+}
+
+import { DesktopStateStore } from "./desktop_state_store.js";
+import { captureDesktopObservation } from "./screenshot.js";
+import { execTool } from "./exec_tool.js";
+import { fsTool } from "./fs_tools.js";
+import { LocalMCPManager } from "./mcp_manager.js";
+import { browserUse, stopBrowser } from "./browser_control.js";
+import { executeCode } from "./code_executor.js";
+import { startConfigServer } from "./config_server.js";
+import { mouseKeyboard } from "./mouse_keyboard.js";
+import { FeishuHandler } from "./feishu-handler.js";
+import {
+  loadConnectionConfig,
+  hasValidConfig,
+  backoffDelayMs,
+  readConfig,
+  type AiloConnectionConfig,
+} from "./connection_util.js";
+import { CONFIG_FILENAME, NO_SUBJECT } from "./constants.js";
+import { errMsg } from "./utils.js";
+
+const BLUEPRINTS_DIR = join(__dirname, "..", "..", "..", "blueprints");
+
+function parseArgs(): { port?: number; blueprintUrl?: string } {
+  const args = process.argv.slice(2);
+  let port: number | undefined;
+  let blueprintUrl: string | undefined;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--port" && args[i + 1]) {
+      const p = Number(args[++i]);
+      if (!Number.isNaN(p) && p > 0) port = p;
+    } else if (args[i] === "--blueprint-url" && args[i + 1]) blueprintUrl = args[++i];
+  }
+  return { port, blueprintUrl };
+}
+
+const { port: CLI_PORT, blueprintUrl: CLI_BLUEPRINT_URL } = parseArgs();
+
+const BLUEPRINT_URL = CLI_BLUEPRINT_URL ?? join(BLUEPRINTS_DIR, "desktop-agent.blueprint.md");
+const BLUEPRINT_WEBCHAT = join(BLUEPRINTS_DIR, "webchat.blueprint.md");
+const BLUEPRINT_FEISHU = join(BLUEPRINTS_DIR, "feishu.blueprint.md");
+
+// ──────────────────────────────────────────────────────────────
+// 配置加载：各平台 + email
+// ──────────────────────────────────────────────────────────────
+
+export interface FeishuConfig { appId: string; appSecret: string }
+
+function loadSectionConfig<T>(
+  configPath: string,
+  section: string,
+  requiredKeys: string[],
+  mapper: (raw: Record<string, unknown>) => T,
+): T | null {
+  const raw = readConfig(configPath);
+  const s = (raw as Record<string, unknown>)[section] as Record<string, unknown> | undefined;
+  if (!s || requiredKeys.some((k) => !s[k])) return null;
+  return mapper(s);
+}
+
+
+const loadFeishuConfig = (p: string) =>
+  loadSectionConfig<FeishuConfig>(p, "feishu", ["appId", "appSecret"], (f) => ({
+    appId: f.appId as string,
+    appSecret: f.appSecret as string,
+  }));
+
+
+// ──────────────────────────────────────────────────────────────
+// 运行时状态
+// ──────────────────────────────────────────────────────────────
+
+const mcpManager = new LocalMCPManager();
+let endpointCtx: EndpointContext | null = null;
+let webchatApi: { recordAiloReply: (text: string, participantName: string) => boolean } | null = null;
+let feishuHandler: FeishuHandler | null = null;
+let lastMcpToolSnapshot: Map<string, ToolCapability> = new Map();
+const desktopStateStore = new DesktopStateStore();
+
+function computeToolDiff(oldTools: Map<string, ToolCapability>, newTools: ToolCapability[]): {
+  register: ToolCapability[];
+  unregister: string[];
+} {
+  const newMap = new Map(newTools.map((t) => [t.name, t]));
+  const register: ToolCapability[] = [];
+  const unregister: string[] = [];
+  for (const [name] of oldTools) {
+    if (!newMap.has(name)) unregister.push(name);
+  }
+  for (const [name, tool] of newMap) {
+    if (!oldTools.has(name)) register.push(tool);
+  }
+  return { register, unregister };
+}
+
+async function syncMcpToolsToServer(): Promise<void> {
+  if (!endpointCtx) return;
+  const currentTools = mcpManager.getAllPrivateTools();
+  const { register, unregister } = computeToolDiff(lastMcpToolSnapshot, currentTools);
+  if (register.length === 0 && unregister.length === 0) return;
+  try {
+    await endpointCtx.update({
+      register: register.length > 0 ? { tools: register } : undefined,
+      unregister: unregister.length > 0 ? { tools: unregister } : undefined,
+    });
+    lastMcpToolSnapshot = new Map(currentTools.map((t) => [t.name, t]));
+    console.log(`[desktop] MCP 工具增量同步: +${register.length} -${unregister.length}`);
+  } catch (e: unknown) {
+    console.error("[desktop] MCP 工具增量同步失败:", errMsg(e));
+  }
+}
+
+async function initSubsystems(): Promise<void> {
+  try {
+    await mcpManager.init();
+    mcpManager.startWatching();
+    let mcpSyncTimer: ReturnType<typeof setTimeout> | null = null;
+    mcpManager.setOnToolsChanged(() => {
+      if (mcpSyncTimer) return; // 防抖：500ms 内只同步一次
+      mcpSyncTimer = setTimeout(() => {
+        mcpSyncTimer = null;
+        console.log("[desktop] MCP 工具变更，增量同步到 Ailo");
+        syncMcpToolsToServer();
+      }, 500);
+    });
+  } catch (e: unknown) {
+    console.error("[desktop] MCP 初始化失败:", errMsg(e));
+  }
+}
+
+// ──────────────────────────────────────────────────────────────
+// 平台 handler 生命周期
+// ──────────────────────────────────────────────────────────────
+
+async function startPlatformHandlers(ctx: EndpointContext, configPath: string): Promise<void> {
+  // 飞书
+  const feishuCfg = loadFeishuConfig(configPath);
+  if (feishuCfg) {
+    feishuHandler = new FeishuHandler(feishuCfg);
+    await feishuHandler.start(ctx);
+    console.log("[desktop] 飞书通道已启动");
+  }
+}
+
+async function stopPlatformHandlers(): Promise<void> {
+  if (feishuHandler) {
+    await feishuHandler.stop();
+    feishuHandler = null;
+  }
+}
+
+// ──────────────────────────────────────────────────────────────
+// 动态计算 blueprints（只注册已配置的平台）
+// ──────────────────────────────────────────────────────────────
+
+function buildBlueprints(configPath: string): string[] {
+  const list: string[] = [BLUEPRINT_URL, BLUEPRINT_WEBCHAT];
+  if (loadFeishuConfig(configPath)) list.push(BLUEPRINT_FEISHU);
+  return list;
+}
+
+// ──────────────────────────────────────────────────────────────
+// 工具 handlers
+// ──────────────────────────────────────────────────────────────
+
+const FS_TOOLS = [
+  "read_file", "write_file", "edit_file", "append_file", "list_directory",
+  "find_files", "search_content", "delete_file", "move_file", "copy_file",
+];
+
+function requireHandler<T>(handler: T | null, platform: string): T {
+  if (!handler) throw new Error(`${platform}未配置，请在配置页对应标签中填写信息`);
+  return handler;
+}
+
+const requireFeishu = () => requireHandler(feishuHandler, "飞书");
+
+function buildToolHandlers(): Record<string, (args: Record<string, unknown>) => Promise<ContentPart[] | unknown>> {
+  const handlers: Record<string, (args: Record<string, unknown>) => Promise<ContentPart[] | unknown>> = {
+    screenshot: async (args) => {
+      const result = await captureDesktopObservation({
+        capture_window: !!args.capture_window,
+        screen: args.screen as number | "all" | undefined,
+      });
+      if (result.observation) desktopStateStore.saveObservation(result.observation);
+      return result.parts;
+    },
+    browser_use: async (args) => browserUse(args),
+    execute_code: async (args) => {
+      if (!endpointCtx) throw new Error("端点未就绪");
+      return executeCode(endpointCtx, args);
+    },
+    exec: async (args) => {
+      if (!endpointCtx) throw new Error("端点未就绪");
+      return execTool(endpointCtx, args);
+    },
+    mouse_keyboard: async (args) => mouseKeyboard(args, { stateStore: desktopStateStore }),
+    mcp_manage: async (args) => {
+      const result = await mcpManager.handle(args);
+      if (result.toolsChanged) syncMcpToolsToServer();
+      return result.text;
+    },
+    // 网页聊天发送
+    webchat_send: async (args) => {
+      const text = args.text as string | undefined;
+      const participantName = args.participantName as string;
+      const attachments = (args.attachments as { path?: string }[]) ?? [];
+      if (!webchatApi && attachments.length === 0) {
+        return [{ type: "text", text: JSON.stringify({ ok: false, error: "webchat未就绪，请先连接Ailo并打开配置页" }) }];
+      }
+      const results: string[] = [];
+      // 发送文字
+      if (text && webchatApi) {
+        const ok = webchatApi.recordAiloReply(text, participantName ?? "");
+        results.push(ok ? "文字已发送" : "文字发送失败，请确认participantName与网页聊天中的称呼一致且用户在线");
+      }
+      // 发送附件
+      if (attachments.length > 0) {
+        if (!endpointCtx) return [{ type: "text", text: JSON.stringify({ ok: false, error: "端点未就绪，无法发送附件" }) }];
+        for (const att of attachments) {
+          if (att.path) {
+            await endpointCtx.sendFile(att.path);
+            results.push(`文件已发送：${att.path}`);
+          }
+        }
+      }
+      if (results.length === 0) return [{ type: "text", text: JSON.stringify({ ok: false, error: "请提供text或attachments" }) }];
+      return [{ type: "text", text: JSON.stringify({ ok: true, results }) }];
+    },
+    // 飞书发送
+    feishu_send: async (args) => {
+      const h = requireFeishu();
+      const atts = ((args.attachments as any[]) ?? []).map((a: any) => ({
+        type: a.type,
+        file_path: a.path,
+        mime: a.mime,
+        name: a.name,
+        duration: a.duration,
+      }));
+      await h.sendText(args.chat_id as string, (args.text as string) ?? "", atts);
+      return [{ type: "text", text: `已发送到 ${args.chat_id}` }];
+    },
+  };
+  for (const name of FS_TOOLS) {
+    handlers[name] = async (args) => fsTool(name, args);
+  }
+  return handlers;
+}
+
+// ──────────────────────────────────────────────────────────────
+// 主函数
+// ──────────────────────────────────────────────────────────────
+
+async function main(): Promise<void> {
+  const port = CLI_PORT ?? (await promptPort());
+  const configPath = join(process.cwd(), CONFIG_FILENAME);
+  const connectionState = { connected: false, endpointId: "" };
+  let webchatCtxRef: EndpointContext | null = null;
+  let connectAttempt = 0;
+  let endpointConnecting = false;
+
+  async function reloadPlatformHandler<
+    C,
+    H extends { start(ctx: EndpointContext): Promise<void>; stop(): Promise<void> },
+  >(opts: {
+    getHandler: () => H | null;
+    setHandler: (h: H | null) => void;
+    loadConfig: () => C | null;
+    createHandler: (cfg: C) => H;
+    blueprint: string;
+  }): Promise<void> {
+    if (!endpointCtx) return;
+    const wasRunning = !!opts.getHandler();
+    if (opts.getHandler()) {
+      await opts.getHandler()!.stop();
+      opts.setHandler(null);
+    }
+    const cfg = opts.loadConfig();
+    if (cfg) {
+      const h = opts.createHandler(cfg);
+      opts.setHandler(h);
+      await h.start(endpointCtx);
+      if (!wasRunning) await endpointCtx.update({ register: { blueprints: [opts.blueprint] } });
+    } else if (wasRunning) {
+      await endpointCtx.update({ unregister: { blueprints: [opts.blueprint] } });
+    }
+  }
+
+  async function applyConnectionConfig(overrides?: AiloConnectionConfig): Promise<void> {
+    const cfg = overrides ?? loadConnectionConfig(configPath);
+    if (!hasValidConfig(cfg)) return;
+    if (!endpointCtx && endpointConnecting) return;
+
+    endpointConnecting = true;
+    connectAttempt = 0;
+    try {
+      const blueprints = buildBlueprints(configPath);
+      runEndpoint({
+        ailoWsUrl: cfg.url,
+        ailoApiKey: cfg.apiKey,
+        endpointId: cfg.endpointId,
+        handler: {
+          start: async (ctx) => {
+            endpointCtx = ctx;
+            endpointConnecting = false;
+            connectAttempt = 0;
+            connectionState.connected = true;
+            connectionState.endpointId = cfg.endpointId;
+            webchatCtxRef = ctx;
+            lastMcpToolSnapshot = new Map(mcpManager.getAllPrivateTools().map((t) => [t.name, t]));
+            serverRef.notifyContextAttached();
+            await startPlatformHandlers(ctx, configPath);
+            console.log("[desktop] 桌面端点已启动");
+          },
+          stop: async () => {
+            await stopPlatformHandlers();
+            endpointCtx = null;
+            endpointConnecting = false;
+            connectionState.connected = false;
+            connectionState.endpointId = "";
+            webchatCtxRef = null;
+            await mcpManager.shutdown();
+            await stopBrowser();
+            console.log("[desktop] 桌面端点已停止");
+          },
+        },
+        caps: ["message", "tool_execute"],
+        blueprints,
+        tools: mcpManager.getAllPrivateTools(),
+        toolHandlers: buildToolHandlers(),
+        onUnknownTool: async (name: string, args: Record<string, unknown>) => {
+          const idx = name.indexOf(":");
+          if (idx > 0) {
+            const serverName = name.slice(0, idx);
+            const toolName = name.slice(idx + 1);
+            if (mcpManager.isRunning(serverName)) {
+              return mcpManager.executeToolCall(serverName, toolName, args);
+            }
+          }
+          throw new Error(`unknown tool: ${name}`);
+        },
+        onConnectFailure: async (err, client) => {
+          const delay = backoffDelayMs(connectAttempt++);
+          console.error(`[desktop] 连接失败，${(delay / 1000).toFixed(1)}s 后使用最新配置重试 (${err.message})`);
+          await new Promise((r) => setTimeout(r, delay));
+          const latest = loadConnectionConfig(configPath);
+          if (!hasValidConfig(latest)) {
+            endpointConnecting = false;
+            return;
+          }
+          try {
+            await client.reconnect(undefined, {
+              url: latest.url,
+              apiKey: latest.apiKey,
+              endpointId: latest.endpointId,
+            });
+          } catch (e) {
+            console.error("[desktop] 重试连接失败:", errMsg(e));
+          }
+        },
+      });
+    } catch (e) {
+      endpointConnecting = false;
+      throw e;
+    }
+  }
+
+  await initSubsystems();
+
+  const serverRef = startConfigServer({
+    mcpManager,
+    getConnectionStatus: () => connectionState,
+    getWebchatCtx: () => webchatCtxRef,
+    port,
+    configPath,
+    blueprintUrl: BLUEPRINT_URL,
+    blueprintLocalPath: join(BLUEPRINTS_DIR, "desktop-agent.blueprint.md"),
+    getBlueprintPaths: () => buildBlueprints(configPath),
+    onWebchatReady: (api) => { webchatApi = api; },
+    onRequestReconnect: async () => {
+      if (!endpointCtx) return;
+      await endpointCtx.client.reconnect([]);
+    },
+    onConnectionConfigSaved: async (config) => {
+      const cfg: AiloConnectionConfig = {
+        url: config.ailoWsUrl,
+        apiKey: config.ailoApiKey,
+        endpointId: config.endpointId,
+      };
+      if (endpointCtx) {
+        await endpointCtx.client.reconnect(undefined, cfg);
+      } else {
+        await applyConnectionConfig(cfg);
+      }
+    },
+    onFeishuConfigSaved: () => reloadPlatformHandler({
+      getHandler: () => feishuHandler,
+      setHandler: (h) => { feishuHandler = h; },
+      loadConfig: () => loadFeishuConfig(configPath),
+      createHandler: (cfg) => new FeishuHandler(cfg),
+      blueprint: BLUEPRINT_FEISHU,
+    }),
+    getFeishuStatus: () => ({
+      configured: !!loadFeishuConfig(configPath),
+      running: !!feishuHandler,
+    }),
+  });
+
+  const initial = loadConnectionConfig(configPath);
+  if (hasValidConfig(initial)) {
+    await applyConnectionConfig(initial);
+  } else {
+    console.log("[desktop] 未检测到 Ailo 连接配置，请在配置页填写并保存，将自动尝试连接（连不上会退避重试）。");
+    console.log(`[desktop] 配置界面: http://127.0.0.1:${port}`);
+  }
+}
+
+if (subcommand !== "init") {
+  main().catch((e) => {
+    console.error(e);
+    process.exit(1);
+  });
+}

package/src/mcp/config-manager.ts

@@ -0,0 +1,85 @@
+import { readFile, writeFile, mkdir, stat } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+export interface MCPServerConfig {
+  transport?: "stdio" | "sse";
+  command?: string;
+  args?: string[];
+  env?: Record<string, string>;
+  url?: string;
+  enabled?: boolean;
+}
+
+export interface MCPConfigFile {
+  mcpServers: Record<string, MCPServerConfig>;
+}
+
+const CONFIG_DIR = join(homedir(), ".agents");
+const CONFIG_PATH = join(CONFIG_DIR, "mcp_config.json");
+
+export class MCPConfigManager {
+  private configs = new Map<string, MCPServerConfig>();
+  private lastMtime = 0;
+
+  getConfigPath(): string {
+    return CONFIG_PATH;
+  }
+
+  async load(): Promise<void> {
+    try {
+      const raw = await readFile(CONFIG_PATH, "utf-8");
+      const data = JSON.parse(raw) as MCPConfigFile;
+      this.configs.clear();
+      for (const [name, cfg] of Object.entries(data.mcpServers ?? {})) {
+        this.configs.set(name, cfg);
+      }
+      try {
+        const s = await stat(CONFIG_PATH);
+        this.lastMtime = s.mtimeMs;
+      } catch {}
+    } catch {
+      // no config file yet
+    }
+  }
+
+  async save(): Promise<void> {
+    await mkdir(CONFIG_DIR, { recursive: true });
+    const data: MCPConfigFile = { mcpServers: Object.fromEntries(this.configs) };
+    await writeFile(CONFIG_PATH, JSON.stringify(data, null, 2), "utf-8");
+    try {
+      const s = await stat(CONFIG_PATH);
+      this.lastMtime = s.mtimeMs;
+    } catch {}
+  }
+
+  get(name: string): MCPServerConfig | undefined {
+    return this.configs.get(name);
+  }
+
+  set(name: string, config: MCPServerConfig): void {
+    this.configs.set(name, config);
+  }
+
+  delete(name: string): boolean {
+    return this.configs.delete(name);
+  }
+
+  getAll(): Map<string, MCPServerConfig> {
+    return new Map(this.configs);
+  }
+
+  getLastMtime(): number {
+    return this.lastMtime;
+  }
+
+  async checkChanged(): Promise<boolean> {
+    try {
+      const s = await stat(CONFIG_PATH);
+      return s.mtimeMs > this.lastMtime;
+    } catch {
+      return false;
+    }
+  }
+}

package/src/mcp/index.ts

@@ -0,0 +1,7 @@
+export { MCPConfigManager } from './config-manager.js';
+export type { MCPServerConfig, MCPConfigFile } from './config-manager.js';
+
+export { startStdioServer, startSSEServer, stopSession } from './session.js';
+export type { MCPSession, StdioSession, SSESession, PendingRPC } from './session.js';
+
+export { initializeSession, createStdioRpc, createSSERpc, handleSSEMessage } from './rpc.js';

package/src/mcp/rpc.ts

@@ -0,0 +1,131 @@
+import type { MCPSession, StdioSession, SSESession, PendingRPC } from "./session.js";
+import type { ToolCapability } from "@greatlhd/ailo-endpoint-sdk";
+
+export async function initializeSession(
+  session: MCPSession,
+  request: (method: string, params: unknown) => Promise<unknown>,
+  notify: (method: string, params: unknown) => void,
+): Promise<ToolCapability[]> {
+  await request("initialize", {
+    protocolVersion: "2024-11-05",
+    capabilities: {},
+    clientInfo: { name: "ailo-desktop", version: "1.0.0" },
+  });
+
+  notify("notifications/initialized", {});
+
+  const result = await request("tools/list", {}) as { tools?: Array<{ name: string; description?: string; inputSchema?: unknown }> };
+  const tools: ToolCapability[] = (result.tools ?? []).map((t) => ({
+    name: t.name,
+    description: t.description,
+    parameters: t.inputSchema as Record<string, unknown>,
+  }));
+  
+  return tools;
+}
+
+export function createStdioRpc(
+  session: StdioSession,
+): {
+  request: (method: string, params: unknown) => Promise<unknown>;
+  notify: (method: string, params: unknown) => void;
+  processBuffer: () => void;
+} {
+  const request = (method: string, params: unknown): Promise<unknown> => {
+    return new Promise((resolve, reject) => {
+      const id = session.nextId++;
+      session.pendingRequests.set(id, { resolve, reject });
+      const msg = JSON.stringify({ jsonrpc: "2.0", id, method, params });
+      session.proc.stdin?.write(msg + "\n");
+      setTimeout(() => {
+        if (session.pendingRequests.has(id)) {
+          session.pendingRequests.delete(id);
+          reject(new Error(`RPC timeout for ${method}`));
+        }
+      }, 30000);
+    });
+  };
+
+  const notify = (method: string, params: unknown): void => {
+    const msg = JSON.stringify({ jsonrpc: "2.0", method, params });
+    session.proc.stdin?.write(msg + "\n");
+  };
+
+  const processBuffer = (): void => {
+    const lines = session.buffer.split("\n");
+    session.buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const msg = JSON.parse(trimmed);
+        if (msg.id !== undefined && session.pendingRequests.has(msg.id)) {
+          const pending = session.pendingRequests.get(msg.id)!;
+          session.pendingRequests.delete(msg.id);
+          if (msg.error) pending.reject(new Error(msg.error.message ?? JSON.stringify(msg.error)));
+          else pending.resolve(msg.result);
+        }
+      } catch {}
+    }
+  };
+
+  return { request, notify, processBuffer };
+}
+
+export function createSSERpc(
+  session: SSESession,
+): {
+  request: (method: string, params: unknown) => Promise<unknown>;
+  notify: (method: string, params: unknown) => void;
+} {
+  const request = (method: string, params: unknown): Promise<unknown> => {
+    return new Promise((resolve, reject) => {
+      const id = session.nextId++;
+      session.pendingRequests.set(id, { resolve, reject });
+      const msg = JSON.stringify({ jsonrpc: "2.0", id, method, params });
+      fetch(session.messageEndpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: msg,
+        signal: session.abortController.signal,
+      }).catch((err) => {
+        if (session.pendingRequests.has(id)) {
+          session.pendingRequests.delete(id);
+          reject(new Error(`SSE POST failed: ${err.message}`));
+        }
+      });
+      setTimeout(() => {
+        if (session.pendingRequests.has(id)) {
+          session.pendingRequests.delete(id);
+          reject(new Error(`RPC timeout for ${method}`));
+        }
+      }, 30000);
+    });
+  };
+
+  const notify = (method: string, params: unknown): void => {
+    const msg = JSON.stringify({ jsonrpc: "2.0", method, params });
+    fetch(session.messageEndpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: msg,
+      signal: session.abortController.signal,
+    }).catch((err) => {
+      console.error(`[mcp:sse] notify POST failed:`, err.message);
+    });
+  };
+
+  return { request, notify };
+}
+
+export function handleSSEMessage(session: SSESession, data: string): void {
+  try {
+    const msg = JSON.parse(data);
+    if (msg.id !== undefined && session.pendingRequests.has(msg.id)) {
+      const pending = session.pendingRequests.get(msg.id)!;
+      session.pendingRequests.delete(msg.id);
+      if (msg.error) pending.reject(new Error(msg.error.message ?? JSON.stringify(msg.error)));
+      else pending.resolve(msg.result);
+    }
+  } catch {}
+}