memeloop 0.0.1 → 0.1.1

package/dist/device-network.cjs

@@ -0,0 +1,906 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/device-network-entry.ts
+var device_network_entry_exports = {};
+__export(device_network_entry_exports, {
+  ChatSyncEngine: () => ChatSyncEngine,
+  DEVICE_ORCHESTRATION_PROTOCOL: () => DEVICE_ORCHESTRATION_PROTOCOL,
+  DEVICE_PAIRING_INVITE_PROTOCOL: () => DEVICE_PAIRING_INVITE_PROTOCOL,
+  DEVICE_PAIRING_INVITE_TTL_MS: () => DEVICE_PAIRING_INVITE_TTL_MS,
+  LIBP2P_RPC_REQUEST_TYPE: () => LIBP2P_RPC_REQUEST_TYPE,
+  LIBP2P_RPC_RESPONSE_TYPE: () => LIBP2P_RPC_RESPONSE_TYPE,
+  LIBP2P_SYNC_REQUEST_TYPE: () => LIBP2P_SYNC_REQUEST_TYPE,
+  LIBP2P_SYNC_RESPONSE_TYPE: () => LIBP2P_SYNC_RESPONSE_TYPE,
+  Libp2pDeviceSyncTransport: () => Libp2pDeviceSyncTransport,
+  LocalTrustDeviceAuthorizer: () => LocalTrustDeviceAuthorizer,
+  MemoryDeviceNetworkService: () => MemoryDeviceNetworkService,
+  PeerNodeSyncAdapter: () => PeerNodeSyncAdapter,
+  attachmentBlobFromWire: () => attachmentBlobFromWire,
+  createDeviceOrchestrationStreamHandler: () => createDeviceOrchestrationStreamHandler,
+  createDeviceOrchestrationTransport: () => createDeviceOrchestrationTransport,
+  createDevicePairingInvite: () => createDevicePairingInvite,
+  decodeAttachmentBlobRpc: () => decodeAttachmentBlobRpc,
+  encodeDevicePairingInvite: () => encodeDevicePairingInvite,
+  isConversationMeta: () => isConversationMeta,
+  isLibp2pRpcRequest: () => isLibp2pRpcRequest,
+  isLibp2pRpcResponse: () => isLibp2pRpcResponse,
+  isLibp2pSyncRequest: () => isLibp2pSyncRequest,
+  isLibp2pSyncResponse: () => isLibp2pSyncResponse,
+  parseDevicePairingInvite: () => parseDevicePairingInvite,
+  syncCloudDevices: () => syncCloudDevices
+});
+module.exports = __toCommonJS(device_network_entry_exports);
+
+// src/orchestration/errors.ts
+var OrchestrationError = class extends Error {
+  code;
+  retryable;
+  retryAfterMs;
+  reason;
+  details;
+  constructor(data) {
+    super(data.message);
+    this.name = "OrchestrationError";
+    this.code = data.code;
+    this.retryable = data.retryable;
+    this.retryAfterMs = data.retryAfterMs;
+    this.reason = data.reason;
+    this.details = data.details;
+  }
+  toJSON() {
+    return {
+      code: this.code,
+      message: this.message,
+      retryable: this.retryable,
+      retryAfterMs: this.retryAfterMs,
+      reason: this.reason,
+      details: this.details
+    };
+  }
+};
+
+// src/device-network/deviceOrchestrationTransport.ts
+var DEVICE_ORCHESTRATION_PROTOCOL = "/memeloop/orchestration/1.0.0";
+var DEFAULT_MAX_FRAME_BYTES = 1024 * 1024;
+function orchestrationTransportError(code, message) {
+  return new OrchestrationError({
+    code,
+    message,
+    retryable: code === "UNAVAILABLE"
+  });
+}
+function assertFrameLimit(limit) {
+  if (!Number.isSafeInteger(limit) || limit < 256) {
+    throw new TypeError("maxFrameBytes must be a safe integer of at least 256");
+  }
+}
+async function* encodeLines(values, maxFrameBytes) {
+  const encoder = new TextEncoder();
+  for await (const value of values) {
+    const frame = encoder.encode(`${JSON.stringify(value)}
+`);
+    if (frame.byteLength > maxFrameBytes) {
+      throw orchestrationTransportError(
+        "EXHAUSTED",
+        `device orchestration frame exceeds ${maxFrameBytes} bytes`
+      );
+    }
+    yield frame;
+  }
+}
+async function* decodeLines(source, maxFrameBytes) {
+  const decoder = new TextDecoder();
+  let buffered = "";
+  for await (const chunk of source) {
+    buffered += decoder.decode(chunk, { stream: true });
+    for (; ; ) {
+      const newline = buffered.indexOf("\n");
+      if (newline < 0) break;
+      const line = buffered.slice(0, newline);
+      buffered = buffered.slice(newline + 1);
+      if (!line) continue;
+      if (new TextEncoder().encode(line).byteLength > maxFrameBytes) {
+        throw orchestrationTransportError(
+          "EXHAUSTED",
+          `device orchestration frame exceeds ${maxFrameBytes} bytes`
+        );
+      }
+      try {
+        yield JSON.parse(line);
+      } catch {
+        throw orchestrationTransportError(
+          "INVALID",
+          "device orchestration stream contains invalid JSON"
+        );
+      }
+    }
+    if (new TextEncoder().encode(buffered).byteLength > maxFrameBytes) {
+      throw orchestrationTransportError(
+        "EXHAUSTED",
+        `device orchestration frame exceeds ${maxFrameBytes} bytes`
+      );
+    }
+  }
+  buffered += decoder.decode();
+  if (buffered.trim()) {
+    try {
+      yield JSON.parse(buffered);
+    } catch {
+      throw orchestrationTransportError(
+        "INVALID",
+        "device orchestration stream contains invalid trailing JSON"
+      );
+    }
+  }
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted) {
+    throw orchestrationTransportError("CANCELLED", "device orchestration request was cancelled");
+  }
+}
+async function openAuthenticatedStream(options) {
+  const grant = await options.grantProvider?.(options.peerId);
+  return {
+    stream: await options.deviceNetwork.openStream(
+      options.peerId,
+      DEVICE_ORCHESTRATION_PROTOCOL,
+      grant
+    ),
+    grant
+  };
+}
+async function writeRequest(stream, request, grant, maxFrameBytes) {
+  const envelope = {
+    type: "memeloop-device-orchestration-request-v1",
+    request,
+    ...grant ? { grant } : {}
+  };
+  await stream.sink(encodeLines([envelope], maxFrameBytes));
+}
+function createDeviceOrchestrationTransport(options) {
+  const maxFrameBytes = options.maxFrameBytes ?? DEFAULT_MAX_FRAME_BYTES;
+  assertFrameLimit(maxFrameBytes);
+  return {
+    async request(request, transportOptions = {}) {
+      throwIfAborted(transportOptions.signal);
+      const { stream, grant } = await openAuthenticatedStream(options);
+      const closeOnAbort = () => {
+        void stream.close();
+      };
+      transportOptions.signal?.addEventListener("abort", closeOnAbort, {
+        once: true
+      });
+      try {
+        await writeRequest(stream, request, grant, maxFrameBytes);
+        let response;
+        for await (const value of decodeLines(stream.source, maxFrameBytes)) {
+          if (response) {
+            throw orchestrationTransportError(
+              "INVALID",
+              "device orchestration request returned multiple responses"
+            );
+          }
+          response = value;
+        }
+        throwIfAborted(transportOptions.signal);
+        if (!response) {
+          throw orchestrationTransportError(
+            "UNAVAILABLE",
+            "device orchestration request returned no response"
+          );
+        }
+        return response;
+      } finally {
+        transportOptions.signal?.removeEventListener("abort", closeOnAbort);
+        await stream.close().catch(() => void 0);
+      }
+    },
+    async *watch(request, transportOptions = {}) {
+      throwIfAborted(transportOptions.signal);
+      const { stream, grant } = await openAuthenticatedStream(options);
+      const closeOnAbort = () => {
+        void stream.close();
+      };
+      transportOptions.signal?.addEventListener("abort", closeOnAbort, {
+        once: true
+      });
+      try {
+        await writeRequest(stream, request, grant, maxFrameBytes);
+        for await (const value of decodeLines(stream.source, maxFrameBytes)) {
+          throwIfAborted(transportOptions.signal);
+          yield value;
+        }
+        throwIfAborted(transportOptions.signal);
+      } finally {
+        transportOptions.signal?.removeEventListener("abort", closeOnAbort);
+        await stream.close().catch(() => void 0);
+      }
+    }
+  };
+}
+async function readSingleRequest(stream, maxFrameBytes) {
+  let envelope;
+  for await (const value of decodeLines(stream.source, maxFrameBytes)) {
+    if (envelope) {
+      throw orchestrationTransportError(
+        "INVALID",
+        "device orchestration stream accepts exactly one request"
+      );
+    }
+    if (value === null || typeof value !== "object" || Array.isArray(value) || value.type !== "memeloop-device-orchestration-request-v1" || value.request === null || typeof value.request !== "object") {
+      throw orchestrationTransportError(
+        "INVALID",
+        "device orchestration request envelope is invalid"
+      );
+    }
+    envelope = value;
+  }
+  if (!envelope) {
+    throw orchestrationTransportError("INVALID", "device orchestration request is missing");
+  }
+  return envelope;
+}
+function createDeviceOrchestrationStreamHandler(options) {
+  const maxFrameBytes = options.maxFrameBytes ?? DEFAULT_MAX_FRAME_BYTES;
+  assertFrameLimit(maxFrameBytes);
+  return async ({ remotePeerId, stream, authorize }) => {
+    const abort = new AbortController();
+    try {
+      const envelope = await readSingleRequest(stream, maxFrameBytes);
+      if (authorize && !await authorize(envelope.grant)) {
+        throw orchestrationTransportError("UNAVAILABLE", "device_not_trusted");
+      }
+      const request = envelope.request;
+      const handler = await options.resolveHandler(remotePeerId);
+      if (request.operation === "watch") {
+        await stream.sink(
+          encodeLines(handler.watch(request, { signal: abort.signal }), maxFrameBytes)
+        );
+      } else {
+        await stream.sink(encodeLines([await handler.request(request)], maxFrameBytes));
+      }
+    } finally {
+      abort.abort();
+      await stream.close().catch(() => void 0);
+    }
+  };
+}
+
+// src/device-network/libp2pSyncProtocol.ts
+var LIBP2P_SYNC_REQUEST_TYPE = "memeloop-sync-request-v1";
+var LIBP2P_SYNC_RESPONSE_TYPE = "memeloop-sync-response-v1";
+var syncMethods = /* @__PURE__ */ new Set([
+  "exchangeVersionVector",
+  "pullMissingMetadata",
+  "pullMissingMessages",
+  "pullAttachmentBlob"
+]);
+function isLibp2pSyncRequest(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  return record.type === LIBP2P_SYNC_REQUEST_TYPE && typeof record.id === "string" && typeof record.method === "string" && syncMethods.has(record.method);
+}
+function isLibp2pSyncResponse(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  if (record.type !== LIBP2P_SYNC_RESPONSE_TYPE || typeof record.id !== "string" || typeof record.ok !== "boolean") return false;
+  if (record.ok) return "result" in record;
+  return typeof record.error === "string";
+}
+function isAttachmentBlobWire(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  return typeof record.dataBase64Url === "string" && typeof record.filename === "string" && typeof record.mimeType === "string" && typeof record.size === "number";
+}
+async function attachmentBlobFromWire(value) {
+  if (value === null) return null;
+  if (!isAttachmentBlobWire(value)) throw new Error("invalid_sync_response");
+  let data;
+  try {
+    const base64 = value.dataBase64Url.replace(/-/g, "+").replace(/_/g, "/");
+    const paddedBase64 = base64.padEnd(Math.ceil(base64.length / 4) * 4, "=");
+    const binary = atob(paddedBase64);
+    data = Uint8Array.from(binary, (character) => character.charCodeAt(0));
+  } catch {
+    throw new Error("invalid_sync_response");
+  }
+  return {
+    data,
+    filename: value.filename,
+    mimeType: value.mimeType,
+    size: value.size
+  };
+}
+
+// src/device-network/libp2pDeviceSyncTransport.ts
+var Libp2pDeviceSyncTransport = class {
+  nodeId;
+  deviceNetwork;
+  grantProvider;
+  constructor(options) {
+    this.nodeId = options.nodeId;
+    this.deviceNetwork = options.deviceNetwork;
+    this.grantProvider = options.grantProvider;
+  }
+  listPeers() {
+    return this.deviceNetwork.listDevices();
+  }
+  exchangeVersionVector(peerId, localVersion) {
+    return this.request(peerId, "exchangeVersionVector", { localVersion });
+  }
+  pullMissingMetadata(peerId, sinceVersion) {
+    return this.request(peerId, "pullMissingMetadata", { sinceVersion });
+  }
+  pullMissingMessages(peerId, conversationId, knownMessageIds) {
+    return this.request(peerId, "pullMissingMessages", { conversationId, knownMessageIds });
+  }
+  async pullAttachmentBlob(peerId, contentHash) {
+    const result = await this.request(peerId, "pullAttachmentBlob", { contentHash });
+    return attachmentBlobFromWire(result);
+  }
+  async request(peerId, method, parameters) {
+    const grant = await this.grantProvider?.(peerId);
+    const stream = await this.deviceNetwork.openStream(peerId, "/memeloop/sync/1.0.0", grant);
+    const request = {
+      type: LIBP2P_SYNC_REQUEST_TYPE,
+      id: crypto.randomUUID(),
+      method,
+      params: parameters,
+      grant
+    };
+    await writeJsonToStream(stream, request);
+    const response = await readJsonFromStream(stream);
+    await stream.close();
+    if (!isLibp2pSyncResponse(response)) throw new Error("invalid_sync_response");
+    if (response.id !== request.id) throw new Error("sync_response_id_mismatch");
+    if (!response.ok) throw new Error(response.error);
+    return response.result;
+  }
+};
+async function writeJsonToStream(stream, message) {
+  const payload = new TextEncoder().encode(JSON.stringify(message));
+  await stream.sink((async function* () {
+    yield payload;
+  })());
+}
+async function readJsonFromStream(stream) {
+  const reader = stream.source[Symbol.asyncIterator]();
+  const result = await reader.next();
+  if (result.done || !result.value) throw new Error("sync_response_missing");
+  return JSON.parse(new TextDecoder().decode(result.value));
+}
+
+// src/device-network/libp2pRpcProtocol.ts
+var LIBP2P_RPC_REQUEST_TYPE = "memeloop-rpc-request-v1";
+var LIBP2P_RPC_RESPONSE_TYPE = "memeloop-rpc-response-v1";
+function isLibp2pRpcRequest(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  return record.type === LIBP2P_RPC_REQUEST_TYPE && typeof record.id === "string" && typeof record.method === "string";
+}
+function isLibp2pRpcResponse(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  if (record.type !== LIBP2P_RPC_RESPONSE_TYPE || typeof record.id !== "string" || typeof record.ok !== "boolean") return false;
+  if (record.ok) return "result" in record;
+  return typeof record.error === "string";
+}
+
+// src/device-network/localTrustDeviceAuthorizer.ts
+var PAIRING_PROTOCOL = "/memeloop/pairing/1.0.0";
+var LocalTrustDeviceAuthorizer = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.allowPairingProtocol = options.allowPairingProtocol ?? true;
+    for (const record of options.trustedDevices ?? []) {
+      this.trustedDevices.set(record.peerId, record);
+    }
+  }
+  trustedDevices = /* @__PURE__ */ new Map();
+  allowPairingProtocol;
+  setTrustedDevice(record) {
+    this.trustedDevices.set(record.peerId, record);
+  }
+  removeTrustedDevice(peerId) {
+    this.trustedDevices.delete(peerId);
+  }
+  async canOpenProtocol(input) {
+    const record = this.options.getTrustedDevice?.(input.remotePeerId) ?? this.trustedDevices.get(input.remotePeerId);
+    if (record?.revokedAt) return false;
+    if (input.protocol === PAIRING_PROTOCOL) return this.allowPairingProtocol;
+    return record !== void 0;
+  }
+};
+
+// src/device-network/pairingInvite.ts
+var DEVICE_PAIRING_INVITE_PROTOCOL = "memeloop-device-pairing-v1";
+var DEVICE_PAIRING_INVITE_TTL_MS = 5 * 6e4;
+var MAX_INVITE_LENGTH = 16 * 1024;
+var MAX_ADDRESSES = 8;
+function requireText(value, name, maxLength) {
+  const trimmed = value.trim();
+  if (!trimmed || trimmed.length > maxLength) {
+    throw new Error(`invalid device pairing invite ${name}`);
+  }
+  return trimmed;
+}
+function validateAddresses(addresses) {
+  const unique = [...new Set(addresses.map((address) => address.trim()))].filter(Boolean);
+  if (unique.length === 0 || unique.length > MAX_ADDRESSES || unique.some(
+    (address) => address.length > 2048 || !address.startsWith("/") || !address.includes("/ws") && !address.includes("/wss")
+  )) {
+    throw new Error("device pairing invite requires WebSocket multiaddrs");
+  }
+  return unique;
+}
+function createDevicePairingInvite(device, options = {}) {
+  const createdAt = options.now ?? Date.now();
+  const ttlMs = options.ttlMs ?? DEVICE_PAIRING_INVITE_TTL_MS;
+  if (!Number.isSafeInteger(createdAt) || !Number.isSafeInteger(ttlMs) || ttlMs <= 0 || ttlMs > DEVICE_PAIRING_INVITE_TTL_MS) {
+    throw new Error("invalid device pairing invite lifetime");
+  }
+  return {
+    protocol: DEVICE_PAIRING_INVITE_PROTOCOL,
+    peerId: requireText(device.peerId, "peerId", 256),
+    deviceName: requireText(device.displayName, "deviceName", 256),
+    multiaddrs: validateAddresses(device.multiaddrs ?? []),
+    createdAt,
+    expiresAt: createdAt + ttlMs
+  };
+}
+function encodeDevicePairingInvite(invite) {
+  const validated = parseDevicePairingInvite(JSON.stringify(invite), {
+    now: invite.createdAt
+  });
+  return JSON.stringify(validated);
+}
+function parseDevicePairingInvite(serialized, options = {}) {
+  if (!serialized || serialized.length > MAX_INVITE_LENGTH) {
+    throw new Error("invalid device pairing invite length");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(serialized);
+  } catch {
+    throw new Error("device pairing invite is not valid JSON");
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("invalid device pairing invite");
+  }
+  const record = parsed;
+  if (record.protocol !== DEVICE_PAIRING_INVITE_PROTOCOL || typeof record.peerId !== "string" || typeof record.deviceName !== "string" || !Array.isArray(record.multiaddrs) || record.multiaddrs.some((address) => typeof address !== "string") || typeof record.createdAt !== "number" || typeof record.expiresAt !== "number" || !Number.isSafeInteger(record.createdAt) || !Number.isSafeInteger(record.expiresAt) || record.expiresAt <= record.createdAt || record.expiresAt - record.createdAt > DEVICE_PAIRING_INVITE_TTL_MS) {
+    throw new Error("invalid device pairing invite");
+  }
+  if (record.expiresAt <= (options.now ?? Date.now())) {
+    throw new Error("device pairing invite has expired");
+  }
+  return {
+    protocol: DEVICE_PAIRING_INVITE_PROTOCOL,
+    peerId: requireText(record.peerId, "peerId", 256),
+    deviceName: requireText(record.deviceName, "deviceName", 256),
+    multiaddrs: validateAddresses(record.multiaddrs),
+    createdAt: record.createdAt,
+    expiresAt: record.expiresAt
+  };
+}
+
+// src/sync/attachmentRpcCodec.ts
+function decodeAttachmentBlobRpc(result) {
+  if (result == null || typeof result !== "object") return null;
+  const r = result;
+  if (r.error || !r.found || typeof r.dataBase64 !== "string") return null;
+  let data;
+  try {
+    const binary = atob(r.dataBase64);
+    if (!binary.length) return null;
+    data = Uint8Array.from(binary, (character) => character.charCodeAt(0));
+  } catch {
+    return null;
+  }
+  return {
+    data,
+    filename: typeof r.filename === "string" ? r.filename : "attachment",
+    mimeType: typeof r.mimeType === "string" ? r.mimeType : "application/octet-stream",
+    size: typeof r.size === "number" && r.size > 0 ? r.size : data.byteLength
+  };
+}
+
+// src/sync/chatSyncEngine.ts
+var ChatSyncEngine = class {
+  nodeId;
+  storage;
+  getPeers;
+  versionVector = {};
+  constructor(options) {
+    this.nodeId = options.nodeId;
+    this.storage = options.storage;
+    this.getPeers = options.peers;
+    this.versionVector[this.nodeId] = 0;
+  }
+  /**
+   * 在本节点新产生一条消息时调用，增加本节点的 lamportClock。
+   */
+  bumpLocalVersion() {
+    this.versionVector[this.nodeId] = (this.versionVector[this.nodeId] ?? 0) + 1;
+  }
+  /**
+   * 执行一次与所有 peer 的增量同步（metadata 级别），并尽力拉取缺失消息。
+   */
+  async syncOnce() {
+    const peers = this.getPeers();
+    if (peers.length === 0) return;
+    const localVersion = { ...this.versionVector };
+    const pulledConversations = /* @__PURE__ */ new Set();
+    for (const peer of peers) {
+      const { remoteVersion, missingForRemote } = await peer.exchangeVersionVector(localVersion);
+      const missingForLocal = await peer.pullMissingMetadata(this.versionVector);
+      for (const meta of missingForLocal) {
+        await this.storage.upsertConversationMetadata(meta);
+        pulledConversations.add(meta.conversationId);
+      }
+      for (const [nodeId, clock] of Object.entries(remoteVersion)) {
+        const current = this.versionVector[nodeId] ?? 0;
+        if (clock > current) {
+          this.versionVector[nodeId] = clock;
+        }
+      }
+      if (missingForRemote.length > 0) {
+        this.bumpLocalVersion();
+      }
+    }
+    for (const conversationId of pulledConversations) {
+      await this.pullMessagesForConversationFromPeers(conversationId, peers);
+    }
+  }
+  /**
+   * Anti-entropy：先 syncOnce，再对已知会话逐个向各 peer 拉取缺失消息（参考审查单「定期对账」）。
+   */
+  async antiEntropyOnce() {
+    await this.syncOnce();
+    const list = await this.storage.listConversations({ limit: 500 });
+    const peers = this.getPeers();
+    for (const meta of list) {
+      await this.pullMessagesForConversationFromPeers(meta.conversationId, peers);
+    }
+  }
+  async pullMessagesForConversationFromPeers(conversationId, peers) {
+    const localMsgs = await this.storage.getMessages(conversationId, { mode: "full-content" });
+    const knownIds = localMsgs.map((m) => m.messageId);
+    for (const peer of peers) {
+      if (!peer.pullMissingMessages) continue;
+      try {
+        const incoming = await peer.pullMissingMessages(conversationId, knownIds);
+        if (incoming.length > 0) {
+          await this.storage.insertMessagesIfAbsent(incoming);
+          await this.ensureAttachmentsFromMessages(incoming, peers);
+        }
+      } catch {
+      }
+    }
+  }
+  /** 从消息元数据收集 `attachments[].contentHash`，对本地缺失 BLOB 的哈希向各 peer 拉取并 `saveAttachment`。 */
+  async ensureAttachmentsFromMessages(messages, peers) {
+    const hashes = /* @__PURE__ */ new Set();
+    for (const m of messages) {
+      for (const a of m.attachments ?? []) {
+        if (a.contentHash) hashes.add(a.contentHash);
+      }
+    }
+    for (const h of hashes) {
+      const reference = await this.storage.getAttachment(h);
+      if (reference) {
+        const reader = this.storage.readAttachmentData?.bind(this.storage);
+        if (!reader) continue;
+        const bytes = await reader(h);
+        if (bytes && bytes.length > 0) continue;
+      }
+      for (const peer of peers) {
+        const pull = peer.pullAttachmentBlob?.bind(peer);
+        if (!pull) continue;
+        try {
+          const blob = await pull(h);
+          if (blob?.data?.length) {
+            const ar = {
+              contentHash: h,
+              filename: blob.filename,
+              mimeType: blob.mimeType,
+              size: blob.size > 0 ? blob.size : blob.data.length
+            };
+            await this.storage.saveAttachment(ar, blob.data);
+            break;
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  getVersionVector() {
+    return { ...this.versionVector };
+  }
+  getStorage() {
+    return this.storage;
+  }
+};
+
+// src/sync/peerNodeAdapter.ts
+var PeerNodeSyncAdapter = class {
+  nodeId;
+  transport;
+  constructor(nodeId, transport) {
+    this.nodeId = nodeId;
+    this.transport = transport;
+  }
+  exchangeVersionVector(localVersion) {
+    return this.transport.exchangeVersionVector(this.nodeId, localVersion);
+  }
+  pullMissingMetadata(sinceVersion) {
+    return this.transport.pullMissingMetadata(this.nodeId, sinceVersion);
+  }
+  pullMissingMessages(conversationId, knownMessageIds) {
+    const function_ = this.transport.pullMissingMessages?.bind(this.transport);
+    if (!function_) {
+      return Promise.resolve([]);
+    }
+    return function_(this.nodeId, conversationId, knownMessageIds);
+  }
+  pullAttachmentBlob(contentHash) {
+    const function_ = this.transport.pullAttachmentBlob?.bind(this.transport);
+    if (!function_) {
+      return Promise.resolve(null);
+    }
+    return function_(this.nodeId, contentHash);
+  }
+};
+
+// src/sync/protocol.ts
+function isConversationMeta(value) {
+  if (value === null || typeof value !== "object") return false;
+  const o = value;
+  return typeof o.conversationId === "string" && typeof o.title === "string" && typeof o.originNodeId === "string" && typeof o.definitionId === "string" && typeof o.messageCount === "number" && typeof o.lastMessageTimestamp === "number" && typeof o.isUserInitiated === "boolean";
+}
+
+// src/device-network/memoryDeviceNetworkService.ts
+var emptyCapabilities = {
+  tools: [],
+  mcpServers: [],
+  hasWiki: false,
+  agentLoop: false,
+  imChannels: [],
+  wikis: []
+};
+function toDevice(record, capabilities) {
+  return {
+    peerId: record.peerId,
+    displayName: record.deviceName,
+    platform: record.platform,
+    trustMode: record.trustMode,
+    trusted: !record.revokedAt,
+    reachability: {
+      state: record.revokedAt ? "offline" : "nearby",
+      paths: record.revokedAt ? [] : ["lan"]
+    },
+    capabilities,
+    lastSeen: record.lastSeen
+  };
+}
+var MemoryDeviceNetworkService = class {
+  constructor(options) {
+    this.options = options;
+    this.capabilities = options.capabilities ?? emptyCapabilities;
+    for (const record of options.trustedDevices ?? []) {
+      this.trustedDevices.set(record.peerId, record);
+    }
+  }
+  started = false;
+  capabilities;
+  trustedDevices = /* @__PURE__ */ new Map();
+  pairingSessions = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  pairingListeners = /* @__PURE__ */ new Set();
+  async start() {
+    this.started = true;
+    this.emitDevices();
+  }
+  async stop() {
+    this.started = false;
+    this.emitDevices();
+  }
+  async getLocalDevice() {
+    return {
+      peerId: this.options.identity.peerId,
+      displayName: this.options.identity.deviceName,
+      platform: this.options.identity.platform,
+      trustMode: "local-pairing",
+      reachability: {
+        state: this.started ? "online" : "offline",
+        paths: this.started ? ["lan"] : []
+      },
+      capabilities: this.capabilities,
+      lastSeen: Date.now()
+    };
+  }
+  async listDevices() {
+    return [...this.trustedDevices.values()].map((record) => toDevice(record, emptyCapabilities));
+  }
+  observeDevices(listener) {
+    this.listeners.add(listener);
+    void this.listDevices().then(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  async listPairingSessions() {
+    return [...this.pairingSessions.values()];
+  }
+  observePairingSessions(listener) {
+    this.pairingListeners.add(listener);
+    void this.listPairingSessions().then(listener);
+    return () => {
+      this.pairingListeners.delete(listener);
+    };
+  }
+  async requestLocalPairing(peerId, _options = {}) {
+    const createdAt = Date.now();
+    const session = {
+      sessionId: `pairing-${this.options.identity.peerId}-${peerId}-${createdAt}`,
+      localPeerId: this.options.identity.peerId,
+      remotePeerId: peerId,
+      remotePublicKeyMultibase: "",
+      remoteDeviceName: peerId,
+      remotePlatform: "cli",
+      remoteCapabilities: emptyCapabilities,
+      remoteMultiaddrs: [],
+      direction: "outbound",
+      status: "pending",
+      confirmCode: this.confirmCode(peerId),
+      createdAt,
+      expiresAt: createdAt + 5 * 6e4
+    };
+    this.pairingSessions.set(session.sessionId, session);
+    this.emitPairingSessions();
+    return session;
+  }
+  async acceptPairing(sessionId) {
+    const session = this.pairingSessions.get(sessionId);
+    if (!session) throw new Error("pairing_session_not_found");
+    if (session.expiresAt < Date.now()) throw new Error("pairing_session_expired");
+    if (session.status !== "pending") throw new Error("pairing_session_not_pending");
+    this.trustedDevices.set(session.remotePeerId, {
+      peerId: session.remotePeerId,
+      publicKeyMultibase: session.remotePublicKeyMultibase,
+      deviceName: session.remoteDeviceName,
+      platform: session.remotePlatform,
+      trustMode: "local-pairing",
+      createdAt: Date.now(),
+      lastSeen: Date.now()
+    });
+    session.status = "accepted";
+    this.emitPairingSessions();
+    this.emitDevices();
+  }
+  async rejectPairing(sessionId) {
+    const session = this.pairingSessions.get(sessionId);
+    if (!session) return;
+    session.status = "rejected";
+    this.emitPairingSessions();
+  }
+  async removeTrustedDevice(peerId) {
+    this.trustedDevices.delete(peerId);
+    this.emitDevices();
+  }
+  async openStream(peerId, _protocol, _presentedGrant) {
+    if (!this.trustedDevices.has(peerId)) throw new Error("device_not_trusted");
+    return {
+      source: (async function* emptySource() {
+      })(),
+      async sink() {
+      },
+      async close() {
+      }
+    };
+  }
+  async sendRpc(peerId, _method, _parameters, _presentedGrant) {
+    if (!this.trustedDevices.has(peerId)) throw new Error("device_not_trusted");
+    throw new Error("rpc_handler_not_registered");
+  }
+  async syncWithDevice(peerId, _presentedGrant) {
+    if (!this.trustedDevices.has(peerId)) throw new Error("device_not_trusted");
+    return { ok: true, peerId, syncedAt: Date.now() };
+  }
+  confirmCode(peerId) {
+    const input = `${this.options.identity.peerId}:${peerId}`;
+    let hash = 0;
+    for (let index = 0; index < input.length; index += 1) {
+      hash = hash * 31 + input.charCodeAt(index) >>> 0;
+    }
+    return (hash % 1e6).toString().padStart(6, "0");
+  }
+  emitDevices() {
+    void this.listDevices().then((devices) => {
+      for (const listener of this.listeners) listener(devices);
+    });
+  }
+  emitPairingSessions() {
+    void this.listPairingSessions().then((sessions) => {
+      for (const listener of this.pairingListeners) listener(sessions);
+    });
+  }
+};
+
+// src/device-network/syncCloudDevices.ts
+async function syncCloudDevices(input) {
+  const cloudDevices = await input.cloudClient.listDevices();
+  if (cloudDevices.length === 0) return [];
+  const existingRecords = await input.trustStore.loadTrustedDevices();
+  const existingByPeerId = new Map(existingRecords.map((r) => [r.peerId, r]));
+  for (const cloudDevice of cloudDevices) {
+    const existing = existingByPeerId.get(cloudDevice.peerId);
+    const record = {
+      peerId: cloudDevice.peerId,
+      publicKeyMultibase: cloudDevice.publicKeyMultibase,
+      deviceName: cloudDevice.deviceName,
+      platform: cloudDevice.platform,
+      trustMode: "cloud-account",
+      accountId: cloudDevice.accountId,
+      createdAt: existing?.createdAt ?? Date.now(),
+      lastSeen: cloudDevice.lastSeen,
+      revokedAt: cloudDevice.revokedAt
+    };
+    if (existing) {
+      existing.lastSeen = cloudDevice.lastSeen;
+      existing.revokedAt = cloudDevice.revokedAt;
+      if (existing.publicKeyMultibase !== record.publicKeyMultibase || existing.deviceName !== record.deviceName || existing.platform !== record.platform) {
+        await input.trustStore.saveTrustedDevice(record);
+      }
+    } else {
+      await input.trustStore.saveTrustedDevice(record);
+    }
+  }
+  return cloudDevices;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChatSyncEngine,
+  DEVICE_ORCHESTRATION_PROTOCOL,
+  DEVICE_PAIRING_INVITE_PROTOCOL,
+  DEVICE_PAIRING_INVITE_TTL_MS,
+  LIBP2P_RPC_REQUEST_TYPE,
+  LIBP2P_RPC_RESPONSE_TYPE,
+  LIBP2P_SYNC_REQUEST_TYPE,
+  LIBP2P_SYNC_RESPONSE_TYPE,
+  Libp2pDeviceSyncTransport,
+  LocalTrustDeviceAuthorizer,
+  MemoryDeviceNetworkService,
+  PeerNodeSyncAdapter,
+  attachmentBlobFromWire,
+  createDeviceOrchestrationStreamHandler,
+  createDeviceOrchestrationTransport,
+  createDevicePairingInvite,
+  decodeAttachmentBlobRpc,
+  encodeDevicePairingInvite,
+  isConversationMeta,
+  isLibp2pRpcRequest,
+  isLibp2pRpcResponse,
+  isLibp2pSyncRequest,
+  isLibp2pSyncResponse,
+  parseDevicePairingInvite,
+  syncCloudDevices
+});
+//# sourceMappingURL=device-network.cjs.map