capdebug 0.2.0 → 0.3.0

package/dist/plugin.js

@@ -2374,10 +2374,861 @@ var capacitorCapDebug = (function (exports, core) {
     }
   }
 
+  class HttpSseSignalingClient {
+    baseUrl;
+    sessionId = "";
+    secret = "";
+    role = "peer";
+    eventSource = null;
+    listeners = /* @__PURE__ */ new Set();
+    isClosed = false;
+    pollTimer = null;
+    constructor(baseUrl) {
+      this.baseUrl = baseUrl.replace(/\/+$/, "");
+    }
+    async createSession(ttlSeconds = 300) {
+      this.role = "host";
+      const res = await fetch(`${this.baseUrl}/api/pair/create`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ ttl: ttlSeconds })
+      });
+      if (!res.ok) {
+        throw new Error(`Failed to create pairing session: ${res.statusText}`);
+      }
+      const data = await res.json();
+      this.sessionId = data.sessionId;
+      this.secret = data.secret;
+      this.connectEventStream();
+      return data;
+    }
+    async joinSession(sessionId, secret) {
+      this.role = "peer";
+      this.sessionId = sessionId;
+      this.secret = secret;
+      const res = await fetch(`${this.baseUrl}/api/pair/join`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ sessionId, secret })
+      });
+      if (!res.ok) {
+        const err = await res.text().catch(() => "");
+        throw new Error(`Failed to join pairing session: ${err || res.statusText}`);
+      }
+      this.connectEventStream();
+    }
+    async send(message) {
+      if (this.isClosed) return;
+      message.sessionId = this.sessionId;
+      message.secret = this.secret;
+      message.sender = this.role;
+      message.timestamp = Date.now();
+      await fetch(`${this.baseUrl}/api/pair/signal`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(message)
+      });
+    }
+    onMessage(callback) {
+      this.listeners.add(callback);
+      return () => {
+        this.listeners.delete(callback);
+      };
+    }
+    close() {
+      this.isClosed = true;
+      if (this.eventSource) {
+        this.eventSource.close();
+        this.eventSource = null;
+      }
+      if (this.pollTimer) {
+        clearInterval(this.pollTimer);
+        this.pollTimer = null;
+      }
+      this.listeners.clear();
+    }
+    connectEventStream() {
+      if (typeof EventSource !== "undefined") {
+        const sseUrl = `${this.baseUrl}/api/pair/events?session=${encodeURIComponent(this.sessionId)}&secret=${encodeURIComponent(this.secret)}&role=${this.role}`;
+        this.eventSource = new EventSource(sseUrl);
+        this.eventSource.onmessage = (event) => {
+          if (!event.data) return;
+          try {
+            const msg = JSON.parse(event.data);
+            this.dispatchMessage(msg);
+          } catch {
+          }
+        };
+        this.eventSource.onerror = () => {
+        };
+      } else {
+        this.startPolling();
+      }
+    }
+    startPolling() {
+      if (this.pollTimer) return;
+      this.pollTimer = setInterval(async () => {
+        if (this.isClosed || !this.sessionId) return;
+        try {
+          const res = await fetch(
+            `${this.baseUrl}/api/pair/poll?session=${encodeURIComponent(this.sessionId)}&secret=${encodeURIComponent(this.secret)}&role=${this.role}`
+          );
+          if (res.ok) {
+            const messages = await res.json();
+            if (Array.isArray(messages)) {
+              for (const msg of messages) {
+                this.dispatchMessage(msg);
+              }
+            }
+          }
+        } catch {
+        }
+      }, 1e3);
+    }
+    dispatchMessage(message) {
+      for (const listener of this.listeners) {
+        try {
+          listener(message);
+        } catch (err) {
+          console.error("[CapDebug Signaling] Listener error:", err);
+        }
+      }
+    }
+  }
+
+  const PROTOCOL_VERSION = 1;
+  class RemoteProtocol {
+    static createHello(capdebugVersion = "0.2.0", platform = "web", deviceName) {
+      return {
+        v: 1,
+        type: "hello",
+        payload: {
+          capdebugVersion,
+          platform,
+          deviceName: deviceName || (typeof navigator !== "undefined" ? navigator.userAgent : "Unknown Device")
+        },
+        timestamp: Date.now()
+      };
+    }
+    static createHelloAck() {
+      return {
+        v: 1,
+        type: "hello-ack",
+        payload: {
+          serverTime: Date.now()
+        },
+        timestamp: Date.now()
+      };
+    }
+    static createEvent(event) {
+      return {
+        v: 1,
+        type: "event",
+        event,
+        timestamp: Date.now()
+      };
+    }
+    static createBatch(events) {
+      return {
+        v: 1,
+        type: "events-batch",
+        events,
+        timestamp: Date.now()
+      };
+    }
+    static createControl(command) {
+      return {
+        v: 1,
+        type: "control",
+        command,
+        timestamp: Date.now()
+      };
+    }
+    static createPing(timestamp = Date.now()) {
+      return {
+        v: 1,
+        type: "ping",
+        timestamp
+      };
+    }
+    static createPong(pingTimestamp) {
+      return {
+        v: 1,
+        type: "pong",
+        payload: { pingTimestamp },
+        timestamp: Date.now()
+      };
+    }
+    static serialize(message) {
+      return JSON.stringify(message);
+    }
+    static parse(raw) {
+      try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object") {
+          return null;
+        }
+        if (parsed.v !== PROTOCOL_VERSION) {
+          console.warn(`[CapDebug Remote] Unsupported protocol version: ${parsed.v}`);
+          return null;
+        }
+        return parsed;
+      } catch {
+        return null;
+      }
+    }
+  }
+
+  class RemoteEventBuffer {
+    buffer = [];
+    maxCapacity;
+    droppedCount = 0;
+    constructor(maxCapacity = 100) {
+      this.maxCapacity = Math.max(1, maxCapacity);
+    }
+    push(event) {
+      if (this.buffer.length >= this.maxCapacity) {
+        this.buffer.shift();
+      }
+      this.buffer.push(event);
+    }
+    flush() {
+      const items = [...this.buffer];
+      this.buffer = [];
+      return items;
+    }
+    clear() {
+      this.buffer = [];
+      this.droppedCount = 0;
+    }
+    size() {
+      return this.buffer.length;
+    }
+    getDroppedCount() {
+      return this.droppedCount;
+    }
+    incrementDropped() {
+      this.droppedCount++;
+    }
+  }
+
+  class WebRTCTransport {
+    id = "webrtc";
+    pc = null;
+    signaling = null;
+    config = null;
+    eventsChannel = null;
+    controlChannel = null;
+    status = "disconnected";
+    buffer = new RemoteEventBuffer(100);
+    eventListeners = /* @__PURE__ */ new Set();
+    controlListeners = /* @__PURE__ */ new Set();
+    statusListeners = /* @__PURE__ */ new Set();
+    diagnosticsListeners = /* @__PURE__ */ new Set();
+    pingTimer = null;
+    statsTimer = null;
+    rttMs = 0;
+    totalEventsSent = 0;
+    totalEventsReceived = 0;
+    connectedAt = 0;
+    remoteDeviceName = "Unknown Device";
+    remotePlatform = "unknown";
+    diagnostics = {
+      transport: "webrtc",
+      status: "disconnected",
+      route: "unknown"
+    };
+    async connect(config) {
+      this.config = config;
+      this.setStatus("connecting");
+      const signalingUrl = config.signalingUrl || (typeof window !== "undefined" ? window.location.origin : "http://localhost:4783");
+      this.signaling = new HttpSseSignalingClient(signalingUrl);
+      this.signaling.onMessage((msg) => this.handleSignalingMessage(msg));
+      if (config.isHost) {
+        this.setStatus("signaling");
+      } else {
+        this.setStatus("signaling");
+        await this.signaling.joinSession(config.sessionId, config.secret);
+      }
+    }
+    send(event) {
+      if (this.eventsChannel && this.eventsChannel.readyState === "open") {
+        if (this.eventsChannel.bufferedAmount > 256 * 1024) {
+          if (event.level === "debug" || event.level === "info") {
+            this.buffer.incrementDropped();
+            return;
+          }
+        }
+        const msg = RemoteProtocol.createEvent(event);
+        try {
+          this.eventsChannel.send(RemoteProtocol.serialize(msg));
+          this.totalEventsSent++;
+        } catch (err) {
+          console.error("[CapDebug Remote] Send error:", err);
+        }
+      } else {
+        this.buffer.push(event);
+      }
+    }
+    sendControl(command) {
+      if (this.controlChannel && this.controlChannel.readyState === "open") {
+        const msg = RemoteProtocol.createControl(command);
+        try {
+          this.controlChannel.send(RemoteProtocol.serialize(msg));
+        } catch (err) {
+          console.error("[CapDebug Remote] Control send error:", err);
+        }
+      }
+    }
+    disconnect() {
+      this.stopTimers();
+      if (this.controlChannel) {
+        try {
+          this.sendControl({ type: "disconnect" });
+        } catch {
+        }
+      }
+      if (this.signaling) {
+        this.signaling.close();
+        this.signaling = null;
+      }
+      if (this.eventsChannel) {
+        this.eventsChannel.close();
+        this.eventsChannel = null;
+      }
+      if (this.controlChannel) {
+        this.controlChannel.close();
+        this.controlChannel = null;
+      }
+      if (this.pc) {
+        this.pc.close();
+        this.pc = null;
+      }
+      this.setStatus("disconnected");
+    }
+    getStatus() {
+      return this.status;
+    }
+    getDiagnostics() {
+      return {
+        ...this.diagnostics,
+        status: this.status,
+        rttMs: this.rttMs,
+        bufferedAmountBytes: this.eventsChannel?.bufferedAmount || 0,
+        droppedEventsCount: this.buffer.getDroppedCount(),
+        totalEventsSent: this.totalEventsSent,
+        totalEventsReceived: this.totalEventsReceived,
+        connectedAt: this.connectedAt,
+        deviceName: this.remoteDeviceName,
+        platform: this.remotePlatform
+      };
+    }
+    onEvent(callback) {
+      this.eventListeners.add(callback);
+      return () => this.eventListeners.delete(callback);
+    }
+    onControl(callback) {
+      this.controlListeners.add(callback);
+      return () => this.controlListeners.delete(callback);
+    }
+    onStatusChange(callback) {
+      this.statusListeners.add(callback);
+      callback(this.status);
+      return () => this.statusListeners.delete(callback);
+    }
+    onDiagnostics(callback) {
+      this.diagnosticsListeners.add(callback);
+      return () => this.diagnosticsListeners.delete(callback);
+    }
+    async handleSignalingMessage(msg) {
+      switch (msg.type) {
+        case "peer-joined":
+          if (this.config?.isHost) {
+            await this.startHandshakeAsInitiator();
+          }
+          break;
+        case "offer":
+          if (!this.config?.isHost) {
+            await this.handleOffer(msg.payload);
+          }
+          break;
+        case "answer":
+          if (this.config?.isHost && this.pc) {
+            await this.pc.setRemoteDescription(new RTCSessionDescription(msg.payload));
+          }
+          break;
+        case "ice-candidate":
+          if (this.pc && msg.payload) {
+            try {
+              await this.pc.addIceCandidate(new RTCIceCandidate(msg.payload));
+            } catch (err) {
+              console.warn("[CapDebug Remote] ICE Candidate error:", err);
+            }
+          }
+          break;
+        case "disconnect":
+          this.disconnect();
+          break;
+      }
+    }
+    initPeerConnection() {
+      const iceServers = this.config?.iceServers || [
+        { urls: "stun:stun.l.google.com:19302" },
+        { urls: "stun:global.stun.twilio.com:3478" }
+      ];
+      const pc = new RTCPeerConnection({ iceServers });
+      pc.onicecandidate = (event) => {
+        if (event.candidate && this.signaling) {
+          this.signaling.send({
+            sessionId: this.config.sessionId,
+            secret: this.config.secret,
+            type: "ice-candidate",
+            sender: this.config.isHost ? "host" : "peer",
+            payload: event.candidate.toJSON()
+          });
+        }
+      };
+      pc.onconnectionstatechange = () => {
+        this.updateDiagnostics();
+        if (pc.connectionState === "failed") {
+          this.setStatus("failed");
+        } else if (pc.connectionState === "closed" || pc.connectionState === "disconnected") {
+          this.setStatus("disconnected");
+        }
+      };
+      pc.oniceconnectionstatechange = () => {
+        this.updateDiagnostics();
+      };
+      this.pc = pc;
+      return pc;
+    }
+    async startHandshakeAsInitiator() {
+      const pc = this.initPeerConnection();
+      this.eventsChannel = pc.createDataChannel("events", { ordered: true });
+      this.controlChannel = pc.createDataChannel("control", { ordered: true });
+      this.setupDataChannel(this.eventsChannel, "events");
+      this.setupDataChannel(this.controlChannel, "control");
+      const offer = await pc.createOffer();
+      await pc.setLocalDescription(offer);
+      if (this.signaling) {
+        await this.signaling.send({
+          sessionId: this.config.sessionId,
+          secret: this.config.secret,
+          type: "offer",
+          sender: "host",
+          payload: offer
+        });
+      }
+    }
+    async handleOffer(offerSdp) {
+      const pc = this.initPeerConnection();
+      pc.ondatachannel = (event) => {
+        const channel = event.channel;
+        if (channel.label === "events") {
+          this.eventsChannel = channel;
+          this.setupDataChannel(channel, "events");
+        } else if (channel.label === "control") {
+          this.controlChannel = channel;
+          this.setupDataChannel(channel, "control");
+        }
+      };
+      await pc.setRemoteDescription(new RTCSessionDescription(offerSdp));
+      const answer = await pc.createAnswer();
+      await pc.setLocalDescription(answer);
+      if (this.signaling) {
+        await this.signaling.send({
+          sessionId: this.config.sessionId,
+          secret: this.config.secret,
+          type: "answer",
+          sender: "peer",
+          payload: answer
+        });
+      }
+    }
+    setupDataChannel(channel, label) {
+      channel.onopen = () => {
+        if (this.eventsChannel?.readyState === "open" && this.controlChannel?.readyState === "open") {
+          this.connectedAt = Date.now();
+          this.setStatus("connected");
+          this.startTimers();
+          if (!this.config?.isHost) {
+            const hello = RemoteProtocol.createHello("0.2.0", "mobile");
+            channel.send(RemoteProtocol.serialize(hello));
+            const buffered = this.buffer.flush();
+            if (buffered.length > 0 && this.eventsChannel?.readyState === "open") {
+              const batch = RemoteProtocol.createBatch(buffered);
+              this.eventsChannel.send(RemoteProtocol.serialize(batch));
+              this.totalEventsSent += buffered.length;
+            }
+          }
+        }
+      };
+      channel.onclose = () => {
+        this.setStatus("disconnected");
+      };
+      channel.onmessage = (e) => {
+        const raw = e.data;
+        if (typeof raw !== "string") return;
+        const message = RemoteProtocol.parse(raw);
+        if (!message) return;
+        if (label === "events") {
+          if (message.type === "event" && message.event) {
+            this.totalEventsReceived++;
+            for (const listener of this.eventListeners) {
+              listener(message.event);
+            }
+          } else if (message.type === "events-batch" && Array.isArray(message.events)) {
+            this.totalEventsReceived += message.events.length;
+            for (const ev of message.events) {
+              for (const listener of this.eventListeners) {
+                listener(ev);
+              }
+            }
+          }
+        } else if (label === "control") {
+          this.handleControlMessage(message);
+        }
+      };
+    }
+    handleControlMessage(message) {
+      if (message.type === "control" && message.command) {
+        for (const listener of this.controlListeners) {
+          listener(message.command);
+        }
+      } else if (message.type === "hello") {
+        this.remoteDeviceName = message.payload?.deviceName || "Mobile Device";
+        this.remotePlatform = message.payload?.platform || "mobile";
+        if (this.controlChannel?.readyState === "open") {
+          this.controlChannel.send(RemoteProtocol.serialize(RemoteProtocol.createHelloAck()));
+        }
+        this.updateDiagnostics();
+      } else if (message.type === "hello-ack") {
+        this.updateDiagnostics();
+      } else if (message.type === "ping") {
+        if (this.controlChannel?.readyState === "open") {
+          const pong = RemoteProtocol.createPong(message.timestamp || Date.now());
+          this.controlChannel.send(RemoteProtocol.serialize(pong));
+        }
+      } else if (message.type === "pong") {
+        const pingTime = message.payload?.pingTimestamp || message.timestamp;
+        if (pingTime) {
+          this.rttMs = Math.max(1, Date.now() - pingTime);
+          this.updateDiagnostics();
+        }
+      }
+    }
+    startTimers() {
+      this.stopTimers();
+      this.pingTimer = setInterval(() => {
+        if (this.controlChannel?.readyState === "open") {
+          this.controlChannel.send(RemoteProtocol.serialize(RemoteProtocol.createPing(Date.now())));
+        }
+      }, 2e3);
+      this.statsTimer = setInterval(() => {
+        this.queryWebRTCStats();
+      }, 3e3);
+    }
+    stopTimers() {
+      if (this.pingTimer) {
+        clearInterval(this.pingTimer);
+        this.pingTimer = null;
+      }
+      if (this.statsTimer) {
+        clearInterval(this.statsTimer);
+        this.statsTimer = null;
+      }
+    }
+    async queryWebRTCStats() {
+      if (!this.pc) return;
+      try {
+        const stats = await this.pc.getStats();
+        let candidateType = "unknown";
+        let protocol = "UDP";
+        let route = "unknown";
+        stats.forEach((report) => {
+          if (report.type === "candidate-pair" && (report.selected || report.state === "succeeded")) {
+            const localCandidate = stats.get(report.localCandidateId);
+            if (localCandidate) {
+              candidateType = localCandidate.candidateType || "host";
+              protocol = localCandidate.protocol || "UDP";
+              if (candidateType === "host") {
+                route = "direct / LAN";
+              } else if (candidateType === "srflx" || candidateType === "prflx") {
+                route = "STUN / WAN";
+              } else if (candidateType === "relay") {
+                route = "relay / TURN";
+              }
+            }
+            if (report.currentRoundTripTime) {
+              this.rttMs = Math.round(report.currentRoundTripTime * 1e3);
+            }
+          }
+        });
+        this.diagnostics = {
+          ...this.diagnostics,
+          candidateType,
+          protocol,
+          route
+        };
+        this.updateDiagnostics();
+      } catch {
+      }
+    }
+    setStatus(status) {
+      this.status = status;
+      this.updateDiagnostics();
+      for (const listener of this.statusListeners) {
+        listener(status);
+      }
+    }
+    updateDiagnostics() {
+      if (this.pc) {
+        this.diagnostics.connectionState = this.pc.connectionState;
+        this.diagnostics.iceConnectionState = this.pc.iceConnectionState;
+        this.diagnostics.iceGatheringState = this.pc.iceGatheringState;
+        this.diagnostics.signalingState = this.pc.signalingState;
+      }
+      const fullDiag = this.getDiagnostics();
+      for (const listener of this.diagnosticsListeners) {
+        listener(fullDiag);
+      }
+    }
+  }
+
+  class PairingHelper {
+    /**
+     * Creates a new pairing session with given TTL (default 5 minutes).
+     */
+    static createSession(ttlMs = 5 * 60 * 1e3) {
+      const now = Date.now();
+      return {
+        id: this.generateSessionId(),
+        createdAt: now,
+        expiresAt: now + ttlMs,
+        status: "waiting"
+      };
+    }
+    /**
+     * Generates a short, human-readable session ID (e.g. "K7P4-M2" or "7HQ2-9X").
+     */
+    static generateSessionId() {
+      const chars = "23456789ABCDEFGHJKLMNPQRSTUVWXYZ";
+      const bytes = this.getRandomBytes(4);
+      let id = "";
+      for (let i = 0; i < 4; i++) {
+        id += chars[bytes[i] % chars.length];
+      }
+      const suffix = this.getRandomBytes(2);
+      id += "-" + chars[suffix[0] % chars.length] + chars[suffix[1] % chars.length];
+      return id;
+    }
+    /**
+     * Generates a cryptographically strong 128-bit random secret string.
+     */
+    static generateSecret() {
+      const bytes = this.getRandomBytes(16);
+      return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+    }
+    /**
+     * Formats a web pairing URL where the secret is stored strictly in the URL fragment (#SECRET).
+     */
+    static formatPairingUrl(baseUrl, sessionId, secret) {
+      const cleanBase = baseUrl.replace(/\/+$/, "");
+      return `${cleanBase}/pair?s=${encodeURIComponent(sessionId)}#${secret}`;
+    }
+    /**
+     * Formats a Capacitor mobile deep link URL.
+     */
+    static formatDeepLinkUrl(sessionId, secret, signalingUrl) {
+      let url = `capdebug://pair?session=${encodeURIComponent(sessionId)}&secret=${encodeURIComponent(secret)}`;
+      if (signalingUrl) {
+        url += `&server=${encodeURIComponent(signalingUrl)}`;
+      }
+      return url;
+    }
+    /**
+     * Parses a web pairing URL or Capacitor deep-link URL into session and secret components.
+     */
+    static parseUrl(urlStr) {
+      if (!urlStr || typeof urlStr !== "string") return null;
+      try {
+        if (urlStr.startsWith("capdebug://")) {
+          const queryIdx = urlStr.indexOf("?");
+          if (queryIdx === -1) return null;
+          const search = urlStr.substring(queryIdx + 1);
+          const params = new URLSearchParams(search);
+          const sessionId2 = params.get("session") || params.get("s");
+          const secret2 = params.get("secret") || params.get("sec") || "";
+          const signalingUrl2 = params.get("server") || params.get("sig") || void 0;
+          if (sessionId2 && secret2) {
+            return { sessionId: sessionId2, secret: secret2, signalingUrl: signalingUrl2, rawUrl: urlStr };
+          }
+          return null;
+        }
+        const url = new URL(urlStr);
+        let sessionId = url.searchParams.get("s") || url.searchParams.get("session");
+        if (!sessionId && url.pathname.includes("/s/")) {
+          const parts = url.pathname.split("/s/");
+          if (parts[1]) {
+            sessionId = decodeURIComponent(parts[1].split("/")[0]);
+          }
+        }
+        let secret = url.hash.replace(/^#/, "");
+        if (!secret) {
+          secret = url.searchParams.get("secret") || url.searchParams.get("sec") || "";
+        }
+        const signalingUrl = url.searchParams.get("server") || `${url.protocol}//${url.host}`;
+        if (sessionId && secret) {
+          return {
+            sessionId: sessionId.trim(),
+            secret: secret.trim(),
+            signalingUrl,
+            rawUrl: urlStr
+          };
+        }
+        return null;
+      } catch {
+        return null;
+      }
+    }
+    static getRandomBytes(length) {
+      const bytes = new Uint8Array(length);
+      if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+        crypto.getRandomValues(bytes);
+      } else {
+        for (let i = 0; i < length; i++) {
+          bytes[i] = Math.floor(Math.random() * 256);
+        }
+      }
+      return bytes;
+    }
+  }
+
+  class RemoteManager {
+    transport;
+    store;
+    isListening = false;
+    eventListener = null;
+    constructor(store) {
+      this.store = store;
+      this.transport = new WebRTCTransport();
+      this.setupControlHandler();
+    }
+    get activeTransport() {
+      return this.transport;
+    }
+    async connect(config) {
+      this.startEventListener();
+      await this.transport.connect(config);
+    }
+    disconnect() {
+      this.transport.disconnect();
+      this.stopEventListener();
+    }
+    status() {
+      return this.transport.getStatus();
+    }
+    getDiagnostics() {
+      return this.transport.getDiagnostics();
+    }
+    async handlePairingUrl(url) {
+      const parsed = PairingHelper.parseUrl(url);
+      if (!parsed) {
+        console.warn("[CapDebug Remote] Invalid pairing URL:", url);
+        return false;
+      }
+      try {
+        await this.connect({
+          sessionId: parsed.sessionId,
+          secret: parsed.secret,
+          signalingUrl: parsed.signalingUrl,
+          isHost: false
+        });
+        return true;
+      } catch (err) {
+        console.error("[CapDebug Remote] Failed to connect via pairing URL:", err);
+        return false;
+      }
+    }
+    startEventListener() {
+      if (this.isListening || typeof window === "undefined") return;
+      this.eventListener = (event) => {
+        const customEvent = event;
+        if (customEvent.detail) {
+          this.transport.send(customEvent.detail);
+        }
+      };
+      window.addEventListener("capdebug", this.eventListener);
+      this.isListening = true;
+    }
+    stopEventListener() {
+      if (!this.isListening || typeof window === "undefined") return;
+      if (this.eventListener) {
+        window.removeEventListener("capdebug", this.eventListener);
+        this.eventListener = null;
+      }
+      this.isListening = false;
+    }
+    setupControlHandler() {
+      this.transport.onControl(async (cmd) => {
+        switch (cmd.type) {
+          case "pause":
+            this.store.pause();
+            break;
+          case "resume":
+            this.store.resume();
+            break;
+          case "clear":
+            this.store.clear();
+            break;
+          case "snapshot.request":
+            try {
+              const [device, memory, webView, app, network] = await Promise.allSettled([
+                CapDebugNative.getDeviceInfo(),
+                CapDebugNative.getMemoryInfo(),
+                CapDebugNative.getWebViewInfo(),
+                CapDebugNative.getAppInfo(),
+                CapDebugNative.getNetworkInfo()
+              ]);
+              const snapshot = {
+                device: device.status === "fulfilled" ? device.value : null,
+                memory: memory.status === "fulfilled" ? memory.value : null,
+                webView: webView.status === "fulfilled" ? webView.value : null,
+                app: app.status === "fulfilled" ? app.value : null,
+                network: network.status === "fulfilled" ? network.value : null
+              };
+              this.transport.send({
+                id: "diag_" + Date.now(),
+                timestamp: Date.now(),
+                source: "native",
+                type: "device.snapshot",
+                level: "info",
+                message: "Live native diagnostics snapshot",
+                data: snapshot
+              });
+            } catch (err) {
+              console.error("[CapDebug Remote] Failed snapshot:", err);
+            }
+            break;
+          case "disconnect":
+            this.disconnect();
+            break;
+        }
+      });
+    }
+  }
+
+  class DeepLinkHandler {
+    static parse(url) {
+      return PairingHelper.parseUrl(url);
+    }
+  }
+
   class CapDebugManager {
     store;
     viewerElement = null;
     isMounted = false;
+    remoteManager;
     customEventCollector;
     consoleCollector;
     errorCollector;
@@ -2386,6 +3237,7 @@ var capacitorCapDebug = (function (exports, core) {
     bridgeCollector;
     constructor() {
       this.store = new CapDebugStore();
+      this.remoteManager = new RemoteManager(this.store);
       this.customEventCollector = new CustomEventCollector(this.store);
       this.consoleCollector = new ConsoleCollector();
       this.errorCollector = new ErrorCollector();
@@ -2393,6 +3245,12 @@ var capacitorCapDebug = (function (exports, core) {
       this.browserEventCollector = new BrowserEventCollector();
       this.bridgeCollector = new BridgeCollector();
     }
+    get remote() {
+      return this.remoteManager;
+    }
+    async handlePairingUrl(url) {
+      return this.remoteManager.handlePairingUrl(url);
+    }
     get native() {
       return CapDebugNative;
     }
@@ -2634,9 +3492,17 @@ var capacitorCapDebug = (function (exports, core) {
   exports.ConsoleCollector = ConsoleCollector;
   exports.CustomEventCollector = CustomEventCollector;
   exports.DataSanitizer = DataSanitizer;
+  exports.DeepLinkHandler = DeepLinkHandler;
   exports.ErrorCollector = ErrorCollector;
+  exports.HttpSseSignalingClient = HttpSseSignalingClient;
   exports.JsonViewer = JsonViewer;
   exports.NetworkCollector = NetworkCollector;
+  exports.PROTOCOL_VERSION = PROTOCOL_VERSION;
+  exports.PairingHelper = PairingHelper;
+  exports.RemoteEventBuffer = RemoteEventBuffer;
+  exports.RemoteManager = RemoteManager;
+  exports.RemoteProtocol = RemoteProtocol;
+  exports.WebRTCTransport = WebRTCTransport;
   exports.default = CapDebug;
   exports.defaultSanitizer = defaultSanitizer;
   exports.registerCustomElement = registerCustomElement;