@whaletalk/dsh-codex-collab 0.1.7 → 0.1.9

package/docs/codex-desktop-attachment-evidence.md

@@ -0,0 +1,116 @@
+# M0 证据：Codex Desktop 桌面接入能力（本机 Windows）
+
+- 首次记录：2026-10-10；**复核更新：2026-10-12**（桌面重启后 PID 变化，结论未变）
+- 仓库：`E:/11-Github/dsh-codex-collab`
+- 计划：`docs/DSH_TO_CODEX_MESSAGING_PLAN.md`
+- **结论：M0 未通过 —— 本机不存在可附着的桌面端点。桌面自动唤醒处于 blocked。**
+- 文中 PID / 安装路径均为**当次现场信息**，仅作证据；实现里一律不硬编码（探针每次现场读取）。
+
+## 1. 一句话结论
+
+桌面 Codex（ChatGPT.exe）把 app-server 以**默认 `stdio://`** 启动，stdin/stdout 归父进程私有；
+本机既没有 `--listen` 出的 ws/TCP 端点，也没有文档所说的 app-server 控制套接字。
+因此在"**不启动第二份 app-server**"的前提下，第三方无法连到桌面正在使用的那个后台，
+`thread/loaded/list` 与 canary 都无法进行。协议本身具备所需方法（见 §4），缺的只是**传输**。
+
+## 2. 现场事实与证据（2026-10-12 复核）
+
+| # | 探测项 | 实测结果 | 证据来源 |
+|---|---|---|---|
+| 1 | 桌面 App | `ChatGPT.exe`（PID 11768），Store 包 `OpenAI.Codex_26.1007.2314.0_x64__2p2nqsd0c76g0` | 进程扫描 |
+| 2 | 桌面 app-server | PID 17068，`codex-cli 0.162.0-alpha.17.2`（bundled CLI），**祖先链**：`17068 ← ChatGPT.exe(11768)` | 探针 `desktop[].why` |
+| 3 | 同一桌面的其它 app-server | PID 19848、53256，同样 `--listen stdio://`；祖先链 `app-server ← node_repl.exe ← node.exe ← 17068 ← ChatGPT.exe(11768)` | 探针 `desktop[].ancestry` |
+| 4 | app-server 启动参数 | 桌面主实例：`-c features.code_mode_host=true app-server --analytics-default-enabled …`（**无 `--listen`** → 默认 `stdio://`）；另两个显式 `app-server --listen stdio://` | 进程命令行 |
+| 5 | TCP 监听 | 三个实例 **tcp=[]**（无任何 LISTEN 端点） | 探针 `listenerScan` |
+| 6 | 控制套接字 | `C:\Users\Marx\.codex\app-server-control\app-server-control.sock` **不存在** | 探针 `controlSocket` |
+| 7 | daemon 路径（bundled CLI） | `app-server daemon version` → `Error: failed to connect to …app-server-control.sock` / `os error 10050` | 探针 `daemonProbe` |
+| 8 | daemon 路径（全局 CLI 0.147.0） | `app-server daemon version` → `Error: codex app-server daemon lifecycle is only supported on Unix platforms` | 2026-10-10 实跑 |
+| 9 | `proxy --sock` | 帮助里出现，但目标是"app-server **Unix domain socket**"；实跑 → `failed to connect to socket at …` + `os error 10050`。**帮助里有 ≠ 可用** | 2026-10-10 实跑 |
+| 10 | 命名管道 | 41 个 codex 管道（`codex-browser-use-*` / `codex-computer-use-*` / `codex-ipc` / 沙箱服务）。`codex-ipc` 字符串**存在于 CLI 二进制内** → Codex 内部 IPC，非文档传输；**未连接、未使用** | 探针 `namedPipes` |
+| 11 | 协议方法面 | `app-server generate-json-schema --out <临时目录>` 成功；含 `v1/InitializeParams`、`v2/ThreadLoadedListParams`、`ThreadRead/List`、`TurnStart/Steer/Interrupt`、`ThreadInjectItems` | 探针 `schema.keyMethods` |
+| 12 | 历史（2026-10-10） | 当时为 `ChatGPT.exe 44100 → app-server 24776`，其余结论相同 | 前一版记录（PID 仅是历史，不作依据） |
+
+## 3. 被排除的替代路径（以及为什么）
+
+| 路径 | 为什么不用 |
+|---|---|
+| 自己起 `codex app-server --listen ws://…` | 那是**第二份 app-server**（独立存储/独立线程注册表）。用它 `thread/resume` 同一 ID 只能证明"磁盘上能读到这个 ID"，**不能证明连上了桌面正在用的后台**——计划明文禁止以此冒充投递成功 |
+| `app-server daemon start/bootstrap` | 该生命周期在本平台不可用（§2 #7/#8）；即便可用也仍是第二实例；`enable-remote-control` 属未授权变更 |
+| `codex app-server proxy` | 依赖不存在的 Unix 控制套接字（§2 #9） |
+| 直写桌面会话存储 / rollout 文件 | 计划禁止；写入磁盘不会让那条聊天产生回合，不满足验收 |
+| **同一份存储目录** | **不能证明是同一后台**：探针刻意不把 storage 当证据；判定只看祖先链与端点是否存在 |
+| `\\.\pipe\codex-ipc` 私有 IPC | 计划明令不得以"私有 IPC 猜测"凑通路；未做连接尝试 |
+| 普通 MCP notification / Work Cloud 的 MCP Events | 前者不会唤醒本地聊天，后者适用范围是 Work 产品线，**都不算本地桌面唤醒** |
+| 重启 Codex/DSH 以带 `--listen` 启动 | 未获授权（且会中断正在进行的回合） |
+
+## 4. 结论与能力边界
+
+- **协议可行、传输阻断**：所需方法在 schema 中都存在，"投递并观察回合"在协议层可表达；
+  缺的是**一条被支持的、指向桌面现有后台的传输**。
+- 降级交付 = **收件箱模式**。能力如实上报（`codex-inbox capabilities` / `codex-desktop-probe`）：
+
+  ```json
+  {
+    "available": false,
+    "deliveryMode": "inbox",
+    "canWakeIdle": false,
+    "canObserveTurns": false,
+    "reason": "desktop-attachment-unavailable"
+  }
+  ```
+
+- **明确不宣称**：桌面自动唤醒、在线长等待、回合事件观察均**未实现**。
+- 授权目标线程 `01a100f1-045c-7e10-84c7-ac8ec37eff3f` 与来源会话
+  `session-dd9655aa-b99f-4e36-b914-a5035fd094e1` 仅登记在**本地实验绑定**里（收件箱用），
+  **未**写入任何发布包默认值。因为没有投递入口，**canary 未发送**（无路可发，不是失败）。
+
+## 5. 探针的判定纪律（2026-10-12 强化）
+
+`mcp/codex-desktop-probe.mjs` 的判定是**纯函数**（`classifyProcesses` / `decideCapabilities`），
+采集层解析（`parseScanOutput`）也是纯函数，都可离线测试：
+
+1. **桌面身份靠祖先链证明，且另一份 app-server 会遮断归属**：命令行里出现 `app-server` 不足以认定桌面；
+   必须**先**遇到安装式桌面 App（`ChatGPT.exe`/`Codex.exe` 位于 `WindowsApps`/`Programs`）。
+   祖先链里若**先**遇到另一份 app-server，说明该实例是由那份后台派生的（桌面运行时 `node_repl`/`node`
+   就会派生这种实例）→ 单列为 `standalone`，**不能算作桌面正在使用的后台**。
+   祖先链拿不到的进 `unidentified`。
+2. **同一份存储不能证明是同一后台**：探针不使用 storage 做判定，只在报告里附注。
+3. **采集层必须 fail loud**：PowerShell 查询一律 `-ErrorAction Stop` 并显式传播失败；脚本用
+   `DSH_PROBE_JSON:` 标记 + 退出码区分"结果为空"与"没有结果"。**非终止错误 + exit 0 + 空 stdout
+   绝不能被当成"扫描成功且结果为空"**——那会让探针从"没查到"误推成"没有端点"。采集解析失败 →
+   `probe-inconclusive`，不是 `unavailable`。
+4. **存在端点信号 → `endpoint-present-unverified`**：桌面 app-server 用了非 stdio 的 `--listen`、
+   或控制套接字存在、或 daemon 探测成功，任一成立即报此结论（**不因为"没有 TCP 监听"就声称没有端点**）。
+5. **`canWakeIdle` / `canObserveTurns` 恒为 false**，直到真的完成协议校验与同一聊天 canary。
+6. `--schema` 生成的临时目录在**递归删除前**显式校验解析后的目标位于系统临时根之内。
+
+## 6. 什么条件下可以重新评估 M0
+
+出现以下任一情形即可重跑 `node mcp/codex-desktop-probe.mjs --schema` 复核：
+
+1. 桌面版本/配置使 app-server 以 `--listen ws://127.0.0.1:<port>`（或 Windows 上可用的 `unix://`）启动；
+2. 桌面提供**文档化的**本机控制端点（例如 `app-server-control` 在本平台真实存在且可连）；
+3. 官方为 Windows 提供可用的 app-server daemon 生命周期。
+
+届时 M0 需重做：连上**同一后台** → `initialize/initialized` → `thread/loaded/list` 命中目标 →
+`thread/read` 取证 → 观察运行中回合 → 空闲后 canary。
+
+## 7. 本次未做的操作（合规声明）
+
+未修改 Codex 配置或权限模式、未启用远程控制、未重启 Codex/DSH、未读取或输出任何凭据
+（`auth.json` 等一律未读）、未改写会话存储、未模拟点击、未修改上游、未打 tag、未 npm 发布。
+除可选的临时 schema 目录（用后即删，且删除前校验路径）外探针只读；收件箱默认写在
+`~/.dsh-codex-inbox`，**不写入仓库**。
+
+## 8. 复现命令
+
+```powershell
+# 一条命令给出结论（含祖先链归属与协议方法面）
+node mcp/codex-desktop-probe.mjs --schema
+
+# 手动复核
+Get-CimInstance Win32_Process | Where-Object { $_.CommandLine -match 'app-server' } |
+  Select-Object ProcessId,ParentProcessId,ExecutablePath,CommandLine
+Get-NetTCPConnection -State Listen | Where-Object { $_.OwningProcess -in <上面的 pid> }   # 期望为空
+Test-Path "$env:USERPROFILE\.codex\app-server-control\app-server-control.sock"            # 期望 False
+```

package/harness/codex-associations.mjs

@@ -0,0 +1,265 @@
+/**
+ * codex-associations.mjs —— 「来源 Codex 对话 → 任务 → 执行方 DSH」的持久关联记录（零依赖）。
+ *
+ * 目的（R1）：Codex 在**某个回合**派活时带上来源对话 ID（originThreadId），此后**任何回合**都能
+ * 用 originThreadId + taskId 精确取回这次任务的结果；只给 originThreadId 时能列出该对话登记过的任务，
+ * 用来找回丢失的 taskId。
+ *
+ * 存储：`<root>/<namespace>/bindings.jsonl`，**追加型事件日志**（bind / update 各一行），读取时折叠成记录。
+ *   - 追加前修记录边界（末字节不是换行就先补一个），残尾不会吞掉后续写入；
+ *   - 写入在 fs-lock.mjs 的独占写锁内串行化（与收件箱共用同一把锁的算法）；
+ *   - 读不动（权限/IO）抛 store-unreadable；文件有内容但一行都解析不出抛 store-corrupt——
+ *     **绝不静默降级成空记录**。
+ *
+ * 隔离：命名空间是**校验过的短标识**（`[A-Za-z0-9._-]{1,64}`），只用来选子目录；origin/taskId
+ * 永远不参与路径拼接。多个网关共用同一命名空间也是安全的：日志是追加型、taskId 全局唯一，
+ * 不存在"别人覆盖我的记录"；需要按 profile 分隔时用 DSH_CODEX_TASK_ASSOC_NAMESPACE 指定。
+ *
+ * 注意：originThreadId 是**关联元数据**，不是认证/授权凭据。
+ */
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { createFileLock } from './fs-lock.mjs'
+
+export const ASSOC_REASONS = {
+  /** originThreadId 不是合法的非空字符串。 */
+  INVALID_ORIGIN: 'invalid-origin',
+  /** 需要来源才能精确取值/恢复，但调用方没给。 */
+  MISSING_ORIGIN: 'origin-required',
+  /** 给了来源，但这条任务的登记来源不是它——**绝不返回别的对话的结果**。 */
+  ORIGIN_MISMATCH: 'origin-mismatch',
+  /** taskId 没有关联登记。 */
+  UNKNOWN_TASK: 'unknown-task',
+  /** 同一 taskId 试图改投另一个来源。 */
+  ORIGIN_CONFLICT: 'origin-conflict',
+  STORE_UNREADABLE: 'store-unreadable',
+  STORE_CORRUPT: 'store-corrupt',
+}
+
+export const MAX_ORIGIN_LENGTH = 200
+const NAMESPACE_RE = /^[A-Za-z0-9._-]{1,64}$/
+
+/** origin 必须是**非空**字符串（去空白后仍非空）、不含控制字符、长度有界。 */
+export const isValidOrigin = (value) => typeof value === 'string'
+  && value.trim() !== ''
+  && value.trim().length <= MAX_ORIGIN_LENGTH
+  && !/[\u0000-\u001f\u007f]/.test(value)
+
+/** 命名空间只允许 `[A-Za-z0-9._-]{1,64}`，且显式排除 `.` / `..`（它们会让 path.join 逃出存储根）。 */
+export const isValidNamespace = (value) => typeof value === 'string'
+  && NAMESPACE_RE.test(value)
+  && value !== '.'
+  && value !== '..'
+
+/** 存储根：显式参数 > DSH_CODEX_TASK_ASSOC_DIR > 用户数据目录（**绝不默认写进仓库**）。 */
+export const resolveAssocRoot = (explicit) => {
+  if (typeof explicit === 'string' && explicit.trim() !== '') return path.resolve(explicit)
+  const fromEnv = process.env.DSH_CODEX_TASK_ASSOC_DIR
+  if (typeof fromEnv === 'string' && fromEnv.trim() !== '') return path.resolve(fromEnv)
+  return path.join(os.homedir(), '.dsh-codex-task-assoc')
+}
+
+/** 命名空间：显式参数 > 环境变量 > 'default'。非法命名空间直接抛错（不拼路径）。 */
+export const resolveNamespace = (explicit) => {
+  const raw = (typeof explicit === 'string' && explicit.trim() !== '')
+    ? explicit.trim()
+    : (typeof process.env.DSH_CODEX_TASK_ASSOC_NAMESPACE === 'string' && process.env.DSH_CODEX_TASK_ASSOC_NAMESPACE.trim() !== ''
+        ? process.env.DSH_CODEX_TASK_ASSOC_NAMESPACE.trim()
+        : 'default')
+  if (!isValidNamespace(raw)) {
+    throw Object.assign(new Error('invalid association namespace: ' + JSON.stringify(raw) + ' (expected [A-Za-z0-9._-]{1,64})'), { reason: ASSOC_REASONS.INVALID_ORIGIN })
+  }
+  return raw
+}
+
+const fail = (reason, message, extra) => Object.assign(new Error(message), { reason, ...(extra === undefined ? {} : extra) })
+
+const readJsonLines = (file) => {
+  let text
+  try {
+    text = fs.readFileSync(file, 'utf8')
+  } catch (e) {
+    if (e !== null && typeof e === 'object' && e.code === 'ENOENT') return []
+    throw fail(ASSOC_REASONS.STORE_UNREADABLE, 'cannot read ' + file + ': ' + e.message)
+  }
+  if (text.trim() === '') return []
+  const events = []
+  let bad = 0
+  for (const line of text.split('\n')) {
+    const trimmed = line.trim()
+    if (trimmed === '') continue
+    try {
+      const value = JSON.parse(trimmed)
+      if (value !== null && typeof value === 'object' && typeof value.type === 'string') events.push(value)
+      else bad++
+    } catch (e) { bad++ }
+  }
+  if (events.length === 0 && bad > 0) {
+    // 有内容却一条都解析不出来：这是损坏，不是"空存储"。
+    throw fail(ASSOC_REASONS.STORE_CORRUPT, file + ' has content but no readable records (' + bad + ' bad line(s))')
+  }
+  return events
+}
+
+const foldRecords = (events) => {
+  const records = new Map()
+  for (const event of events) {
+    if (event.type === 'bind') {
+      if (typeof event.taskId !== 'string' || typeof event.originThreadId !== 'string') continue
+      records.set(event.taskId, {
+        originThreadId: event.originThreadId,
+        taskId: event.taskId,
+        kind: event.kind,
+        target: event.target,
+        profile: event.profile,
+        status: typeof event.status === 'string' ? event.status : 'accepted',
+        createdAt: event.at,
+        updatedAt: event.at,
+        delivered: event.delivered,
+        result: undefined,
+        error: undefined,
+        reason: undefined,
+        stopReason: undefined,
+      })
+      continue
+    }
+    if (event.type === 'update') {
+      const record = records.get(event.taskId)
+      if (record === undefined) continue
+      for (const key of ['status', 'delivered', 'result', 'error', 'reason', 'stopReason', 'requestId', 'dshTurn']) {
+        if (event[key] !== undefined) record[key] = event[key]
+      }
+      record.updatedAt = event.at
+    }
+  }
+  return records
+}
+
+/**
+ * 打开任务关联存储。方法与收件箱同风格：同步、语义确定。
+ * @param {{root?: string, namespace?: string, lockTimeoutMs?: number, profile?: string}} options
+ */
+export const openAssociations = (options = {}) => {
+  const root = resolveAssocRoot(options.root)
+  const namespace = resolveNamespace(options.namespace)
+  const dir = path.join(root, namespace)
+  const file = path.join(dir, 'bindings.jsonl')
+  const lock = createFileLock({ lockFile: path.join(dir, '.write.lock'), timeoutMs: options.lockTimeoutMs })
+  const profile = typeof options.profile === 'string' && options.profile !== '' ? options.profile : (process.env.DSH_PROFILE || undefined)
+
+  const ensureDir = () => { fs.mkdirSync(dir, { recursive: true }) }
+
+  const load = () => foldRecords(readJsonLines(file))
+
+  /** 追加一行；先修记录边界（末字节不是换行就先补换行），避免残尾吞掉新记录。 */
+  const appendEvent = (event) => {
+    ensureDir()
+    let size = 0
+    try { size = fs.statSync(file).size } catch (e) { size = 0 }
+    if (size > 0) {
+      let last = 0
+      const fd = fs.openSync(file, 'r')
+      try {
+        const buf = Buffer.alloc(1)
+        fs.readSync(fd, buf, 0, 1, size - 1)
+        last = buf[0]
+      } finally {
+        fs.closeSync(fd)
+      }
+      if (last !== 0x0a) fs.appendFileSync(file, '\n', 'utf8')
+    }
+    fs.appendFileSync(file, JSON.stringify(event) + '\n', 'utf8')
+  }
+
+  return {
+    root,
+    namespace,
+    dir,
+    file,
+
+    /**
+     * 登记一条关联。**必须在执行前调用**：写盘失败就抛错，让调用方放弃启动 DSH 执行
+     * （绝不出现"执行了却没绑定"）。
+     */
+    bind({ originThreadId, taskId, kind, target, delivered }) {
+      if (!isValidOrigin(originThreadId)) {
+        throw fail(ASSOC_REASONS.INVALID_ORIGIN, 'originThreadId must be a non-empty string of at most ' + MAX_ORIGIN_LENGTH + ' characters without control characters')
+      }
+      if (typeof taskId !== 'string' || taskId.trim() === '') throw fail(ASSOC_REASONS.UNKNOWN_TASK, 'taskId is required')
+      return lock.withLock(() => {
+        const existing = load().get(taskId)
+        if (existing !== undefined && existing.originThreadId !== originThreadId.trim()) {
+          throw fail(ASSOC_REASONS.ORIGIN_CONFLICT, 'task ' + taskId + ' is already bound to another origin', { taskId })
+        }
+        if (existing !== undefined) return existing
+        const at = Date.now()
+        appendEvent({
+          type: 'bind',
+          version: 1,
+          originThreadId: originThreadId.trim(),
+          taskId,
+          kind,
+          target,
+          profile,
+          status: 'accepted',
+          delivered: delivered === true ? true : undefined,
+          at,
+        })
+        return load().get(taskId)
+      })
+    },
+
+    /** 更新终态/交付信息。任务未登记 → unknown-task（不静默新建）。 */
+    update(taskId, patch = {}) {
+      if (typeof taskId !== 'string' || taskId.trim() === '') throw fail(ASSOC_REASONS.UNKNOWN_TASK, 'taskId is required')
+      return lock.withLock(() => {
+        const record = load().get(taskId)
+        if (record === undefined) throw fail(ASSOC_REASONS.UNKNOWN_TASK, 'task ' + taskId + ' has no association record', { taskId })
+        appendEvent({
+          type: 'update',
+          version: 1,
+          taskId,
+          status: typeof patch.status === 'string' ? patch.status : undefined,
+          delivered: patch.delivered === undefined ? undefined : patch.delivered === true,
+          result: typeof patch.result === 'string' ? patch.result : undefined,
+          error: typeof patch.error === 'string' ? patch.error : undefined,
+          reason: typeof patch.reason === 'string' ? patch.reason : undefined,
+          stopReason: typeof patch.stopReason === 'string' ? patch.stopReason : undefined,
+          requestId: typeof patch.requestId === 'string' ? patch.requestId : undefined,
+          dshTurn: typeof patch.dshTurn === 'number' ? patch.dshTurn : undefined,
+          at: Date.now(),
+        })
+        return load().get(taskId)
+      })
+    },
+
+    record(taskId) {
+      return load().get(taskId)
+    },
+
+    /** 精确取值：必须 origin 匹配；不匹配/缺失一律拒绝，**失败时不返回任何 record**（不泄漏别人的结果）。 */
+    fetch({ originThreadId, taskId }) {
+      if (typeof taskId !== 'string' || taskId.trim() === '') return { ok: false, reason: ASSOC_REASONS.UNKNOWN_TASK }
+      const record = load().get(taskId)
+      if (record === undefined) return { ok: false, reason: ASSOC_REASONS.UNKNOWN_TASK }
+      if (!isValidOrigin(originThreadId)) return { ok: false, reason: ASSOC_REASONS.MISSING_ORIGIN }
+      if (record.originThreadId !== originThreadId.trim()) return { ok: false, reason: ASSOC_REASONS.ORIGIN_MISMATCH }
+      return { ok: true, record }
+    },
+
+    /** 列出某个来源登记过的任务（找回丢失的 taskId 用），最新在前。 */
+    byOrigin(originThreadId, filter = {}) {
+      if (!isValidOrigin(originThreadId)) return { ok: false, reason: ASSOC_REASONS.INVALID_ORIGIN }
+      const origin = originThreadId.trim()
+      const all = Array.from(load().values()).filter((r) => r.originThreadId === origin)
+      all.sort((a, b) => b.createdAt - a.createdAt)
+      const limit = typeof filter.limit === 'number' && filter.limit > 0 ? filter.limit : undefined
+      return { ok: true, originThreadId: origin, tasks: limit === undefined ? all : all.slice(0, limit) }
+    },
+
+    count() {
+      return load().size
+    },
+  }
+}