desktop-pet-app 0.1.1 → 0.2.1

package/out/main/index.js

@@ -110,6 +110,7 @@ const PET_EVENT = "pet:event";
 const PET_MOVE = "pet:move";
 const PET_DRAG = "pet:drag";
 const PET_MENU = "pet:menu";
+const PET_MOUSE_PASSTHROUGH = "pet:mouse-passthrough";
 const P2P_SIGNAL_IN = "p2p:signal-in";
 const P2P_SIGNAL_OUT = "p2p:signal-out";
 const P2P_CONFIG = "p2p:config";
@@ -342,7 +343,7 @@ function validate(credentials) {
     throw new Error("设备配置的 serverUrl 必须使用 http 或 https");
   }
 }
-const DEFAULT_DESKTOP_PET_HOST = "http://47.94.20.104";
+const DEFAULT_DESKTOP_PET_HOST = "https://deskpalai.com";
 function configuredRelayURL() {
   const host = process.env.DESKTOP_PET_HOST?.trim();
   if (host) return relayURLFromHost(host);
@@ -443,6 +444,32 @@ function showDesktopNotification(title, body) {
   if (!electron.Notification.isSupported()) return;
   new electron.Notification({ title, body }).show();
 }
+function p2pSigningPayload(message, fromDeviceId) {
+  const signalJSON = JSON.stringify(message.signal ?? null);
+  const signalHash = node_crypto.createHash("sha256").update(signalJSON).digest("hex");
+  return [
+    message.type,
+    message.taskId ?? "",
+    message.sessionId ?? "",
+    fromDeviceId,
+    message.toDeviceId ?? "",
+    message.expiresAt ?? "",
+    signalHash
+  ].join("\n");
+}
+function verifyP2PSignal(message) {
+  if (!message.signature || !message.publicKey || !message.fromDeviceId || !message.taskId || !message.sessionId || !message.toDeviceId || !message.expiresAt) return false;
+  try {
+    return node_crypto.verify(
+      null,
+      Buffer.from(p2pSigningPayload(message, message.fromDeviceId)),
+      message.publicKey,
+      Buffer.from(message.signature, "base64")
+    );
+  } catch {
+    return false;
+  }
+}
 let serverURL = configuredRelayURL();
 let userID = process.env.DESKTOP_PET_USER ?? os.hostname();
 const SKIN = process.env.DESKTOP_PET_SKIN ?? "";
@@ -623,7 +650,16 @@ function ensureConnected() {
         showCapabilityGapResult(msg.task);
         notifyResultWaiters(msg.task);
       } else if (msg.type.startsWith("p2p.") && msg.type !== "p2p.forwarded") {
-        for (const listener of p2pSignalListeners) listener(msg);
+        if (!verifyP2PSignal(msg)) {
+          logger.warn("received invalid p2p signal", {
+            type: msg.type,
+            taskId: msg.taskId,
+            sessionId: msg.sessionId,
+            fromDeviceId: msg.fromDeviceId
+          });
+        } else {
+          for (const listener of p2pSignalListeners) listener(msg);
+        }
       } else if (msg.type === "help.request" && msg.from) {
         dispatch({ type: "state", state: "excited", ttl: 10 });
         dispatch({ type: "bubble", text: `@${msg.from} 想请你帮忙，右键我可以同意或婉拒`, ttl: 12e3 });
@@ -954,14 +990,9 @@ function onP2PSignal(listener) {
 async function sendP2PSignal(message) {
   if (!signingPrivateKey) throw new Error("设备未配置 P2P 签名密钥");
   const outgoing = { ...message, protocolVersion: TASK_PROTOCOL_VERSION };
-  const signature = crypto.sign(null, Buffer.from(p2pSigningPayload(outgoing)), signingPrivateKey).toString("base64");
+  const signature = crypto.sign(null, Buffer.from(p2pSigningPayload(outgoing, deviceID)), signingPrivateKey).toString("base64");
   await relayRPC({ ...outgoing, signature }, 1e4);
 }
-function p2pSigningPayload(message) {
-  const signalJSON = JSON.stringify(message.signal ?? null);
-  const signalHash = crypto.createHash("sha256").update(signalJSON).digest("hex");
-  return [message.type, message.taskId, message.sessionId, deviceID, message.toDeviceId, message.expiresAt, signalHash].join("\n");
-}
 async function requestRemoteTaskContext(taskId, request) {
   const response = await relayRPC(
     { type: "task.context.request", protocolVersion: TASK_PROTOCOL_VERSION, taskId, payload: request },
@@ -1550,7 +1581,15 @@ async function sendFriendChatPreferred(input) {
 }
 function onRendererSignal(event, message) {
   if (!transportWindow || event.sender !== transportWindow.webContents) return;
-  void sendP2PSignal(message).catch((err) => {
+  void sendP2PSignal(message).then(() => {
+    if (message.type !== "p2p.ice-candidate") {
+      logger.info("p2p signal forwarded", {
+        type: message.type,
+        taskId: message.taskId,
+        sessionId: message.sessionId
+      });
+    }
+  }).catch((err) => {
     logger.warn("p2p signal failed", { type: message.type, taskId: message.taskId, error: String(err) });
     if (message.type === "p2p.offer" && message.taskId.startsWith("chat.")) {
       void fallbackChat(message.taskId.slice("chat.".length));
@@ -1560,6 +1599,18 @@ function onRendererSignal(event, message) {
 function onChatEvent(event, message) {
   if (!transportWindow || event.sender !== transportWindow.webContents || !message || typeof message !== "object") return;
   const value = message;
+  if (value.type === "diagnostic") {
+    logger.info("p2p diagnostic", {
+      stage: value.stage,
+      sessionId: value.sessionId,
+      signalType: value.signalType,
+      connectionState: value.connectionState,
+      iceConnectionState: value.iceConnectionState,
+      iceGatheringState: value.iceGatheringState,
+      error: value.error
+    });
+    return;
+  }
   if (value.type === "received" && value.text) {
     dispatch({ type: "state", state: "excited", ttl: 6 });
     dispatch({ type: "bubble", text: `${value.from ?? "好友"}：${value.text}`, ttl: 1e4 });
@@ -1899,6 +1950,7 @@ function createPetWindow(skin, options) {
   });
   win.setAlwaysOnTop(true, "screen-saver");
   win.setVisibleOnAllWorkspaces(true, { visibleOnFullScreen: true });
+  win.setIgnoreMouseEvents(true, { forward: true });
   registerPetWindow(id, win);
   petManager.register(id, win, skin, identity);
   if (process.env.ELECTRON_RENDERER_URL) {
@@ -1930,6 +1982,10 @@ function createPetWindow(skin, options) {
     if (win.isDestroyed() || e.sender !== win.webContents) return;
     void showPetMenu();
   };
+  const onMousePassthrough = (e, enabled) => {
+    if (win.isDestroyed() || e.sender !== win.webContents || typeof enabled !== "boolean") return;
+    win.setIgnoreMouseEvents(enabled, { forward: enabled });
+  };
   const showPetMenu = async () => {
     const accountUsername = currentAccountUsername();
     const identityPresentation = publishIdentity();
@@ -2022,10 +2078,12 @@ function createPetWindow(skin, options) {
   electron.ipcMain.on(PET_MOVE, onMove);
   electron.ipcMain.on(PET_DRAG, onDrag);
   electron.ipcMain.on(PET_MENU, onMenu);
+  electron.ipcMain.on(PET_MOUSE_PASSTHROUGH, onMousePassthrough);
   win.on("closed", () => {
     electron.ipcMain.removeListener(PET_MOVE, onMove);
     electron.ipcMain.removeListener(PET_DRAG, onDrag);
     electron.ipcMain.removeListener(PET_MENU, onMenu);
+    electron.ipcMain.removeListener(PET_MOUSE_PASSTHROUGH, onMousePassthrough);
   });
   return id;
 }

package/out/preload/index.js

@@ -4,6 +4,7 @@ const PET_EVENT = "pet:event";
 const PET_MOVE = "pet:move";
 const PET_DRAG = "pet:drag";
 const PET_MENU = "pet:menu";
+const PET_MOUSE_PASSTHROUGH = "pet:mouse-passthrough";
 const P2P_SIGNAL_IN = "p2p:signal-in";
 const P2P_SIGNAL_OUT = "p2p:signal-out";
 const P2P_START = "p2p:start";
@@ -13,6 +14,7 @@ const P2P_CHAT_EVENT = "p2p:chat-event";
 electron.contextBridge.exposeInMainWorld("petApi", {
   move: (dx, dy) => electron.ipcRenderer.send(PET_MOVE, dx, dy),
   drag: (phase, dx = 0, dy = 0) => electron.ipcRenderer.send(PET_DRAG, phase, dx, dy),
+  setMousePassthrough: (enabled) => electron.ipcRenderer.send(PET_MOUSE_PASSTHROUGH, enabled),
   openMenu: () => electron.ipcRenderer.send(PET_MENU),
   onEvent: (cb) => {
     electron.ipcRenderer.on(PET_EVENT, (_e, ev) => cb(ev));

package/out/renderer/assets/{index-DqBgThfZ.js → index-CHc4qvDr.js}

@@ -1618,9 +1618,28 @@ window.petApi.onEvent((ev) => {
 let dragging = false;
 let lastX = 0;
 let lastY = 0;
+let mousePassthrough = false;
+function updateMousePassthrough(clientX, clientY) {
+  const rect = canvas.getBoundingClientRect();
+  const x = Math.floor((clientX - rect.left) * canvas.width / rect.width);
+  const y = Math.floor((clientY - rect.top) * canvas.height / rect.height);
+  let overPet = false;
+  if (x >= 0 && x < canvas.width && y >= 0 && y < canvas.height) {
+    const alpha = canvas.getContext("2d").getImageData(x, y, 1, 1).data[3];
+    overPet = alpha > 16;
+  }
+  const next = !dragging && !overPet;
+  if (next === mousePassthrough) return;
+  mousePassthrough = next;
+  window.petApi.setMousePassthrough(next);
+}
 canvas.addEventListener("mousedown", (e) => {
   if (e.button !== 0) return;
   dragging = true;
+  if (mousePassthrough) {
+    mousePassthrough = false;
+    window.petApi.setMousePassthrough(false);
+  }
   lastX = e.screenX;
   lastY = e.screenY;
   animator.setDragging(true);
@@ -1628,21 +1647,24 @@ canvas.addEventListener("mousedown", (e) => {
   draw();
 });
 window.addEventListener("mousemove", (e) => {
-  if (!dragging) return;
-  const dx = e.screenX - lastX;
-  const dy = e.screenY - lastY;
-  if (dx !== 0 || dy !== 0) window.petApi.drag("move", dx, dy);
-  lastX = e.screenX;
-  lastY = e.screenY;
+  if (dragging) {
+    const dx = e.screenX - lastX;
+    const dy = e.screenY - lastY;
+    if (dx !== 0 || dy !== 0) window.petApi.drag("move", dx, dy);
+    lastX = e.screenX;
+    lastY = e.screenY;
+  }
+  updateMousePassthrough(e.clientX, e.clientY);
 });
-window.addEventListener("mouseup", () => {
+window.addEventListener("mouseup", (e) => {
   if (!dragging) return;
   dragging = false;
   window.petApi.drag("end");
   animator.setDragging(false);
   draw();
+  updateMousePassthrough(e.clientX, e.clientY);
 });
-window.addEventListener("contextmenu", (e) => {
+canvas.addEventListener("contextmenu", (e) => {
   e.preventDefault();
   if (dragging) {
     dragging = false;
@@ -1659,3 +1681,4 @@ window.addEventListener("blur", () => {
   animator.setDragging(false);
   draw();
 });
+window.petApi.setMousePassthrough(true);

package/out/renderer/assets/{p2p-Ch5g1MsK.js → p2p-LRPQ9Jzg.js}

@@ -53,11 +53,16 @@ function decodeArtifactChunk(buffer) {
   };
 }
 class IceCandidateBuffer {
-  constructor(maxPerSession = 64) {
+  constructor(maxPerSession = 64, maxSessions = 64) {
     this.maxPerSession = maxPerSession;
+    this.maxSessions = maxSessions;
   }
   candidates = /* @__PURE__ */ new Map();
   add(sessionId, candidate) {
+    if (!this.candidates.has(sessionId) && this.candidates.size >= this.maxSessions) {
+      const oldestSessionId = this.candidates.keys().next().value;
+      if (oldestSessionId) this.candidates.delete(oldestSessionId);
+    }
     const queued = this.candidates.get(sessionId) ?? [];
     if (queued.length < this.maxPerSession) queued.push(candidate);
     this.candidates.set(sessionId, queued);
@@ -211,7 +216,13 @@ let iceServers = parseIceServers();
 window.p2pApi.onStart((request) => void createOffer(request));
 window.p2pApi.onChatSend((request) => void createOffer(request));
 window.p2pApi.onSignal((message) => {
-  void receiveSignal(message).catch(() => failSession(message.sessionId));
+  void receiveSignal(message).catch((error) => {
+    reportDiagnostic("signal-error", message.sessionId, {
+      signalType: message.type,
+      error: error instanceof Error ? `${error.name}: ${error.message}` : String(error)
+    });
+    failSession(message.sessionId);
+  });
 });
 window.p2pApi.onConfig((config) => {
   if (config.iceServers?.length) iceServers = config.iceServers;
@@ -228,24 +239,28 @@ async function createOffer(request) {
   const session = sessions.get(sessionId);
   session.channel = new ReliableArtifactChannel(channel);
   session.operationId = request.operationId;
-  wireChatChannel(channel, request.toUsername, request.operationId, request.text);
+  wireChatChannel(channel, sessionId, request.toUsername, request.operationId, request.text);
   const offer = await peer.createOffer();
   await peer.setLocalDescription(offer);
+  reportDiagnostic("offer-created", sessionId, peerState(peer));
   send({ type: "p2p.offer", taskId: request.taskId, toDeviceId: request.toDeviceId, sessionId, signal: offer });
 }
 async function receiveSignal(message) {
   if (new Date(message.expiresAt).getTime() <= Date.now()) return;
-  if (!await verifySignal(message)) return;
+  if (message.type !== "p2p.ice-candidate") {
+    reportDiagnostic("signal-received", message.sessionId, { signalType: message.type });
+  }
   if (message.type === "p2p.offer" && message.fromDeviceId && message.signal) {
     const peer = createPeer(message.taskId, message.sessionId, message.fromDeviceId);
     peer.ondatachannel = (event) => {
       sessions.get(message.sessionId).channel = new ReliableArtifactChannel(event.channel);
-      wireChatChannel(event.channel, message.from);
+      wireChatChannel(event.channel, message.sessionId, message.from);
     };
     await peer.setRemoteDescription(message.signal);
     await flushPendingIceCandidates(message.sessionId, peer);
     const answer = await peer.createAnswer();
     await peer.setLocalDescription(answer);
+    reportDiagnostic("answer-created", message.sessionId, peerState(peer));
     send({
       type: "p2p.answer",
       taskId: message.taskId,
@@ -270,40 +285,10 @@ async function receiveSignal(message) {
     closeSession(message.sessionId);
   }
 }
-async function verifySignal(message) {
-  if (!message.signature || !message.publicKey || !message.fromDeviceId) return false;
-  try {
-    const der = pemToBytes(message.publicKey);
-    const key = await crypto.subtle.importKey("spki", der, { name: "Ed25519" }, false, ["verify"]);
-    const signalJSON = JSON.stringify(message.signal ?? null);
-    const digest2 = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(signalJSON));
-    const hash = [...new Uint8Array(digest2)].map((value) => value.toString(16).padStart(2, "0")).join("");
-    const payload = [
-      message.type,
-      message.taskId,
-      message.sessionId,
-      message.fromDeviceId,
-      message.toDeviceId,
-      message.expiresAt,
-      hash
-    ].join("\n");
-    return crypto.subtle.verify(
-      "Ed25519",
-      key,
-      Uint8Array.from(atob(message.signature), (char) => char.charCodeAt(0)),
-      new TextEncoder().encode(payload)
-    );
-  } catch {
-    return false;
-  }
-}
-function pemToBytes(value) {
-  const base64 = value.replace(/-----[^-]+-----/g, "").replace(/\s/g, "");
-  return Uint8Array.from(atob(base64), (char) => char.charCodeAt(0)).buffer;
-}
 function createPeer(taskId, sessionId, toDeviceId, timeoutMs = P2P_CONNECT_TIMEOUT_MS) {
   const peer = new RTCPeerConnection({ iceServers });
   const timer = setTimeout(() => {
+    reportDiagnostic("connect-timeout", sessionId, peerState(peer));
     const operationId = sessions.get(sessionId)?.operationId;
     if (operationId) window.p2pApi.emitChatEvent({ type: "failed", operationId });
     send({ type: "p2p.failed", taskId, sessionId, toDeviceId });
@@ -316,6 +301,7 @@ function createPeer(taskId, sessionId, toDeviceId, timeoutMs = P2P_CONNECT_TIMEO
     }
   };
   peer.onconnectionstatechange = () => {
+    reportDiagnostic("connection-state", sessionId, peerState(peer));
     if (peer.connectionState === "connected") {
       clearTimeout(timer);
       send({ type: "p2p.ready", taskId, sessionId, toDeviceId });
@@ -327,9 +313,10 @@ function createPeer(taskId, sessionId, toDeviceId, timeoutMs = P2P_CONNECT_TIMEO
   };
   return peer;
 }
-function wireChatChannel(channel, peerUsername, operationId, outgoingText) {
+function wireChatChannel(channel, sessionId, peerUsername, operationId, outgoingText) {
   if (operationId && outgoingText) {
     channel.addEventListener("open", () => {
+      reportDiagnostic("channel-open", sessionId);
       channel.send(JSON.stringify({ type: "chat.message", text: outgoingText }));
       window.p2pApi.emitChatEvent({ type: "sent", operationId });
     }, { once: true });
@@ -366,6 +353,16 @@ async function flushPendingIceCandidates(sessionId, peer) {
 function send(message) {
   window.p2pApi.sendSignal({ ...message, expiresAt: new Date(Date.now() + 5 * 6e4).toISOString() });
 }
+function peerState(peer) {
+  return {
+    connectionState: peer.connectionState,
+    iceConnectionState: peer.iceConnectionState,
+    iceGatheringState: peer.iceGatheringState
+  };
+}
+function reportDiagnostic(stage, sessionId, fields = {}) {
+  window.p2pApi.emitChatEvent({ type: "diagnostic", stage, sessionId, ...fields });
+}
 function parseIceServers() {
   try {
     const env = __vite_import_meta_env__;

package/out/renderer/index.html

@@ -147,7 +147,7 @@
         }
       }
     </style>
-    <script type="module" crossorigin src="./assets/index-DqBgThfZ.js"></script>
+    <script type="module" crossorigin src="./assets/index-CHc4qvDr.js"></script>
   </head>
   <body>
     <canvas id="pet"></canvas>

package/out/renderer/p2p.html

@@ -1,6 +1,6 @@
 <!doctype html>
 <html lang="en">
-  <head><meta charset="UTF-8" /><title>Desktop Pet P2P</title>  <script type="module" crossorigin src="./assets/p2p-Ch5g1MsK.js"></script>
+  <head><meta charset="UTF-8" /><title>Desktop Pet P2P</title>  <script type="module" crossorigin src="./assets/p2p-LRPQ9Jzg.js"></script>
 </head>
   <body></body>
 </html>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "desktop-pet-app",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "description": "AI desktop pet with MCP support and a self-hosted relay server",
   "license": "MIT",
   "keywords": [
@@ -34,7 +34,9 @@
     "test": "vitest run",
     "package:mac": "npm run build && electron-builder --mac pkg --publish never",
     "pack:check": "npm pack --dry-run",
-    "prepack": "npm run build",
+    "prepack": "npm run build && node scripts/prepare-npm-package.mjs",
+    "postpack": "node scripts/prepare-npm-package.mjs --restore",
+    "recover:npm-package": "node scripts/prepare-npm-package.mjs --restore",
     "prepublishOnly": "npm run typecheck && npm test && npm run pack:check"
   },
   "build": {
@@ -65,8 +67,8 @@
     "vitest": "^3.2.7"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.30.0",
     "electron": "^33.2.0",
+    "@modelcontextprotocol/sdk": "^1.30.0",
     "ws": "^8.21.3",
     "zod": "^4.5.4"
   }