cicy-desktop 1.0.8

package/src/main.js

@@ -0,0 +1,403 @@
+const { app: electronApp } = require("electron");
+const { default: contextMenu } = require("electron-context-menu");
+
+  // 🎯 添加右键上下文菜单
+  contextMenu({
+    showLookUpSelection: true,
+    showSearchWithGoogle: true,
+    showCopyImage: true,
+    showCopyImageAddress: true,
+    showSaveImageAs: true,
+    showCopyVideoAddress: true,
+    showSaveVideoAs: true,
+    showCopyLink: true,
+    showSaveLinkAs: true,
+    showInspectElement: true,
+    showServices: true,
+    labels: {
+      cut: '剪切',
+      copy: '复制',
+      paste: '粘贴',
+      selectAll: '全选',
+      reload: '重新加载',
+      forceReload: '强制重新加载',
+      toggleDevTools: '切换开发者工具',
+      inspectElement: '检查元素',
+      services: '服务',
+      lookUpSelection: '查找选中内容',
+      searchWithGoogle: '用 Google 搜索',
+      copyImage: '复制图片',
+      copyImageAddress: '复制图片地址',
+      saveImage: '保存图片',
+      copyVideoAddress: '复制视频地址',
+      saveVideo: '保存视频',
+      copyLink: '复制链接',
+      saveLinkAs: '链接另存为...'
+    }
+  });
+
+
+// Setup Electron flags IMMEDIATELY after require
+electronApp.commandLine.appendSwitch("ignore-certificate-errors");
+if (process.platform === "linux") {
+  process.env["ELECTRON_DISABLE_SECURITY_WARNINGS"] = "true";
+  // electronApp.commandLine.appendSwitch("disable-setuid-sandbox");
+  electronApp.commandLine.appendSwitch("log-level", "3");
+  electronApp.commandLine.appendSwitch("disable-notifications");
+  electronApp.commandLine.appendSwitch("ignore-certificate-errors");
+  if (process.env.ELECTRON_DISABLE_HTTP_CACHE === "1") {
+    electronApp.commandLine.appendSwitch("disable-http-cache");
+    electronApp.commandLine.appendSwitch("disable-application-cache");
+  }
+  electronApp.commandLine.appendSwitch("disable-geolocation");
+  electronApp.commandLine.appendSwitch("disable-dev-shm-usage");
+  electronApp.commandLine.appendSwitch("use-gl", "angle");
+  electronApp.commandLine.appendSwitch("use-angle", "swiftshader");
+}
+
+const http = require("http");
+const log = require("electron-log");
+const { z } = require("zod");
+const { config } = require("./config");
+const { createWindow } = require("./utils/window-utils");
+const { AuthManager } = require("./utils/auth");
+const { setupElectronFlags, setupErrorHandlers } = require("./server/electron-setup");
+const { parseArgs } = require("./server/args-parser");
+const { setupLogging, wrapLogger } = require("./server/logging");
+const { createExpressApp } = require("./server/express-app");
+const { createMcpServer, setupMcpRoutes } = require("./server/mcp-server");
+const { registerTool } = require("./server/tool-registry");
+
+// Setup
+// setupElectronFlags(); // Already done above
+setupErrorHandlers();
+
+// Parse arguments
+const { PORT, START_URL, PROXY, oneWindow } = parseArgs();
+config.port = PORT;
+if (PROXY) {
+  config.proxy = PROXY;
+  log.info(`[MCP] Global proxy enabled: ${PROXY}`);
+}
+if (oneWindow) {
+  config.oneWindow = true;
+  log.info("[MCP] Single window mode enabled");
+}
+
+// Setup logging
+setupLogging(config);
+wrapLogger();
+
+log.info("[MCP] Server starting at", new Date().toISOString());
+
+// Initialize auth
+const authManager = new AuthManager();
+global.authManager = authManager; // Make it globally accessible
+const authMiddleware = (req, res, next) => {
+  if (!authManager.validateAuth(req)) {
+    res.setHeader("WWW-Authenticate", 'Basic realm="Electron MCP"');
+    return res.status(401).json({ error: "Unauthorized" });
+  }
+  next();
+};
+
+// Create servers
+const mcpServer = createMcpServer();
+const tools = {};
+const app = createExpressApp(authMiddleware, tools);
+
+// Register tools
+const toolModules = require("./tools");
+
+toolModules.forEach((module) => {
+  module((title, description, schema, handler, options) => {
+    registerTool(mcpServer, tools, title, description, schema, handler, options);
+  });
+});
+
+// Setup MCP routes
+setupMcpRoutes(app, mcpServer, authMiddleware);
+
+// RPC endpoint with hot reload
+app.post("/rpc/tools/call", authMiddleware, async (req, res) => {
+  let body = req.body;
+
+  // Parse YAML if Content-Type is application/yaml
+  if (req.get("Content-Type")?.includes("application/yaml")) {
+    try {
+      const yaml = require("js-yaml");
+      const rawBody = await new Promise((resolve) => {
+        let data = "";
+        req.on("data", (chunk) => (data += chunk));
+        req.on("end", () => resolve(data));
+      });
+      body = yaml.load(rawBody);
+    } catch (error) {
+      return res.status(400).json({ error: `Invalid YAML: ${error.message}` });
+    }
+  }
+
+  const { name, arguments: args } = body;
+  try {
+    // Re-load tool modules
+    const toolModules = require("./tools");
+
+    let handler = null;
+    let schema = null;
+
+    toolModules.forEach((module) => {
+      module((title, description, toolSchema, toolHandler, options) => {
+        if (title === name) {
+          handler = toolHandler;
+          schema = toolSchema;
+        }
+      });
+    });
+
+    if (!handler) {
+      throw new Error(`Tool '${name}' not found`);
+    }
+
+    const validatedArgs = schema.parse(args || {});
+    const result = await handler(validatedArgs);
+
+    // Support YAML response
+    const accept = req.headers.accept || "application/json";
+    if (accept.includes("application/yaml") || accept.includes("text/yaml")) {
+      const yaml = require("js-yaml");
+      res.type("yaml").send(yaml.dump({ result }));
+    } else {
+      res.json({ result });
+    }
+  } catch (error) {
+    // Handle Zod validation errors
+    if (error.name === "ZodError") {
+      const errorMsg = error.errors.map((e) => e.message).join(", ");
+      return res.json({
+        result: {
+          content: [{ type: "text", text: errorMsg }],
+          isError: true,
+        },
+      });
+    }
+    res.status(500).json({ error: error.message });
+  }
+});
+
+app.get("/rpc/tools", authMiddleware, (req, res) => {
+  const accept = req.headers.accept || "application/json";
+  const allTools = Object.values(tools).flat();
+
+  if (accept.includes("application/yaml") || accept.includes("text/yaml")) {
+    const yaml = require("js-yaml");
+    res.type("yaml").send(yaml.dump({ tools: allTools }));
+  } else {
+    res.json({ tools: allTools });
+  }
+});
+
+// Static file server for uploads/downloads
+const fs = require("fs");
+const path = require("path");
+const serveIndex = require("serve-index");
+const FILES_DIR = path.join(require("os").homedir(), "electron-mcp-files");
+if (!fs.existsSync(FILES_DIR)) {
+  fs.mkdirSync(FILES_DIR, { recursive: true });
+}
+
+// Serve files with directory listing (auth required)
+app.use("/files", authMiddleware, require("express").static(FILES_DIR));
+app.use("/files", authMiddleware, serveIndex(FILES_DIR, { icons: true, view: "details" }));
+
+// Dynamic tool endpoints: /rpc/{tool_name}
+Object.values(tools)
+  .flat()
+  .forEach((tool) => {
+    app.post(`/rpc/${tool.name}`, authMiddleware, async (req, res) => {
+      let body = req.body;
+
+      // Parse YAML if Content-Type is application/yaml
+      if (req.get("Content-Type")?.includes("application/yaml")) {
+        try {
+          const yaml = require("js-yaml");
+          const rawBody = await new Promise((resolve) => {
+            let data = "";
+            req.on("data", (chunk) => (data += chunk));
+            req.on("end", () => resolve(data));
+          });
+          body = yaml.load(rawBody) || {};
+        } catch (error) {
+          return res.status(400).json({ error: `Invalid YAML: ${error.message}` });
+        }
+      }
+
+      try {
+        // Re-load tool modules
+        const toolModules = require("./tools");
+
+        let handler = null;
+        let schema = null;
+
+        toolModules.forEach((module) => {
+          module((name, desc, inputSchema, fn) => {
+            if (name === tool.name) {
+              handler = fn;
+              schema = inputSchema;
+            }
+          });
+        });
+
+        if (!handler) {
+          throw new Error(`Tool '${tool.name}' not found`);
+        }
+
+        const validatedArgs = schema.parse(body || {});
+        const result = await handler(validatedArgs);
+
+        // Support YAML response
+        const accept = req.headers.accept || "application/json";
+        if (accept.includes("application/yaml") || accept.includes("text/yaml")) {
+          const yaml = require("js-yaml");
+          res.type("yaml").send(yaml.dump({ result }));
+        } else {
+          res.json({ result });
+        }
+      } catch (error) {
+        if (error.name === "ZodError") {
+          const errorMsg = error.errors.map((e) => e.message).join(", ");
+          return res.json({
+            result: {
+              content: [{ type: "text", text: errorMsg }],
+              isError: true,
+            },
+          });
+        }
+        res.status(500).json({ error: error.message });
+      }
+    });
+  });
+
+
+
+// File upload to path: curl --data-binary @local.js http://localhost:8101/rpc/upload/C:/Users/Administrator/data/file.js
+app.post("/rpc/upload/*", authMiddleware, require("express").raw({ type: "*/*", limit: "10mb" }), (req, res) => {
+  try {
+    const filePath = req.params[0];
+    if (!filePath) return res.status(400).json({ error: "Missing path" });
+    const dir = require("path").dirname(filePath);
+    if (!require("fs").existsSync(dir)) require("fs").mkdirSync(dir, { recursive: true });
+    require("fs").writeFileSync(filePath, req.body);
+    const size = require("fs").statSync(filePath).size;
+    res.json({ success: true, path: filePath, size });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// File upload + execute: curl -X POST --data-binary @local.js http://localhost:8101/rpc/exec/node
+// Supported types: shell, python, node, js (js = browser exec_js)
+app.post("/rpc/exec/:type", authMiddleware, require("express").text({ type: "*/*", limit: "10mb" }), async (req, res) => {
+  const type = req.params.type;
+  const body = typeof req.body === "string" ? req.body : req.body.toString("utf-8");
+  if (!body) return res.status(400).json({ error: "Empty body" });
+
+  const TMP = require("path").join(require("os").homedir(), "tmp");
+  if (!require("fs").existsSync(TMP)) require("fs").mkdirSync(TMP, { recursive: true });
+
+  try {
+    // Re-load tools for hot reload
+    const toolModules = require("./tools");
+    const toolName = type === "js" ? "exec_js_file" : `exec_${type}_file`;
+    let handler = null, schema = null;
+    toolModules.forEach((module) => {
+      module((name, desc, toolSchema, fn) => {
+        if (name === toolName) { handler = fn; schema = toolSchema; }
+      });
+    });
+    if (!handler) return res.status(404).json({ error: `Unknown type: ${type}` });
+
+    const result = await handler({ content: body, win_id: parseInt(req.query.win_id) || 1 });
+    res.json({ result });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// Start server
+const server = http.createServer(app);
+
+// 必须在 whenReady 之前设置调试端口
+electronApp.commandLine.appendSwitch("remote-debugging-port", "9221");
+log.info("[MCP] Remote debugging enabled on port 9221");
+
+// IPC Bridge: expose all RPC tools to renderer via ipcMain.handle
+const { ipcMain } = require("electron");
+ipcMain.handle("rpc", async (event, toolName, args) => {
+  console.log("[IPC Bridge] called:", toolName, JSON.stringify(args));
+  try {
+  const toolModules = require("./tools");
+  let handler = null, schema = null;
+  toolModules.forEach((module) => {
+    module((name, desc, toolSchema, fn) => {
+      if (name === toolName) { handler = fn; schema = toolSchema; }
+    });
+  });
+  if (!handler) throw new Error("Tool '" + toolName + "' not found");
+  const validatedArgs = schema.parse(args || {});
+  const result = await handler(validatedArgs);
+  console.log("[IPC Bridge] success:", toolName);
+  return result;
+  } catch(e) { console.error("[IPC Bridge] error:", toolName, e.message); throw e; }
+});
+console.log("[IPC Bridge] All RPC tools available via ipcRenderer.invoke('rpc', toolName, args)");
+
+electronApp.whenReady().then(() => {
+
+  // 为 webview partition 设置代理
+  if (config.proxy) {
+    const { session } = require("electron");
+    const mainSession = session.fromPartition("persist:main");
+    mainSession.setProxy({
+      proxyRules: config.proxy
+    }).then(() => {
+      log.info(`[Proxy] persist:main partition 已设置代理: ${config.proxy}`);
+    }).catch(err => {
+      log.error("[Proxy] persist:main partition 设置代理失败:", err);
+    });
+  }
+  server.listen(PORT, () => {
+    log.info(`[MCP] Log file: ${config.logFilePath}`);
+    log.info(`[MCP] Server listening on http://localhost:${PORT}`);
+    log.info(`[MCP] SSE endpoint: http://localhost:${PORT}/mcp`);
+    log.info(`[MCP] REST API docs: http://localhost:${PORT}/docs`);
+    log.info(`[MCP] Remote debugger: http://localhost:9221`);
+
+      createWindow({ url: START_URL ||"https://ide.cicy.de5.net"}, 0);
+
+  });
+});
+
+electronApp.on("window-all-closed", () => {
+  // Keep app running
+});
+
+function cleanup() {
+  log.info("[MCP] Server shutting down");
+  server.close();
+  electronApp.quit();
+}
+
+process.on("SIGTERM", cleanup);
+
+// 为所有 session（包括 webview partition）设置代理
+electronApp.on('session-created', (session) => {
+  if (config.proxy) {
+    session.setProxy({
+      proxyRules: config.proxy
+    }).then(() => {
+      log.info(`[Proxy] Session ${session.partition || 'default'} 已设置代理: ${config.proxy}`);
+    }).catch(err => {
+      log.error(`[Proxy] Session ${session.partition || 'default'} 设置代理失败:`, err);
+    });
+  }
+});

package/src/preload-rpc.js

@@ -0,0 +1,4 @@
+const { contextBridge, ipcRenderer } = require("electron");
+contextBridge.exposeInMainWorld("electronRPC", {
+  invoke: (toolName, args) => ipcRenderer.invoke("rpc", toolName, args),
+});

package/src/server/args-parser.js

@@ -0,0 +1,37 @@
+function parseArgs() {
+  const args = process.argv.slice(2);
+
+  let PORT = args.find((arg) => arg.startsWith("--port="))?.split("=")[1];
+  if (!PORT) {
+    const portIndex = args.indexOf("--port");
+    if (portIndex !== -1 && args[portIndex + 1]) {
+      PORT = args[portIndex + 1];
+    }
+  }
+  if (!PORT) {
+    PORT = process.env.PORT;
+  }
+  PORT = parseInt(PORT) || 8101;
+
+  let START_URL = args.find((arg) => arg.startsWith("--url="))?.split("=")[1];
+  if (!START_URL) {
+    const urlIndex = args.indexOf("--url");
+    if (urlIndex !== -1 && args[urlIndex + 1]) {
+      START_URL = args[urlIndex + 1];
+    }
+  }
+
+  let PROXY = args.find((arg) => arg.startsWith("--proxy="))?.split("=")[1];
+  if (!PROXY) {
+    const proxyIndex = args.indexOf("--proxy");
+    if (proxyIndex !== -1 && args[proxyIndex + 1]) {
+      PROXY = args[proxyIndex + 1];
+    }
+  }
+
+  const oneWindow = args.includes("--one-window");
+
+  return { PORT, START_URL, PROXY, oneWindow };
+}
+
+module.exports = { parseArgs };

package/src/server/electron-setup.js

@@ -0,0 +1,33 @@
+const { app: electronApp } = require("electron");
+const log = require("electron-log");
+
+function setupElectronFlags() {
+  // Must be called before app.whenReady()
+  electronApp.commandLine.appendSwitch("no-sandbox");
+  electronApp.commandLine.appendSwitch("disable-setuid-sandbox");
+
+  if (process.platform === "linux") {
+    process.env["ELECTRON_DISABLE_SECURITY_WARNINGS"] = "true";
+    electronApp.commandLine.appendSwitch("log-level", "3");
+    electronApp.commandLine.appendSwitch("disable-notifications");
+    electronApp.commandLine.appendSwitch("disable-geolocation");
+    electronApp.commandLine.appendSwitch("disable-dev-shm-usage");
+    electronApp.commandLine.appendSwitch("disable-gpu");
+    electronApp.commandLine.appendSwitch("disable-software-rasterizer");
+    electronApp.commandLine.appendSwitch("disable-gpu-compositing");
+    electronApp.commandLine.appendSwitch("disable-gpu-rasterization");
+    electronApp.commandLine.appendSwitch("use-gl", "swiftshader");
+  }
+}
+
+function setupErrorHandlers() {
+  process.on("uncaughtException", (error) => {
+    log.error("[Uncaught Exception]", error);
+  });
+
+  process.on("unhandledRejection", (reason, promise) => {
+    log.error("[Unhandled Rejection]", reason);
+  });
+}
+
+module.exports = { setupElectronFlags, setupErrorHandlers };

package/src/server/express-app.js

@@ -0,0 +1,166 @@
+const express = require("express");
+const cors = require("cors");
+const path = require("path");
+const uiRoutes = require("./ui-routes");
+
+function createExpressApp(authMiddleware, tools = {}) {
+  const app = express();
+
+  app.use(
+    cors({
+      origin: "*",
+      methods: ["GET", "POST", "OPTIONS"],
+      allowedHeaders: ["Content-Type", "Authorization"],
+    })
+  );
+
+  app.use(express.json());
+  app.use(express.text());
+
+  // Health check - no auth
+  app.get("/ping", (req, res) => {
+    res.json({ ping: "pong", ts: Date.now() });
+  });
+
+  // Swagger UI
+  app.get("/docs", (req, res) => {
+    const htmlPath = path.join(__dirname, "../swagger-ui.html");
+    res.sendFile(htmlPath);
+  });
+
+  // OpenAPI spec - dynamic generation, no auth
+  app.get("/openapi.json", (req, res) => {
+    const acceptHeader = req.get("Accept") || "application/json";
+    const useYaml = acceptHeader.includes("application/yaml");
+
+    const allTools = Object.entries(tools).flatMap(([tag, toolList]) =>
+      toolList.map((tool) => ({ ...tool, tag }))
+    );
+
+    const openapi = {
+      openapi: "3.0.0",
+      info: {
+        title: "Electron MCP REST API",
+        version: "1.0.0",
+        description: `REST API for Electron MCP tools - ${allTools.length} tools available`,
+      },
+      servers: [
+        {
+          url: "https://g-electron.cicy.de5.net",
+          description: "Remote server",
+        },
+      ],
+      components: {
+        securitySchemes: {
+          bearerAuth: {
+            type: "http",
+            scheme: "bearer",
+            bearerFormat: "token",
+          },
+        },
+      },
+      security: [{ bearerAuth: [] }],
+      paths: {
+        "/rpc/tools": {
+          get: {
+            summary: "List all available tools",
+            tags: ["Tools"],
+            security: [{ bearerAuth: [] }],
+            responses: {
+              200: {
+                description: "List of tools",
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object",
+                      properties: {
+                        tools: {
+                          type: "array",
+                          items: {
+                            type: "object",
+                            properties: {
+                              name: { type: "string" },
+                              description: { type: "string" },
+                            },
+                          },
+                        },
+                      },
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    };
+
+    // Generate endpoint for each tool
+    allTools.forEach((tool) => {
+      openapi.paths[`/rpc/${tool.name}`] = {
+        post: {
+          summary: tool.name,
+          description: tool.description,
+          tags: [tool.tag],
+          security: [{ bearerAuth: [] }],
+          requestBody: {
+            required: true,
+            content: {
+              "application/yaml": {
+                schema: tool.inputSchema,
+              },
+              "application/json": {
+                schema: tool.inputSchema,
+              },
+            },
+          },
+          responses: {
+            200: {
+              description: "Tool execution result",
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object",
+                    properties: {
+                      content: {
+                        type: "array",
+                        items: {
+                          type: "object",
+                          properties: {
+                            type: { type: "string" },
+                            text: { type: "string" },
+                          },
+                        },
+                      },
+                    },
+                  },
+                },
+              },
+            },
+            404: { description: "Tool not found" },
+            500: { description: "Execution error" },
+          },
+        },
+      };
+    });
+
+    if (useYaml) {
+      const yaml = require("js-yaml");
+      res.type("application/yaml").send(yaml.dump(openapi));
+    } else {
+      res.json(openapi);
+    }
+  });
+
+  // Serve UI page (no auth — page handles token itself)
+  app.get("/ui", (req, res) => {
+    res.sendFile(path.join(__dirname, "../ui.html"));
+  });
+
+  // Mount UI API routes
+  app.use("/ui", uiRoutes);
+
+  return app;
+}
+
+module.exports = { createExpressApp };