dshost-plugin 0.1.5 → 0.1.8

package/lib/core.js

@@ -105,14 +105,87 @@ function collectDisks() {
   return disks;
 }
 
+/**
+ * Locate the dsh runtime this agent actually serves and reports.
+ *
+ * dsh >= 0.1.2 installs are frequently built from a source checkout with
+ * /usr/bin/dsh symlinked into it (e.g. /root/dsh-src/apps/cli/lib/bin.js),
+ * which leaves the historical hardcoded npm-global package.json stale the
+ * moment the host upgrades — the dashboard then keeps showing the previous
+ * release's version forever. Resolution order:
+ *   1. DSH_VERSION env var (explicit pin / tests)
+ *   2. the CLI entry that started this process (the plugin runs inside
+ *      `dsh web`, so process.argv[1] IS the runtime, symlink included)
+ *   3. the first `dsh` executable on PATH (standalone agent / manual runs)
+ *   4. legacy npm global install path (dsh <= 0.1.1 behavior)
+ * Only a package.json of the dsh package itself is accepted while walking
+ * up, so an unrelated ancestor package (this repo's own package.json among
+ * them) can never be mistaken for the runtime.
+ * @returns {{version?: string, root?: string}}
+ */
+function findDshRuntime() {
+  if (process.env.DSH_VERSION) return { version: process.env.DSH_VERSION };
+  const entryPoints = [];
+  const pushEntry = (p) => { try { entryPoints.push(fs.realpathSync(p)); } catch {} };
+  if (process.argv[1]) pushEntry(process.argv[1]);
+  try {
+    for (const dir of (process.env.PATH || '').split(path.delimiter)) {
+      if (!dir) continue;
+      const bin = path.join(dir, 'dsh');
+      let st = null;
+      try { st = fs.statSync(bin); } catch { continue; }
+      if (st.isFile()) { pushEntry(bin); break; }
+    }
+  } catch {}
+  for (const entry of entryPoints) {
+    let dir = path.dirname(entry);
+    for (let depth = 0; depth < 8; depth++) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8'));
+        const name = pkg.name || '';
+        if (pkg.version && (name === '@deepseek-ai/dsh' || name === 'dsh' || name.startsWith('@deepseek-ai/dsh'))) {
+          return { version: pkg.version, root: dir };
+        }
+      } catch {}
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  }
+  try {
+    const legacyRoot = '/usr/lib/node_modules/@deepseek-ai/dsh';
+    const pkg = JSON.parse(fs.readFileSync(path.join(legacyRoot, 'package.json'), 'utf8'));
+    if (pkg.version) return { version: pkg.version, root: legacyRoot };
+  } catch {}
+  return {};
+}
+
+/** Version of <name> as installed under <rootDir>/node_modules, or ''. */
+function pluginVersionAt(rootDir, name) {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(rootDir, 'node_modules', name, 'package.json'), 'utf8')).version || '';
+  } catch { return ''; }
+}
+
 /** Automatically detect local DSH runtime metadata (version + installed profile plugins with exact versions) */
 function detectDshMetadata() {
-  let dshVersion = '0.1.0-rc.7';
+  const runtime = findDshRuntime();
+  const dshVersion = runtime.version || '0.1.0-rc.7';
+  // Where bundled dsh plugins may live: the runtime package itself plus the
+  // workspace roots above it (source-checkout / pnpm layouts hoist deps to
+  // the repo root), then the legacy npm global install.
+  const dshModuleRoots = [];
+  if (runtime.root) {
+    let dir = runtime.root;
+    for (let depth = 0; depth < 3; depth++) {
+      dshModuleRoots.push(dir);
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  }
+  dshModuleRoots.push('/usr/lib/node_modules/@deepseek-ai/dsh');
   let plugins = [];
-  try {
-    const pkg = JSON.parse(fs.readFileSync('/usr/lib/node_modules/@deepseek-ai/dsh/package.json', 'utf8'));
-    if (pkg.version) dshVersion = pkg.version;
-  } catch {}
   try {
     const profileDir = os.homedir() + '/.dsh/profiles/web';
     const profilePkgPath = profileDir + '/package.json';
@@ -129,12 +202,12 @@ function detectDshMetadata() {
           const p1 = profileDir + '/node_modules/' + name + '/package.json';
           if (fs.existsSync(p1)) ver = JSON.parse(fs.readFileSync(p1, 'utf8')).version || '';
         } catch {}
-        // 2. Check dsh embedded node_modules (for dsh bundles)
+        // 2. Check dsh runtime node_modules (npm global / source checkout)
         if (!ver) {
-          try {
-            const p2 = '/usr/lib/node_modules/@deepseek-ai/dsh/node_modules/' + name + '/package.json';
-            if (fs.existsSync(p2)) ver = JSON.parse(fs.readFileSync(p2, 'utf8')).version || '';
-          } catch {}
+          for (const root of dshModuleRoots) {
+            ver = pluginVersionAt(root, name);
+            if (ver) break;
+          }
         }
         // 3. Check global node_modules
         if (!ver) {
@@ -193,6 +266,7 @@ export function collectSystemInfo(defaultVersion) {
  * @param {string} [opts.version]    agent version reported at registration
  * @param {string} [opts.dshHost]    local dsh host (default 127.0.0.1)
  * @param {number} [opts.dshPort]    local dsh port (default 3080)
+ * @param {string} [opts.webToken]   local dsh web launch token (dsh >= 0.1.2 auth mode)
  * @param {object} [opts.log]        logger with log/warn/error (default console)
  * @param {string} [opts.dshVersion] reported dsh version (default rc.6)
  * @returns {{ stop: () => void }}
@@ -217,6 +291,60 @@ export function startAgent(opts) {
     return { stop() {} };
   }
 
+  // ── Local web auth (dsh >= 0.1.2 one-time launch token → signed cookie) ──
+  // dsh 0.1.2 gates its web UI behind a per-process launch token: GET
+  // /?token=X mints a signed authority-bound browser cookie, everything else
+  // 401s. When the plugin runs inside the dsh host process it hands us the
+  // live token via setWebToken() (see plugin index.js ctx.inject hook);
+  // standalone agents can use DSH_WEB_TOKEN. With a token on file we mint a
+  // cookie once and inject it into proxied HTTP/WS requests; a 401 drops the
+  // cookie and re-mints (covers dsh restarts rotating the token). On
+  // dsh <= 0.1.1 there is no web auth: with no token source nothing is
+  // injected and behavior is identical to plugin 0.1.5 (ApiProxy era).
+  let webToken = opts.webToken || process.env.DSH_WEB_TOKEN || null;
+  let authCookie = null;
+  let minting = null;
+
+  function mintAuthCookie() {
+    if (minting) return minting;
+    if (!webToken) return Promise.resolve(null);
+    minting = new Promise((resolve) => {
+      const req = http.get(
+        `http://${dshHost}:${dshPort}/?token=${encodeURIComponent(webToken)}`,
+        { timeout: 5000 },
+        (res) => {
+          res.resume();
+          const set = res.headers['set-cookie'];
+          if (res.statusCode === 303 && Array.isArray(set) && set[0]) {
+            authCookie = set[0].split(';')[0];
+            log.log?.('[agent] local web auth cookie minted');
+            resolve(authCookie);
+          } else {
+            log.warn?.(`[agent] local web auth mint failed (HTTP ${res.statusCode})`);
+            resolve(null);
+          }
+        },
+      );
+      req.on('timeout', () => req.destroy(new Error('mint timeout')));
+      req.on('error', (err) => {
+        log.warn?.(`[agent] local web auth mint error: ${err.message}`);
+        resolve(null);
+      });
+    });
+    minting.then(() => { minting = null; }, () => { minting = null; });
+    return minting;
+  }
+
+  function setWebToken(token) {
+    if (!token || token === webToken) return;
+    webToken = token;
+    authCookie = null;
+    log.log?.('[agent] web launch token acquired (dsh 0.1.2 auth mode)');
+    mintAuthCookie();
+  }
+
+  if (webToken) mintAuthCookie();
+
   const streams = new Map();
   let registered = false;
   let reconnectTimer = null;
@@ -266,7 +394,9 @@ export function startAgent(opts) {
         const stream = streams.get(msg.streamId);
         if (stream && stream.dshReq) stream.dshReq.end();
       } else if (msg.type === 'ws:open') {
-        handleWsOpen(ws, msg);
+        // dsh >= 0.1.2: make sure the auth cookie exists before the upgrade.
+        if ((webToken || authCookie) && !authCookie) mintAuthCookie().then(() => handleWsOpen(ws, msg));
+        else handleWsOpen(ws, msg);
       } else if (msg.type === 'ws:frame') {
         const stream = streams.get(msg.streamId);
         if (stream && stream.dshWs) {
@@ -418,67 +548,129 @@ export function startAgent(opts) {
     return true;
   }
 
-  function handleHttpRequest(ws, msg) {
-    const { streamId, method, path, headers } = msg;
+  function respondError(ws, streamId, status, message) {
+    send(ws, {
+      type: 'http:response',
+      streamId,
+      status,
+      headers: { 'content-type': 'text/plain; charset=utf-8', 'cache-control': 'no-store' },
+    });
+    send(ws, { type: 'http:data', streamId, data: b64(Buffer.from(message)) });
+    send(ws, { type: 'http:end-response', streamId });
+    streams.delete(streamId);
+  }
 
-    const dshHeaders = {
-      ...headers,
-      host: `${dshHost}:${dshPort}`,
-      origin: `http://${dshHost}:${dshPort}`,
-    };
-    delete dshHeaders['content-length'];
-
-    const dshReq = http.request({
-      hostname: dshHost,
-      port: dshPort,
-      path,
-      method,
-      headers: dshHeaders,
-    }, (dshRes) => {
-      send(ws, {
-        type: 'http:response',
-        streamId,
-        status: dshRes.statusCode,
-        headers: dshRes.headers,
-      });
+  function handleHttpRequest(ws, msg, isRetry) {
+    const { streamId, method, path, headers } = msg;
 
-      // Backpressure: pause reading from dsh when the relay link is slow.
-      // NOTE: the ws library does NOT emit 'drain' (verified), so resume is
-      // driven by polling bufferedAmount down below the high-water mark —
-      // a once('drain') here would never fire and would deadlock (truncated
-      // responses, hanging browsers).
-      dshRes.on('data', (chunk) => {
-        if (ws.bufferedAmount > WS_SEND_HIGH_WATER) {
-          dshRes.pause();
-          const resumeWhenDrained = () => {
-            if (ws.readyState !== WebSocket.OPEN) return;
-            if (ws.bufferedAmount < WS_SEND_HIGH_WATER / 2) {
-              dshRes.resume();
-            } else {
-              setTimeout(resumeWhenDrained, 50);
-            }
-          };
-          setTimeout(resumeWhenDrained, 50);
+    // dsh >= 0.1.2 web auth: inject the minted browser cookie when we have
+    // one. dsh <= 0.1.1 has no web auth; with no token/cookie nothing is
+    // injected and requests go out exactly like plugin 0.1.5 sent them.
+    const issue = (cookie) => {
+      const dshHeaders = {
+        ...headers,
+        host: `${dshHost}:${dshPort}`,
+        origin: `http://${dshHost}:${dshPort}`,
+      };
+      if (cookie) dshHeaders.cookie = cookie;
+      delete dshHeaders['content-length'];
+
+      const dshReq = http.request({
+        hostname: dshHost,
+        port: dshPort,
+        path,
+        method,
+        headers: dshHeaders,
+      }, (dshRes) => {
+        if (dshRes.statusCode === 401 && cookie) {
+          // Cached cookie rejected (launch token rotated, e.g. dsh restarted).
+          // Re-mint; body-less requests are retried once with the fresh
+          // cookie, everything else forwards the 401 and the browser app
+          // retries its next action with the fresh cookie.
+          dshRes.resume();
+          authCookie = null;
+          const remint = mintAuthCookie();
+          if ((method === 'GET' || method === 'HEAD') && !isRetry) {
+            log.log?.('[agent] local dsh 401, re-minting web auth cookie and retrying');
+            remint.then((c) => {
+              if (c) handleHttpRequest(ws, msg, true);
+              else respondError(ws, streamId, 502, 'dsh-remote: local web auth re-mint failed');
+            });
+          } else {
+            log.log?.('[agent] local dsh 401 on body request, re-minting web auth cookie for next requests');
+          }
+          return;
         }
-        send(ws, { type: 'http:data', streamId, data: b64(chunk) });
-      });
-      dshRes.on('end', () => {
-        send(ws, { type: 'http:end-response', streamId });
-        streams.delete(streamId);
+        const respHeaders = { ...dshRes.headers };
+        // The dsh index carries no cache-control; a heuristically cached stale
+        // HTML from a previous build references dead module revs and breaks
+        // the client module system. HTML must always revalidate.
+        if (String(respHeaders['content-type'] || '').includes('text/html')) {
+          respHeaders['cache-control'] = 'no-store';
+        }
+        send(ws, {
+          type: 'http:response',
+          streamId,
+          status: dshRes.statusCode,
+          headers: respHeaders,
+        });
+
+        // Backpressure: pause reading from dsh when the relay link is slow.
+        // NOTE: the ws library does NOT emit 'drain' (verified), so resume is
+        // driven by polling bufferedAmount down below the high-water mark —
+        // a once('drain') here would never fire and would deadlock (truncated
+        // responses, hanging browsers).
+        dshRes.on('data', (chunk) => {
+          if (ws.bufferedAmount > WS_SEND_HIGH_WATER) {
+            dshRes.pause();
+            const resumeWhenDrained = () => {
+              if (ws.readyState !== WebSocket.OPEN) return;
+              if (ws.bufferedAmount < WS_SEND_HIGH_WATER / 2) {
+                dshRes.resume();
+              } else {
+                setTimeout(resumeWhenDrained, 50);
+              }
+            };
+            setTimeout(resumeWhenDrained, 50);
+          }
+          send(ws, { type: 'http:data', streamId, data: b64(chunk) });
+        });
+        dshRes.on('end', () => {
+          send(ws, { type: 'http:end-response', streamId });
+          streams.delete(streamId);
+        });
+        dshRes.on('error', () => {
+          send(ws, { type: 'error', streamId, message: 'Local dsh response error' });
+          streams.delete(streamId);
+        });
       });
-      dshRes.on('error', () => {
-        send(ws, { type: 'error', streamId, message: 'Local dsh response error' });
+
+      dshReq.on('error', (err) => {
+        log.error?.(`[agent] HTTP Error: ${err.message}`);
+        send(ws, { type: 'error', streamId, message: err.message });
         streams.delete(streamId);
       });
-    });
 
-    dshReq.on('error', (err) => {
-      log.error?.(`[agent] HTTP Error: ${err.message}`);
-      send(ws, { type: 'error', streamId, message: err.message });
-      streams.delete(streamId);
-    });
+      streams.set(streamId, { dshReq, dshRes: null, chunks: [] });
 
-    streams.set(streamId, { dshReq, dshRes: null, chunks: [] });
+      // Body-less requests are complete the moment they are created: end them
+      // now so a 401-retry (whose http:end frame was already consumed by the
+      // first attempt) still transmits. The later http:end frame, when it
+      // arrives, calls dshReq.end() again — a safe no-op. Body-bearing
+      // requests keep waiting for http:body/http:end frames as before.
+      if (method === 'GET' || method === 'HEAD') dshReq.end();
+    };
+
+    if ((webToken || authCookie) && !authCookie) {
+      // A token is known but the eager mint has not landed yet (startup
+      // race): mint first, then issue. Body frames arriving during the mint
+      // window are dropped (no streams entry yet) — only POSTs racing the
+      // very first mint are affected; the eager mint on token acquisition
+      // makes this path practically unreachable.
+      mintAuthCookie().then((c) => issue(c));
+    } else {
+      issue(authCookie || undefined);
+    }
   }
 
   function handleWsOpen(ws, msg) {
@@ -494,6 +686,8 @@ export function startAgent(opts) {
       },
       rejectUnauthorized: false,
     };
+    // dsh >= 0.1.2 gates the WS upgrade behind the same browser cookie.
+    if (authCookie) options.headers.cookie = authCookie;
 
     const dshWs = new WebSocket(dshWsUrl, undefined, options);
     const pending = [];
@@ -552,6 +746,8 @@ export function startAgent(opts) {
   connect();
 
   return {
+    /** Provide the local dsh web launch token (dsh >= 0.1.2 auth mode). */
+    setWebToken,
     stop() {
       if (heartbeatInterval) clearInterval(heartbeatInterval);
       if (reconnectTimer) clearTimeout(reconnectTimer);

package/lib/index.js

@@ -16,26 +16,54 @@ export function apply(ctx, config) {
   const relayUrl = config.relayUrl || process.env.DSH_RELAY_URL || 'wss://relay.example.com/agent';
   const autoConnect = config.autoConnect !== false;
   // Local dsh instance this plugin proxies (config-overridable for tests/dev)
-  const dshHost = config.dshHost || process.env.DSH_HOST || '127.0.0.1';
-  const dshPort = parseInt(config.dshPort || process.env.DSH_PORT || '3080', 10);
+  const dshHost = config.dshHost || process.env.DSH_HOST || DSH_HOST;
+  const dshPort = parseInt(config.dshPort || process.env.DSH_PORT || String(DSH_PORT), 10);
 
   console.log('[dsh-remote] Plugin loaded, token:', token ? '***' : 'none');
 
   if (!token) {
     console.warn('[dsh-remote] No token configured. Please set token in settings.');
-    return;
+    return { setWebToken() {}, stop() {} };
   }
 
   if (!autoConnect) {
     console.log('[dsh-remote] Auto-connect disabled.');
-    return;
+    return { setWebToken() {}, stop() {} };
   }
 
   // Start the agent connection (wss enforcement lives in core.js)
-  startAgent({
+  const agent = startAgent({
     token,
     relayUrl,
     dshHost,
     dshPort,
   });
+
+  // dsh >= 0.1.2 web auth: the web UI is gated behind a per-process one-time
+  // launch token (the @Remote gateway era replaced the plain ApiProxy surface
+  // and added BrowserAuth on the shared /api FetchHandler). Our agent runs
+  // inside the host process, so it asks the connection service for the
+  // authenticated URL and mints a browser cookie for all proxied traffic.
+  // dsh <= 0.1.1 has no 'connection' service: the guarded inject below never
+  // fires and the plugin keeps its 0.1.5 behavior — one build, both hosts.
+  try {
+    if (ctx && typeof ctx.inject === 'function') {
+      ctx.inject(['connection'], (connectionCtx) => {
+        try {
+          const conn = connectionCtx && connectionCtx.connection;
+          if (!conn || typeof conn.authenticatedUrl !== 'function') return;
+          const url = conn.authenticatedUrl(`http://${dshHost}:${dshPort}/`);
+          const webToken = new URL(url).searchParams.get('token');
+          if (webToken) agent.setWebToken(webToken);
+        } catch (err) {
+          console.warn('[dsh-remote] web launch token acquisition failed:', err && err.message);
+        }
+      });
+    }
+  } catch {
+    // Non-cordis ctx (smoke tests) or an older host without the service
+    // registry shape: legacy mode, no web auth injection.
+  }
+
+  return agent;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dshost-plugin",
-  "version": "0.1.5",
+  "version": "0.1.8",
   "description": "Official remote cloud relay plugin for DSHost (dshost.me): securely access your dsh Web UI from anywhere",
   "type": "module",
   "main": "lib/index.js",