@psyduck25/dsh-session-manager 0.0.0-stage → 0.4.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -0
- package/README.md +158 -2
- package/assets/icon-180.png +0 -0
- package/assets/screenshot-1.png +0 -0
- package/cordis.patch.yml +12 -0
- package/docs/DETAIL.md +60 -0
- package/docs/DETAIL.zh.md +56 -0
- package/docs/preview.svg +79 -0
- package/icon.svg +24 -0
- package/lib/client.js +1069 -0
- package/lib/index.js +1012 -0
- package/lib/state.js +148 -0
- package/lib/trash.js +216 -0
- package/locale/en.json +7 -0
- package/locale/zh.json +7 -0
- package/package.json +68 -4
- package/screenshots.json +3 -0
package/lib/index.js
ADDED
|
@@ -0,0 +1,1012 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* dsh-session-manager 的宿主行。
|
|
3
|
+
*
|
|
4
|
+
* 职责:给设置页开一组本地 HTTP 路由,并托管「删除缓冲站」的定时器。
|
|
5
|
+
*
|
|
6
|
+
* 为什么用 `ctx.webServer.register` 而不是 Remote 服务:这里是插件自建的业务接口,
|
|
7
|
+
* 用普通 HTTP 路由更直接(union-search、compaction-ask 也走这条路),
|
|
8
|
+
* 所有路由只接受本机 loopback 请求。
|
|
9
|
+
*
|
|
10
|
+
* 路由:
|
|
11
|
+
* POST /api/dsh-session-manager/state 页面挂载/刷新时拉一次全量数据
|
|
12
|
+
* POST /api/dsh-session-manager/settings 改缓冲时长
|
|
13
|
+
* POST /api/dsh-session-manager/lock 锁定 / 解锁一个会话
|
|
14
|
+
* POST /api/dsh-session-manager/delete 二次确认后把会话送进缓冲站
|
|
15
|
+
* POST /api/dsh-session-manager/restore 从缓冲站回档
|
|
16
|
+
*
|
|
17
|
+
* 删除的两段式:
|
|
18
|
+
* 1. 进入缓冲站时先把会话从左侧列表「摘掉」,再**把日志文件搬进回收站**
|
|
19
|
+
* (`$DSH_HOME/session-manager/trash/<会话>/`)。文件不在会话目录里,
|
|
20
|
+
* 存储层就列不出它——哪怕用户开着「显示归档会话」也看不见(归档只是变灰)。
|
|
21
|
+
* 2. 到期(默认 24 小时)后才真正销毁回收站里的文件、解除工作区归属、清掉归档集合。
|
|
22
|
+
* 会话如果还被本进程活着(正在打开),Windows 上删不掉持有中的文件,
|
|
23
|
+
* 于是标记 pending 并继续重试;下次 DSH 启动时第一件事就是清掉这些欠账。
|
|
24
|
+
*
|
|
25
|
+
* 回档把文件原样搬回去即可:工作区登记里那个 id 自始至终没被删过,位置不用猜。
|
|
26
|
+
*/
|
|
27
|
+
|
|
28
|
+
import { readdir, rmdir, unlink } from 'node:fs/promises'
|
|
29
|
+
import path from 'node:path'
|
|
30
|
+
import {
|
|
31
|
+
DEFAULTS,
|
|
32
|
+
LIMITS,
|
|
33
|
+
readState,
|
|
34
|
+
resolveDshHome,
|
|
35
|
+
stateFile,
|
|
36
|
+
writeState,
|
|
37
|
+
} from './state.js'
|
|
38
|
+
import { moveIntoTrash, purgeTrash, restoreFromTrash } from './trash.js'
|
|
39
|
+
|
|
40
|
+
export const ROUTE_PREFIX = '/api/dsh-session-manager'
|
|
41
|
+
|
|
42
|
+
/** 单次请求体上限:这里只收几个数字和 id。 */
|
|
43
|
+
const MAX_BODY_BYTES = 64 * 1024
|
|
44
|
+
|
|
45
|
+
/** 缓冲站巡检间隔:一分钟一次足够,到期的条目最多晚一分钟被清掉。 */
|
|
46
|
+
const TICK_MS = 60_000
|
|
47
|
+
|
|
48
|
+
/**
|
|
49
|
+
* 等一个会话从内存里退出的上限。
|
|
50
|
+
*
|
|
51
|
+
* 归档后客户端会在下一帧放掉主视图的引用,宿主随即释放 Agent——通常几十毫秒。
|
|
52
|
+
* 但「当前正在看的那个会话」不会退出:它还被主视图攥着。那种情况按 deferred
|
|
53
|
+
* 收进缓冲站(归档已经让它从列表消失),等它关掉后由巡检补搬文件。
|
|
54
|
+
*/
|
|
55
|
+
const DETACH_TIMEOUT_MS = 3_000
|
|
56
|
+
|
|
57
|
+
export const inject = ['webServer']
|
|
58
|
+
|
|
59
|
+
export function apply(ctx, config = {}) {
|
|
60
|
+
/** @type {{ home?: unknown }} */
|
|
61
|
+
const rowConfig = config !== null && typeof config === 'object' ? config : {}
|
|
62
|
+
const home = typeof rowConfig.home === 'string' && rowConfig.home !== '' ? rowConfig.home : resolveDshHome()
|
|
63
|
+
const logger = ctx.logger
|
|
64
|
+
|
|
65
|
+
/** 串行化所有状态写入,避免两次点击互相覆盖。 */
|
|
66
|
+
/** @type {Promise<unknown>} */
|
|
67
|
+
let queue = Promise.resolve()
|
|
68
|
+
/**
|
|
69
|
+
* 把一次写入排进队列,并把它的返回值交回给调用方。
|
|
70
|
+
* @template T
|
|
71
|
+
* @param {() => Promise<T>} operation
|
|
72
|
+
* @returns {Promise<T>}
|
|
73
|
+
*/
|
|
74
|
+
const serialize = (operation) => {
|
|
75
|
+
const next = queue.then(operation, operation)
|
|
76
|
+
queue = next.then(() => undefined, () => undefined)
|
|
77
|
+
return next
|
|
78
|
+
}
|
|
79
|
+
|
|
80
|
+
// ------------------------------------------------------------------ 数据读取
|
|
81
|
+
|
|
82
|
+
/** 会话标题:日志里最新的标题事件;没有标题的会话返回 undefined。 */
|
|
83
|
+
async function readTitles(ids) {
|
|
84
|
+
const query = ctx.get('sessionQuery')
|
|
85
|
+
const titles = new Map()
|
|
86
|
+
if (query === undefined || ids.length === 0) return titles
|
|
87
|
+
try {
|
|
88
|
+
const results = await query.readTitleSnapshots(ids)
|
|
89
|
+
for (const result of results) {
|
|
90
|
+
if (result.status !== 'fulfilled') continue
|
|
91
|
+
const title = result.value.title
|
|
92
|
+
if (title !== undefined && typeof title.title === 'string' && title.title.trim() !== '') {
|
|
93
|
+
titles.set(result.sessionId, title.title.trim())
|
|
94
|
+
}
|
|
95
|
+
}
|
|
96
|
+
} catch (error) {
|
|
97
|
+
logger?.warn?.(`dsh-session-manager: 读取会话标题失败 ${messageOf(error)}`)
|
|
98
|
+
}
|
|
99
|
+
return titles
|
|
100
|
+
}
|
|
101
|
+
|
|
102
|
+
/** 会话摘要:优先用会话控制器(和左侧列表同一份数据),失败时退回查询服务。 */
|
|
103
|
+
async function readSummaries(signal) {
|
|
104
|
+
const controller = ctx.get('sessionController')
|
|
105
|
+
if (controller !== undefined) {
|
|
106
|
+
try {
|
|
107
|
+
const value = await controller.list({}, signal)
|
|
108
|
+
if (Array.isArray(value?.items)) return value.items
|
|
109
|
+
} catch (error) {
|
|
110
|
+
logger?.warn?.(`dsh-session-manager: 会话列表回退到 sessionQuery(${messageOf(error)})`)
|
|
111
|
+
}
|
|
112
|
+
}
|
|
113
|
+
const query = ctx.get('sessionQuery')
|
|
114
|
+
if (query === undefined) return []
|
|
115
|
+
const records = await query.listSessions(signal)
|
|
116
|
+
return records.map((record) => ({
|
|
117
|
+
sessionId: record.header.id,
|
|
118
|
+
updatedAt: record.header.createdAt,
|
|
119
|
+
blank: false,
|
|
120
|
+
running: false,
|
|
121
|
+
agentAvailable: false,
|
|
122
|
+
cwd: record.header.cwd,
|
|
123
|
+
}))
|
|
124
|
+
}
|
|
125
|
+
|
|
126
|
+
/** 把会话、工作区、锁定、缓冲站拼成页面要的一份数据。 */
|
|
127
|
+
async function readView() {
|
|
128
|
+
const state = readState(home)
|
|
129
|
+
const registry = ctx.get('workspaceRegistry')
|
|
130
|
+
const sessionStore = ctx.get('sessions')
|
|
131
|
+
const agentStore = ctx.get('agents')
|
|
132
|
+
const summaries = await readSummaries()
|
|
133
|
+
const titles = await readTitles(summaries.map((item) => item.sessionId))
|
|
134
|
+
|
|
135
|
+
const workspaces = (registry?.list?.() ?? []).map((workspace) => ({
|
|
136
|
+
workspaceId: workspace.id,
|
|
137
|
+
title: workspace.title,
|
|
138
|
+
path: workspace.path,
|
|
139
|
+
sessionIds: [...workspace.sessionIds],
|
|
140
|
+
}))
|
|
141
|
+
|
|
142
|
+
const owner = new Map()
|
|
143
|
+
for (const workspace of workspaces) {
|
|
144
|
+
for (const sessionId of workspace.sessionIds) {
|
|
145
|
+
if (!owner.has(sessionId)) owner.set(sessionId, workspace.workspaceId)
|
|
146
|
+
}
|
|
147
|
+
}
|
|
148
|
+
|
|
149
|
+
const locked = new Set(state.locks)
|
|
150
|
+
const buffered = new Set(state.buffer.map((entry) => entry.sessionId))
|
|
151
|
+
// 进缓冲站的会话已经从左侧列表隐藏了,这里也不再列一遍:
|
|
152
|
+
// 否则同一个会话会同时出现在「会话」和「删除缓冲站」两处,还带一个会报错的删除按钮。
|
|
153
|
+
const visible = summaries.filter((summary) => !buffered.has(summary.sessionId))
|
|
154
|
+
const sessions = visible.map((summary) => {
|
|
155
|
+
const id = summary.sessionId
|
|
156
|
+
const live = sessionStore?.get?.(id)
|
|
157
|
+
// 运行中看的是 Agent,不是 Session:会话本身没有 status。
|
|
158
|
+
const agent = agentStore?.get?.(id)
|
|
159
|
+
const cwd = typeof summary.cwd === 'string' ? summary.cwd : ''
|
|
160
|
+
// 没被任何工作区登记的会话会落在左侧的「未分组」里。
|
|
161
|
+
// 它的 cwd 往往正好是某个工作区的目录,只是工作区的补登记只在启动时跑一次,
|
|
162
|
+
// 之后新出现的会话不会再被收进去——这里算出来,让页面能提示并一键归位。
|
|
163
|
+
const ownerId = owner.get(id) ?? ''
|
|
164
|
+
const adoptable = ownerId === '' && cwd !== ''
|
|
165
|
+
? workspaces.find((workspace) => workspace.path === cwd)
|
|
166
|
+
: undefined
|
|
167
|
+
return {
|
|
168
|
+
sessionId: id,
|
|
169
|
+
title: titles.get(id) ?? '',
|
|
170
|
+
workspaceId: ownerId,
|
|
171
|
+
cwd,
|
|
172
|
+
updatedAt: Number.isFinite(summary.updatedAt) ? summary.updatedAt : 0,
|
|
173
|
+
blank: summary.blank === true,
|
|
174
|
+
subagent: summary.origin === 'subagent',
|
|
175
|
+
running: summary.running === true || agent?.status === 'running',
|
|
176
|
+
live: live !== undefined,
|
|
177
|
+
locked: locked.has(id),
|
|
178
|
+
buffered: buffered.has(id),
|
|
179
|
+
adoptInto: adoptable === undefined ? '' : adoptable.workspaceId,
|
|
180
|
+
adoptIntoTitle: adoptable === undefined ? '' : adoptable.title,
|
|
181
|
+
}
|
|
182
|
+
})
|
|
183
|
+
|
|
184
|
+
// 工作区里登记了、但当前进程读不到日志的会话也要占一行,否则用户看不见它。
|
|
185
|
+
const known = new Set(sessions.map((session) => session.sessionId))
|
|
186
|
+
for (const workspace of workspaces) {
|
|
187
|
+
for (const sessionId of workspace.sessionIds) {
|
|
188
|
+
if (known.has(sessionId)) continue
|
|
189
|
+
if (buffered.has(sessionId)) continue
|
|
190
|
+
known.add(sessionId)
|
|
191
|
+
sessions.push({
|
|
192
|
+
sessionId,
|
|
193
|
+
title: '',
|
|
194
|
+
workspaceId: workspace.workspaceId,
|
|
195
|
+
cwd: workspace.path,
|
|
196
|
+
updatedAt: 0,
|
|
197
|
+
blank: false,
|
|
198
|
+
running: false,
|
|
199
|
+
live: false,
|
|
200
|
+
locked: locked.has(sessionId),
|
|
201
|
+
buffered: false,
|
|
202
|
+
missing: true,
|
|
203
|
+
})
|
|
204
|
+
}
|
|
205
|
+
}
|
|
206
|
+
|
|
207
|
+
return {
|
|
208
|
+
ok: true,
|
|
209
|
+
settings: state.settings,
|
|
210
|
+
defaults: DEFAULTS,
|
|
211
|
+
limits: LIMITS,
|
|
212
|
+
statePath: stateFile(home),
|
|
213
|
+
workspaces,
|
|
214
|
+
sessions,
|
|
215
|
+
buffer: state.buffer,
|
|
216
|
+
now: Date.now(),
|
|
217
|
+
}
|
|
218
|
+
}
|
|
219
|
+
|
|
220
|
+
/**
|
|
221
|
+
* `readView` 的容错版:写操作已经落盘之后,重新读列表失败不该把成功覆盖成失败。
|
|
222
|
+
* 读不出来就退回一个空视图,页面照常显示操作结果,用户点刷新还能再看。
|
|
223
|
+
*/
|
|
224
|
+
async function readViewSafely() {
|
|
225
|
+
try {
|
|
226
|
+
return await readView()
|
|
227
|
+
} catch (error) {
|
|
228
|
+
logger?.warn?.(`dsh-session-manager: 操作成功但重新读取列表失败 ${messageOf(error)}`)
|
|
229
|
+
return { ok: false, code: 'readFailed' }
|
|
230
|
+
}
|
|
231
|
+
}
|
|
232
|
+
|
|
233
|
+
/**
|
|
234
|
+
* 什么情况下不能动这个会话的日志文件。
|
|
235
|
+
*
|
|
236
|
+
* 只有「正在跑回合」是硬拦:那时 DSH 会持续往日志里追加事件,把文件搬走会
|
|
237
|
+
* 让写入者落到一个已经不在原位的路径上,重启后就是一堆丢失的对话。
|
|
238
|
+
*
|
|
239
|
+
* 「会话开着但空闲」不是拦的理由,但也不能直接搬:DSH 的会话列表是
|
|
240
|
+
* 「磁盘文件 ∪ 内存实例」的并集,文件搬走了内存里那个实例还在,左侧照样
|
|
241
|
+
* 显示。所以那种会话先归档(客户端主视图会放掉它、宿主随即释放 Agent),
|
|
242
|
+
* 等它真的不在内存里了再搬文件。
|
|
243
|
+
*/
|
|
244
|
+
function liveBlockers(sessionId) {
|
|
245
|
+
const blockers = []
|
|
246
|
+
const agent = ctx.get('agents')?.get?.(sessionId)
|
|
247
|
+
if (agent !== undefined && agent.status === 'running') blockers.push('running')
|
|
248
|
+
return blockers
|
|
249
|
+
}
|
|
250
|
+
|
|
251
|
+
/** 会话是否还活在本进程里(列表会把它算进去)。 */
|
|
252
|
+
function isLive(sessionId) {
|
|
253
|
+
return ctx.get('sessions')?.get?.(sessionId) !== undefined
|
|
254
|
+
}
|
|
255
|
+
|
|
256
|
+
/** 让这个会话缓冲中的事件落盘;没有存储层或没有活会话时什么也不做。 */
|
|
257
|
+
async function flushSession(sessionId) {
|
|
258
|
+
const session = ctx.get('sessions')?.get?.(sessionId)
|
|
259
|
+
if (session === undefined) return
|
|
260
|
+
try {
|
|
261
|
+
await ctx.get('sessions')?.flush?.(session)
|
|
262
|
+
} catch (error) {
|
|
263
|
+
logger?.warn?.(`dsh-session-manager: flush 会话失败 ${messageOf(error)}`)
|
|
264
|
+
}
|
|
265
|
+
}
|
|
266
|
+
|
|
267
|
+
/** 读一个会话的 header(含 cwd)。活着就直接拿,冷会话走存储层。 */
|
|
268
|
+
async function readSessionHeader(sessionId) {
|
|
269
|
+
const live = ctx.get('sessions')?.get?.(sessionId)
|
|
270
|
+
if (live !== undefined) return live.header
|
|
271
|
+
const persistence = ctx.get('sessionPersistence')
|
|
272
|
+
if (persistence === undefined) return undefined
|
|
273
|
+
try {
|
|
274
|
+
const snapshot = await persistence.stat(sessionId)
|
|
275
|
+
return snapshot?.header
|
|
276
|
+
} catch {
|
|
277
|
+
return undefined
|
|
278
|
+
}
|
|
279
|
+
}
|
|
280
|
+
|
|
281
|
+
/**
|
|
282
|
+
* 等这个会话从内存里退出(归档后客户端会放掉引用,宿主随即释放 Agent)。
|
|
283
|
+
* @returns 是否在超时前退出了内存。
|
|
284
|
+
*/
|
|
285
|
+
async function waitUntilDetached(sessionId, timeoutMs) {
|
|
286
|
+
const deadline = Date.now() + timeoutMs
|
|
287
|
+
for (;;) {
|
|
288
|
+
if (!isLive(sessionId)) return true
|
|
289
|
+
if (Date.now() >= deadline) return false
|
|
290
|
+
await delay(150)
|
|
291
|
+
}
|
|
292
|
+
}
|
|
293
|
+
|
|
294
|
+
// ------------------------------------------------------------------ 删除与回档
|
|
295
|
+
|
|
296
|
+
/**
|
|
297
|
+
* 找到会话日志在磁盘上的位置。存储层知道;没有存储层时返回 undefined。
|
|
298
|
+
*/
|
|
299
|
+
async function locateSessionLog(sessionId) {
|
|
300
|
+
const persistence = ctx.get('sessionPersistence')
|
|
301
|
+
if (persistence === undefined) return { file: undefined, code: 'noPersistence' }
|
|
302
|
+
try {
|
|
303
|
+
const snapshot = await persistence.stat(sessionId)
|
|
304
|
+
if (snapshot === undefined) return { file: undefined, code: 'missingLog' }
|
|
305
|
+
const file = snapshot.location?.path
|
|
306
|
+
if (typeof file !== 'string' || file === '') return { file: undefined, code: 'noLocation' }
|
|
307
|
+
return { file }
|
|
308
|
+
} catch (error) {
|
|
309
|
+
return { file: undefined, code: 'statFailed', detail: messageOf(error) }
|
|
310
|
+
}
|
|
311
|
+
}
|
|
312
|
+
|
|
313
|
+
/**
|
|
314
|
+
* 把一个会话藏起来。两步都要做,各自解决一半问题:
|
|
315
|
+
*
|
|
316
|
+
* 1. 归档:写进工作区归档集合,会让工作区流推一帧,左侧列表立刻重新拉数据;
|
|
317
|
+
* 同时也挡住这个会话后续的唤醒。
|
|
318
|
+
* 2. 把日志文件搬进回收站:只有这一步能让会话在「显示归档会话」开关打开时
|
|
319
|
+
* 也彻底不在列表里——列表来自存储层的会话清单,文件不在了就没有这一行。
|
|
320
|
+
*
|
|
321
|
+
* 顺序不能反:归档要先做(它要检查会话存在),搬完文件后存储层就找不到它了。
|
|
322
|
+
*/
|
|
323
|
+
async function hideSession(sessionId) {
|
|
324
|
+
// 跑着回合的会话不能动:日志还在被持续追加。先叫停,让用户稍后再删。
|
|
325
|
+
const blockers = liveBlockers(sessionId)
|
|
326
|
+
if (blockers.length > 0) return { hidden: false, code: 'liveBlocked', detail: blockers.join(',') }
|
|
327
|
+
|
|
328
|
+
const registry = ctx.get('workspaceRegistry')
|
|
329
|
+
if (registry === undefined) return { hidden: false, code: 'archiveFailed', detail: 'no workspace registry' }
|
|
330
|
+
|
|
331
|
+
// 1. 先把内存里还没落盘的事件刷进日志。必须排在归档之前:归档之后会话会被
|
|
332
|
+
// 释放,那时 flushSession 取不到会话就直接返回了,等于什么也没刷。
|
|
333
|
+
await flushSession(sessionId)
|
|
334
|
+
|
|
335
|
+
// 2. 归档:写进归档集合,推一帧让客户端放掉主视图引用。
|
|
336
|
+
try {
|
|
337
|
+
await registry.archiveSession(sessionId, { stopActivity: true })
|
|
338
|
+
} catch (error) {
|
|
339
|
+
return { hidden: false, code: 'archiveFailed', detail: messageOf(error) }
|
|
340
|
+
}
|
|
341
|
+
const unarchive = async () => {
|
|
342
|
+
try {
|
|
343
|
+
await registry.unarchiveSession(sessionId)
|
|
344
|
+
} catch {
|
|
345
|
+
// 退回失败也只是多一个归档条目,不影响正确性
|
|
346
|
+
}
|
|
347
|
+
}
|
|
348
|
+
|
|
349
|
+
// 3. 等它从内存退出:列表是「磁盘 ∪ 内存」,内存里还在就照样看得见。
|
|
350
|
+
const detached = await waitUntilDetached(sessionId, DETACH_TIMEOUT_MS)
|
|
351
|
+
if (!detached) {
|
|
352
|
+
// 有人正看着它(比如当前会话本身)。归档留着,等它关掉后由巡检接着搬。
|
|
353
|
+
return { hidden: true, originalDir: '', files: [], deferred: true }
|
|
354
|
+
}
|
|
355
|
+
|
|
356
|
+
// 4. 搬文件:这一步之后存储层列不出它,开关也救不回来。
|
|
357
|
+
const located = await locateSessionLog(sessionId)
|
|
358
|
+
if (located.file === undefined) {
|
|
359
|
+
// 找不到日志文件:归档已经让它从列表里消失了,收进缓冲站到期再清一次。
|
|
360
|
+
return { hidden: true, originalDir: '', files: [] }
|
|
361
|
+
}
|
|
362
|
+
const moved = await moveIntoTrash(home, sessionId, located.file)
|
|
363
|
+
if (moved.moved) {
|
|
364
|
+
return { hidden: true, originalDir: moved.originalDir, files: moved.files }
|
|
365
|
+
}
|
|
366
|
+
if (moved.code === 'missingLog') return { hidden: true, originalDir: '', files: [] }
|
|
367
|
+
|
|
368
|
+
// 搬不动就把归档也退回去,别留一个「显示已删但还在列表」的半截状态。
|
|
369
|
+
await unarchive()
|
|
370
|
+
return { hidden: false, code: moved.code ?? 'moveFailed', detail: moved.detail ?? '' }
|
|
371
|
+
}
|
|
372
|
+
|
|
373
|
+
/**
|
|
374
|
+
* 回档:先把日志搬回它原来的会话目录,再解除归档。
|
|
375
|
+
*
|
|
376
|
+
* 顺序和隐藏相反:文件先回来,存储层重新列得出它,归档集合再去掉它,
|
|
377
|
+
* 工作区流推一帧,列表里就回到原来的位置(工作区登记自始至终没动过)。
|
|
378
|
+
*
|
|
379
|
+
* 旧版插件(0.1.0 早期)是纯「归档」实现的隐藏,条目里没有 originalDir:
|
|
380
|
+
* 那种条目只需解除归档就能原样回来。
|
|
381
|
+
*/
|
|
382
|
+
async function showSession(entry) {
|
|
383
|
+
const registry = ctx.get('workspaceRegistry')
|
|
384
|
+
const hasFiles = Array.isArray(entry.files) && entry.files.length > 0
|
|
385
|
+
const hasDir = typeof entry.originalDir === 'string' && entry.originalDir !== ''
|
|
386
|
+
|
|
387
|
+
if (hasFiles && hasDir) {
|
|
388
|
+
const restored = await restoreFromTrash(home, entry)
|
|
389
|
+
if (!restored.restored) {
|
|
390
|
+
return { restored: false, code: restored.code ?? 'restoreFailed', detail: restored.detail ?? '' }
|
|
391
|
+
}
|
|
392
|
+
}
|
|
393
|
+
|
|
394
|
+
if (registry !== undefined) {
|
|
395
|
+
try {
|
|
396
|
+
await registry.unarchiveSession(entry.sessionId)
|
|
397
|
+
} catch (error) {
|
|
398
|
+
// 文件已经搬回去了,这个会话在存储层眼里已经回来了;只是归档集合里
|
|
399
|
+
// 还留着一个 id。这种情况必须当成回档成功:否则条目会留在缓冲站里,
|
|
400
|
+
// 到期后巡检会把刚刚救回来的日志再删一遍。
|
|
401
|
+
logger?.warn?.(`dsh-session-manager: 解除归档失败,日志已回位 ${messageOf(error)}`)
|
|
402
|
+
}
|
|
403
|
+
}
|
|
404
|
+
return { restored: true }
|
|
405
|
+
}
|
|
406
|
+
|
|
407
|
+
/** 彻底删除:回收站里的文件真正移除,再把它从工作区登记里摘掉。 */
|
|
408
|
+
async function purgeSession(entry) {
|
|
409
|
+
const sessionId = entry.sessionId
|
|
410
|
+
// 跑着回合就等下一轮:回收站里的文件反正已经不在会话目录了,不急。
|
|
411
|
+
const blockers = liveBlockers(sessionId)
|
|
412
|
+
if (blockers.length > 0) return { done: false, code: 'liveBlocked', detail: blockers.join(',') }
|
|
413
|
+
|
|
414
|
+
// 会话还挂在内存里的话,它可能随时把日志再写出来(回档后又被打开过)。
|
|
415
|
+
// 先归档让它退出内存,等真的退出了再动文件;退不掉就只删回收站里的那份,
|
|
416
|
+
// 剩下的欠账留给下一次巡检。
|
|
417
|
+
let detached = true
|
|
418
|
+
const registry = ctx.get('workspaceRegistry')
|
|
419
|
+
if (registry !== undefined && isLive(sessionId)) {
|
|
420
|
+
try {
|
|
421
|
+
await registry.archiveSession(sessionId, { stopActivity: true })
|
|
422
|
+
} catch {
|
|
423
|
+
// 不在工作区里也算正常
|
|
424
|
+
}
|
|
425
|
+
detached = await waitUntilDetached(sessionId, DETACH_TIMEOUT_MS)
|
|
426
|
+
}
|
|
427
|
+
|
|
428
|
+
// 缓冲站里的会话日志在回收站目录;先删它。
|
|
429
|
+
const purged = await purgeTrash(home, sessionId)
|
|
430
|
+
if (!purged.purged) return { done: false, code: purged.code ?? 'purgeFailed', detail: purged.detail ?? '' }
|
|
431
|
+
|
|
432
|
+
// 还在内存里就别动会话目录:文件可能正被持有,删了会写出一个已 unlink 的 inode。
|
|
433
|
+
if (!detached) return { done: true, note: 'deferred' }
|
|
434
|
+
|
|
435
|
+
// 万一日志还在会话目录里(回档失败、或当初根本没找到文件),也清一遍。
|
|
436
|
+
const located = await locateSessionLog(sessionId)
|
|
437
|
+
if (located.file !== undefined) {
|
|
438
|
+
const removal = await removeFilesAt(located.file, sessionId)
|
|
439
|
+
if (!removal.done) return removal
|
|
440
|
+
}
|
|
441
|
+
|
|
442
|
+
if (registry !== undefined) {
|
|
443
|
+
// 先摘掉工作区登记(会话记录还读得到,这一步会检查它存在),
|
|
444
|
+
// 再撤销归档:顺序反了的话登记录取不到会话就会被跳过,留下一条孤儿。
|
|
445
|
+
let detachedFromAll = true
|
|
446
|
+
for (const workspace of registry.list?.() ?? []) {
|
|
447
|
+
if (!workspace.sessionIds.includes(sessionId)) continue
|
|
448
|
+
try {
|
|
449
|
+
await workspace.detachSession(sessionId)
|
|
450
|
+
} catch (error) {
|
|
451
|
+
// 摘不掉就会留下一条指向已删日志的「日志缺失」行,必须让条目留在
|
|
452
|
+
// 缓冲站里继续重试,不能报告成功。
|
|
453
|
+
detachedFromAll = false
|
|
454
|
+
logger?.warn?.(`dsh-session-manager: 解除工作区归属失败 ${messageOf(error)}`)
|
|
455
|
+
}
|
|
456
|
+
}
|
|
457
|
+
if (!detachedFromAll) return { done: false, code: 'detachFailed' }
|
|
458
|
+
try {
|
|
459
|
+
await registry.unarchiveSession(sessionId)
|
|
460
|
+
} catch {
|
|
461
|
+
// 不在归档集合里就什么都不用做
|
|
462
|
+
}
|
|
463
|
+
}
|
|
464
|
+
return { done: true }
|
|
465
|
+
}
|
|
466
|
+
|
|
467
|
+
/**
|
|
468
|
+
* 删掉某条日志所在目录里的会话文件:只在彻底删除时用。
|
|
469
|
+
*
|
|
470
|
+
* 只删**确认属于这个会话**的文件。会话目录的约定是
|
|
471
|
+
* `<sessions>/<编码后的 cwd>/<sessionId>/`,所以目录名必须逐字等于会话 id。
|
|
472
|
+
* 目录名对不上(存储层改了布局、或者路径是拼出来的)就只删 `location.path`
|
|
473
|
+
* 指的那一个文件,绝不按前缀批量删——那样会连带删掉别人的日志。
|
|
474
|
+
*/
|
|
475
|
+
async function removeFilesAt(file, sessionId) {
|
|
476
|
+
const directory = path.dirname(file)
|
|
477
|
+
const ownsDirectory = path.basename(directory) === sessionId
|
|
478
|
+
if (!ownsDirectory) {
|
|
479
|
+
try {
|
|
480
|
+
await unlink(file)
|
|
481
|
+
} catch (error) {
|
|
482
|
+
if (isMissing(error)) return { done: true }
|
|
483
|
+
return { done: false, code: 'unlinkFailed', detail: messageOf(error) }
|
|
484
|
+
}
|
|
485
|
+
return { done: true }
|
|
486
|
+
}
|
|
487
|
+
let entries
|
|
488
|
+
try {
|
|
489
|
+
entries = await readdir(directory, { withFileTypes: true })
|
|
490
|
+
} catch (error) {
|
|
491
|
+
if (isMissing(error)) return { done: true }
|
|
492
|
+
return { done: false, code: 'readdirFailed', detail: messageOf(error) }
|
|
493
|
+
}
|
|
494
|
+
for (const entry of entries) {
|
|
495
|
+
if (!entry.isFile()) continue
|
|
496
|
+
if (!entry.name.startsWith('session.')) continue
|
|
497
|
+
try {
|
|
498
|
+
await unlink(path.join(directory, entry.name))
|
|
499
|
+
} catch (error) {
|
|
500
|
+
if (isMissing(error)) continue
|
|
501
|
+
return { done: false, code: 'unlinkFailed', detail: `${entry.name}:${messageOf(error)}` }
|
|
502
|
+
}
|
|
503
|
+
}
|
|
504
|
+
try {
|
|
505
|
+
await rmdir(directory)
|
|
506
|
+
} catch {
|
|
507
|
+
// ENOTEMPTY / ENOENT 都无所谓
|
|
508
|
+
}
|
|
509
|
+
return { done: true }
|
|
510
|
+
}
|
|
511
|
+
|
|
512
|
+
/**
|
|
513
|
+
* 把「进了缓冲站但文件还没搬走」的条目补搬一次。
|
|
514
|
+
*
|
|
515
|
+
* 两种情况会留下这种条目:
|
|
516
|
+
* - 删除时那个会话还开着(当前正在看的那个),先只归档、文件等它退出内存再搬;
|
|
517
|
+
* - 早期版本用纯归档实现隐藏,条目里根本没有 originalDir。
|
|
518
|
+
* 已经搬好的条目直接返回,stat 不到文件的也直接返回。
|
|
519
|
+
*/
|
|
520
|
+
async function adoptLegacyEntry(entry) {
|
|
521
|
+
const hasFiles = Array.isArray(entry.files) && entry.files.length > 0
|
|
522
|
+
const hasDir = typeof entry.originalDir === 'string' && entry.originalDir !== ''
|
|
523
|
+
if (hasFiles && hasDir) return entry
|
|
524
|
+
|
|
525
|
+
// 还活着就等下次:日志可能还要被追加。
|
|
526
|
+
if (isLive(entry.sessionId)) return entry
|
|
527
|
+
|
|
528
|
+
const located = await locateSessionLog(entry.sessionId)
|
|
529
|
+
if (located.file === undefined) return entry
|
|
530
|
+
const moved = await moveIntoTrash(home, entry.sessionId, located.file)
|
|
531
|
+
if (!moved.moved) return entry
|
|
532
|
+
return { ...entry, originalDir: moved.originalDir, files: moved.files, pending: false, note: '', noteDetail: '' }
|
|
533
|
+
}
|
|
534
|
+
|
|
535
|
+
/**
|
|
536
|
+
* 清掉已经不存在的会话的锁。
|
|
537
|
+
*
|
|
538
|
+
* 锁是按会话 id 记的,会话删掉之后 id 就再也不会出现,锁会一直占着
|
|
539
|
+
* state.json。这不是正确性问题,但状态文件会越攒越脏,用户也没法自己清。
|
|
540
|
+
* 只在「确实读到了会话清单」的时候清:清单读失败或者为空(存储层还没起来)
|
|
541
|
+
* 的时候什么都不动,免得把有效的锁误删。
|
|
542
|
+
*/
|
|
543
|
+
async function pruneLocks(state) {
|
|
544
|
+
if (state.locks.length === 0) return state
|
|
545
|
+
let known
|
|
546
|
+
try {
|
|
547
|
+
known = new Set((await readSummaries()).map((summary) => summary.sessionId))
|
|
548
|
+
} catch {
|
|
549
|
+
return state
|
|
550
|
+
}
|
|
551
|
+
if (known.size === 0) return state
|
|
552
|
+
// 工作区里登记着但读不到日志的会话也算存在(页面上它们还有一行)。
|
|
553
|
+
const registry = ctx.get('workspaceRegistry')
|
|
554
|
+
for (const workspace of registry?.list?.() ?? []) {
|
|
555
|
+
for (const sessionId of workspace.sessionIds) known.add(sessionId)
|
|
556
|
+
}
|
|
557
|
+
for (const entry of state.buffer) known.add(entry.sessionId)
|
|
558
|
+
const locks = state.locks.filter((sessionId) => known.has(sessionId))
|
|
559
|
+
if (locks.length === state.locks.length) return state
|
|
560
|
+
return { ...state, locks }
|
|
561
|
+
}
|
|
562
|
+
|
|
563
|
+
/** 巡检缓冲站:到期的条目彻底删除,删不掉的标记成 pending 下次再试。 */
|
|
564
|
+
function sweep() {
|
|
565
|
+
return serialize(async () => {
|
|
566
|
+
const stored = readState(home)
|
|
567
|
+
const state = await pruneLocks(stored)
|
|
568
|
+
// 锁被清过也算状态变了,必须落盘,否则下次读回来还是一堆死锁。
|
|
569
|
+
const locksChanged = state.locks.length !== stored.locks.length
|
|
570
|
+
if (state.buffer.length === 0) {
|
|
571
|
+
return locksChanged ? writeState(home, state) : state
|
|
572
|
+
}
|
|
573
|
+
const now = Date.now()
|
|
574
|
+
// 每条都先补搬一次:推迟搬运的条目一旦退出内存就能搬了。
|
|
575
|
+
let buffer = []
|
|
576
|
+
let adopted = false
|
|
577
|
+
for (const entry of state.buffer) {
|
|
578
|
+
let current = entry
|
|
579
|
+
try {
|
|
580
|
+
current = await adoptLegacyEntry(entry)
|
|
581
|
+
} catch (error) {
|
|
582
|
+
logger?.warn?.(`dsh-session-manager: 补搬缓冲站条目失败 ${messageOf(error)}`)
|
|
583
|
+
}
|
|
584
|
+
if (current !== entry) adopted = true
|
|
585
|
+
buffer.push(current)
|
|
586
|
+
}
|
|
587
|
+
|
|
588
|
+
const due = buffer.filter((entry) => entry.expiresAt <= now)
|
|
589
|
+
if (due.length === 0) {
|
|
590
|
+
if (!adopted && !locksChanged) return state
|
|
591
|
+
return writeState(home, { ...state, buffer })
|
|
592
|
+
}
|
|
593
|
+
let changed = adopted
|
|
594
|
+
for (const entry of due) {
|
|
595
|
+
// 上面已经补搬过了,直接走删除流程。
|
|
596
|
+
const current = buffer.find((item) => item.sessionId === entry.sessionId) ?? entry
|
|
597
|
+
let result
|
|
598
|
+
try {
|
|
599
|
+
result = await purgeSession(current)
|
|
600
|
+
} catch (error) {
|
|
601
|
+
result = { done: false, code: 'purgeFailed', detail: messageOf(error) }
|
|
602
|
+
}
|
|
603
|
+
changed = true
|
|
604
|
+
const index = buffer.findIndex((item) => item.sessionId === entry.sessionId)
|
|
605
|
+
if (index === -1) continue
|
|
606
|
+
if (result.done) {
|
|
607
|
+
buffer.splice(index, 1)
|
|
608
|
+
logger?.info?.(`dsh-session-manager: 已彻底删除会话 ${entry.sessionId}`)
|
|
609
|
+
} else {
|
|
610
|
+
const code = result.code ?? 'purgeFailed'
|
|
611
|
+
const detail = result.detail ?? ''
|
|
612
|
+
buffer[index] = { ...current, pending: true, note: code, noteDetail: detail }
|
|
613
|
+
// 每分钟都会重试;只有原因变了才再记一条,免得刷屏。
|
|
614
|
+
if (entry.note !== code || entry.pending !== true) {
|
|
615
|
+
logger?.warn?.(`dsh-session-manager: 会话 ${entry.sessionId} 暂时删不掉(${code} ${detail})`)
|
|
616
|
+
}
|
|
617
|
+
}
|
|
618
|
+
}
|
|
619
|
+
if (!changed && !locksChanged) return state
|
|
620
|
+
return writeState(home, { ...state, buffer })
|
|
621
|
+
})
|
|
622
|
+
}
|
|
623
|
+
|
|
624
|
+
// 路由统一用错误码回话,界面按当前语言翻译;只有真正意外的异常才带原始消息。
|
|
625
|
+
const routes = [
|
|
626
|
+
{
|
|
627
|
+
path: `${ROUTE_PREFIX}/state`,
|
|
628
|
+
handler: async (request, response) => {
|
|
629
|
+
if (!isLoopbackRequest(request)) return writeJson(response, 403, { ok: false, code: 'notLoopback' })
|
|
630
|
+
try {
|
|
631
|
+
// 每次打开页面都巡检一次:补搬推迟的条目、清掉到期的条目。
|
|
632
|
+
await sweep()
|
|
633
|
+
writeJson(response, 200, await readView())
|
|
634
|
+
} catch (error) {
|
|
635
|
+
writeJson(response, 500, { ok: false, code: 'readFailed', error: messageOf(error) })
|
|
636
|
+
}
|
|
637
|
+
},
|
|
638
|
+
},
|
|
639
|
+
{
|
|
640
|
+
path: `${ROUTE_PREFIX}/settings`,
|
|
641
|
+
handler: async (request, response) => {
|
|
642
|
+
if (!isLoopbackRequest(request)) return writeJson(response, 403, { ok: false, code: 'notLoopback' })
|
|
643
|
+
const body = await readJsonBody(request)
|
|
644
|
+
if (body === undefined) return writeJson(response, 400, { ok: false, code: 'badBody' })
|
|
645
|
+
if (body.reset === true || body.bufferHours !== undefined) {
|
|
646
|
+
// 只收真正的数字。`Number(null)`、`Number('')`、`Number([])` 都是 0,
|
|
647
|
+
// 而 0 意味着「确认后立即彻底删除」——绝不能因为一个畸形请求就静默打开它。
|
|
648
|
+
let hours
|
|
649
|
+
if (body.reset === true) {
|
|
650
|
+
hours = DEFAULTS.bufferHours
|
|
651
|
+
} else {
|
|
652
|
+
const raw = body.bufferHours
|
|
653
|
+
if (typeof raw !== 'number' || !Number.isFinite(raw)) {
|
|
654
|
+
return writeJson(response, 400, { ok: false, code: 'badNumber' })
|
|
655
|
+
}
|
|
656
|
+
const limit = LIMITS.bufferHours
|
|
657
|
+
const rounded = Math.round(raw)
|
|
658
|
+
if (rounded < limit.min || rounded > limit.max) {
|
|
659
|
+
return writeJson(response, 400, { ok: false, code: 'outOfRange' })
|
|
660
|
+
}
|
|
661
|
+
hours = rounded
|
|
662
|
+
}
|
|
663
|
+
try {
|
|
664
|
+
const saved = await serialize(async () => {
|
|
665
|
+
const state = readState(home)
|
|
666
|
+
const written = writeState(home, { ...state, settings: { ...state.settings, bufferHours: hours } })
|
|
667
|
+
return written.settings
|
|
668
|
+
})
|
|
669
|
+
logger?.info?.(`dsh-session-manager: 缓冲时长 = ${saved.bufferHours} 小时`)
|
|
670
|
+
} catch (error) {
|
|
671
|
+
return writeJson(response, 500, { ok: false, code: 'saveFailed', error: messageOf(error) })
|
|
672
|
+
}
|
|
673
|
+
}
|
|
674
|
+
try {
|
|
675
|
+
writeJson(response, 200, await readView())
|
|
676
|
+
} catch (error) {
|
|
677
|
+
writeJson(response, 500, { ok: false, code: 'readFailed', error: messageOf(error) })
|
|
678
|
+
}
|
|
679
|
+
},
|
|
680
|
+
},
|
|
681
|
+
{
|
|
682
|
+
path: `${ROUTE_PREFIX}/lock`,
|
|
683
|
+
handler: async (request, response) => {
|
|
684
|
+
if (!isLoopbackRequest(request)) return writeJson(response, 403, { ok: false, code: 'notLoopback' })
|
|
685
|
+
const body = await readJsonBody(request)
|
|
686
|
+
if (body === undefined) return writeJson(response, 400, { ok: false, code: 'badBody' })
|
|
687
|
+
const sessionId = typeof body.sessionId === 'string' ? body.sessionId : ''
|
|
688
|
+
if (sessionId === '') return writeJson(response, 400, { ok: false, code: 'badBody' })
|
|
689
|
+
const locked = body.locked === true
|
|
690
|
+
try {
|
|
691
|
+
await serialize(async () => {
|
|
692
|
+
const state = readState(home)
|
|
693
|
+
const others = state.locks.filter((id) => id !== sessionId)
|
|
694
|
+
writeState(home, { ...state, locks: locked ? [sessionId, ...others] : others })
|
|
695
|
+
})
|
|
696
|
+
} catch (error) {
|
|
697
|
+
return writeJson(response, 500, { ok: false, code: 'saveFailed', error: messageOf(error) })
|
|
698
|
+
}
|
|
699
|
+
try {
|
|
700
|
+
writeJson(response, 200, await readView())
|
|
701
|
+
} catch (error) {
|
|
702
|
+
writeJson(response, 500, { ok: false, code: 'readFailed', error: messageOf(error) })
|
|
703
|
+
}
|
|
704
|
+
},
|
|
705
|
+
},
|
|
706
|
+
{
|
|
707
|
+
path: `${ROUTE_PREFIX}/delete`,
|
|
708
|
+
handler: async (request, response) => {
|
|
709
|
+
if (!isLoopbackRequest(request)) return writeJson(response, 403, { ok: false, code: 'notLoopback' })
|
|
710
|
+
const body = await readJsonBody(request)
|
|
711
|
+
if (body === undefined) return writeJson(response, 400, { ok: false, code: 'badBody' })
|
|
712
|
+
const sessionId = typeof body.sessionId === 'string' ? body.sessionId : ''
|
|
713
|
+
if (sessionId === '') return writeJson(response, 400, { ok: false, code: 'badBody' })
|
|
714
|
+
|
|
715
|
+
try {
|
|
716
|
+
const outcome = await serialize(async () => {
|
|
717
|
+
const state = readState(home)
|
|
718
|
+
if (state.locks.includes(sessionId)) return { ok: false, code: 'locked' }
|
|
719
|
+
if (state.buffer.some((entry) => entry.sessionId === sessionId)) {
|
|
720
|
+
return { ok: false, code: 'alreadyBuffered' }
|
|
721
|
+
}
|
|
722
|
+
const hours = state.settings.bufferHours
|
|
723
|
+
const deletedAt = Date.now()
|
|
724
|
+
// 先把日志搬进回收站:搬完这个会话就从列表里彻底消失了。
|
|
725
|
+
// 搬不动(会话开着 / 目录动不了)就不写缓冲站,免得出现「显示已删但还在列表」。
|
|
726
|
+
const hidden = await hideSession(sessionId)
|
|
727
|
+
if (!hidden.hidden) {
|
|
728
|
+
return { ok: false, code: hidden.code ?? 'moveFailed', detail: hidden.detail ?? '' }
|
|
729
|
+
}
|
|
730
|
+
const written = writeState(home, {
|
|
731
|
+
...state,
|
|
732
|
+
buffer: [
|
|
733
|
+
{
|
|
734
|
+
sessionId,
|
|
735
|
+
title: typeof body.title === 'string' ? body.title : '',
|
|
736
|
+
workspaceId: typeof body.workspaceId === 'string' ? body.workspaceId : '',
|
|
737
|
+
workspaceTitle: typeof body.workspaceTitle === 'string' ? body.workspaceTitle : '',
|
|
738
|
+
deletedAt,
|
|
739
|
+
expiresAt: deletedAt + hours * 3_600_000,
|
|
740
|
+
originalDir: hidden.originalDir ?? '',
|
|
741
|
+
files: hidden.files ?? [],
|
|
742
|
+
pending: false,
|
|
743
|
+
note: '',
|
|
744
|
+
noteDetail: '',
|
|
745
|
+
},
|
|
746
|
+
...state.buffer,
|
|
747
|
+
],
|
|
748
|
+
})
|
|
749
|
+
if (hours === 0) {
|
|
750
|
+
// 缓冲时长为 0:确认后立刻彻底删除。
|
|
751
|
+
const entry = written.buffer.find((item) => item.sessionId === sessionId)
|
|
752
|
+
const purged = await purgeSession(entry)
|
|
753
|
+
if (!purged.done) {
|
|
754
|
+
const kept = written.buffer.map((item) =>
|
|
755
|
+
item.sessionId === sessionId
|
|
756
|
+
? { ...item, pending: true, note: purged.code ?? 'purgeFailed', noteDetail: purged.detail ?? '' }
|
|
757
|
+
: item,
|
|
758
|
+
)
|
|
759
|
+
writeState(home, { ...written, buffer: kept })
|
|
760
|
+
return { ok: true, purged: false, code: purged.code ?? 'purgeFailed' }
|
|
761
|
+
}
|
|
762
|
+
writeState(home, {
|
|
763
|
+
...written,
|
|
764
|
+
buffer: written.buffer.filter((item) => item.sessionId !== sessionId),
|
|
765
|
+
})
|
|
766
|
+
return { ok: true, purged: true }
|
|
767
|
+
}
|
|
768
|
+
return { ok: true, purged: false }
|
|
769
|
+
})
|
|
770
|
+
if (outcome.ok === false) return writeJson(response, 200, outcome)
|
|
771
|
+
writeJson(response, 200, { ...outcome, view: await readViewSafely() })
|
|
772
|
+
} catch (error) {
|
|
773
|
+
writeJson(response, 500, { ok: false, code: 'deleteFailed', error: messageOf(error) })
|
|
774
|
+
}
|
|
775
|
+
},
|
|
776
|
+
},
|
|
777
|
+
{
|
|
778
|
+
path: `${ROUTE_PREFIX}/restore`,
|
|
779
|
+
handler: async (request, response) => {
|
|
780
|
+
if (!isLoopbackRequest(request)) return writeJson(response, 403, { ok: false, code: 'notLoopback' })
|
|
781
|
+
const body = await readJsonBody(request)
|
|
782
|
+
if (body === undefined) return writeJson(response, 400, { ok: false, code: 'badBody' })
|
|
783
|
+
const sessionId = typeof body.sessionId === 'string' ? body.sessionId : ''
|
|
784
|
+
if (sessionId === '') return writeJson(response, 400, { ok: false, code: 'badBody' })
|
|
785
|
+
try {
|
|
786
|
+
const outcome = await serialize(async () => {
|
|
787
|
+
const state = readState(home)
|
|
788
|
+
const entry = state.buffer.find((item) => item.sessionId === sessionId)
|
|
789
|
+
if (entry === undefined) {
|
|
790
|
+
return { ok: false, code: 'notBuffered' }
|
|
791
|
+
}
|
|
792
|
+
const restored = await showSession(entry)
|
|
793
|
+
if (!restored.restored) {
|
|
794
|
+
return { ok: false, code: restored.code ?? 'restoreFailed', detail: restored.detail ?? '' }
|
|
795
|
+
}
|
|
796
|
+
writeState(home, { ...state, buffer: state.buffer.filter((item) => item.sessionId !== sessionId) })
|
|
797
|
+
return { ok: true }
|
|
798
|
+
})
|
|
799
|
+
if (outcome.ok === false) return writeJson(response, 200, outcome)
|
|
800
|
+
// 回档已经落库(文件搬回来了、条目也从缓冲站移走了),读视图失败
|
|
801
|
+
// 不能再盖成 500:界面会报「回档失败」,而实际上会话已经回来了。
|
|
802
|
+
writeJson(response, 200, { ...outcome, view: await readViewSafely() })
|
|
803
|
+
} catch (error) {
|
|
804
|
+
writeJson(response, 500, { ok: false, code: 'restoreFailed', error: messageOf(error) })
|
|
805
|
+
}
|
|
806
|
+
},
|
|
807
|
+
},
|
|
808
|
+
{
|
|
809
|
+
// 缓冲站里「彻底删除」:前面已经二次确认过了,这里不再确认。
|
|
810
|
+
path: `${ROUTE_PREFIX}/purge`,
|
|
811
|
+
handler: async (request, response) => {
|
|
812
|
+
if (!isLoopbackRequest(request)) return writeJson(response, 403, { ok: false, code: 'notLoopback' })
|
|
813
|
+
const body = await readJsonBody(request)
|
|
814
|
+
if (body === undefined) return writeJson(response, 400, { ok: false, code: 'badBody' })
|
|
815
|
+
const sessionId = typeof body.sessionId === 'string' ? body.sessionId : ''
|
|
816
|
+
if (sessionId === '') return writeJson(response, 400, { ok: false, code: 'badBody' })
|
|
817
|
+
try {
|
|
818
|
+
const outcome = await serialize(async () => {
|
|
819
|
+
const state = readState(home)
|
|
820
|
+
const entry = state.buffer.find((item) => item.sessionId === sessionId)
|
|
821
|
+
if (entry === undefined) return { ok: false, code: 'notBuffered' }
|
|
822
|
+
const purged = await purgeSession(entry)
|
|
823
|
+
if (!purged.done) {
|
|
824
|
+
const kept = state.buffer.map((item) =>
|
|
825
|
+
item.sessionId === sessionId
|
|
826
|
+
? { ...item, pending: true, note: purged.code ?? 'purgeFailed', noteDetail: purged.detail ?? '' }
|
|
827
|
+
: item,
|
|
828
|
+
)
|
|
829
|
+
writeState(home, { ...state, buffer: kept })
|
|
830
|
+
return { ok: false, code: purged.code ?? 'purgeFailed', detail: purged.detail ?? '' }
|
|
831
|
+
}
|
|
832
|
+
writeState(home, { ...state, buffer: state.buffer.filter((item) => item.sessionId !== sessionId) })
|
|
833
|
+
return { ok: true }
|
|
834
|
+
})
|
|
835
|
+
if (outcome.ok === false) return writeJson(response, 200, { ...outcome, view: await readViewSafely() })
|
|
836
|
+
// 删除已经落盘成功了,重新读列表失败不能再把结果盖成 500,
|
|
837
|
+
// 否则用户看到「删除失败」而实际已删,重试还会撞上 notBuffered。
|
|
838
|
+
writeJson(response, 200, { ...outcome, view: await readViewSafely() })
|
|
839
|
+
} catch (error) {
|
|
840
|
+
writeJson(response, 500, { ok: false, code: 'purgeFailed', error: messageOf(error) })
|
|
841
|
+
}
|
|
842
|
+
},
|
|
843
|
+
},
|
|
844
|
+
{
|
|
845
|
+
/**
|
|
846
|
+
* 归位:「未分组」里的会话按 cwd 挂回它本来属于的工作区。
|
|
847
|
+
*
|
|
848
|
+
* DSH 的工作区补登记只在启动时按目录归并一次,之后新建的会话不会被收进去,
|
|
849
|
+
* 于是左侧就多出「未分组」一栏。工作区的 `attachSession` 会自己校验 cwd
|
|
850
|
+
* 必须解析到该工作区目录,所以这里不用重复判断,交给它拒绝。
|
|
851
|
+
*/
|
|
852
|
+
path: `${ROUTE_PREFIX}/adopt`,
|
|
853
|
+
handler: async (request, response) => {
|
|
854
|
+
if (!isLoopbackRequest(request)) return writeJson(response, 403, { ok: false, code: 'notLoopback' })
|
|
855
|
+
const body = await readJsonBody(request)
|
|
856
|
+
if (body === undefined) return writeJson(response, 400, { ok: false, code: 'badBody' })
|
|
857
|
+
const sessionId = typeof body.sessionId === 'string' ? body.sessionId : ''
|
|
858
|
+
if (sessionId === '') return writeJson(response, 400, { ok: false, code: 'badBody' })
|
|
859
|
+
const registry = ctx.get('workspaceRegistry')
|
|
860
|
+
if (registry === undefined) return writeJson(response, 500, { ok: false, code: 'noRegistry' })
|
|
861
|
+
try {
|
|
862
|
+
const outcome = await serialize(async () => {
|
|
863
|
+
const header = await readSessionHeader(sessionId)
|
|
864
|
+
if (header === undefined) return { ok: false, code: 'noHeader' }
|
|
865
|
+
const cwd = typeof header.cwd === 'string' ? header.cwd : ''
|
|
866
|
+
if (cwd === '') return { ok: false, code: 'noCwd' }
|
|
867
|
+
const target = (registry.list?.() ?? []).find((workspace) => workspace.path === cwd)
|
|
868
|
+
if (target === undefined) return { ok: false, code: 'noWorkspaceForCwd' }
|
|
869
|
+
await target.attachSession(sessionId)
|
|
870
|
+
return { ok: true, workspaceId: target.id }
|
|
871
|
+
})
|
|
872
|
+
if (outcome.ok === false) return writeJson(response, 200, outcome)
|
|
873
|
+
// 归位已经落库,读视图失败不能再把它盖成 500:界面会提示失败,
|
|
874
|
+
// 用户再点一次就重复登记同一个会话。读不到就只回成功和落点。
|
|
875
|
+
writeJson(response, 200, { ...outcome, view: await readViewSafely() })
|
|
876
|
+
} catch (error) {
|
|
877
|
+
writeJson(response, 500, { ok: false, code: 'adoptFailed', error: messageOf(error) })
|
|
878
|
+
}
|
|
879
|
+
},
|
|
880
|
+
},
|
|
881
|
+
]
|
|
882
|
+
|
|
883
|
+
ctx.effect(() => {
|
|
884
|
+
// 兜底一层:任何 handler 里漏网的异常都收成 500,绝不让它变成
|
|
885
|
+
// 没人接管的 promise rejection 把宿主进程拖下水。
|
|
886
|
+
const guard = (handler) => async (request, response) => {
|
|
887
|
+
try {
|
|
888
|
+
await handler(request, response)
|
|
889
|
+
} catch (error) {
|
|
890
|
+
logger?.warn?.(`dsh-session-manager: 路由异常 ${messageOf(error)}`)
|
|
891
|
+
if (!response.headersSent) {
|
|
892
|
+
writeJson(response, 500, { ok: false, code: 'internal', error: messageOf(error) })
|
|
893
|
+
} else {
|
|
894
|
+
try {
|
|
895
|
+
response.end()
|
|
896
|
+
} catch {
|
|
897
|
+
// 连接已经没了
|
|
898
|
+
}
|
|
899
|
+
}
|
|
900
|
+
}
|
|
901
|
+
}
|
|
902
|
+
const disposers = routes.map((route) =>
|
|
903
|
+
ctx.webServer.register({ kind: 'exact', path: route.path, handler: guard(route.handler) }),
|
|
904
|
+
)
|
|
905
|
+
return () => {
|
|
906
|
+
for (const dispose of disposers) {
|
|
907
|
+
try {
|
|
908
|
+
dispose()
|
|
909
|
+
} catch {
|
|
910
|
+
// 已经随作用域一起释放了
|
|
911
|
+
}
|
|
912
|
+
}
|
|
913
|
+
}
|
|
914
|
+
}, 'dsh-session-manager: settings routes')
|
|
915
|
+
|
|
916
|
+
// 启动时先巡检一次(补搬推迟的条目 + 清欠账),然后每分钟一次。
|
|
917
|
+
ctx.effect(() => {
|
|
918
|
+
let stopped = false
|
|
919
|
+
const tick = () => {
|
|
920
|
+
if (stopped) return
|
|
921
|
+
void sweep().catch((error) => logger?.warn?.(`dsh-session-manager: 巡检失败 ${messageOf(error)}`))
|
|
922
|
+
}
|
|
923
|
+
const timer = setTimeout(tick, 2_000)
|
|
924
|
+
const interval = setInterval(tick, TICK_MS)
|
|
925
|
+
interval.unref?.()
|
|
926
|
+
return () => {
|
|
927
|
+
stopped = true
|
|
928
|
+
clearTimeout(timer)
|
|
929
|
+
clearInterval(interval)
|
|
930
|
+
}
|
|
931
|
+
}, 'dsh-session-manager: recycle sweeper')
|
|
932
|
+
|
|
933
|
+
logger?.info?.(`dsh-session-manager: 设置路由挂在 ${ROUTE_PREFIX},状态文件 ${stateFile(home)}`)
|
|
934
|
+
}
|
|
935
|
+
|
|
936
|
+
// -------------------------------------------------------------------- helpers
|
|
937
|
+
|
|
938
|
+
function messageOf(error) {
|
|
939
|
+
return error instanceof Error ? error.message : String(error)
|
|
940
|
+
}
|
|
941
|
+
|
|
942
|
+
function delay(ms) {
|
|
943
|
+
return new Promise((resolve) => {
|
|
944
|
+
const timer = setTimeout(resolve, ms)
|
|
945
|
+
timer.unref?.()
|
|
946
|
+
})
|
|
947
|
+
}
|
|
948
|
+
|
|
949
|
+
function isMissing(error) {
|
|
950
|
+
return error instanceof Error && ['ENOENT', 'ENOTDIR'].includes(/** @type {NodeJS.ErrnoException} */ (error).code)
|
|
951
|
+
}
|
|
952
|
+
|
|
953
|
+
/**
|
|
954
|
+
* 只放行本机页面发来的请求。
|
|
955
|
+
*
|
|
956
|
+
* 三层检查缺一不可:socket 地址保证是回环、Host 头保证不是 DNS 重绑定的域名、
|
|
957
|
+
* `sec-fetch-site` 保证不是别的站点发起的跨站请求。最后一条只排除 `cross-site`
|
|
958
|
+
* 是不够的:`localhost` 其它端口上的本地 dev server 发来的是 `same-site`,
|
|
959
|
+
* 而服务端并不看 `content-type`,一个 `no-cors` + `text/plain` 的请求就能
|
|
960
|
+
* 把合法 JSON 打进 `/delete`。所以这里改成白名单:只认本页面自己发起的请求。
|
|
961
|
+
*/
|
|
962
|
+
function isLoopbackRequest(request) {
|
|
963
|
+
const address = request.socket?.remoteAddress
|
|
964
|
+
if (address !== '127.0.0.1' && address !== '::1' && address !== '::ffff:127.0.0.1') return false
|
|
965
|
+
const host = request.headers?.host
|
|
966
|
+
if (typeof host !== 'string') return false
|
|
967
|
+
let hostname
|
|
968
|
+
try {
|
|
969
|
+
hostname = new URL(`http://${host}`).hostname
|
|
970
|
+
} catch {
|
|
971
|
+
return false
|
|
972
|
+
}
|
|
973
|
+
if (hostname !== '127.0.0.1' && hostname !== 'localhost' && hostname !== '[::1]') return false
|
|
974
|
+
const site = request.headers?.['sec-fetch-site']
|
|
975
|
+
// `none` 是地址栏直接打开,`same-origin` 是同源页面;浏览器不发这个头时
|
|
976
|
+
// 也放行(非浏览器客户端),真正的门槛是上面的回环 + Host 检查。
|
|
977
|
+
if (site !== undefined && site !== 'same-origin' && site !== 'none') return false
|
|
978
|
+
return true
|
|
979
|
+
}
|
|
980
|
+
|
|
981
|
+
function writeJson(response, statusCode, body) {
|
|
982
|
+
const payload = JSON.stringify(body)
|
|
983
|
+
response.writeHead(statusCode, {
|
|
984
|
+
'content-type': 'application/json; charset=utf-8',
|
|
985
|
+
'cache-control': 'no-store',
|
|
986
|
+
'referrer-policy': 'no-referrer',
|
|
987
|
+
})
|
|
988
|
+
response.end(payload)
|
|
989
|
+
}
|
|
990
|
+
|
|
991
|
+
async function readJsonBody(request) {
|
|
992
|
+
const chunks = []
|
|
993
|
+
let size = 0
|
|
994
|
+
try {
|
|
995
|
+
for await (const chunk of request) {
|
|
996
|
+
size += chunk.length
|
|
997
|
+
if (size > MAX_BODY_BYTES) return undefined
|
|
998
|
+
chunks.push(chunk)
|
|
999
|
+
}
|
|
1000
|
+
} catch {
|
|
1001
|
+
// 客户端中途断开时流会抛 ERR_STREAM_PREMATURE_CLOSE;当成坏请求处理,
|
|
1002
|
+
// 不能让它变成没人接管的 promise rejection。
|
|
1003
|
+
return undefined
|
|
1004
|
+
}
|
|
1005
|
+
if (size === 0) return {}
|
|
1006
|
+
try {
|
|
1007
|
+
const parsed = JSON.parse(Buffer.concat(chunks).toString('utf8'))
|
|
1008
|
+
return parsed !== null && typeof parsed === 'object' ? parsed : {}
|
|
1009
|
+
} catch {
|
|
1010
|
+
return undefined
|
|
1011
|
+
}
|
|
1012
|
+
}
|