capdebug 0.2.0 → 0.3.0

package/dist/plugin.cjs.js

@@ -2377,10 +2377,861 @@ function registerCustomElement() {
   }
 }
 
+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;
@@ -2389,6 +3240,7 @@ class CapDebugManager {
   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();
@@ -2396,6 +3248,12 @@ class CapDebugManager {
     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;
   }
@@ -2637,9 +3495,17 @@ exports.CapDebugViewerElement = CapDebugViewerElement;
 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;