@linxin666/dsh-remote-web-ui 0.3.6 → 0.3.10

package/lib/types/remote-api.js

@@ -1,21 +1,21 @@
 /**
  * The remote desktop data channel: `/remote` is this plugin's own prefix, so
- * the paired-device cookie is the access control (exactly like `/m/api`).
- * After that gate, every fenced same-origin path the browser rewrote here is
- * re-issued to 127.0.0.1 as a loopback-shaped request so sibling plugin
- * fences (and the connection plugin's `/api`) accept it — no `--trusted-host`
- * and no per-plugin pairing consult.
+ * the paired-device cookie is the access control. After that gate, every
+ * fenced same-origin path the browser rewrote here is re-issued to 127.0.0.1
+ * as a loopback-shaped request so sibling plugin fences (and the connection
+ * plugin's `/api`) accept it — no `--trusted-host` and no per-plugin pairing
+ * consult.
  *
  * Security model:
  * - While `requirePairingForLan` is on (default), every request must carry a
  *   live paired-device cookie, enforced before any bytes are forwarded and
  *   before any host call. With the policy off, the cookie gate is skipped
- *   (the loopback-only denials below still apply).
- * - The SDK's loopback-only privileged methods (native dialogs, the settings
- *   plane, credentials — the `PRIVILEGED_METHODS` set of client-connection)
- *   are denied here. The set is pinned by tests/remote-contract.spec.ts.
- * - `/api/pair/*`, `/api/update/*`, `/api/plugin-manager/*`,
- *   `/api/dsh-desktop-launcher/*` and `/api/dsh-web-ui-settings/*` stay physically local.
+ *   (the local-only denials below still apply).
+ * - A paired remote desktop is a full-control credential: the browser half
+ *   flips the official UI into host mode (the transport ownsHost hook), so
+ *   the configuration plane (settings, credentials, presets, deliverables)
+ *   rides this channel like every other call. The four control planes in
+ *   LOCAL_ONLY_PREFIXES stay physically local.
  * - Everything else is HTTP- or WebSocket-proxied to the local port with
  *   Host rewritten, Origin and cookies dropped, and a synthetic same-origin
  *   browser marker added after authentication. Plugin loopback fences then
@@ -24,8 +24,8 @@
 import { readCookie } from "./gate.js";
 import { writeJson } from "./http.js";
 import { proxyLoopbackHttp, proxyLoopbackUpgrade } from "./loopback-proxy.js";
-import { DESKTOP_LAUNCHER_PATH, LOOPBACK_ONLY_METHODS, PLUGIN_MANAGER_PATH, REMOTE_PREFIX, REMOTE_UPGRADE_PATHS, WEB_UI_SETTINGS_BRIDGE_PATH, } from "./remote-methods.js";
-export { DESKTOP_LAUNCHER_PATH, LOOPBACK_ONLY_METHODS, PLUGIN_MANAGER_PATH, REMOTE_API_PATHS, REMOTE_PREFIX, REMOTE_UPGRADE_PATHS, WEB_UI_SETTINGS_BRIDGE_PATH, } from "./remote-methods.js";
+import { REMOTE_DEVICE_HEADER, REMOTE_DEVICE_QUERY, REMOTE_PREFIX, REMOTE_UPGRADE_PATHS, localOnlyDenial, } from "./remote-methods.js";
+export { DESKTOP_LAUNCHER_PATH, LOCAL_ONLY_PREFIXES, PLUGIN_MANAGER_PATH, REMOTE_API_PATHS, REMOTE_DEVICE_HEADER, REMOTE_DEVICE_QUERY, REMOTE_PREFIX, REMOTE_UPGRADE_PATHS, WEB_UI_SETTINGS_BRIDGE_PATH, localOnlyDenial, } from "./remote-methods.js";
 export { REMOTE_API_PREFIX } from "./remote-methods.js";
 const ALLOWED_METHODS = new Set(['GET', 'HEAD', 'POST', 'PUT', 'PATCH', 'DELETE']);
 /** Reject traversal and empty segments; allow plugin file-path characters. */
@@ -68,32 +68,28 @@ export function innerPathOf(pathname) {
     return rest;
 }
 /**
- * Whether a paired inner path must stay physically local.
+ * Whether a paired inner path must stay physically local (delegates to the
+ * shared LOCAL_ONLY_PREFIXES table).
  * @returns a denial message, or undefined when the path may be proxied.
  */
 export function loopbackOnlyDenial(innerPath) {
-    if (innerPath === '/api/pair' || innerPath.startsWith('/api/pair/')) {
-        return 'pairing endpoints stay loopback-only and stay unreachable from a paired remote desktop';
-    }
-    if (innerPath === '/api/update' || innerPath.startsWith('/api/update/')) {
-        return 'update endpoints stay loopback-only and stay unreachable from a paired remote desktop';
-    }
-    if (innerPath === PLUGIN_MANAGER_PATH || innerPath.startsWith(`${PLUGIN_MANAGER_PATH}/`)) {
-        return 'plugin-manager stays loopback-only and stays unreachable from a paired remote desktop';
-    }
-    if (innerPath === DESKTOP_LAUNCHER_PATH || innerPath.startsWith(`${DESKTOP_LAUNCHER_PATH}/`)) {
-        return 'desktop-launcher endpoints stay loopback-only and stay unreachable from a paired remote desktop';
-    }
-    if (innerPath === WEB_UI_SETTINGS_BRIDGE_PATH || innerPath.startsWith(`${WEB_UI_SETTINGS_BRIDGE_PATH}/`)) {
-        return 'settings-bridge endpoints stay loopback-only and stay unreachable from a paired remote desktop';
-    }
-    if (!innerPath.startsWith('/api/'))
+    return localOnlyDenial(innerPath);
+}
+/**
+ * Resolve a live device credential for a gated HTTP request: the pairing
+ * cookie first, then the cookieless header the boot patch attaches. Unknown
+ * or revoked ids are a no-op - a stale id never re-arms a device.
+ * @returns the touched device id, or undefined when neither credential is live.
+ */
+export function pairedDeviceIdOf(req, service) {
+    const cookieDevice = readCookie(req.headers.cookie, service.config.cookieName);
+    const headerDevice = typeof req.headers[REMOTE_DEVICE_HEADER] === 'string'
+        ? req.headers[REMOTE_DEVICE_HEADER]
+        : undefined;
+    const id = cookieDevice ?? headerDevice;
+    if (id === undefined)
         return undefined;
-    const method = innerPath.slice('/api/'.length);
-    if (method !== '' && !method.includes('/') && LOOPBACK_ONLY_METHODS.has(method)) {
-        return `${method} is loopback-only and stays unreachable from a paired remote desktop`;
-    }
-    return undefined;
+    return service.touchDevice(id) ? id : undefined;
 }
 /**
  * Build the remote desktop channel HTTP routes.
@@ -108,9 +104,8 @@ export function makeRemoteApiRoutes(deps) {
         // (a stale client rewrite must not 403); loopback-only denials stay below.
         const require = typeof requirePairingForLan === 'function' ? requirePairingForLan() : requirePairingForLan;
         if (require) {
-            const deviceId = readCookie(req.headers.cookie, service.config.cookieName);
-            const paired = deviceId !== undefined && service.touchDevice(deviceId);
-            if (!paired) {
+            const paired = pairedDeviceIdOf(req, service);
+            if (paired === undefined) {
                 req.resume();
                 envelopeError(res, 403, 'invalid-request', 'unpaired', 'this device is not paired with the desktop');
                 return;
@@ -135,7 +130,7 @@ export function makeRemoteApiRoutes(deps) {
             envelopeError(res, 403, 'invalid-request', 'forbidden', denied);
             return;
         }
-        proxyLoopbackHttp(req, res, port, `${inner}${url.search}`);
+        proxyLoopbackHttp(req, res, port, `${inner}${url.search}`, deps.auth);
     };
     return [{ kind: 'prefix', path: REMOTE_PREFIX, handler }];
 }
@@ -168,8 +163,16 @@ export function makeRemoteApiUpgradeRoutes(deps) {
     const handlerFor = (fallbackPath) => (req, socket, head) => {
         const require = typeof requirePairingForLan === 'function' ? requirePairingForLan() : requirePairingForLan;
         if (require) {
-            const deviceId = readCookie(req.headers.cookie, service.config.cookieName);
-            if (deviceId === undefined || !service.touchDevice(deviceId)) {
+            // WebSocket handshakes cannot carry headers from the Web API, so the
+            // cookieless credential rides the query; the cookie stays the primary.
+            let queryDevice;
+            try {
+                queryDevice = new URL(req.url ?? '/', 'http://127.0.0.1').searchParams.get(REMOTE_DEVICE_QUERY) ?? undefined;
+            }
+            catch { /* fall through to the cookie */ }
+            const deviceId = pairedDeviceIdOf(req, service);
+            const paired = deviceId ?? (queryDevice !== undefined && service.touchDevice(queryDevice) ? queryDevice : undefined);
+            if (paired === undefined) {
                 socket.write('HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\n');
                 socket.destroy();
                 return;
@@ -182,7 +185,17 @@ export function makeRemoteApiUpgradeRoutes(deps) {
             socket.destroy();
             return;
         }
-        proxyLoopbackUpgrade(req, socket, head, port, inner);
+        // The inner handshake needs the browser-auth credential (the gateway
+        // event-stream route enforces it); resolving it is async, so the
+        // handshake bytes are written once it settles. A missing credential
+        // proceeds as before — the gateway route then refuses.
+        void Promise.resolve(deps.auth?.ready())
+            .catch(() => undefined)
+            .then((cookie) => {
+            if (socket.destroyed)
+                return;
+            proxyLoopbackUpgrade(req, socket, head, port, inner, typeof cookie === 'string' ? cookie : undefined);
+        });
     };
     return REMOTE_UPGRADE_PATHS.map((path) => ({
         path,

package/lib/types/remote-channel-boot.d.ts

@@ -10,8 +10,15 @@
  * (hooks + pending unpaired signal) instead of patching twice.
  *
  * The rewrite decisions are generated from REMOTE_CHANNEL_RULES, the same
- * data the browser patch consumes — the two cannot drift apart. The script
- * self-skips on loopback origins and never throws.
+ * data the browser patch consumes — the two cannot drift apart. On this
+ * 0.1.2-alpha.2 line the "configuration plane is local" behavior lives in
+ * the browser (client plugins branch on connection.isLoopback), so the
+ * script also flips the official UI into host mode by installing the
+ * transport hook `__DSH_TRANSPORT__ = { ownsHost: true }` before the
+ * connection plugin reads it: the paired remote desktop gets the full
+ * settings/credentials/presets surface, and every call still rides the
+ * gated /remote channel. The script self-skips on loopback origins and
+ * never throws.
  * @module @linxin666/dsh-remote-web-ui/remote-channel-boot
  */
 import { type RemoteChannelRules } from './remote-channel-rules.ts';
@@ -21,6 +28,18 @@ import { type RemoteChannelRules } from './remote-channel-rules.ts';
  * the window global.
  */
 export declare function buildRemoteChannelBootScript(rules?: RemoteChannelRules): string;
+/** Boot-watchdog latch: one self-reload per session while the boot is broken. */
+export declare const BOOT_WATCHDOG_KEY = "dsh-remote-boot-reload";
+/**
+ * Build the boot-watchdog script fragment. A remote boot has no recovery
+ * path of its own: the SPA mounts nothing when a boot-critical request dies
+ * (a tunnel-edge 429 under burst, a dropped stream, a boot-order race), and
+ * the phone then shows a permanently blank shell. The watchdog polls for the
+ * app's conversation surface and reloads once when it never appears; the
+ * sessionStorage latch keeps a genuinely broken deployment from looping,
+ * and a successful boot clears the latch so a later failure can recover.
+ */
+export declare function buildBootWatchdogScript(waitMs?: number, pollMs?: number): string;
 /** The script this plugin contributes; built once from the live rules. */
 export declare const REMOTE_CHANNEL_BOOT_SCRIPT: string;
 //# sourceMappingURL=remote-channel-boot.d.ts.map

package/lib/types/remote-channel-boot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"remote-channel-boot.d.ts","sourceRoot":"","sources":["../../src/remote-channel-boot.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAoD,KAAK,kBAAkB,EAAE,MAAM,2BAA2B,CAAA;AAErH;;;;GAIG;AACH,wBAAgB,4BAA4B,CAAC,KAAK,GAAE,kBAAyC,GAAG,MAAM,CAuGrG;AAED,0EAA0E;AAC1E,eAAO,MAAM,0BAA0B,EAAE,MAAuC,CAAA"}
+{"version":3,"file":"remote-channel-boot.d.ts","sourceRoot":"","sources":["../../src/remote-channel-boot.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAoD,KAAK,kBAAkB,EAAE,MAAM,2BAA2B,CAAA;AAErH;;;;GAIG;AACH,wBAAgB,4BAA4B,CAAC,KAAK,GAAE,kBAAyC,GAAG,MAAM,CA+HrG;AAED,iFAAiF;AACjF,eAAO,MAAM,iBAAiB,2BAA2B,CAAA;AAQzD;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,SAAwB,EAAE,MAAM,SAAwB,GAAG,MAAM,CAgB9G;AAED,0EAA0E;AAC1E,eAAO,MAAM,0BAA0B,EAAE,MAAuC,CAAA"}

package/lib/types/remote-channel-boot.js

@@ -10,8 +10,15 @@
  * (hooks + pending unpaired signal) instead of patching twice.
  *
  * The rewrite decisions are generated from REMOTE_CHANNEL_RULES, the same
- * data the browser patch consumes — the two cannot drift apart. The script
- * self-skips on loopback origins and never throws.
+ * data the browser patch consumes — the two cannot drift apart. On this
+ * 0.1.2-alpha.2 line the "configuration plane is local" behavior lives in
+ * the browser (client plugins branch on connection.isLoopback), so the
+ * script also flips the official UI into host mode by installing the
+ * transport hook `__DSH_TRANSPORT__ = { ownsHost: true }` before the
+ * connection plugin reads it: the paired remote desktop gets the full
+ * settings/credentials/presets surface, and every call still rides the
+ * gated /remote channel. The script self-skips on loopback origins and
+ * never throws.
  * @module @linxin666/dsh-remote-web-ui/remote-channel-boot
  */
 import { REMOTE_CHANNEL_BOOT_GLOBAL, REMOTE_CHANNEL_RULES } from "./remote-channel-rules.js";
@@ -30,7 +37,23 @@ export function buildRemoteChannelBootScript(rules = REMOTE_CHANNEL_RULES) {
         'var w=window,loc=w.location,h=loc.hostname;' +
         // Loopback origins keep the original paths (mirrors isLoopbackHostname).
         "if(h==='localhost'||h==='::1'||/^127(\\.\\d{1,3}){3}$/.test(h))return;" +
+        // Host mode: the paired remote desktop presents itself as the machine
+        // owner, so the official UI keeps its full configuration surface (the
+        // settings mirror, document controller, and deliverables open actions
+        // all branch on connection.isLoopback). Must run before any boot entry.
+        'try{if(w.__DSH_TRANSPORT__===undefined)w.__DSH_TRANSPORT__={};w.__DSH_TRANSPORT__.ownsHost=true}catch(e){}' +
         'var R=' + json + ';' +
+        // The cookieless device credential: read lazily per call - the
+        // /pair-app capture script sets it in head AFTER this boot script ran,
+        // so a parse-time read would always see null.
+        'function rdv(){try{return w.sessionStorage.getItem(R.deviceKey)}catch(e){return null}}' +
+        'function att(init){' +
+        'var dv=rdv();' +
+        'if(dv===null)return init;' +
+        'var h=init&&init.headers;' +
+        'if(typeof Headers!=="undefined"&&h instanceof Headers){try{h.set(R.deviceHeader,dv)}catch(e){}return init}' +
+        'if(typeof h==="object"&&h!==null){var o={};for(var k in h)o[k]=h[k];o[R.deviceHeader]=dv;return Object.assign({},init,{headers:o})}' +
+        'return init}' +
         'function sf(p){' +
         'if(p.indexOf(R.pairPrefix)===0)return false;' +
         'if(p.indexOf(R.updatePrefix)===0)return false;' +
@@ -78,7 +101,7 @@ export function buildRemoteChannelBootScript(rules = REMOTE_CHANNEL_RULES) {
         'var next=new URL(url);' +
         'next.pathname=rp(url.pathname);' +
         'var target=typeof input==="string"||input instanceof URL?next.toString():new Request(next,input);' +
-        'return Promise.resolve(of.call(w,target,init)).then(function(res){' +
+        'return Promise.resolve(of.call(w,target,att(init))).then(function(res){' +
         // denied() is sync-false for non-403 and a promise otherwise.
         'void Promise.resolve(denied(res)).then(signal);' +
         'return res})}' +
@@ -90,6 +113,8 @@ export function buildRemoteChannelBootScript(rules = REMOTE_CHANNEL_RULES) {
         'if(o!==""&&o===loc.origin&&sw(p.pathname)){' +
         'var nx=new URL(p);' +
         'nx.pathname=rp(p.pathname);' +
+        'var dvv=rdv();' +
+        'if(dvv!==null)nx.searchParams.set(R.deviceQuery,dvv);' +
         'return protocols!==undefined?new OW(nx,protocols):new OW(nx)}' +
         'return protocols!==undefined?new OW(url,protocols):new OW(url)};' +
         'w.WebSocket.prototype=OW.prototype;' +
@@ -101,6 +126,8 @@ export function buildRemoteChannelBootScript(rules = REMOTE_CHANNEL_RULES) {
         'if(so(p)&&sf(p.pathname)){' +
         'var nx=new URL(p);' +
         'nx.pathname=rp(p.pathname);' +
+        'var dvv=rdv();' +
+        'if(dvv!==null)nx.searchParams.set(R.deviceQuery,dvv);' +
         'return new OE(nx,cfg)}' +
         'return new OE(url,cfg)};' +
         'w.EventSource.prototype=OE.prototype}' +
@@ -121,8 +148,43 @@ export function buildRemoteChannelBootScript(rules = REMOTE_CHANNEL_RULES) {
         'for(var i=0;i<restores.length;i++)restores[i]();' +
         'try{delete w[' + seat + ']}catch(e){w[' + seat + ']=undefined}};' +
         'w[' + seat + ']=seat' +
+        // The boot watchdog rides the same IIFE and skip conditions: it needs
+        // the non-loopback gate above (the desktop boots over loopback without
+        // a tunnel in the path) and the try/catch fail-closed envelope.
+        buildBootWatchdogScript() +
         '}catch(e){}' +
         '})();';
 }
+/** Boot-watchdog latch: one self-reload per session while the boot is broken. */
+export const BOOT_WATCHDOG_KEY = 'dsh-remote-boot-reload';
+/** Total wait for the app's first conversation surface before the reload. */
+const BOOT_WATCHDOG_WAIT_MS = 15_000;
+/** Watchdog poll cadence. */
+const BOOT_WATCHDOG_POLL_MS = 1_000;
+/**
+ * Build the boot-watchdog script fragment. A remote boot has no recovery
+ * path of its own: the SPA mounts nothing when a boot-critical request dies
+ * (a tunnel-edge 429 under burst, a dropped stream, a boot-order race), and
+ * the phone then shows a permanently blank shell. The watchdog polls for the
+ * app's conversation surface and reloads once when it never appears; the
+ * sessionStorage latch keeps a genuinely broken deployment from looping,
+ * and a successful boot clears the latch so a later failure can recover.
+ */
+export function buildBootWatchdogScript(waitMs = BOOT_WATCHDOG_WAIT_MS, pollMs = BOOT_WATCHDOG_POLL_MS) {
+    const key = JSON.stringify(BOOT_WATCHDOG_KEY);
+    return (
+    // Leading semicolon: the preceding seat assignment ends without one,
+    // and the fragment must parse when spliced into the IIFE.
+    ';function wBoot(){try{return !!(w.document&&w.document.querySelector&&(w.document.querySelector("[data-conversation-scroll]")||w.document.querySelector("[data-slot=\\"conversation\\"]")))}catch(e){return false}}' +
+        'function wTick(n){try{' +
+        'if(wBoot()){try{w.sessionStorage.removeItem(' + key + ')}catch(e){}return}' +
+        'if(n<' + waitMs + '){w.setTimeout(function(){wTick(n+' + pollMs + ')},' + pollMs + ');return}' +
+        'var done=false;try{done=w.sessionStorage.getItem(' + key + ')==="1"}catch(e){}' +
+        'if(done)return;' +
+        'try{w.sessionStorage.setItem(' + key + ',"1")}catch(e){}' +
+        'w.location.reload()' +
+        '}catch(e){}}' +
+        'if(typeof w.setTimeout==="function")w.setTimeout(function(){wTick(0)},' + pollMs + ');');
+}
 /** The script this plugin contributes; built once from the live rules. */
 export const REMOTE_CHANNEL_BOOT_SCRIPT = buildRemoteChannelBootScript();

package/lib/types/remote-channel-rules.d.ts

@@ -7,6 +7,8 @@
  */
 /** The gated mirror prefix (must match src/remote-methods.ts). */
 export declare const REMOTE_PREFIX = "/remote";
+import { REMOTE_DEVICE_HEADER, REMOTE_DEVICE_QUERY } from './remote-methods.ts';
+export { REMOTE_DEVICE_HEADER, REMOTE_DEVICE_QUERY };
 /** Connection-plugin method prefix under the gated channel. */
 export declare const REMOTE_API_PREFIX = "/remote/api";
 /** Every decision input of the remote-channel rewrite, JSON-serializable. */
@@ -21,6 +23,12 @@ export interface RemoteChannelRules {
     readonly gitPrefix: string;
     readonly petPrefix: string;
     readonly wsPaths: readonly string[];
+    /** Header carrying the cookieless device credential on gated fetches. */
+    readonly deviceHeader: string;
+    /** sessionStorage key holding the device credential (set by /pair-app). */
+    readonly deviceKey: string;
+    /** Query parameter carrying it on WebSocket upgrades. */
+    readonly deviceQuery: string;
 }
 /** The live rule set. */
 export declare const REMOTE_CHANNEL_RULES: RemoteChannelRules;

package/lib/types/remote-channel-rules.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"remote-channel-rules.d.ts","sourceRoot":"","sources":["../../src/remote-channel-rules.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,kEAAkE;AAClE,eAAO,MAAM,aAAa,YAAY,CAAA;AAEtC,+DAA+D;AAC/D,eAAO,MAAM,iBAAiB,gBAAyB,CAAA;AAEvD,6EAA6E;AAC7E,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,qBAAqB,EAAE,MAAM,CAAA;IACtC,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAA;IACrC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;IAC9B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAA;CACpC;AAED,yBAAyB;AACzB,eAAO,MAAM,oBAAoB,EAAE,kBAiBlC,CAAA;AAED,iEAAiE;AACjE,eAAO,MAAM,0BAA0B,gCAAgC,CAAA;AAEvE;;;;GAIG;AACH,MAAM,WAAW,qBAAqB;IACpC,UAAU,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAAA;IAC/B,QAAQ,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAAA;IAC7B,eAAe,EAAE,OAAO,CAAA;IACxB,OAAO,IAAI,IAAI,CAAA;CAChB"}
+{"version":3,"file":"remote-channel-rules.d.ts","sourceRoot":"","sources":["../../src/remote-channel-rules.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,kEAAkE;AAClE,eAAO,MAAM,aAAa,YAAY,CAAA;AAEtC,OAAO,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AAE/E,OAAO,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,CAAA;AAEpD,+DAA+D;AAC/D,eAAO,MAAM,iBAAiB,gBAAyB,CAAA;AAEvD,6EAA6E;AAC7E,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,qBAAqB,EAAE,MAAM,CAAA;IACtC,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAA;IACrC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;IAC9B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAA;IACnC,yEAAyE;IACzE,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,2EAA2E;IAC3E,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,yDAAyD;IACzD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;CAC7B;AAED,yBAAyB;AACzB,eAAO,MAAM,oBAAoB,EAAE,kBAsBlC,CAAA;AAED,iEAAiE;AACjE,eAAO,MAAM,0BAA0B,gCAAgC,CAAA;AAEvE;;;;GAIG;AACH,MAAM,WAAW,qBAAqB;IACpC,UAAU,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAAA;IAC/B,QAAQ,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAAA;IAC7B,eAAe,EAAE,OAAO,CAAA;IACxB,OAAO,IAAI,IAAI,CAAA;CAChB"}

package/lib/types/remote-channel-rules.js

@@ -7,6 +7,8 @@
  */
 /** The gated mirror prefix (must match src/remote-methods.ts). */
 export const REMOTE_PREFIX = '/remote';
+import { REMOTE_DEVICE_HEADER, REMOTE_DEVICE_QUERY } from "./remote-methods.js";
+export { REMOTE_DEVICE_HEADER, REMOTE_DEVICE_QUERY };
 /** Connection-plugin method prefix under the gated channel. */
 export const REMOTE_API_PREFIX = `${REMOTE_PREFIX}/api`;
 /** The live rule set. */
@@ -20,13 +22,18 @@ export const REMOTE_CHANNEL_RULES = {
     sidebarPrefix: '/sidebar/',
     gitPrefix: '/git/',
     petPrefix: '/pet/',
+    // The official 0.1.2-alpha.2 line opens exactly one stream socket (the
+    // Typert gateway mux, /api/remote.mux); the legacy /api/events.* paths
+    // were removed by the SDK and stay absent here.
     wsPaths: [
-        '/api/events.mux',
-        '/api/events.host',
+        '/api/remote.mux',
         '/sidebar/ws/terminal',
         '/sidebar/ws/agent-terminals',
         '/api/dsh-ssh/terminal',
     ],
+    deviceHeader: REMOTE_DEVICE_HEADER,
+    deviceKey: 'dsh-remote-device',
+    deviceQuery: REMOTE_DEVICE_QUERY,
 };
 /** The window global the boot patch publishes its seat under. */
 export const REMOTE_CHANNEL_BOOT_GLOBAL = '__DSH_REMOTE_CHANNEL_BOOT__';

package/lib/types/remote-methods.d.ts

@@ -1,33 +1,67 @@
 /**
  * Remote desktop channel constants — SDK-independent so tests and the
  * client half can pin them without importing the host SDK graph.
+ *
+ * Access model on the 0.1.2-alpha.2 line: the host /api surface has no
+ * per-method privilege pin — the "configuration plane is local" behavior
+ * lives in the browser (client plugins branch on connection.isLoopback), and
+ * the paired remote desktop flips into host mode via the transport hook
+ * (ownsHost) while every call rides this gated channel as a loopback-shaped
+ * request. A paired device is therefore a full-control credential by
+ * design; the only paths that stay physically local are the control planes
+ * below (pairing control, self-update, plugin install/remove, host power).
  */
 /** Gated mirror of same-origin fenced paths (`/remote` + original pathname). */
 export declare const REMOTE_PREFIX = "/remote";
 /** Connection-plugin method prefix under the gated channel. */
 export declare const REMOTE_API_PREFIX = "/remote/api";
-/** WebSocket event-stream paths served by the channel (client rewrites to these). */
+/**
+ * The gated mirrors of the official client WebSocket paths. On the pinned
+ * 0.1.2-alpha.2 line the client opens ONE persistent stream socket — the
+ * Typert gateway mux at `/api/remote.mux` — and every Remote stream
+ * (workspace follow, session feed, ...) rides it. If that socket is not
+ * rewritten onto the gated channel the phone's streams die at the connection
+ * fence and the UI shows an empty workspace/session mirror, so the mux is
+ * the one path that must never be missing here.
+ */
 export declare const REMOTE_API_PATHS: {
-    readonly mux: "/remote/api/events.mux";
-    readonly host: "/remote/api/events.host";
+    readonly mux: "/remote/api/remote.mux";
 };
 /**
  * Exact upgrade paths registered on webServer (the SDK matches upgrades by
  * exact path, not prefix). Query strings ride on the request URL.
  */
-export declare const REMOTE_UPGRADE_PATHS: readonly ["/remote/api/events.mux", "/remote/api/events.host", "/remote/sidebar/ws/terminal", "/remote/sidebar/ws/agent-terminals", "/remote/api/dsh-ssh/terminal"];
+export declare const REMOTE_UPGRADE_PATHS: readonly ["/remote/api/remote.mux", "/remote/sidebar/ws/terminal", "/remote/sidebar/ws/agent-terminals", "/remote/api/dsh-ssh/terminal"];
 /** Plugin-manager HTTP prefix: install/remove stay physically local. */
 export declare const PLUGIN_MANAGER_PATH = "/api/plugin-manager";
 /** Desktop-launcher HTTP prefix: shortcut create and host shutdown stay physically local. */
 export declare const DESKTOP_LAUNCHER_PATH = "/api/dsh-desktop-launcher";
-/** Family settings-bridge HTTP prefix: describe/mutate stay physically local. */
+/** Family settings-bridge HTTP prefix — re-exposed to paired devices (plain settings parity). */
 export declare const WEB_UI_SETTINGS_BRIDGE_PATH = "/api/dsh-web-ui-settings";
 /**
- * Loopback-only methods of the host API surface, mirrored from
- * client-connection's `PRIVILEGED_METHODS` (pinned by
- * tests/remote-contract.spec.ts against the installed SDK). They stay
- * unreachable from a paired remote desktop, matching the SDK's own stance
- * that the configuration plane is loopback-same-origin only.
+ * The cookieless device credential: the boot patch reads the device id from
+ * the /pair-app URL, keeps it in sessionStorage, and attaches it to every
+ * gated HTTP call as this header (and to WebSocket upgrades as the `device`
+ * query parameter - WS handshakes cannot carry headers from the Web API).
+ * The channel gate accepts it exactly like the device cookie, so the mobile
+ * flow works even with browser cookies fully blocked; the cookie remains the
+ * primary credential on normal browsers.
+ */
+export declare const REMOTE_DEVICE_HEADER = "x-dsh-remote-device";
+export declare const REMOTE_DEVICE_QUERY = "device";
+/**
+ * Path prefixes that stay physically local even for a paired device. A
+ * paired remote desktop may use the full host API (chat, sessions,
+ * settings, credentials, presets — it is a full-control credential), but it
+ * must not reach the machine-control planes: pairing control itself, the
+ * dsh-web self-update installer, plugin install/remove, and desktop
+ * launcher actions (host shutdown, shortcuts).
+ */
+export declare const LOCAL_ONLY_PREFIXES: readonly string[];
+/**
+ * Whether a paired inner path must stay physically local.
+ * @param innerPath - the rewritten inner path (e.g. `/api/session.list`).
+ * @returns a denial message, or undefined when the path may be proxied.
  */
-export declare const LOOPBACK_ONLY_METHODS: Set<string>;
+export declare function localOnlyDenial(innerPath: string): string | undefined;
 //# sourceMappingURL=remote-methods.d.ts.map

package/lib/types/remote-methods.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"remote-methods.d.ts","sourceRoot":"","sources":["../../src/remote-methods.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,gFAAgF;AAChF,eAAO,MAAM,aAAa,YAAY,CAAA;AAEtC,+DAA+D;AAC/D,eAAO,MAAM,iBAAiB,gBAAyB,CAAA;AAEvD,qFAAqF;AACrF,eAAO,MAAM,gBAAgB;;;CAGnB,CAAA;AAEV;;;GAGG;AACH,eAAO,MAAM,oBAAoB,qKAMvB,CAAA;AAEV,wEAAwE;AACxE,eAAO,MAAM,mBAAmB,wBAAwB,CAAA;AAExD,6FAA6F;AAC7F,eAAO,MAAM,qBAAqB,8BAA8B,CAAA;AAEhE,iFAAiF;AACjF,eAAO,MAAM,2BAA2B,6BAA6B,CAAA;AAErE;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,aAgBhC,CAAA"}
+{"version":3,"file":"remote-methods.d.ts","sourceRoot":"","sources":["../../src/remote-methods.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,gFAAgF;AAChF,eAAO,MAAM,aAAa,YAAY,CAAA;AAEtC,+DAA+D;AAC/D,eAAO,MAAM,iBAAiB,gBAAyB,CAAA;AAEvD;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB;;CAEnB,CAAA;AAEV;;;GAGG;AACH,eAAO,MAAM,oBAAoB,0IAKvB,CAAA;AAEV,wEAAwE;AACxE,eAAO,MAAM,mBAAmB,wBAAwB,CAAA;AAExD,6FAA6F;AAC7F,eAAO,MAAM,qBAAqB,8BAA8B,CAAA;AAEhE,iGAAiG;AACjG,eAAO,MAAM,2BAA2B,6BAA6B,CAAA;AAErE;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,wBAAwB,CAAA;AACzD,eAAO,MAAM,mBAAmB,WAAW,CAAA;AAE3C;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,EAAE,SAAS,MAAM,EAKvC,CAAA;AAEV;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAOrE"}

package/lib/types/remote-methods.js

@@ -1,15 +1,31 @@
 /**
  * Remote desktop channel constants — SDK-independent so tests and the
  * client half can pin them without importing the host SDK graph.
+ *
+ * Access model on the 0.1.2-alpha.2 line: the host /api surface has no
+ * per-method privilege pin — the "configuration plane is local" behavior
+ * lives in the browser (client plugins branch on connection.isLoopback), and
+ * the paired remote desktop flips into host mode via the transport hook
+ * (ownsHost) while every call rides this gated channel as a loopback-shaped
+ * request. A paired device is therefore a full-control credential by
+ * design; the only paths that stay physically local are the control planes
+ * below (pairing control, self-update, plugin install/remove, host power).
  */
 /** Gated mirror of same-origin fenced paths (`/remote` + original pathname). */
 export const REMOTE_PREFIX = '/remote';
 /** Connection-plugin method prefix under the gated channel. */
 export const REMOTE_API_PREFIX = `${REMOTE_PREFIX}/api`;
-/** WebSocket event-stream paths served by the channel (client rewrites to these). */
+/**
+ * The gated mirrors of the official client WebSocket paths. On the pinned
+ * 0.1.2-alpha.2 line the client opens ONE persistent stream socket — the
+ * Typert gateway mux at `/api/remote.mux` — and every Remote stream
+ * (workspace follow, session feed, ...) rides it. If that socket is not
+ * rewritten onto the gated channel the phone's streams die at the connection
+ * fence and the UI shows an empty workspace/session mirror, so the mux is
+ * the one path that must never be missing here.
+ */
 export const REMOTE_API_PATHS = {
-    mux: `${REMOTE_API_PREFIX}/events.mux`,
-    host: `${REMOTE_API_PREFIX}/events.host`,
+    mux: `${REMOTE_API_PREFIX}/remote.mux`,
 };
 /**
  * Exact upgrade paths registered on webServer (the SDK matches upgrades by
@@ -17,7 +33,6 @@ export const REMOTE_API_PATHS = {
  */
 export const REMOTE_UPGRADE_PATHS = [
     REMOTE_API_PATHS.mux,
-    REMOTE_API_PATHS.host,
     `${REMOTE_PREFIX}/sidebar/ws/terminal`,
     `${REMOTE_PREFIX}/sidebar/ws/agent-terminals`,
     `${REMOTE_API_PREFIX}/dsh-ssh/terminal`,
@@ -26,29 +41,43 @@ export const REMOTE_UPGRADE_PATHS = [
 export const PLUGIN_MANAGER_PATH = '/api/plugin-manager';
 /** Desktop-launcher HTTP prefix: shortcut create and host shutdown stay physically local. */
 export const DESKTOP_LAUNCHER_PATH = '/api/dsh-desktop-launcher';
-/** Family settings-bridge HTTP prefix: describe/mutate stay physically local. */
+/** Family settings-bridge HTTP prefix — re-exposed to paired devices (plain settings parity). */
 export const WEB_UI_SETTINGS_BRIDGE_PATH = '/api/dsh-web-ui-settings';
 /**
- * Loopback-only methods of the host API surface, mirrored from
- * client-connection's `PRIVILEGED_METHODS` (pinned by
- * tests/remote-contract.spec.ts against the installed SDK). They stay
- * unreachable from a paired remote desktop, matching the SDK's own stance
- * that the configuration plane is loopback-same-origin only.
+ * The cookieless device credential: the boot patch reads the device id from
+ * the /pair-app URL, keeps it in sessionStorage, and attaches it to every
+ * gated HTTP call as this header (and to WebSocket upgrades as the `device`
+ * query parameter - WS handshakes cannot carry headers from the Web API).
+ * The channel gate accepts it exactly like the device cookie, so the mobile
+ * flow works even with browser cookies fully blocked; the cookie remains the
+ * primary credential on normal browsers.
+ */
+export const REMOTE_DEVICE_HEADER = 'x-dsh-remote-device';
+export const REMOTE_DEVICE_QUERY = 'device';
+/**
+ * Path prefixes that stay physically local even for a paired device. A
+ * paired remote desktop may use the full host API (chat, sessions,
+ * settings, credentials, presets — it is a full-control credential), but it
+ * must not reach the machine-control planes: pairing control itself, the
+ * dsh-web self-update installer, plugin install/remove, and desktop
+ * launcher actions (host shutdown, shortcuts).
+ */
+export const LOCAL_ONLY_PREFIXES = [
+    '/api/pair',
+    '/api/update',
+    PLUGIN_MANAGER_PATH,
+    DESKTOP_LAUNCHER_PATH,
+];
+/**
+ * Whether a paired inner path must stay physically local.
+ * @param innerPath - the rewritten inner path (e.g. `/api/session.list`).
+ * @returns a denial message, or undefined when the path may be proxied.
  */
-export const LOOPBACK_ONLY_METHODS = new Set([
-    'agentPreset.read',
-    'agentPreset.copy',
-    'agentPreset.openDocument',
-    'agentPreset.remove',
-    'host.pickDirectory',
-    'host.openPath',
-    'settings.describe',
-    'settings.openDocument',
-    'settings.update',
-    'settings.replace',
-    'settings.mutate',
-    'credentials.describe',
-    'credentials.set',
-    'credentials.unset',
-    'llm.discoverModels',
-]);
+export function localOnlyDenial(innerPath) {
+    for (const prefix of LOCAL_ONLY_PREFIXES) {
+        if (innerPath === prefix || innerPath.startsWith(`${prefix}/`)) {
+            return `${prefix.slice(1)} stays physically local and stays unreachable from a paired remote desktop`;
+        }
+    }
+    return undefined;
+}

package/lib/types/remote-presence-pet.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Remote-presence to pet-visibility link (user requirement): while at least
+ * one paired device is online (an active phone mirror session), the
+ * host-global pet is hidden through the pet's OWN hide switch (the
+ * PetService.setVisible RPC, the same one the pet's hide button uses);
+ * once the last device stays offline past a grace window, the pet is
+ * restored. The pet plugin is optional: without it (or on any pet failure)
+ * the link is a no-op - the remote-control feature never depends on the
+ * pet being installed.
+ *
+ * The visibility is host-global by design (the pet is host-global, no
+ * session dimension): the desktop and the phone share one pet, so the link
+ * hides it while the operator is away on a phone mirror and restores it
+ * when the mirror ends. A manual user hide is respected: if the pet is
+ * already hidden when the first device comes online, nothing is recorded
+ * and nothing is restored later.
+ */
+/** The pet service seam the link needs (structural slice, no package edge). */
+export interface PresencePetSeam {
+    /** RPC: show or hide the pet. */
+    setVisible(visible: boolean): Promise<unknown>;
+    /** Read the current display state (the visibility the user sees). */
+    state(): Promise<{
+        display?: {
+            visible?: boolean;
+        };
+    }>;
+}
+/** Dependencies of the presence link (all injectable for tests). */
+export interface PresencePetDeps {
+    /** Subscribe to pairing snapshot changes (fires with every state change). */
+    onState(listener: (snapshot: {
+        phase: string;
+        onlineCount: number;
+    }) => void): () => void;
+    /** Resolve the pet service seam (undefined when the pet plugin is absent). */
+    pet(): PresencePetSeam | undefined;
+    /** Grace before restoring the pet after the last device went offline. */
+    restoreAfterMs?: number;
+    timers?: {
+        setTimeout(fn: () => void, ms: number): unknown;
+        clearTimeout(t: unknown): void;
+    };
+}
+/**
+ * Start the presence link. Returns the disposer (withdraws the state
+ * subscription and cancels a pending restore).
+ * @param deps - pairing stream + pet seam (+ test seams).
+ */
+export declare function startRemotePresencePet(deps: PresencePetDeps): () => void;
+//# sourceMappingURL=remote-presence-pet.d.ts.map

package/lib/types/remote-presence-pet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote-presence-pet.d.ts","sourceRoot":"","sources":["../../src/remote-presence-pet.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,+EAA+E;AAC/E,MAAM,WAAW,eAAe;IAC9B,iCAAiC;IACjC,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAC9C,qEAAqE;IACrE,KAAK,IAAI,OAAO,CAAC;QAAE,OAAO,CAAC,EAAE;YAAE,OAAO,CAAC,EAAE,OAAO,CAAA;SAAE,CAAA;KAAE,CAAC,CAAA;CACtD;AAED,oEAAoE;AACpE,MAAM,WAAW,eAAe;IAC9B,6EAA6E;IAC7E,OAAO,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,GAAG,MAAM,IAAI,CAAA;IACzF,8EAA8E;IAC9E,GAAG,IAAI,eAAe,GAAG,SAAS,CAAA;IAClC,yEAAyE;IACzE,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,MAAM,CAAC,EAAE;QACP,UAAU,CAAC,EAAE,EAAE,MAAM,IAAI,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAA;QAC/C,YAAY,CAAC,CAAC,EAAE,OAAO,GAAG,IAAI,CAAA;KAC/B,CAAA;CACF;AASD;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,eAAe,GAAG,MAAM,IAAI,CA4ExE"}