dsh-desktop-kit 0.0.0-stage → 2.0.0

package/plugins/dsh-session-move/cordis.patch.yml

@@ -0,0 +1,5 @@
+# Host half of the "Move chats between Workspaces" plugin.
+# The browser half is loaded from this package's dsh.client entry.
+- insert:
+    - id: session-move
+      name: dsh-session-move

package/plugins/dsh-session-move/icon.svg

@@ -0,0 +1,14 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" width="64" height="64" role="img" aria-label="Move chat between workspaces">
+  <defs>
+    <linearGradient id="sm-a" x1="0" y1="0" x2="1" y2="1">
+      <stop offset="0" stop-color="#2f7df6"/>
+      <stop offset="1" stop-color="#1f4fbf"/>
+    </linearGradient>
+  </defs>
+  <rect x="2" y="2" width="60" height="60" rx="14" fill="url(#sm-a)"/>
+  <rect x="10" y="14" width="18" height="13" rx="3" fill="#ffffff" opacity=".92"/>
+  <rect x="10" y="31" width="18" height="13" rx="3" fill="#ffffff" opacity=".55"/>
+  <rect x="36" y="14" width="18" height="13" rx="3" fill="#ffffff" opacity=".35"/>
+  <rect x="36" y="31" width="18" height="13" rx="3" fill="#ffffff" opacity=".2"/>
+  <path d="M31 38.5 L41 45.5 L31 52.5" fill="none" stroke="#ffffff" stroke-width="4" stroke-linecap="round" stroke-linejoin="round" opacity=".95"/>
+</svg>

package/plugins/dsh-session-move/index.js

@@ -0,0 +1,497 @@
+/**
+ * dsh-session-move — Host half.
+ *
+ * Adds "move this chat to another Workspace" to the DSH Web GUI:
+ *  - re-accounts the Session in the durable Workspace registry (target Workspace
+ *    gains the Session, the previous one loses it),
+ *  - switches the Session's effective working directory to the target
+ *    Workspace directory (so the model really works in that project),
+ *  - remembers the override in a small JSON file, because a Session's stored
+ *    header keeps the original project directory: the durable membership is
+ *    re-applied on every Host start.
+ *
+ * The browser half talks to this half through one authenticated exact Fetch
+ * route family mounted under `/api/dsh-session-move/*` on the existing
+ * Connection carrier (`ctx.connection.fetch.register`). No new model-facing
+ * tool, prompt, or Session event is produced.
+ *
+ * Workspace membership is normally derived from the immutable Session header
+ * `cwd`. This plugin therefore maintains an in-memory `sessionPaths` override
+ * in `ctx.workspaceRegistry` plus the durable Workspace records; see
+ * README.md for the exact contract and failure modes.
+ */
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+/** Mounted route family; the browser calls `/api/dsh-session-move/<op>`. */
+const ROUTE_BASE = "/api/dsh-session-move";
+/** RPC method prefix carried inside the Connection envelope. */
+const RPC_NAMESPACE = "dsh-session-move";
+/** Version of the local move-state file. */
+const STATE_VERSION = 1;
+
+export const inject = ["connection", "workspaceRegistry"];
+
+/** Structured failure with a stable machine code. */
+class SessionMoveError extends Error {
+  constructor(code, message, details = {}) {
+    super(message);
+    this.name = "SessionMoveError";
+    this.code = code;
+    this.details = details;
+  }
+}
+
+function pluginDataDirectory() {
+  const home = process.env.DSH_HOME ?? path.join(os.homedir(), ".dsh");
+  return path.join(home, "dsh-session-move");
+}
+
+function stateFilePath() {
+  return path.join(pluginDataDirectory(), "state.json");
+}
+
+function stringOrNull(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+
+/**
+ * Read persisted overrides. A malformed file is ignored (and re-written on the
+ * next change) instead of failing plugin activation.
+ */
+function readMoves(logger) {
+  const moves = new Map();
+  let raw;
+  try {
+    raw = fs.readFileSync(stateFilePath(), "utf8");
+  } catch (error) {
+    if (error?.code !== "ENOENT") logger?.warn?.(`[session-move] cannot read state: ${String(error)}`);
+    return moves;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    logger?.warn?.(`[session-move] state.json is not JSON, ignoring: ${String(error)}`);
+    return moves;
+  }
+  if (!parsed || parsed.version !== STATE_VERSION || !parsed.moves || typeof parsed.moves !== "object") {
+    logger?.warn?.("[session-move] state.json has an unsupported shape, ignoring");
+    return moves;
+  }
+  for (const [sessionId, entry] of Object.entries(parsed.moves)) {
+    if (typeof sessionId !== "string" || sessionId.length === 0) continue;
+    if (!entry || typeof entry !== "object") continue;
+    const workspaceId = stringOrNull(entry.workspaceId);
+    if (workspaceId === null && entry.workspaceId !== null) continue;
+    moves.set(sessionId, {
+      workspaceId,
+      homeWorkspaceId: stringOrNull(entry.homeWorkspaceId),
+      updatedAt: typeof entry.updatedAt === "string" ? entry.updatedAt : new Date(0).toISOString(),
+    });
+  }
+  return moves;
+}
+
+/** Atomic replace: a crash between write and rename cannot truncate the state. */
+function writeMoves(moves) {
+  const directory = pluginDataDirectory();
+  fs.mkdirSync(directory, { recursive: true });
+  const target = stateFilePath();
+  const temporary = `${target}.${process.pid}.tmp`;
+  const payload = {
+    version: STATE_VERSION,
+    updatedAt: new Date().toISOString(),
+    moves: Object.fromEntries(moves),
+  };
+  fs.writeFileSync(temporary, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+  fs.renameSync(temporary, target);
+}
+
+/** Id of the Workspace whose durable record currently accounts for a Session. */
+function accountedWorkspaceId(registry, sessionId) {
+  const table = registry.table;
+  if (table !== undefined && typeof table.entries === "function") {
+    for (const [workspaceId, record] of table.entries()) {
+      if (Array.isArray(record?.sessionIds) && record.sessionIds.includes(sessionId)) return String(workspaceId);
+    }
+  }
+  for (const workspace of registry.list()) {
+    const record = workspace.record;
+    if (Array.isArray(record?.sessionIds) && record.sessionIds.includes(sessionId)) return String(workspace.id);
+  }
+  return undefined;
+}
+
+async function readHeader(registry, sessionId) {
+  try {
+    return await registry.readSessionHeader(sessionId);
+  } catch {
+    return undefined;
+  }
+}
+
+/** Workspace that owns the Session's original (header) directory, when registered. */
+async function homeWorkspace(registry, header) {
+  if (typeof header?.cwd !== "string" || header.cwd.length === 0) return undefined;
+  try {
+    return await registry.resolveByPath(header.cwd);
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Attach a Session to a Workspace even though its stored header names another
+ * directory. `attachSession` validates the header `cwd`; the temporary override
+ * makes that validation see the target path, while the durable header is never
+ * touched. The registry itself then records the new account and updates its
+ * canonical-path cache (`rememberSessionPath`).
+ */
+async function attachAcrossProjects(registry, workspace, sessionId, header) {
+  const original = registry.readSessionHeader;
+  try {
+    registry.readSessionHeader = async (id) =>
+      id === sessionId ? { ...header, cwd: workspace.path } : original.call(registry, id);
+    await workspace.attachSession(sessionId);
+  } finally {
+    registry.readSessionHeader = original;
+  }
+}
+
+/** Force the in-memory canonical-path index to accept the override. */
+function rememberOverride(registry, sessionId, workspacePath) {
+  registry.sessionPaths.set(sessionId, workspacePath);
+  registry.missingSessionPaths.delete(sessionId);
+  registry.invalidSessionPaths.delete(sessionId);
+}
+
+/** Stop filtering the Session out of `Workspace.sessionIds` (Ungrouped bucket). */
+function forgetOverride(registry, sessionId) {
+  registry.sessionPaths.delete(sessionId);
+  registry.missingSessionPaths.delete(sessionId);
+  registry.invalidSessionPaths.delete(sessionId);
+}
+
+/**
+ * Make the Session's effective working directory follow the target project.
+ * A live Agent is reused; a cold Session is resumed quietly through Session
+ * Controller (the same service other Host domains use). Failures are reported
+ * to the caller but never roll the membership move back.
+ */
+async function followProjectDirectory(ctx, sessionId, directory) {
+  const workingDirectory = ctx.get("workingDirectory");
+  if (workingDirectory === undefined) return "unavailable";
+  let agent = ctx.get("agents")?.get(sessionId);
+  if (agent === undefined) {
+    const sessionController = ctx.get("sessionController");
+    if (sessionController === undefined) return "unavailable";
+    let resolved;
+    try {
+      resolved = await sessionController.resolveAgent(sessionId);
+    } catch (error) {
+      return `skipped: ${error instanceof Error ? error.message : String(error)}`;
+    }
+    if (resolved === undefined || resolved.agent === undefined) {
+      const reason = resolved?.error?.code ?? "no-agent";
+      return `skipped: ${reason}`;
+    }
+    agent = resolved.agent;
+  }
+  try {
+    await workingDirectory.set(agent, directory);
+    return "ok";
+  } catch (error) {
+    return `skipped: ${error instanceof Error ? error.message : String(error)}`;
+  }
+}
+
+function workspaceSummary(workspace) {
+  return {
+    workspaceId: String(workspace.id),
+    title: workspace.title,
+    path: workspace.path,
+  };
+}
+
+async function readState(registry, moves, payload) {
+  const workspaces = registry.list().map(workspaceSummary);
+  let session = null;
+  const sessionId = stringOrNull(payload?.sessionId);
+  if (sessionId !== null) {
+    const header = await readHeader(registry, sessionId);
+    if (header === undefined) throw new SessionMoveError("session-move/session-unknown", "Session not found", { sessionId });
+    const home = await homeWorkspace(registry, header);
+    session = {
+      sessionId,
+      workspaceId: accountedWorkspaceId(registry, sessionId) ?? null,
+      homeWorkspaceId: home === undefined ? null : String(home.id),
+      archived: registry.archivedSessionIds.includes(sessionId),
+      subagent: header.origin === "subagent",
+    };
+  }
+  return {
+    workspaces,
+    session,
+    moves: [...moves.entries()].map(([movedSessionId, entry]) => ({ sessionId: movedSessionId, ...entry })),
+  };
+}
+
+/**
+ * Serialize moves of the same Session. The state file and the registry queue
+ * stay authoritative; this only prevents a double drop from racing itself.
+ */
+const inFlight = new Set();
+
+async function moveSession(ctx, registry, moves, payload) {
+  const sessionId = stringOrNull(payload?.sessionId);
+  if (sessionId === null) throw new SessionMoveError("session-move/bad-request", "sessionId is required", {});
+  const rawTarget = payload?.workspaceId;
+  if (rawTarget !== null && rawTarget !== undefined && typeof rawTarget !== "string") {
+    throw new SessionMoveError("session-move/bad-request", "workspaceId must be a string or null", {});
+  }
+  const targetId = stringOrNull(rawTarget);
+  if (rawTarget !== null && rawTarget !== undefined && targetId === null) {
+    throw new SessionMoveError("session-move/bad-request", "workspaceId must not be empty", {});
+  }
+  if (inFlight.has(sessionId)) throw new SessionMoveError("session-move/busy", "Another move of this Session is already running", { sessionId });
+  inFlight.add(sessionId);
+  try {
+    const header = await readHeader(registry, sessionId);
+    if (header === undefined) throw new SessionMoveError("session-move/session-unknown", "Session not found", { sessionId });
+    if (header.origin === "subagent") throw new SessionMoveError("session-move/subagent", "Subagent Sessions cannot be moved", { sessionId });
+
+    const target = targetId === null ? undefined : registry.get(targetId);
+    if (targetId !== null && target === undefined) {
+      throw new SessionMoveError("session-move/workspace-unknown", "Workspace not found", { workspaceId: targetId });
+    }
+    if (target !== undefined) {
+      const status = await target.status();
+      if (status !== "ok") {
+        throw new SessionMoveError("session-move/workspace-missing-dir", "The Workspace directory is missing", {
+          workspaceId: targetId,
+          path: target.path,
+        });
+      }
+    }
+
+    let previousWorkspaceId = null;
+    let changed = false;
+    await registry.enqueueOperation(async () => {
+      const currentId = accountedWorkspaceId(registry, sessionId);
+      previousWorkspaceId = currentId ?? null;
+      if (target !== undefined ? currentId === String(target.id) : currentId === undefined) return;
+      if (currentId !== undefined) {
+        const current = registry.get(currentId);
+        if (current !== undefined) await current.detachSession(sessionId);
+      }
+      if (target !== undefined) await attachAcrossProjects(registry, target, sessionId, header);
+      else forgetOverride(registry, sessionId);
+      changed = true;
+    });
+
+    const home = await homeWorkspace(registry, header);
+    const homeId = home === undefined ? null : String(home.id);
+    if (!changed) {
+      return {
+        changed: false,
+        sessionId,
+        previousWorkspaceId,
+        workspaceId: target === undefined ? null : String(target.id),
+        workingDirectory: "unchanged",
+      };
+    }
+
+    if (target === undefined || (homeId !== null && String(target.id) === homeId)) moves.delete(sessionId);
+    else {
+      moves.set(sessionId, {
+        workspaceId: String(target.id),
+        homeWorkspaceId: homeId,
+        updatedAt: new Date().toISOString(),
+      });
+    }
+    writeMoves(moves);
+
+    const workingDirectory = target === undefined ? "unchanged" : await followProjectDirectory(ctx, sessionId, target.path);
+    return {
+      changed: true,
+      sessionId,
+      previousWorkspaceId,
+      workspaceId: target === undefined ? null : String(target.id),
+      workingDirectory,
+    };
+  } finally {
+    inFlight.delete(sessionId);
+  }
+}
+
+/**
+ * Re-apply persisted overrides after a Host start. The durable Workspace
+ * records already contain the moved Sessions; this only restores the
+ * canonical-path cache that drives `Workspace.sessionIds`, and repairs records
+ * whose target Workspace disappeared.
+ */
+async function restoreMappings(ctx, registry, moves) {
+  let dirty = false;
+  for (const [sessionId, entry] of [...moves.entries()]) {
+    const header = await readHeader(registry, sessionId);
+    if (header === undefined || header.origin === "subagent") {
+      moves.delete(sessionId);
+      dirty = true;
+      continue;
+    }
+    if (entry.workspaceId === null) continue;
+    const target = registry.get(entry.workspaceId);
+    if (target === undefined) {
+      moves.delete(sessionId);
+      dirty = true;
+      const home = await homeWorkspace(registry, header);
+      if (home === undefined) continue;
+      try {
+        await registry.enqueueOperation(async () => {
+          const currentId = accountedWorkspaceId(registry, sessionId);
+          if (currentId !== undefined && currentId !== String(home.id)) {
+            const current = registry.get(currentId);
+            if (current !== undefined) await current.detachSession(sessionId);
+          }
+          rememberOverride(registry, sessionId, home.path);
+          const record = registry.table?.get(home.id);
+          if (record !== undefined && !record.sessionIds.includes(sessionId)) {
+            await attachAcrossProjects(registry, home, sessionId, header);
+          }
+        });
+      } catch (error) {
+        ctx.logger?.warn?.(`[session-move] could not re-home Session ${sessionId}: ${String(error)}`);
+      }
+      continue;
+    }
+    rememberOverride(registry, sessionId, target.path);
+    const record = registry.table?.get(target.id);
+    if (record !== undefined && !record.sessionIds.includes(sessionId)) {
+      try {
+        await registry.enqueueOperation(async () => {
+          const currentId = accountedWorkspaceId(registry, sessionId);
+          if (currentId !== undefined && currentId !== String(target.id)) {
+            const current = registry.get(currentId);
+            if (current !== undefined) await current.detachSession(sessionId);
+          }
+          await attachAcrossProjects(registry, target, sessionId, header);
+        });
+      } catch (error) {
+        ctx.logger?.warn?.(`[session-move] could not re-attach Session ${sessionId}: ${String(error)}`);
+      }
+    }
+  }
+  if (dirty) {
+    try {
+      writeMoves(moves);
+    } catch (error) {
+      ctx.logger?.warn?.(`[session-move] could not persist the repaired move state: ${String(error)}`);
+    }
+  }
+}
+
+/* ------------------------------------------------------------------ */
+/* Wire envelope helpers                                              */
+/* ------------------------------------------------------------------ */
+
+function okEnvelope(rpcId, value) {
+  return Response.json({ type: "server-response", rpcId, result: { ok: true, value } });
+}
+
+function errorEnvelope(rpcId, code, message, details = {}) {
+  return Response.json({ type: "server-response", rpcId, result: { ok: false, error: { code, message, details } } });
+}
+
+async function readEnvelope(request) {
+  let body;
+  try {
+    body = await request.json();
+  } catch {
+    throw new SessionMoveError("session-move/bad-request", "Request body is not JSON", {});
+  }
+  if (
+    body === null ||
+    typeof body !== "object" ||
+    body.type !== "client-request" ||
+    typeof body.rpcId !== "string" ||
+    typeof body.method !== "string"
+  ) {
+    throw new SessionMoveError("session-move/bad-request", "Invalid Connection envelope", {});
+  }
+  return { rpcId: body.rpcId, method: body.method, payload: body.payload ?? {} };
+}
+
+function registerOperation(ctx, operation, handler) {
+  const route = {
+    path: `${ROUTE_BASE}/${operation}`,
+    methods: ["POST"],
+    requestBody: "buffered",
+    fetch: async (request) => {
+      let rpcId = "invalid-request";
+      try {
+        const envelope = await readEnvelope(request);
+        rpcId = envelope.rpcId;
+        if (envelope.method !== `${RPC_NAMESPACE}/${operation}`) {
+          return errorEnvelope(rpcId, "session-move/bad-request", "Envelope method does not match its endpoint", {
+            expected: `${RPC_NAMESPACE}/${operation}`,
+            actual: envelope.method,
+          });
+        }
+        const value = await handler(envelope.payload);
+        return okEnvelope(rpcId, value);
+      } catch (error) {
+        const code = typeof error?.code === "string" && error.code.startsWith("session-move/")
+          ? error.code
+          : "session-move/internal";
+        const message = error instanceof Error ? error.message : String(error);
+        const details = error?.details && typeof error.details === "object" ? error.details : {};
+        if (code === "session-move/internal") ctx.logger?.warn?.(`[session-move] ${operation} failed: ${String(error)}`);
+        return errorEnvelope(rpcId, code, message, details);
+      }
+    },
+  };
+  ctx.effect(() => {
+    const dispose = ctx.connection.fetch.register(route);
+    return () => {
+      try {
+        void Promise.resolve(dispose()).catch(() => {});
+      } catch {
+        /* the carrier may already be unloading */
+      }
+    };
+  }, `session-move: ${operation} route`);
+}
+
+/* ------------------------------------------------------------------ */
+/* Plugin entry                                                       */
+/* ------------------------------------------------------------------ */
+
+export async function apply(ctx) {
+  const logger = ctx.logger;
+  const registry = ctx.workspaceRegistry;
+  const moves = readMoves(logger);
+  try {
+    fs.mkdirSync(pluginDataDirectory(), { recursive: true });
+  } catch {
+    /* read-only home: moves still work in memory for this process */
+  }
+  try {
+    await restoreMappings(ctx, registry, moves);
+  } catch (error) {
+    logger?.warn?.(`[session-move] restoring persisted moves failed: ${String(error)}`);
+  }
+
+  registerOperation(ctx, "state", (payload) => readState(registry, moves, payload));
+  registerOperation(ctx, "move", (payload) => moveSession(ctx, registry, moves, payload));
+  registerOperation(ctx, "diag", () => ({
+    version: 1,
+    pid: process.pid,
+    host: process.version,
+    stateFile: stateFilePath(),
+    moves: moves.size,
+    workspaces: registry.list().length,
+  }));
+}

package/plugins/dsh-session-move/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Move chats between workspaces",
+    "description": "Drag a chat from one workspace to another in the sidebar and keep it there: the chat's project and working directory follow the drop target."
+  }
+}

package/plugins/dsh-session-move/locale/ru.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Перенос чатов между рабочими областями",
+    "description": "Перетащите чат из одной рабочей области в другую в боковой панели — чат останется там: его проект и рабочая директория переключатся на цель."
+  }
+}

package/plugins/dsh-session-move/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "在工作区之间移动对话",
+    "description": "在侧边栏把对话从一个工作区拖到另一个工作区，对话会留在那里：所属项目和工作目录都会切换到目标工作区。"
+  }
+}

package/plugins/dsh-session-move/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "dsh-session-move",
+  "version": "1.0.0",
+  "private": true,
+  "description": "Drag & drop chats between Workspaces in the DSH Web GUI, and keep them there.",
+  "type": "module",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js",
+    "./client": "./client.js",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg"
+  },
+  "files": [
+    "index.js",
+    "client.js",
+    "cordis.patch.yml",
+    "locale/*.json",
+    "icon.svg",
+    "README.md"
+  ],
+  "dsh": {
+    "manifestVersion": 1,
+    "bundle": { "patch": "./cordis.patch.yml" },
+    "client": {
+      "platform": "web",
+      "immediately": true,
+      "inject": []
+    }
+  }
+}

package/plugins/dsh-session-move/screenshots/qa-report.json

@@ -0,0 +1,62 @@
+{
+  "steps": [
+    {
+      "name": "visible-session",
+      "value": {
+        "key": "session:session-73e5c76d-f3ae-43db-ac82-64e23969f6e4",
+        "id": "session-73e5c76d-f3ae-43db-ac82-64e23969f6e4",
+        "title": "БегЛокальная база знаний по проектам для ИИ1мин"
+      }
+    },
+    {
+      "name": "axe-dialog",
+      "value": {
+        "violations": []
+      }
+    },
+    {
+      "name": "viewport-390",
+      "value": {
+        "scrollWidth": 390,
+        "clientWidth": 390,
+        "dialogWidth": 342,
+        "viewport": 390
+      }
+    },
+    {
+      "name": "dark-theme",
+      "value": {
+        "source": "system",
+        "background": "rgb(21, 21, 23)"
+      }
+    },
+    {
+      "name": "dialog-closed",
+      "value": true
+    },
+    {
+      "name": "drag-highlight",
+      "value": {
+        "dragInfo": {
+          "ok": true
+        },
+        "visible": false
+      }
+    }
+  ],
+  "errors": [],
+  "screenshots": [
+    "%USERPROFILE%/Documents/deepseek-harness/default-workspace/projects/dsh-session-move/screenshots/01-row-menu-1440-light.png",
+    "%USERPROFILE%/Documents/deepseek-harness/default-workspace/projects/dsh-session-move/screenshots/02-dialog-1440-light.png",
+    "%USERPROFILE%/Documents/deepseek-harness/default-workspace/projects/dsh-session-move/screenshots/03-dialog-390-light.png",
+    "%USERPROFILE%/Documents/deepseek-harness/default-workspace/projects/dsh-session-move/screenshots/04-dialog-1440-dark.png",
+    "%USERPROFILE%/Documents/deepseek-harness/default-workspace/projects/dsh-session-move/screenshots/05-drag-highlight-1440-light.png"
+  ],
+  "axe": {
+    "violations": []
+  },
+  "logs": [
+    "[info] [session-move] ready",
+    "[error] [deepseek-account] account read failed {field: profile}"
+  ]
+}

package/plugins/dsh-skill-autopilot/cordis.patch.yml

@@ -0,0 +1,3 @@
+- insert:
+    - id: dsh-skill-autopilot
+      name: dsh-skill-autopilot