@whaletalk/dsh-codex-collab 0.1.2 → 0.1.4

package/README.md

@@ -202,12 +202,17 @@ dsh-task --in "<继续推进的指令>" --session "session-8d481ad9-..."
 
 ## 已知限制
 
-- 网关插件需要 `webServer` 服务（由 `dsh-web-app` 提供），因此**只能挂 web / desktop profile**；headless profile 会一直 pending。session 目标还需要同 bundle 的 `sessionController`，缺失时返回 `session-controller-unavailable`
+- 网关插件需要 `webServer` 服务（由 `dsh-web-app` 提供），因此**只能挂 web / desktop profile**；headless profile 会一直 pending。session 目标还需要 `sessionController`——它由组合**异步注册**（`webserver → web-runtime → connection → file-upload → session-controller`），所以插件是惰性取用，注册前调用会返回 `session-controller-unavailable`（稍后重试即可）
+- **`sessionController.search` 可能被部署禁用**（`session-query` 索引 `openAt: "never"`）。此时按标题查找自动退回 `list`（读持久化 header + 标题投影，同样不激活 Agent），响应里的 `matchedBy` 标明走了哪条路
+- **不能投递进子代理会话**：`resolveAgent` 对 subagent 路由拥有的会话返回 `session-busy: owned by subagent routing`；只能接普通会话
+- `POST /api/dsh-bridge/sessions {"create": true, "cwd": "..."}` 可新建一条空白会话（探针/一次性任务用），它不会碰任何已有会话
 - **同一会话同时只允许一个在途 bridge 任务**：DSH 自己会排队，但无法可靠地把两次并发派活的回报各自归属，所以第二个会被明确拒绝（`session-busy`）而不是猜
 - **冷会话可能接不上**：DSH 激活 Agent 需要会话投影（`Agent activation requires a projected Session observation`），未激活的会话会返回 `session-not-activatable`；归档会话的回合会以 `blocked` 收口（`session-archived`）
 - **评审不支持会话目标**：评审员必须与编码会话隔离，"独立评审"才成立
 - session 目标不使用 `cwd`/`lane`/`model`/`--commit`（会话自带这些语义），传了会被判 `invalid-target`
 - 网关重启会丢失内存中的任务表（含 session 观察器），这是既有设计
+- **DSH profile 的 pnpm 供应链冷却**：新发布的版本约 24 小时内会被 `minimumReleaseAge` 拒绝安装（`ERR_PNPM_MINIMUM_RELEASE_AGE_VIOLATION`）；管理器会把它写进 `pnpm-workspace.yaml` 的 `minimumReleaseAgeExclude` 才放行。刚发版就装不上属正常，不是包的问题
+- 升级已装组合包 = **卸载 → 重新安装**；卸载会把该包从 `dsh.profile.bundles` 移除，所以重装后**要确认它被重新选中**，否则插件不会挂载（表现为所有 `/api/dsh-bridge/*` 都落到网关鉴权层返回 401）
 - Codex Desktop Windows 本地市场技能注入 bug（见上，MCP 通道不受影响）
 - 动态插件环境无 `AbortSignal`，冷恢复失败时自动降级为一次性执行；宿主组合持久化版无此问题
 - ChatGPT Plus 写入型 MCP 的开放度取决于 OpenAI 产品策略

package/codex-plugin/plugins/dsh/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Codex 主导的双向编码协作插件：ChatGPT 把编码任务下发给本机 DeepSeek Harness 的持久编码子代理执行，DeepSeek 在共享工作目录 D:\\Harness 中写代码并实时回传进度与汇报，Codex 读文件验收、反馈修正，直到通过。",
   "author": {
     "name": "FuJackGao"

package/codex-plugin/plugins/dsh/skills/dsh-collab/SKILL.md

@@ -84,5 +84,7 @@ dsh-task --cancel <taskId> --force     # 取消 session 目标任务（会打断
 
 - 连接失败：DeepSeek Harness 未运行（网关应监听本机端口，默认 3080；挂在 web/desktop profile 时也可能就是 GUI 的端口）。
 - 派 session 任务返回 `session-writer-held` / `session-busy`：那条会话被别的写入方或另一个 bridge 任务占用；稍后重试，或改用 worker 目标。
+- 返回 `session-busy: owned by subagent routing`：那是子代理会话，**不能作为投递目标**；只能接普通会话。
 - 返回 `session-not-activatable` / `session-archived`：该会话当前接不了（冷会话未能激活，或已归档）；请用户先在客户端打开它，或解除归档。
+- 某些部署禁用了搜索（会话索引 `openAt: never`）：`--sessions` 会自动退回 `list` + 标题投影匹配，响应里的 `matchedBy` 会写 `list`。
 - 读不到 `--cwd` 目录：提示用户在 Codex 设置中把该目录加入可访问/可写目录。

package/harness/dsh-bridge.mjs

@@ -29,6 +29,8 @@ import {
   classifyTarget,
   selectSession,
   mapControllerError,
+  sessionTitleOf,
+  looksLikeDisabledSearch,
   taskResponse,
 } from './session-target.mjs'
 
@@ -46,9 +48,11 @@ export async function apply(ctx) {
   const sessionPersistence = ctx.get('sessionPersistence')
   const workspaceRegistry = ctx.get('workspaceRegistry')
   const llm = ctx.get('llm')
-  // 已有会话的读写入口（由 dsh-web-app bundle 提供，与 webServer 同源）。
-  // 不放进 inject：缺失时降级为稳定的 session-controller-unavailable，而不是整个插件挂掉。
-  const sessionController = ctx.get('sessionController')
+  // 已有会话的读写入口。**必须惰性取**：@deepseek-ai/dsh-api-session-controller 的
+  // sessionController 由组合异步注册（DSH 启动日志里它先处于 waiting for services），
+  // 在 apply() 时捕获会永久拿到 undefined。每次使用时现取；缺失时返回稳定的
+  // session-controller-unavailable，而不是让整个插件挂掉。
+  const sessionControllerNow = () => ctx.get('sessionController')
 
   // 清理历史版本可能泄漏的路由条目（重启前的动态插件、旧版本次插件）
   try {
@@ -397,20 +401,66 @@ export async function apply(ctx) {
   const sessionTargets = new Map()
 
   const sessionSearch = async (query) => {
-    const value = await sessionController.search({ query }, signalOf())
+    const controller = sessionControllerNow()
+    if (controller === undefined) {
+      throw Object.assign(new Error('sessionController service is not mounted in this profile'), { code: 'bridge/no-controller' })
+    }
+    const value = await controller.search({ query }, signalOf())
     const items = value !== undefined && value !== null && Array.isArray(value.items) ? value.items : []
     return items.filter((it) => it !== null && typeof it === 'object' && typeof it.sessionId === 'string' && it.sessionId !== '')
   }
 
+  /**
+   * 退回路径：不打开 search 索引，直接遍历 list（读持久化 header + 投影缓存）。
+   * 有些部署把 session-query 索引配成 openAt: "never"，此时 search 永远失败，
+   * 而按标题找会话仍必须可用——list 就是不激活 Agent 也能拿到标题的那条路。
+   */
+  const sessionList = async (query) => {
+    const controller = sessionControllerNow()
+    if (controller === undefined) {
+      throw Object.assign(new Error('sessionController service is not mounted in this profile'), { code: 'bridge/no-controller' })
+    }
+    const needle = query.toLowerCase()
+    const value = await controller.list({}, signalOf())
+    const items = value !== undefined && value !== null && Array.isArray(value.items) ? value.items : []
+    const out = []
+    for (const summary of items) {
+      if (summary === null || typeof summary !== 'object' || typeof summary.sessionId !== 'string') continue
+      const title = sessionTitleOf(summary)
+      if (title !== '' && title.toLowerCase().includes(needle)) {
+        out.push({ sessionId: summary.sessionId, snippet: title })
+        continue
+      }
+      if (typeof summary.cwd === 'string' && summary.cwd !== '' && summary.cwd.toLowerCase().includes(needle)) {
+        out.push({ sessionId: summary.sessionId, snippet: summary.cwd })
+      }
+    }
+    return out
+  }
+
+  /** 先 search，失败就退回 list；返回 {hits, matchedBy} 让调用方看得见走了哪条路。 */
+  const sessionFind = async (query) => {
+    try {
+      return { hits: await sessionSearch(query), matchedBy: 'search' }
+    } catch (e) {
+      if (!looksLikeDisabledSearch(e)) throw e
+      return { hits: await sessionList(query), matchedBy: 'list' }
+    }
+  }
+
   /** 只读解析：query → search 选一；sessionId → 直接用。任何不确定性都返回 reason。 */
   const resolveSessionTarget = async (target) => {
-    if (sessionController === undefined) {
+    const controller = sessionControllerNow()
+    if (controller === undefined) {
       return { ok: false, reason: REASONS.CONTROLLER_UNAVAILABLE, message: 'sessionController service is not mounted in this profile', candidates: [] }
     }
     let hits = []
+    let matchedBy = 'sessionId'
     if (target.sessionId === undefined) {
       try {
-        hits = await sessionSearch(target.query)
+        const found = await sessionFind(target.query)
+        hits = found.hits
+        matchedBy = found.matchedBy
       } catch (e) {
         return { ok: false, reason: REASONS.GATEWAY_INTERNAL, message: errText(e), candidates: [] }
       }
@@ -419,14 +469,14 @@ export async function apply(ctx) {
     if (!picked.ok) return picked
     let result
     try {
-      result = await sessionController.resolveAgent(picked.sessionId)
+      result = await controller.resolveAgent(picked.sessionId)
     } catch (e) {
       return { ok: false, reason: mapControllerError(e), message: errText(e), candidates: picked.candidates }
     }
     if (result !== undefined && result !== null && result.error !== undefined) {
       return { ok: false, reason: mapControllerError(result.error), message: errText(result.error), candidates: picked.candidates }
     }
-    return { ok: true, sessionId: picked.sessionId, snippet: picked.snippet, candidates: picked.candidates }
+    return { ok: true, sessionId: picked.sessionId, snippet: picked.snippet, candidates: picked.candidates, matchedBy }
   }
 
   const sessionPendingTask = (sessionId) => tasks.find((t) => (t.status === 'accepted' || t.status === 'running') && t.target !== undefined && t.target.kind === 'session' && t.target.sessionId === sessionId)
@@ -478,7 +528,9 @@ export async function apply(ctx) {
     record.watcher = 'follow'
     void (async () => {
       try {
-        const stream = sessionController.follow({ address: { kind: 'session', sessionId: record.sessionId } }, controller.signal)
+        const controllerRef = sessionControllerNow()
+        if (controllerRef === undefined) throw new Error('sessionController is not mounted')
+        const stream = controllerRef.follow({ address: { kind: 'session', sessionId: record.sessionId } }, controller.signal)
         for await (const frame of stream) {
           if (record.settled) break
           if (frame === null || typeof frame !== 'object') continue
@@ -523,6 +575,7 @@ export async function apply(ctx) {
     task.target.sessionId = resolved.sessionId
     if (resolved.snippet !== undefined) task.target.snippet = resolved.snippet
     if (resolved.candidates.length > 0) task.candidates = resolved.candidates
+    if (resolved.matchedBy !== undefined) task.matchedBy = resolved.matchedBy
 
     const inFlight = sessionPendingTask(resolved.sessionId)
     if (inFlight !== undefined && inFlight.taskId !== task.taskId) {
@@ -552,7 +605,17 @@ export async function apply(ctx) {
     sessionTargets.set(resolved.sessionId, record)
 
     try {
-      await sessionController.prompt({
+      const controllerRef = sessionControllerNow()
+      if (controllerRef === undefined) {
+        sessionTargets.delete(resolved.sessionId)
+        record.settled = true
+        task.status = 'error'
+        task.error = 'sessionController service is not mounted in this profile'
+        task.reason = REASONS.CONTROLLER_UNAVAILABLE
+        pushTask(task.taskId, 'error', { error: task.error, reason: task.reason, target: { kind: 'session', sessionId: resolved.sessionId } })
+        return { task, failed: { reason: task.reason, message: task.error, candidates: [] } }
+      }
+      await controllerRef.prompt({
         requestId: task.taskId,
         sessionId: resolved.sessionId,
         mode: deliver,
@@ -720,7 +783,8 @@ export async function apply(ctx) {
   }
 
   // 完成信号：会话从 running 回到 idle 即这一轮结束（follow 只负责流式进度）。
-  if (sessionController !== undefined) {
+  // 订阅的是 ctx 上的事件，与服务何时注册无关，所以不设门禁。
+  {
     ctx.effect(() => {
       const off = ctx.on('api-session/status', (sessionId, running) => {
         const record = sessionTargets.get(sessionId)
@@ -819,12 +883,24 @@ export async function apply(ctx) {
       } else {
         parsed = qsOf(req)
       }
-      if (sessionController === undefined) {
-        sendJson(res, 503, { error: 'sessionController service is not mounted in this profile', reason: REASONS.CONTROLLER_UNAVAILABLE })
+      const controller = sessionControllerNow()
+      if (controller === undefined) {
+        sendJson(res, 503, { error: 'sessionController service is not mounted yet (it registers asynchronously after startup; retry shortly)', reason: REASONS.CONTROLLER_UNAVAILABLE })
         return
       }
       const query = typeof parsed.query === 'string' && parsed.query.trim() !== '' ? parsed.query.trim() : undefined
       const sessionId = typeof parsed.sessionId === 'string' && parsed.sessionId.trim() !== '' ? parsed.sessionId.trim() : undefined
+      // create 是显式动作：为探针/一次性任务建一条空白会话，不去碰任何已有会话。
+      if (parsed.create === true) {
+        const cwd = typeof parsed.cwd === 'string' && parsed.cwd.trim() !== '' ? parsed.cwd.trim() : undefined
+        try {
+          const created = await controller.create(cwd === undefined ? {} : { cwd }, signalOf())
+          sendJson(res, 201, { sessionId: created !== undefined && created !== null ? created.sessionId : undefined, agentPreset: created === undefined || created === null ? undefined : created.agentPreset })
+        } catch (e) {
+          sendJson(res, 502, { error: errText(e), reason: mapControllerError(e) })
+        }
+        return
+      }
       if (query === undefined && sessionId === undefined) {
         sendJson(res, 400, { error: 'query or sessionId required', reason: REASONS.INVALID_TARGET })
         return
@@ -840,7 +916,9 @@ export async function apply(ctx) {
           sendJson(res, 200, { items: [{ sessionId: resolved.sessionId, ...(resolved.snippet === undefined ? {} : { snippet: resolved.snippet }), agentAvailable: true }], hasMore: false })
           return
         }
-        const hits = await sessionSearch(query)
+        // search 失败就退回 list：有些部署把 session-query 索引配成 openAt "never"。
+        const found = await sessionFind(query)
+        const hits = found.hits
         const items = hits.slice(0, limit).map((h) => ({
           sessionId: h.sessionId,
           snippet: typeof h.snippet === 'string' ? h.snippet.slice(0, 200) : '',
@@ -849,7 +927,7 @@ export async function apply(ctx) {
           // 只对前 5 条探能力：逐条 stat 会很贵，这里保持有界。
           for (const item of items.slice(0, 5)) {
             try {
-              const r = await sessionController.resolveAgent(item.sessionId)
+              const r = await controller.resolveAgent(item.sessionId)
               const failed = r !== undefined && r !== null && r.error !== undefined
               item.agentAvailable = !failed
               if (failed) item.problem = mapControllerError(r.error)
@@ -859,7 +937,7 @@ export async function apply(ctx) {
             }
           }
         }
-        sendJson(res, 200, { items, hasMore: hits.length > items.length, total: hits.length })
+        sendJson(res, 200, { items, hasMore: hits.length > items.length, total: hits.length, matchedBy: found.matchedBy })
       } catch (e) {
         sendJson(res, 502, { error: errText(e), reason: mapControllerError(e) })
       }
@@ -914,7 +992,9 @@ export async function apply(ctx) {
         }
         let cancelled = false
         try {
-          await sessionController.cancel({ sessionId: task.target.sessionId }, signalOf())
+          const controller = sessionControllerNow()
+          if (controller === undefined) throw new Error('sessionController service is not mounted in this profile')
+          await controller.cancel({ sessionId: task.target.sessionId }, signalOf())
           cancelled = true
         } catch (e) {
           console.error('[dsh-bridge] session cancel failed:', errText(e).slice(0, 200))
@@ -960,6 +1040,7 @@ export async function apply(ctx) {
           taskId: task.taskId, status: task.status, kind: task.kind, cwd: task.cwd, lane: task.lane,
           target: task.target, deliver: task.deliver, instruction: task.instruction.slice(0, 300),
           result: task.result, error: task.error, reason: task.reason, fallback: task.fallback,
+          ...(task.matchedBy === undefined ? {} : { matchedBy: task.matchedBy }),
           ...(Array.isArray(task.candidates) && task.candidates.length > 0 ? { candidates: task.candidates } : {}),
           ...(record === undefined ? {} : { watcher: record.watcher, sawRunning: record.sawRunning }),
         })
@@ -971,7 +1052,7 @@ export async function apply(ctx) {
         lanes: Array.from(buckets.keys()),
         reviewers: Array.from(reviewerBuckets.keys()),
         sessions: Array.from(sessionTargets.keys()),
-        sessionController: sessionController !== undefined,
+        sessionController: sessionControllerNow() !== undefined,
         tasks: tasks.slice(-20).map((t) => ({ taskId: t.taskId, kind: t.kind, status: t.status, cwd: t.cwd, lane: t.lane, target: t.target, deliver: t.deliver })),
       })
     },
@@ -982,7 +1063,15 @@ export async function apply(ctx) {
     path: '/api/dsh-bridge/debug',
     handler: async (req, res) => {
       if (!isLoopback(req)) { res.writeHead(403); res.end('forbidden'); return }
-      const out = { pending: 0, historyCount: history.length, presets: [], providers: [], buckets: [], reviewers: [], sessionController: sessionController !== undefined, sessionTargets: [], models: knownModels, modelProvider, modelListError, workspaces: [] }
+      // services 是现场探测（不是 apply 时的快照）：sessionController 可能晚于本插件注册，
+      // 这份清单能在"接不上会话"时直接告诉我们到底缺哪个服务。
+      const probe = (name) => { try { return ctx.get(name) !== undefined } catch (e) { return false } }
+      const out = {
+        pending: 0, historyCount: history.length, presets: [], providers: [], buckets: [], reviewers: [],
+        sessionController: probe('sessionController'),
+        services: Object.fromEntries(['sessionController', 'connection', 'sessionQuery', 'sessionPersistence', 'workspaceRegistry', 'agents', 'subagents', 'agentPresets', 'timer', 'llm'].map((n) => [n, probe(n)])),
+        sessionTargets: [], models: knownModels, modelProvider, modelListError, workspaces: [],
+      }
       out.pending = tasks.filter((t) => t.status === 'accepted' || t.status === 'running').length
       try { out.providers = subagents.list() } catch (e) { out.providers = ['list failed: ' + errText(e)] }
       if (agentPresets !== undefined) {
@@ -1124,5 +1213,5 @@ export async function apply(ctx) {
     sessionTargets.clear()
   })
 
-  console.log('[dsh-bridge] persistent gateway ready (host composition): task(new|session) · sessions · review · tasks · cancel · status · debug · WS | sessionController=' + (sessionController !== undefined ? 'yes' : 'no'))
+  console.log('[dsh-bridge] persistent gateway ready (host composition): task(new|session) · sessions · review · tasks · cancel · status · debug · WS | sessionController=' + (sessionControllerNow() !== undefined ? 'yes' : 'late-bound (registers asynchronously)'))
 }

package/harness/session-target.mjs

@@ -190,6 +190,34 @@ export const mapControllerError = (error) => {
   }
 }
 
+/**
+ * 从 SessionSummary 里取标题。
+ *
+ * 标题不在 summary 顶层：它来自投影缓存（`projections.values.title`），而且不同 DSH
+ * 版本可能给字符串或 `{ val }` 包装，两种都认。`list` 在**不激活 Agent、也不打开
+ * search 索引**的前提下读持久化 header 与投影缓存，因此在 search 被部署禁用
+ * （session-query 索引 openAt: "never"）时，它是唯一还能按标题找会话的路径。
+ */
+export const sessionTitleOf = (summary) => {
+  if (summary === null || typeof summary !== 'object') return ''
+  const projections = summary.projections
+  if (projections === null || typeof projections !== 'object') return ''
+  const values = projections.values
+  if (values === null || typeof values !== 'object') return ''
+  const title = values.title
+  if (typeof title === 'string') return title
+  if (title !== null && typeof title === 'object' && typeof title.val === 'string') return title.val
+  return ''
+}
+
+/** search 在本部署被禁用时的报错特征（session-query 索引 openAt: "never"）。 */
+export const looksLikeDisabledSearch = (error) => {
+  const text = error !== null && typeof error === 'object' && typeof error.message === 'string'
+    ? error.message
+    : String(error === undefined || error === null ? '' : error)
+  return /search is disabled/i.test(text)
+}
+
 /** 任务在 HTTP 行上的回显：调用方一眼能看出这次是"新建"还是"接进哪个会话"。 */
 export const taskResponse = (task) => {
   const out = { taskId: task.taskId, status: task.status, kind: task.kind }

package/mcp/dsh-mcp.mjs

@@ -6,7 +6,7 @@
 //      客户端（Secure MCP Tunnel / cloudflared）桥接给 ChatGPT 等远程产品。
 const GATEWAY = process.env.DSH_BRIDGE_URL || 'http://127.0.0.1:3080'
 const SERVER_NAME = 'dsh-bridge'
-const SERVER_VERSION = '0.1.2'
+const SERVER_VERSION = '0.1.4'
 const PROTOCOL_VERSION = '2024-11-05'
 
 const log = (...args) => console.error('[dsh-mcp]', ...args)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@whaletalk/dsh-codex-collab",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Codex × DeepSeek Harness 双向编码协作：Codex 主导派活与验收，DeepSeek Harness 编码子代理在共享工作目录执行并回传，独立评审子代理实际跑通构建/测试后出具报告。提供 DSH 宿主网关插件、零依赖 MCP 服务器与 Codex 技能三件套。",
   "license": "MIT",
   "type": "module",