npm - dextunnel - Versions diffs - 0.1.0 - Mend

dextunnel 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (76) hide show

package/LICENSE +211 -0
package/README.md +112 -0
package/SECURITY.md +27 -0
package/SUPPORT.md +43 -0
package/package.json +44 -0
package/public/client-shared.js +1831 -0
package/public/favicon.svg +11 -0
package/public/host.html +29 -0
package/public/host.js +2079 -0
package/public/index.html +28 -0
package/public/index.js +98 -0
package/public/live-bridge-lifecycle.js +258 -0
package/public/live-bridge-retry-state.js +61 -0
package/public/live-selection-intent.js +79 -0
package/public/remote-operator-state.js +316 -0
package/public/remote.html +167 -0
package/public/remote.js +3967 -0
package/public/styles.css +2793 -0
package/public/surface-view-state.js +89 -0
package/public/voice-dictation.js +45 -0
package/src/bin/desktop-rehydration-smoke.mjs +111 -0
package/src/bin/dextunnel.mjs +41 -0
package/src/bin/doctor.mjs +48 -0
package/src/bin/launch-attest.mjs +39 -0
package/src/bin/launch-status.mjs +49 -0
package/src/bin/mobile-link-proxy.mjs +221 -0
package/src/bin/mobile-proof.mjs +164 -0
package/src/bin/mobile-transport-smoke.mjs +200 -0
package/src/bin/probe-codex-app-server-write.mjs +36 -0
package/src/bin/probe-codex-app-server.mjs +30 -0
package/src/lib/agent-room-context.mjs +54 -0
package/src/lib/agent-room-runtime.mjs +355 -0
package/src/lib/agent-room-service.mjs +335 -0
package/src/lib/agent-room-state.mjs +406 -0
package/src/lib/agent-room-store.mjs +71 -0
package/src/lib/agent-room-text.mjs +48 -0
package/src/lib/app-server-contract.mjs +66 -0
package/src/lib/app-server-runtime.mjs +60 -0
package/src/lib/attachment-service.mjs +119 -0
package/src/lib/bridge-api-handler.mjs +719 -0
package/src/lib/bridge-runtime-lifecycle.mjs +51 -0
package/src/lib/bridge-status-builder.mjs +60 -0
package/src/lib/codex-app-server-client.mjs +1511 -0
package/src/lib/companion-state.mjs +453 -0
package/src/lib/control-lease-service.mjs +180 -0
package/src/lib/debug-harness-service.mjs +173 -0
package/src/lib/desktop-integration.mjs +146 -0
package/src/lib/desktop-rehydration-smoke.mjs +269 -0
package/src/lib/dextunnel-cli.mjs +122 -0
package/src/lib/discovery-docs.mjs +1321 -0
package/src/lib/fake-codex-app-server-bridge.mjs +340 -0
package/src/lib/install-preflight.mjs +373 -0
package/src/lib/interaction-resolution-service.mjs +185 -0
package/src/lib/interaction-state.mjs +360 -0
package/src/lib/launch-release-bar.mjs +158 -0
package/src/lib/live-control-state.mjs +107 -0
package/src/lib/live-payload-builder.mjs +298 -0
package/src/lib/live-selection-transition-state.mjs +49 -0
package/src/lib/live-transcript-state.mjs +549 -0
package/src/lib/mobile-network-profile.mjs +39 -0
package/src/lib/mock-codex-adapter.mjs +62 -0
package/src/lib/operator-diagnostics.mjs +82 -0
package/src/lib/repo-changes-service.mjs +527 -0
package/src/lib/runtime-config.mjs +106 -0
package/src/lib/selection-state-service.mjs +214 -0
package/src/lib/session-store.mjs +355 -0
package/src/lib/shared-room-state.mjs +473 -0
package/src/lib/shared-selection-state.mjs +40 -0
package/src/lib/sse-hub.mjs +35 -0
package/src/lib/static-surface-service.mjs +71 -0
package/src/lib/surface-access.mjs +189 -0
package/src/lib/surface-presence-service.mjs +118 -0
package/src/lib/surface-request-guard.mjs +52 -0
package/src/lib/thread-sync-state.mjs +536 -0
package/src/lib/watcher-lifecycle.mjs +287 -0
package/src/server.mjs +1446 -0

package/public/index.html ADDED Viewed

@@ -0,0 +1,28 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta http-equiv="refresh" content="0; url=/">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>Dextunnel</title>
+    <link rel="icon" href="/favicon.svg" type="image/svg+xml">
+    <link rel="stylesheet" href="/styles.css">
+  </head>
+  <body class="landing-shell">
+    <main class="landing-grid">
+      <section class="panel hero-panel">
+        <p class="eyebrow">Dextunnel / remote</p>
+        <h1>Opening the Dextunnel remote.</h1>
+        <p class="lede">
+          The browser landing page has been retired. Dextunnel now opens the main remote surface at the root URL.
+        </p>
+        <div class="hero-actions">
+          <a class="cta" href="/">Open remote</a>
+        </div>
+      </section>
+    </main>
+    <script>
+      window.location.replace("/");
+    </script>
+  </body>
+</html>

package/public/index.js ADDED Viewed

@@ -0,0 +1,98 @@
+const nodes = {
+  badge: document.querySelector("#preflight-badge"),
+  checks: document.querySelector("#preflight-checks"),
+  nextSteps: document.querySelector("#preflight-next-steps"),
+  refresh: document.querySelector("#preflight-refresh"),
+  summary: document.querySelector("#preflight-summary")
+};
+function setBadge(status, label) {
+  if (!nodes.badge) {
+    return;
+  }
+  nodes.badge.textContent = label;
+  nodes.badge.className = "landing-status-badge";
+  nodes.badge.classList.add(`is-${status}`);
+}
+function setSummary(message) {
+  if (nodes.summary) {
+    nodes.summary.textContent = message;
+  }
+}
+function renderChecks(checks) {
+  if (!nodes.checks) {
+    return;
+  }
+  nodes.checks.textContent = "";
+  for (const check of checks || []) {
+    const article = document.createElement("article");
+    article.className = `preflight-card is-${check.severity || "warning"}`;
+    const label = document.createElement("p");
+    label.className = "preflight-card-label";
+    label.textContent = check.label || "Check";
+    const detail = document.createElement("p");
+    detail.className = "preflight-card-detail";
+    detail.textContent = check.detail || "";
+    article.append(label, detail);
+    nodes.checks.append(article);
+  }
+}
+function renderNextSteps(steps) {
+  if (!nodes.nextSteps) {
+    return;
+  }
+  nodes.nextSteps.textContent = "";
+  for (const step of steps || []) {
+    const item = document.createElement("li");
+    item.textContent = step;
+    nodes.nextSteps.append(item);
+  }
+}
+async function loadPreflight() {
+  setBadge("loading", "Checking");
+  setSummary("Running a local Dextunnel preflight...");
+  try {
+    const response = await fetch("/api/preflight?warmup=1", {
+      headers: {
+        Accept: "application/json"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`Preflight returned HTTP ${response.status}.`);
+    }
+    const payload = await response.json();
+    const status = payload.status || "warning";
+    setBadge(status, status === "ready" ? "Ready" : status === "error" ? "Needs attention" : "Almost there");
+    setSummary(payload.summary || "Preflight complete.");
+    renderChecks(payload.checks || []);
+    renderNextSteps(payload.nextSteps || []);
+  } catch (error) {
+    setBadge("error", "Unavailable");
+    setSummary(String(error?.message || error || "Failed to load the Dextunnel preflight."));
+    renderChecks([
+      {
+        detail: "Try reloading this page or run npm run doctor in the repo root.",
+        label: "Preflight",
+        severity: "error"
+      }
+    ]);
+  }
+}
+nodes.refresh?.addEventListener("click", () => {
+  void loadPreflight();
+});
+void loadPreflight();

package/public/live-bridge-lifecycle.js ADDED Viewed

@@ -0,0 +1,258 @@
+import {
+  planBootstrapRetry,
+  planStreamRecovery,
+  reconnectStreamState
+} from "./live-bridge-retry-state.js";
+export function createLiveBridgeLifecycleState({
+  bootstrapRetryBaseMs,
+  streamRecoveryBaseMs
+} = {}) {
+  return {
+    bootstrapPromise: null,
+    bootstrapRetryBackoffMs: bootstrapRetryBaseMs,
+    bootstrapRetryTimer: null,
+    refreshAfterStreamReconnect: false,
+    refreshPromise: null,
+    stream: null,
+    streamRecoveryBackoffMs: streamRecoveryBaseMs,
+    streamRecoveryTimer: null,
+    streamState: "connecting"
+  };
+}
+export function createLiveBridgeLifecycle({
+  state,
+  bootstrapRetry,
+  streamRecovery,
+  createEventSource,
+  createTimeout = (callback, delay) => window.setTimeout(callback, delay),
+  clearCreatedTimeout = (timer) => window.clearTimeout(timer),
+  getHasLiveState,
+  getVisible,
+  onBootstrapError,
+  onBootstrapStart,
+  onBootstrapSuccess,
+  onLive,
+  onRender = () => {},
+  onSnapshot,
+  onStreamError,
+  onStreamOpen,
+  requestBootstrap,
+  requestRefresh,
+  streamUrl
+}) {
+  if (!state) {
+    throw new Error("createLiveBridgeLifecycle requires a mutable state object.");
+  }
+  const lifecycle = {
+    bootstrap,
+    closeStream,
+    ensureStream,
+    resetBootstrapRetry,
+    resetStreamRecovery,
+    resumeVisible,
+    refresh
+  };
+  function resetStreamRecovery() {
+    if (state.streamRecoveryTimer) {
+      clearCreatedTimeout(state.streamRecoveryTimer);
+      state.streamRecoveryTimer = null;
+    }
+    state.streamRecoveryBackoffMs = streamRecovery.baseMs;
+  }
+  function resetBootstrapRetry() {
+    if (state.bootstrapRetryTimer) {
+      clearCreatedTimeout(state.bootstrapRetryTimer);
+      state.bootstrapRetryTimer = null;
+    }
+    state.bootstrapRetryBackoffMs = bootstrapRetry.baseMs;
+  }
+  function closeStream() {
+    if (!state.stream) {
+      return;
+    }
+    state.stream.close();
+    state.stream = null;
+  }
+  function scheduleBootstrapRetry() {
+    const plan = planBootstrapRetry({
+      backoffMs: state.bootstrapRetryBackoffMs,
+      baseMs: bootstrapRetry.baseMs,
+      hasTimer: Boolean(state.bootstrapRetryTimer),
+      isVisible: getVisible(),
+      maxMs: bootstrapRetry.maxMs
+    });
+    if (!plan.schedule) {
+      return;
+    }
+    state.bootstrapRetryBackoffMs = plan.nextBackoffMs;
+    state.bootstrapRetryTimer = createTimeout(() => {
+      state.bootstrapRetryTimer = null;
+      if (getVisible()) {
+        void lifecycle.bootstrap({ retrying: true });
+        lifecycle.ensureStream();
+      }
+    }, plan.delay);
+  }
+  function ensureStream({ force = false } = {}) {
+    if (state.stream && !force) {
+      return;
+    }
+    if (force) {
+      closeStream();
+    }
+    state.streamState = reconnectStreamState({ hasLiveState: getHasLiveState() });
+    const nextStream = createEventSource(streamUrl);
+    state.stream = nextStream;
+    nextStream.addEventListener("snapshot", (event) => {
+      if (state.stream !== nextStream) {
+        return;
+      }
+      onSnapshot(JSON.parse(event.data));
+      onRender();
+    });
+    nextStream.addEventListener("open", () => {
+      if (state.stream !== nextStream) {
+        return;
+      }
+      state.streamState = "live";
+      resetStreamRecovery();
+      onStreamOpen?.();
+      if (state.refreshAfterStreamReconnect) {
+        state.refreshAfterStreamReconnect = false;
+        void lifecycle.refresh({ background: true });
+      }
+      onRender();
+    });
+    nextStream.addEventListener("live", (event) => {
+      if (state.stream !== nextStream) {
+        return;
+      }
+      onLive(JSON.parse(event.data));
+      onRender();
+    });
+    nextStream.addEventListener("error", () => {
+      if (state.stream !== nextStream) {
+        return;
+      }
+      state.streamState = reconnectStreamState({ hasLiveState: getHasLiveState() });
+      closeStream();
+      onStreamError?.();
+      scheduleStreamRecovery();
+      onRender();
+    });
+  }
+  function scheduleStreamRecovery() {
+    const plan = planStreamRecovery({
+      backoffMs: state.streamRecoveryBackoffMs,
+      baseMs: streamRecovery.baseMs,
+      hasLiveState: getHasLiveState(),
+      hasTimer: Boolean(state.streamRecoveryTimer),
+      isVisible: getVisible(),
+      maxMs: streamRecovery.maxMs
+    });
+    if (!plan.schedule) {
+      state.streamState = plan.streamState;
+      return;
+    }
+    state.streamState = plan.streamState;
+    state.streamRecoveryBackoffMs = plan.nextBackoffMs;
+    state.streamRecoveryTimer = createTimeout(() => {
+      state.streamRecoveryTimer = null;
+      if (!getVisible()) {
+        return;
+      }
+      state.refreshAfterStreamReconnect = plan.followupAction === "refresh";
+      lifecycle.ensureStream({ force: true });
+      if (plan.followupAction === "bootstrap") {
+        void lifecycle.bootstrap({ retrying: true });
+      }
+    }, plan.delay);
+  }
+  async function bootstrap({ retrying = false } = {}) {
+    if (state.bootstrapPromise) {
+      return state.bootstrapPromise;
+    }
+    onBootstrapStart?.({ retrying });
+    onRender();
+    state.bootstrapPromise = requestBootstrap()
+      .then(({ snapshot, live }) => {
+        onBootstrapSuccess({ live, retrying, snapshot });
+        state.streamState = "live";
+        resetBootstrapRetry();
+        onRender();
+        return live;
+      })
+      .catch((error) => {
+        state.streamState = reconnectStreamState({ hasLiveState: getHasLiveState() });
+        onBootstrapError?.({ error, retrying });
+        onRender();
+        scheduleBootstrapRetry();
+        return null;
+      })
+      .finally(() => {
+        state.bootstrapPromise = null;
+      });
+    return state.bootstrapPromise;
+  }
+  async function refresh({ background = false } = {}) {
+    if (state.refreshPromise) {
+      return state.refreshPromise;
+    }
+    state.refreshPromise = Promise.resolve()
+      .then(() => requestRefresh({ background }))
+      .catch((error) => {
+        if (background) {
+          return null;
+        }
+        throw error;
+      })
+      .finally(() => {
+        state.refreshPromise = null;
+      });
+    return state.refreshPromise;
+  }
+  function resumeVisible() {
+    if (!getVisible()) {
+      return;
+    }
+    lifecycle.ensureStream();
+    if (!getHasLiveState()) {
+      void lifecycle.bootstrap({ retrying: true });
+    }
+  }
+  return lifecycle;
+}

package/public/live-bridge-retry-state.js ADDED Viewed

@@ -0,0 +1,61 @@
+export function nextBackoffDelay(currentMs, { baseMs, maxMs }) {
+  const delay = Number.isFinite(currentMs) && currentMs > 0 ? currentMs : baseMs;
+  return {
+    delay,
+    nextMs: Math.min(delay * 2, maxMs)
+  };
+}
+export function shouldScheduleRetry({ hasTimer = false, isVisible = true } = {}) {
+  return !hasTimer && Boolean(isVisible);
+}
+export function reconnectStreamState({ hasLiveState = false } = {}) {
+  return hasLiveState ? "recovering" : "connecting";
+}
+export function planBootstrapRetry({
+  backoffMs,
+  baseMs,
+  maxMs,
+  hasTimer = false,
+  isVisible = true
+} = {}) {
+  if (!shouldScheduleRetry({ hasTimer, isVisible })) {
+    return {
+      schedule: false
+    };
+  }
+  const next = nextBackoffDelay(backoffMs, { baseMs, maxMs });
+  return {
+    delay: next.delay,
+    nextBackoffMs: next.nextMs,
+    schedule: true
+  };
+}
+export function planStreamRecovery({
+  backoffMs,
+  baseMs,
+  maxMs,
+  hasLiveState = false,
+  hasTimer = false,
+  isVisible = true
+} = {}) {
+  if (!shouldScheduleRetry({ hasTimer, isVisible })) {
+    return {
+      schedule: false,
+      streamState: reconnectStreamState({ hasLiveState })
+    };
+  }
+  const next = nextBackoffDelay(backoffMs, { baseMs, maxMs });
+  return {
+    delay: next.delay,
+    followupAction: hasLiveState ? "refresh" : "bootstrap",
+    nextBackoffMs: next.nextMs,
+    schedule: true,
+    streamState: reconnectStreamState({ hasLiveState })
+  };
+}

package/public/live-selection-intent.js ADDED Viewed

@@ -0,0 +1,79 @@
+export function createSelectionIntent({
+  cwd = null,
+  projectLabel = "",
+  source = "remote",
+  threadId = null,
+  threadLabel = ""
+} = {}) {
+  return {
+    projectLabel: String(projectLabel || "").trim(),
+    requestedCwd: String(cwd || "").trim(),
+    requestedThreadId: String(threadId || "").trim(),
+    source: String(source || "remote").trim() || "remote",
+    threadLabel: String(threadLabel || "").trim()
+  };
+}
+export function selectionIntentSatisfied(intent = null, liveState = null) {
+  if (!intent) {
+    return true;
+  }
+  const requestedThreadId = String(intent.requestedThreadId || "").trim();
+  const requestedCwd = String(intent.requestedCwd || "").trim();
+  const selectedThreadId = String(liveState?.selectedThreadId || "").trim();
+  const selectedCwd = String(liveState?.selectedProjectCwd || "").trim();
+  if (requestedThreadId) {
+    return selectedThreadId === requestedThreadId;
+  }
+  if (requestedCwd) {
+    return selectedCwd === requestedCwd;
+  }
+  return true;
+}
+export function selectionIntentMessage(intent = null, fallback = "Switching shared room...") {
+  if (!intent) {
+    return fallback;
+  }
+  if (intent.threadLabel) {
+    return `Switching to ${intent.threadLabel}...`;
+  }
+  if (intent.projectLabel) {
+    return `Switching to ${intent.projectLabel}...`;
+  }
+  return fallback;
+}
+export function selectionIntentTitle(intent = null) {
+  if (!intent) {
+    return "";
+  }
+  const threadLabel = String(intent.threadLabel || "").trim();
+  if (!threadLabel) {
+    return "";
+  }
+  const normalized = threadLabel
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+  return normalized ? `#${normalized}` : "";
+}
+export function reconcileSelectionIntent(intent = null, liveState = null) {
+  const settled = selectionIntentSatisfied(intent, liveState);
+  return {
+    intent: settled ? null : intent,
+    settled
+  };
+}