dsh-phone-bridge 0.1.0 → 0.2.0

package/index.js

@@ -221,6 +221,9 @@ function createHandler(ctx) {
 const DSH_HOME = join(homedir(), ".dsh");
 const SESSIONS_ROOT = join(DSH_HOME, "sessions");
 const PROJCACHE_ROOT = join(DSH_HOME, "storages", "session_projcache", "sessions");
+// The desktop sidebar renders this registry, so the /sessions route reads it too
+// in order to list the same rows the desktop does.
+const WORKSPACE_FILE = join(DSH_HOME, "storages", "workspace.json");
 // TRASH_ROOT is assigned in apply() from Config, because it is the one path a
 // deployment may reasonably want to move somewhere else.
 
@@ -254,6 +257,49 @@ function listOnDiskSessionIds() {
   return ids;
 }
 
+// Pull just the title out of a session's projection bag.
+//
+// The bag also carries token counts, context pressure, the turn outline and the
+// subagent catalog. On a long session that is tens of kilobytes, and a session
+// list or a status line needs none of it - the title is the only part that makes
+// a session identifiable. The key is not guaranteed across versions, so probe
+// the plausible names the same way the phone side does.
+function titleFromProjections(values) {
+  for (const key of ["title", "sessionTitle", "name", "label"]) {
+    const value = values?.[key];
+    if (typeof value === "string" && value.trim()) return value.trim();
+    if (value && typeof value === "object" && typeof value.title === "string" && value.title.trim()) {
+      return value.title.trim();
+    }
+  }
+  return "";
+}
+
+// The ids the desktop sidebar would actually list.
+//
+// The sidebar renders DSH's workspace registry (workspaces[<id>].sessionIds),
+// not the disk. Sessions that were never registered there - subagent sessions,
+// ones made before the registry existed - have files but no row. Listing the
+// disk alone therefore shows the phone rows the desktop does not have, which
+// reads as "the phone still shows sessions I deleted".
+//
+// Returns null when the registry cannot be read, so the caller can fall back to
+// the disk list instead of hiding everything.
+function readRegisteredSessionIds() {
+  try {
+    const parsed = JSON.parse(readFileSync(WORKSPACE_FILE, "utf8"));
+    const ids = new Set();
+    for (const workspace of Object.values(parsed?.tables?.workspaces ?? {})) {
+      for (const id of workspace?.sessionIds ?? []) ids.add(id);
+    }
+    // Archived sessions live in their own sidebar section, not the main list.
+    for (const id of parsed?.global?.archivedSessionIds ?? []) ids.delete(id);
+    return ids;
+  } catch {
+    return null;
+  }
+}
+
 // Move rather than unlink. DSH exposes no delete API, and an irreversible
 // deletion triggered from a chat message is a bad trade. A session becomes
 // invisible to DSH the instant its directory leaves the sessions root, so
@@ -337,23 +383,34 @@ export function apply(ctx, config = {}) {
         const sessionController = ctx.get("sessionController");
         if (!sessionController) throw new Error("sessionController is unavailable");
         const listing = await sessionController.list({}, new AbortController().signal);
-        // Hide sessions whose directory is gone: sessionController.list() keeps a
-        // cached phantom after a delete (its cache is not evicted on directory
-        // removal), and the phone would otherwise still offer a session that no
-        // longer opens. Running sessions are exempt because they may be created
-        // but not yet written to disk.
+        // Two filters, both about agreeing with the desktop sidebar:
+        //  - the registry filter drops sessions the sidebar would not list at all
+        //    (never registered in a workspace: subagent sessions, pre-registry
+        //    ones). Without it the phone shows rows the desktop does not have,
+        //    which reads as "the phone still has the sessions I deleted".
+        //  - the disk filter drops cached phantoms: sessionController.list()
+        //    keeps returning a session after its directory is moved to the trash,
+        //    because that cache is only rebuilt on restart.
+        // Running sessions bypass both: they can exist before being materialized
+        // or registered.
         const onDisk = listOnDiskSessionIds();
+        const registered = readRegisteredSessionIds();
         const sessions = (listing?.items ?? [])
-          .filter((item) => item.running || onDisk.has(item.sessionId))
+          .filter((item) => {
+            if (item.running) return true;
+            if (!onDisk.has(item.sessionId)) return false;
+            if (registered !== null && !registered.has(item.sessionId)) return false;
+            return true;
+          })
           .map((item) => ({
           sessionId: item.sessionId,
           updatedAt: item.updatedAt,
           running: Boolean(item.running),
           blank: Boolean(item.blank),
           cwd: item.cwd ?? "",
-          // Projection values carry derived per-session data such as the
-          // generated title, which is what makes a session identifiable.
-          projections: item.projections?.values ?? null,
+          // Only the title is sent: the full projection bag runs to tens of
+          // kilobytes per session on a long one, and the phone lists these.
+          projections: { title: titleFromProjections(item.projections?.values) },
         }));
         sendJson(res, 200, { ok: true, sessions });
       } catch (error) {
@@ -683,6 +740,145 @@ export function apply(ctx, config = {}) {
     },
   }));
 
+  // What is the session doing right now. Everything here comes from list(),
+  // which is cheap and does not activate a cold session - asking for status
+  // should never wake one up.
+  disposers.push(ctx.webServer.register({
+    kind: "exact",
+    path: `${ROUTE_PATH}/status`,
+    handler: async (req, res) => {
+      try {
+        const url = new URL(req.url ?? "/", "http://127.0.0.1");
+        const sessionId = (url.searchParams.get("sessionId") ?? "").trim();
+        const sessionController = ctx.get("sessionController");
+        if (!sessionController) throw new Error("sessionController is unavailable");
+        const signal = new AbortController().signal;
+        const listing = await sessionController.list({}, signal);
+        const items = listing?.items ?? [];
+        const running = items.filter((item) => item.running);
+
+        let detail = null;
+        if (sessionId) {
+          const found = items.find((item) => item.sessionId === sessionId);
+          detail = {
+            sessionId,
+            known: Boolean(found),
+            running: Boolean(found?.running),
+            blank: Boolean(found?.blank),
+            cwd: found?.cwd ?? "",
+            updatedAt: found?.updatedAt ?? null,
+            projections: { title: titleFromProjections(found?.projections?.values) },
+          };
+        }
+
+        sendJson(res, 200, {
+          ok: true,
+          runningCount: running.length,
+          runningIds: running.map((item) => item.sessionId),
+          detail,
+        });
+      } catch (error) {
+        sendJson(res, 500, { ok: false, error: String(error?.message ?? error) });
+      }
+    },
+  }));
+
+  // Stop whatever the session is doing. cancel() takes { kind } internally and
+  // keeps the inbox, so the user's queued messages are not silently dropped.
+  disposers.push(ctx.webServer.register({
+    kind: "exact",
+    path: `${ROUTE_PATH}/stop`,
+    handler: async (req, res) => {
+      try {
+        if (req.method !== "POST") {
+          sendJson(res, 405, { ok: false, error: "POST only" });
+          return;
+        }
+        const raw = await readBody(req);
+        let payload;
+        try {
+          payload = JSON.parse(raw || "{}");
+        } catch {
+          sendJson(res, 400, { ok: false, error: "invalid json" });
+          return;
+        }
+        const sessionId = String(payload.sessionId ?? "").trim();
+        if (!sessionId) {
+          sendJson(res, 400, { ok: false, error: "sessionId is required" });
+          return;
+        }
+        const sessionController = ctx.get("sessionController");
+        if (!sessionController) throw new Error("sessionController is unavailable");
+        if (typeof sessionController.cancel !== "function") {
+          throw new Error("this DSH build does not expose cancel");
+        }
+        const result = await sessionController.cancel({ sessionId });
+        sendJson(res, 200, { ok: true, accepted: result?.accepted !== false });
+      } catch (error) {
+        sendJson(res, 500, { ok: false, error: String(error?.message ?? error) });
+      }
+    },
+  }));
+
+  // The model catalog is a deployment-wide read, so the phone can fetch it once
+  // and then switch models by index without carrying provider ids around.
+  disposers.push(ctx.webServer.register({
+    kind: "exact",
+    path: `${ROUTE_PATH}/models`,
+    handler: async (_req, res) => {
+      try {
+        const sessionController = ctx.get("sessionController");
+        if (!sessionController) throw new Error("sessionController is unavailable");
+        if (typeof sessionController.modelCatalog !== "function") {
+          throw new Error("this DSH build does not expose modelCatalog");
+        }
+        sendJson(res, 200, { ok: true, catalog: (await sessionController.modelCatalog()) ?? null });
+      } catch (error) {
+        sendJson(res, 500, { ok: false, error: String(error?.message ?? error) });
+      }
+    },
+  }));
+
+  // Switch the model a session uses. selectModel() resumes the session, so this
+  // is the one route here with a deliberate side effect.
+  disposers.push(ctx.webServer.register({
+    kind: "exact",
+    path: `${ROUTE_PATH}/model`,
+    handler: async (req, res) => {
+      try {
+        if (req.method !== "POST") {
+          sendJson(res, 405, { ok: false, error: "POST only" });
+          return;
+        }
+        const raw = await readBody(req);
+        let payload;
+        try {
+          payload = JSON.parse(raw || "{}");
+        } catch {
+          sendJson(res, 400, { ok: false, error: "invalid json" });
+          return;
+        }
+        const sessionId = String(payload.sessionId ?? "").trim();
+        const provider = String(payload.provider ?? "").trim();
+        const model = String(payload.model ?? "").trim();
+        if (!sessionId || !provider || !model) {
+          sendJson(res, 400, { ok: false, error: "sessionId, provider and model are required" });
+          return;
+        }
+        const sessionController = ctx.get("sessionController");
+        if (!sessionController) throw new Error("sessionController is unavailable");
+        if (typeof sessionController.selectModel !== "function") {
+          throw new Error("this DSH build does not expose selectModel");
+        }
+        const request = { sessionId, provider, model };
+        if (payload.reasoningEffort) request.reasoningEffort = payload.reasoningEffort;
+        sendJson(res, 200, { ok: true, selection: (await sessionController.selectModel(request)) ?? null });
+      } catch (error) {
+        sendJson(res, 500, { ok: false, error: String(error?.message ?? error) });
+      }
+    },
+  }));
+
   disposers.push(ctx.webServer.register({
     kind: "exact",
     path: ROUTE_PATH,

package/package.json

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