fix: stabilize workbench entry, project identity and session subscriptions

This commit is contained in:
newbie 2026-11-12 18:52:15 +08:00
parent 257c47f78c
commit efc4a32c75
17 changed files with 683 additions and 334 deletions

View File

@ -1,6 +1,15 @@
# Changelog
> 版本号以 `package.json` 为准(当前 0.13.2)。更早的 0.6.x 条目沿用旧编号,保留作历史。
> 版本号以 `package.json` 为准(当前 0.14.0)。更早的 0.6.x 条目沿用旧编号,保留作历史。
## 0.14.0 — 入口生命周期、项目识别、项目隔离与会话订阅
- **入口注册按服务生命周期**:betterSidebar / 原生 sidebarRightTabs 通过 `ctx.inject` 监听,服务晚到或重挂时先清理旧注册再重建,两条路径互斥不重复;原生降级补齐 `guide` 胶囊,第一次进入不再找不到「朝堂」。
- **项目识别不再猜首项目**:当前工作区由 `sessions.list` 的 `mainView` 保留会话与 `workspaces.list` 的会话归属公开推导;`uiWorkspace.currentWorkspaceId` / `selection` 不再是依赖。没有明确项目时只显示项目清单和选择引导,bootstrap 也不再默认返回第一个项目。
- **项目隔离**:所有部门操作继续显式携带 projectId;切换项目会丢弃旧项目迟到响应,避免 A 的席位/任务显示到 B。
- **会话订阅**:follow 地址改为 `{kind:'session', sessionId}`,支持 `{kind:'subagent', parentSessionId, childSessionId, mode}`;同一会话只保留一条流,订阅失败会把对应绑定标成 unavailable(缺少 follow 能力的宿主除外)。
- **移除退役预设**:部门会话不再硬编码 `sansheng-liubu` 预设;显式预设先经宿主 `agentPresets.list()` 校验,不存在时返回明确错误。
- **清理旧安装自检**:`workbench-install.mjs` 只打印迁移说明,不再改 profile;`workbench-preflight.mjs` 改为严格只读、只检查主包入口与 16 条路由,不再要求独立 workbench 包。
## 0.13.2 — 修面板接管主区时与官方入口重复声明槽位

View File

@ -21,15 +21,16 @@
## 安装与启用
前提:DSH 桌面版已把本包登记为 bundle。工作台面板单独开关:
本包只发布一条:`dsh-sansheng-liubu-mode`。朝堂面板已并回主包,**不要**
再单独安装 `dsh-sansheng-liubu-workbench`;旧脚本 `workbench-install.mjs`
现在只打印迁移说明,不会再改任何 profile 文件。
```sh
node scripts/workbench-install.mjs on # 装上面板
node scripts/workbench-install.mjs off # 卸下面板
node scripts/workbench-install.mjs status # 看状态
node scripts/workbench-preflight.mjs # 严格只读自检:入口、bundle 语法、路由、账本可写
```
改完之后要**彻底退出并重启 DSH** 才生效。
安装、修复与迁移是独立授权操作;自检不会创建、覆盖或迁移用户文件。
改完安装后要**彻底退出并重启 DSH** 才生效。
## 验证
@ -48,6 +49,7 @@ node scripts/workbench-preflight.mjs # 装配与安装状态预检
根目录 `index.js` 现在只负责在应用根上启动工作台宿主。
升级注意:如果你的 DSH 配置文件 `cordis.patch.yml` 里还留着
以前写入的上朝预设段,请把它删掉再重启;工作台面板的安装方式
不变。本包的包名保持 `dsh-sansheng-liubu-mode` 不变,只是为了
让既有 bundle 登记继续有效,它不再提供任何模式。
以前写入的上朝预设段,请把它删掉再重启;如果 profile 里还登记了
`dsh-sansheng-liubu-workbench`,也一并移除(面板已并回本包)。本包的包名
保持 `dsh-sansheng-liubu-mode` 不变,只是为了既有 bundle 登记继续有效,
它不再提供任何模式。

View File

@ -70,8 +70,8 @@
| 现象 | 处理 |
| --- | --- |
| 中央区白屏或样式崩了 | 控制台执行 `localStorage['sansheng.workbench.main']='off'`,刷新。接管被整个跳过,原生聊天照旧 |
| 右栏不出现 | `node scripts/workbench-preflight.mjs` 看 7 项自检;再确认重启是**彻底退出**而不是关窗口 |
| 右栏不出现 | `node scripts/workbench-preflight.mjs` 看 5 项自检;再确认重启是**彻底退出**而不是关窗口 |
| 派工后一直「已备好」 | 宿主没接上会话层:重启获取一次;右栏会提示「已记入台账,但暂时没有真的发出」 |
| 完全不想用了 | `node scripts/workbench-install.mjs off` 再重启 |
| 完全不想用了 | 从 profile 移除 `dsh-sansheng-liubu-mode` 后重启(独立 workbench 包已退役) |
账本在 `%USERPROFILE%\.dsh\sansheng-liubu\workbench.json`。它是唯一事实来源,删掉等于清空工作台;Git 回退代码不会回退它。

View File

@ -90,22 +90,20 @@ node --test --test-isolation=none test/policy.test.js workbench/test/*.test.mjs
## 3. 复现步骤(真机部分)
1. 安装前端 bundle(已执行过一次,幂等):
1. 确认主包已安装(朝堂面板已并回 `dsh-sansheng-liubu-mode`,不再有独立 workbench 包):
```bash
node scripts/workbench-install.mjs on # 写进 profile 的 dependencies + dsh.profile.bundles + node_modules junction
node scripts/workbench-install.mjs status # 期望 installed=true, targetExists=true
node scripts/workbench-preflight.mjs # 期望 7/7 通过:链接、入口、bundle 语法、12 条路由、账本可写
node scripts/workbench-preflight.mjs # 期望 5/5 通过:入口、bundle 语法、16 条路由、账本可写
```
> `workbench-preflight.mjs` 是只读自检:不装、不改配置,只回答「重启后会不会白屏 / 路由起不起得来」。
> 它会真的创建 `%DSH_HOME%\sansheng-liubu` 目录(插件运行时本来也会建),除此之外不写任何东西。
> `workbench-preflight.mjs` 是严格只读自检:不装、不改配置、不创建文件,只回答「重启后会不会白屏 / 路由起不起得来」。
> 安装、修复与迁移是另外的显式操作;旧 `workbench-install.mjs` 现在只打印迁移说明。
2. **彻底退出 DSH 再启动**(托盘退出,不是关窗口);只对新会话生效。
3. 打开任意项目会话,右侧应出现「朝堂 / 任务 / 成果」。
4. 依次验:接通一个部门 → 派一条任务 → 完成 → 在成果区点「找主责部门修改」。
5. 白屏逃生:控制台 `localStorage['sansheng.workbench.main']='off'` 后刷新,接管会被跳过。
6. 完全回退:`node scripts/workbench-install.mjs off` 再重启。
6. 完全回退:从 profile 移除 `dsh-sansheng-liubu-mode` 后重启(旧独立 workbench 包已退役,不要安装)。
---

View File

@ -1,6 +1,6 @@
{
"name": "dsh-sansheng-liubu-mode",
"version": "0.13.3",
"version": "0.14.0",
"description": "三省六部工作台:十席独立会话、项目账本、派工与分层记忆",
"type": "module",
"main": "./index.js",
@ -35,7 +35,6 @@
},
"scripts": {
"test": "node --test --test-isolation=none workbench/test/*.test.mjs workbench/panel/test/client.test.mjs",
"workbench:install": "node scripts/workbench-install.mjs",
"workbench:preflight": "node scripts/workbench-preflight.mjs",
"preview:workbench": "node scripts/preview-workbench.mjs"
},

View File

@ -1,144 +1,17 @@
#!/usr/bin/env node
// 工作台前端(workbench/panel)的安装开关:只动 profile 的 package.json、
// bundles 列表,以及 node_modules 里的一个链接。它不碰 cordis.patch.yml,
// 也不改「上朝」预设——那是 scripts/mode.mjs 的事。
// 退役说明(0.13.0+):朝堂面板已并回主包 `dsh-sansheng-liubu-mode`。
// 本脚本不再安装、卸载或改写任何 profile 文件,只打印迁移说明。
//
// node scripts/workbench-install.mjs status # 现在装没装
// node scripts/workbench-install.mjs on # 装上(需要彻底重启 DSH 才生效)
// node scripts/workbench-install.mjs off # 卸掉
//
// 幂等:重复执行结果一致;不需要备份(版本历史由 Git 管)。
// 安装/修复/迁移是独立授权操作;自检请用 `node scripts/workbench-preflight.mjs`。
import { readFile, writeFile, mkdir, lstat, readlink, rm, symlink } from 'node:fs/promises'
import { existsSync } from 'node:fs'
import { homedir } from 'node:os'
import { dirname, join, resolve } from 'node:path'
const NAME = 'dsh-sansheng-liubu-workbench'
const REPO = resolve(import.meta.dirname, '..')
const TARGET = join(REPO, 'workbench', 'panel')
const profileDir = resolve(process.env.DSH_PROFILE_DIR ?? join(homedir(), '.dsh', 'profiles', 'desktop'))
const profilePath = join(profileDir, 'package.json')
const linkPath = join(profileDir, 'node_modules', NAME)
/** Windows 上 `link:` 依赖写成正斜杠;反斜杠在 profile 里会被当成转义。 */
const posix = (value) => value.replace(/\\/g, '/')
async function readProfile() {
return JSON.parse(await readFile(profilePath, 'utf8'))
}
async function writeProfile(profile) {
await writeFile(profilePath, `${JSON.stringify(profile, null, 2)}\n`, 'utf8')
}
async function linkState() {
try {
const stat = await lstat(linkPath)
if (!stat.isSymbolicLink()) return { linked: false, note: '不是链接(可能有同名真实目录)' }
const actual = await readlink(linkPath)
const resolved = resolve(profileDir, 'node_modules', actual)
const ok = resolved.toLowerCase() === resolve(TARGET).toLowerCase()
return { linked: ok, target: actual, note: ok ? undefined : `链接指向 ${actual}` }
} catch (error) {
if (error.code === 'ENOENT') return { linked: false, note: '链接不存在' }
throw error
}
}
async function status() {
const profile = await readProfile()
const link = await linkState()
const bundles = profile.dsh?.profile?.bundles ?? []
return {
profile: profilePath,
target: TARGET,
targetExists: existsSync(join(TARGET, 'lib', 'client.js')),
dependency: profile.dependencies?.[NAME] ?? null,
inBundles: bundles.includes(NAME),
link,
installed: profile.dependencies?.[NAME] === `link:${posix(TARGET)}` && bundles.includes(NAME) && link.linked,
}
}
async function ensureLink() {
await mkdir(dirname(linkPath), { recursive: true })
const state = await linkState()
if (state.linked) return { changed: false }
if (existsSync(linkPath) || state.note === '不是链接(可能有同名真实目录)') await rm(linkPath, { recursive: true, force: true })
// Windows 上用 junction:不需要管理员权限,跳转由文件系统处理。
await symlink(TARGET, linkPath, process.platform === 'win32' ? 'junction' : 'dir')
return { changed: true }
}
async function enable() {
if (!existsSync(join(TARGET, 'lib', 'client.js'))) {
throw new Error(`找不到 ${join(TARGET, 'lib', 'client.js')}:工作台前端还没构建出来,先别装。`)
}
const profile = await readProfile()
let changed = false
profile.dependencies ??= {}
const wanted = `link:${posix(TARGET)}`
if (profile.dependencies[NAME] !== wanted) {
profile.dependencies[NAME] = wanted
changed = true
}
profile.dsh ??= {}
profile.dsh.profile ??= {}
profile.dsh.profile.bundles ??= []
if (!profile.dsh.profile.bundles.includes(NAME)) {
profile.dsh.profile.bundles.push(NAME)
changed = true
}
if (changed) await writeProfile(profile)
const link = await ensureLink()
return {
...(await status()),
changed: changed || link.changed,
hint: changed || link.changed
? '已装上。彻底退出并重启 DSH 后生效(客户端 bundle 在启动时加载,热更新不覆盖)。'
: '本来就已经装好,未改动。',
}
}
async function disable() {
const profile = await readProfile()
let changed = false
if (profile.dependencies && NAME in profile.dependencies) {
delete profile.dependencies[NAME]
changed = true
}
const bundles = profile.dsh?.profile?.bundles
if (Array.isArray(bundles) && bundles.includes(NAME)) {
profile.dsh.profile.bundles = bundles.filter((name) => name !== NAME)
changed = true
}
if (changed) await writeProfile(profile)
let unlinked = false
try {
await rm(linkPath, { recursive: true, force: true })
unlinked = true
} catch {
/* 链接本来就不在 */
}
return {
...(await status()),
changed: changed || unlinked,
hint: changed || unlinked ? '已卸掉。彻底重启 DSH 后生效。' : '本来就没装,未改动。',
}
}
const action = (process.argv[2] ?? 'status').toLowerCase()
const handlers = { status, on: enable, off: disable }
const handler = handlers[action]
if (!handler) {
console.error(`未知动作:${action}(可用:status / on / off)`)
process.exit(2)
}
try {
console.log(JSON.stringify(await handler(), null, 2))
} catch (error) {
console.error(String(error?.message ?? error))
process.exit(1)
}
console.error([
'dsh-sansheng-liubu-workbench 已退役:面板已并回主包 dsh-sansheng-liubu-mode。',
'不要再安装或启用独立的 workbench 包,也不需要再运行本脚本的 on/off。',
'迁移:',
' 1. 从 profile 的 dependencies / dsh.profile.bundles 中移除 dsh-sansheng-liubu-workbench(若存在);',
' 2. 安装或更新 dsh-sansheng-liubu-mode;',
' 3. 彻底退出并重启 DSH;',
' 4. 运行 node scripts/workbench-preflight.mjs 做严格只读自检。',
'本脚本不会改动任何文件。',
].join('\n'))
process.exitCode = 2

View File

@ -1,11 +1,8 @@
// 重启前自检:只读,不改任何东西。
// 重启前自检:严格只读,不创建、覆盖或迁移任何用户文件。
//
// 目的:把「重启 DSH 之后才发现客户端 bundle 根本没加载」这类问题提前挡掉。
// 检查四件事——
// 1. profile 里到底有没有把本插件链进去(dependencies + dsh.profile.bundles)
// 2. 链接指向的目录里,exports 声明的那个文件在不在
// 3. 那个文件是不是一段能解析的 JS(语法坏了会让整页白屏,且报错很难看懂)
// 4. Host 侧装配能不能在内存账本上跑起来(16 条路由 + bootstrap 可用)
// 0.13.0 起朝堂面板已并回主包 `dsh-sansheng-liubu-mode`,不再有独立的
// `dsh-sansheng-liubu-workbench` 安装包。自检只回答“当前这份包能不能在
// 宿主上正常加载”,安装/修复/迁移是另外的显式操作,不混在这里。
//
// 用法:node scripts/workbench-preflight.mjs
// 退出码:0 全通;1 有失败项(打印哪一项失败、为什么)。
@ -18,7 +15,8 @@ import vm from 'node:vm'
import { createWorkbenchHost } from '../workbench/host/index.mjs'
import { WorkbenchStore } from '../workbench/core/store.mjs'
const PLUGIN_ID = 'dsh-sansheng-liubu-workbench'
const PACKAGE_NAME = 'dsh-sansheng-liubu-mode'
const PACKAGE_ROOT = path.resolve(import.meta.dirname, '..')
const results = []
function check(name, run) {
@ -35,50 +33,32 @@ function dshHome(env = process.env) {
return value === '' ? path.join(os.homedir(), '.dsh') : value
}
const profileDir = path.join(dshHome(), 'profiles', 'desktop')
const profilePackage = path.join(profileDir, 'package.json')
let profile = null
check('读取 profile/package.json', () => {
profile = JSON.parse(fs.readFileSync(profilePackage, 'utf8'))
return profilePackage
})
check('profile 的 dependencies 里链了本插件', () => {
const spec = profile?.dependencies?.[PLUGIN_ID]
if (typeof spec !== 'string' || spec === '') throw new Error(`dependencies 里没有 ${PLUGIN_ID}`)
return spec
})
check('profile 的 bundles 里登记了本插件', () => {
const bundles = profile?.dsh?.profile?.bundles
if (!Array.isArray(bundles) || !bundles.includes(PLUGIN_ID)) {
throw new Error(`dsh.profile.bundles 里没有 ${PLUGIN_ID}(现有:${Array.isArray(bundles) ? bundles.join(', ') : '无'})`)
let packageJson = null
check('读取本包 package.json', () => {
const file = path.join(PACKAGE_ROOT, 'package.json')
packageJson = JSON.parse(fs.readFileSync(file, 'utf8'))
if (packageJson.name !== PACKAGE_NAME) {
throw new Error(`包名是 ${packageJson.name},预期 ${PACKAGE_NAME}`)
}
return `${bundles.length} 个 bundle`
return `${packageJson.name} ${packageJson.version}`
})
const linkedDir = path.join(profileDir, 'node_modules', PLUGIN_ID)
let entryFile = null
check('链接目录与入口文件存在', () => {
const stat = fs.statSync(linkedDir)
if (!stat.isDirectory()) throw new Error(`${linkedDir} 不是目录`)
const pkg = JSON.parse(fs.readFileSync(path.join(linkedDir, 'package.json'), 'utf8'))
const exported = pkg?.exports?.['./client']
const rel = typeof exported === 'string' ? exported : exported?.import ?? exported?.default
check('面板客户端入口存在且属于主包', () => {
const exported = packageJson?.exports?.['./client']
const rel = typeof exported === 'string' ? exported : exported?.default
if (typeof rel !== 'string') throw new Error('package.json 没有 exports["./client"]')
entryFile = path.join(linkedDir, rel)
entryFile = path.join(PACKAGE_ROOT, rel)
const size = fs.statSync(entryFile).size
if (size < 1024) throw new Error(`入口文件过小(${size} 字节),可能是空壳`)
return `${path.basename(entryFile)} · ${size} 字节`
return `${path.relative(PACKAGE_ROOT, entryFile)} · ${size} 字节`
})
check('客户端 bundle 语法可解析(语法错会让整页白屏)', () => {
if (entryFile === null) throw new Error('上一个检查没通过,跳过')
const text = fs.readFileSync(entryFile, 'utf8')
if (!text.includes('__ModuleLoader__')) throw new Error('入口不像 DSH 客户端 bundle(缺少 __ModuleLoader__)')
if (!text.includes(PLUGIN_ID)) throw new Error(`入口里没有插件 id ${PLUGIN_ID}`)
if (!text.includes(PACKAGE_NAME)) throw new Error(`入口里没有主包 id ${PACKAGE_NAME}`)
// 只解析不执行:能抓住未闭合括号、非法 token 这类致命错误。
new vm.Script(text, { filename: entryFile })
return `${Math.round(text.length / 1024)} KB`
@ -109,13 +89,18 @@ check('Host 侧装配:内存账本上能起 16 条路由', () => {
}
})
check('账本落点可写(重启后第一次写账不会失败)', () => {
check('账本落点可写(只做 access 检查,不创建文件)', () => {
const dir = path.join(dshHome(), 'sansheng-liubu')
fs.mkdirSync(dir, { recursive: true })
const probe = path.join(dir, '.preflight')
fs.writeFileSync(probe, String(Date.now()))
fs.rmSync(probe, { force: true })
return dir
// 从目标目录向上找第一个真实存在的父目录;只检查写权限,不创建目录或文件。
let probe = dir
for (;;) {
if (fs.existsSync(probe)) break
const parent = path.dirname(probe)
if (parent === probe) throw new Error(`找不到可检查的父目录:${dir}`)
probe = parent
}
fs.accessSync(probe, fs.constants.W_OK)
return `${dir}(自上而下检查到 ${probe})`
})
let failed = 0

View File

@ -58,7 +58,7 @@ export {
* @param {() => number} [options.clock] 注入时钟。
* @param {() => string} [options.random] 注入随机源(测试里固定 ID 用)。
* @param {boolean} [options.load=true] 是否从磁盘加载既有账本。
* @param {string} [options.presetId] 部门会话使用的 agentPreset,默认「上朝」。
* @param {string} [options.presetId] 部门会话显式使用的 agentPreset;缺省不指定,走宿主默认创建流程。
* @param {boolean} [options.startReconciler=true] 是否启动周期对账。
* @param {number} [options.longPollMs] 事件长轮询上限(毫秒)。
* @param {number} [options.pollIntervalMs] 长轮询内部检查间隔(毫秒)。

View File

@ -1346,7 +1346,7 @@ export function createWorkbenchService(options = {}) {
// ---------- 投影 ----------
/**
* bootstrap:一次拿全。projectId 为空时取列表第一个;
* bootstrap:一次拿全。projectId 为空时只返回项目清单,不默认选中第一个;
* 传入的项目不可见按 NOT_FOUND 报错,不泄露其他项目是否存在。
*/
function bootstrap(projectId) {
@ -1354,8 +1354,6 @@ export function createWorkbenchService(options = {}) {
let selectedId = null
if (projectId !== undefined && projectId !== null && projectId !== '') {
selectedId = projectIdOf({ projectId }).id
} else if (projects.length > 0) {
selectedId = projects[0].id
}
if (selectedId === null) {
return {

View File

@ -182,16 +182,24 @@ export function createSessionAdapter(options = {}) {
/**
* 订阅会话事件。alreadyAttached 时不重复起流:同一个会话只留一条 follow,
* 避免双窗口/重启后重建出两条流导致事件重复。
*
* @param {string|object} target 普通会话 id,或宿主 `SessionAddress` 对象
* (普通会话 `{kind:'session', sessionId}`;直接子代理会话
* `{kind:'subagent', parentSessionId, childSessionId, mode}`)。
* @param {object} [options]
* @param {(frame: object) => void} [options.onFrame]
* @param {(failure: {sessionId: string, code: string, message: string}) => void} [options.onError]
*/
function follow(sessionId, { onFrame } = {}) {
function follow(target, { onFrame, onError } = {}) {
ensureAlive()
const address = normalizeAddress(target)
const sessionId = address.kind === 'subagent' ? address.childSessionId : address.sessionId
if (followers.has(sessionId)) return followers.get(sessionId).handle
if (typeof controller.follow !== 'function') throw new SessionAdapterError('NO_FOLLOW', 'controller 无 follow')
const abort = new AbortController()
const handle = { sessionId, stop: () => abort.abort() }
const handle = { sessionId, address, stop: () => abort.abort() }
const done = (async () => {
try {
const address = { sessionId }
const stream = controller.follow({ address }, abort.signal)
for await (const frame of stream) {
if (disposed || abort.signal.aborted) break
@ -203,8 +211,23 @@ export function createSessionAdapter(options = {}) {
log(`[sansheng-liubu] 处理会话帧失败:${messageOf(error)}`)
}
}
if (!abort.signal.aborted && !disposed) log(`[sansheng-liubu] 会话订阅正常结束:${sessionId}`)
} catch (error) {
if (!abort.signal.aborted) log(`[sansheng-liubu] 会话流中断:${messageOf(error)}`)
if (abort.signal.aborted) {
log(`[sansheng-liubu] 会话订阅已取消:${sessionId}`)
} else {
const failure = {
sessionId,
code: error?.code ?? (error?.name === 'AbortError' ? 'ABORTED' : 'FOLLOW_FAILED'),
message: messageOf(error),
}
log(`[sansheng-liubu] 会话流中断(${failure.code}):${failure.message}`)
try {
if (typeof onError === 'function') onError(failure)
} catch (handlerError) {
log(`[sansheng-liubu] 订阅失败回调异常:${messageOf(handlerError)}`)
}
}
} finally {
followers.delete(sessionId)
}
@ -245,6 +268,26 @@ export function createSessionAdapter(options = {}) {
})
}
function normalizeAddress(target) {
if (typeof target === 'string' && target.trim() !== '') return { kind: 'session', sessionId: target }
if (target !== null && typeof target === 'object') {
if (target.kind === 'subagent'
&& typeof target.parentSessionId === 'string'
&& typeof target.childSessionId === 'string') {
return {
kind: 'subagent',
parentSessionId: target.parentSessionId,
childSessionId: target.childSessionId,
mode: ['one-shot', 'continuable', 'unknown'].includes(target.mode) ? target.mode : 'unknown',
}
}
if (typeof target.sessionId === 'string' && target.sessionId !== '') {
return { kind: 'session', sessionId: target.sessionId }
}
}
throw new SessionAdapterError('BAD_ADDRESS', '会话订阅需要普通 sessionId 或宿主 SessionAddress')
}
function messageOf(error) {
return error instanceof Error ? error.message : String(error)
}

View File

@ -25,7 +25,7 @@ export const WORKBENCH_HOST_VERSION = 1
* @param {object} [options.store] 已有 store(测试注入);缺省按环境建一个。
* @param {object} [options.service] 已有 service;缺省按 store 新建。给了 service 就必须同时给 store,
* 否则两边的账不是同一本。
* @param {string} [options.presetId] 部门会话使用的 agentPreset,首版沿用「上朝」。
* @param {string} [options.presetId] 部门会话显式使用的 agentPreset;缺省不指定,走宿主默认创建流程。
* @param {boolean} [options.startReconciler] 是否启动周期对账,默认 true。
*/
export function createWorkbenchHost(ctx, options = {}) {
@ -69,9 +69,82 @@ export function createWorkbenchHost(ctx, options = {}) {
reconciler = createReconciler({ store, service, sessions, log })
hasSessions = true
if (started && options.startReconciler !== false) reconciler.start()
followBoundSessions()
return true
}
/**
* 订阅一个部门会话。subscribe 失败与正常结束分开处理:
* - 正常结束/主动取消只记日志;
* - 订阅失败把该绑定标成 unavailable,界面会显示“绑定失效,需重新接通”,
* 而不是让用户对着一个永远不更新的会话猜。
*/
function followSession(sessionId) {
if (sessions === null || typeof sessionId !== 'string' || sessionId === '') return
try {
sessions.follow(sessionId, {
onFrame: (frame) => {
if (reconciler !== null) {
void Promise.resolve(reconciler.onSessionFrame({ sessionId })).catch((error) => {
log(`[sansheng-liubo] 帧事件对账失败:${error?.message ?? error}`)
})
}
void frame
},
onError: (failure) => {
log(`[sansheng-liubo] 会话 ${failure.sessionId} 订阅失败(${failure.code}):${failure.message}`)
markSessionUnavailable(failure.sessionId, failure.message)
},
})
} catch (error) {
const code = error?.code ?? 'UNKNOWN'
log(`[sansheng-liubo] 无法订阅会话 ${sessionId}(${code}):${error?.message ?? error}`)
// 宿主没有 follow 能力是“功能缺席”,不是绑定失效:不要因此标坏部门。
if (code !== 'NO_FOLLOW') markSessionUnavailable(sessionId, error?.message ?? String(error))
}
}
/** 找到持有该会话的项目/席位,并把绑定状态标成 unavailable。 */
function markSessionUnavailable(sessionId, reason) {
if (typeof sessionId !== 'string' || sessionId === '') return
for (const project of store.listProjects()) {
let seats = []
try {
seats = service.listSeats(project.id)
} catch {
continue
}
for (const seat of seats) {
const binding = store.getBinding(project.id, seat.roleId)
if (binding?.currentSessionId !== sessionId) continue
try {
service.setDepartmentStatus({ projectId: project.id, roleId: seat.roleId, status: 'unavailable' })
} catch (error) {
log(`[sansheng-liubo] 标记 ${seat.roleId} 订阅失败状态被拒:${error?.message ?? error}`)
}
log(`[sansheng-liubo] 部门 ${seat.roleId} 的会话订阅失败:${reason ?? 'unknown'}`)
return
}
}
}
/** 会话层晚挂或重挂后,把账本里已有的部门绑定重新接上事件流。 */
function followBoundSessions() {
if (sessions === null) return 0
let count = 0
for (const project of store.listProjects()) {
for (const seat of service.listSeats(project.id)) {
const binding = store.getBinding(project.id, seat.roleId)
if (binding?.currentSessionId) {
followSession(binding.currentSessionId)
count += 1
}
}
}
if (count > 0) log(`[sansheng-liubo] 已恢复 ${count} 个部门会话订阅`)
return count
}
/** 宿主稍后才提供 sessionController 时补挂(不重启也能用)。返回是否挂上。 */
function attachSessions(controller) {
const mounted = mountSessions(controller ?? null)
@ -81,7 +154,35 @@ export function createWorkbenchHost(ctx, options = {}) {
mountSessions(ctx?.sessionController ?? ctx?.remote?.session ?? null)
const presetId = typeof options.presetId === 'string' && options.presetId !== '' ? options.presetId : 'sansheng-liubu'
const presetId = typeof options.presetId === 'string' && options.presetId !== '' ? options.presetId : null
/**
* 显式预设先用宿主公开的 preset 名册校验;名册服务缺席时不假装能验,
* 交给 `sessionController.create` 返回它自己的 agent-preset/not-found。
*/
async function assertAgentPreset(agentPreset) {
if (typeof agentPreset !== 'string' || agentPreset.trim() === '') return
let presets = null
try {
presets = typeof ctx?.get === 'function' ? ctx.get('agentPresets') : ctx?.agentPresets
} catch {
presets = null
}
if (presets === null || presets === undefined || typeof presets.list !== 'function') return
let roster = null
try {
roster = await presets.list()
} catch (error) {
log(`[sansheng-liubo] 无法读取宿主预设名册:${error?.message ?? error}`)
return
}
if (!Array.isArray(roster)) return
if (!roster.some((row) => row?.id === agentPreset)) {
const error = new Error(`指定的预设“${agentPreset}”不存在或未启用`)
error.code = 'INVALID_INPUT'
throw error
}
}
/**
* 接通某个部门的会话:已有绑定就直接用,没有就按 workspace 建一个并登记。
@ -99,12 +200,17 @@ export function createWorkbenchHost(ctx, options = {}) {
const existing = binding?.currentSessionId ?? null
if (existing !== null) {
const known = await sessions.inspectSession(existing)
if (known !== null) return { sessionId: existing, created: false, seat: seatOf(projectId, roleId) }
if (known !== null) {
followSession(existing)
return { sessionId: existing, created: false, seat: seatOf(projectId, roleId) }
}
}
const requestedPreset = input.agentPreset ?? presetId
await assertAgentPreset(requestedPreset)
const target = await sessions.ensureSession({
workspaceId: project?.hostWorkspaceId,
sessionId: input.sessionId ?? null,
agentPreset: input.agentPreset ?? presetId,
agentPreset: requestedPreset,
})
// 账上登记:同一会话被别的部门占用时 store 会拒绝,正是我们要的“会话独占”。
const saved = service.bindDepartmentSession({
@ -113,6 +219,7 @@ export function createWorkbenchHost(ctx, options = {}) {
sessionId: target.sessionId,
allowReplace: existing !== null,
})
followSession(target.sessionId)
return { sessionId: target.sessionId, created: target.created === true, seat: saved.seat }
}

View File

@ -175,16 +175,12 @@ window.__ModuleLoader__.load({
function pickProjectId(data, hostWorkspaceId) {
var projects = data && Array.isArray(data.projects) ? data.projects : [];
if (hostWorkspaceId) {
for (var i = 0; i < projects.length; i++) {
var project = projects[i];
if (project && project.hostWorkspaceId === hostWorkspaceId && project.id) return project.id;
}
return null;
}
if (data && typeof data.projectId === "string" && data.projectId) return data.projectId;
for (var j = 0; j < projects.length; j++) {
if (projects[j] && projects[j].id) return projects[j].id;
// 必须显式给出 hostWorkspaceId 才允许匹配;绝不在缺失时退回 bootstrap
// 默认项目或列表第一项——那会把 A 项目的席位/任务显示到 B 工作区。
if (typeof hostWorkspaceId !== "string" || hostWorkspaceId === "") return null;
for (var i = 0; i < projects.length; i++) {
var project = projects[i];
if (project && project.hostWorkspaceId === hostWorkspaceId && project.id) return project.id;
}
return null;
}
@ -433,75 +429,102 @@ window.__ModuleLoader__.load({
}
}
function betterSidebarOf(ctx) {
var candidates = [readService(ctx, "betterSidebar")];
for (var i = 0; i < candidates.length; i++) {
var candidate = candidates[i];
if (candidate && typeof candidate.registerTab === "function") return candidate;
}
return null;
}
function sidebarRightTabsOf(ctx) {
var service = readService(ctx, "sidebarRightTabs");
if (service && typeof service.register === "function") return service;
return null;
}
function effectOf(ctx, factory, label) {
if (ctx && typeof ctx.effect === "function") return ctx.effect(factory, label);
function workspacesSnapshotOf(ctx) {
var service = readService(ctx, "workspaces");
var source = service && service.list ? service.list : service;
if (!source || typeof source.getSnapshot !== "function") return null;
try {
return factory();
return source.getSnapshot();
} catch (error) {
console.warn("[sansheng-workbench] " + label + " 注册失败", error);
return undefined;
return null;
}
}
/**
* 当前会话的公开来源:`sessions.list` 里保留在 `mainView` 引用源上的
* 那一条。当前 DSH 不提供 `SessionListState.current`,也不提供
* `uiWorkspace.currentWorkspaceId`/`selection`;这是宿主公开的等价事实。
*/
function currentSessionIdOf(ctx) {
var sessions = readService(ctx, "sessions");
var source = sessions && sessions.list ? sessions.list : sessions;
if (!source || typeof source.getSnapshot !== "function") return null;
try {
var snapshot = source.getSnapshot();
var byId = snapshot && snapshot.byId ? snapshot.byId : {};
var ids = Object.keys(byId);
for (var i = 0; i < ids.length; i++) {
var row = byId[ids[i]];
var retained = row && row.retainedBy ? row.retainedBy.mainView : 0;
if (typeof retained === "number" && retained > 0) return ids[i];
}
} catch (error) {
// 服务形状不认识时按“没有明确选择”处理。
}
return null;
}
/**
* 由明确的会话-工作区关系取当前 workspaceId;空工作区的“新会话”
* 在宿主里同样是一个选中的空白会话,因此这里不会回退到首个项目。
*/
function workspaceIdOf(ctx) {
var workspace = ctx && ctx.uiWorkspace;
if (!workspace) return null;
var direct = workspace.currentWorkspaceId || workspace.workspaceId;
if (direct) return String(direct);
try {
var selection = workspace.selection && typeof workspace.selection.getSnapshot === "function"
? workspace.selection.getSnapshot()
: null;
if (selection && selection.workspaceId) return String(selection.workspaceId);
} catch (error) {
// 忽略:拿不到工作区就退回 bootstrap 自带 projectId。
var snapshot = workspacesSnapshotOf(ctx);
if (!snapshot || !Array.isArray(snapshot.items)) return null;
var sessionId = currentSessionIdOf(ctx);
if (typeof sessionId === "string" && sessionId !== "") {
for (var i = 0; i < snapshot.items.length; i++) {
var item = snapshot.items[i];
if (!item || !Array.isArray(item.sessionIds)) continue;
if (item.sessionIds.indexOf(sessionId) !== -1 && item.workspaceId) return String(item.workspaceId);
}
}
// 可选的项目树状态服务(workspace-groups 等):只有它明确给出选择时才采用。
var selection = readService(ctx, "workspaceGroupsSelection") || readService(ctx, "workspaceGroups");
if (selection && typeof selection.selectedWorkspaceId === "string" && selection.selectedWorkspaceId) {
return selection.selectedWorkspaceId;
}
return null;
}
function workspaceItemOf(ctx, workspaceId) {
if (typeof workspaceId !== "string" || workspaceId === "") return null;
var snapshot = workspacesSnapshotOf(ctx);
if (!snapshot || !Array.isArray(snapshot.items)) return null;
for (var i = 0; i < snapshot.items.length; i++) {
var item = snapshot.items[i];
if (item && String(item.workspaceId) === workspaceId) return item;
}
return null;
}
function displayNameOf(ctx, workspaceId) {
var workspace = ctx && ctx.uiWorkspace;
var name = workspace && (workspace.currentWorkspaceName || workspace.workspaceName || workspace.displayName);
var workspace = workspaceItemOf(ctx, workspaceId);
var name = workspace && workspace.title;
if (typeof name === "string" && name) return name;
return workspaceId ? "工作区 " + workspaceId : "";
}
function canonicalRootOf(ctx) {
var workspace = ctx && ctx.uiWorkspace;
var root = workspace && (
workspace.currentWorkspaceRoot ||
workspace.workspaceRoot ||
(workspace.currentWorkspace && workspace.currentWorkspace.root)
);
function canonicalRootOf(ctx, workspaceId) {
var workspace = workspaceItemOf(ctx, workspaceId);
var root = workspace && workspace.path;
return typeof root === "string" && root ? root : null;
}
async function resolveWorkbenchProject(ctx) {
var hostWorkspaceId = workspaceIdOf(ctx);
var value = await apiGet("bootstrap");
var targetId = pickProjectId(value, hostWorkspaceId);
// 没有明确的项目选择:只返回项目清单供界面提示,绝不拿 bootstrap
// 默认的第一个项目冒充当前项目。
if (!hostWorkspaceId) return { projectId: null, value: value };
if (hostWorkspaceId && !targetId) {
var targetId = pickProjectId(value, hostWorkspaceId);
if (!targetId) {
var body = {
hostWorkspaceId: hostWorkspaceId,
displayNameCache: displayNameOf(ctx, hostWorkspaceId),
};
var root = canonicalRootOf(ctx);
var root = canonicalRootOf(ctx, hostWorkspaceId);
if (root) body.canonicalRoot = root;
var created = null;
@ -518,15 +541,15 @@ window.__ModuleLoader__.load({
targetId = (created.project && created.project.id) || created.id || targetId;
}
if (!targetId) {
// 登记失败后重新读一次清单再精确匹配;仍无匹配就明确返回“未选择”。
value = await apiGet("bootstrap");
targetId = pickProjectId(value, hostWorkspaceId) || value.projectId || null;
targetId = pickProjectId(value, hostWorkspaceId);
}
}
if (targetId && value.projectId !== targetId) {
if (!targetId) return { projectId: null, value: value };
if (value.projectId !== targetId) {
value = await apiGet("bootstrap", { projectId: targetId });
}
if (!targetId) targetId = value.projectId || null;
return { projectId: targetId, value: value };
}
@ -1145,6 +1168,19 @@ window.__ModuleLoader__.load({
projectIdRef.current = result.projectId;
seqRef.current = Number(result.value && result.value.eventSeq) || 0;
setProjectId(result.projectId);
if (!result.projectId) {
// 没有明确项目时只保留项目清单;bootstrap 的默认项目数据不能
// 被渲染成“当前项目”,否则会误显示/误操作首项目。
setData(assign({}, result.value, {
projectId: null,
project: null,
seats: [],
tasks: [],
artifacts: [],
results: [],
}));
return;
}
setData(result.value);
}
@ -1192,14 +1228,17 @@ window.__ModuleLoader__.load({
function check() {
var next = workspaceIdOf(ctx);
if (!next || next === hostRef.current) return;
if (next === hostRef.current) return;
hostRef.current = next;
var token = ++pendingToken;
var loadToken = ++loadTokenRef.current;
setData(null);
setProjectId(null);
setSelectedArtifactId(null);
setNotice(null);
setError(null);
// No explicit project still re-reads the project list so the UI can
// show “select a project”; it never falls back to the first project.
resolveWorkbenchProject(ctx).then(function (result) {
if (cancelled || token !== pendingToken) return;
applyBootstrap(result, loadToken);
@ -1209,16 +1248,25 @@ window.__ModuleLoader__.load({
});
}
var selection = workspace.selection;
var sessionsService = readService(ctx, "sessions");
var workspacesService = readService(ctx, "workspaces");
if (sessionsService && sessionsService.list && typeof sessionsService.list.subscribe === "function") {
disposers.push(sessionsService.list.subscribe(check));
}
if (workspacesService && workspacesService.list && typeof workspacesService.list.subscribe === "function") {
disposers.push(workspacesService.list.subscribe(check));
}
// 兼容旧宿主:仍暴露 uiWorkspace 订阅时一并监听。
var selection = workspace && workspace.selection;
if (selection && typeof selection.subscribe === "function") {
var off = selection.subscribe(check);
if (typeof off === "function") disposers.push(off);
}
if (typeof workspace.subscribe === "function") {
if (workspace && typeof workspace.subscribe === "function") {
var offWorkspace = workspace.subscribe(check);
if (typeof offWorkspace === "function") disposers.push(offWorkspace);
}
if (typeof workspace.on === "function") {
if (workspace && typeof workspace.on === "function") {
var offEvent = workspace.on("change", check);
if (typeof offEvent === "function") disposers.push(offEvent);
}
@ -2012,7 +2060,15 @@ window.__ModuleLoader__.load({
}
var content;
if (view === "tasks") content = renderTasks();
if (!projectId && data !== null) {
content = h("div", { className: "wb-empty", role: "status", key: "no-project" }, [
h("div", { key: "title" }, "尚未选择工作区项目"),
h("div", { key: "detail", style: { marginTop: "6px", color: "var(--wb-ink-3)" } },
"请在左侧工作区项目树中选择一个项目(空工作区也可以);未选择项目时不会读取或修改任何项目。"),
]);
} else if (!projectId) {
content = renderCourt();
} else if (view === "tasks") content = renderTasks();
else if (view === "artifacts") content = renderArtifacts();
else content = renderCourt();
@ -2156,41 +2212,166 @@ window.__ModuleLoader__.load({
// 注册
// ---------------------------------------------------------------------
function entryDiagnostic(level, message) {
try {
if (level === "error") console.error("[sansheng-workbench][entry] " + message);
else if (level === "info") console.info("[sansheng-workbench][entry] " + message);
else console.warn("[sansheng-workbench][entry] " + message);
} catch (ignored) {
// 日志失败不能影响入口。
}
}
/** 把一次注册托管给 ctx.effect;没有 effect 的宿主/测试直接返回 disposer。 */
function ownRegistration(ctx, factory, label) {
if (ctx && typeof ctx.effect === "function") {
var dispose = ctx.effect(factory, label);
return typeof dispose === "function" ? dispose : function () {};
}
try {
var value = factory();
return typeof value === "function" ? value : function () {};
} catch (error) {
entryDiagnostic("error", label + " 注册失败:" + (error && error.message ? error.message : error));
return function () {};
}
}
function registerBetterEntry(ctx, better) {
return ownRegistration(ctx, function () {
return better.registerTab({
id: TAB_ID,
title: "朝堂",
description: "三省六部 · 十席部门树",
order: 5,
single: true,
component: function (props) {
return h(WorkbenchPanel, { ctx: ctx, scope: props && props.scope });
},
});
}, "三省六部工作台:better-sidebar 页签");
}
function registerNativeEntry(ctx, tabs) {
return ownRegistration(ctx, function () {
return tabs.register({
id: TAB_ID,
kind: TAB_KIND,
priority: "builtin",
title: function () {
return "朝堂";
},
// 原生右栏的 guide 是首次进入的唯一入口:没有它时页签类型虽注册,
// 用户也找不到可点的“朝堂”胶囊。guide 与 title 保持同一文案。
guide: [{
id: TAB_ID,
order: 5,
title: function () {
return "朝堂";
},
description: function () {
return "三省六部 · 十席部门树";
},
}],
});
}, "三省六部工作台:原生右侧栏页签");
}
/**
* 入口注册控制器:betterSidebar 与原生 sidebarRightTabs 都按服务生命周期
* 监听。任一时刻只保留一个活动入口;服务消失后自动清理,服务晚到/重挂
* 时重新注册,绝不重复叠加。
*/
function createEntryController(ctx) {
var better = null;
var nativeTabs = null;
var active = null;
function disposeActive() {
if (active === null) return;
var dispose = active.dispose;
active = null;
try {
if (typeof dispose === "function") dispose();
} catch (error) {
entryDiagnostic("error", "清理旧入口失败:" + (error && error.message ? error.message : error));
}
}
function reconcile() {
var wanted = better !== null
? { kind: "better", service: better }
: nativeTabs !== null
? { kind: "native", service: nativeTabs }
: null;
if (wanted === null) {
disposeActive();
entryDiagnostic("warn", "betterSidebar / sidebarRightTabs 均未就绪,等待服务");
return;
}
if (active !== null && active.kind === wanted.kind && active.service === wanted.service) return;
disposeActive();
try {
var dispose = wanted.kind === "better"
? registerBetterEntry(ctx, wanted.service)
: registerNativeEntry(ctx, wanted.service);
active = { kind: wanted.kind, service: wanted.service, dispose: typeof dispose === "function" ? dispose : function () {} };
entryDiagnostic("info", "已注册朝堂入口(" + (wanted.kind === "better" ? "betterSidebar" : "原生 sidebarRightTabs") + ")");
} catch (error) {
active = null;
entryDiagnostic("error", "朝堂入口注册失败:" + (error && error.message ? error.message : error));
}
}
function setBetter(service) {
better = service !== null && service !== undefined && typeof service.registerTab === "function" ? service : null;
reconcile();
}
function setNativeTabs(service) {
nativeTabs = service !== null && service !== undefined && typeof service.register === "function" ? service : null;
reconcile();
}
return {
setBetter: setBetter,
setNativeTabs: setNativeTabs,
reconcile: reconcile,
dispose: disposeActive,
get activeKind() {
return active === null ? null : active.kind;
},
};
}
function watchClientService(ctx, name, setter) {
if (ctx && typeof ctx.inject === "function") {
try {
ctx.inject([name], function (scope) {
setter(readService(scope, name));
return function () {
setter(null);
};
});
return;
} catch (error) {
entryDiagnostic("error", "监听服务 " + name + " 失败:" + (error && error.message ? error.message : error));
}
}
// 旧宿主或测试替身没有 ctx.inject:退化为一次同步探测。
setter(readService(ctx, name));
}
function apply(ctx) {
if (!ctx) throw new Error("三省六部工作台需要宿主上下文");
// 1) 右侧栏页签「朝堂」:优先 better-sidebar 的 registerTab。
var better = betterSidebarOf(ctx);
if (better) {
effectOf(ctx, function () {
return better.registerTab({
id: TAB_ID,
title: "朝堂",
description: "三省六部 · 十席部门树",
order: 5,
single: true,
component: function (props) {
return h(WorkbenchPanel, { ctx: ctx, scope: props && props.scope });
},
});
}, "三省六部工作台:better-sidebar 页签");
} else {
var tabs = sidebarRightTabsOf(ctx);
if (tabs) {
effectOf(ctx, function () {
return tabs.register({
id: TAB_ID,
kind: TAB_KIND,
priority: "builtin",
title: function () {
return "朝堂";
},
});
}, "三省六部工作台:右侧栏页签");
} else {
console.warn("[sansheng-workbench] 宿主没有 betterSidebar / sidebarRightTabs,页签可能无法停靠;pane 槽仍会注册。");
}
}
// 1) 右侧栏页签「朝堂」:服务生命周期驱动注册。
// 优先 better-sidebar;没有时用原生 sidebarRightTabs(含 guide 入口)。
// 两条路径由同一个控制器互斥,服务重挂不会重复注册。
var entry = createEntryController(ctx);
watchClientService(ctx, "betterSidebar", entry.setBetter);
watchClientService(ctx, "sidebarRightTabs", entry.setNativeTabs);
entry.reconcile();
// 2) 页签内容 + 标题:即使上面没有服务也注册,宿主若按槽渲染仍可用。
if (ctx.slots && typeof ctx.slots.inject === "function") {
@ -2231,7 +2412,7 @@ window.__ModuleLoader__.load({
}
}
exports.inject = ["slots", "sessions", "uiWorkspace", "uiConversation"];
exports.inject = ["slots", "sessions", "workspaces", "uiWorkspace", "uiConversation"];
exports.apply = apply;
exports.WorkbenchRail = WorkbenchRail;
exports.WorkbenchPanel = WorkbenchPanel;
@ -2242,6 +2423,8 @@ window.__ModuleLoader__.load({
mergeEvents: mergeEvents,
apiPath: apiPath,
pickProjectId: pickProjectId,
workspaceIdOf: workspaceIdOf,
currentSessionIdOf: currentSessionIdOf,
formatModelLine: formatModelLine,
seatDisplayName: seatDisplayName,
modelTitle: modelTitle,

View File

@ -1,15 +1,10 @@
{
"name": "dsh-sansheng-liubu-workbench",
"version": "0.2.0",
"description": "三省六部工作台:右侧朝堂部门树、任务与成果",
"name": "dsh-sansheng-liubu-mode-panel-source",
"version": "0.14.0",
"description": "三省六部工作台面板源码(已并入 dsh-sansheng-liubu-mode,不是独立安装包)",
"type": "module",
"private": true,
"files": [
"lib/**",
"index.js",
"cordis.patch.yml"
],
"peerDependencies": {
"@deepseek-ai/cordis": "~4.0.5"
},
"private": true
"lib/**"
]
}

View File

@ -182,12 +182,12 @@ test("bundle 契约:id、inject 与纯函数导出", function () {
const plugin = loadPlugin();
const api = plugin.exports;
assert.deepEqual(Array.from(api.inject), ["slots", "sessions", "uiWorkspace", "uiConversation"]);
assert.deepEqual(Array.from(api.inject), ["slots", "sessions", "workspaces", "uiWorkspace", "uiConversation"]);
assert.equal(typeof api.apply, "function");
assert.equal(typeof api.WorkbenchRail, "function");
assert.equal(typeof api.__test, "object");
const expected = ["computeRailLayout", "statusOf", "mergeEvents", "apiPath", "pickProjectId", "formatModelLine", "ROLE_META"];
const expected = ["computeRailLayout", "statusOf", "mergeEvents", "apiPath", "pickProjectId", "workspaceIdOf", "formatModelLine", "ROLE_META"];
for (const key of expected) assert.ok(key in api.__test, "__test 缺少 " + key);
assert.equal(Object.keys(api.__test.ROLE_META).length, 10);
assert.deepEqual(Object.keys(api.__test.ROLE_META).slice(0, 4), ["lead", "zhongshu", "shangshu", "menxia"]);
@ -336,7 +336,7 @@ test("apiPath:拼出同源工作台路径并编码查询串", function () {
assert.equal(apiPath("bootstrap", {}), "/sansheng/workbench/bootstrap");
});
test("pickProjectId:优先当前工作区,其次 bootstrap 默认项目", function () {
test("pickProjectId:只按明确的 hostWorkspaceId 匹配,缺省不再退回首项目", function () {
const { pickProjectId } = loadPlugin().exports.__test;
const data = {
projectId: "p-default",
@ -347,9 +347,51 @@ test("pickProjectId:优先当前工作区,其次 bootstrap 默认项目", fu
};
assert.equal(pickProjectId(data, "ws-mine"), "p-mine");
assert.equal(pickProjectId(data, "ws-missing"), null);
assert.equal(pickProjectId(data), "p-default");
assert.equal(pickProjectId({ projects: [{ id: "p-only" }] }), "p-only");
assert.equal(pickProjectId({ projects: [] }), null);
assert.equal(pickProjectId(data), null, "没有工作区身份时不能回退到默认项目");
assert.equal(pickProjectId(data, ""), null);
assert.equal(pickProjectId({ projects: [{ id: "p-only" }] }, "ws-only"), null);
assert.equal(pickProjectId({ projects: [] }, "ws-x"), null);
});
test("workspaceIdOf:从当前 mainView 会话反查工作区,绝不猜第一个", function () {
const { workspaceIdOf } = loadPlugin().exports.__test;
const sessions = {
list: {
getSnapshot: () => ({
byId: {
"s-1": { id: "s-1", retainedBy: { mainView: 1 } },
"s-2": { id: "s-2", retainedBy: {} },
},
}),
},
};
const workspaces = {
list: {
getSnapshot: () => ({
items: [
{ workspaceId: "ws-first", sessionIds: ["s-2"] },
{ workspaceId: "ws-current", sessionIds: ["s-1"] },
],
}),
},
};
const ctx = {
get(name) {
if (name === "sessions") return sessions;
if (name === "workspaces") return workspaces;
return undefined;
},
};
assert.equal(workspaceIdOf(ctx), "ws-current");
// 没有 mainView 会话时返回 null,绝不拿列表第一项。
const noSelection = {
get(name) {
if (name === "sessions") return { list: { getSnapshot: () => ({ byId: {} }) } };
if (name === "workspaces") return workspaces;
return undefined;
},
};
assert.equal(workspaceIdOf(noSelection), null);
});
test("apply:注册朝堂页签、pane 槽与 priority -1 的 main.conversation", function () {
@ -365,6 +407,10 @@ test("apply:注册朝堂页签、pane 槽与 priority -1 的 main.conversation
assert.equal(mock.tabs[0].id, "sansheng-liubu-workbench");
assert.equal(mock.tabs[0].priority, "builtin");
assert.equal(mock.tabs[0].title(), "朝堂");
assert.ok(Array.isArray(mock.tabs[0].guide) && mock.tabs[0].guide.length === 1, "原生降级必须带 guide 入口");
assert.equal(mock.tabs[0].guide[0].id, "sansheng-liubu-workbench");
assert.equal(mock.tabs[0].guide[0].title(), "朝堂");
assert.equal(typeof mock.tabs[0].guide[0].description(), "string");
const main = mock.registrations.find((entry) => entry.spec && entry.spec.name === "main.conversation");
assert.ok(main, "必须注册 main.conversation");
@ -372,6 +418,62 @@ test("apply:注册朝堂页签、pane 槽与 priority -1 的 main.conversation
assert.deepEqual(Array.from(Object.keys(main.spec.children)), ["conversation.header"]);
});
test("apply:服务晚到与重挂时只保留一个朝堂入口,先清理旧注册", function () {
const plugin = loadPlugin();
const registered = [];
const disposed = [];
const watchers = new Map();
const ctx = {
slots: {
inject: function () {},
register: function (spec) { return { spec: spec } },
},
effect: function (factory) {
const value = factory();
return typeof value === "function" ? value : function () {};
},
get: function () { return undefined; },
inject: function (names, callback) {
watchers.set(names[0], { callback: callback, cleanup: null });
return function () {};
},
};
plugin.exports.apply(ctx);
assert.equal(registered.length, 0, "服务未就绪时不能假装注册");
const better = {
registerTab: function (spec) {
registered.push({ kind: "better", spec: spec });
return function () { disposed.push("better"); };
},
};
const native = {
register: function (spec) {
registered.push({ kind: "native", spec: spec });
return function () { disposed.push("native"); };
},
};
const betterWatcher = watchers.get("betterSidebar");
betterWatcher.cleanup = betterWatcher.callback({ get: function () { return better; } });
assert.equal(registered.length, 1);
assert.equal(registered[0].kind, "better");
const nativeWatcher = watchers.get("sidebarRightTabs");
nativeWatcher.cleanup = nativeWatcher.callback({ get: function () { return native; } });
assert.equal(registered.length, 1, "betterSidebar 在场时不能重复注册原生入口");
betterWatcher.cleanup();
assert.equal(registered.length, 2, "betterSidebar 卸载后应补注册原生入口");
assert.equal(registered[1].kind, "native");
betterWatcher.cleanup = betterWatcher.callback({ get: function () { return better; } });
assert.equal(registered.length, 3, "betterSidebar 重挂后应重新注册 better 入口");
assert.equal(registered[2].kind, "better");
assert.ok(disposed.includes("native"), "切回 better 前必须先释放原生注册");
});
test("apply:localStorage 逃生开关 sansheng.workbench.main=off 时不接管主区", function () {
const plugin = loadPlugin({ storage: { "sansheng.workbench.main": "off" } });
const mock = createCtx();

View File

@ -156,6 +156,55 @@ test('会话适配:prompt 必须带 requestId,错误分类可区分可重试
assert.equal(classifyHostError(new Error('随便什么')), 'unknown')
})
test('会话适配:follow 发送 kind=session 地址,同一会话只保留一条流', async () => {
let address = null
const controller = {
...fakeController(),
follow(request, signal) {
address = request.address
return (async function* () {
yield { type: 'turn/start' }
while (!signal.aborted) await new Promise((resolve) => setTimeout(resolve, 5))
})()
},
}
const sessions = createSessionAdapter({ sessionController: controller })
const first = sessions.follow('ses_follow')
await new Promise((resolve) => setTimeout(resolve, 10))
assert.deepEqual(address, { kind: 'session', sessionId: 'ses_follow' })
assert.equal(sessions.follow('ses_follow'), first, '同一会话不能起第二条流')
first.stop()
await new Promise((resolve) => setTimeout(resolve, 10))
})
test('会话适配:直接子代理使用 kind=subagent 地址,订阅失败回调可见', async () => {
let address = null
let failure = null
const controller = {
...fakeController(),
follow(request) {
address = request.address
return (async function* () {
throw Object.assign(new Error('session not found'), { code: 'session/not-found' })
})()
},
}
const sessions = createSessionAdapter({ sessionController: controller })
sessions.follow(
{ kind: 'subagent', parentSessionId: 'ses_parent', childSessionId: 'ses_child', mode: 'one-shot' },
{ onError: (value) => { failure = value } },
)
await new Promise((resolve) => setTimeout(resolve, 10))
assert.deepEqual(address, {
kind: 'subagent',
parentSessionId: 'ses_parent',
childSessionId: 'ses_child',
mode: 'one-shot',
})
assert.equal(failure?.sessionId, 'ses_child')
assert.equal(failure?.code, 'session/not-found')
})
test('派发提示词只写事实,不给“已完成”下定义', () => {
const text = buildDispatchText({
task: { id: 'task_1', title: '整理报表', objective: '合并三张表', acceptance: ['口径一致'], constraints: ['只读源文件'] },

View File

@ -368,13 +368,16 @@ test('bootstrap:一次拿全,且只含选中项目', async () => {
assert.deepEqual(value.layout.lead, ['lead'])
})
test('bootstrap:不传 projectId 时选中第一个项目', async () => {
test('bootstrap:不传 projectId 时只返回项目清单,不默认选中第一个项目', async () => {
const { service } = makeService()
const { call } = mount(service)
const { a } = seedService(service)
const res = await call('GET', `${ROUTE_PREFIX}/bootstrap`)
assert.equal(res.statusCode, 200)
assert.equal(res.json.value.projectId, a.id)
assert.equal(res.json.value.projectId, null)
assert.equal(res.json.value.project, null)
assert.deepEqual(res.json.value.seats, [])
assert.equal(res.json.value.projects.some((project) => project.id === a.id), true)
})
test('bootstrap:伪造 projectId 返回 404,不泄露存在性', async () => {

View File

@ -491,9 +491,12 @@ test('bootstrap 一次拿全且只含选中项目的数据', () => {
assert.deepEqual(view.tasks.map((row) => row.id), [taskA.id])
assert.ok(!view.tasks.some((row) => row.id === taskB.id), '不串项目任务')
assert.equal(view.eventSeq, ctx.store.eventSeq)
// 不传 projectId 时取第一个项目
// 不传 projectId 时只返回项目清单,不默认选中第一个项目
const fallback = ctx.service.bootstrap()
assert.equal(fallback.projectId, view.projects[0].id)
assert.equal(fallback.projectId, null)
assert.equal(fallback.project, null)
assert.deepEqual(fallback.seats, [])
assert.equal(fallback.projects.length, 2)
expectCode(() => ctx.service.bootstrap('proj_ghost'), 'NOT_FOUND')
})