cicy-desktop 1.0.8

package/src/server/logging.js

@@ -0,0 +1,58 @@
+const log = require("electron-log");
+const path = require("path");
+const fs = require("fs");
+
+function setupLogging(config) {
+  const logsDir = path.join(require("electron").app.getPath("home"), "logs");
+  if (!fs.existsSync(logsDir)) {
+    fs.mkdirSync(logsDir, { recursive: true });
+  }
+
+  config.logsDir = logsDir;
+  config.logFilePath = path.join(logsDir, `electron-mcp-${config.port}.log`);
+
+  log.transports.file.resolvePathFn = () => config.logFilePath;
+  log.transports.file.format = "{y}-{m}-{d} {h}:{i}:{s}.{ms} [{level}] {text}";
+  log.transports.console.format = "{y}-{m}-{d} {h}:{i}:{s}.{ms} [{level}] {text}";
+}
+
+function getCallerInfo() {
+  const stack = new Error().stack.split("\n");
+  const callerLine = stack[3] || "";
+  const match = callerLine.match(/\((.+):(\d+):(\d+)\)/) || callerLine.match(/at (.+):(\d+):(\d+)/);
+  if (match) {
+    const file = match[1].split("/").pop();
+    const line = match[2];
+    return `${file}:${line}`;
+  }
+  return "";
+}
+
+function wrapLogger() {
+  const originalInfo = log.info.bind(log);
+  const originalError = log.error.bind(log);
+  const originalWarn = log.warn.bind(log);
+  const originalDebug = log.debug.bind(log);
+
+  log.info = (...args) => {
+    const caller = getCallerInfo();
+    originalInfo(args.join(" ") + (caller ? ` (${caller})` : ""));
+  };
+
+  log.error = (...args) => {
+    const caller = getCallerInfo();
+    originalError(args.join(" ") + (caller ? ` (${caller})` : ""));
+  };
+
+  log.warn = (...args) => {
+    const caller = getCallerInfo();
+    originalWarn(args.join(" ") + (caller ? ` (${caller})` : ""));
+  };
+
+  log.debug = (...args) => {
+    const caller = getCallerInfo();
+    originalDebug(args.join(" ") + (caller ? ` (${caller})` : ""));
+  };
+}
+
+module.exports = { setupLogging, wrapLogger };

package/src/server/mcp-server.js

@@ -0,0 +1,53 @@
+const { McpServer } = require("@modelcontextprotocol/sdk/server/mcp.js");
+const { SSEServerTransport } = require("@modelcontextprotocol/sdk/server/sse.js");
+const log = require("electron-log");
+
+const transports = new Map();
+
+function createMcpServer() {
+  return new McpServer({
+    name: "electron-mcp",
+    version: "1.0.0",
+  });
+}
+
+function createTransport(res, sessionId) {
+  const transport = new SSEServerTransport("/messages", res);
+  transports.set(sessionId, transport);
+
+  res.on("close", () => {
+    transports.delete(sessionId);
+    log.debug(`[MCP] SSE connection closed: ${sessionId}`);
+  });
+
+  return transport;
+}
+
+function setupMcpRoutes(app, mcpServer, authMiddleware) {
+  app.get("/mcp", authMiddleware, async (req, res) => {
+    const sessionId = req.query.sessionId || req.headers["x-session-id"];
+    if (!sessionId) {
+      return res.status(400).json({ error: "sessionId required" });
+    }
+
+    log.debug(`[MCP] SSE connection established: ${sessionId}`);
+    const transport = createTransport(res, sessionId);
+    await mcpServer.connect(transport);
+  });
+
+  app.post("/messages", authMiddleware, async (req, res) => {
+    const sessionId = req.body.sessionId || req.headers["x-session-id"];
+    if (!sessionId) {
+      return res.status(400).json({ error: "sessionId required" });
+    }
+
+    const transport = transports.get(sessionId);
+    if (transport) {
+      await transport.handlePostMessage(req, res);
+    } else {
+      res.status(400).json({ error: `No active SSE connection for session: ${sessionId}` });
+    }
+  });
+}
+
+module.exports = { createMcpServer, setupMcpRoutes };

package/src/server/tool-registry.js

@@ -0,0 +1,77 @@
+const { z } = require("zod");
+
+function zodToJsonSchema(zodSchema) {
+  const shape = zodSchema._def.shape ? zodSchema._def.shape() : {};
+  const properties = {};
+  const required = [];
+
+  for (const [key, value] of Object.entries(shape)) {
+    let fieldDef = value._def;
+    let fieldSchema = { type: "string" };
+
+    // Unwrap ZodOptional and ZodDefault
+    while (fieldDef.typeName === "ZodOptional" || fieldDef.typeName === "ZodDefault") {
+      if (fieldDef.typeName === "ZodDefault") {
+        fieldSchema.default = fieldDef.defaultValue();
+      }
+      fieldDef = fieldDef.innerType?._def || fieldDef;
+    }
+
+    // Map Zod types to JSON Schema types
+    if (fieldDef.typeName === "ZodNumber") {
+      fieldSchema.type = "integer";
+    } else if (fieldDef.typeName === "ZodString") {
+      fieldSchema.type = "string";
+    } else if (fieldDef.typeName === "ZodBoolean") {
+      fieldSchema.type = "boolean";
+    } else if (fieldDef.typeName === "ZodArray") {
+      fieldSchema.type = "array";
+      fieldSchema.items = { type: "string" };
+    } else if (fieldDef.typeName === "ZodObject") {
+      fieldSchema.type = "object";
+    }
+
+    if (fieldDef.description || value._def.description) {
+      fieldSchema.description = fieldDef.description || value._def.description;
+    }
+
+    const isOptional = value.isOptional && value.isOptional();
+    if (!isOptional) {
+      required.push(key);
+    }
+
+    properties[key] = fieldSchema;
+  }
+
+  return {
+    type: "object",
+    properties,
+    required: required.length > 0 ? required : undefined,
+  };
+}
+
+function registerTool(mcpServer, tools, title, description, schema, handler, options = {}) {
+  const inputSchema = zodToJsonSchema(schema);
+  const tag = options.tag || "General";
+
+  if (!tools[tag]) tools[tag] = [];
+  tools[tag].push({
+    name: title,
+    description,
+    inputSchema,
+  });
+
+  mcpServer.tool(title, description, inputSchema, async (args) => {
+    try {
+      const validatedArgs = schema.parse(args);
+      return await handler(validatedArgs);
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: `Error: ${error.message}` }],
+        isError: true,
+      };
+    }
+  });
+}
+
+module.exports = { zodToJsonSchema, registerTool };

package/src/server/ui-routes.js

@@ -0,0 +1,81 @@
+const express = require("express");
+const { BrowserWindow } = require("electron");
+const router = express.Router();
+
+function uiAuth(req, res, next) {
+  const manager = global.authManager;
+  const queryToken = req.query.token;
+  if (queryToken && queryToken === manager.getToken()) return next();
+  if (manager.validateAuth(req)) return next();
+  res.status(401).json({ error: "Unauthorized" });
+}
+
+// GET /ui/windows → JSON list of all BrowserWindows
+router.get("/windows", uiAuth, (req, res) => {
+  const wins = BrowserWindow.getAllWindows().map((w) => ({
+    win_id: w.id,
+    title: w.getTitle(),
+    url: w.webContents.getURL(),
+    bounds: w.getBounds(),
+    isVisible: w.isVisible(),
+    isDestroyed: w.isDestroyed(),
+  }));
+  res.json({ windows: wins });
+});
+
+// GET /ui/snapshot?win_id=X[&quality=80] → JPEG image, scaled to 50% of window size
+router.get("/snapshot", uiAuth, async (req, res) => {
+  const winId = parseInt(req.query.win_id);
+  if (isNaN(winId)) return res.status(400).json({ error: "win_id required" });
+  const win = BrowserWindow.fromId(winId);
+  if (!win) return res.status(404).json({ error: "Window not found" });
+  const quality = Math.min(100, Math.max(1, parseInt(req.query.quality) || 80));
+  const scale = Math.min(1, Math.max(0.1, parseFloat(req.query.scale) || 0.5));
+  try {
+    const image = await win.webContents.capturePage();
+    const { width, height } = image.getSize();
+    const scaled = image.resize({
+      width: Math.max(1, Math.floor(width * scale)),
+      height: Math.max(1, Math.floor(height * scale)),
+    });
+    const buf = scaled.toJPEG(quality);
+    res.set("Content-Type", "image/jpeg");
+    res.set("Cache-Control", "no-store");
+    res.send(buf);
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
+// POST /ui/close-window { win_id }
+router.post("/close-window", uiAuth, (req, res) => {
+  const winId = parseInt(req.body.win_id);
+  if (isNaN(winId)) return res.status(400).json({ error: "win_id required" });
+  const win = BrowserWindow.fromId(winId);
+  if (!win) return res.status(404).json({ error: "Window not found" });
+  win.destroy();
+  res.json({ ok: true });
+});
+
+// POST /ui/close-all
+router.post("/close-all", uiAuth, (req, res) => {
+  BrowserWindow.getAllWindows().forEach((w) => w.destroy());
+  res.json({ ok: true });
+});
+
+// POST /ui/set-bounds { win_id, x, y, width, height }
+router.post("/set-bounds", uiAuth, (req, res) => {
+  const winId = parseInt(req.body.win_id);
+  if (isNaN(winId)) return res.status(400).json({ error: "win_id required" });
+  const win = BrowserWindow.fromId(winId);
+  if (!win) return res.status(404).json({ error: "Window not found" });
+  const bounds = {};
+  if (req.body.x !== undefined) bounds.x = parseInt(req.body.x);
+  if (req.body.y !== undefined) bounds.y = parseInt(req.body.y);
+  if (req.body.width !== undefined) bounds.width = parseInt(req.body.width);
+  if (req.body.height !== undefined) bounds.height = parseInt(req.body.height);
+  win.setBounds(bounds);
+  res.json({ ok: true, bounds: win.getBounds() });
+});
+
+module.exports = router;

package/src/swagger-ui.html

@@ -0,0 +1,41 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>Electron MCP API</title>
+  <link rel="stylesheet" type="text/css" href="https://unpkg.com/swagger-ui-dist@5/swagger-ui.css">
+  <style>
+    .swagger-ui .topbar { display: none }
+  </style>
+</head>
+<body>
+  <div id="swagger-ui"></div>
+  <script src="https://unpkg.com/swagger-ui-dist@5/swagger-ui-bundle.js"></script>
+  <script>
+    window.onload = function() {
+      SwaggerUIBundle({
+        url: "/openapi.json",
+        dom_id: '#swagger-ui',
+        deepLinking: true,
+        presets: [
+          SwaggerUIBundle.presets.apis,
+          SwaggerUIBundle.SwaggerUIStandalonePreset
+        ],
+        requestInterceptor: function(request) {
+          // 移除默认的 accept 头，只保留 application/yaml
+          delete request.headers['accept'];
+          request.headers['Accept'] = 'application/yaml';
+          
+          // 从 localStorage 读取 token 并添加到请求
+          const token = localStorage.getItem('MCP_TOKEN');
+          if (token) {
+            request.headers['Authorization'] = 'Bearer ' + token;
+          }
+          
+          return request;
+        }
+      });
+    };
+  </script>
+</body>
+</html>

package/src/tools/account-tools.js

@@ -0,0 +1,194 @@
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const { z } = require("zod");
+
+const ACCOUNT_DIR = path.join(os.homedir(), "data", "electron");
+
+module.exports = (registerTool) => {
+  // 获取账户信息
+  registerTool(
+    "get_account",
+    "获取指定账户的配置信息，包括窗口列表、创建时间等",
+    z.object({
+      accountIdx: z.number().describe("账户索引"),
+    }),
+    async ({ accountIdx }) => {
+      try {
+        const accountFile = path.join(ACCOUNT_DIR, `account-${accountIdx}.json`);
+
+        if (!fs.existsSync(accountFile)) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({ error: `Account ${accountIdx} not found` }, null, 2),
+              },
+            ],
+            isError: true,
+          };
+        }
+
+        const accountData = JSON.parse(fs.readFileSync(accountFile, "utf-8"));
+
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(accountData, null, 2),
+            },
+          ],
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error.message}` }],
+          isError: true,
+        };
+      }
+    },
+    { tag: "Account" }
+  );
+
+  // 保存账户信息
+  registerTool(
+    "save_account_info",
+    "保存或更新账户配置信息",
+    z.object({
+      accountIdx: z.number().describe("账户索引"),
+      metadata: z
+        .object({
+          description: z.string().optional().describe("账户描述"),
+          tags: z.array(z.string()).optional().describe("标签"),
+        })
+        .optional(),
+    }),
+    async ({ accountIdx, metadata }) => {
+      try {
+        // 确保目录存在
+        if (!fs.existsSync(ACCOUNT_DIR)) {
+          fs.mkdirSync(ACCOUNT_DIR, { recursive: true });
+        }
+
+        const accountFile = path.join(ACCOUNT_DIR, `account-${accountIdx}.json`);
+
+        let accountData;
+
+        if (fs.existsSync(accountFile)) {
+          // 更新现有账户
+          accountData = JSON.parse(fs.readFileSync(accountFile, "utf-8"));
+          if (metadata) {
+            accountData.metadata = { ...accountData.metadata, ...metadata };
+          }
+          accountData.updatedAt = new Date().toISOString();
+        } else {
+          // 创建新账户
+          accountData = {
+            accountIdx,
+            createdAt: new Date().toISOString(),
+            windows: [],
+            metadata: metadata || {
+              description: `Account ${accountIdx}`,
+              tags: [],
+            },
+            updatedAt: new Date().toISOString(),
+          };
+        }
+
+        fs.writeFileSync(accountFile, JSON.stringify(accountData, null, 2));
+
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({ success: true, account: accountData }, null, 2),
+            },
+          ],
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error.message}` }],
+          isError: true,
+        };
+      }
+    },
+    { tag: "Account" }
+  );
+
+  // 列出所有账户
+  registerTool(
+    "list_accounts",
+    "列出所有已创建的账户",
+    z.object({}),
+    async () => {
+      try {
+        if (!fs.existsSync(ACCOUNT_DIR)) {
+          return {
+            content: [{ type: "text", text: JSON.stringify([], null, 2) }],
+          };
+        }
+
+        const files = fs.readdirSync(ACCOUNT_DIR);
+        const accounts = files
+          .filter((f) => f.startsWith("account-") && f.endsWith(".json"))
+          .map((f) => {
+            const accountFile = path.join(ACCOUNT_DIR, f);
+            return JSON.parse(fs.readFileSync(accountFile, "utf-8"));
+          })
+          .sort((a, b) => a.accountIdx - b.accountIdx);
+
+        return {
+          content: [{ type: "text", text: JSON.stringify(accounts, null, 2) }],
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error.message}` }],
+          isError: true,
+        };
+      }
+    },
+    { tag: "Account" }
+  );
+
+  // 设置账户代理
+  registerTool(
+    "set_account_proxy",
+    "为指定账户设置代理，该账户下所有窗口都会使用此代理",
+    z.object({
+      accountIdx: z.number().describe("账户索引"),
+      proxy: z.string().optional().describe("代理地址，如 http://127.0.0.1:8888，留空则清除代理"),
+    }),
+    async ({ accountIdx, proxy }) => {
+      try {
+        const { session } = require("electron");
+        const ses = session.fromPartition(`persist:sandbox-${accountIdx}`);
+
+        if (proxy) {
+          await ses.setProxy({ proxyRules: proxy });
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({ success: true, accountIdx, proxy }, null, 2),
+              },
+            ],
+          };
+        } else {
+          await ses.setProxy({ proxyRules: "" });
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({ success: true, accountIdx, proxy: "cleared" }, null, 2),
+              },
+            ],
+          };
+        }
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error.message}` }],
+          isError: true,
+        };
+      }
+    },
+    { tag: "Account" }
+  );};