@wingsky-1/dsh-worktree-sidebar 0.2.5

package/lib/client/source.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 伪造的 `sessions` hook 源：把某个会话的 `cwd` 改写成 worktree 路径，其余字段原样透传。
+ *
+ * 三条硬约束，每一条失效的形态都很难查：
+ * 1. **引用稳定**：同一次真实快照 + 同一条 worktree 路径必须回同一个对象。每次新建对象会让渲染层
+ *    认为状态一直在变，表现是右栏持续重渲染（刷得看不出来，只是卡）。
+ * 2. **只改一个字段**：ById 里其余会话、以及该会话的其余字段都必须是原引用，否则预览、命令面板等
+ *    消费方会看到被我们改过的世界。
+ * 3. **未绑定即原样**：没有绑定就直接回真实快照，不制造副本——那时我们的存在应当完全不可见。
+ */
+import type { ObservablePort, SessionsSnapshotLike } from "./shared/ports.js";
+/** 一个会话的改写源。 */
+interface SessionsSource extends ObservablePort<SessionsSnapshotLike> {
+    /** 通知订阅者状态可能变了（由绑定刷新驱动）。 */
+    notify(): void;
+}
+/**
+ * @param real - 真实会话源（官方注入的那一个）。
+ * @param currentPath - 同步读当前生效的 worktree 路径；null 表示按真实 cwd 走。
+ */
+export declare function createSessionsSource(real: ObservablePort<SessionsSnapshotLike>, sessionId: string, currentPath: () => string | null): SessionsSource;
+export {};

package/lib/client/takeover.d.ts

@@ -0,0 +1,51 @@
+/**
+ * 接管 files 页签：把官方组件的**目录根**换掉，不重写树 UI。
+ *
+ * 接管只做一件事：以**官方 id** 为 key、**更低的 priority** 再登记一条正文，组件 / store /
+ * locale 全部复用官方那条（inject 面由 `inject.ts` 包一层）。官方 ui-slots 的每个 cell 取
+ * 「优先级最低的那条存活项」——它的注册表原话是 register at a different priority to shadow it
+ * (lowest renders)（`@deepseek-ai/dsh-client-ui-slots` 的 `lib/index.js:77`；排序 `:130`；取当值项 `:187-200`）。
+ *
+ * **那个包不在 dsh 安装树里**：它在构建期被内联进 `dsh-web-frontend/dist/assets/index-*.js`，
+ * 所以要照注释去读原文时，可读副本在同仓 catalog 锁版处
+ * （`node_modules/.pnpm/@deepseek-ai+dsh-client-ui-slots@0.1.5-rc.1_...` 下的
+ * `node_modules/@deepseek-ai/dsh-client-ui-slots/lib/index.js`）。
+ * 树内可读的两处是类型面与运行时入口：`dsh-client-ui-renderer/lib/types/client/registry.d.ts:46/84/154/164`
+ * （`class SlotRegistry`、`register`、`entries`、`entriesOfSlot`）与同一包 `lib/client.js:953/1191-1198/1388`。
+ *
+ * **为什么不再顶掉类型表**：顶掉就得把官方定义整份搬运（`guide` / `patterns` / `canOpen` 以及
+ * 将来新增的字段），官方注册表 refresh 后还会用**在册定义**重算 guide 条目——搬丢 `guide` 的后果
+ * 是所有会话的默认页签变成空的 Guide。遮蔽正文让类型表、标题、guide 全部保持原样，这份搬运消失。
+ *
+ * **当值判定**：登记之后座位上当值的那条必须带我们的 priority，否则说明遮蔽没生效（官方换了更低的
+ * 优先级，或我们的条目已被退场）。判定失败当场撤掉自己那条并出声：可感知地什么都不做，好过静默
+ * 显示错的地方。
+ *
+ * 本文件只经 `TakeoverDeps.wrapInject` 拿到改写器——接管块与改写块零互引，装配由 `index.ts` 完成。
+ */
+import type { ClientSlotsPort, StoredEntryLike, TabsPort, WrapInject } from "./shared/ports.js";
+/** 我们接管的 kind。 */
+export declare const FILES_KIND = "files";
+/** 正文座位。 */
+export declare const BODY_SLOT = "sidebar.right.pane.tab";
+/**
+ * 我们那条正文的 priority：比官方那条**低一档**。
+ *
+ * 官方当前那条没声明 priority（它的 register options 只有 name/key/locale/store/inject，
+ * 见界面包里那处注册），所以实际取值仍是 -1；但「官方是 0」不是契约，写死常量意味着
+ * 官方哪天声明了 0 以下的 priority，我们就从遮蔽者变成被遮蔽者（自检会当场退位，接管静默失效）。
+ * 取值的唯一约束是「比官方低且与官方不同」——同 key 同 priority 的登记会当场抛。
+ */
+export declare function shadowPriorityOf(official: StoredEntryLike): number;
+interface TakeoverDeps {
+    readonly slots: ClientSlotsPort;
+    readonly tabs: TabsPort;
+    readonly logger: {
+        warn(message: string): void;
+    };
+    /** 官方 inject 面的改写器：由装配根从 `inject.ts` 接进来（块间零互引）。 */
+    readonly wrapInject: WrapInject;
+}
+/** 接管入口。返回值是完整释放函数；调用方把它放进 `ctx.effect` 的 disposer。 */
+export declare function installTakeover(deps: TakeoverDeps): () => void;
+export {};

package/lib/client.js

@@ -0,0 +1,394 @@
+"use strict";
+(() => {
+  // <define:__DSH_ROUTES__>
+  var define_DSH_ROUTES_default = { bindings: "/api/dsh-worktree-sidebar/bindings", health: "/api/dsh-worktree-sidebar/health" };
+
+  // src/shared/contract.ts
+  var ROUTES = {
+    bindings: "/api/dsh-worktree-sidebar/bindings",
+    health: "/api/dsh-worktree-sidebar/health"
+  };
+
+  // src/client/bindings.ts
+  function createBindingState(read, sessionId) {
+    let path = null;
+    let revision = -1;
+    const listeners = /* @__PURE__ */ new Set();
+    return {
+      getSnapshot: () => path,
+      subscribe(listener) {
+        listeners.add(listener);
+        return () => {
+          listeners.delete(listener);
+        };
+      },
+      async refresh() {
+        let next;
+        try {
+          next = await read(sessionId);
+        } catch {
+          return;
+        }
+        if (next === void 0) return;
+        if (next.revision === revision && next.worktreePath === path) return;
+        if (next.revision < revision) return;
+        revision = next.revision;
+        path = next.worktreePath;
+        for (const listener of [...listeners]) listener();
+      }
+    };
+  }
+
+  // src/client/inject.ts
+  var liveSeedings = /* @__PURE__ */ new Set();
+  function releaseAllSeedings() {
+    for (const release of [...liveSeedings]) release();
+  }
+  function createInjectWrapper(viewFor) {
+    return (official) => {
+      return (...args) => {
+        const face = official === void 0 ? {} : official(...args);
+        const sessionId = args.find((arg) => typeof arg === "string");
+        if (sessionId === void 0) return face;
+        const view = viewFor(sessionId);
+        const bound = { ...face, hooks: mergeSessions(face, view) };
+        return typeof face["start"] === "function" ? { ...bound, ...seeding(view, face) } : bound;
+      };
+    };
+  }
+  function mergeSessions(face, view) {
+    const existing = face["hooks"];
+    const hooks = typeof existing === "object" && existing !== null ? existing : {};
+    return { ...hooks, sessions: view.source };
+  }
+  function seeding(view, face) {
+    const officialStart = face["start"];
+    const officialLoad = face["load"];
+    const watched = /* @__PURE__ */ new Map();
+    let unsubscribe;
+    let detachVisible;
+    const refresh = () => {
+      void view.root.refresh();
+    };
+    const reseed = () => {
+      const next = view.root.getSnapshot();
+      for (const [tabId, tab] of [...watched]) {
+        if (tab.signal?.aborted === true) continue;
+        const root = next ?? tab.fallback;
+        if (root === tab.seeded) continue;
+        tab.seeded = root;
+        officialStart(tabId, root, tab.signal);
+      }
+    };
+    const release = () => {
+      watched.clear();
+      liveSeedings.delete(release);
+      unsubscribe?.();
+      unsubscribe = void 0;
+      detachVisible?.();
+      detachVisible = void 0;
+    };
+    const watchAbort = (tabId, signal) => {
+      signal?.addEventListener(
+        "abort",
+        () => {
+          watched.delete(tabId);
+          if (watched.size === 0) release();
+        },
+        { once: true }
+      );
+    };
+    const attach = (tabId, fallback, seeded, signal) => {
+      liveSeedings.add(release);
+      watched.set(tabId, { seeded, fallback, signal });
+      unsubscribe ?? (unsubscribe = view.root.subscribe(reseed));
+      detachVisible ?? (detachVisible = refreshWhenVisible(refresh));
+      watchAbort(tabId, signal);
+    };
+    const start = (tabId, root, signal) => {
+      attach(tabId, root, root, signal);
+      officialStart(tabId, root, signal);
+      void view.root.refresh().then(() => {
+        if (signal?.aborted === true) return;
+        const seeded = view.root.getSnapshot() ?? root;
+        const tab = watched.get(tabId);
+        if (tab === void 0 || tab.seeded === seeded) return;
+        tab.seeded = seeded;
+        officialStart(tabId, seeded, tab.signal);
+      });
+    };
+    const load = (tabId, path, signal) => {
+      if (watched.get(tabId)?.seeded === path) refresh();
+      officialLoad?.(tabId, path, signal);
+    };
+    return officialLoad === void 0 ? { start } : { start, load };
+  }
+  function refreshWhenVisible(refresh) {
+    if (typeof document === "undefined" || typeof window === "undefined") return () => void 0;
+    const onVisible = () => {
+      if (!document.hidden) refresh();
+    };
+    document.addEventListener("visibilitychange", onVisible);
+    window.addEventListener("focus", onVisible);
+    return () => {
+      document.removeEventListener("visibilitychange", onVisible);
+      window.removeEventListener("focus", onVisible);
+    };
+  }
+
+  // src/client/source.ts
+  function createSessionsSource(real, sessionId, currentPath) {
+    const listeners = /* @__PURE__ */ new Set();
+    let cached;
+    let cachedFrom;
+    let cachedPath = null;
+    return {
+      getSnapshot() {
+        const snapshot = real.getSnapshot();
+        const path = currentPath();
+        if (path === null) return snapshot;
+        if (cached !== void 0 && cachedFrom === snapshot && cachedPath === path) return cached;
+        cachedFrom = snapshot;
+        cachedPath = path;
+        cached = rewrite(snapshot, sessionId, path);
+        return cached;
+      },
+      subscribe(listener) {
+        const unsubscribeReal = real.subscribe(listener);
+        listeners.add(listener);
+        return () => {
+          listeners.delete(listener);
+          unsubscribeReal();
+        };
+      },
+      notify() {
+        for (const listener of [...listeners]) listener();
+      }
+    };
+  }
+  function rewrite(snapshot, sessionId, path) {
+    const byId = snapshot.byId;
+    if (byId === void 0) return snapshot;
+    const entry = byId[sessionId];
+    if (typeof entry !== "object" || entry === null) return snapshot;
+    return {
+      ...snapshot,
+      byId: { ...byId, [sessionId]: { ...entry, cwd: path } }
+    };
+  }
+
+  // src/client/takeover.ts
+  var FILES_KIND = "files";
+  var BODY_SLOT = "sidebar.right.pane.tab";
+  function shadowPriorityOf(official) {
+    return (official.options.priority ?? 0) - 1;
+  }
+  var TRANSIENT_ATTEMPTS = 2;
+  function installTakeover(deps) {
+    let live = null;
+    const ours = /* @__PURE__ */ new Set();
+    const attempts = /* @__PURE__ */ new WeakMap();
+    let refused = null;
+    const officialId = () => deps.tabs.get(FILES_KIND)?.id;
+    const isOurs = (entry) => entry.options.priority !== void 0 && ours.has(entry.options.priority);
+    const findOfficial = (id) => {
+      let best;
+      for (const entry of deps.slots.entries(BODY_SLOT)) {
+        if (entry.options.key !== id || isOurs(entry)) continue;
+        if (best === void 0 || (entry.options.priority ?? 0) > (best.options.priority ?? 0)) {
+          best = entry;
+        }
+      }
+      return best;
+    };
+    const isWinner = (id, priority) => deps.slots.entriesOfSlot(BODY_SLOT).some((entry) => entry.options.key === id && entry.options.priority === priority);
+    const teardown = () => {
+      const current = live;
+      live = null;
+      if (current === null) return;
+      ours.delete(current.priority);
+      try {
+        current.dispose();
+      } catch {
+      }
+    };
+    class ShadowRefused extends Error {
+    }
+    const tryTakeOver = (official, id) => {
+      const priority = shadowPriorityOf(official);
+      let dispose;
+      try {
+        dispose = deps.slots.register(
+          {
+            name: BODY_SLOT,
+            key: id,
+            priority,
+            locale: official.locale,
+            store: official.store,
+            inject: deps.wrapInject(official.inject)
+          },
+          official.component
+        );
+        if (!isWinner(id, priority)) {
+          throw new ShadowRefused("遮蔽未生效：当值项不是我们这条（priority 更低者才渲染）");
+        }
+      } catch (cause) {
+        try {
+          dispose?.();
+        } catch {
+        }
+        const reason = cause instanceof Error ? cause.message : String(cause);
+        deps.logger.warn(
+          "dsh-worktree-sidebar: 接管 files 页签正文失败，已退位（保持官方行为）— " + reason
+        );
+        if (cause instanceof ShadowRefused) {
+          refused = official;
+          return;
+        }
+        const tries = (attempts.get(official) ?? 0) + 1;
+        attempts.set(official, tries);
+        if (tries >= TRANSIENT_ATTEMPTS) refused = official;
+        return;
+      }
+      attempts.delete(official);
+      refused = null;
+      ours.add(priority);
+      live = { dispose, shadowed: official, priority };
+    };
+    const evaluate = () => {
+      const id = officialId();
+      if (id === void 0) {
+        teardown();
+        return;
+      }
+      const official = findOfficial(id);
+      if (official === void 0) {
+        teardown();
+        return;
+      }
+      if (live !== null) {
+        if (live.shadowed === official) {
+          if (isWinner(id, live.priority)) return;
+          teardown();
+          deps.logger.warn(
+            "dsh-worktree-sidebar: 接管 files 页签正文失败，已退位（当值项被更低的 priority 夺走，我们的包装不会渲染）"
+          );
+          refused = official;
+          return;
+        }
+        teardown();
+      } else if (official === refused) {
+        return;
+      } else if (!deps.slots.entriesOfSlot(BODY_SLOT).some((e) => e.options.key === id)) {
+        return;
+      }
+      tryTakeOver(official, id);
+    };
+    const unsubscribeSlot = deps.slots.subscribe(BODY_SLOT, evaluate);
+    let unsubscribeErrors;
+    try {
+      unsubscribeErrors = deps.slots.onEntryError((key, entry, error) => {
+        if (key !== BODY_SLOT || !isOurs(entry)) return;
+        deps.logger.warn(
+          "dsh-worktree-sidebar: 接管入口出现异常（" + key + "）— " + (error instanceof Error ? error.message : String(error))
+        );
+      });
+      evaluate();
+    } catch (cause) {
+      try {
+        unsubscribeErrors?.();
+      } catch {
+      }
+      try {
+        unsubscribeSlot();
+      } catch {
+      }
+      throw cause;
+    }
+    return () => {
+      teardown();
+      try {
+        unsubscribeSlot();
+      } catch {
+      }
+      try {
+        unsubscribeErrors?.();
+      } catch {
+      }
+    };
+  }
+
+  // src/client/index.ts
+  var ROUTES_INJECTED = typeof define_DSH_ROUTES_default !== "undefined" ? define_DSH_ROUTES_default : ROUTES;
+  var BINDINGS_URL = ROUTES_INJECTED.bindings;
+  var readBinding = async (sessionId) => {
+    try {
+      const response = await fetch(BINDINGS_URL + "?session=" + encodeURIComponent(sessionId), {
+        headers: { accept: "application/json" }
+      });
+      if (!response.ok) return void 0;
+      const body = await response.json();
+      if (typeof body.revision !== "number") return void 0;
+      return {
+        revision: body.revision,
+        worktreePath: typeof body.worktreePath === "string" ? body.worktreePath : null
+      };
+    } catch {
+      return void 0;
+    }
+  };
+  var VIEW_CACHE_MAX = 128;
+  function apply(ctx) {
+    try {
+      const views = /* @__PURE__ */ new Map();
+      const viewFor = (sessionId) => {
+        const cached = views.get(sessionId);
+        if (cached !== void 0) {
+          views.delete(sessionId);
+          views.set(sessionId, cached);
+          return cached;
+        }
+        const state = createBindingState(readBinding, sessionId);
+        const source = createSessionsSource(ctx.sessions.list, sessionId, () => state.getSnapshot());
+        state.subscribe(() => source.notify());
+        const view = { source, root: state };
+        views.set(sessionId, view);
+        if (views.size > VIEW_CACHE_MAX) {
+          const coldest = views.keys().next().value;
+          if (coldest !== void 0) views.delete(coldest);
+        }
+        return view;
+      };
+      const restore = installTakeover({
+        slots: ctx.slots,
+        tabs: ctx.sidebarRightTabs,
+        logger: { warn: (message) => console.warn(message) },
+        wrapInject: createInjectWrapper(viewFor)
+      });
+      ctx.effect(
+        () => () => {
+          restore();
+          releaseAllSeedings();
+          views.clear();
+        },
+        "dsh-worktree-sidebar: 会话视图与 files 页签接管"
+      );
+    } catch (error) {
+      console.warn("[dsh-worktree-sidebar] mount failed:", error);
+    }
+  }
+  var inject = ["slots", "sidebarRightTabs", "sessions", "locale"];
+
+  // src/client/client-wrapper.ts
+  window.__ModuleLoader__.load({
+    id: "@wingsky-1/dsh-worktree-sidebar",
+    factory: function(require2) {
+      var module = { exports: {} };
+      var exports = module.exports;
+      exports.apply = apply;
+      exports.inject = inject;
+      Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+      return module.exports;
+    }
+  });
+})();

package/lib/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 宿主端组合根：收窄宿主上下文、按依赖顺序装配各域、卸载逆序释放。
+ *
+ * `ctx` 的知识只在这里出现——两个宿主适配器各自的官方形状收窄都写在下面对应的 `bind*` 调用里，
+ * 适配逻辑住 `src/server/host/`（宿主 rc 演进时只动那几个小文件）。五个域因此都拿不到 `ctx`，
+ * 也都能脱离 cordis 被单测驱动。
+ */
+import type { Context } from "@deepseek-ai/cordis";
+import { ROUTES } from "./shared/interface.js";
+/** 路由清单经这里出去，构建期注入客户端（bundle-host.ts 只认入口的 `ROUTES` 导出）。 */
+export { ROUTES };
+/** 稳定的 cordis 插件名。 */
+export declare const name = "worktree-sidebar";
+/**
+ * 依赖的宿主服务。声明成依赖之后由框架保证服务就绪才轮到装配。
+ *
+ * `typert` 是接管 `workspaceFileScope` 的唯一入口；`sessions` 只用来读**父链**（子 agent 继承父会话的
+ * 登记要靠它）。`sandboxPolicy` 曾经也在这里，是「provider 缺失时自己复刻官方默认语义」那套兜底的输入，
+ * 兜底删掉后它没有消费方了。
+ */
+export declare const inject: string[];
+/** 组合层入口配置。只有总开关（经插件配置传入）：不在盘上读用户配置文件，绑定表由插件在 DSH_HOME 下自持。 */
+export interface WorktreeSidebarConfig {
+    /** 总开关；`false` 时一律不接管、不注册工具、不挂路由。 */
+    enabled?: boolean;
+}
+/** 挂载 dsh-worktree-sidebar。 */
+export declare function apply(ctx: Context, config?: WorktreeSidebarConfig): Promise<void>;