desktop-pet-app 0.1.1 → 0.1.2

package/out/main/index.js

@@ -443,6 +443,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 +649,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 +989,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 +1580,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 +1598,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 });

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/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.1.2",
   "description": "AI desktop pet with MCP support and a self-hosted relay server",
   "license": "MIT",
   "keywords": [
@@ -34,7 +34,8 @@
     "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",
     "prepublishOnly": "npm run typecheck && npm test && npm run pack:check"
   },
   "build": {
@@ -65,8 +66,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"
   }