desktop-pet-app 0.1.1

package/out/renderer/assets/p2p-Ch5g1MsK.js

@@ -0,0 +1,377 @@
+const ARTIFACT_CHUNK_BYTES = 64 * 1024;
+const P2P_CONNECT_TIMEOUT_MS = 12e3;
+const P2P_CHAT_CONNECT_TIMEOUT_MS = 2500;
+const MAGIC = new Uint8Array([68, 80, 69, 84]);
+function encodeArtifactChunk(chunk) {
+  const id = new TextEncoder().encode(chunk.artifactId);
+  if (id.length === 0) throw new Error("artifact id must not be empty");
+  if (id.length > 128) throw new Error("artifact id is too long");
+  if (chunk.chunkIndex < 0 || chunk.totalChunks < 1 || chunk.chunkIndex >= chunk.totalChunks) {
+    throw new Error("invalid chunk indices");
+  }
+  if (chunk.payload.length > ARTIFACT_CHUNK_BYTES) {
+    throw new Error(`artifact chunk payload exceeds ${ARTIFACT_CHUNK_BYTES} bytes`);
+  }
+  const headerLength = 4 + 1 + 2 + 4 + 4 + 4 + id.length;
+  const output = new Uint8Array(headerLength + chunk.payload.length);
+  output.set(MAGIC, 0);
+  const view = new DataView(output.buffer);
+  view.setUint8(4, 1);
+  view.setUint16(5, id.length);
+  view.setUint32(7, chunk.chunkIndex);
+  view.setUint32(11, chunk.totalChunks);
+  view.setUint32(15, chunk.payload.length);
+  output.set(id, 19);
+  output.set(chunk.payload, headerLength);
+  return output.buffer;
+}
+function decodeArtifactChunk(buffer) {
+  const bytes = new Uint8Array(buffer);
+  if (bytes.length < 19 || !MAGIC.every((value, index) => bytes[index] === value)) {
+    throw new Error("invalid artifact chunk magic");
+  }
+  const view = new DataView(buffer);
+  if (view.getUint8(4) !== 1) throw new Error("unsupported artifact chunk version");
+  const idLength = view.getUint16(5);
+  if (idLength === 0) throw new Error("artifact id must not be empty");
+  if (idLength > 128) throw new Error("artifact id is too long");
+  const chunkIndex = view.getUint32(7);
+  const totalChunks = view.getUint32(11);
+  const payloadLength = view.getUint32(15);
+  if (payloadLength > ARTIFACT_CHUNK_BYTES) {
+    throw new Error(`artifact chunk payload exceeds ${ARTIFACT_CHUNK_BYTES} bytes`);
+  }
+  const headerLength = 19 + idLength;
+  if (totalChunks < 1 || chunkIndex >= totalChunks || bytes.length !== headerLength + payloadLength) {
+    throw new Error("invalid artifact chunk lengths");
+  }
+  return {
+    artifactId: new TextDecoder().decode(bytes.slice(19, headerLength)),
+    chunkIndex,
+    totalChunks,
+    payload: bytes.slice(headerLength)
+  };
+}
+class IceCandidateBuffer {
+  constructor(maxPerSession = 64) {
+    this.maxPerSession = maxPerSession;
+  }
+  candidates = /* @__PURE__ */ new Map();
+  add(sessionId, candidate) {
+    const queued = this.candidates.get(sessionId) ?? [];
+    if (queued.length < this.maxPerSession) queued.push(candidate);
+    this.candidates.set(sessionId, queued);
+  }
+  take(sessionId) {
+    const queued = this.candidates.get(sessionId) ?? [];
+    this.candidates.delete(sessionId);
+    return queued;
+  }
+  clear(sessionId) {
+    this.candidates.delete(sessionId);
+  }
+}
+class ReliableArtifactChannel {
+  constructor(channel) {
+    this.channel = channel;
+    channel.binaryType = "arraybuffer";
+    channel.bufferedAmountLowThreshold = ARTIFACT_CHUNK_BYTES * 4;
+    channel.addEventListener("message", (event) => void this.receive(event.data));
+  }
+  incoming = /* @__PURE__ */ new Map();
+  outgoing = /* @__PURE__ */ new Map();
+  onArtifact = () => {
+  };
+  onControl = () => {
+  };
+  async sendArtifact(artifactId, bytes) {
+    const totalChunks = Math.max(1, Math.ceil(bytes.length / ARTIFACT_CHUNK_BYTES));
+    const sha256 = await digest(bytes);
+    const chunks = Array.from({ length: totalChunks }, (_, index) => {
+      const start = index * ARTIFACT_CHUNK_BYTES;
+      return bytes.slice(start, Math.min(bytes.length, start + ARTIFACT_CHUNK_BYTES));
+    });
+    this.outgoing.set(artifactId, { chunks, acknowledged: /* @__PURE__ */ new Set() });
+    this.sendControl({ type: "artifact.start", artifactId, size: bytes.length, sha256, totalChunks });
+    await this.sendMissing(artifactId);
+  }
+  async receive(value) {
+    if (typeof value === "string") {
+      const control = JSON.parse(value);
+      this.onControl(control);
+      if (control.type === "artifact.start") {
+        this.incoming.set(control.artifactId, {
+          size: control.size,
+          sha256: control.sha256,
+          totalChunks: control.totalChunks,
+          chunks: /* @__PURE__ */ new Map()
+        });
+      } else if (control.type === "artifact.chunk-ack") {
+        const outgoing = this.outgoing.get(control.artifactId);
+        for (const index of control.received) outgoing?.acknowledged.add(index);
+      } else if (control.type === "artifact.resume") {
+        const outgoing = this.outgoing.get(control.artifactId);
+        if (outgoing) {
+          outgoing.acknowledged = new Set(control.received);
+          await this.sendMissing(control.artifactId);
+        }
+      } else if (control.type === "artifact.hash-mismatch") {
+        const outgoing = this.outgoing.get(control.artifactId);
+        if (outgoing) {
+          outgoing.acknowledged.clear();
+          await this.sendMissing(control.artifactId);
+        }
+      } else if (control.type === "artifact.complete" || control.type === "artifact.abort") {
+        this.outgoing.delete(control.artifactId);
+      }
+      return;
+    }
+    if (!(value instanceof ArrayBuffer)) return;
+    const chunk = decodeArtifactChunk(value);
+    const artifact = this.incoming.get(chunk.artifactId);
+    if (!artifact || artifact.totalChunks !== chunk.totalChunks) return;
+    artifact.chunks.set(chunk.chunkIndex, chunk.payload);
+    if (!artifact.ackTimer) {
+      artifact.ackTimer = setTimeout(() => {
+        artifact.ackTimer = void 0;
+        this.acknowledge(chunk.artifactId, artifact);
+      }, 500);
+    }
+    if (artifact.chunks.size % 16 === 0 || artifact.chunks.size === artifact.totalChunks) {
+      if (artifact.ackTimer) clearTimeout(artifact.ackTimer);
+      artifact.ackTimer = void 0;
+      this.acknowledge(chunk.artifactId, artifact);
+    }
+    if (artifact.chunks.size !== artifact.totalChunks) return;
+    const output = new Uint8Array(artifact.size);
+    let offset = 0;
+    for (let index = 0; index < artifact.totalChunks; index++) {
+      const part = artifact.chunks.get(index);
+      if (!part) return;
+      output.set(part, offset);
+      offset += part.length;
+    }
+    this.incoming.delete(chunk.artifactId);
+    if (offset !== artifact.size || await digest(output) !== artifact.sha256) {
+      this.sendControl({ type: "artifact.hash-mismatch", artifactId: chunk.artifactId });
+      return;
+    }
+    this.sendControl({ type: "artifact.complete", artifactId: chunk.artifactId });
+    this.onArtifact(chunk.artifactId, output);
+  }
+  resumeArtifact(artifactId) {
+    const artifact = this.incoming.get(artifactId);
+    this.sendControl({
+      type: "artifact.resume",
+      artifactId,
+      received: artifact ? [...artifact.chunks.keys()].sort((a, b) => a - b) : []
+    });
+  }
+  acknowledge(artifactId, artifact) {
+    this.sendControl({
+      type: "artifact.chunk-ack",
+      artifactId,
+      received: [...artifact.chunks.keys()].sort((a, b) => a - b)
+    });
+  }
+  async sendMissing(artifactId) {
+    const outgoing = this.outgoing.get(artifactId);
+    if (!outgoing) return;
+    for (let index = 0; index < outgoing.chunks.length; index++) {
+      if (outgoing.acknowledged.has(index)) continue;
+      await this.waitForBackpressure();
+      this.channel.send(
+        encodeArtifactChunk({
+          artifactId,
+          chunkIndex: index,
+          totalChunks: outgoing.chunks.length,
+          payload: outgoing.chunks[index]
+        })
+      );
+    }
+  }
+  sendControl(control) {
+    this.channel.send(JSON.stringify(control));
+  }
+  waitForBackpressure() {
+    if (this.channel.bufferedAmount <= this.channel.bufferedAmountLowThreshold) return Promise.resolve();
+    return new Promise((resolve) => this.channel.addEventListener("bufferedamountlow", () => resolve(), { once: true }));
+  }
+}
+async function digest(bytes) {
+  const copy = new Uint8Array(bytes.byteLength);
+  copy.set(bytes);
+  const hash = await crypto.subtle.digest("SHA-256", copy.buffer);
+  return [...new Uint8Array(hash)].map((value) => value.toString(16).padStart(2, "0")).join("");
+}
+const __vite_import_meta_env__ = { "BASE_URL": "./", "DEV": false, "MODE": "production", "PROD": true, "SSR": false };
+const sessions = /* @__PURE__ */ new Map();
+const pendingIceCandidates = new IceCandidateBuffer();
+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));
+});
+window.p2pApi.onConfig((config) => {
+  if (config.iceServers?.length) iceServers = config.iceServers;
+});
+async function createOffer(request) {
+  const sessionId = crypto.randomUUID();
+  const peer = createPeer(
+    request.taskId,
+    sessionId,
+    request.toDeviceId,
+    request.operationId ? P2P_CHAT_CONNECT_TIMEOUT_MS : P2P_CONNECT_TIMEOUT_MS
+  );
+  const channel = peer.createDataChannel("desktop-pet-artifacts", { ordered: true });
+  const session = sessions.get(sessionId);
+  session.channel = new ReliableArtifactChannel(channel);
+  session.operationId = request.operationId;
+  wireChatChannel(channel, request.toUsername, request.operationId, request.text);
+  const offer = await peer.createOffer();
+  await peer.setLocalDescription(offer);
+  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.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);
+    };
+    await peer.setRemoteDescription(message.signal);
+    await flushPendingIceCandidates(message.sessionId, peer);
+    const answer = await peer.createAnswer();
+    await peer.setLocalDescription(answer);
+    send({
+      type: "p2p.answer",
+      taskId: message.taskId,
+      sessionId: message.sessionId,
+      toDeviceId: message.fromDeviceId,
+      signal: answer
+    });
+  } else if (message.type === "p2p.answer" && message.signal) {
+    const peer = sessions.get(message.sessionId)?.peer;
+    if (!peer) return;
+    await peer.setRemoteDescription(message.signal);
+    await flushPendingIceCandidates(message.sessionId, peer);
+  } else if (message.type === "p2p.ice-candidate" && message.signal) {
+    const candidate = message.signal;
+    const peer = sessions.get(message.sessionId)?.peer;
+    if (peer?.remoteDescription) {
+      await peer.addIceCandidate(candidate);
+    } else {
+      pendingIceCandidates.add(message.sessionId, candidate);
+    }
+  } else if (message.type === "p2p.close" || message.type === "p2p.failed") {
+    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(() => {
+    const operationId = sessions.get(sessionId)?.operationId;
+    if (operationId) window.p2pApi.emitChatEvent({ type: "failed", operationId });
+    send({ type: "p2p.failed", taskId, sessionId, toDeviceId });
+    closeSession(sessionId);
+  }, timeoutMs);
+  sessions.set(sessionId, { peer, timer });
+  peer.onicecandidate = (event) => {
+    if (event.candidate) {
+      send({ type: "p2p.ice-candidate", taskId, sessionId, toDeviceId, signal: event.candidate.toJSON() });
+    }
+  };
+  peer.onconnectionstatechange = () => {
+    if (peer.connectionState === "connected") {
+      clearTimeout(timer);
+      send({ type: "p2p.ready", taskId, sessionId, toDeviceId });
+    } else if (peer.connectionState === "failed" || peer.connectionState === "closed") {
+      const operationId = sessions.get(sessionId)?.operationId;
+      if (operationId) window.p2pApi.emitChatEvent({ type: "failed", operationId });
+      closeSession(sessionId);
+    }
+  };
+  return peer;
+}
+function wireChatChannel(channel, peerUsername, operationId, outgoingText) {
+  if (operationId && outgoingText) {
+    channel.addEventListener("open", () => {
+      channel.send(JSON.stringify({ type: "chat.message", text: outgoingText }));
+      window.p2pApi.emitChatEvent({ type: "sent", operationId });
+    }, { once: true });
+  }
+  channel.addEventListener("message", (event) => {
+    if (typeof event.data !== "string") return;
+    try {
+      const message = JSON.parse(event.data);
+      if (message.type === "chat.message" && message.text) {
+        window.p2pApi.emitChatEvent({ type: "received", from: peerUsername ?? "好友", text: message.text });
+      }
+    } catch {
+    }
+  });
+}
+function closeSession(sessionId) {
+  const session = sessions.get(sessionId);
+  if (!session) return;
+  clearTimeout(session.timer);
+  session.peer.close();
+  sessions.delete(sessionId);
+  pendingIceCandidates.clear(sessionId);
+}
+function failSession(sessionId) {
+  const operationId = sessions.get(sessionId)?.operationId;
+  if (operationId) window.p2pApi.emitChatEvent({ type: "failed", operationId });
+  closeSession(sessionId);
+  pendingIceCandidates.clear(sessionId);
+}
+async function flushPendingIceCandidates(sessionId, peer) {
+  const candidates = pendingIceCandidates.take(sessionId);
+  for (const candidate of candidates) await peer.addIceCandidate(candidate);
+}
+function send(message) {
+  window.p2pApi.sendSignal({ ...message, expiresAt: new Date(Date.now() + 5 * 6e4).toISOString() });
+}
+function parseIceServers() {
+  try {
+    const env = __vite_import_meta_env__;
+    const configured = JSON.parse(env?.VITE_DESKTOP_PET_ICE_SERVERS ?? "[]");
+    return configured.length ? configured : [{ urls: "stun:stun.l.google.com:19302" }];
+  } catch {
+    return [{ urls: "stun:stun.l.google.com:19302" }];
+  }
+}

package/out/renderer/index.html

@@ -0,0 +1,156 @@
+<!doctype html>
+<html lang="zh-CN">
+  <head>
+    <meta charset="UTF-8" />
+    <title>Desktop Pet</title>
+    <link
+      href="https://fonts.googleapis.com/css2?family=Press+Start+2P&display=swap"
+      rel="stylesheet"
+    />
+    <style>
+      html,
+      body {
+        margin: 0;
+        width: 100%;
+        height: 100%;
+        background: transparent;
+        overflow: hidden;
+        -webkit-user-select: none;
+        user-select: none;
+      }
+
+      #pet {
+        position: absolute;
+        bottom: 6px;
+        left: 50%;
+        transform: translateX(-50%);
+        cursor: grab;
+      }
+      #pet:active {
+        cursor: grabbing;
+      }
+
+      .pet-identity {
+        position: absolute;
+        left: 50%;
+        bottom: 2px;
+        transform: translateX(-50%);
+        z-index: 8;
+        max-width: calc(100% - 12px);
+        box-sizing: border-box;
+        border: 1px solid rgba(255, 255, 255, 0.72);
+        border-radius: 999px;
+        padding: 3px 7px;
+        background: rgba(28, 31, 38, 0.88);
+        color: #ffffff;
+        font-family: -apple-system, BlinkMacSystemFont, 'PingFang SC', sans-serif;
+        font-size: 10px;
+        font-weight: 650;
+        line-height: 1.2;
+        text-align: center;
+        white-space: nowrap;
+        overflow: hidden;
+        text-overflow: ellipsis;
+        pointer-events: none;
+      }
+      .pet-identity[data-kind='remote-friend'] {
+        background: rgba(21, 93, 160, 0.92);
+      }
+
+      .bubble {
+        position: absolute;
+        top: 6px;
+        left: 50%;
+        transform: translateX(-50%);
+        max-width: 176px;
+        box-sizing: border-box;
+        background: #ffffff;
+        border: 3px solid #2d2d2d;
+        border-radius: 10px;
+        padding: 6px 9px;
+        font-family: 'Press Start 2P', 'PingFang SC', monospace;
+        font-size: 10px;
+        line-height: 1.6;
+        color: #2d2d2d;
+        box-shadow: 3px 3px 0 rgba(0, 0, 0, 0.18);
+        word-break: break-all;
+        pointer-events: none;
+        opacity: 0;
+        transition: opacity 0.3s;
+      }
+      .bubble::after {
+        content: '';
+        position: absolute;
+        bottom: -8px;
+        left: 50%;
+        margin-left: -5px;
+        width: 10px;
+        height: 10px;
+        background: #ffffff;
+        border-right: 3px solid #2d2d2d;
+        border-bottom: 3px solid #2d2d2d;
+        transform: rotate(45deg);
+      }
+      .bubble.show {
+        opacity: 1;
+      }
+      .bubble.fade {
+        opacity: 0;
+      }
+      .bubble.pop {
+        animation: pop 0.25s cubic-bezier(0.2, 1.6, 0.4, 1);
+      }
+      @keyframes pop {
+        0% {
+          transform: translateX(-50%) scale(0.6);
+        }
+        100% {
+          transform: translateX(-50%) scale(1);
+        }
+      }
+
+      .reward-float {
+        position: absolute;
+        left: 50%;
+        bottom: 72px;
+        transform: translateX(-50%);
+        font-family: 'Press Start 2P', 'PingFang SC', monospace;
+        font-size: 11px;
+        color: #f0a05a;
+        text-shadow:
+          2px 2px 0 #1a1008,
+          0 0 8px rgba(240, 160, 90, 0.55);
+        pointer-events: none;
+        opacity: 0;
+        white-space: nowrap;
+        z-index: 5;
+      }
+      .reward-float.play {
+        animation: fish-rise 2.1s cubic-bezier(0.22, 1, 0.36, 1) forwards;
+      }
+      @keyframes fish-rise {
+        0% {
+          opacity: 0;
+          transform: translateX(-50%) translateY(12px) scale(0.7);
+        }
+        18% {
+          opacity: 1;
+          transform: translateX(-50%) translateY(0) scale(1.08);
+        }
+        70% {
+          opacity: 1;
+          transform: translateX(-50%) translateY(-28px) scale(1);
+        }
+        100% {
+          opacity: 0;
+          transform: translateX(-50%) translateY(-48px) scale(0.95);
+        }
+      }
+    </style>
+    <script type="module" crossorigin src="./assets/index-DqBgThfZ.js"></script>
+  </head>
+  <body>
+    <canvas id="pet"></canvas>
+    <div id="pet-identity" class="pet-identity" hidden></div>
+  </body>
+</html>

package/out/renderer/p2p.html

@@ -0,0 +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>
+  <body></body>
+</html>

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "desktop-pet-app",
+  "version": "0.1.1",
+  "description": "AI desktop pet with MCP support and a self-hosted relay server",
+  "license": "MIT",
+  "keywords": [
+    "desktop-pet",
+    "electron",
+    "mcp",
+    "ai-agent"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "out/main/index.js",
+  "bin": {
+    "desktop-pet": "./bin/cli.js"
+  },
+  "files": [
+    "bin",
+    "out"
+  ],
+  "scripts": {
+    "dev": "electron-vite dev",
+    "build": "electron-vite build && npm run build:mcp",
+    "build:mcp": "esbuild src/mcp-server/index.ts --bundle --platform=node --format=esm --packages=external --outfile=out/mcp-server/index.js && node -e \"require('fs').writeFileSync('out/mcp-server/package.json', JSON.stringify({ type: 'module' }))\"",
+    "e2e:duty": "node scripts/e2e-duty-sessions.mjs",
+    "e2e:codebuddy:git": "node scripts/e2e-codebuddy-git-task.mjs",
+    "e2e:codebuddy:context": "node scripts/e2e-codebuddy-context-round.mjs",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "package:mac": "npm run build && electron-builder --mac pkg --publish never",
+    "pack:check": "npm pack --dry-run",
+    "prepack": "npm run build",
+    "prepublishOnly": "npm run typecheck && npm test && npm run pack:check"
+  },
+  "build": {
+    "appId": "com.xinshu.desktoppet",
+    "productName": "Desktop Pet",
+    "directories": {
+      "output": "release"
+    },
+    "files": [
+      "out/**",
+      "bin/**",
+      "package.json"
+    ],
+    "mac": {
+      "category": "public.app-category.utilities",
+      "target": [
+        "pkg"
+      ]
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/ws": "^8.18.1",
+    "electron-builder": "^26.15.3",
+    "electron-vite": "^2.3.0",
+    "typescript": "^5.6.3",
+    "vite": "^5.4.8",
+    "vitest": "^3.2.7"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "electron": "^33.2.0",
+    "ws": "^8.21.3",
+    "zod": "^4.5.4"
+  }
+}