desktop-pet-app 0.3.4 → 0.3.13

package/out/main/index.js

@@ -1,3259 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-const electron = require("electron");
-const node_fs = require("node:fs");
-const node_path = require("node:path");
-const path = require("path");
-const os = require("os");
-const node_crypto = require("node:crypto");
-const node_http = require("node:http");
-const node_os = require("node:os");
-const crypto = require("crypto");
-const WebSocket = require("ws");
-const fs = require("fs");
-const promises = require("node:fs/promises");
-const node_stream = require("node:stream");
-const promises$1 = require("node:stream/promises");
-const node_child_process = require("node:child_process");
-const http = require("http");
-const ORDER = { debug: 10, info: 20, warn: 30, error: 40 };
-class Logger {
-  constructor(minLevel = "info", write = console.log) {
-    this.minLevel = minLevel;
-    this.write = write;
-  }
-  debug(msg, fields) {
-    this.log("debug", msg, fields);
-  }
-  info(msg, fields) {
-    this.log("info", msg, fields);
-  }
-  warn(msg, fields) {
-    this.log("warn", msg, fields);
-  }
-  error(msg, fields) {
-    this.log("error", msg, fields);
-  }
-  log(level, msg, fields) {
-    if (ORDER[level] < ORDER[this.minLevel]) return;
-    this.write(
-      JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), level, msg, ...fields })
-    );
-  }
-}
-function levelFromEnv() {
-  const v = (process.env.DESKTOP_PET_LOG_LEVEL ?? "info").toLowerCase();
-  return v === "debug" || v === "warn" || v === "error" ? v : "info";
-}
-function mainLogDirectory() {
-  return node_path.join(electron.app.getPath("userData"), "logs");
-}
-function writeMainLog(line) {
-  console.log(line);
-  try {
-    const directory = mainLogDirectory();
-    node_fs.mkdirSync(directory, { recursive: true });
-    node_fs.appendFileSync(node_path.join(directory, "main.log"), `${line}
-`, "utf8");
-  } catch {
-  }
-}
-const logger = new Logger(levelFromEnv(), writeMainLog);
-const PORT_FILE = process.env.DESKTOP_PET_PORT_FILE?.trim() || path.join(os.homedir(), ".desktop-pet-port");
-const LOCAL_PET_PROTOCOL_VERSION = "1.0";
-const LOCAL_PET_MAX_BODY_BYTES = 64 * 1024;
-const MAX_PETS = 4;
-const PET_WINDOW = { width: 200, height: 190 };
-const PET_WINDOW_BY_SKIN = {
-  "robot-blue": { width: 260, height: 320 }
-};
-const GREET_DISTANCE = 260;
-const GREET_COOLDOWN_MS = 15e3;
-const PROXIMITY_SCAN_MS = 500;
-const SKIN_IDS = [
-  "codex",
-  "claude",
-  "minecraft",
-  "hoot",
-  "cat",
-  "dog",
-  "bird",
-  "lion",
-  "tiger",
-  "whale",
-  "penguin",
-  "robot-blue"
-];
-const SKIN_LABELS = {
-  codex: "Codex 小宠",
-  claude: "Claude 小宠",
-  minecraft: "我的世界小宠",
-  hoot: "Professor Hoot",
-  cat: "橘猫",
-  dog: "小狗",
-  bird: "小鸟",
-  lion: "狮子",
-  tiger: "老虎",
-  whale: "蓝鲸",
-  penguin: "企鹅",
-  "robot-blue": "蓝色协作机器人"
-};
-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";
-const P2P_CHAT_SEND = "p2p:chat-send";
-const P2P_CHAT_EVENT = "p2p:chat-event";
-const windows = /* @__PURE__ */ new Map();
-function registerPetWindow(id, win) {
-  windows.set(id, win);
-  win.on("closed", () => windows.delete(id));
-}
-function getPetWindow(id) {
-  const win = windows.get(id);
-  return win && !win.isDestroyed() ? win : void 0;
-}
-function listPetIds() {
-  return [...windows.keys()].filter((id) => {
-    const win = windows.get(id);
-    return win && !win.isDestroyed();
-  });
-}
-function dispatch(event, targetId) {
-  if (targetId) {
-    const win = windows.get(targetId);
-    if (win && !win.isDestroyed()) win.webContents.send(PET_EVENT, event);
-    return;
-  }
-  for (const win of windows.values()) {
-    if (!win.isDestroyed()) win.webContents.send(PET_EVENT, event);
-  }
-}
-const busy = /* @__PURE__ */ new Set();
-const homePos = /* @__PURE__ */ new Map();
-function handleQuest(cmd, targetId) {
-  const id = listPetIds()[0];
-  if (!id) {
-    logger.warn("quest ignored: no pet window");
-    return;
-  }
-  void runQuest(id, cmd);
-}
-async function runQuest(petId, cmd) {
-  if (busy.has(petId)) {
-    logger.warn("quest already running", { petId });
-    return;
-  }
-  const win = getPetWindow(petId);
-  if (!win || win.isDestroyed()) return;
-  busy.add(petId);
-  try {
-    if (cmd.phase === "leave") {
-      await leave(win, petId, cmd.friendName, cmd.leaveText);
-    } else {
-      await comeBack(win, petId, cmd.returnText, cmd.fish ?? 5);
-    }
-  } catch (err) {
-    logger.error("quest failed", { petId, error: String(err) });
-    restoreHome(win, petId);
-  } finally {
-    busy.delete(petId);
-  }
-}
-async function leave(win, petId, friendName, leaveText) {
-  const [x, y] = win.getPosition();
-  homePos.set(petId, { x, y });
-  const friend = friendName ?? "小白";
-  dispatch({ type: "state", state: "excited", ttl: 5 }, petId);
-  dispatch({
-    type: "bubble",
-    text: leaveText ?? `我去找 ${friend} 帮忙，20 分钟回来～`,
-    ttl: 3800
-  }, petId);
-  await sleep(900);
-  if (win.isDestroyed()) return;
-  dispatch({ type: "state", state: "walk", ttl: 40 }, petId);
-  const [w] = win.getSize();
-  const area = electron.screen.getDisplayNearestPoint({ x, y }).workArea;
-  const exitX = area.x + area.width + w;
-  await animatePosition(win, x, y, exitX, y, 1100);
-  if (!win.isDestroyed()) win.hide();
-}
-async function comeBack(win, petId, returnText, fish = 5) {
-  const home = homePos.get(petId);
-  const [cw, ch] = win.isDestroyed() ? [200, 190] : win.getSize();
-  const area = electron.screen.getPrimaryDisplay().workArea;
-  const hx = home?.x ?? area.x + area.width - cw - 120;
-  const hy = home?.y ?? area.y + area.height - ch - 60;
-  if (win.isDestroyed()) return;
-  const enterX = area.x - cw - 10;
-  win.setPosition(Math.round(enterX), Math.round(hy));
-  win.show();
-  win.setAlwaysOnTop(true, "screen-saver");
-  dispatch({ type: "state", state: "excited", ttl: 14 }, petId);
-  dispatch({
-    type: "bubble",
-    text: returnText ?? "我回来啦！朋友帮了大忙 📄",
-    ttl: 9e3
-  }, petId);
-  await animatePosition(win, enterX, hy, hx, hy, 1100);
-  if (win.isDestroyed()) return;
-  dispatch({ type: "reward", amount: fish, label: "小鱼干" }, petId);
-  homePos.delete(petId);
-}
-function restoreHome(win, petId) {
-  const home = homePos.get(petId);
-  if (!home || win.isDestroyed()) return;
-  win.setPosition(home.x, home.y);
-  win.show();
-  homePos.delete(petId);
-}
-function animatePosition(win, x0, y0, x1, y1, durationMs) {
-  return new Promise((resolve) => {
-    const start = Date.now();
-    const tick = () => {
-      if (win.isDestroyed()) {
-        resolve();
-        return;
-      }
-      const t = Math.min(1, (Date.now() - start) / durationMs);
-      const e = easeInOut(t);
-      win.setPosition(Math.round(x0 + (x1 - x0) * e), Math.round(y0 + (y1 - y0) * e));
-      if (t < 1) setTimeout(tick, 16);
-      else resolve();
-    };
-    tick();
-  });
-}
-function easeInOut(t) {
-  return t < 0.5 ? 2 * t * t : 1 - Math.pow(-2 * t + 2, 2) / 2;
-}
-function sleep(ms) {
-  return new Promise((r) => setTimeout(r, ms));
-}
-function isPetOnQuest(petId) {
-  return busy.has(petId);
-}
-function canSendAwayPet(identity) {
-  return identity.kind === "remote-friend";
-}
-function presentPetIdentity(identity, localUsername) {
-  if (identity.kind === "remote-friend") {
-    return {
-      badge: `好友 @${identity.username}`,
-      menuHeader: `远端好友 @${identity.username} · 来访形象`,
-      greeting: `我是远端好友 @${identity.username}，不是本机账号的分身`
-    };
-  }
-  const account = localUsername ? `@${localUsername}` : "未登录";
-  return {
-    badge: `本机主宠 · ${account}`,
-    menuHeader: `本机主宠 · ${account}`,
-    greeting: localUsername ? `你好呀，我是 ${account} 的本机主宠！` : "右键我，登录你的账号吧！"
-  };
-}
-class PetManager {
-  pets = /* @__PURE__ */ new Map();
-  lastGreetAt = /* @__PURE__ */ new Map();
-  timer;
-  petsVisible = true;
-  register(id, win, skin, identity) {
-    this.pets.set(id, { id, win, skin, identity });
-    win.on("closed", () => this.pets.delete(id));
-    if (!this.petsVisible) win.hide();
-    if (!this.timer) this.timer = setInterval(() => this.checkProximity(), PROXIMITY_SCAN_MS);
-    logger.info("pet registered", { id, skin, total: this.pets.size });
-  }
-  count() {
-    return this.pets.size;
-  }
-  hasPrimaryPet() {
-    return [...this.pets.values()].some(
-      (pet) => !pet.win.isDestroyed() && pet.identity.kind === "primary"
-    );
-  }
-  arePetsVisible() {
-    return this.petsVisible;
-  }
-  setPetsVisible(visible) {
-    this.petsVisible = visible;
-    for (const pet of this.pets.values()) {
-      if (pet.win.isDestroyed()) continue;
-      if (visible) pet.win.showInactive();
-      else pet.win.hide();
-    }
-  }
-  findRemoteFriend(username) {
-    const normalized = username.trim().toLowerCase();
-    return [...this.pets.values()].find(
-      (pet) => !pet.win.isDestroyed() && pet.identity.kind === "remote-friend" && pet.identity.username.toLowerCase() === normalized
-    );
-  }
-  refreshLocalIdentityBadges(username) {
-    for (const pet of this.pets.values()) {
-      if (pet.win.isDestroyed() || pet.identity.kind === "remote-friend") continue;
-      const presentation = presentPetIdentity(pet.identity, username);
-      dispatch({ type: "identity", label: presentation.badge, kind: pet.identity.kind }, pet.id);
-    }
-  }
-  checkProximity() {
-    const arr = [...this.pets.values()].filter((p) => !p.win.isDestroyed());
-    for (let i = 0; i < arr.length; i++) {
-      for (let j = i + 1; j < arr.length; j++) {
-        const a = center(arr[i].win.getBounds());
-        const b = center(arr[j].win.getBounds());
-        const dist = Math.hypot(a.x - b.x, a.y - b.y);
-        if (dist >= GREET_DISTANCE) continue;
-        const key = [arr[i].id, arr[j].id].sort().join("|");
-        const now = Date.now();
-        if (now - (this.lastGreetAt.get(key) ?? 0) < GREET_COOLDOWN_MS) continue;
-        this.lastGreetAt.set(key, now);
-        dispatch({ type: "interact", kind: "greet" }, arr[i].id);
-        dispatch({ type: "interact", kind: "greet" }, arr[j].id);
-        dispatch({ type: "interact", kind: "approach", dir: a.x < b.x ? 1 : -1 }, arr[i].id);
-        logger.debug("pets greeted", { a: arr[i].id, b: arr[j].id });
-      }
-    }
-  }
-}
-function center(bounds) {
-  return { x: bounds.x + bounds.width / 2, y: bounds.y + bounds.height / 2 };
-}
-const petManager = new PetManager();
-function credentialPath() {
-  return node_path.join(electron.app.getPath("userData"), "device-credentials.enc");
-}
-function saveDeviceCredentials(credentials) {
-  validate(credentials);
-  if (!electron.safeStorage.isEncryptionAvailable()) {
-    throw new Error("系统钥匙串当前不可用，无法安全保存设备凭据");
-  }
-  const encrypted = electron.safeStorage.encryptString(JSON.stringify(credentials));
-  node_fs.writeFileSync(credentialPath(), encrypted, { mode: 384 });
-  node_fs.chmodSync(credentialPath(), 384);
-}
-function loadDeviceCredentials() {
-  const path2 = credentialPath();
-  if (!node_fs.existsSync(path2)) return void 0;
-  if (!electron.safeStorage.isEncryptionAvailable()) return void 0;
-  const credentials = JSON.parse(electron.safeStorage.decryptString(node_fs.readFileSync(path2)));
-  validate(credentials);
-  return credentials;
-}
-function clearDeviceCredentials() {
-  node_fs.rmSync(credentialPath(), { force: true });
-}
-function validate(credentials) {
-  if (!credentials.serverUrl || !credentials.userId || !credentials.deviceId || credentials.refreshToken.length < 32) {
-    throw new Error("无效的桌宠设备配置");
-  }
-  const url = new URL(credentials.serverUrl);
-  if (url.protocol !== "http:" && url.protocol !== "https:") {
-    throw new Error("设备配置的 serverUrl 必须使用 http 或 https");
-  }
-}
-const DEFAULT_DESKTOP_PET_HOST = "https://deskpalai.com";
-function configuredRelayURL() {
-  const host = process.env.DESKTOP_PET_HOST?.trim();
-  if (host) return relayURLFromHost(host);
-  return process.env.DESKTOP_PET_SERVER?.trim() || relayURLFromHost(DEFAULT_DESKTOP_PET_HOST);
-}
-function relayURLFromHost(value) {
-  const source = value.includes("://") ? value : `${isLocalHost(value) ? "http" : "https"}://${value}`;
-  let url;
-  try {
-    url = new URL(source);
-  } catch {
-    throw new Error("DESKTOP_PET_HOST 必须是有效的服务地址");
-  }
-  if (url.protocol === "https:") url.protocol = "wss:";
-  else if (url.protocol === "http:") url.protocol = "ws:";
-  if (url.protocol !== "ws:" && url.protocol !== "wss:") {
-    throw new Error("DESKTOP_PET_HOST 必须使用 http:// 或 https://");
-  }
-  url.pathname = "/ws";
-  url.search = "";
-  url.hash = "";
-  return url.toString();
-}
-function isLocalHost(value) {
-  return /^(localhost|127\.0\.0\.1|\[::1\])(?::\d+)?(?:\/|$)/i.test(value.trim());
-}
-const TASK_PROTOCOL_VERSION = "1.0";
-const sensitivePathPatterns = [
-  /(^|\/)\.env(?:\.|$)/i,
-  /(^|\/)(?:id_rsa|id_ed25519|known_hosts|credentials)(?:$|\/)/i,
-  /(^|\/)\.ssh(?:$|\/)/i,
-  /(^|\/)\.gnupg(?:$|\/)/i,
-  /(^|\/)node_modules(?:$|\/)/i,
-  /(^|\/)\.git(?:$|\/)/i,
-  /(^|\/)(?:dist|out|build|coverage)(?:$|\/)/i
-];
-function isSafeWorkspacePath(path2) {
-  if (!path2 || node_path.isAbsolute(path2) || path2.includes("\0")) return false;
-  const clean = node_path.normalize(path2);
-  return clean !== ".." && !clean.startsWith(`..${node_path.sep}`);
-}
-function isSensitiveContextPath(path2) {
-  const slashPath = path2.replaceAll("\\", "/");
-  return sensitivePathPatterns.some((pattern) => pattern.test(slashPath));
-}
-function sha256Text(text) {
-  return node_crypto.createHash("sha256").update(text, "utf8").digest("hex");
-}
-function inlineContextItem(input) {
-  if (input.path && (!isSafeWorkspacePath(input.path) || isSensitiveContextPath(input.path))) {
-    throw new Error(`unsafe or sensitive context path: ${input.path}`);
-  }
-  const size = Buffer.byteLength(input.text, "utf8");
-  return {
-    id: node_crypto.randomUUID(),
-    kind: input.kind ?? (input.path ? "file" : "text"),
-    path: input.path,
-    mimeType: input.mimeType ?? "text/plain; charset=utf-8",
-    size,
-    sha256: sha256Text(input.text),
-    encoding: "utf8",
-    transport: "inline",
-    inlineText: input.text,
-    required: input.required ?? true
-  };
-}
-function inlineResultArtifact(input) {
-  if (input.path && !isSafeWorkspacePath(input.path)) throw new Error(`unsafe result path: ${input.path}`);
-  if (input.kind === "patch" && !input.baseCommit) throw new Error("patch artifact requires baseCommit");
-  return {
-    id: node_crypto.randomUUID(),
-    kind: input.kind,
-    path: input.path,
-    mimeType: input.mimeType ?? "text/plain; charset=utf-8",
-    size: Buffer.byteLength(input.text, "utf8"),
-    sha256: sha256Text(input.text),
-    baseCommit: input.baseCommit,
-    transport: "inline",
-    inlineText: input.text
-  };
-}
-function isTerminalTaskStatus(status2) {
-  return status2 === "completed" || status2 === "failed" || status2 === "cancelled" || status2 === "expired";
-}
-const DEFAULT_EXECUTION_CAPABILITIES = [
-  "filesystem.read",
-  "filesystem.write",
-  "shell",
-  "network",
-  "browser",
-  "document.create"
-];
-function executionCapabilities(configured = process.env.DESKTOP_PET_EXECUTION_CAPABILITIES) {
-  const source = configured?.trim() || DEFAULT_EXECUTION_CAPABILITIES.join(",");
-  return [...new Set(source.split(",").map((value) => value.trim()).filter(Boolean))];
-}
-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 ?? "";
-let authToken = process.env.DESKTOP_PET_TOKEN?.trim();
-let deviceID = process.env.DESKTOP_PET_DEVICE_ID?.trim() || "";
-let signingPrivateKey = "";
-const pendingTasks = /* @__PURE__ */ new Map();
-const pendingAnswers = /* @__PURE__ */ new Map();
-const pendingTaskWaiters = /* @__PURE__ */ new Set();
-const pendingRPCs = /* @__PURE__ */ new Map();
-const availableTaskWaiters = /* @__PURE__ */ new Set();
-const resultWaiters = /* @__PURE__ */ new Map();
-const p2pSignalListeners = /* @__PURE__ */ new Set();
-const leaseTimers = /* @__PURE__ */ new Map();
-const taskSequences = /* @__PURE__ */ new Map();
-let ws = null;
-let connectPromise = null;
-let intentionalClose = false;
-let protocolV1Available = false;
-let mcpRegistration;
-function getAuthenticatedRelayUserId() {
-  return authToken ? userID : void 0;
-}
-function isProtocolV1Available() {
-  return protocolV1Available;
-}
-function getRelayHTTPAuth() {
-  if (!authToken) throw new Error("relay device access token is unavailable");
-  const url = new URL(serverURL);
-  url.protocol = url.protocol === "wss:" ? "https:" : "http:";
-  url.pathname = "";
-  url.search = "";
-  url.hash = "";
-  return { baseURL: url.toString().replace(/\/$/, ""), accessToken: authToken, deviceId: deviceID };
-}
-function configureRelayIdentity(config) {
-  if (ws || connectPromise) throw new Error("stop relay before changing identity");
-  serverURL = config.serverUrl;
-  userID = config.userId;
-  deviceID = config.deviceId;
-  authToken = config.accessToken;
-  signingPrivateKey = config.signingPrivateKey ?? "";
-}
-async function registerMcpClient(agentHost, capabilities = {}) {
-  mcpRegistration = { agentHost, capabilities };
-  await ensureConnected();
-  ws?.send(
-    JSON.stringify({
-      type: "device.capabilities",
-      protocolVersion: TASK_PROTOCOL_VERSION,
-      messageId: crypto.randomUUID(),
-      capabilities: relayCapabilities()
-    })
-  );
-}
-function startRelay() {
-  intentionalClose = false;
-  void ensureConnected().catch((err) => {
-    logger.warn("relay connect failed on startup", { error: String(err) });
-  });
-}
-function stopRelay() {
-  intentionalClose = true;
-  protocolV1Available = false;
-  connectPromise = null;
-  if (ws) {
-    ws.close();
-    ws = null;
-  }
-  for (const [id, p] of pendingAnswers) {
-    clearTimeout(p.timer);
-    p.resolve({
-      text: "连接已关闭",
-      resultKind: "text",
-      from: "",
-      questionId: id,
-      timedOut: true
-    });
-  }
-  pendingAnswers.clear();
-  for (const waiter of pendingTaskWaiters) {
-    clearTimeout(waiter.timer);
-    waiter.resolve(null);
-  }
-  pendingTaskWaiters.clear();
-  for (const pending of pendingRPCs.values()) {
-    clearTimeout(pending.timer);
-    pending.reject(new Error("relay connection closed"));
-  }
-  pendingRPCs.clear();
-  for (const wake of availableTaskWaiters) wake();
-  availableTaskWaiters.clear();
-  for (const waiters of resultWaiters.values()) {
-    for (const waiter of waiters) {
-      clearTimeout(waiter.timer);
-      waiter.resolve(null);
-    }
-  }
-  resultWaiters.clear();
-  for (const timer of leaseTimers.values()) clearInterval(timer);
-  leaseTimers.clear();
-}
-function ensureConnected() {
-  if (ws && ws.readyState === WebSocket.OPEN) return Promise.resolve();
-  if (connectPromise) return connectPromise;
-  connectPromise = new Promise((resolve, reject) => {
-    let settled = false;
-    const sock = new WebSocket(serverURL, {
-      ...authToken ? { headers: { Authorization: `Bearer ${authToken}` } } : {}
-    });
-    ws = sock;
-    sock.on("open", () => {
-      sock.send(
-        JSON.stringify({
-          type: "register",
-          protocolVersion: TASK_PROTOCOL_VERSION,
-          userId: userID,
-          deviceId: deviceID,
-          capabilities: relayCapabilities(),
-          skin: SKIN
-        })
-      );
-    });
-    sock.on("message", (data) => {
-      let msg;
-      try {
-        msg = JSON.parse(String(data));
-      } catch {
-        return;
-      }
-      if (msg.type === "registered") {
-        protocolV1Available = msg.protocolVersion === TASK_PROTOCOL_VERSION;
-        logger.info("registered to relay", { userId: userID, server: serverURL });
-        if (!settled) {
-          settled = true;
-          resolve();
-        }
-      } else if (msg.type === "error" && msg.messageId) {
-        const pending = pendingRPCs.get(msg.messageId);
-        if (pending) {
-          pendingRPCs.delete(msg.messageId);
-          clearTimeout(pending.timer);
-          const err = new Error(msg.message ?? msg.code ?? "relay request failed");
-          err.code = msg.code;
-          pending.reject(err);
-        }
-      } else if (msg.messageId && pendingRPCs.has(msg.messageId)) {
-        const pending = pendingRPCs.get(msg.messageId);
-        pendingRPCs.delete(msg.messageId);
-        clearTimeout(pending.timer);
-        pending.resolve(msg);
-      } else if (msg.type === "task.available") {
-        const sender = msg.from ?? msg.task?.envelope.from.userId;
-        if (sender) showRemoteFriendVisitor(sender, msg.skin, "有新的远端任务");
-        if (msg.taskId && sock.readyState === WebSocket.OPEN) {
-          const seq = (taskSequences.get(msg.taskId) ?? 0) + 1;
-          taskSequences.set(msg.taskId, seq);
-          sock.send(
-            JSON.stringify({
-              type: "task.delivered",
-              protocolVersion: TASK_PROTOCOL_VERSION,
-              messageId: crypto.randomUUID(),
-              taskId: msg.taskId,
-              seq,
-              sentAt: (/* @__PURE__ */ new Date()).toISOString(),
-              fromDeviceId: deviceID,
-              traceId: msg.traceId ?? crypto.randomUUID()
-            })
-          );
-        }
-        for (const wake of availableTaskWaiters) wake();
-        availableTaskWaiters.clear();
-      } else if (msg.type === "task.capability.unavailable") {
-        showCapabilityUnavailable(msg);
-      } else if (msg.type === "task.updated" && msg.task) {
-        if (isTerminalTaskStatus(msg.task.status) || msg.task.status === "cancelling") stopLease(msg.task.taskId);
-        if (msg.task.status === "running" && msg.task.assignedDeviceId === deviceID) startLease(msg.task.taskId);
-        showCapabilityGapResult(msg.task);
-        notifyResultWaiters(msg.task);
-      } else if (msg.type.startsWith("p2p.") && msg.type !== "p2p.forwarded") {
-        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 });
-        showDesktopNotification("桌宠好友求助", `@${msg.from} 想请你帮忙，右键桌宠可以同意或婉拒`);
-      } else if (msg.type === "help.updated" && msg.to) {
-        dispatch({ type: "state", state: msg.status === "accepted" ? "success" : "failed", ttl: 10 });
-        dispatch({
-          type: "bubble",
-          text: msg.status === "accepted" ? `@${msg.to} 同意帮你了，可以让 Agent 派任务啦！` : `@${msg.to} 婉拒了你的求助`,
-          ttl: 1e4
-        });
-      } else if (msg.type === "chat.message" && msg.from && msg.text) {
-        dispatch({ type: "state", state: "excited", ttl: 6 });
-        dispatch({ type: "bubble", text: `${msg.from}：${msg.text}`, ttl: 1e4 });
-        showDesktopNotification(`来自 ${msg.from} 的消息`, msg.text);
-      } else if (msg.type === "ask") {
-        onAsk(msg);
-      } else if (msg.type === "answer") {
-        onAnswer(msg);
-      } else if (msg.type === "error" && msg.questionId) {
-        const pending = pendingAnswers.get(msg.questionId);
-        if (pending) {
-          pendingAnswers.delete(msg.questionId);
-          clearTimeout(pending.timer);
-          pending.resolve({
-            text: msg.message ?? "对方不在线",
-            resultKind: "text",
-            from: "",
-            questionId: msg.questionId,
-            timedOut: true
-          });
-        }
-      }
-    });
-    sock.on("error", (err) => {
-      logger.warn("relay socket error", { error: String(err) });
-      if (!settled) {
-        settled = true;
-        if (ws === sock) {
-          connectPromise = null;
-        }
-        reject(err);
-      }
-    });
-    sock.on("close", (code, reason) => {
-      const isCurrentSocket = ws === sock;
-      logger.warn("relay connection closed", {
-        server: serverURL,
-        code,
-        reason: reason.toString(),
-        isCurrentSocket
-      });
-      if (isCurrentSocket) {
-        ws = null;
-        connectPromise = null;
-      }
-      if (!settled) {
-        settled = true;
-        reject(new Error(`relay connection closed before registration (${code})`));
-      }
-      if (isCurrentSocket && !intentionalClose) {
-        setTimeout(() => {
-          void ensureConnected().catch(() => {
-          });
-        }, 3e3);
-      }
-    });
-  });
-  return connectPromise;
-}
-async function askFriend(opts) {
-  await ensureConnected();
-  const questionId = crypto.randomUUID();
-  const timeoutMs = opts.timeoutMs ?? 3e5;
-  const friendName = opts.to;
-  handleQuest({
-    type: "quest",
-    phase: "leave",
-    friendName,
-    leaveText: `任务交给我！我去找 ${friendName} 帮忙～`
-  });
-  return new Promise((resolve) => {
-    const timer = setTimeout(() => {
-      pendingAnswers.delete(questionId);
-      handleQuest({
-        type: "quest",
-        phase: "return",
-        returnText: `对方暂时没理我（${Math.round(timeoutMs / 1e3)} 秒）`,
-        fish: 1
-      });
-      resolve({
-        questionId,
-        from: "",
-        text: `对方暂时没理我（${Math.round(timeoutMs / 1e3)} 秒未回复）`,
-        resultKind: "text",
-        timedOut: true
-      });
-    }, timeoutMs);
-    pendingAnswers.set(questionId, {
-      friendName,
-      timer,
-      resolve: (value) => {
-        handleQuest({
-          type: "quest",
-          phase: "return",
-          returnText: value.timedOut ? value.text.slice(0, 80) : `我回来啦！${value.from || friendName} 那边有结果了`,
-          fish: value.timedOut ? 1 : 5
-        });
-        resolve(value);
-      }
-    });
-    ws.send(
-      JSON.stringify({
-        type: "ask",
-        to: opts.to,
-        questionId,
-        title: opts.title,
-        text: opts.text,
-        context: opts.context,
-        tools: opts.tools
-      })
-    );
-    logger.info("ask friend", { to: opts.to, questionId });
-  });
-}
-async function getCollaborationState() {
-  const response = await relayRPC({ type: "help.list" }, 1e4);
-  return { friends: response.friends ?? [], helpRequests: response.helpRequests ?? [] };
-}
-async function requestFriendHelp(to) {
-  const response = await relayRPC({ type: "help.request", to }, 1e4);
-  return response.helpRequests?.[0];
-}
-async function respondFriendHelp(requestId, accept) {
-  await relayRPC({ type: "help.respond", requestId, status: accept ? "accepted" : "rejected" }, 1e4);
-}
-async function sendFriendChat(to, text) {
-  await relayRPC({ type: "chat.send", to, text }, 1e4);
-}
-function listPendingTasks() {
-  return [...pendingTasks.values()].sort((a, b) => b.createdAt - a.createdAt);
-}
-function waitForPendingTask(timeoutMs) {
-  const existing = listPendingTasks()[0];
-  if (existing) return Promise.resolve(existing);
-  const waitMs = typeof timeoutMs === "number" && Number.isFinite(timeoutMs) ? Math.min(Math.max(timeoutMs, 1e3), 55e3) : 45e3;
-  return new Promise((resolve) => {
-    const waiter = {
-      resolve,
-      timer: setTimeout(() => {
-        pendingTaskWaiters.delete(waiter);
-        resolve(null);
-      }, waitMs)
-    };
-    pendingTaskWaiters.add(waiter);
-  });
-}
-async function answerFriend(questionId, text, resultKind = "text") {
-  await ensureConnected();
-  const task = pendingTasks.get(questionId);
-  if (!task) {
-    const err = new Error("问题不存在或已被回答");
-    err.code = "UNKNOWN_QUESTION";
-    throw err;
-  }
-  pendingTasks.delete(questionId);
-  ws.send(JSON.stringify({ type: "answer", questionId, text, resultKind }));
-  logger.info("answered friend task", { questionId, resultKind });
-  dispatch({
-    type: "bubble",
-    text: `结果已送回给 ${task.from}～`,
-    ttl: 6e3
-  });
-  dispatch({ type: "state", state: "excited", ttl: 6 });
-}
-async function delegateTask(envelope) {
-  const authenticatedEnvelope = {
-    ...envelope,
-    from: { userId: userID, deviceId: deviceID }
-  };
-  const response = await relayRPC(
-    { type: "task.create", protocolVersion: TASK_PROTOCOL_VERSION, envelope: authenticatedEnvelope },
-    15e3
-  );
-  if (!response.task) throw new Error("relay did not return the created task");
-  if (response.warning) {
-    logger.warn("task created with delivery warning", { warning: response.warning });
-    dispatch({ type: "state", state: "failed", ttl: 10 });
-    dispatch({ type: "bubble", text: `暂时无法派发任务：${response.warning}`, ttl: 16e3 });
-    showDesktopNotification("桌宠任务暂未派发", response.warning);
-  }
-  return { task: response.task, warning: response.warning };
-}
-function relayCapabilities() {
-  return {
-    agentHost: mcpRegistration?.agentHost ?? (process.env.DESKTOP_PET_AGENT_HOST || "desktop-pet-mcp"),
-    mcp: {
-      tools: true,
-      sampling: false,
-      roots: true,
-      tasks: true,
-      ...mcpRegistration?.capabilities ?? {}
-    },
-    execution: executionCapabilities(),
-    platform: `${process.platform}-${process.arch}`
-  };
-}
-function showCapabilityUnavailable(msg) {
-  const required = msg.requiredCapabilities ?? [];
-  const available = new Set(executionCapabilities());
-  const missing = required.filter((capability) => !available.has(capability));
-  const named = (missing.length > 0 ? missing : required).join("、") || "所需工具";
-  const sender = msg.from ? `@${msg.from} 的` : "这项";
-  const text = `暂时无法帮忙：${sender}任务需要 ${named}。请在当前 Agent 中安装或启用对应工具后重新连接桌宠。`;
-  dispatch({ type: "state", state: "failed", ttl: 12 });
-  dispatch({ type: "bubble", text, ttl: 18e3 });
-  showDesktopNotification("桌宠暂时无法接单", text);
-}
-async function getRemoteTask(taskId) {
-  const response = await relayRPC(
-    { type: "task.get", protocolVersion: TASK_PROTOCOL_VERSION, taskId },
-    1e4
-  );
-  if (!response.task) throw new Error("relay did not return task details");
-  return response.task;
-}
-async function listRemoteTasks(options) {
-  const response = await relayRPC(
-    {
-      type: "task.list",
-      protocolVersion: TASK_PROTOCOL_VERSION,
-      direction: options.direction,
-      status: options.status,
-      limit: options.limit
-    },
-    1e4
-  );
-  return response.tasks ?? [];
-}
-async function claimRemoteTask(timeoutMs = 45e3) {
-  const immediate = await claimOnce();
-  if (immediate) {
-    startLease(immediate.taskId);
-    dispatch({ type: "state", state: "working", ttl: 30 });
-    return immediate;
-  }
-  const waitMs = Math.min(Math.max(timeoutMs, 1e3), 55e3);
-  const available = await new Promise((resolve) => {
-    let done = false;
-    const wake = () => {
-      if (done) return;
-      done = true;
-      clearTimeout(timer);
-      availableTaskWaiters.delete(wake);
-      resolve(true);
-    };
-    const timer = setTimeout(() => {
-      if (done) return;
-      done = true;
-      availableTaskWaiters.delete(wake);
-      resolve(false);
-    }, waitMs);
-    availableTaskWaiters.add(wake);
-  });
-  if (!available) return null;
-  const claimed = await claimOnce();
-  if (claimed) {
-    startLease(claimed.taskId);
-    dispatch({ type: "state", state: "working", ttl: 30 });
-  }
-  return claimed;
-}
-async function waitRemoteTaskResult(taskId, timeoutMs = 45e3) {
-  const current = await getRemoteTask(taskId);
-  if (isTerminalTaskStatus(current.status) || current.status === "needs_context") return current;
-  const waitMs = Math.min(Math.max(timeoutMs, 1e3), 55e3);
-  return new Promise((resolve) => {
-    const waiters = resultWaiters.get(taskId) ?? /* @__PURE__ */ new Set();
-    const waiter = {
-      resolve: (task) => resolve(task ?? current),
-      timer: setTimeout(() => {
-        waiters.delete(waiter);
-        if (waiters.size === 0) resultWaiters.delete(taskId);
-        resolve(current);
-      }, waitMs)
-    };
-    waiters.add(waiter);
-    resultWaiters.set(taskId, waiters);
-  });
-}
-async function submitRemoteTaskResult(result) {
-  await relayRPC(
-    {
-      type: "task.result",
-      protocolVersion: TASK_PROTOCOL_VERSION,
-      taskId: result.taskId,
-      result
-    },
-    15e3
-  );
-  stopLease(result.taskId);
-  dispatch({ type: "state", state: result.status === "completed" ? "success" : "failed", ttl: 12 });
-  const gap = result.diagnostics.find((diagnostic) => diagnostic.code === "CAPABILITY_UNAVAILABLE");
-  if (gap) {
-    dispatch({ type: "bubble", text: `暂时无法帮忙：${gap.message}`, ttl: 18e3 });
-    showDesktopNotification("桌宠暂时无法接单", gap.message);
-  }
-}
-function showCapabilityGapResult(task) {
-  const gap = task.result?.diagnostics.find((diagnostic) => diagnostic.code === "CAPABILITY_UNAVAILABLE");
-  if (!gap) return;
-  const text = `@${task.envelope.to.userId} 暂时无法帮助：${gap.message}`;
-  dispatch({ type: "state", state: "failed", ttl: 12 });
-  dispatch({ type: "bubble", text, ttl: 18e3 });
-  showDesktopNotification("桌宠任务无法完成", text);
-}
-async function cancelRemoteTask(taskId) {
-  const response = await relayRPC(
-    { type: "task.cancel", protocolVersion: TASK_PROTOCOL_VERSION, taskId },
-    1e4
-  );
-  return response.task;
-}
-function onP2PSignal(listener) {
-  p2pSignalListeners.add(listener);
-  return () => p2pSignalListeners.delete(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, deviceID)), signingPrivateKey).toString("base64");
-  await relayRPC({ ...outgoing, signature }, 1e4);
-}
-async function requestRemoteTaskContext(taskId, request) {
-  const response = await relayRPC(
-    { type: "task.context.request", protocolVersion: TASK_PROTOCOL_VERSION, taskId, payload: request },
-    1e4
-  );
-  return response.task;
-}
-async function supplyRemoteTaskContext(taskId, items) {
-  const response = await relayRPC(
-    { type: "task.context.supply", protocolVersion: TASK_PROTOCOL_VERSION, taskId, payload: { items } },
-    15e3
-  );
-  return response.task;
-}
-async function claimOnce() {
-  const response = await relayRPC(
-    { type: "task.claim", protocolVersion: TASK_PROTOCOL_VERSION },
-    1e4
-  );
-  return response.task ?? null;
-}
-async function relayRPC(message, timeoutMs) {
-  await ensureConnected();
-  const messageId = crypto.randomUUID();
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => {
-      pendingRPCs.delete(messageId);
-      reject(new Error(`relay request timed out: ${message.type}`));
-    }, timeoutMs);
-    pendingRPCs.set(messageId, { resolve, reject, timer });
-    const taskKey = message.taskId ?? message.envelope?.taskId;
-    const seq = taskKey ? (taskSequences.get(taskKey) ?? 0) + 1 : 0;
-    if (taskKey) taskSequences.set(taskKey, seq);
-    ws.send(
-      JSON.stringify({
-        ...message,
-        messageId,
-        seq,
-        sentAt: (/* @__PURE__ */ new Date()).toISOString(),
-        fromDeviceId: deviceID,
-        traceId: message.traceId ?? crypto.randomUUID()
-      })
-    );
-  });
-}
-function notifyResultWaiters(task) {
-  const waiters = resultWaiters.get(task.taskId);
-  if (!waiters) return;
-  resultWaiters.delete(task.taskId);
-  for (const waiter of waiters) {
-    clearTimeout(waiter.timer);
-    waiter.resolve(task);
-  }
-}
-function startLease(taskId) {
-  stopLease(taskId);
-  const timer = setInterval(() => {
-    void relayRPC({ type: "task.lease", protocolVersion: TASK_PROTOCOL_VERSION, taskId }, 1e4).catch(() => {
-      stopLease(taskId);
-    });
-  }, 3e4);
-  leaseTimers.set(taskId, timer);
-}
-function stopLease(taskId) {
-  const timer = leaseTimers.get(taskId);
-  if (timer) clearInterval(timer);
-  leaseTimers.delete(taskId);
-}
-function onAsk(msg) {
-  if (!msg.questionId || !msg.from || !msg.text) return;
-  const task = {
-    questionId: msg.questionId,
-    from: msg.from,
-    title: msg.title,
-    text: msg.text,
-    context: msg.context,
-    tools: msg.tools,
-    createdAt: Date.now()
-  };
-  pendingTasks.set(msg.questionId, task);
-  notifyTaskWaiter(task);
-  logger.info("received friend task", { from: msg.from, questionId: msg.questionId });
-  const preview = (msg.title || msg.text).slice(0, 40);
-  dispatch({ type: "state", state: "excited", ttl: 12 });
-  dispatch({
-    type: "bubble",
-    text: `有任务了！来自 ${msg.from}：${preview}`,
-    ttl: 16e3
-  });
-  setTimeout(() => {
-    dispatch({
-      type: "bubble",
-      text: "跟 Agent 说：帮我朋友一下",
-      ttl: 8e3
-    });
-  }, 2500);
-  showRemoteFriendVisitor(msg.from, msg.skin, "又发来了一项任务");
-}
-function showRemoteFriendVisitor(username, requestedSkin, message = "发来了一项任务") {
-  const existingVisitor = petManager.findRemoteFriend(username);
-  if (existingVisitor) {
-    dispatch({ type: "state", state: "excited", ttl: 12 }, existingVisitor.id);
-    dispatch({ type: "bubble", text: `@${username} ${message}`, ttl: 8e3 }, existingVisitor.id);
-    return;
-  }
-  const skin = requestedSkin && SKIN_IDS.includes(requestedSkin) ? requestedSkin : "claude";
-  void Promise.resolve().then(() => petWindow).then(
-    ({ createPetWindow: createPetWindow2 }) => createPetWindow2(skin, { identity: { kind: "remote-friend", username } })
-  );
-}
-function notifyTaskWaiter(task) {
-  const waiter = pendingTaskWaiters.values().next().value;
-  if (!waiter) return;
-  pendingTaskWaiters.delete(waiter);
-  clearTimeout(waiter.timer);
-  waiter.resolve(task);
-}
-function onAnswer(msg) {
-  if (!msg.questionId) return;
-  const pending = pendingAnswers.get(msg.questionId);
-  if (!pending) return;
-  pendingAnswers.delete(msg.questionId);
-  clearTimeout(pending.timer);
-  const kind = normalizeResultKind$1(msg.resultKind);
-  pending.resolve({
-    questionId: msg.questionId,
-    from: msg.from ?? "",
-    text: msg.text ?? "",
-    resultKind: kind
-  });
-}
-function normalizeResultKind$1(v) {
-  if (v === "code" || v === "patch" || v === "markdown" || v === "files" || v === "text") return v;
-  return "text";
-}
-let refreshTimer;
-let deviceIceServers = [];
-function getDeviceIceServers() {
-  return deviceIceServers;
-}
-async function activateStoredDevice() {
-  if (process.env.DESKTOP_PET_TOKEN?.trim()) {
-    startRelay();
-    return true;
-  }
-  const credentials = loadDeviceCredentials();
-  if (!credentials) return false;
-  await activateDevice(credentials, false);
-  return true;
-}
-async function configureAndActivateDevice(credentials) {
-  const signedCredentials = withSigningKeys(credentials);
-  saveDeviceCredentials(signedCredentials);
-  await activateDevice(signedCredentials, true);
-}
-async function activateDevice(credentials, restart) {
-  if (!credentials.publicKey || !credentials.privateKey || !credentials.encryptionPublicKey || !credentials.encryptionPrivateKey) {
-    credentials = withSigningKeys(credentials);
-    saveDeviceCredentials(credentials);
-  }
-  const base = credentials.serverUrl.replace(/\/$/, "");
-  const response = await fetch(`${base}/api/auth/device-token`, {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify({
-      deviceId: credentials.deviceId,
-      refreshToken: credentials.refreshToken,
-      publicKey: credentials.publicKey,
-      encryptionPublicKey: credentials.encryptionPublicKey
-    })
-  });
-  const body = await response.json();
-  if (!response.ok || body.code !== 0 || !body.data?.token) {
-    throw new Error(body.message || "设备令牌刷新失败");
-  }
-  if (body.data.user.username.toLowerCase() !== credentials.userId.toLowerCase()) {
-    throw new Error("设备凭据用户与配置用户不一致");
-  }
-  const iceResponse = await fetch(`${base}/api/p2p/ice-config`, {
-    headers: { Authorization: `Bearer ${body.data.token}` }
-  }).catch(() => void 0);
-  if (iceResponse?.ok) {
-    const iceBody = await iceResponse.json();
-    deviceIceServers = iceBody.data?.iceServers ?? [];
-  }
-  if (restart) stopRelay();
-  const httpURL = new URL(base);
-  httpURL.protocol = httpURL.protocol === "https:" ? "wss:" : "ws:";
-  httpURL.pathname = "/ws";
-  configureRelayIdentity({
-    serverUrl: httpURL.toString(),
-    userId: credentials.userId,
-    deviceId: credentials.deviceId,
-    accessToken: body.data.token,
-    signingPrivateKey: credentials.privateKey
-  });
-  startRelay();
-  clearTimeout(refreshTimer);
-  const refreshAt = Math.max(6e4, new Date(body.data.expiresAt).getTime() - Date.now() - 5 * 6e4);
-  refreshTimer = setTimeout(() => {
-    void activateDevice(credentials, true).catch(
-      (err) => logger.warn("device access token refresh failed", { error: String(err) })
-    );
-  }, refreshAt);
-}
-function withSigningKeys(credentials) {
-  let next = credentials;
-  if (!next.publicKey || !next.privateKey) {
-    const { publicKey, privateKey } = node_crypto.generateKeyPairSync("ed25519", {
-      publicKeyEncoding: { type: "spki", format: "pem" },
-      privateKeyEncoding: { type: "pkcs8", format: "pem" }
-    });
-    next = { ...next, publicKey, privateKey };
-  }
-  if (!next.encryptionPublicKey || !next.encryptionPrivateKey) {
-    const { publicKey, privateKey } = node_crypto.generateKeyPairSync("rsa", {
-      modulusLength: 2048,
-      publicKeyEncoding: { type: "spki", format: "pem" },
-      privateKeyEncoding: { type: "pkcs8", format: "pem" }
-    });
-    next = { ...next, encryptionPublicKey: publicKey, encryptionPrivateKey: privateKey };
-  }
-  return next;
-}
-const deviceAuth = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  activateStoredDevice,
-  configureAndActivateDevice,
-  getDeviceIceServers
-}, Symbol.toStringTag, { value: "Module" }));
-function defaultAccountServerURL(relayURL = configuredRelayURL()) {
-  const url = new URL(relayURL);
-  url.protocol = url.protocol === "wss:" ? "https:" : "http:";
-  url.pathname = "";
-  url.search = "";
-  url.hash = "";
-  return url.toString().replace(/\/$/, "");
-}
-function defaultAccountPortalURL(serverUrl) {
-  const override = process.env.DESKTOP_PET_PORTAL_URL?.trim();
-  return override ? normalizeServerURL(override) : serverUrl;
-}
-async function bindDesktopPetToWebSession(server, accessToken) {
-  const serverUrl = normalizeServerURL(server);
-  if (!accessToken) throw new Error("网页没有返回有效的登录会话");
-  const session = await get(serverUrl, "/api/auth/me", accessToken);
-  if (!session.user?.username) throw new Error("服务器没有返回有效的账号信息");
-  const device = await post(
-    serverUrl,
-    "/api/devices",
-    {
-      name: `Desktop Pet · ${node_os.hostname()}`,
-      capabilities: {
-        agentHost: process.env.DESKTOP_PET_AGENT_HOST || "unknown-mcp-host",
-        mcp: { tools: true, sampling: false, roots: true, tasks: true },
-        execution: executionCapabilities(),
-        platform: `${process.platform}-${process.arch}`
-      }
-    },
-    accessToken
-  );
-  if (!device.device?.id || !device.refreshToken) throw new Error("服务器没有返回有效的桌宠设备凭据");
-  await configureAndActivateDevice({
-    serverUrl,
-    userId: session.user.username,
-    deviceId: device.device.id,
-    refreshToken: device.refreshToken
-  });
-  return { username: session.user.username };
-}
-function normalizeServerURL(value) {
-  let url;
-  try {
-    url = new URL(value.trim());
-  } catch {
-    throw new Error("中转服务器地址无效");
-  }
-  if (url.protocol !== "http:" && url.protocol !== "https:") {
-    throw new Error("中转服务器地址必须以 http:// 或 https:// 开头");
-  }
-  url.pathname = "";
-  url.search = "";
-  url.hash = "";
-  return url.toString().replace(/\/$/, "");
-}
-async function post(serverUrl, path2, body, token) {
-  let response;
-  try {
-    response = await fetch(`${serverUrl}${path2}`, {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        ...token ? { authorization: `Bearer ${token}` } : {}
-      },
-      body: JSON.stringify(body)
-    });
-  } catch {
-    throw new Error("无法连接中转服务器");
-  }
-  let envelope;
-  try {
-    envelope = await response.json();
-  } catch {
-    throw new Error("中转服务器返回了无效响应");
-  }
-  if (!response.ok || envelope.code !== 0 || !envelope.data) {
-    throw new Error(envelope.message || "请求失败");
-  }
-  return envelope.data;
-}
-async function get(serverUrl, path2, token) {
-  let response;
-  try {
-    response = await fetch(`${serverUrl}${path2}`, { headers: { authorization: `Bearer ${token}` } });
-  } catch {
-    throw new Error("无法连接中转服务器");
-  }
-  let envelope;
-  try {
-    envelope = await response.json();
-  } catch {
-    throw new Error("中转服务器返回了无效响应");
-  }
-  if (!response.ok || envelope.code !== 0 || !envelope.data) {
-    throw new Error(envelope.message || "登录会话已失效");
-  }
-  return envelope.data;
-}
-const pendingServers = /* @__PURE__ */ new Set();
-let callbackServer;
-let callbackPort;
-let callbackNonce;
-async function startAccountCallbackRouter() {
-  if (callbackServer) return;
-  callbackNonce = node_crypto.randomBytes(24).toString("base64url");
-  callbackServer = node_http.createServer((req, res) => {
-    if (req.method !== "POST" || req.url !== "/auth-callback") {
-      res.writeHead(404).end();
-      return;
-    }
-    let body = "";
-    req.setEncoding("utf8");
-    req.on("data", (chunk) => {
-      body += chunk;
-      if (body.length > 16 * 1024) req.destroy();
-    });
-    req.on("end", () => {
-      try {
-        const payload = JSON.parse(body);
-        if (payload.nonce !== callbackNonce || typeof payload.url !== "string") {
-          res.writeHead(403).end();
-          return;
-        }
-        res.writeHead(204).end();
-        void finishWebAuthentication(payload.url);
-      } catch {
-        res.writeHead(400).end();
-      }
-    });
-  });
-  await new Promise((resolve, reject) => {
-    callbackServer.once("error", reject);
-    callbackServer.listen(0, "127.0.0.1", () => {
-      callbackServer.removeListener("error", reject);
-      const address = callbackServer.address();
-      if (!address || typeof address === "string") {
-        reject(new Error("本地认证回调端口不可用"));
-        return;
-      }
-      callbackPort = address.port;
-      resolve();
-    });
-  });
-}
-function stopAccountCallbackRouter() {
-  callbackServer?.close();
-  callbackServer = void 0;
-  callbackPort = void 0;
-  callbackNonce = void 0;
-}
-function openAccountWindow(mode) {
-  const serverUrl = storedServerURL() ?? defaultAccountServerURL();
-  let portalBase;
-  try {
-    portalBase = defaultAccountPortalURL(serverUrl);
-  } catch (error) {
-    electron.dialog.showErrorBox("门户地址无效", error instanceof Error ? error.message : "请检查 DESKTOP_PET_PORTAL_URL 配置");
-    return;
-  }
-  const portalURL = new URL("/", `${portalBase}/`);
-  portalURL.searchParams.set("desktopPet", "1");
-  portalURL.searchParams.set("desktopPetMode", mode);
-  const callbackURL = new URL("desktop-pet://auth-complete");
-  callbackURL.searchParams.set("server", serverUrl);
-  if (callbackPort && callbackNonce) {
-    callbackURL.searchParams.set("callbackPort", String(callbackPort));
-    callbackURL.searchParams.set("callbackNonce", callbackNonce);
-  }
-  portalURL.searchParams.set("desktopPetReturn", callbackURL.toString());
-  pendingServers.add(serverUrl);
-  dispatch({ type: "bubble", text: "已打开默认浏览器，请完成账号认证～", ttl: 5e3 });
-  void electron.shell.openExternal(portalURL.toString()).catch((error) => {
-    pendingServers.delete(serverUrl);
-    electron.dialog.showErrorBox("无法打开浏览器", error instanceof Error ? error.message : "请检查默认浏览器设置");
-  });
-}
-function registerAccountProtocol() {
-  if (process.defaultApp && process.argv[1]) {
-    electron.app.setAsDefaultProtocolClient("desktop-pet", process.execPath, [process.argv[1]]);
-  } else {
-    electron.app.setAsDefaultProtocolClient("desktop-pet");
-  }
-  electron.app.on("open-url", (event, url) => {
-    event.preventDefault();
-    void handleAccountCallback(url);
-  });
-}
-function handleAccountCallback(url) {
-  const callback = parseDesktopPetCallback(url);
-  if (callback?.callbackPort && callback.callbackNonce) {
-    void forwardAuthenticationCallback(callback.callbackPort, callback.callbackNonce, url);
-    return;
-  }
-  void finishWebAuthentication(url);
-}
-function logoutDesktopPet() {
-  stopRelay();
-  clearDeviceCredentials();
-  petManager.refreshLocalIdentityBadges();
-  dispatch({ type: "bubble", text: "已退出当前账号" });
-}
-function currentAccountUsername() {
-  try {
-    return loadDeviceCredentials()?.userId ?? getAuthenticatedRelayUserId();
-  } catch {
-    return getAuthenticatedRelayUserId();
-  }
-}
-function storedServerURL() {
-  try {
-    return loadDeviceCredentials()?.serverUrl;
-  } catch {
-    return void 0;
-  }
-}
-function parseDesktopPetCallback(value) {
-  try {
-    const callback = new URL(value);
-    if (callback.protocol !== "desktop-pet:" || callback.hostname !== "auth-complete") return void 0;
-    const serverUrl = callback.searchParams.get("server");
-    const token = new URLSearchParams(callback.hash.slice(1)).get("token");
-    if (!serverUrl || !token) return void 0;
-    const rawPort = callback.searchParams.get("callbackPort");
-    const callbackPort2 = rawPort ? Number(rawPort) : void 0;
-    const callbackNonce2 = callback.searchParams.get("callbackNonce") ?? void 0;
-    if (callbackPort2 && (!Number.isInteger(callbackPort2) || callbackPort2 < 1 || callbackPort2 > 65535)) return void 0;
-    return { serverUrl, token, callbackPort: callbackPort2, callbackNonce: callbackNonce2 };
-  } catch {
-    return void 0;
-  }
-}
-async function forwardAuthenticationCallback(port, nonce, url) {
-  try {
-    const response = await fetch(`http://127.0.0.1:${port}/auth-callback`, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ nonce, url })
-    });
-    if (!response.ok) throw new Error(`本地认证回调被拒绝 (${response.status})`);
-  } catch (error) {
-    electron.dialog.showErrorBox("无法回传登录结果", error instanceof Error ? error.message : "请重新在对应桌宠窗口发起登录");
-  }
-}
-async function finishWebAuthentication(callbackURL) {
-  const callback = parseDesktopPetCallback(callbackURL);
-  if (!callback || !pendingServers.has(callback.serverUrl)) return;
-  pendingServers.delete(callback.serverUrl);
-  try {
-    const result = await bindDesktopPetToWebSession(callback.serverUrl, callback.token);
-    petManager.refreshLocalIdentityBadges(result.username);
-    dispatch({ type: "bubble", text: `已登录 @${result.username}` });
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "登录后的桌宠绑定失败";
-    dispatch({ type: "bubble", text: `登录失败：${message}` });
-    electron.dialog.showErrorBox("Desktop Pet 登录失败", message);
-  }
-}
-function copyMcpConfig() {
-  const serverEntry = path.join(electron.app.getAppPath(), "out", "mcp-server", "index.js");
-  if (!fs.existsSync(serverEntry)) {
-    return { ok: false, message: "MCP server 尚未构建，请先在 app 目录执行 npm run build" };
-  }
-  const customPortFile = process.env.DESKTOP_PET_PORT_FILE?.trim();
-  const config = {
-    mcpServers: {
-      "desktop-pet": {
-        command: "node",
-        args: [serverEntry],
-        ...customPortFile ? { env: { DESKTOP_PET_PORT_FILE: PORT_FILE } } : {}
-      }
-    }
-  };
-  electron.clipboard.writeText(JSON.stringify(config, null, 2));
-  return { ok: true, message: "MCP 配置已复制，直接粘贴到 Agent 的 MCP 配置里即可" };
-}
-const P2P_CHAT_CONNECT_TIMEOUT_MS = 2500;
-let transportWindow;
-let transportReady = false;
-let removeRelayListener;
-const pendingChats = /* @__PURE__ */ new Map();
-function startP2PWindow(iceServers = []) {
-  if (transportWindow) return;
-  const win = new electron.BrowserWindow({
-    show: false,
-    width: 1,
-    height: 1,
-    webPreferences: {
-      preload: node_path.join(__dirname, "../preload/index.js"),
-      contextIsolation: true
-    }
-  });
-  transportWindow = win;
-  transportReady = false;
-  win.webContents.once("did-finish-load", () => {
-    transportReady = true;
-    win.webContents.send(P2P_CONFIG, { iceServers });
-  });
-  if (process.env.ELECTRON_RENDERER_URL) {
-    win.loadURL(`${process.env.ELECTRON_RENDERER_URL}/p2p.html`);
-  } else {
-    win.loadFile(node_path.join(__dirname, "../renderer/p2p.html"));
-  }
-  removeRelayListener = onP2PSignal((message) => {
-    if (!win.isDestroyed()) win.webContents.send(P2P_SIGNAL_IN, message);
-  });
-  electron.ipcMain.on(P2P_SIGNAL_OUT, onRendererSignal);
-  electron.ipcMain.on(P2P_CHAT_EVENT, onChatEvent);
-  win.on("closed", () => {
-    transportWindow = void 0;
-    transportReady = false;
-    removeRelayListener?.();
-    removeRelayListener = void 0;
-    electron.ipcMain.removeListener(P2P_SIGNAL_OUT, onRendererSignal);
-    electron.ipcMain.removeListener(P2P_CHAT_EVENT, onChatEvent);
-  });
-}
-function stopP2PWindow() {
-  removeRelayListener?.();
-  removeRelayListener = void 0;
-  electron.ipcMain.removeListener(P2P_SIGNAL_OUT, onRendererSignal);
-  electron.ipcMain.removeListener(P2P_CHAT_EVENT, onChatEvent);
-  transportWindow?.destroy();
-  transportWindow = void 0;
-  transportReady = false;
-  for (const [operationId, pending] of pendingChats) {
-    clearTimeout(pending.timer);
-    pending.reject(new Error("P2P 服务已停止"));
-    pendingChats.delete(operationId);
-  }
-}
-async function sendFriendChatPreferred(input) {
-  const text = input.text.trim();
-  if (!text || text.length > 500) throw new Error("消息内容须为 1–500 个字符");
-  if (!transportWindow || !transportReady || !input.toDeviceId) {
-    await sendFriendChat(input.to, text);
-    return "relay";
-  }
-  const operationId = node_crypto.randomUUID();
-  return new Promise((resolve, reject) => {
-    const pending = {
-      to: input.to,
-      text,
-      resolve,
-      reject,
-      timer: setTimeout(() => void fallbackChat(operationId), P2P_CHAT_CONNECT_TIMEOUT_MS + 1e3)
-    };
-    pendingChats.set(operationId, pending);
-    transportWindow.webContents.send(P2P_CHAT_SEND, {
-      operationId,
-      taskId: `chat.${operationId}`,
-      toDeviceId: input.toDeviceId,
-      toUsername: input.to,
-      text
-    });
-  });
-}
-function onRendererSignal(event, message) {
-  if (!transportWindow || event.sender !== transportWindow.webContents) return;
-  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));
-    }
-  });
-}
-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 });
-    showDesktopNotification(`来自 ${value.from ?? "好友"} 的消息`, value.text);
-    return;
-  }
-  if (!value.operationId) return;
-  const pending = pendingChats.get(value.operationId);
-  if (!pending) return;
-  if (value.type === "sent") {
-    clearTimeout(pending.timer);
-    pendingChats.delete(value.operationId);
-    logger.info("friend chat sent", { to: pending.to, transport: "p2p" });
-    pending.resolve("p2p");
-  } else if (value.type === "failed") {
-    void fallbackChat(value.operationId);
-  }
-}
-async function fallbackChat(operationId) {
-  const pending = pendingChats.get(operationId);
-  if (!pending) return;
-  clearTimeout(pending.timer);
-  pendingChats.delete(operationId);
-  try {
-    await sendFriendChat(pending.to, pending.text);
-    logger.info("friend chat sent", { to: pending.to, transport: "relay" });
-    pending.resolve("relay");
-  } catch (error) {
-    pending.reject(error instanceof Error ? error : new Error("消息发送失败"));
-  }
-}
-const REQUEST_TIMEOUT_MS = 6e3;
-const DOWNLOAD_TIMEOUT_MS = 10 * 6e4;
-const LEGACY_OFFICIAL_HTTP_HOST = "47.94.20.104";
-const MAC_BUNDLE_ID = "com.xinshu.desktoppet";
-const MAC_INSTALLED_APP = "/Applications/Desktop Pet.app";
-let status = { kind: "idle" };
-function updateCheckURL() {
-  const override = process.env.DESKTOP_PET_UPDATE_API?.trim();
-  if (override) return validateUpdateAPIURL(override).toString();
-  const relayURL = updateRelayURL();
-  const url = new URL(relayURL);
-  url.protocol = url.protocol === "wss:" ? "https:" : "http:";
-  url.pathname = "/api/updates/check";
-  url.search = "";
-  url.hash = "";
-  return validateUpdateAPIURL(url.toString()).toString();
-}
-function getUpdateStatus() {
-  return status;
-}
-async function checkForUpdates(currentVersion = electron.app.getVersion()) {
-  if (status.kind === "downloading") return status;
-  status = { kind: "checking" };
-  try {
-    const endpoint = new URL(updateCheckURL());
-    endpoint.searchParams.set("platform", process.platform);
-    endpoint.searchParams.set("arch", process.arch);
-    endpoint.searchParams.set("currentVersion", currentVersion);
-    const response = await electron.net.fetch(endpoint.toString(), {
-      headers: updateCheckHeaders(endpoint),
-      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
-      cache: "no-store"
-    });
-    const body = await response.json();
-    if (!response.ok || body.code !== 0 || !body.data) {
-      throw new Error(body.message || "更新服务器返回异常");
-    }
-    const update = parseUpdate(body.data.update);
-    if (!update || compareVersions(update.version, currentVersion) <= 0) {
-      status = { kind: "up-to-date", checkedAt: Date.now() };
-      return status;
-    }
-    const cachedArtifactPath = await verifiedCachedArtifact(update);
-    if (cachedArtifactPath) {
-      status = { kind: "downloaded", update, artifactPath: cachedArtifactPath, downloadedAt: Date.now() };
-      logger.info("using cached verified update", { version: update.version });
-      return status;
-    }
-    status = { kind: "available", update, checkedAt: Date.now() };
-    logger.info("update available", { currentVersion, version: update.version });
-    return status;
-  } catch (error) {
-    const message = humanizeUpdateError(error);
-    status = { kind: "error", message, checkedAt: Date.now() };
-    logger.warn("update check failed", { error: String(error) });
-    return status;
-  }
-}
-function updateCheckHeaders(endpoint) {
-  const headers = { accept: "application/json" };
-  try {
-    const auth = getRelayHTTPAuth();
-    if (new URL(auth.baseURL).origin === endpoint.origin) {
-      headers.authorization = `Bearer ${auth.accessToken}`;
-    }
-  } catch {
-  }
-  return headers;
-}
-async function downloadAvailableUpdate() {
-  const available = status.kind === "available" ? status.update : void 0;
-  if (!available) return status;
-  status = { kind: "downloading", update: available, downloadedBytes: 0 };
-  const updateDirectory = node_path.join(electron.app.getPath("userData"), "updates");
-  const artifactPath = updateArtifactPath(available);
-  const temporaryPath = `${artifactPath}.${node_crypto.randomUUID()}.download`;
-  try {
-    await promises.mkdir(updateDirectory, { recursive: true });
-    const response = await electron.net.fetch(available.releaseUrl, {
-      headers: { accept: "application/octet-stream, application/wasm, */*" },
-      signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS),
-      cache: "no-store",
-      redirect: "follow"
-    });
-    if (!response.ok) throw new Error(`下载更新失败（${response.status}）`);
-    if (!response.body) throw new Error("更新包为空，请稍后重试");
-    if (response.url && new URL(response.url).protocol !== "https:") {
-      throw new Error("更新下载地址必须使用 HTTPS");
-    }
-    const totalBytes = parseContentLength(response.headers.get("content-length"));
-    let downloadedBytes = 0;
-    status = { kind: "downloading", update: available, downloadedBytes, totalBytes };
-    const digest = await saveAndHash(response.body, temporaryPath, (chunkBytes) => {
-      downloadedBytes += chunkBytes;
-      status = { kind: "downloading", update: available, downloadedBytes, totalBytes };
-    });
-    if (digest !== available.sha256) throw new Error("更新包校验失败，文件未安装");
-    await promises.rm(artifactPath, { force: true });
-    await moveFile(temporaryPath, artifactPath);
-    status = { kind: "downloaded", update: available, artifactPath, downloadedAt: Date.now() };
-    logger.info("update downloaded and verified", { version: available.version });
-    return status;
-  } catch (error) {
-    await promises.rm(temporaryPath, { force: true }).catch(() => void 0);
-    const message = humanizeUpdateError(error);
-    status = { kind: "error", message, checkedAt: Date.now() };
-    logger.warn("update download failed", { error: String(error) });
-    return status;
-  }
-}
-async function installDownloadedUpdate() {
-  if (status.kind !== "downloaded") return void 0;
-  if (!supportsInAppInstall()) throw new Error("当前运行方式不支持应用内安装，请使用正式发布版");
-  if (process.platform !== "darwin" && process.platform !== "win32") {
-    throw new Error("当前平台暂不支持应用内安装，请下载对应安装包更新");
-  }
-  const downloaded = status;
-  const helperPath = await writeUpdateHelper();
-  const child = node_child_process.spawn(process.execPath, [
-    helperPath,
-    String(process.pid),
-    downloaded.artifactPath,
-    downloaded.update.sha256,
-    process.platform,
-    downloaded.update.version,
-    process.execPath,
-    JSON.stringify(restartArgumentsAfterUpdate())
-  ], {
-    detached: true,
-    stdio: "ignore",
-    env: { ...process.env, ELECTRON_RUN_AS_NODE: "1" }
-  });
-  child.unref();
-  status = { kind: "installing", update: downloaded.update };
-  logger.info("update installation requested", { version: downloaded.update.version });
-  electron.app.quit();
-  return downloaded.update;
-}
-function supportsInAppInstall() {
-  return electron.app.isPackaged || process.env.DESKTOP_PET_NPM_DISTRIBUTION === "1";
-}
-function restartArgumentsAfterUpdate() {
-  return !electron.app.isPackaged && process.argv[1] ? [process.argv[1]] : [];
-}
-function updateArtifactPath(update) {
-  return node_path.join(electron.app.getPath("userData"), "updates", `desktop-pet-${update.version}${installerExtension(update.releaseUrl)}`);
-}
-async function verifiedCachedArtifact(update) {
-  const artifactPath = updateArtifactPath(update);
-  try {
-    return await sha256File(artifactPath) === update.sha256 ? artifactPath : void 0;
-  } catch (error) {
-    if (error.code !== "ENOENT") {
-      logger.warn("could not verify cached update", { version: update.version, error: String(error) });
-    }
-    return void 0;
-  }
-}
-function sha256File(path2) {
-  return new Promise((resolve, reject) => {
-    const hash = node_crypto.createHash("sha256");
-    const input = node_fs.createReadStream(path2);
-    input.on("data", (chunk) => hash.update(chunk));
-    input.on("error", reject);
-    input.on("end", () => resolve(hash.digest("hex")));
-  });
-}
-async function saveAndHash(body, destination, onChunk) {
-  const hash = node_crypto.createHash("sha256");
-  const meter = new node_stream.Transform({
-    transform(chunk, _encoding, done) {
-      hash.update(chunk);
-      onChunk(chunk.length);
-      done(null, chunk);
-    }
-  });
-  await promises$1.pipeline(
-    node_stream.Readable.fromWeb(body),
-    meter,
-    node_fs.createWriteStream(destination, { flags: "wx" })
-  );
-  return hash.digest("hex");
-}
-function parseContentLength(value) {
-  if (!value) return void 0;
-  const bytes = Number(value);
-  return Number.isSafeInteger(bytes) && bytes > 0 ? bytes : void 0;
-}
-function downloadProgressText(progress) {
-  if (progress.totalBytes) {
-    const percent = Math.min(100, Math.floor(progress.downloadedBytes / progress.totalBytes * 100));
-    return `${percent}%`;
-  }
-  return formatBytes(progress.downloadedBytes);
-}
-function formatBytes(bytes) {
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-}
-async function moveFile(source, destination) {
-  const { rename } = await import("node:fs/promises");
-  await rename(source, destination);
-}
-async function writeUpdateHelper() {
-  const helperPath = node_path.join(electron.app.getPath("userData"), "updates", "install-downloaded-update.cjs");
-  await promises.writeFile(helperPath, UPDATE_HELPER_SOURCE, { mode: 448 });
-  return helperPath;
-}
-const UPDATE_HELPER_SOURCE = String.raw`const fs = require('node:fs/promises')
-const { createHash } = require('node:crypto')
-const { createReadStream } = require('node:fs')
-const { dirname, join } = require('node:path')
-const { execFile, spawn } = require('node:child_process')
-const { promisify } = require('node:util')
-
-const [, , parentPidText, sourcePath, expectedSHA256, platform, targetVersion, fallbackExecutable, fallbackArgsJSON] = process.argv
-const parentPid = Number(parentPidText)
-const fallbackArgs = JSON.parse(fallbackArgsJSON || '[]')
-const run = promisify(execFile)
-
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
-const parentIsRunning = () => {
-  try { process.kill(parentPid, 0); return true } catch { return false }
-}
-const sha256 = (path) => new Promise((resolve, reject) => {
-  const hash = createHash('sha256')
-  const input = createReadStream(path)
-  input.on('data', (chunk) => hash.update(chunk))
-  input.on('error', reject)
-  input.on('end', () => resolve(hash.digest('hex')))
-})
-const restartFallback = () => {
-  const env = { ...process.env }
-  delete env.ELECTRON_RUN_AS_NODE
-  const child = spawn(fallbackExecutable, fallbackArgs, { detached: true, stdio: 'ignore', env })
-  child.on('error', () => undefined)
-  child.unref()
-}
-const findInstalledMacApp = async () => {
-  const plist = join('${MAC_INSTALLED_APP}', 'Contents', 'Info.plist')
-  const bundle = await run('/usr/libexec/PlistBuddy', ['-c', 'Print :CFBundleIdentifier', plist])
-  const version = await run('/usr/libexec/PlistBuddy', ['-c', 'Print :CFBundleShortVersionString', plist])
-  if (bundle.stdout.trim() !== '${MAC_BUNDLE_ID}' || version.stdout.trim() !== targetVersion) {
-    throw new Error('installed app identity or version does not match the verified update')
-  }
-  return '${MAC_INSTALLED_APP}'
-}
-const restartInstalledApp = async () => {
-  if (platform === 'darwin') {
-    // PKG 禁止重定位；安装后再次核对固定路径的 bundle ID 与版本再启动。
-    const installedApp = await findInstalledMacApp()
-    await run('/usr/bin/open', ['-n', installedApp])
-    return
-  }
-  restartFallback()
-}
-const shellQuote = (value) => "'" + value.replace(/'/g, "'\\''") + "'"
-
-async function install() {
-  if (platform === 'darwin') {
-    const command = '/usr/sbin/installer -pkg ' + shellQuote(sourcePath) + ' -target /'
-    await run('/usr/bin/osascript', ['-e', 'do shell script ' + JSON.stringify(command) + ' with administrator privileges'])
-    return
-  }
-  if (platform === 'win32') {
-    // 发布端须提供支持 /S 静默安装的签名 NSIS 安装器。
-    await run(sourcePath, ['/S'])
-    return
-  }
-  throw new Error('unsupported platform')
-}
-
-async function main() {
-  while (parentIsRunning()) await sleep(200)
-
-  let installed = false
-  try {
-    if (await sha256(sourcePath) !== expectedSHA256) throw new Error('downloaded update hash changed')
-    await install()
-    installed = true
-  } catch (error) {
-    await fs.writeFile(join(dirname(sourcePath), 'last-install-error.log'), String(error)).catch(() => undefined)
-  } finally {
-    if (installed) {
-      try {
-        await restartInstalledApp()
-      } catch (error) {
-        await fs.writeFile(join(dirname(sourcePath), 'last-restart-error.log'), String(error)).catch(() => undefined)
-        restartFallback()
-      }
-    } else {
-      restartFallback()
-    }
-  }
-}
-
-main().catch(() => restartFallback())
-`;
-function installerExtension(releaseUrl) {
-  const pathname = new URL(releaseUrl).pathname.toLowerCase();
-  if (pathname.endsWith(".pkg")) return ".pkg";
-  if (pathname.endsWith(".exe")) return ".exe";
-  return ".installer";
-}
-function storedRelayURL() {
-  try {
-    return loadDeviceCredentials()?.serverUrl;
-  } catch (error) {
-    logger.warn("could not read stored server URL for update check", { error: String(error) });
-    return void 0;
-  }
-}
-function updateRelayURL() {
-  const stored = storedRelayURL();
-  if (stored && !isLegacyOfficialHTTPURL(stored)) return stored;
-  return configuredRelayURL();
-}
-function isLegacyOfficialHTTPURL(value) {
-  try {
-    const url = new URL(value);
-    return url.protocol === "http:" && url.hostname === LEGACY_OFFICIAL_HTTP_HOST;
-  } catch {
-    return false;
-  }
-}
-function validateUpdateAPIURL(value) {
-  const url = new URL(value);
-  const local = url.hostname === "127.0.0.1" || url.hostname === "localhost" || url.hostname === "::1";
-  if (url.protocol !== "https:" && !(url.protocol === "http:" && local && !electron.app.isPackaged)) {
-    throw new Error("更新服务器必须使用 HTTPS");
-  }
-  return url;
-}
-function parseUpdate(value) {
-  if (value === null || value === void 0) return void 0;
-  if (!isRecord(value)) throw new Error("更新服务器返回了无效的更新信息");
-  const version = asString(value.version);
-  const releaseUrl = asString(value.releaseUrl);
-  const sha256 = asString(value.sha256);
-  if (!isVersion(version) || !releaseUrl || !/^[a-f0-9]{64}$/i.test(sha256)) {
-    throw new Error("更新信息缺少版本、下载地址或校验值");
-  }
-  const url = new URL(releaseUrl);
-  if (url.protocol !== "https:") throw new Error("更新下载地址必须使用 HTTPS");
-  return {
-    version,
-    releaseUrl: url.toString(),
-    sha256: sha256.toLowerCase(),
-    notes: optionalString(value.notes),
-    publishedAt: optionalString(value.publishedAt),
-    mandatory: value.mandatory === true
-  };
-}
-function asString(value) {
-  return typeof value === "string" ? value.trim() : "";
-}
-function optionalString(value) {
-  const normalized = asString(value);
-  return normalized || void 0;
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-function isVersion(value) {
-  return /^v?\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(value);
-}
-function compareVersions(a, b) {
-  const parse = (value) => {
-    const [, major, minor, patch, prerelease] = value.match(/^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/) ?? [];
-    return { major: Number(major), minor: Number(minor), patch: Number(patch), prerelease };
-  };
-  const left = parse(a);
-  const right = parse(b);
-  for (const key of ["major", "minor", "patch"]) {
-    if (left[key] !== right[key]) return left[key] > right[key] ? 1 : -1;
-  }
-  if (!left.prerelease && right.prerelease) return 1;
-  if (left.prerelease && !right.prerelease) return -1;
-  if (!left.prerelease || !right.prerelease) return 0;
-  return left.prerelease.localeCompare(right.prerelease, void 0, { numeric: true });
-}
-function humanizeUpdateError(error) {
-  if (error instanceof DOMException && error.name === "TimeoutError") return "检查更新超时，请稍后重试";
-  if (error instanceof TypeError && error.message === "fetch failed") {
-    return "无法连接更新服务器，请检查网络或系统代理";
-  }
-  if (error instanceof Error) return error.message;
-  return "暂时无法检查更新";
-}
-const SKINS = SKIN_IDS.map((id) => ({ id, label: SKIN_LABELS[id] }));
-let nextId = 1;
-function createPetWindow(skin, options) {
-  if (petManager.count() >= MAX_PETS) {
-    logger.warn("pet limit reached", { max: MAX_PETS });
-    return null;
-  }
-  const id = `pet-${nextId++}`;
-  const identity = options.identity;
-  let currentSkin = skin;
-  const workArea = electron.screen.getPrimaryDisplay().workArea;
-  const initialSize = PET_WINDOW_BY_SKIN[skin] ?? PET_WINDOW;
-  let W = initialSize.width;
-  let H = initialSize.height;
-  const x = options.near?.x ?? workArea.x + workArea.width - W - 120;
-  const y = options.near?.y ?? workArea.y + workArea.height - H - 60;
-  const win = new electron.BrowserWindow({
-    show: petManager.arePetsVisible(),
-    width: W,
-    height: H,
-    x,
-    y,
-    transparent: true,
-    frame: false,
-    resizable: false,
-    alwaysOnTop: true,
-    skipTaskbar: true,
-    hasShadow: false,
-    backgroundColor: "#00000000",
-    webPreferences: {
-      preload: path.join(__dirname, "../preload/index.js"),
-      contextIsolation: true
-    }
-  });
-  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) {
-    win.loadURL(process.env.ELECTRON_RENDERER_URL);
-  } else {
-    win.loadFile(path.join(__dirname, "../renderer/index.html"));
-  }
-  win.webContents.on("did-finish-load", () => {
-    dispatch({ type: "skin", skin: currentSkin }, id);
-    const presentation = publishIdentity();
-    dispatch({ type: "bubble", text: presentation.greeting }, id);
-  });
-  const publishIdentity = () => {
-    const presentation = presentPetIdentity(identity, currentAccountUsername());
-    dispatch({ type: "identity", label: presentation.badge, kind: identity.kind }, id);
-    return presentation;
-  };
-  const onMove = (e, dx, dy) => {
-    if (isPetOnQuest(id)) return;
-    if (!win.isDestroyed() && e.sender === win.webContents) moveBy(win, dx, dy);
-  };
-  const onDrag = (e, phase, dx = 0, dy = 0) => {
-    if (isPetOnQuest(id)) return;
-    if (!win.isDestroyed() && e.sender === win.webContents && phase === "move") {
-      moveBy(win, dx, dy);
-    }
-  };
-  const onMenu = (e) => {
-    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();
-    const collaboration = accountUsername ? await loadCollaborationState() : void 0;
-    if (win.isDestroyed()) return;
-    const incoming = collaboration?.helpRequests.filter(
-      (request) => request.toUsername === accountUsername && request.status === "pending"
-    ) ?? [];
-    const friendItems = collaboration?.friends.map(
-      (friend) => friendMenuItem(friend, collaboration, accountUsername ?? "", id)
-    ) ?? [];
-    const menu = electron.Menu.buildFromTemplate([
-      {
-        label: identityPresentation.menuHeader,
-        enabled: false
-      },
-      { type: "separator" },
-      {
-        label: accountUsername ? `本机账号 @${accountUsername}（点击切换）` : "登录本机账号",
-        click: () => openAccountWindow("login")
-      },
-      {
-        label: "注册账号",
-        click: () => openAccountWindow("register")
-      },
-      ...accountUsername ? [
-        {
-          label: "退出当前账号",
-          click: () => logoutDesktopPet()
-        }
-      ] : [],
-      { type: "separator" },
-      {
-        label: "切换形象",
-        submenu: SKINS.map((s) => ({
-          label: s.label,
-          type: "radio",
-          checked: s.id === currentSkin,
-          click: () => {
-            currentSkin = s.id;
-            const nextSize = PET_WINDOW_BY_SKIN[s.id] ?? PET_WINDOW;
-            W = nextSize.width;
-            H = nextSize.height;
-            win.setSize(W, H, true);
-            dispatch({ type: "skin", skin: s.id }, id);
-          }
-        }))
-      },
-      { type: "separator" },
-      {
-        label: `好友状态${collaboration ? `（${collaboration.friends.length}）` : ""}`,
-        enabled: Boolean(accountUsername),
-        submenu: collaboration ? friendItems.length > 0 ? friendItems : [{ label: "还没有好友，请先到个人后台添加", enabled: false }] : [{ label: accountUsername ? "暂时无法连接服务器" : "请先登录账号", enabled: false }]
-      },
-      {
-        label: `要我帮忙${incoming.length ? `（${incoming.length}）` : ""}`,
-        enabled: Boolean(accountUsername),
-        submenu: incoming.length ? incoming.map((request) => ({
-          label: `@${request.fromUsername} 想请你帮忙`,
-          submenu: [
-            {
-              label: "同意帮 TA",
-              click: () => runMenuAction(respondFriendHelp(request.id, true), `已同意帮 @${request.fromUsername}，TA 的 Agent 可以向你派任务了`, id)
-            },
-            {
-              label: "婉拒",
-              click: () => runMenuAction(respondFriendHelp(request.id, false), `已婉拒 @${request.fromUsername} 的求助`, id)
-            }
-          ]
-        })) : [{ label: "暂无待处理的求助", enabled: false }]
-      },
-      { type: "separator" },
-      {
-        label: "复制 MCP 配置",
-        click: () => {
-          const result = copyMcpConfig();
-          dispatch({ type: "bubble", text: result.message, ttl: 6e3 }, id);
-        }
-      },
-      {
-        label: "打开日志文件夹",
-        click: () => {
-          void electron.shell.openPath(mainLogDirectory()).then((error) => {
-            if (error) dispatch({ type: "bubble", text: "无法打开日志文件夹", ttl: 6e3 }, id);
-          });
-        }
-      },
-      {
-        label: updateMenuLabel(),
-        submenu: updateMenuItems(id)
-      },
-      { type: "separator" },
-      { label: "隐藏所有桌面宠物", click: () => petManager.setPetsVisible(false) },
-      ...canSendAwayPet(identity) ? [{ label: "送走这只宠物", click: () => win.close() }] : [],
-      { label: "退出", click: () => electron.app.quit() }
-    ]);
-    menu.popup({ window: win });
-  };
-  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;
-}
-function updateMenuLabel() {
-  const status2 = getUpdateStatus();
-  if (status2.kind === "available") return `软件更新（v${status2.update.version} 可下载）`;
-  if (status2.kind === "downloading") {
-    return `软件更新（v${status2.update.version} 下载 ${downloadProgressText(status2)}）`;
-  }
-  if (status2.kind === "downloaded") return `软件更新（v${status2.update.version} 已下载）`;
-  return "软件更新";
-}
-function updateMenuItems(petId) {
-  const status2 = getUpdateStatus();
-  const items = [
-    { label: `当前版本 v${electron.app.getVersion()}`, enabled: false },
-    {
-      label: "检查更新",
-      click: () => {
-        void checkForUpdates().then((result) => {
-          if (result.kind === "available") {
-            dispatch({ type: "bubble", text: `发现 v${result.update.version}，可从“软件更新”安装`, ttl: 6e3 }, petId);
-          } else if (result.kind === "up-to-date") {
-            dispatch({ type: "bubble", text: "已经是最新版本啦", ttl: 4500 }, petId);
-          } else if (result.kind === "downloading") {
-            dispatch({
-              type: "bubble",
-              text: `v${result.update.version} 正在下载：${downloadProgressText(result)}`,
-              ttl: 4500
-            }, petId);
-          } else if (result.kind === "error") {
-            dispatch({ type: "bubble", text: result.message, ttl: 7e3 }, petId);
-          }
-        });
-      }
-    }
-  ];
-  if (status2.kind === "available") {
-    items.splice(1, 0, {
-      label: `请求下载 v${status2.update.version}`,
-      click: () => {
-        dispatch({ type: "bubble", text: `正在下载 v${status2.update.version}，完成后会提示你安装`, ttl: 5e3 }, petId);
-        void downloadAvailableUpdate().then((result) => {
-          if (result.kind === "downloaded") {
-            dispatch({ type: "bubble", text: `v${result.update.version} 已下载，右键选择“安装并重启”`, ttl: 7e3 }, petId);
-          } else if (result.kind === "error") {
-            dispatch({ type: "bubble", text: result.message, ttl: 7e3 }, petId);
-          }
-        });
-      }
-    });
-  }
-  if (status2.kind === "downloading") {
-    items.splice(1, 0, {
-      label: `正在下载 v${status2.update.version} · ${downloadProgressText(status2)}`,
-      enabled: false
-    });
-  }
-  if (status2.kind === "downloaded") {
-    items.splice(1, 0, {
-      label: `安装 v${status2.update.version} 并重启`,
-      click: () => {
-        void installDownloadedUpdate().catch((error) => {
-          const message = error instanceof Error ? error.message : "无法安装更新，请稍后重试";
-          dispatch({ type: "bubble", text: message, ttl: 7e3 }, petId);
-        });
-      }
-    });
-  }
-  return items;
-}
-async function loadCollaborationState() {
-  try {
-    return await Promise.race([
-      getCollaborationState(),
-      new Promise((resolve) => setTimeout(() => resolve(void 0), 1800))
-    ]);
-  } catch {
-    return void 0;
-  }
-}
-function friendMenuItem(friend, state, currentUsername, petId) {
-  const outboundHelp = state.helpRequests.find(
-    (request) => request.fromUsername === currentUsername && request.toUsername === friend.username
-  );
-  const activeHelp = state.helpRequests.find(
-    (request) => request.status === "accepted" && (request.fromUsername === currentUsername && request.toUsername === friend.username || request.fromUsername === friend.username && request.toUsername === currentUsername)
-  );
-  const helpLabel = outboundHelp?.status === "accepted" ? " · TA 已同意帮我" : outboundHelp?.status === "pending" ? " · 求助待 TA 接受" : activeHelp ? " · 我正在帮 TA" : "";
-  const chatMessages = ["你好呀！", "现在方便聊聊吗？", "谢谢你的帮助！"];
-  return {
-    label: `${friend.online ? "●" : "○"} ${friend.displayName} (@${friend.username})${helpLabel}`,
-    submenu: [
-      {
-        label: outboundHelp?.status === "accepted" ? "TA 已同意帮我（可让 Agent 派任务）" : outboundHelp?.status === "pending" ? "求助已发出，等 TA 接受" : "请 TA 帮我",
-        enabled: outboundHelp?.status !== "accepted" && outboundHelp?.status !== "pending",
-        click: () => runMenuAction(requestFriendHelp(friend.username), `已向 @${friend.username} 发出求助，等待对方接受`, petId)
-      },
-      {
-        label: "发送消息",
-        enabled: friend.online,
-        submenu: [
-          {
-            label: "发送剪贴板文字",
-            click: () => {
-              const text = electron.clipboard.readText().trim();
-              const action = text ? sendFriendChatPreferred({
-                to: friend.username,
-                toDeviceId: friend.deviceId,
-                text: text.slice(0, 500)
-              }) : Promise.reject(new Error("剪贴板里没有文字"));
-              runMenuAction(action, `消息已发送给 ${friend.username}`, petId);
-            }
-          },
-          { type: "separator" },
-          ...chatMessages.map((text) => ({
-            label: text,
-            click: () => runMenuAction(
-              sendFriendChatPreferred({
-                to: friend.username,
-                toDeviceId: friend.deviceId,
-                text
-              }),
-              `消息已发送给 ${friend.username}`,
-              petId
-            )
-          }))
-        ]
-      }
-    ]
-  };
-}
-function runMenuAction(action, successText, petId) {
-  void action.then(() => {
-    dispatch({ type: "state", state: "excited", ttl: 6 }, petId);
-    dispatch({ type: "bubble", text: successText, ttl: 6e3 }, petId);
-  }).catch((error) => {
-    const message = error instanceof Error ? error.message : "操作失败";
-    dispatch({ type: "state", state: "failed", ttl: 8 }, petId);
-    dispatch({ type: "bubble", text: message, ttl: 9e3 }, petId);
-  });
-}
-function moveBy(win, dx, dy) {
-  if (win.isDestroyed()) return;
-  const [x, y] = win.getPosition();
-  const [w, h] = win.getSize();
-  const area = electron.screen.getDisplayNearestPoint({ x, y }).workArea;
-  const nx = Math.min(Math.max(x + dx, area.x), area.x + area.width - w);
-  const ny = Math.min(Math.max(y + dy, area.y), area.y + area.height - h);
-  win.setPosition(nx, ny);
-}
-const petWindow = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  createPetWindow
-}, Symbol.toStringTag, { value: "Module" }));
-const ErrorCodes = {
-  BAD_EVENT: "BAD_EVENT",
-  TOO_MANY_PETS: "TOO_MANY_PETS",
-  PET_NOT_RUNNING: "PET_NOT_RUNNING",
-  PET_REJECTED: "PET_REJECTED",
-  RELAY_UNREACHABLE: "RELAY_UNREACHABLE",
-  UNKNOWN_QUESTION: "UNKNOWN_QUESTION",
-  QUESTION_NOT_ASSIGNED: "QUESTION_NOT_ASSIGNED",
-  HELP_NOT_ACCEPTED: "HELP_NOT_ACCEPTED",
-  NOT_FRIENDS: "NOT_FRIENDS",
-  USER_NOT_ONLINE: "USER_NOT_ONLINE",
-  BAD_MESSAGE: "BAD_MESSAGE",
-  MUST_REGISTER: "MUST_REGISTER",
-  UNKNOWN_TYPE: "UNKNOWN_TYPE",
-  INTERNAL: "INTERNAL",
-  UNSUPPORTED_PROTOCOL: "UNSUPPORTED_PROTOCOL",
-  TASK_NOT_FOUND: "TASK_NOT_FOUND"
-};
-const ERROR_CODE_VALUES = new Set(Object.values(ErrorCodes));
-function isErrorCode(value) {
-  return typeof value === "string" && ERROR_CODE_VALUES.has(value);
-}
-class AppError extends Error {
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-    this.name = "AppError";
-  }
-  static badEvent(detail) {
-    return new AppError(ErrorCodes.BAD_EVENT, detail);
-  }
-}
-const PET_STATES = [
-  "idle",
-  "walk",
-  "sleep",
-  "excited",
-  "drag",
-  "working",
-  "success",
-  "failed"
-];
-function parseIncomingEvent(raw) {
-  if (!raw || typeof raw !== "object") throw AppError.badEvent("event must be an object");
-  const ev = raw;
-  switch (ev.type) {
-    case "state":
-      if (!PET_STATES.includes(ev.state)) {
-        throw AppError.badEvent(`invalid state: ${String(ev.state)}`);
-      }
-      return { type: "state", state: ev.state, ttl: optNumber(ev.ttl) };
-    case "bubble":
-      if (typeof ev.text !== "string" || ev.text.length === 0 || ev.text.length > 500) {
-        throw AppError.badEvent("bubble text must be a string of 1..500 chars");
-      }
-      return { type: "bubble", text: ev.text, ttl: optNumber(ev.ttl) };
-    case "skin":
-      if (typeof ev.skin !== "string" || ev.skin.length === 0 || ev.skin.length > 64) {
-        throw AppError.badEvent("skin must be a string of 1..64 chars");
-      }
-      return { type: "skin", skin: ev.skin };
-    case "reward": {
-      const amount = ev.amount;
-      if (typeof amount !== "number" || !Number.isFinite(amount) || amount <= 0 || amount > 9999) {
-        throw AppError.badEvent("reward amount must be a number in 1..9999");
-      }
-      const label = typeof ev.label === "string" && ev.label.length > 0 && ev.label.length <= 16 ? ev.label : void 0;
-      return { type: "reward", amount, label };
-    }
-    case "quest":
-      return parseQuest(ev);
-    default:
-      throw AppError.badEvent(`unknown event type: ${String(ev.type)}`);
-  }
-}
-function parseQuest(ev) {
-  const phase = ev.phase;
-  const friendName = optString(ev.friendName, 32);
-  const leaveText = optString(ev.leaveText, 120);
-  const returnText = optString(ev.returnText, 200);
-  const fish = optNumber(ev.fish);
-  if (phase === "leave") {
-    return { type: "quest", phase: "leave", friendName, leaveText };
-  }
-  if (phase === "return") {
-    return { type: "quest", phase: "return", returnText, fish };
-  }
-  throw AppError.badEvent("quest phase must be leave | return");
-}
-function optNumber(v) {
-  return typeof v === "number" && Number.isFinite(v) ? v : void 0;
-}
-function optString(v, max) {
-  return typeof v === "string" && v.length > 0 && v.length <= max ? v : void 0;
-}
-function isRelayCommand(raw) {
-  if (!raw || typeof raw !== "object") return false;
-  const t = raw.type;
-  return t === "ask" || t === "list_tasks" || t === "wait_task" || t === "answer" || t === "delegate_task" || t === "get_task" || t === "wait_task_result" || t === "claim_task" || t === "submit_task_result" || t === "cancel_task" || t === "list_remote_tasks" || t === "request_task_context" || t === "supply_task_context" || t === "configure_device" || t === "register_mcp_client" || t === "upload_relay_artifact" || t === "download_relay_artifact";
-}
-async function uploadRelayBlob(input) {
-  if (input.kind === "patch" && !input.baseCommit) throw new Error("patch artifact requires baseCommit");
-  const auth = getRelayHTTPAuth();
-  const peersResponse = await fetch(`${auth.baseURL}/api/tasks/${encodeURIComponent(input.taskId)}/peer-keys`, {
-    headers: { Authorization: `Bearer ${auth.accessToken}` }
-  });
-  const peersBody = await peersResponse.json();
-  if (!peersResponse.ok) throw new Error(peersBody.message || "unable to load peer encryption keys");
-  const peers = peersBody.data?.devices ?? [];
-  if (!peers.length) throw new Error("no active peer device has an encryption key");
-  const encrypted = encryptForRecipients(input.bytes, peers);
-  const artifactId = input.artifactId ?? node_crypto.randomUUID();
-  const sha256 = node_crypto.createHash("sha256").update(input.bytes).digest("hex");
-  const response = await fetch(
-    `${auth.baseURL}/api/tasks/${encodeURIComponent(input.taskId)}/artifacts/${encodeURIComponent(artifactId)}`,
-    {
-      method: "PUT",
-      headers: {
-        Authorization: `Bearer ${auth.accessToken}`,
-        "Content-Type": "application/octet-stream",
-        "X-Artifact-Size": String(input.bytes.byteLength),
-        "X-Artifact-SHA256": sha256,
-        "X-Artifact-Direction": input.direction,
-        "X-Artifact-Kind": input.kind,
-        "X-Artifact-Mime": input.mimeType,
-        "X-Artifact-Key-Wraps": Buffer.from(JSON.stringify(encrypted.keyWraps)).toString("base64url")
-      },
-      body: Buffer.from(encrypted.ciphertext)
-    }
-  );
-  if (!response.ok) throw new Error(`relay blob upload failed (${response.status})`);
-  return {
-    id: artifactId,
-    kind: normalizeResultKind(input.kind),
-    path: input.path,
-    mimeType: input.mimeType,
-    size: input.bytes.byteLength,
-    sha256,
-    baseCommit: input.baseCommit,
-    transport: "relay-blob",
-    artifactRef: `relay:${artifactId}`
-  };
-}
-async function downloadRelayBlob(taskId, artifact) {
-  if (artifact.transport !== "relay-blob") throw new Error("artifact is not a relay blob");
-  const credentials = loadDeviceCredentials();
-  if (!credentials?.encryptionPrivateKey) throw new Error("device decryption key is unavailable");
-  const auth = getRelayHTTPAuth();
-  const response = await fetch(
-    `${auth.baseURL}/api/tasks/${encodeURIComponent(taskId)}/artifacts/${encodeURIComponent(artifact.id)}`,
-    { headers: { Authorization: `Bearer ${auth.accessToken}` } }
-  );
-  if (!response.ok) throw new Error(`relay blob download failed (${response.status})`);
-  const metadataEncoded = response.headers.get("x-artifact-metadata") ?? "";
-  const metadata = JSON.parse(Buffer.from(metadataEncoded, "base64url").toString("utf8"));
-  const bytes = decryptForDevice(new Uint8Array(await response.arrayBuffer()), metadata.keyWraps, auth.deviceId, credentials.encryptionPrivateKey);
-  const digest = node_crypto.createHash("sha256").update(bytes).digest("hex");
-  if (bytes.byteLength !== artifact.size || digest !== artifact.sha256) throw new Error("relay artifact hash mismatch");
-  return bytes;
-}
-function encryptForRecipients(bytes, peers) {
-  const key = node_crypto.randomBytes(32);
-  const iv = node_crypto.randomBytes(12);
-  const cipher = node_crypto.createCipheriv("aes-256-gcm", key, iv);
-  const encrypted = Buffer.concat([cipher.update(bytes), cipher.final()]);
-  const ciphertext = Buffer.concat([Buffer.from([1]), iv, cipher.getAuthTag(), encrypted]);
-  const keyWraps = peers.map((peer) => ({
-    deviceId: peer.id,
-    wrappedKey: node_crypto.publicEncrypt(
-      { key: peer.encryptionPublicKey, padding: node_crypto.constants.RSA_PKCS1_OAEP_PADDING, oaepHash: "sha256" },
-      key
-    ).toString("base64")
-  }));
-  return { ciphertext, keyWraps };
-}
-function decryptForDevice(ciphertext, wraps, deviceId, privateKey) {
-  if (ciphertext.byteLength < 30 || ciphertext[0] !== 1) throw new Error("invalid relay ciphertext");
-  const wrap = wraps.find((candidate) => candidate.deviceId === deviceId);
-  if (!wrap) throw new Error("artifact key is not wrapped for this device");
-  const key = node_crypto.privateDecrypt(
-    { key: privateKey, padding: node_crypto.constants.RSA_PKCS1_OAEP_PADDING, oaepHash: "sha256" },
-    Buffer.from(wrap.wrappedKey, "base64")
-  );
-  const iv = ciphertext.slice(1, 13);
-  const tag = ciphertext.slice(13, 29);
-  const decipher = node_crypto.createDecipheriv("aes-256-gcm", key, iv);
-  decipher.setAuthTag(tag);
-  return Buffer.concat([decipher.update(ciphertext.slice(29)), decipher.final()]);
-}
-function normalizeResultKind(kind) {
-  return kind === "text" || kind === "markdown" || kind === "patch" ? kind : "file";
-}
-function writeJSON(res, status2, body) {
-  res.writeHead(status2, { "content-type": "application/json" });
-  res.end(JSON.stringify(body));
-}
-function ok(res, data) {
-  writeJSON(res, 200, { code: 0, message: "ok", ...data !== void 0 ? { data } : {} });
-}
-function fail(res, status2, message, errorCode) {
-  writeJSON(res, status2, {
-    code: status2,
-    message,
-    ...errorCode ? { errorCode } : {}
-  });
-}
-class BodyTooLargeError extends Error {
-}
-function hasJSONContentType(req) {
-  const value = req.headers["content-type"];
-  return typeof value === "string" && value.toLowerCase().startsWith("application/json");
-}
-function hasValidSessionToken(req, sessionToken) {
-  const authorization = req.headers.authorization;
-  if (!authorization?.startsWith("Bearer ")) return false;
-  const supplied = authorization.slice("Bearer ".length);
-  const expected = Buffer.from(sessionToken);
-  const actual = Buffer.from(supplied);
-  return actual.length === expected.length && crypto.timingSafeEqual(actual, expected);
-}
-async function readBody(req, maxBytes) {
-  return new Promise((resolve2, reject) => {
-    const declaredSize = Number(req.headers["content-length"]);
-    if (Number.isFinite(declaredSize) && declaredSize > maxBytes) {
-      req.resume();
-      reject(new BodyTooLargeError());
-      return;
-    }
-    const chunks = [];
-    let size = 0;
-    let rejected = false;
-    req.on("data", (chunk) => {
-      if (rejected) return;
-      size += chunk.length;
-      if (size > maxBytes) {
-        rejected = true;
-        req.resume();
-        reject(new BodyTooLargeError());
-        return;
-      }
-      chunks.push(chunk);
-    });
-    req.on("end", () => {
-      if (!rejected) resolve2(Buffer.concat(chunks).toString("utf8"));
-    });
-    req.on("error", reject);
-  });
-}
-let eventServer;
-function startEventServer(appVersion = "0.0.0") {
-  if (eventServer) return;
-  const sessionToken = crypto.randomBytes(32).toString("base64url");
-  const server = http.createServer((req, res) => {
-    void (async () => {
-      if (req.method !== "POST") {
-        fail(res, 404, "not found");
-        return;
-      }
-      if (!hasJSONContentType(req)) {
-        fail(res, 415, "content-type must be application/json");
-        return;
-      }
-      if (!hasValidSessionToken(req, sessionToken)) {
-        fail(res, 401, "invalid local pet session");
-        return;
-      }
-      try {
-        const raw = JSON.parse(await readBody(req, LOCAL_PET_MAX_BODY_BYTES));
-        if (isRelayCommand(raw)) {
-          await handleRelay(raw, res);
-          return;
-        }
-        const event = parseIncomingEvent(raw);
-        if (event.type === "quest") {
-          handleQuest(event);
-          logger.info("quest started", { phase: event.phase });
-        } else {
-          dispatch(event);
-          logger.debug("event dispatched", { type: event.type });
-        }
-        ok(res);
-      } catch (err) {
-        if (err instanceof AppError) {
-          fail(res, 400, err.message, err.code);
-        } else if (err instanceof BodyTooLargeError) {
-          fail(res, 413, `request body exceeds ${LOCAL_PET_MAX_BODY_BYTES} bytes`);
-        } else if (err instanceof SyntaxError) {
-          fail(res, 400, "bad json");
-        } else {
-          const relayCode = err.code;
-          if (isErrorCode(relayCode) && relayCode !== ErrorCodes.INTERNAL) {
-            fail(res, relayErrorHTTPStatus(relayCode), err instanceof Error ? err.message : relayCode, relayCode);
-          } else {
-            logger.error("event server error", { error: String(err) });
-            fail(res, 500, "internal error");
-          }
-        }
-      }
-    })();
-  });
-  eventServer = server;
-  server.listen(0, "127.0.0.1", () => {
-    const addr = server.address();
-    if (addr && typeof addr === "object") {
-      const endpoint = {
-        protocolVersion: LOCAL_PET_PROTOCOL_VERSION,
-        appVersion,
-        port: addr.port,
-        pid: process.pid,
-        sessionToken,
-        createdAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      fs.writeFileSync(PORT_FILE, JSON.stringify(endpoint), { mode: 384 });
-      fs.chmodSync(PORT_FILE, 384);
-      logger.info("event server listening", { port: addr.port });
-    }
-  });
-}
-function relayErrorHTTPStatus(code) {
-  if (code === ErrorCodes.TASK_NOT_FOUND || code === ErrorCodes.UNKNOWN_QUESTION) return 404;
-  if (code === ErrorCodes.HELP_NOT_ACCEPTED || code === ErrorCodes.NOT_FRIENDS || code === ErrorCodes.USER_NOT_ONLINE || code === ErrorCodes.QUESTION_NOT_ASSIGNED) {
-    return 409;
-  }
-  return 400;
-}
-async function handleRelay(cmd, res) {
-  switch (cmd.type) {
-    case "ask": {
-      if (!cmd.to?.trim() || !cmd.text?.trim()) {
-        fail(res, 400, "ask requires to and text", ErrorCodes.BAD_EVENT);
-        return;
-      }
-      if (isProtocolV1Available()) {
-        const now = /* @__PURE__ */ new Date();
-        const envelope = {
-          protocolVersion: TASK_PROTOCOL_VERSION,
-          taskId: crypto.randomUUID(),
-          idempotencyKey: crypto.randomUUID(),
-          from: { userId: "authenticated-local-user", deviceId: "" },
-          to: { userId: cmd.to.trim() },
-          createdAt: now.toISOString(),
-          deadlineAt: new Date(now.getTime() + (cmd.timeoutMs ?? 3e5)).toISOString(),
-          objective: cmd.text.trim(),
-          title: cmd.title,
-          constraints: [],
-          acceptanceCriteria: [],
-          context: {
-            summary: cmd.context ?? "",
-            items: cmd.context ? [inlineContextItem({ kind: "text", text: cmd.context })] : [],
-            redactions: []
-          },
-          executionPolicy: {
-            capabilities: ["filesystem.read"],
-            writableScopes: [],
-            networkPolicy: "ask",
-            approvalMode: "manual",
-            maxRuntimeMs: cmd.timeoutMs ?? 3e5
-          },
-          outputContract: {
-            acceptedKinds: ["text", "markdown", "patch", "files"],
-            maxTotalBytes: 10 * 1024 * 1024,
-            requireTests: false,
-            includeReasoning: false
-          }
-        };
-        const created = await delegateTask(envelope);
-        const completed = await waitRemoteTaskResult(created.task.taskId, Math.min(cmd.timeoutMs ?? 55e3, 55e3));
-        const firstText = completed.result?.artifacts.find((artifact) => artifact.inlineText)?.inlineText;
-        const fallback = completed.result ? `任务状态：${completed.status}` : `任务状态：${completed.status}${created.warning ? `（${created.warning}）` : ""}`;
-        ok(res, {
-          questionId: completed.taskId,
-          from: completed.envelope.to.userId,
-          text: firstText ?? completed.result?.summary ?? fallback,
-          resultKind: completed.result?.artifacts[0]?.kind ?? "text",
-          timedOut: !completed.result
-        });
-        return;
-      }
-      const result = await askFriend({
-        to: cmd.to.trim(),
-        title: cmd.title,
-        text: cmd.text,
-        context: cmd.context,
-        tools: cmd.tools,
-        timeoutMs: cmd.timeoutMs
-      });
-      ok(res, result);
-      return;
-    }
-    case "list_tasks": {
-      if (isProtocolV1Available()) {
-        const taskV1 = await claimRemoteTask(1e3);
-        ok(res, { taskV1, tasks: [] });
-        return;
-      }
-      ok(res, { tasks: listPendingTasks() });
-      return;
-    }
-    case "wait_task": {
-      if (isProtocolV1Available()) {
-        const taskV1 = await claimRemoteTask(cmd.timeoutMs);
-        ok(res, { taskV1 });
-        return;
-      }
-      const task = await waitForPendingTask(cmd.timeoutMs);
-      ok(res, { task });
-      return;
-    }
-    case "answer": {
-      if (!cmd.questionId?.trim() || !cmd.text?.trim()) {
-        fail(res, 400, "answer requires questionId and text", ErrorCodes.BAD_EVENT);
-        return;
-      }
-      try {
-        if (isProtocolV1Available()) {
-          const task = await getRemoteTask(cmd.questionId);
-          const artifact = inlineResultArtifact({
-            kind: cmd.resultKind === "patch" ? "patch" : cmd.resultKind === "markdown" ? "markdown" : "text",
-            text: cmd.text,
-            baseCommit: cmd.resultKind === "patch" ? task.envelope.workspace?.baseCommit : void 0
-          });
-          const result = {
-            protocolVersion: TASK_PROTOCOL_VERSION,
-            taskId: cmd.questionId,
-            status: "completed",
-            summary: cmd.text.slice(0, 1e3),
-            artifacts: [artifact],
-            diagnostics: [],
-            tests: [],
-            completedAt: (/* @__PURE__ */ new Date()).toISOString()
-          };
-          await submitRemoteTaskResult(result);
-          ok(res, { status: "ok" });
-          return;
-        }
-        await answerFriend(cmd.questionId, cmd.text, normalizeKind(cmd.resultKind));
-        ok(res, { status: "ok" });
-      } catch (err) {
-        const code = err.code;
-        if (code === "UNKNOWN_QUESTION") {
-          fail(res, 404, "问题不存在或已被回答", ErrorCodes.UNKNOWN_QUESTION);
-          return;
-        }
-        throw err;
-      }
-      return;
-    }
-    case "delegate_task": {
-      const { task, warning } = await delegateTask(cmd.envelope);
-      ok(res, { task, warning });
-      return;
-    }
-    case "register_mcp_client": {
-      const agentHost = cmd.agentHost.trim();
-      if (!agentHost || agentHost.length > 200) {
-        fail(res, 400, "register_mcp_client requires agentHost", ErrorCodes.BAD_EVENT);
-        return;
-      }
-      await registerMcpClient(agentHost, cmd.mcpCapabilities ?? {});
-      ok(res);
-      return;
-    }
-    case "get_task": {
-      const task = await getRemoteTask(cmd.taskId);
-      ok(res, { task });
-      return;
-    }
-    case "wait_task_result": {
-      const task = await waitRemoteTaskResult(cmd.taskId, cmd.timeoutMs);
-      ok(res, { task });
-      return;
-    }
-    case "claim_task": {
-      const task = await claimRemoteTask(cmd.timeoutMs);
-      ok(res, { task });
-      return;
-    }
-    case "submit_task_result": {
-      await submitRemoteTaskResult(cmd.result);
-      ok(res, { status: "ok" });
-      return;
-    }
-    case "cancel_task": {
-      const task = await cancelRemoteTask(cmd.taskId);
-      ok(res, { task });
-      return;
-    }
-    case "list_remote_tasks": {
-      const tasks = await listRemoteTasks({
-        direction: cmd.direction,
-        status: cmd.status,
-        limit: cmd.limit
-      });
-      ok(res, { tasks });
-      return;
-    }
-    case "request_task_context": {
-      const task = await requestRemoteTaskContext(cmd.taskId, {
-        paths: cmd.paths,
-        questions: cmd.questions
-      });
-      ok(res, { task });
-      return;
-    }
-    case "supply_task_context": {
-      const task = await supplyRemoteTaskContext(cmd.taskId, cmd.items);
-      ok(res, { task });
-      return;
-    }
-    case "configure_device": {
-      const { configureAndActivateDevice: configureAndActivateDevice2 } = await Promise.resolve().then(() => deviceAuth);
-      await configureAndActivateDevice2({
-        serverUrl: cmd.serverUrl,
-        userId: cmd.userId,
-        deviceId: cmd.deviceId,
-        refreshToken: cmd.refreshToken
-      });
-      ok(res, { status: "configured" });
-      return;
-    }
-    case "upload_relay_artifact": {
-      const source = resolveWorkspaceFile(cmd.workspaceRoot, cmd.path, true);
-      const bytes = fs.readFileSync(source);
-      const artifact = await uploadRelayBlob({
-        taskId: cmd.taskId,
-        bytes,
-        direction: cmd.direction,
-        kind: cmd.kind,
-        mimeType: cmd.mimeType,
-        path: cmd.path,
-        baseCommit: cmd.baseCommit
-      });
-      ok(res, { artifact });
-      return;
-    }
-    case "download_relay_artifact": {
-      const destination = resolveWorkspaceFile(cmd.workspaceRoot, cmd.destinationPath, false);
-      if (fs.existsSync(destination)) throw new Error("目标文件已存在；relay artifact 不会覆盖现有文件");
-      const bytes = await downloadRelayBlob(cmd.taskId, cmd.artifact);
-      fs.writeFileSync(destination, bytes, { flag: "wx", mode: 384 });
-      ok(res, { path: destination, size: bytes.byteLength });
-      return;
-    }
-  }
-}
-function resolveWorkspaceFile(workspaceRoot, relativePath, mustExist) {
-  if (!workspaceRoot || !relativePath || relativePath.includes("\0")) throw new Error("无效工作区路径");
-  const root = fs.realpathSync(workspaceRoot);
-  const candidate = node_path.resolve(root, relativePath);
-  if (candidate !== root && !candidate.startsWith(root + node_path.sep)) throw new Error("路径越出工作区");
-  if (mustExist) {
-    const actual = fs.realpathSync(candidate);
-    if (actual !== root && !actual.startsWith(root + node_path.sep)) throw new Error("符号链接越出工作区");
-    if (!fs.statSync(actual).isFile()) throw new Error("artifact 来源必须是普通文件");
-    return actual;
-  }
-  const parent = fs.realpathSync(node_path.dirname(candidate));
-  if (parent !== root && !parent.startsWith(root + node_path.sep)) throw new Error("目标目录越出工作区");
-  return candidate;
-}
-function normalizeKind(v) {
-  if (v === "code" || v === "patch" || v === "markdown" || v === "files" || v === "text") return v;
-  return "text";
-}
-async function stopEventServer() {
-  fs.rmSync(PORT_FILE, { force: true });
-  const server = eventServer;
-  eventServer = void 0;
-  if (!server) return;
-  await new Promise((resolve2, reject) => {
-    server.close((err) => err ? reject(err) : resolve2());
-  });
-}
-function mapProviderEvent(event) {
-  if (!event || typeof event !== "object") return null;
-  const value = event;
-  if ("reasoning" in value || "tool_input" in value || "tool_output" in value || "environment" in value) {
-    return null;
-  }
-  if (value.type === "final" && typeof value.text === "string") {
-    return { type: "final", text: sanitize(value.text) };
-  }
-  if (value.type === "progress" && typeof value.message === "string") {
-    return { type: "progress", message: sanitize(value.message).slice(0, 500) };
-  }
-  if (value.type === "error" && typeof value.message === "string") {
-    return { type: "error", message: sanitize(value.message).slice(0, 1e3) };
-  }
-  if (value.type === "artifact" && typeof value.path === "string" && typeof value.mimeType === "string") {
-    return { type: "artifact", path: value.path, mimeType: value.mimeType };
-  }
-  return null;
-}
-function sanitize(text) {
-  return text.replace(/\b(?:sk|pk|api)[-_][A-Za-z0-9_-]{16,}\b/g, "[REDACTED_TOKEN]").replace(/(authorization|api[_-]?key)\s*[:=]\s*\S+/gi, "$1=[REDACTED]");
-}
-class CodexCLIAdapter {
-  constructor(workspaceRoot) {
-    this.workspaceRoot = workspaceRoot;
-  }
-  id = "codex-cli";
-  runs = /* @__PURE__ */ new Map();
-  async detect() {
-    return new Promise((resolve) => {
-      const child = node_child_process.spawn("codex", ["--version"], { stdio: "ignore" });
-      child.once("error", () => resolve(false));
-      child.once("exit", (code) => resolve(code === 0));
-    });
-  }
-  async startTask(input) {
-    if (process.env.DESKTOP_PET_RUNNER_ADAPTERS !== "1") {
-      throw new Error("runner adapters are disabled");
-    }
-    const runId = node_crypto.randomUUID();
-    const prompt = publicTaskPrompt(input);
-    const child = node_child_process.spawn("codex", ["exec", "--json", "--sandbox", "workspace-write", prompt], {
-      cwd: this.workspaceRoot,
-      env: runnerEnvironment(),
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    const result = collectResult(child, input);
-    this.runs.set(runId, { child, result });
-    return { runId };
-  }
-  async waitForResult(runId, signal) {
-    const run = this.runs.get(runId);
-    if (!run) throw new Error("unknown runner runId");
-    const abort = () => run.child.kill("SIGTERM");
-    signal.addEventListener("abort", abort, { once: true });
-    try {
-      return await run.result;
-    } finally {
-      signal.removeEventListener("abort", abort);
-      this.runs.delete(runId);
-    }
-  }
-  async cancel(runId) {
-    this.runs.get(runId)?.child.kill("SIGTERM");
-  }
-}
-function runnerEnvironment() {
-  const environment = { ...process.env };
-  for (const key of Object.keys(environment)) {
-    if (/^DESKTOP_PET_.*(?:TOKEN|SECRET|PASSWORD|REFRESH|TURN)/i.test(key)) {
-      delete environment[key];
-    }
-  }
-  return environment;
-}
-function publicTaskPrompt(input) {
-  return [
-    input.objective,
-    input.constraints.length ? `Constraints:
-- ${input.constraints.join("\n- ")}` : "",
-    input.acceptanceCriteria.length ? `Acceptance criteria:
-- ${input.acceptanceCriteria.join("\n- ")}` : "",
-    "Return only the final result and concise test summary. Do not expose hidden reasoning, credentials, or raw environment data."
-  ].filter(Boolean).join("\n\n");
-}
-function collectResult(child, task) {
-  return new Promise((resolve) => {
-    const publicEvents = [];
-    let buffered = "";
-    child.stdout.setEncoding("utf8");
-    child.stdout.on("data", (chunk) => {
-      buffered += chunk;
-      const lines = buffered.split("\n");
-      buffered = lines.pop() ?? "";
-      for (const line of lines) {
-        try {
-          const mapped = mapProviderEvent(JSON.parse(line));
-          if (mapped) publicEvents.push(mapped);
-        } catch {
-        }
-      }
-    });
-    child.once("exit", (code) => {
-      const final = [...publicEvents].reverse().find((event) => event.type === "final");
-      const text = final?.type === "final" ? final.text : code === 0 ? "Runner completed without a public final event." : "Runner failed.";
-      resolve({
-        protocolVersion: TASK_PROTOCOL_VERSION,
-        taskId: task.taskId,
-        status: code === 0 ? "completed" : "failed",
-        summary: text.slice(0, 8e3),
-        artifacts: [inlineResultArtifact({ kind: "text", text })],
-        diagnostics: code === 0 ? [] : [{ level: "error", code: "RUNNER_EXIT", message: `runner exited with code ${code}` }],
-        tests: [],
-        completedAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
-    });
-  });
-}
-let stopped = true;
-let activeAbort;
-async function startRunnerManager() {
-  if (process.env.DESKTOP_PET_RUNNER_ADAPTERS !== "1" || !stopped) return;
-  const configuredRoot = process.env.DESKTOP_PET_RUNNER_WORKSPACE?.trim();
-  if (!configuredRoot) {
-    logger.warn("runner adapters enabled without DESKTOP_PET_RUNNER_WORKSPACE");
-    return;
-  }
-  const adapter = new CodexCLIAdapter(node_path.resolve(configuredRoot));
-  if (!await adapter.detect()) {
-    logger.warn("Codex CLI runner adapter is unavailable; MCP duty mode remains active");
-    return;
-  }
-  stopped = false;
-  void dutyLoop(adapter);
-}
-function stopRunnerManager() {
-  stopped = true;
-  activeAbort?.abort();
-  activeAbort = void 0;
-}
-async function dutyLoop(adapter) {
-  while (!stopped) {
-    try {
-      const task = await claimRemoteTask(45e3);
-      if (!task || stopped) continue;
-      const run = await adapter.startTask(task.envelope);
-      const abort = new AbortController();
-      activeAbort = abort;
-      const cancellationPoll = setInterval(() => {
-        void getRemoteTask(task.taskId).then((latest) => {
-          if (latest.status === "cancelling" || latest.status === "cancelled") abort.abort();
-        }).catch(() => {
-        });
-      }, 3e3);
-      try {
-        const result = await adapter.waitForResult(run.runId, abort.signal);
-        await submitRemoteTaskResult(result);
-      } finally {
-        clearInterval(cancellationPoll);
-        activeAbort = void 0;
-      }
-    } catch (error) {
-      logger.warn("runner duty iteration failed", { error: String(error) });
-      await new Promise((resolveDelay) => setTimeout(resolveDelay, 2e3));
-    }
-  }
-}
-const PRODUCT_DATA_DIRECTORY = "Desktop Pet";
-const LEGACY_NPM_DATA_DIRECTORY = "desktop-pet-app";
-function configureRuntimeIdentity() {
-  const profileDirectory = process.env.DESKTOP_PET_PROFILE?.trim();
-  if (profileDirectory) {
-    electron.app.setPath("userData", node_path.resolve(profileDirectory));
-    return;
-  }
-  if (!electron.app.isPackaged && process.env.DESKTOP_PET_NPM_DISTRIBUTION !== "1") return;
-  const appDataDirectory = electron.app.getPath("appData");
-  const canonicalDirectory = node_path.join(appDataDirectory, PRODUCT_DATA_DIRECTORY);
-  if (process.env.DESKTOP_PET_NPM_DISTRIBUTION === "1") {
-    migrateLegacyNpmData(node_path.join(appDataDirectory, LEGACY_NPM_DATA_DIRECTORY), canonicalDirectory);
-  }
-  electron.app.setPath("userData", canonicalDirectory);
-}
-function migrateLegacyNpmData(legacyDirectory, canonicalDirectory) {
-  if (!node_fs.existsSync(legacyDirectory) || node_fs.existsSync(canonicalDirectory)) return false;
-  try {
-    node_fs.renameSync(legacyDirectory, canonicalDirectory);
-    return true;
-  } catch (error) {
-    console.warn(`无法迁移 Desktop Pet 用户数据：${String(error)}`);
-    return false;
-  }
-}
-const trayIcon1xPath = path.join(__dirname, "./chunks/tray-iconTemplate-BIK86F-0.png");
-const trayIcon2xPath = path.join(__dirname, "./chunks/tray-iconTemplate@2x-B19HpcaE.png");
-let tray;
-function createMenuBar() {
-  if (process.platform !== "darwin" || tray) return;
-  tray = new electron.Tray(createPetTemplateImage());
-  tray.setToolTip("Desktop Pet");
-  tray.on("click", showMenu);
-  tray.on("right-click", showMenu);
-}
-function destroyMenuBar() {
-  tray?.destroy();
-  tray = void 0;
-}
-function showMenu() {
-  tray?.popUpContextMenu(electron.Menu.buildFromTemplate([
-    { label: `Desktop Pet v${electron.app.getVersion()}`, enabled: false },
-    { type: "separator" },
-    {
-      label: petManager.arePetsVisible() ? "隐藏所有桌面宠物" : "显示所有桌面宠物",
-      click: () => petManager.setPetsVisible(!petManager.arePetsVisible())
-    },
-    { type: "separator" },
-    { label: "退出 Desktop Pet", click: () => electron.app.quit() }
-  ]));
-}
-function createPetTemplateImage() {
-  let image = electron.nativeImage.createFromBuffer(node_fs.readFileSync(trayIcon2xPath), { scaleFactor: 2 });
-  if (image.isEmpty()) image = electron.nativeImage.createFromPath(trayIcon1xPath);
-  if (image.isEmpty()) throw new Error("无法加载 macOS 菜单栏图标");
-  image.setTemplateImage(true);
-  return image;
-}
-configureRuntimeIdentity();
-registerAccountProtocol();
-const singleInstance = electron.app.requestSingleInstanceLock();
-if (!singleInstance) {
-  logger.warn("another instance is running, quitting");
-  electron.app.quit();
-} else {
-  electron.app.on("second-instance", (_event, argv) => {
-    const callback = argv.find((value) => value.startsWith("desktop-pet://"));
-    if (callback) handleAccountCallback(callback);
-    petManager.setPetsVisible(true);
-    ensurePrimaryPet();
-  });
-}
-function ensurePrimaryPet() {
-  if (petManager.hasPrimaryPet()) return null;
-  return createPetWindow(process.env.DESKTOP_PET_SKIN || "codex", {
-    identity: { kind: "primary" }
-  });
-}
-electron.app.whenReady().then(async () => {
-  createMenuBar();
-  await startAccountCallbackRouter();
-  startEventServer(electron.app.getVersion());
-  const activated = await activateStoredDevice().catch((err) => {
-    logger.warn("device authentication failed", { error: String(err) });
-    return false;
-  });
-  if (!activated) startRelay();
-  if (process.env.DESKTOP_PET_P2P !== "0") startP2PWindow(getDeviceIceServers());
-  void startRunnerManager();
-  const id = ensurePrimaryPet();
-  setTimeout(() => {
-    void checkForUpdates().then((result) => {
-      if (id && result.kind === "available") {
-        dispatch({
-          type: "bubble",
-          text: `发现 v${result.update.version}，右键“软件更新”可请求下载`,
-          ttl: 7e3
-        }, id);
-      }
-    });
-  }, 1200);
-  logger.info("app started", { firstPet: id });
-});
-electron.app.on("window-all-closed", () => {
-  if (process.platform !== "darwin") electron.app.quit();
-});
-electron.app.on("quit", () => {
-  destroyMenuBar();
-  stopAccountCallbackRouter();
-  stopRelay();
-  stopP2PWindow();
-  stopRunnerManager();
-  void stopEventServer().catch((err) => logger.warn("event server shutdown failed", { error: String(err) }));
-  logger.info("app quit");
-});