dsh-card-dispatch 0.1.0 → 0.1.1

package/src/human-channel.js

@@ -24,6 +24,7 @@ import { describeConfig, mergeConfig, normalizeConfig } from './config.js'
 import { evaluateStart } from './gates.js'
 import { runSelfCheck } from './selfcheck.js'
 import { decideNext, parseVerdict, verdictPath } from './verdict.js'
+import { createReworkStore } from './rework-store.js'
 import { parseRequirementDoc } from './import.js'
 import { suggestCriteria } from './criteria.js'
 import { draftWithModel } from './criteria-llm.js'
@@ -48,6 +49,27 @@ function isLoopbackAddress(address) {
   return value === '::1' || value === '127.0.0.1' || value.startsWith('127.') || value === '::ffff:127.0.0.1'
 }
 
+/**
+ * 运行态快照：页面从看板 `/state` 的 executions 汇总后传进来。
+ *
+ * 缺一个数就返回 null（而不是补 0）：补 0 等于「今天一次没跑、没有会话在跑」，
+ * 两个闸会永远放行——这正是要修掉的那个洞。
+ *
+ * @param {unknown} raw
+ * @returns {{runsToday:number, runningSessions:number}|null}
+ */
+function gateStateOf(raw) {
+  if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) return null
+  const count = (value) => {
+    const number = Number(value)
+    return Number.isFinite(number) && number >= 0 ? Math.trunc(number) : null
+  }
+  const runsToday = count(raw.runsToday)
+  const runningSessions = count(raw.runningSessions)
+  if (runsToday === null || runningSessions === null) return null
+  return { runsToday, runningSessions }
+}
+
 /**
  * 模型写的「提示词开头」，只认 root / part-N 两种 key。
  *
@@ -187,9 +209,21 @@ export function createHumanChannel(deps = {}) {
     return { status: 200, body: { ok: true, rejected, config: describeConfig(merged) } }
   }
 
-  const statusRoute = () => {
+  const statusRoute = ({ searchParams } = {}) => {
     const workspaces = safeWorkspaces()
-    const check = runSelfCheck({ config: current, facts: { ...facts(), workspaceCount: workspaces.length } })
+    // 页面能看见看板（同源 fetch），插件进程看不见（看板自己有信任栅栏）。
+    // 所以让页面把探测结果带回来，体检才不是一堆「未知」。
+    const query = searchParams ?? new URLSearchParams()
+    const tri = (key) => {
+      const raw = query.get(key)
+      return raw === 'true' ? true : (raw === 'false' ? false : null)
+    }
+    const mergedFacts = { ...facts(), workspaceCount: workspaces.length }
+    const reachable = tri('boardReachable')
+    const teamRun = tri('boardTeamRun')
+    if (reachable !== null) mergedFacts.boardReachable = reachable
+    if (teamRun !== null) mergedFacts.boardTeamRun = teamRun
+    const check = runSelfCheck({ config: current, facts: mergedFacts })
     return {
       status: 200,
       body: {
@@ -248,14 +282,45 @@ export function createHumanChannel(deps = {}) {
         ? { ok: false, verdict: null, items: [], problems: [], summary: '', error: readError }
         : parseVerdict(text)
 
-    const decision = decideNext({ parsed, config: current, rejectedCount: body?.rejectedCount ?? 0 })
+    // 打回次数由**服务端落盘**决定，不信任 body 里的 rejectedCount：
+    // 以前计数只活在页面内存，刷新一次就归零，R3 的「第三次必须升级」形同虚设。
+    const reworkStore = createReworkStore({ dir: current.dataDir })
+    let previous = 0
+    try {
+      previous = reworkStore.get(rootId)
+    } catch {
+      // 读不出来按 0 处理；真正写的时候失败会明确报错（见下）
+      previous = 0
+    }
+    const decision = decideNext({ parsed, config: current, rejectedCount: previous })
     // 一次可以重跑多张卡：验收结论的 items 里可能有好几条判据，分属不同子卡。
     // `taskId` 是单卡的老写法，保留；`taskIds` 是页面上用的写法。
     const requested = Array.isArray(body?.taskIds)
       ? body.taskIds
       : (typeof body?.taskId === 'string' ? [body.taskId] : [])
     const taskIds = requested.map((value) => String(value ?? '').trim()).filter((value) => value !== '')
-    const runs = decision.action === 'rework'
+    // 只有「真的给出了要重跑的卡」才算一次打回：页面会先读一次结论、再带着卡 id 调一次，
+    // 第一次不该把计数加掉，否则上限会少算一轮。
+    const willRerun = decision.action === 'rework' && taskIds.length > 0
+    let counted = false
+    if (willRerun) {
+      try {
+        reworkStore.set(rootId, decision.rejectedCount)
+        counted = true
+      } catch (error) {
+        return {
+          status: 500,
+          body: { ok: false, error: { code: 'E_STORE_WRITE', message: `打回次数写盘失败（上限不生效，已拒绝重跑）：${error?.message ?? String(error)}` } },
+        }
+      }
+    } else if (decision.action === 'pass') {
+      try {
+        reworkStore.set(rootId, 0)
+      } catch {
+        // 验收通过时清不掉旧计数不致命：下次 rework 会按旧值继续，至少不会放宽
+      }
+    }
+    const runs = willRerun
       ? taskIds.map((id) => ({ requestId: `card-dispatch-${randomUUID()}`, action: { kind: 'run', taskId: id } }))
       : []
     return {
@@ -265,10 +330,13 @@ export function createHumanChannel(deps = {}) {
         path,
         verdict: parsed,
         decision,
+        // 这次到底有没有把计数加掉：页面据此说「第 N 次」才不会虚报
+        counted,
+        attempt: decision.rejectedCount,
         runs,
         run: runs.length > 0 ? runs[0] : null,
         // 判定做完了但不知道重跑哪张卡时，明确说清楚
-        hint: decision.action === 'rework' && runs.length === 0 ? '要重跑就带上 taskIds（被拒的那几张开发卡）' : '',
+        hint: decision.action === 'rework' && runs.length === 0 ? '要重跑就带上 taskIds（被拒的那几张开发卡）；带上才会记一次打回' : '',
       },
     }
   }
@@ -598,22 +666,29 @@ export function createHumanChannel(deps = {}) {
         criteria: body?.criteria ?? [],
         parallel: body?.parallel !== false,
         workspaceId: body?.workspaceId ?? null,
-        agentPreset: body?.agentPreset ?? null,
-        permission: body?.permission ?? current.permission ?? 'workspace-write',
+        // 权限与预设只认配置：body 能覆盖的话，curl 一句就能把卡提到 danger-full-access，
+        // 「配置里写 workspace-write」就成了摆设。页面本来也不传这两个字段。
+        agentPreset: null,
+        permission: current.permission,
         // 交付门槛开着才生成验收卡与证据要求；关掉就是省一张卡（它的会话费在团队模式下本来也不额外计）。
         requireEvidence: current.gates.requireEvidence === true,
         // 智能体团队由开关决定；父卡带 teamRun，子卡不带（子卡是 Lead 派出去的 teammate）。
         teamRun: current.execution?.teamRun === true,
         intros: sanitizeIntros(body?.intros),
+        maxReworkRounds: current.gates.maxReworkRounds,
       })
       // 拆分本身不花钱（只算文本），所以闸门卡的是**运行信封**：闸门不允许时
       // `run` 直接为 null，页面拿不到可执行的指令，就不会误开一轮。
       // 计划闸的「批准」在这一层只能来自人点「写入并运行」这一下——插件无法证明人
       // 真的读过拆分，这点在文档里写明了，不假装能证明。
+      // 运行态（今天跑了几次、几个在跑）由页面从看板 /state 汇总后传来；
+      // 拿不到就不放行（E_STATE_UNKNOWN），不能拿 0 冒充。
+      const gateState = gateStateOf(body?.state)
       const gate = evaluateStart({
         config: current,
-        state: {},
+        state: gateState ?? {},
         request: { planApproved: body?.planApproved === true },
+        stateKnown: gateState !== null,
       })
       return { status: 200, body: { ok: true, ...plan, run: gate.allow ? plan.run : null, gate } }
     } catch (error) {
@@ -655,7 +730,7 @@ export function createHumanChannel(deps = {}) {
       if (method === 'POST' && pathname === '/criteria') return criteriaRoute(request)
       if (method === 'POST' && pathname === '/parse') return parseRoute(request)
       if (method === 'POST' && pathname === '/plan') return planRoute(request)
-      if (method === 'GET' && pathname === '/status') return statusRoute()
+      if (method === 'GET' && pathname === '/status') return statusRoute({ searchParams: request.searchParams })
       if (method === 'GET' && pathname === '/config') {
         return { status: 200, body: { ok: true, configFile: store?.file ?? null, config: describeConfig(current) } }
       }
@@ -675,11 +750,13 @@ export function createHumanChannel(deps = {}) {
   }
 }
 
-function createHttpHandler(channel, options = {}) {
+export function createHttpHandler(channel, options = {}) {
   const send = (res, status, body, contentType = 'application/json; charset=utf-8') => {
     res.statusCode = status
     res.setHeader('content-type', contentType)
     res.setHeader('cache-control', 'no-store')
+    // 页面里的内容只该按声明的类型解释；顺手挡掉跨站嗅探。
+    res.setHeader('x-content-type-options', 'nosniff')
     res.end(typeof body === 'string' ? body : JSON.stringify(body ?? null))
   }
 
@@ -689,6 +766,29 @@ function createHttpHandler(channel, options = {}) {
       send(res, 403, { ok: false, error: { code: 'E_NOT_LOOPBACK', message: '控制台只接受本机回环请求' } })
       return
     }
+
+    // 同源栅栏：人标记不是鉴权，跨站页面可以带 `human: true` 发简单请求。
+    // 宿主有 connection 服务时下面还会再叠一层；没有时这里就是唯一一道。
+    const fetchSite = String(req.headers?.['sec-fetch-site'] ?? '').toLowerCase()
+    if (fetchSite === 'cross-site' || fetchSite === 'same-site') {
+      send(res, 403, { ok: false, error: { code: 'E_CROSS_SITE', message: '只接受同源请求' } })
+      return
+    }
+    const origin = req.headers?.origin
+    if (origin !== undefined) {
+      let originHost = ''
+      try {
+        originHost = new URL(String(origin)).host.toLowerCase()
+      } catch {
+        originHost = ''
+      }
+      const host = String(req.headers?.host ?? '').toLowerCase()
+      if (originHost === '' || originHost !== host) {
+        send(res, 403, { ok: false, error: { code: 'E_CROSS_ORIGIN', message: 'Origin 与 Host 不一致：只接受同源请求' } })
+        return
+      }
+    }
+
     const rejection = options.connection?.requestRejection?.(req)
     if (rejection !== undefined) {
       send(res, rejection, { ok: false, error: { code: 'E_UNTRUSTED_CONNECTION', message: `宿主连接栅栏拒绝：${rejection}` } })
@@ -702,6 +802,12 @@ function createHttpHandler(channel, options = {}) {
 
     let body
     if (String(req.method).toUpperCase() === 'POST') {
+      // 只收 JSON：`text/plain` 的简单请求不触发预检，正是跨站伪造最常用的形状。
+      const contentType = String(req.headers?.['content-type'] ?? '').toLowerCase()
+      if (!contentType.startsWith('application/json')) {
+        send(res, 415, { ok: false, error: { code: 'E_JSON_REQUIRED', message: 'POST 必须带 content-type: application/json' } })
+        return
+      }
       try {
         const text = await readBoundedBody(req)
         body = text.trim() === '' ? {} : JSON.parse(text)

package/src/model-call.js

@@ -30,19 +30,35 @@ async function buildMessage(text) {
 /**
  * 让模型回一段文本。
  *
+ * 失败重试一次：只在**非超时**的失败上重试（网络抖动、流断掉）。
+ * 超时不重试——`/plan` 本来就要顺序调两次，再翻倍等待只会让人以为页面卡死；
+ * 超时直接退回规则解析，让人看到「模型没答上来」。
+ *
  * @param {object} input
  * @param {any} input.llm 宿主的 llm 服务
  * @param {{provider:string, model:string}} input.route
  * @param {string} input.system 系统提示
  * @param {string} input.text 用户内容
  * @param {number} [input.timeoutMs]
+ * @param {number} [input.retries] 额外重试次数（默认 1）
  * @returns {Promise<{ok:boolean, reply:string, error:string|null}>}
  */
-export async function callModel({ llm, route, system, text, timeoutMs = MODEL_TIMEOUT_MS } = {}) {
+export async function callModel({ llm, route, system, text, timeoutMs = MODEL_TIMEOUT_MS, retries = 1 } = {}) {
   if (llm === null || llm === undefined) return { ok: false, reply: '', error: '宿主没有提供 llm 服务' }
   if (route === null || route === undefined) return { ok: false, reply: '', error: '没有可用的模型路由' }
   if (typeof llm.stream !== 'function') return { ok: false, reply: '', error: 'llm 服务没有 stream 方法' }
 
+  const extra = Math.max(0, Math.trunc(Number(retries) || 0))
+  let last = { ok: false, reply: '', error: '模型没有回内容' }
+  for (let attempt = 0; attempt <= extra; attempt += 1) {
+    last = await callOnce({ llm, route, system, text, timeoutMs })
+    if (last.ok || last.aborted === true) return { ok: last.ok, reply: last.reply, error: last.error }
+    if (attempt < extra) await new Promise((resolve) => setTimeout(resolve, 300))
+  }
+  return { ok: last.ok, reply: last.reply, error: last.error }
+}
+
+async function callOnce({ llm, route, system, text, timeoutMs }) {
   const controller = new AbortController()
   const timer = setTimeout(() => controller.abort(), timeoutMs)
   try {
@@ -61,14 +77,15 @@ export async function callModel({ llm, route, system, text, timeoutMs = MODEL_TI
     for await (const chunk of stream) {
       if (chunk !== null && chunk !== undefined && chunk.type === 'text-delta') reply += chunk.text
     }
-    if (reply.trim() === '') return { ok: false, reply: '', error: '模型没有回内容' }
-    return { ok: true, reply, error: null }
+    if (reply.trim() === '') return { ok: false, reply: '', error: '模型没有回内容', aborted: false }
+    return { ok: true, reply, error: null, aborted: false }
   } catch (error) {
     const aborted = controller.signal.aborted
     return {
       ok: false,
       reply: '',
       error: aborted ? `模型 ${timeoutMs / 1000}s 内没答上来` : String(error?.message ?? error),
+      aborted,
     }
   } finally {
     clearTimeout(timer)

package/src/rework-store.js

@@ -0,0 +1,69 @@
+/**
+ * rework-store.js：把「这一批已经打回了几次」**落到磁盘**。
+ *
+ * 为什么不能只放页面内存：R3 要求「第三次打回必须升级给人」。以前计数只活在一个
+ * JS 变量里，刷新页面/重开面板就归零，等于这条上限可以被无限绕过。
+ *
+ * 存哪儿：`<dataDir>/rework.json`，按 `rootId` 记一个很小的对象。
+ * 和 config.json 一样：读失败当空、写失败要报错（写不进去就不能假装限流生效）。
+ *
+ * @module dsh-card-dispatch/rework-store
+ */
+
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+
+/**
+ * @param {object} options
+ * @param {string} options.dir dataDir（相对宿主 cwd，和 config.json 同一个目录）
+ */
+export function createReworkStore({ dir }) {
+  const root = resolve(dir)
+  const file = join(root, 'rework.json')
+
+  /** @returns {Record<string, {count:number, updatedAt:string}>} */
+  function loadAll() {
+    try {
+      const parsed = JSON.parse(readFileSync(file, 'utf8'))
+      if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) return {}
+      return parsed
+    } catch {
+      // 文件不存在 / 被手改成半截 JSON：都当「没有记录」，不能因此让面板挂掉
+      return {}
+    }
+  }
+
+  /**
+   * 这一批已经打回了几次。
+   *
+   * @param {string} rootId
+   * @returns {number}
+   */
+  function get(rootId) {
+    const entry = loadAll()[rootId]
+    const count = Number(entry?.count)
+    return Number.isFinite(count) && count > 0 ? Math.trunc(count) : 0
+  }
+
+  /**
+   * 写回计数；0 表示清掉记录（验收通过）。
+   *
+   * @param {string} rootId
+   * @param {number} count
+   * @returns {number}
+   */
+  function set(rootId, count) {
+    const value = Math.max(0, Math.trunc(Number(count) || 0))
+    const all = loadAll()
+    if (value === 0) {
+      delete all[rootId]
+    } else {
+      all[rootId] = { count: value, updatedAt: new Date().toISOString() }
+    }
+    mkdirSync(root, { recursive: true })
+    writeFileSync(file, `${JSON.stringify(all, null, 2)}\n`, 'utf8')
+    return value
+  }
+
+  return { file, get, set }
+}