dsh-phone-bridge 0.2.6 → 0.2.8

package/index.js

@@ -244,6 +244,32 @@ const REQUIRED_CONTROLLER_METHODS = [
   "selectModel",
 ];
 
+// The DSH version this build was last exercised against. Bumped by hand when the
+// plugin is re-tested on a newer DSH. It is not a compatibility claim, only the
+// value /health compares the running version to, so that a mismatch shows up as a
+// sentence rather than as a mystery.
+const TESTED_WITH_DSH = "0.2.0-rc.2";
+
+// Best effort. The plugin runs inside the DSH process, and Electron patches fs so
+// an app.asar reads like a directory, which is what makes this possible at all.
+// Returns null when it cannot be read; /health says so rather than guessing.
+function readDshVersion() {
+  const candidates = [];
+  if (process.resourcesPath) {
+    candidates.push(join(process.resourcesPath, "app.asar", "package.json"));
+    candidates.push(join(process.resourcesPath, "app", "package.json"));
+  }
+  for (const candidate of candidates) {
+    try {
+      const parsed = JSON.parse(readFileSync(candidate, "utf8"));
+      if (parsed?.version) return { name: parsed.name ?? null, version: parsed.version };
+    } catch {
+      // try the next candidate
+    }
+  }
+  return null;
+}
+
 // A session lives at sessions/<slug-of-cwd>/<sessionId>/, where the slug is a
 // lossy encoding of the working directory. Locate it by scanning instead of
 // trying to re-derive that encoding.
@@ -943,29 +969,74 @@ export function apply(ctx, config = {}) {
         }
         const sessionController = ctx.get("sessionController");
         if (!sessionController) throw new Error("sessionController is unavailable");
-        if (typeof sessionController.page !== "function") {
-          throw new Error("this DSH build does not expose sessionController.page");
-        }
 
         const signal = new AbortController().signal;
-        // throughSeq: -1 means "the newest page"; maxMessages stays well above the
-        // requested count because assistant and tool events sit between the user's.
-        const page = await sessionController.page({
-          address: { kind: "session", sessionId },
-          throughSeq: -1,
-          maxMessages: 200,
-        }, signal);
+        const traces = {};
+
+        // Two ways in, tried in order.
+        //
+        // inspect() hands back the event list outright (SessionInspection.events),
+        // so it needs no cursor. page() does need one: throughSeq is an absolute
+        // sequence, and -1 is not "newest" but "nothing", since paginate starts at
+        // end = throughSeq + 1 = 0 and walks backwards from -1. That misreading is
+        // what made the first version answer ok with zero messages.
+        let events = [];
+        let used = null;
+
+        if (typeof sessionController.inspect === "function") {
+          try {
+            const inspection = await sessionController.inspect(sessionId, signal);
+            const list = Array.isArray(inspection?.events) ? inspection.events : [];
+            traces.inspect = {
+              eventCount: list.length,
+              firstSeq: list[0]?.seq ?? null,
+              lastSeq: list[list.length - 1]?.seq ?? null,
+            };
+            if (list.length) {
+              events = list;
+              used = "inspect";
+            }
+          } catch (error) {
+            traces.inspect = { error: String(error?.message ?? error) };
+          }
+        }
+
+        if (!events.length && typeof sessionController.page === "function") {
+          try {
+            // Page from whatever cursor inspect gave us, else from the very start.
+            const cursor = Number(traces.inspect?.lastSeq ?? 0);
+            const page = await sessionController.page({
+              address: { kind: "session", sessionId },
+              throughSeq: Number.isSafeInteger(cursor) && cursor >= 0 ? cursor : 0,
+              maxMessages: 400,
+            }, signal);
+            const list = (page?.records ?? []).map((record) => record?.event).filter(Boolean);
+            traces.page = {
+              cursor,
+              recordCount: list.length,
+              hasMore: page?.hasMore ?? null,
+              firstSeq: list[0]?.seq ?? null,
+              lastSeq: list[list.length - 1]?.seq ?? null,
+            };
+            if (list.length) {
+              events = list;
+              used = "page";
+            }
+          } catch (error) {
+            traces.page = { error: String(error?.message ?? error) };
+          }
+        }
 
         const texts = [];
-        const allRecords = page?.records ?? [];
         const typeTally = {};
         let firstUserEvent = null;
-        for (const record of allRecords) {
-          const event = record?.event;
+        let userEventCount = 0;
+        for (const event of events) {
           if (!event) continue;
           const key = event.type ?? "(none)";
           typeTally[key] = (typeTally[key] ?? 0) + 1;
           if (event.type !== "user/message") continue;
+          userEventCount += 1;
           if (!firstUserEvent) firstUserEvent = event;
           if (event?.data?.source?.kind !== "user") continue;
           const text = textFromContentBlocks(event.data.content);
@@ -976,6 +1047,7 @@ export function apply(ctx, config = {}) {
         const payload = {
           ok: true,
           sessionId,
+          source: used,
           total: texts.length,
           // Newest last, so the caller can slice from the end.
           messages: texts.slice(-limit),
@@ -986,12 +1058,13 @@ export function apply(ctx, config = {}) {
         // why is to look at what actually arrived. Loopback-only, and truncated.
         if ((url.searchParams.get("debug") ?? "") === "1") {
           payload.diagnostics = {
-            recordCount: allRecords.length,
-            hasMore: page?.hasMore ?? null,
-            recordKeys: allRecords[0] ? Object.keys(allRecords[0]) : [],
+            used,
+            eventCount: events.length,
+            userEventCount,
             eventTypes: typeTally,
-            firstRecordSample: allRecords[0] ? JSON.stringify(allRecords[0]).slice(0, 700) : null,
-            firstUserEventSample: firstUserEvent ? JSON.stringify(firstUserEvent).slice(0, 1400) : null,
+            traces,
+            firstEventKeys: events[0] ? Object.keys(events[0]) : [],
+            firstUserEventSample: firstUserEvent ? JSON.stringify(firstUserEvent).slice(0, 1500) : null,
           };
         }
 
@@ -1011,11 +1084,18 @@ export function apply(ctx, config = {}) {
         const missing = sessionController
           ? REQUIRED_CONTROLLER_METHODS.filter((name) => typeof sessionController[name] !== "function")
           : REQUIRED_CONTROLLER_METHODS.slice();
+        const dsh = readDshVersion();
         sendJson(res, 200, {
           ok: missing.length === 0,
           controllerAvailable: Boolean(sessionController),
           required: REQUIRED_CONTROLLER_METHODS,
           missing,
+          // The method list above is the real compatibility signal. The version is
+          // context: a newer DSH can keep every method and still change what one of
+          // them means, and that is the one failure nothing here can detect.
+          testedWith: TESTED_WITH_DSH,
+          dshVersion: dsh?.version ?? null,
+          versionMatchesTested: dsh?.version ? dsh.version === TESTED_WITH_DSH : null,
         });
       } catch (error) {
         sendJson(res, 500, { ok: false, error: String(error?.message ?? error) });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-phone-bridge",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "description": "Drive an existing DSH desktop session from a chat app, plus a sidebar delete button and trash panel",
   "type": "module",
   "main": "index.js",