dsh-phone-bridge 0.1.0 → 0.2.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 KaiyeZeng
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,63 @@
+# dsh-phone-bridge
+
+Drive an existing DeepSeek Harness **desktop** session from a chat app, and manage
+sessions from the sidebar.
+
+> **Status as of October 2026:** DSH ships no way to reach a running desktop session
+> from a phone, and no delete button. This package fills both gaps. It is unofficial
+> and may break when DSH changes.
+
+## Install
+
+```powershell
+dsh plugin --profile desktop add dsh-phone-bridge
+```
+
+Then restart DSH. The package carries its own `dsh.bundle.patch`, so no config file
+has to be edited by hand.
+
+## What it adds
+
+**Desktop UI** — a delete button on every session row (with a confirmation), and a
+trash panel at the bottom of the sidebar where each entry can be restored or purged.
+
+**HTTP routes** under `/phone-bridge/*`, for a chat-side client to call:
+
+| Route | Purpose |
+|---|---|
+| `GET /sessions` | list sessions, the same set the sidebar shows |
+| `GET /search?q=` | search session message content |
+| `POST /create` | create a session |
+| `POST /rename` | set a session title |
+| `POST /delete` | move a session to the trash |
+| `GET /trash` | list the trash and its size |
+| `POST /restore` | put a trashed session back |
+| `POST /purge` | erase trashed data permanently |
+| `GET /status` | running state, working directory, last activity |
+| `POST /stop` | cancel the session's running turn |
+| `GET /models` | the deployment model catalog |
+| `POST /model` | switch the model a session uses |
+
+Deleting **moves** a session to `~/.dsh/deleted-sessions/` instead of unlinking it,
+so a delete stays recoverable and purging is a separate, explicit step.
+
+## The chat side
+
+This package is only the DSH half. To talk to it from WeChat, Telegram or Yuanbao
+you also need the OpenClaw plugin from the same repository:
+
+<https://github.com/KaiyeZeng/dsh-phone-bridge>
+
+## Notes
+
+- **Zero runtime dependencies.** Only `node:` builtins are imported, so the file can
+  be mounted straight from disk with `file://` and no `node_modules` directory.
+- `/sessions` reads DSH's workspace registry rather than the disk, so the phone lists
+  what the desktop sidebar lists. Sessions that were never registered in a workspace
+  (subagent sessions, ones made before the registry existed) have files but no
+  sidebar row, and listing the disk alone made the phone show rows the desktop did
+  not have.
+- The model catalog is read structurally. The exact shape is not a stable surface, so
+  a change there shortens the list instead of crashing.
+
+MIT licensed.

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.1",
   "description": "Drive an existing DSH desktop session from a chat app, plus a sidebar delete button and trash panel",
   "type": "module",
   "main": "index.js",
@@ -18,7 +18,6 @@
     "client.js",
     "cordis.patch.yml",
     "README.md",
-    "README.zh.md",
     "LICENSE"
   ],
   "keywords": [