dsh-sansheng-liubu/workbench/host/workbench-host.mjs

329 lines
13 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

// 工作台 Host 外壳:把 store + service + 适配层 + 两个后台服务组装成一个可挂载组件。
//
// 挂载方式(index.js 里):
// const host = createWorkbenchHost(ctx, { store, presetId })
// ctx.effect(() => () => host.dispose(), 'sansheng-liubo: workbench')
//
// 能力探测优先:宿主没有 sessionController 时,工作台仍然能读写账本(投影可用),
// 但任何“派发/接通”都返回 NO_SESSION_CONTROLLER,UI 显示“尚未接通”,绝不假装成功。
import { join } from 'node:path'
import { WorkbenchStore, defaultStorePath } from '../core/store.mjs'
import { createMemoryStore } from '../core/memory.mjs'
import { resolveSidecarDir } from './paths.mjs'
import { createWorkbenchService } from './service.mjs'
import { createSessionAdapter } from './session-adapter.mjs'
import { createDispatchService } from './dispatch-service.mjs'
import { createReconciler } from './reconciler.mjs'
import { CONTRACT_ACTIONS, CONTRACT_ACTION_PREFIX, parseContractLines, describeContract } from './contract.mjs'
export const WORKBENCH_HOST_VERSION = 1
/**
* @param {object} ctx Host 插件上下文(cordis Context)
* @param {object} [options]
* @param {object} [options.store] 已有 store(测试注入);缺省按环境建一个。
* @param {object} [options.service] 已有 service;缺省按 store 新建。给了 service 就必须同时给 store,
* 否则两边的账不是同一本。
* @param {string} [options.presetId] 部门会话显式使用的 agentPreset;缺省不指定,走宿主默认创建流程。
* @param {boolean} [options.startReconciler] 是否启动周期对账,默认 true。
*/
export function createWorkbenchHost(ctx, options = {}) {
const log = (message) => {
try {
ctx?.logger?.info?.(message)
} catch {
/* 日志失败不能影响业务 */
}
}
const store = options.store ?? createStore(options)
// 记忆层:默认落在侧车目录的 memory/ 下(惰性读写,装配本身不碰磁盘);
// 测试可注入 options.memory,用 null 明确关掉。
const memory = options.memory === null
? null
: (options.memory ?? createMemoryStore({ dir: join(resolveSidecarDir(options.env ?? process.env), 'memory'), clock: options.clock }))
const service = options.service ?? createWorkbenchService({ store, clock: options.clock, fileExists: options.fileExists, memory })
// 会话层是可选能力:宿主没有 sessionController(或版本不提供)时整体降级。
// 注意 apply 时宿主可能还没把 sessionController 装好,所以这里只是「尝试挂载」,
// 真正的挂载动作集中在 mountSessions,宿主晚到时由 attachSessions 再补一次。
let sessions = null
let dispatchService = null
let reconciler = null
let hasSessions = false
let started = false
function mountSessions(controller) {
const usable = controller !== null && typeof controller?.prompt === 'function'
if (!usable) return false
if (sessions !== null) return true
try {
sessions = createSessionAdapter({ sessionController: controller, log })
} catch (error) {
log(`[sansheng-liubo] 会话层不可用:${error?.message ?? error}`)
sessions = null
return false
}
dispatchService = createDispatchService({ store, service, sessions, log, applyModelToSessions: options.applyModelToSessions === true })
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)
if (!mounted) log('[sansheng-liubo] 会话控制器仍不可用,派发继续保持“只落账”')
return mounted
}
mountSessions(ctx?.sessionController ?? ctx?.remote?.session ?? null)
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 建一个并登记。
* 绑定替换由 store 的 bindSession 判定(allowReplace),账上和宿主保持一致。
*/
async function connectDepartment(input = {}) {
const projectId = requireText(input.projectId, 'projectId')
const roleId = requireText(input.roleId, 'roleId')
const project = store.getProject(projectId)
if (project === undefined) throw new Error('项目不存在')
if (sessions === null) {
throw new Error('宿主未提供会话能力,暂时无法接通部门(账本仍可读写)')
}
const binding = store.getBinding(projectId, roleId)
const existing = binding?.currentSessionId ?? null
if (existing !== null) {
const known = await sessions.inspectSession(existing)
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: requestedPreset,
})
// 账上登记:同一会话被别的部门占用时 store 会拒绝,正是我们要的“会话独占”。
const saved = service.bindDepartmentSession({
projectId,
roleId,
sessionId: target.sessionId,
allowReplace: existing !== null,
})
followSession(target.sessionId)
return { sessionId: target.sessionId, created: target.created === true, seat: saved.seat }
}
function seatOf(projectId, roleId) {
return service.listSeats(projectId).find((seat) => seat.roleId === roleId) ?? null
}
/** 派发(对 UI 的唯一入口)。没有会话层时返回明确错误,不假装已发送。 */
async function dispatchTask(input = {}) {
if (dispatchService === null) {
return { ok: false, code: 'NO_SESSION_CONTROLLER', message: '宿主未提供会话能力,派发已停在工作台账内' }
}
return dispatchService.dispatch(input)
}
/** 处理部门输出里的契约行:只认结构化字段,解析失败的行原样返回给 UI 提示。 */
function ingestAgentOutput({ projectId, roleId, text } = {}) {
const parsed = parseContractLines(text)
const applied = []
const failed = []
for (const call of parsed.calls) {
try {
applied.push(applyContractCall({ projectId, roleId, call }))
} catch (error) {
failed.push({ action: call.action, code: error?.code ?? 'unknown', message: error?.message ?? String(error) })
}
}
return { applied, failed, invalid: parsed.invalid }
}
function applyContractCall({ projectId, roleId, call }) {
const payload = { ...call.payload, projectId }
switch (call.action) {
case 'dispatchTask':
if (payload.sourceRoleId === undefined) payload.sourceRoleId = roleId
return { action: call.action, result: service.dispatchTask(payload) }
case 'reportTaskResult':
return { action: call.action, result: service.reportTaskResult(payload) }
case 'requestTaskInput':
return { action: call.action, result: service.requestTaskInput(payload) }
case 'syncDecision':
return { action: call.action, result: service.syncDecision(payload) }
default:
throw new Error(`未知动作:${String(call.action)}`)
}
}
function start() {
if (started) return
started = true
if (options.startReconciler !== false && reconciler !== null) reconciler.start()
}
function dispose() {
if (reconciler !== null) reconciler.stop()
if (sessions !== null) sessions.dispose()
started = false
}
return Object.freeze({
version: WORKBENCH_HOST_VERSION,
store,
service,
memory,
// 会话层可能晚到:用 getter,调用方总能读到最新挂载结果。
get sessions() {
return sessions
},
get reconciler() {
return reconciler
},
get dispatchService() {
return dispatchService
},
get hasSessions() {
return hasSessions
},
attachSessions,
presetId,
connectDepartment,
dispatchTask,
ingestAgentOutput,
bootstrap: (projectId) => service.bootstrap(projectId),
listEvents: (projectId, since, opts) => service.listEvents(projectId, since, opts),
start,
dispose,
})
}
function createStore(options) {
const file = options.storeFile ?? defaultStorePath(process.env)
const store = new WorkbenchStore({ file })
try {
store.load()
} catch {
// 读到坏账本时不静默清空:由 paths.quarantineFile 在 HTTP 层隔离,这里保持空账可写。
}
return store
}
function requireText(value, field) {
if (typeof value !== 'string' || value.trim() === '') throw new Error(`${field} 必须是非空字符串`)
return value
}
export { CONTRACT_ACTIONS, CONTRACT_ACTION_PREFIX, parseContractLines, describeContract }