@twinsearth/w2m-dsh-plugin 1.1.18 → 1.1.19

package/src/plugin/fleet-chat-route.mjs

@@ -0,0 +1,120 @@
+/**
+ * `/api/w2m/chat` — the browser-facing half of fleet chat (v1.1.17 shipped the tool only; this
+ * module is the missing host route the composer's chat panel calls).
+ *
+ * The route proxies the relay's device-gated `/v1/fleet/messages` endpoints with this machine's
+ * device token. The browser never sees the token: it calls this same-origin route, which is inside
+ * the host's authentication fence, exactly like `/api/w2m/target`.
+ *
+ * Wire:
+ *   GET  /api/w2m/chat?session_id=…&since_ms=…&limit=…   -> relay list shape passed through
+ *   POST /api/w2m/chat  { session_id, text }              -> relay send shape passed through
+ *
+ * Failure is a value here: `{ok:false, error, reason_code, detail}` with a non-2xx status, so the
+ * panel can print the host's own words. A relay that predates the fleet-messages routes answers
+ * 404, which is reported as such rather than as an empty conversation.
+ */
+export const CHAT_ROUTE_PATH = '/api/w2m/chat';
+export const MAX_SESSION_ID_LENGTH = 200;
+
+const NO_STORE = { 'cache-control': 'no-store' };
+
+/**
+ * Attach the route to one host's fetch registry, recording the outcome on `status`.
+ *
+ * @param {object} ctx the plugin context (a Cordis fiber)
+ * @param {{cfg: () => object, request: Function, resolveToken: () => Promise<string|null>}} deps
+ * @returns {{mounted: boolean, reason: string|null}}
+ */
+export function registerChatRoutes(ctx, deps) {
+  const status = { mounted: false, reason: 'the host has no Connection service' };
+  if (typeof ctx?.inject !== 'function') return status;
+  ctx.inject(['connection'], (webCtx) => {
+    const registry = webCtx?.connection?.fetch;
+    if (registry === undefined || registry === null || typeof registry.register !== 'function') {
+      status.reason = 'the connection service carries no fetch registry';
+      return;
+    }
+    try {
+      registry.register({
+        path: CHAT_ROUTE_PATH,
+        methods: ['GET', 'POST'],
+        requestBody: 'buffered',
+        fetch: async (request) => {
+          const refuse = (httpStatus, reasonCode, error, detail) =>
+            Response.json({ ok: false, error, reason_code: reasonCode, detail }, { status: httpStatus, headers: NO_STORE });
+
+          if (request.method !== 'GET' && request.method !== 'POST') {
+            return refuse(405, 'CHAT_METHOD_NOT_ALLOWED', `${request.method} is not answered here`, 'GET lists a session; POST sends a message');
+          }
+
+          const url = new URL(request.url);
+          const sessionIdOf = (value) => (typeof value === 'string' ? value.trim() : '');
+          let sessionId = '';
+          let text = null;
+          if (request.method === 'GET') {
+            sessionId = sessionIdOf(url.searchParams.get('session_id'));
+          } else {
+            let body;
+            try {
+              body = await request.json();
+            } catch {
+              return refuse(400, 'CHAT_BODY_NOT_JSON', 'body is not JSON', 'send {"session_id":"…","text":"…"}');
+            }
+            sessionId = sessionIdOf(body?.session_id);
+            text = typeof body?.text === 'string' ? body.text : null;
+          }
+          if (sessionId === '') return refuse(400, 'CHAT_SESSION_ID_REQUIRED', '`session_id` is required', 'chat is scoped to one conversation');
+          if (sessionId.length > MAX_SESSION_ID_LENGTH) {
+            return refuse(400, 'CHAT_SESSION_ID_TOO_LONG', `\`session_id\` must be at most ${MAX_SESSION_ID_LENGTH} characters`, 'send the id the host gave this session');
+          }
+
+          const cfg = deps.cfg();
+          const rabbitUrl = cfg?.rabbitUrl ?? null;
+          if (rabbitUrl === null) return refuse(503, 'CHAT_NO_RELAY', 'no relay is configured', 'set rabbitUrl in the profile patch');
+          let token;
+          try {
+            token = await deps.resolveToken();
+          } catch (error) {
+            return refuse(503, 'CHAT_UNPAIRED', `this machine has no device token: ${error instanceof Error ? error.message : String(error)}`, 'pair the machine first (autoStartAgent or a pairing code)');
+          }
+          if (typeof token !== 'string' || token === '') {
+            return refuse(503, 'CHAT_UNPAIRED', 'this machine has no device token', 'pair the machine first (autoStartAgent or a pairing code)');
+          }
+
+          try {
+            if (request.method === 'GET') {
+              const query = { session_id: sessionId };
+              const sinceMs = url.searchParams.get('since_ms');
+              const limit = url.searchParams.get('limit');
+              if (sinceMs !== null && /^\d+$/.test(sinceMs)) query.since_ms = sinceMs;
+              if (limit !== null && /^\d+$/.test(limit)) query.limit = limit;
+              const listed = await deps.request({ rabbitUrl, token, method: 'GET', pathname: '/v1/fleet/messages', query, signal: request.signal });
+              if (listed?.ok !== true) {
+                const code = listed?.json?.error?.code ?? listed?.error?.code ?? 'CHAT_LIST_REFUSED';
+                const message = listed?.json?.error?.message ?? listed?.error?.message ?? `the relay answered HTTP ${listed?.status ?? 0}`;
+                return refuse(listed?.status === 404 ? 502 : 502, code, message, 'the relay must run a version with /v1/fleet/messages (>= 1.1.17) and be restarted');
+              }
+              return Response.json({ ...listed.json, ok: true }, { headers: NO_STORE });
+            }
+            const posted = await deps.request({ rabbitUrl, token, method: 'POST', pathname: '/v1/fleet/messages', body: { session_id: sessionId, text: text ?? '' }, signal: request.signal });
+            if (posted?.ok !== true) {
+              const code = posted?.json?.error?.code ?? posted?.error?.code ?? 'CHAT_SEND_REFUSED';
+              const message = posted?.json?.error?.message ?? posted?.error?.message ?? `the relay answered HTTP ${posted?.status ?? 0}`;
+              return refuse(posted?.status === 404 ? 502 : 400, code, message, 'quota, size and non-text are each refused by name; 404 means the relay predates fleet chat');
+            }
+            return Response.json({ ...posted.json, ok: true }, { headers: NO_STORE });
+          } catch (error) {
+            return refuse(502, 'CHAT_RELAY_ERROR', `the relay call failed: ${error instanceof Error ? error.message : String(error)}`, 'check the relay and this machine token');
+          }
+        },
+      });
+      status.mounted = true;
+      status.reason = null;
+    } catch (error) {
+      status.reason = error instanceof Error ? error.message : String(error);
+      ctx?.logger?.warn?.(`w2m: the fleet chat route is inactive — ${status.reason}`);
+    }
+  });
+  return status;
+}

package/src/plugin/tools.mjs

@@ -180,6 +180,9 @@ import {
   sessionKeyFor,
   TARGET_ROUTE_PATH,
 } from './fleet-target.mjs';
+// v1.1.17 chat: the host route behind the composer's fleet-chat panel. The relay side and the
+// `w2m_chat` tool shipped first; this is the browser-facing half that was still missing.
+import { registerChatRoutes } from './fleet-chat-route.mjs';
 // v0.7.0: the LAN hint layer. Imported here and used in exactly one place (`w2m_devices`); see the
 // module header for why a discovered device is a candidate to *ask* and never an authorisation.
 import { createDiscoverySource } from './mdns-discover.mjs';
@@ -217,7 +220,7 @@ const MAX_STAGES = 16;
  * `package.json` during `scripts/pack.mjs` rather than hand-maintained, and `W2M_PLUGIN_VERSION`
  * overrides it at runtime for tests and packagers.
  */
-const PLUGIN_VERSION = '1.1.18';
+const PLUGIN_VERSION = '1.1.19';
 
 /** How long any single HTTP call may take before it is aborted, in milliseconds. */
 const DEFAULT_REQUEST_TIMEOUT_MS = 15_000;
@@ -3401,6 +3404,20 @@ export async function apply(ctx, config = {}) {
     resolveToken,
   });
 
+  // The composer's fleet-chat panel: `GET/POST /api/w2m/chat`, proxied to the relay's device-gated
+  // `/v1/fleet/messages`. Optional like the target routes — a host without Connection keeps every
+  // tool and the panel is simply not mounted.
+  const chatRoutes = registerChatRoutes(ctx, {
+    cfg: () => cfg,
+    request,
+    resolveToken: () => resolveToken(cfg),
+  });
+  if (chatRoutes.mounted !== true) {
+    // Named rather than silent: a composition without the fetch registry loses the chat panel while every tool still
+    // works, and "the panel is missing" with no line anywhere is the shape this project keeps paying for.
+    ctx.logger?.warn?.('w2m: the fleet-chat composer route is not mounted (' + (chatRoutes.reason ?? 'unknown reason') + ')');
+  }
+
   // The LAN discovery source (v0.7.0). Constructing it binds nothing: a socket is opened only when a
   // scan is asked for, and only `w2m_devices` asks. A network where multicast is unavailable produces
   // one log line and an `available: false` block in the answer - never a failure of the tool.
@@ -6320,10 +6337,14 @@ export async function apply(ctx, config = {}) {
       const action = typeof args?.action === 'string' ? args.action : 'list';
       const sessionId = typeof args?.session_id === 'string' ? args.session_id.trim() : '';
       if (sessionId === '') throw new W2MError('W2M_CHAT_SESSION', 'W2M_CHAT_SESSION: session_id is required', { hint: 'chat is scoped to a conversation' });
-      const device = await readDevice(cfg);
       const rabbitUrl = cfg.rabbitUrl ?? null;
       if (rabbitUrl === null) throw new W2MError('W2M_NO_RELAY', 'W2M_NO_RELAY: no relay is configured, so chat cannot be reached', { hint: 'set rabbitUrl in the profile patch' });
-      const token = requireToken(device);
+      // resolveToken, not readDevice: readDevice returns an empty identity whenever `stateDir` is
+      // unset, even though this machine's device.json exists at the default DSH_HOME path — every
+      // other device-authenticated tool goes through resolveToken for exactly that reason, and this
+      // one reported W2M_NO_TOKEN on a machine that was paired and answering every other call.
+      const token = await resolveToken(cfg);
+      if (token === null) throw new W2MError('W2M_NO_TOKEN', 'W2M_NO_TOKEN: this machine has no device token, so chat cannot be authenticated', { hint: 'pair this machine first (autoStartAgent or a pairing code), then retry' });
       if (action === 'send') {
         const posted = await request({ rabbitUrl, token, signal: exec?.signal, method: 'POST', pathname: '/v1/fleet/messages', body: { session_id: sessionId, text: typeof args?.text === 'string' ? args.text : '' } });
         if (posted?.ok !== true) {