dsh-plugin-dshm 0.0.0-stage → 0.1.0

package/lib/client.js

@@ -0,0 +1,419 @@
+window.__ModuleLoader__.load({id:"dsh-plugin-dshm",factory(require){const module={exports:{}};const exports=module.exports;
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/projection/client.mjs
+var client_exports = {};
+__export(client_exports, {
+  apply: () => apply,
+  inject: () => inject
+});
+module.exports = __toCommonJS(client_exports);
+var React = __toESM(require("react"), 1);
+var primitives = __toESM(require("@deepseek-ai/dsh-client-ui-primitives"), 1);
+
+// src/ui/copy.mjs
+function languageFor(hostLanguage, browserLanguage) {
+  const language = typeof hostLanguage === "string" && hostLanguage.trim() ? hostLanguage : browserLanguage;
+  return /^zh(?:[-_]|$)/i.test(language ?? "") ? "zh-CN" : "en";
+}
+var readLanguage = () => languageFor(globalThis.document?.documentElement.lang, globalThis.navigator?.language);
+function subscribeLanguage(listener) {
+  const element = globalThis.document?.documentElement;
+  const observer = element && typeof MutationObserver !== "undefined" ? new MutationObserver(listener) : void 0;
+  observer?.observe(element, { attributes: true, attributeFilter: ["lang"] });
+  globalThis.addEventListener?.("languagechange", listener);
+  return () => {
+    observer?.disconnect();
+    globalThis.removeEventListener?.("languagechange", listener);
+  };
+}
+function useCopy(React2) {
+  const language = React2.useSyncExternalStore(subscribeLanguage, readLanguage, () => "en");
+  return { language, copy: copies[language] };
+}
+var copies = {
+  en: {
+    intro: "Phone not on the same Wi-Fi as this computer? Use Tailscale. On the same Wi-Fi, nothing else is needed.",
+    step1: "Connect this computer",
+    step2: "Connect your iPhone or iPad",
+    "step2.detail": "Install Tailscale, sign in to the same account, and connect.",
+    step3: "Pair with a fresh code",
+    "step3.detail": "Connect Tailscale on both devices first. Paired on Wi-Fi before? Forget the computer in DSHM, revoke the old device below, then pair here.",
+    "step3.check": "Test with your phone on cellular or a different Wi-Fi.",
+    "button.pairRemote": "Pair for remote access",
+    "button.open": "Open Tailscale",
+    "button.check": "Check again",
+    away: "Not on the same Wi-Fi",
+    states: {
+      "not-installed": ["Install Tailscale on this computer", "Use the official installer, then check again."],
+      "needs-login": ["Sign in to Tailscale", "Open Tailscale and finish signing in."],
+      "needs-approval": ["Waiting for approval", "Ask your Tailscale admin to approve this computer."],
+      stopped: ["Tailscale is disconnected", "Open Tailscale and choose Connect."],
+      starting: ["Tailscale is starting", "Check again in a moment."],
+      offline: ["Tailscale is offline", "Check this computer's internet connection."],
+      unavailable: ["Couldn't check Tailscale", "Open Tailscale, then check again."],
+      unsupported: ["Set up your VPN manually", "Automatic checks support Windows and macOS. Same-network pairing still works."],
+      "bridge-not-ready": ["Tailscale connected, DSHM not ready yet", "Check again in a few seconds. If it persists, check the firewall."],
+      ready: ["Ready for remote pairing", "No phone has connected over Tailscale yet."],
+      connected: ["Phone connected over Tailscale", ""]
+    },
+    "409": "Connect Tailscale on this computer, check again, then make a new code.",
+    requestError: "DSHM could not complete this request. Try again.",
+    bridgeError: "The bridge is unavailable. Check the host, then retry.",
+    setupError: "Could not check remote setup. Check the host and retry. Local pairing is still available.",
+    openError: "Could not open Tailscale on the host. Open it from the Start menu or Applications, then check again.",
+    checkingTailscale: "Checking Tailscale\u2026",
+    unavailableStatus: "Status unavailable",
+    opening: "Opening\u2026",
+    checking: "Checking\u2026",
+    getComputer: "Get Tailscale for this computer",
+    getPhone: "Get Tailscale for iPhone or iPad",
+    installDetail: "Run the installer on the computer running DSH. Complete installation and sign-in yourself; canceling leaves local pairing available.",
+    opened: "Tailscale was opened on the host. Complete sign-in or choose Connect there, then return here.",
+    cardLabel: "DSHM remote access",
+    connectedCount: (count) => `${count} connected`,
+    listening: "Listening",
+    noNetwork: "No private network",
+    loading: "Loading bridge\u2026",
+    working: "Working\u2026",
+    pair: "Pair a device",
+    retry: "Retry",
+    qrLabel: "Pairing QR code",
+    scan: "Scan with your iPhone",
+    qrAlt: "DSHM one-use pairing QR code",
+    expires: (time) => `Expires in ${time}`,
+    cancelPair: "Cancel pairing",
+    guidanceMac: "Allow DeepSeek Harness under System Settings \u2192 Privacy & Security \u2192 Local Network. If you run dsh web in a terminal, allow that terminal too.",
+    guidanceWindows: "Allow DeepSeek Harness on Private networks when Windows Firewall asks. Keep Public networks disabled.",
+    bonjour: "Bonjour is unavailable on this network. Pairing still includes the host\u2019s direct addresses.",
+    closeSetup: "Close remote setup",
+    openSetup: "Set up remote access",
+    devices: "Paired devices",
+    viaTailscale: "Connected via Tailscale",
+    viaLAN: "Connected via local network",
+    connected: "Connected",
+    offline: "Offline",
+    lastSeen: (date) => `Last seen ${date}`,
+    notConnected: "Not connected yet",
+    revokeQuestion: (name) => `Revoke ${name}?`,
+    cancel: "Cancel",
+    revokeDevice: "Revoke device",
+    revoke: "Revoke",
+    noDevices: "No paired devices."
+  },
+  "zh-CN": {
+    intro: "\u624B\u673A\u548C\u8FD9\u53F0\u7535\u8111\u4E0D\u5728\u540C\u4E00 Wi-Fi\uFF1F\u4F7F\u7528 Tailscale\u3002\u5728\u540C\u4E00 Wi-Fi \u4E0B\u65E0\u9700\u5176\u4ED6\u8BBE\u7F6E\u3002",
+    step1: "\u8FDE\u63A5\u8FD9\u53F0\u7535\u8111",
+    step2: "\u8FDE\u63A5 iPhone \u6216 iPad",
+    "step2.detail": "\u5B89\u88C5 Tailscale\uFF0C\u767B\u5F55\u540C\u4E00\u8D26\u6237\u5E76\u8FDE\u63A5\u3002",
+    step3: "\u7528\u65B0\u7684\u914D\u5BF9\u7801\u914D\u5BF9",
+    "step3.detail": "\u8BF7\u5148\u5728\u4E24\u53F0\u8BBE\u5907\u4E0A\u8FDE\u63A5 Tailscale\u3002\u4E4B\u524D\u5728 Wi-Fi \u4E0B\u914D\u5BF9\u8FC7\uFF1F\u5728 DSHM \u4E2D\u79FB\u9664\u8FD9\u53F0\u7535\u8111\uFF0C\u5728\u4E0B\u65B9\u64A4\u9500\u65E7\u8BBE\u5907\uFF0C\u7136\u540E\u5728\u6B64\u91CD\u65B0\u914D\u5BF9\u3002",
+    "step3.check": "\u8BF7\u8BA9\u624B\u673A\u4F7F\u7528\u8702\u7A9D\u7F51\u7EDC\u6216\u5176\u4ED6 Wi-Fi \u8FDB\u884C\u6D4B\u8BD5\u3002",
+    "button.pairRemote": "\u914D\u5BF9\u4EE5\u8FDC\u7A0B\u8BBF\u95EE",
+    "button.open": "\u6253\u5F00 Tailscale",
+    "button.check": "\u518D\u6B21\u68C0\u67E5",
+    away: "\u4E0D\u5728\u540C\u4E00 Wi-Fi",
+    states: {
+      "not-installed": ["\u5728\u8FD9\u53F0\u7535\u8111\u4E0A\u5B89\u88C5 Tailscale", "\u4F7F\u7528\u5B98\u65B9\u5B89\u88C5\u7A0B\u5E8F\uFF0C\u7136\u540E\u518D\u6B21\u68C0\u67E5\u3002"],
+      "needs-login": ["\u767B\u5F55 Tailscale", "\u6253\u5F00 Tailscale \u5E76\u5B8C\u6210\u767B\u5F55\u3002"],
+      "needs-approval": ["\u7B49\u5F85\u6279\u51C6", "\u8BF7 Tailscale \u7BA1\u7406\u5458\u6279\u51C6\u8FD9\u53F0\u7535\u8111\u3002"],
+      stopped: ["Tailscale \u672A\u8FDE\u63A5", "\u6253\u5F00 Tailscale \u5E76\u9009\u62E9\u201C\u8FDE\u63A5\u201D\u3002"],
+      starting: ["Tailscale \u6B63\u5728\u542F\u52A8", "\u8BF7\u7A0D\u540E\u518D\u6B21\u68C0\u67E5\u3002"],
+      offline: ["Tailscale \u79BB\u7EBF", "\u8BF7\u68C0\u67E5\u8FD9\u53F0\u7535\u8111\u7684\u7F51\u7EDC\u8FDE\u63A5\u3002"],
+      unavailable: ["\u65E0\u6CD5\u68C0\u67E5 Tailscale", "\u6253\u5F00 Tailscale \u540E\u518D\u6B21\u68C0\u67E5\u3002"],
+      unsupported: ["\u8BF7\u624B\u52A8\u8BBE\u7F6E VPN", "\u81EA\u52A8\u68C0\u67E5\u4EC5\u652F\u6301 Windows \u548C macOS\u3002\u540C\u4E00\u7F51\u7EDC\u914D\u5BF9\u4ECD\u53EF\u4F7F\u7528\u3002"],
+      "bridge-not-ready": ["Tailscale \u5DF2\u8FDE\u63A5\uFF0CDSHM \u5C1A\u672A\u5C31\u7EEA", "\u8BF7\u51E0\u79D2\u540E\u518D\u6B21\u68C0\u67E5\u3002\u5982\u6301\u7EED\u51FA\u73B0\uFF0C\u8BF7\u68C0\u67E5\u9632\u706B\u5899\u3002"],
+      ready: ["\u53EF\u4EE5\u8FDC\u7A0B\u914D\u5BF9", "\u5C1A\u65E0\u624B\u673A\u901A\u8FC7 Tailscale \u8FDE\u63A5\u3002"],
+      connected: ["\u624B\u673A\u5DF2\u901A\u8FC7 Tailscale \u8FDE\u63A5", ""]
+    },
+    "409": "\u8BF7\u5728\u8FD9\u53F0\u7535\u8111\u4E0A\u8FDE\u63A5 Tailscale\uFF0C\u518D\u6B21\u68C0\u67E5\u540E\u751F\u6210\u65B0\u7684\u914D\u5BF9\u7801\u3002",
+    requestError: "DSHM \u65E0\u6CD5\u5B8C\u6210\u6B64\u8BF7\u6C42\uFF0C\u8BF7\u91CD\u8BD5\u3002",
+    bridgeError: "\u6865\u63A5\u4E0D\u53EF\u7528\uFF0C\u8BF7\u68C0\u67E5\u7535\u8111\u540E\u91CD\u8BD5\u3002",
+    setupError: "\u65E0\u6CD5\u68C0\u67E5\u8FDC\u7A0B\u8BBE\u7F6E\uFF0C\u8BF7\u68C0\u67E5\u7535\u8111\u540E\u91CD\u8BD5\u3002\u5C40\u57DF\u7F51\u914D\u5BF9\u4ECD\u53EF\u4F7F\u7528\u3002",
+    openError: "\u65E0\u6CD5\u5728\u7535\u8111\u4E0A\u6253\u5F00 Tailscale\u3002\u8BF7\u4ECE\u201C\u5F00\u59CB\u201D\u83DC\u5355\u6216\u201C\u5E94\u7528\u7A0B\u5E8F\u201D\u4E2D\u6253\u5F00\uFF0C\u7136\u540E\u518D\u6B21\u68C0\u67E5\u3002",
+    checkingTailscale: "\u6B63\u5728\u68C0\u67E5 Tailscale\u2026",
+    unavailableStatus: "\u72B6\u6001\u4E0D\u53EF\u7528",
+    opening: "\u6B63\u5728\u6253\u5F00\u2026",
+    checking: "\u6B63\u5728\u68C0\u67E5\u2026",
+    getComputer: "\u83B7\u53D6\u7535\u8111\u7248 Tailscale",
+    getPhone: "\u83B7\u53D6 iPhone \u6216 iPad \u7248 Tailscale",
+    installDetail: "\u8BF7\u5728\u8FD0\u884C DSH \u7684\u7535\u8111\u4E0A\u5B89\u88C5\uFF0C\u5E76\u4EB2\u81EA\u5B8C\u6210\u5B89\u88C5\u548C\u767B\u5F55\u3002\u53D6\u6D88\u540E\u4ECD\u53EF\u5728\u5C40\u57DF\u7F51\u914D\u5BF9\u3002",
+    opened: "\u5DF2\u5728\u7535\u8111\u4E0A\u6253\u5F00 Tailscale\u3002\u8BF7\u5B8C\u6210\u767B\u5F55\u6216\u9009\u62E9\u201C\u8FDE\u63A5\u201D\uFF0C\u7136\u540E\u8FD4\u56DE\u6B64\u5904\u3002",
+    cardLabel: "DSHM \u8FDC\u7A0B\u8BBF\u95EE",
+    connectedCount: (count) => `${count} \u53F0\u8BBE\u5907\u5DF2\u8FDE\u63A5`,
+    listening: "\u6B63\u5728\u76D1\u542C",
+    noNetwork: "\u6CA1\u6709\u79C1\u6709\u7F51\u7EDC",
+    loading: "\u6B63\u5728\u52A0\u8F7D\u6865\u63A5\u2026",
+    working: "\u6B63\u5728\u5904\u7406\u2026",
+    pair: "\u914D\u5BF9\u8BBE\u5907",
+    retry: "\u91CD\u8BD5",
+    qrLabel: "\u914D\u5BF9\u4E8C\u7EF4\u7801",
+    scan: "\u7528 iPhone \u626B\u63CF",
+    qrAlt: "DSHM \u4E00\u6B21\u6027\u914D\u5BF9\u4E8C\u7EF4\u7801",
+    expires: (time) => `${time} \u540E\u8FC7\u671F`,
+    cancelPair: "\u53D6\u6D88\u914D\u5BF9",
+    guidanceMac: "\u8BF7\u5728\u201C\u7CFB\u7EDF\u8BBE\u7F6E \u2192 \u9690\u79C1\u4E0E\u5B89\u5168\u6027 \u2192 \u672C\u5730\u7F51\u7EDC\u201D\u4E2D\u5141\u8BB8 DeepSeek Harness\u3002\u5982\u679C\u5728\u7EC8\u7AEF\u8FD0\u884C dsh web\uFF0C\u4E5F\u8BF7\u5141\u8BB8\u8BE5\u7EC8\u7AEF\u3002",
+    guidanceWindows: "Windows \u9632\u706B\u5899\u8BE2\u95EE\u65F6\uFF0C\u8BF7\u5141\u8BB8 DeepSeek Harness \u8BBF\u95EE\u4E13\u7528\u7F51\u7EDC\uFF0C\u5E76\u4FDD\u6301\u516C\u7528\u7F51\u7EDC\u7981\u7528\u3002",
+    bonjour: "\u6B64\u7F51\u7EDC\u4E0A\u7684 Bonjour \u4E0D\u53EF\u7528\uFF0C\u914D\u5BF9\u4ECD\u5305\u542B\u7535\u8111\u7684\u76F4\u63A5\u8FDE\u63A5\u5730\u5740\u3002",
+    closeSetup: "\u5173\u95ED\u8FDC\u7A0B\u8BBE\u7F6E",
+    openSetup: "\u8BBE\u7F6E\u8FDC\u7A0B\u8BBF\u95EE",
+    devices: "\u5DF2\u914D\u5BF9\u8BBE\u5907",
+    viaTailscale: "\u5DF2\u901A\u8FC7 Tailscale \u8FDE\u63A5",
+    viaLAN: "\u5DF2\u901A\u8FC7\u5C40\u57DF\u7F51\u8FDE\u63A5",
+    connected: "\u5DF2\u8FDE\u63A5",
+    offline: "\u79BB\u7EBF",
+    lastSeen: (date) => `\u4E0A\u6B21\u8FDE\u63A5\uFF1A${date}`,
+    notConnected: "\u5C1A\u672A\u8FDE\u63A5",
+    revokeQuestion: (name) => `\u64A4\u9500 ${name} \u7684\u8BBF\u95EE\u6743\u9650\uFF1F`,
+    cancel: "\u53D6\u6D88",
+    revokeDevice: "\u64A4\u9500\u8BBE\u5907",
+    revoke: "\u64A4\u9500",
+    noDevices: "\u6CA1\u6709\u5DF2\u914D\u5BF9\u8BBE\u5907\u3002"
+  }
+};
+function guidanceCopy(text, copy) {
+  for (const key of ["guidanceMac", "guidanceWindows"]) if (text === copies.en[key]) return copy[key];
+  return text;
+}
+
+// src/ui/remote-setup.mjs
+var install = { macos: "https://tailscale.com/docs/install/mac", windows: "https://tailscale.com/docs/install/windows", other: "https://tailscale.com/docs/install" };
+function setupPresentation(status, copy = copies.en) {
+  if (!status) return { title: copy.checkingTailscale, detail: "", ready: false };
+  const ready = status.state === "running" && Boolean(status.bridgeListening);
+  const state = status.state !== "running" ? status.state : !ready ? "bridge-not-ready" : status.connectedDevices > 0 ? "connected" : "ready";
+  const [title, detail] = Object.hasOwn(copy.states, state) ? copy.states[state] : copy.states.unavailable;
+  return { title, detail, ready };
+}
+function createRemoteSetup(React2, { Button }) {
+  const h = React2.createElement;
+  const link = (href, label) => h("a", { className: "dshm-link-button", href, target: "_blank", rel: "noopener noreferrer" }, label, " \u2197");
+  return function RemoteSetup({ api, onPair, pairingBusy, copy }) {
+    const [status, setStatus] = React2.useState(null), [error, setError] = React2.useState("");
+    const [busy, setBusy] = React2.useState(false), [opened, setOpened] = React2.useState(false), [checking, setChecking] = React2.useState(false);
+    const live = React2.useRef(true), pending = React2.useRef(false);
+    const check = async (manual = false) => {
+      if (pending.current) return;
+      pending.current = true;
+      if (manual) setChecking(true);
+      try {
+        const value = await api("remoteSetup");
+        if (live.current) {
+          setStatus(value);
+          setError("");
+        }
+      } catch {
+        if (live.current) {
+          setStatus(null);
+          setError("setupError");
+        }
+      } finally {
+        pending.current = false;
+        if (live.current) setChecking(false);
+      }
+    };
+    React2.useEffect(() => {
+      live.current = true;
+      void check();
+      const timer = setInterval(() => {
+        void check();
+      }, 5e3);
+      return () => {
+        live.current = false;
+        clearInterval(timer);
+      };
+    }, []);
+    const open = async () => {
+      if (busy) return;
+      setBusy(true);
+      setError("");
+      setOpened(false);
+      try {
+        await api("openTailscale", {});
+        if (live.current) setOpened(true);
+      } catch {
+        if (live.current) setError("openError");
+      } finally {
+        if (live.current) setBusy(false);
+      }
+    };
+    const view = setupPresentation(status, copy);
+    return h(
+      "div",
+      { className: "dshm-panel", id: "dshm-remote-setup" },
+      h("p", null, copy.intro),
+      h(
+        "ol",
+        { className: "dshm-setup-steps" },
+        h(
+          "li",
+          null,
+          h("h3", null, copy.step1),
+          h("p", { role: "status", "aria-live": "polite", "aria-atomic": true }, error && !status ? copy.unavailableStatus : view.title),
+          view.detail ? h("p", null, view.detail) : null,
+          h(
+            "div",
+            { className: "dshm-actions" },
+            status?.state === "not-installed" || status?.state === "unsupported" ? link(install[status.platform] ?? install.other, copy.getComputer) : null,
+            // Keep keyboard focus during short requests; handlers prevent repeats.
+            status?.canOpenApp ? h(Button, { variant: "outline", "aria-disabled": busy, "aria-busy": busy, onClick: open }, busy ? copy.opening : copy["button.open"]) : null,
+            h(Button, { variant: "outline", "aria-disabled": busy || checking, "aria-busy": checking, onClick: () => {
+              if (!busy) void check(true);
+            } }, checking ? copy.checking : copy["button.check"])
+          ),
+          status?.state === "not-installed" ? h("p", null, copy.installDetail) : null,
+          opened ? h("p", { role: "status" }, copy.opened) : null
+        ),
+        h(
+          "li",
+          null,
+          h("h3", null, copy.step2),
+          h("p", null, copy["step2.detail"]),
+          link("https://tailscale.com/docs/install/ios", copy.getPhone)
+        ),
+        h(
+          "li",
+          null,
+          h("h3", null, copy.step3),
+          h("p", null, copy["step3.detail"]),
+          h(Button, { variant: "primary", disabled: !view.ready || pairingBusy, onClick: onPair }, copy["button.pairRemote"]),
+          h("p", null, copy["step3.check"])
+        )
+      ),
+      error ? h("p", { className: "dshm-error", role: "alert" }, copy[error]) : null
+    );
+  };
+}
+
+// src/ui/card.mjs
+function createSettingsCard(React2, { Button }, apiBase) {
+  const h = React2.createElement;
+  const RemoteSetup = createRemoteSetup(React2, { Button });
+  const icon = (kind) => h("svg", { width: 18, height: 18, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: 1.8, "aria-hidden": true }, h("path", { d: kind === "pair" ? "M4 4h6v6H4zM14 4h6v6h-6zM4 14h6v6H4zM14 14h2v2h-2zM18 14h2v6h-6v-2" : "M5 7h14M9 7V4h6v3M7 7l1 13h8l1-13M10 10v7M14 10v7" }));
+  const style = `.dshm-card{color:var(--dsw-alias-label-primary);font:inherit;font-size:16px;line-height:1.5;display:grid;gap:24px}.dshm-card h2,.dshm-card h3,.dshm-card p{margin:0}.dshm-card h2{font-size:20px}.dshm-card h3{font-size:16px}.dshm-card button{min-height:44px;gap:8px}.dshm-card button:focus-visible,.dshm-link-button:focus-visible{outline:2px solid var(--dsw-alias-label-primary);outline-offset:3px}.dshm-row{display:flex;align-items:center;justify-content:space-between;gap:16px;flex-wrap:wrap}.dshm-muted{color:var(--dsw-alias-label-secondary);font-size:14px}.dshm-panel{padding:16px;border:1px solid var(--dsw-alias-border-primary,currentColor);border-radius:var(--dsw-radius-md,12px);display:grid;gap:12px}.dshm-qr{display:block;width:256px;max-width:100%;height:auto;background:white;border-radius:8px}.dshm-devices{list-style:none;margin:0;padding:0;display:grid;gap:12px}.dshm-device{padding:14px 0;border-bottom:1px solid var(--dsw-alias-border-primary,currentColor)}.dshm-actions{display:flex;gap:8px;flex-wrap:wrap}.dshm-setup-steps{margin:0;padding-left:24px;display:grid;gap:24px}.dshm-setup-steps li{display:grid;gap:12px;min-width:0}.dshm-link-button{display:inline-flex;align-items:center;min-height:44px;padding:8px 12px;border:1px solid var(--dsw-alias-border-primary,currentColor);border-radius:var(--dsw-radius-md,12px);color:inherit;text-decoration:underline;box-sizing:border-box}.dshm-error{color:var(--dsw-alias-danger-label,#b42318)}.dshm-guidance{padding:14px 16px;background:var(--dsw-alias-bg-layer-3);border-radius:var(--dsw-radius-md,12px)}@media(max-width:480px){.dshm-row{align-items:flex-start}.dshm-qr{width:224px}}`;
+  return function SettingsCard2() {
+    const { language, copy } = useCopy(React2);
+    const [status, setStatus] = React2.useState(null), [devices, setDevices] = React2.useState([]);
+    const [pairing, setPairing] = React2.useState(null), [busy, setBusy] = React2.useState(false);
+    const [error, setError] = React2.useState(""), [confirm, setConfirm] = React2.useState(null), [now, setNow] = React2.useState(Date.now());
+    const [remoteOpen, setRemoteOpen] = React2.useState(false);
+    const pairPanel = React2.useRef(null);
+    React2.useEffect(() => {
+      if (pairing) pairPanel.current?.focus();
+    }, [pairing?.expiresAt]);
+    const api = async (route, body) => {
+      const response = await fetch(`${apiBase}/${route}`, { method: body === void 0 ? "GET" : "POST", credentials: "same-origin", cache: "no-store", headers: body === void 0 ? {} : { "Content-Type": "application/json" }, body: body === void 0 ? void 0 : JSON.stringify(body), signal: AbortSignal.timeout(6e3) });
+      if (!response.ok) throw new Error(route === "pairRemote" && response.status === 409 ? "409" : "requestError");
+      return response.json();
+    };
+    const refresh = async () => {
+      const [next, list] = await Promise.all([api("status"), api("devices")]);
+      setStatus(next);
+      setDevices(list.devices);
+      if (!next.pairing.active) setPairing(null);
+    };
+    React2.useEffect(() => {
+      let live = true;
+      const poll = async () => {
+        try {
+          const [next, list] = await Promise.all([api("status"), api("devices")]);
+          if (live) {
+            setStatus(next);
+            setDevices(list.devices);
+            if (!next.pairing.active) setPairing(null);
+          }
+        } catch {
+          if (live) setError("bridgeError");
+        }
+      };
+      void poll();
+      const timer = setInterval(poll, 2e3), clock = setInterval(() => setNow(Date.now()), 1e3);
+      return () => {
+        live = false;
+        clearInterval(timer);
+        clearInterval(clock);
+      };
+    }, []);
+    const action = async (work) => {
+      setBusy(true);
+      setError("");
+      try {
+        await work();
+        await refresh();
+      } catch (failure) {
+        setError(failure.message);
+      } finally {
+        setBusy(false);
+      }
+    };
+    const seconds = pairing ? Math.max(0, Math.ceil((Date.parse(pairing.expiresAt) - now) / 1e3)) : 0;
+    const button = (label, onClick, variant = "outline", glyph) => h(Button, { variant, disabled: busy, onClick }, glyph ? icon(glyph) : null, label);
+    return h(
+      "section",
+      { className: "dshm-card", "aria-label": copy.cardLabel, lang: language },
+      h("style", null, style),
+      h("div", { className: "dshm-row" }, h("div", null, h("h2", null, "DSHM"), h("p", { className: "dshm-muted" }, status ? `${copy.connectedCount(status.connectedDevices)} \xB7 ${status.addresses.length ? copy.listening : copy.noNetwork}` : copy.loading)), button(busy ? copy.working : copy.pair, () => action(async () => {
+        const next = await api("pair", {});
+        setNow(Date.now());
+        setPairing(next);
+      }), "primary", "pair")),
+      error ? h("div", { className: "dshm-panel", role: "alert" }, h("p", { className: "dshm-error" }, copy[error] ?? copy.requestError), button(copy.retry, () => action(refresh))) : null,
+      pairing && seconds > 0 ? h("div", { className: "dshm-panel", ref: pairPanel, tabIndex: -1, "aria-label": copy.qrLabel }, h("h3", null, copy.scan), h("img", { className: "dshm-qr", src: `data:image/svg+xml;base64,${btoa(pairing.svg)}`, alt: copy.qrAlt }), h("p", { role: "timer", "aria-live": "off" }, copy.expires(`${Math.floor(seconds / 60)}:${String(seconds % 60).padStart(2, "0")}`)), button(copy.cancelPair, () => action(async () => {
+        await api("cancelPair", {});
+        setPairing(null);
+      }))) : null,
+      ...(status?.guidance ?? []).map((text) => h("p", { className: "dshm-guidance", key: text }, guidanceCopy(text, copy))),
+      status?.discovery.state === "unavailable" ? h("p", { role: "status" }, copy.bonjour) : null,
+      h("div", { className: "dshm-row" }, h("h3", null, copy.away), h(Button, { variant: "outline", "aria-expanded": remoteOpen, "aria-controls": "dshm-remote-setup", onClick: () => setRemoteOpen(!remoteOpen) }, remoteOpen ? copy.closeSetup : copy.openSetup)),
+      remoteOpen ? h(RemoteSetup, { api, copy, pairingBusy: busy, onPair: () => action(async () => {
+        const next = await api("pairRemote", {});
+        setNow(Date.now());
+        setPairing(next);
+      }) }) : null,
+      h("div", null, h("h3", null, copy.devices), devices.length ? h("ul", { className: "dshm-devices" }, ...devices.map((device) => h("li", { className: "dshm-device", key: device.deviceId }, h("div", { className: "dshm-row" }, h("div", null, h("strong", null, device.name), h("p", { className: "dshm-muted" }, `${device.connected ? device.connectedVia === "tailscale" ? copy.viaTailscale : device.connectedVia === "lan" ? copy.viaLAN : copy.connected : copy.offline} \xB7 ${device.lastSeenAt ? copy.lastSeen(new Date(device.lastSeenAt).toLocaleString(language)) : copy.notConnected}`)), confirm === device.deviceId ? h("div", null, h("p", null, copy.revokeQuestion(device.name)), h("div", { className: "dshm-actions" }, button(copy.cancel, () => setConfirm(null)), button(copy.revokeDevice, () => action(async () => {
+        await api("revoke", { deviceId: device.deviceId });
+        setConfirm(null);
+      }), "outline", "revoke"))) : button(copy.revoke, () => setConfirm(device.deviceId), "outline", "revoke"))))) : h("p", { className: "dshm-muted" }, copy.noDevices))
+    );
+  };
+}
+
+// src/projection/client.mjs
+var inject = ["slots"];
+var SettingsCard = createSettingsCard(React, primitives, "api/dshm");
+function apply(ctx) {
+  ctx.slots.inject("settings.section", () => ctx.slots.register({
+    name: "settings.section",
+    id: "dshm",
+    order: 60,
+    label: () => "DSHM"
+  }, SettingsCard));
+}
+return module.exports;}});

package/lib/config.d.ts

@@ -0,0 +1,10 @@
+export interface Config {
+    port: number;
+    bindMode: 'lan' | 'tailscale' | 'all-private';
+    addresses?: string[];
+    pairOnStart: boolean;
+    quiet: boolean;
+    stateDir: string;
+    pushProxyUrl?: string;
+}
+export declare function parseConfig(input: unknown): Config;

package/lib/config.js

@@ -0,0 +1,27 @@
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
+import { proxyURL } from './push/controller.js';
+export function parseConfig(input) {
+    if (input !== undefined && (input === null || typeof input !== 'object' || Array.isArray(input)))
+        throw new Error('DSHM configuration must be an object');
+    const value = (input ?? {});
+    const allowed = new Set(['port', 'bindMode', 'addresses', 'pairOnStart', 'quiet', 'pushProxyUrl']);
+    for (const key of Object.keys(value))
+        if (!allowed.has(key))
+            throw new Error(`Unknown DSHM configuration field: ${key}`);
+    const port = value.port ?? 47390;
+    if (typeof port !== 'number' || !Number.isInteger(port) || port < 0 || port > 65535)
+        throw new Error('DSHM port must be 0..65535');
+    const mode = value.bindMode ?? 'all-private';
+    if (!['lan', 'tailscale', 'all-private'].includes(String(mode)))
+        throw new Error('Invalid DSHM bindMode');
+    if (value.addresses !== undefined && (!Array.isArray(value.addresses) || !value.addresses.length || value.addresses.some(address => typeof address !== 'string')))
+        throw new Error('DSHM addresses must be a nonempty list of IP literals');
+    for (const field of ['pairOnStart', 'quiet'])
+        if (value[field] !== undefined && typeof value[field] !== 'boolean')
+            throw new Error(`DSHM ${field} must be boolean`);
+    return { port, bindMode: mode, addresses: value.addresses,
+        pairOnStart: value.pairOnStart === true, quiet: value.quiet === true,
+        pushProxyUrl: proxyURL(value.pushProxyUrl),
+        stateDir: resolve(process.env.DSH_HOME ?? resolve(homedir(), '.dsh'), 'dshm') };
+}

package/lib/discovery/advertiser.d.ts

@@ -0,0 +1,45 @@
+import multicastDns from 'multicast-dns';
+type Transport = ReturnType<typeof multicastDns>;
+type TransportOptions = NonNullable<Parameters<typeof multicastDns>[0]>;
+export interface Advertisement {
+    hostId: string;
+    name: string;
+    port: number;
+    addresses: string[];
+}
+export interface DiscoveryStatus {
+    state: 'advertising' | 'unavailable' | 'stopped';
+    serviceName: string;
+    error?: string;
+}
+type Record = {
+    name: string;
+    ttl: number;
+    flush?: boolean;
+} & ({
+    type: 'PTR' | 'A' | 'AAAA';
+    data: string;
+} | {
+    type: 'SRV';
+    data: {
+        port: number;
+        target: string;
+        priority: number;
+        weight: number;
+    };
+} | {
+    type: 'TXT';
+    data: Buffer[];
+});
+export declare function advertisementRecords(values: Advertisement, ttl?: number): {
+    serviceName: string;
+    target: string;
+    records: Record[];
+};
+/** Publishes only bound listener endpoints; this is not an authenticated RPC transport. */
+export declare function createAdvertiser(initial: Advertisement, changed?: (status: DiscoveryStatus) => void, factory?: (options: TransportOptions) => Transport): Promise<{
+    update: (next: Advertisement) => Promise<void>;
+    status: () => DiscoveryStatus;
+    close(): Promise<void>;
+}>;
+export {};

package/lib/discovery/advertiser.js

@@ -0,0 +1,141 @@
+import { createHash } from 'node:crypto';
+import { isIP } from 'node:net';
+import { networkInterfaces, platform } from 'node:os';
+import multicastDns from 'multicast-dns';
+import { isPrivateAddress } from './interfaces.js';
+const serviceType = '_dshm._tcp.local';
+const enumeration = '_services._dns-sd._udp.local';
+const normalName = (name) => name.toLowerCase().replace(/\.$/, '');
+function names(values) {
+    const suffix = createHash('sha256').update(values.hostId).digest('hex').slice(0, 24);
+    let label = `DSHM ${values.name}`.replace(/[.\\\x00-\x1f\x7f]/g, ' ').trim();
+    while (Buffer.byteLength(label) > 46)
+        label = [...label].slice(0, -1).join('');
+    const serviceName = `${label} ${suffix.slice(0, 8)}`;
+    return { serviceName, target: `dshm-${suffix}.local` };
+}
+export function advertisementRecords(values, ttl = 120) {
+    if (!Number.isInteger(values.port) || values.port < 1 || values.port > 65535)
+        throw new Error('Invalid discovery port');
+    if (!values.addresses.length || values.addresses.some(address => !isPrivateAddress(address, true)))
+        throw new Error('Discovery requires private listener addresses');
+    const { serviceName, target } = names(values), fullName = `${serviceName}.${serviceType}`;
+    const records = [
+        { name: enumeration, type: 'PTR', ttl, data: serviceType },
+        { name: serviceType, type: 'PTR', ttl, data: fullName },
+        { name: fullName, type: 'SRV', ttl, flush: true, data: { port: values.port, target, priority: 0, weight: 0 } },
+        { name: fullName, type: 'TXT', ttl, flush: true, data: [Buffer.from(`host=${values.hostId}`), Buffer.from('v=1')] },
+        ...[...new Set(values.addresses)].map((address) => ({ name: target, type: isIP(address) === 6 ? 'AAAA' : 'A', ttl, flush: true, data: address })),
+    ];
+    return { serviceName, target, records };
+}
+function interfaces(addresses) {
+    const entries = Object.entries(networkInterfaces());
+    return addresses.flatMap(address => {
+        if (isIP(address) === 4)
+            return [{ interface: address, bind: '0.0.0.0', type: 'udp4', ip: '224.0.0.251', reuseAddr: true }];
+        const match = entries.find(([, values]) => values?.some(value => value.address === address));
+        if (!match)
+            return [];
+        const info = match[1]?.find(value => value.address === address);
+        const scope = platform() === 'win32' && info?.family === 'IPv6' ? String(info.scopeid) : match[0];
+        return [{ interface: `::%${scope}`, bind: '::', type: 'udp6', ip: `ff02::fb%${scope}`, reuseAddr: true }];
+    });
+}
+/** Publishes only bound listener endpoints; this is not an authenticated RPC transport. */
+export async function createAdvertiser(initial, changed = () => { }, factory = multicastDns) {
+    let values = initial, service = { ...names(initial), records: [] }, sockets = [], timer;
+    let closed = false, status = { state: 'stopped', serviceName: service.serviceName }, previous = '';
+    let sequence = Promise.resolve();
+    const setStatus = (state, error) => {
+        status = { state, serviceName: service.serviceName, ...(error ? { error } : {}) };
+        changed(status);
+    };
+    const send = (socket, records = service.records) => new Promise(resolve => {
+        const timeout = setTimeout(resolve, 1000);
+        timeout.unref();
+        try {
+            socket.respond({ answers: records }, () => { clearTimeout(timeout); resolve(); });
+        }
+        catch {
+            clearTimeout(timeout);
+            resolve();
+        }
+    });
+    const stop = async () => {
+        clearInterval(timer);
+        timer = undefined;
+        const old = sockets;
+        sockets = [];
+        await Promise.all(old.map(async (socket) => {
+            await send(socket, service.records.map(record => ({ ...record, ttl: 0 })));
+            await new Promise(resolve => {
+                const timeout = setTimeout(resolve, 1000);
+                timeout.unref();
+                try {
+                    socket.destroy(() => { clearTimeout(timeout); resolve(); });
+                }
+                catch {
+                    clearTimeout(timeout);
+                    resolve();
+                }
+            });
+        }));
+    };
+    const update = (next) => {
+        sequence = sequence.then(async () => {
+            if (closed)
+                return;
+            const identity = JSON.stringify({ ...next, addresses: [...next.addresses].sort() });
+            if (identity === previous && status.state === 'advertising')
+                return;
+            await stop();
+            values = next;
+            previous = identity;
+            if (!values.addresses.length) {
+                setStatus('unavailable', 'No private listener is available');
+                return;
+            }
+            service = advertisementRecords(values);
+            let failed = false;
+            const fail = () => { failed = true; setStatus('unavailable', 'Bonjour could not use a listener interface'); };
+            for (const options of interfaces(values.addresses)) {
+                const socket = factory(options);
+                sockets.push(socket);
+                socket.on('error', fail);
+                socket.on('warning', error => { if (['EACCES', 'EPERM', 'EADDRNOTAVAIL', 'ENODEV', 'ENETUNREACH', 'EHOSTUNREACH'].includes(String(error.code)))
+                    fail(); });
+                socket.on('query', (packet, remote) => {
+                    if (!packet.questions?.some(question => [serviceType, enumeration, `${service.serviceName}.${serviceType}`, service.target].some(name => normalName(question.name) === normalName(name))))
+                        return;
+                    // Legacy DNS clients use a unicast reply; standard mDNS browsers use multicast.
+                    if (remote.port !== 5353)
+                        socket.respond({ id: packet.id, answers: service.records }, remote);
+                    else
+                        void send(socket);
+                });
+                await new Promise(resolve => {
+                    const timeout = setTimeout(() => { fail(); resolve(); }, 2000);
+                    const ready = () => { clearTimeout(timeout); resolve(); };
+                    socket.once('ready', ready);
+                    socket.once('error', ready);
+                });
+                await send(socket);
+            }
+            if (!sockets.length)
+                fail();
+            if (!failed)
+                setStatus('advertising');
+            timer = setInterval(() => { for (const socket of sockets)
+                void send(socket); }, 60000);
+            timer.unref();
+        });
+        return sequence;
+    };
+    await update(initial);
+    return {
+        update,
+        status: () => ({ ...status }),
+        async close() { closed = true; await sequence; await stop(); setStatus('stopped'); },
+    };
+}

package/lib/discovery/interfaces.d.ts

@@ -0,0 +1,5 @@
+export type BindMode = 'lan' | 'tailscale' | 'all-private';
+export declare function isTailscale(address: string): boolean;
+export declare function isPrivateAddress(address: string, allowLoopback?: boolean): boolean;
+export declare function privateInterfaces(mode?: BindMode): string[];
+export declare const endpoint: (address: string, port: number) => string;