@ceasarxuu/dsh-maid 0.0.0-stage → 0.1.16

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.
@@ -0,0 +1,491 @@
1
+ import { randomUUID } from 'node:crypto'
2
+ import { InputError, required } from './store.js'
3
+
4
+ const CONCURRENCY = 3
5
+ const DELIVERY_RETRIES = 2
6
+ const STANDARD_PRESET = 'standard'
7
+ const now = () => Date.now()
8
+ const sessionId = () => 'session-' + randomUUID()
9
+ const textContent = content => content.filter(block => block.type === 'text').map(block => block.text).join('\n')
10
+ const job = (target, text, mode = 'queue', id = randomUUID()) =>
11
+ ({ id, target, text, mode, at: now(), delivered: false, error: '' })
12
+ const addEvent = (task, text) => task.history.push({ id: randomUUID(), at: now(), text })
13
+ const addNotice = (task, kind, text) => {
14
+ task.notices ??= []
15
+ task.notices.push({ id: randomUUID(), at: now(), text, taskId: task.id, kind })
16
+ }
17
+
18
+ export function createRuntime(ctx, { store, persona, memory }) {
19
+ const main = store.read().sessionId
20
+ const closing = new AbortController()
21
+ const active = new Map()
22
+ const callbacks = new Set()
23
+ const opening = new Map()
24
+ let driving = false
25
+ let timer
26
+ let schedules
27
+
28
+ function background(operation, label) {
29
+ if (closing.signal.aborted) return
30
+ const pending = Promise.resolve().then(operation).catch(error => ctx.logger?.warn('Maid ' + label + ': ' + error.message))
31
+ callbacks.add(pending)
32
+ void pending.finally(() => callbacks.delete(pending))
33
+ }
34
+
35
+ function workspaces() {
36
+ return ctx.workspaceRegistry.list().map(item => ({ id: item.id, title: item.title || item.path }))
37
+ }
38
+
39
+ function belongs(id) {
40
+ return id === main || store.read().tasks.some(task => task.sessionId === id)
41
+ }
42
+
43
+ async function workspaceSessions(id, signal) {
44
+ const workspace = ctx.workspaceRegistry.get(id)
45
+ if (!workspace) throw new InputError('找不到所选项目。')
46
+ const members = new Set(workspace.sessionIds)
47
+ const { items } = await ctx.sessionController.list({}, signal)
48
+ return items.filter(item => members.has(item.sessionId) && !item.blank).slice(0, 50).map(item => ({
49
+ id: item.sessionId, title: item.projections?.values.title ?? item.sessionId,
50
+ status: item.running ? 'running' : item.agentAvailable ? 'idle' : 'inactive',
51
+ }))
52
+ }
53
+
54
+ function readTask(id, state = store.read()) {
55
+ const task = state.tasks.find(item => item.id === id)
56
+ if (!task) throw new InputError('找不到这项任务。')
57
+ return task
58
+ }
59
+
60
+ async function events(id) {
61
+ const live = ctx.sessions.get(id)
62
+ if (live) return live.snapshotEvents()
63
+ if (!await ctx.sessionPersistence.stat(id)) return []
64
+ const view = await ctx.sessionQuery.observeSession(id, { signal: closing.signal, projectionMode: 'none' })
65
+ try { return [...view.events] } finally { view[Symbol.dispose]() }
66
+ }
67
+
68
+ function ensureSession(id) {
69
+ if (opening.has(id)) return opening.get(id)
70
+ const operation = openSession(id).finally(() => opening.delete(id))
71
+ opening.set(id, operation)
72
+ return operation
73
+ }
74
+
75
+ async function openSession(id) {
76
+ closing.signal.throwIfAborted()
77
+ if (ctx.sessions.get(id) || await ctx.sessionPersistence.stat(id)) return
78
+ const task = store.read().tasks.find(item => item.sessionId === id)
79
+ if (task?.workspaceId && !workspaces().some(item => item.id === task.workspaceId)) {
80
+ throw new InputError('任务绑定的工作区已不可用。')
81
+ }
82
+ const location = task?.workspaceId ? { workspaceId: task.workspaceId } : { cwd: store.root }
83
+ const result = await ctx.sessionController.create({
84
+ sessionId: id, ...location,
85
+ ...(id === main && ctx.get?.('agentPresets') ? { agentPreset: STANDARD_PRESET } : {}),
86
+ })
87
+ if (result.sessionId !== id) throw new Error('DSH 返回了不同的会话 ID。')
88
+ const session = ctx.sessions.get(id)
89
+ if (session && id === main) ctx.get?.('sessionTitle')?.rename(session, 'Maid')
90
+ if (session && !await ctx.sessions.flush(session)) throw new Error('DSH 会话尚未写入磁盘。')
91
+ }
92
+
93
+ async function resolveMainConversation() {
94
+ await ensureSession(main)
95
+ const result = await ctx.sessionController.resolveAgent(main)
96
+ if (result.error) throw result.error
97
+ const presets = ctx.get?.('agentPresets')
98
+ if (presets && presets.presetForSession(result.agent.session) !== STANDARD_PRESET) {
99
+ try {
100
+ await presets.select(result.agent, STANDARD_PRESET)
101
+ } catch (error) {
102
+ // DSH locks the preset after the first turn. Keep the existing session and its history.
103
+ if (error?.code !== 'agent-preset/locked') throw error
104
+ return { sessionId: main }
105
+ }
106
+ if (!await ctx.sessions.flush(result.agent.session)) throw new Error('Maid 模式尚未写入磁盘。')
107
+ }
108
+ return { sessionId: main }
109
+ }
110
+
111
+ async function deliver(input) {
112
+ try {
113
+ if (input.target === main) await resolveMainConversation()
114
+ else await ensureSession(input.target)
115
+ closing.signal.throwIfAborted()
116
+ if (input.target !== main && !store.read().tasks.some(task => task.sessionId === input.target && task.status === 'running')) return
117
+ const result = await ctx.sessionController.prompt({
118
+ sessionId: input.target, requestId: input.id, mode: input.mode,
119
+ content: [{ type: 'text', text: input.text }],
120
+ }, closing.signal)
121
+ if (!result.accepted) throw new Error('DSH 尚未接收该消息。')
122
+ if (store.read().tasks.some(task => task.sessionId === input.target && task.status === 'cancelled')) stopSession(input.target)
123
+ const session = ctx.sessions.get(input.target)
124
+ if (!session || !await ctx.sessions.flush(session)) throw new Error('DSH 尚未保存该消息。')
125
+ await store.mutate(state => {
126
+ const saved = state.inputs.find(item => item.id === input.id)
127
+ if (saved) Object.assign(saved, { delivered: true, error: '' })
128
+ if (input.target !== main) state.inputs = state.inputs.filter(item => item.id !== input.id)
129
+ })
130
+ } catch (error) {
131
+ if (closing.signal.aborted) return
132
+ await store.mutate(state => {
133
+ const saved = state.inputs.find(item => item.id === input.id)
134
+ if (!saved) return
135
+ saved.attempts = (saved.attempts ?? 0) + 1
136
+ const retry = !(error instanceof InputError) && saved.attempts <= DELIVERY_RETRIES
137
+ if (retry) saved.retryAt = now() + 1200 * 2 ** (saved.attempts - 1)
138
+ else saved.error = error.message
139
+ const task = state.tasks.find(item => item.sessionId === input.target)
140
+ if (task && task.status === 'running') {
141
+ task.status = retry ? 'queued' : 'blocked'
142
+ if (retry) return
143
+ addEvent(task, '消息待重新投递。' + error.message)
144
+ }
145
+ })
146
+ }
147
+ }
148
+
149
+ function wake() {
150
+ if (driving || closing.signal.aborted) return
151
+ driving = true
152
+ background(async () => {
153
+ try {
154
+ const state = store.read()
155
+ const seen = new Set()
156
+ const workers = new Set([...active.keys()].filter(id => id !== main))
157
+ for (const task of state.tasks) {
158
+ if (task.status === 'running') workers.add(task.sessionId)
159
+ }
160
+ for (const input of state.inputs) {
161
+ if (input.delivered || input.error || seen.has(input.target)) continue
162
+ seen.add(input.target)
163
+ if (input.retryAt > now() || active.has(input.target)) continue
164
+ if (input.target !== main) {
165
+ if (workers.size >= CONCURRENCY || ctx.agents.get(input.target)?.status === 'running'
166
+ || !state.tasks.some(task => task.sessionId === input.target && task.status === 'queued')) continue
167
+ workers.add(input.target)
168
+ }
169
+ const run = Promise.resolve().then(async () => {
170
+ if (input.target !== main) {
171
+ const status = await store.mutate(state => {
172
+ const task = state.tasks.find(item => item.sessionId === input.target)
173
+ if (task?.status !== 'queued') return false
174
+ task.status = 'running'
175
+ return true
176
+ })
177
+ if (!status) return
178
+ }
179
+ await deliver(input)
180
+ }).catch(error => ctx.logger?.warn('Maid 投递失败:' + error.message)).finally(() => {
181
+ active.delete(input.target)
182
+ wake()
183
+ })
184
+ active.set(input.target, run)
185
+ }
186
+ } finally {
187
+ driving = false
188
+ }
189
+ }, '投递')
190
+ }
191
+
192
+ async function submit({ id, text, mode }) {
193
+ if (typeof id !== 'string' || !/^[0-9a-f-]{36}$/.test(id)) throw new InputError('消息 ID 无效。')
194
+ text = required(text, '消息', 32000)
195
+ if (!['queue', 'steer'].includes(mode)) throw new InputError('消息发送方式无效。')
196
+ await store.mutate(state => {
197
+ const previous = state.inputs.find(item => item.id === id)
198
+ if (previous) {
199
+ if (previous.target !== main || previous.text !== text || previous.mode !== mode) throw new InputError('消息 ID 已使用。')
200
+ if (previous.error) Object.assign(previous, { error: '', attempts: 0, retryAt: 0 })
201
+ } else state.inputs.push(job(main, text, mode, id))
202
+ })
203
+ wake()
204
+ }
205
+
206
+ async function taskCreate(input, origin) {
207
+ const title = required(input.title, '任务名称', 120)
208
+ const goal = required(input.goal, '任务目标', 12000)
209
+ const workspaceId = input.workspaceId || null
210
+ if (workspaceId && !workspaces().some(item => item.id === workspaceId)) throw new InputError('找不到所选项目。')
211
+ const result = await store.mutate(state => {
212
+ const duplicate = origin && state.tasks.find(item => item.origin === origin && item.title === title && item.goal === goal)
213
+ if (duplicate) return duplicate
214
+ const task = { id: randomUUID(), sessionId: sessionId(), title, goal, workspaceId, origin,
215
+ kind: 'task', status: 'queued', createdAt: now(), history: [], result: '', recoveries: 0 }
216
+ addEvent(task, '已接手')
217
+ state.tasks.push(task)
218
+ state.inputs.push(job(task.sessionId, goal))
219
+ return task
220
+ })
221
+ wake()
222
+ return result
223
+ }
224
+
225
+ async function watchSession(input, origin) {
226
+ const workspaceId = required(input.workspaceId, '工作区 ID', 120)
227
+ const watched = required(input.sessionId, '会话 ID', 120)
228
+ const workspace = ctx.workspaceRegistry.get(workspaceId)
229
+ if (!workspace?.sessionIds.includes(watched) || belongs(watched)) {
230
+ throw new InputError('只能跟进所选工作区里的普通 DSH 会话。')
231
+ }
232
+ const title = required(input.title, '跟进名称', 120)
233
+ const afterSeq = (await events(watched)).at(-1)?.seq ?? -1
234
+ const task = await store.mutate(state => {
235
+ const previous = origin && state.tasks.find(item => item.origin === origin && item.watched === watched)
236
+ if (previous) return previous
237
+ const row = { id: randomUUID(), kind: 'watch', title, watched, workspaceId, afterSeq, origin,
238
+ goal: '等待这个 DSH 会话在登记之后的下一轮成功结束,届时通知你。',
239
+ status: 'waiting', createdAt: now(), history: [], result: '' }
240
+ addEvent(row, '已开始跟进该会话')
241
+ state.tasks.push(row)
242
+ return row
243
+ })
244
+ const live = ctx.sessions.get(watched)
245
+ if (!live || await ctx.sessions.flush(live)) await confirmWatch(watched, await events(watched))
246
+ return task
247
+ }
248
+
249
+ async function confirmWatch(watched, log) {
250
+ const matching = store.read().tasks.some(task => task.watched === watched && task.status === 'waiting')
251
+ if (!matching || !log.some(event => event.type === 'turn/end' && event.data.reason.kind === 'completed')) return
252
+ await store.mutate(state => {
253
+ for (const task of state.tasks.filter(item => item.watched === watched && item.status === 'waiting')) {
254
+ const event = log.find(entry => entry.seq > task.afterSeq && entry.type === 'turn/end'
255
+ && entry.data.reason.kind === 'completed')
256
+ if (!event) continue
257
+ task.status = 'completed'
258
+ task.result = '跟进的 DSH 会话已成功结束一轮。'
259
+ addEvent(task, task.result)
260
+ addNotice(task, 'completed', task.title + ':' + task.result)
261
+ }
262
+ })
263
+ }
264
+
265
+ async function taskReply(id, text) {
266
+ text = required(text, '补充内容', 12000)
267
+ await store.mutate(state => {
268
+ const task = readTask(id, state)
269
+ if (!['blocked', 'waiting'].includes(task.status) || task.kind !== 'task') throw new InputError('当前任务无需接续。')
270
+ state.inputs = state.inputs.filter(item => item.target !== task.sessionId)
271
+ state.inputs.push(job(task.sessionId, '原任务目标:' + task.goal + '\n\n补充:' + text))
272
+ task.status = 'queued'
273
+ task.recoveries = 0
274
+ addEvent(task, '你补充了:' + text)
275
+ })
276
+ wake()
277
+ }
278
+
279
+ function stopSession(id) {
280
+ if (ctx.agents.get(id)?.status === 'running') ctx.sessionController.cancel({ sessionId: id })
281
+ }
282
+
283
+ async function taskCancel(id) {
284
+ const target = await store.mutate(state => {
285
+ const task = readTask(id, state)
286
+ if (task.kind === 'schedule') throw new InputError('请从定时安排暂停此任务。')
287
+ if (['completed', 'cancelled'].includes(task.status)) return undefined
288
+ task.status = 'cancelled'
289
+ addEvent(task, '你停止了跟进')
290
+ state.inputs = state.inputs.filter(item => item.target !== task.sessionId)
291
+ return task.sessionId
292
+ })
293
+ if (target) stopSession(target)
294
+ wake()
295
+ }
296
+
297
+ async function taskReport(target, kind, text) {
298
+ text = required(text, '进展', 16000)
299
+ if (!['progress', 'waiting', 'completed'].includes(kind)) throw new InputError('进展类型无效。')
300
+ return store.mutate(state => {
301
+ const task = state.tasks.find(item => item.sessionId === target)
302
+ if (!task || task.status !== 'running') throw new InputError('这项任务当前没有执行中的轮次。')
303
+ if (task.history.at(-1)?.text === text && kind === 'progress') return task
304
+ addEvent(task, text)
305
+ if (kind === 'waiting') {
306
+ task.status = 'waiting'
307
+ state.inputs = state.inputs.filter(item => item.target !== target)
308
+ addNotice(task, kind, text)
309
+ }
310
+ if (kind === 'completed') {
311
+ task.status = task.kind === 'schedule' ? 'waiting' : 'completed'
312
+ task.result = text
313
+ state.inputs = state.inputs.filter(item => item.target !== target)
314
+ addNotice(task, kind, text)
315
+ }
316
+ return task
317
+ })
318
+ }
319
+
320
+ async function onEvent(session, event) {
321
+ const target = session.id
322
+ if (event.type === 'turn/end' && event.data.reason.kind === 'completed'
323
+ && store.read().tasks.some(task => task.watched === target && task.status === 'waiting')) {
324
+ if (await ctx.sessions.flush(session)) await confirmWatch(target, [event])
325
+ }
326
+ if (target === main || !belongs(target)) return
327
+ if (event.type === 'user/message' && event.data.source.kind === 'schedule') {
328
+ await store.mutate(state => {
329
+ const task = state.tasks.find(item => item.sessionId === target)
330
+ if (task.kind !== 'schedule' || task.occurrence === event.data.id) return
331
+ task.occurrence = event.data.id
332
+ task.status = 'running'
333
+ addEvent(task, '定时任务已开始')
334
+ })
335
+ }
336
+ if (event.type === 'turn/end') {
337
+ await store.mutate(state => {
338
+ const task = state.tasks.find(item => item.sessionId === target)
339
+ if (task.status !== 'running') return
340
+ task.status = 'blocked'
341
+ const text = event.data.reason.kind === 'completed'
342
+ ? '执行会话已结束,等待确认任务结果。'
343
+ : '执行会话已中断,可以接着处理。'
344
+ addEvent(task, text)
345
+ addNotice(task, 'waiting', text)
346
+ })
347
+ wake()
348
+ }
349
+ }
350
+
351
+ async function memorySource(id) {
352
+ const entry = await memory.read(id)
353
+ if (!entry || !entry.source.startsWith(main + '#')) throw new InputError('这条事实没有可打开的对话原文。')
354
+ const index = Number(entry.source.slice(main.length + 1))
355
+ const original = (await events(main)).find(event => event.seq === index && event.type === 'user/message'
356
+ && event.data.source.kind === 'user')
357
+ if (!original) throw new InputError('原始对话已不可用。')
358
+ return { text: textContent(original.data.content) }
359
+ }
360
+
361
+ async function notebook(state = store.read()) {
362
+ const notices = state.tasks.flatMap(task => task.notices ?? []).sort((a, b) => b.at - a.at)
363
+ return {
364
+ sessionId: main, tasks: state.tasks.map(({ history, notices, ...task }) => ({
365
+ ...task, latest: history.at(-1)?.text || '',
366
+ })).reverse(),
367
+ notices: notices.slice(0, 30),
368
+ interruptedInputs: state.inputs.filter(input => input.target === main && input.error),
369
+ notes: [...state.notes].reverse(), workspaces: workspaces(),
370
+ schedules: await schedules?.list(state) ?? [], scheduleAvailable: Boolean(schedules?.available()),
371
+ }
372
+ }
373
+
374
+ async function snapshot(before) {
375
+ const state = store.read()
376
+ const delivered = await events(main)
377
+ const messages = new Map()
378
+ for (const input of state.inputs.filter(item => item.target === main)) {
379
+ messages.set(input.id, { id: input.id, role: 'user', text: input.text, at: input.at, error: input.error, mode: input.mode })
380
+ }
381
+ for (const event of delivered) {
382
+ if (event.type === 'user/message' && event.data.source.kind === 'user') {
383
+ const id = event.data.source.rpcId || event.data.id
384
+ if (!messages.has(id)) messages.set(id, { id, role: 'user', text: textContent(event.data.content), at: event.time })
385
+ }
386
+ if (event.type === 'assistant/message' && event.surfaceOp === 'append') {
387
+ const text = textContent(event.data.message.content)
388
+ if (text) messages.set(event.data.message.id, { id: event.data.message.id, role: 'maid', text, at: event.time })
389
+ }
390
+ }
391
+ for (const task of state.tasks) {
392
+ for (const entry of task.notices ?? []) {
393
+ messages.set(entry.id, { ...entry, role: 'maid' })
394
+ }
395
+ }
396
+ const sorted = [...messages.values()].sort((a, b) => a.at - b.at || a.id.localeCompare(b.id))
397
+ const end = before ? sorted.findIndex(row => row.id === before) : sorted.length
398
+ const index = end < 0 ? sorted.length : end
399
+ const live = ctx.agents.get(main)
400
+ const latestTurn = delivered.findLast(event => event.type === 'turn/end' || event.type === 'turn/start')
401
+ return {
402
+ ...await notebook(state), messages: sorted.slice(Math.max(0, index - 60), index), earlier: index > 60,
403
+ running: live?.status === 'running', chatError: latestTurn?.data.reason?.kind === 'error'
404
+ ? 'Maid 的会话执行失败:' + (latestTurn.data.reason.error?.message || '') : '',
405
+ pending: state.inputs.filter(item => item.target === main && !item.delivered && !item.error).length,
406
+ }
407
+ }
408
+
409
+ async function recover() {
410
+ const interrupted = store.read().tasks.filter(task => task.kind === 'task' && task.status === 'running'
411
+ && ctx.agents.get(task.sessionId)?.status !== 'running')
412
+ if (interrupted.length) await store.mutate(state => {
413
+ for (const { id } of interrupted) {
414
+ const task = readTask(id, state)
415
+ if (task.status !== 'running') continue
416
+ const pending = state.inputs.find(item => item.target === task.sessionId)
417
+ if (!pending && task.recoveries > 0) {
418
+ task.status = 'blocked'
419
+ addEvent(task, '已恢复过一次,请确认下一步。')
420
+ continue
421
+ }
422
+ if (!pending) {
423
+ task.recoveries++
424
+ state.inputs.push(job(task.sessionId, '从上一执行记录继续。先检查已经得到的结果,再完成剩余工作。'))
425
+ }
426
+ task.status = 'queued'
427
+ }
428
+ })
429
+ wake()
430
+ const watched = new Set(store.read().tasks.filter(task => task.kind === 'watch' && task.status === 'waiting').map(task => task.watched))
431
+ for (const id of watched) {
432
+ try { await confirmWatch(id, await events(id)) }
433
+ catch (error) { ctx.logger?.warn('Maid 关注事项待恢复:' + error.message) }
434
+ }
435
+ }
436
+
437
+ return {
438
+ main, store, persona, memory, memorySource, belongs, workspaces, workspaceSessions, watchSession,
439
+ readTask, taskCreate, taskReply, taskCancel, taskReport, ensureSession,
440
+ setSchedules: service => { schedules = service },
441
+ get schedules() { return schedules },
442
+ runEvent(session, event) {
443
+ if (session.id === main && event.type === 'agent/inbox/spliced' &&
444
+ event.data.inserted.some(message => message.source.kind === 'user')) {
445
+ background(async () => {
446
+ if (!await ctx.sessions.flush(session)) throw new Error('原生收件箱尚未落盘。')
447
+ }, '保存收件箱')
448
+ }
449
+ if (event.type === 'turn/end' || (event.type === 'user/message' && event.data.source.kind === 'schedule')) {
450
+ background(() => onEvent(session, event), '会话事件')
451
+ }
452
+ },
453
+ recover,
454
+ snapshot,
455
+ notebook,
456
+ async prepareConversation() {
457
+ if (ctx.workspaceRegistry.archivedSessionIds.includes(main)) {
458
+ await ctx.workspaceRegistry.unarchiveSession(main)
459
+ }
460
+ return resolveMainConversation()
461
+ },
462
+ attention() {
463
+ return { sessionId: main, count: store.read().tasks.filter(task => task.kind === 'task'
464
+ && ['waiting', 'blocked'].includes(task.status)).length }
465
+ },
466
+ submit,
467
+ note(text, origin) {
468
+ text = required(text, '笔记', 12000)
469
+ return store.mutate(state => {
470
+ const saved = origin && state.notes.find(item => item.origin === origin && item.text === text)
471
+ if (saved) return saved
472
+ const note = { id: randomUUID(), text, origin, at: now() }
473
+ state.notes.push(note)
474
+ return note
475
+ })
476
+ },
477
+ interrupt() { stopSession(main) },
478
+ start() {
479
+ background(recover, '恢复')
480
+ timer = setInterval(wake, 2000)
481
+ timer.unref()
482
+ },
483
+ async close() {
484
+ closing.abort()
485
+ clearInterval(timer)
486
+ await Promise.allSettled([...active.values(), ...callbacks])
487
+ await Promise.allSettled(opening.values())
488
+ await store.settle()
489
+ },
490
+ }
491
+ }
@@ -0,0 +1,130 @@
1
+ import { randomUUID } from 'node:crypto'
2
+ import { InputError, required } from './store.js'
3
+
4
+ export function scheduleTiming(input) {
5
+ const time = required(input.time, '执行时间', 5)
6
+ if (!/^([01]\d|2[0-3]):[0-5]\d$/.test(time)) throw new InputError('请填写有效的执行时间。')
7
+ const time_zone = required(input.timeZone, '时区', 100)
8
+ try { new Intl.DateTimeFormat('zh-CN', { timeZone: time_zone }) }
9
+ catch { throw new InputError('请填写有效的时区。') }
10
+ if (input.repeat === 'once') {
11
+ const date = required(input.date, '执行日期', 10)
12
+ if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) throw new InputError('请按 YYYY-MM-DD 填写执行日期。')
13
+ return { kind: 'at', at: { date, time: time + ':00', time_zone } }
14
+ }
15
+ if (input.repeat === 'daily') return { kind: 'daily', daily: { time: time + ':00', time_zone } }
16
+ if (input.repeat === 'weekly' && Number.isInteger(input.weekday) && input.weekday >= 1 && input.weekday <= 7) {
17
+ return { kind: 'weekly', weekly: { time: time + ':00', time_zone, weekdays: [input.weekday] } }
18
+ }
19
+ throw new InputError('请选择仅一次、每天或每周,并为每周安排指定星期。')
20
+ }
21
+
22
+ function onceTimingError(error, kind) {
23
+ if (kind !== 'at' || error?.name !== 'ScheduleInputError') return undefined
24
+ if (error.code === 'not_future') return new InputError('执行时间已经过去,请选择未来的时间。')
25
+ if (error.code === 'invalid_rule' || error.code === 'invalid_time_zone') {
26
+ return new InputError('这个日期或时间在所选时区无效,请核对后再试。')
27
+ }
28
+ }
29
+
30
+ export function createSchedules(ctx, runtime) {
31
+ const { store } = runtime
32
+ const native = () => ctx.get('schedule')
33
+ const available = () => Boolean(native())
34
+ const toMaid = (row, task) => ({
35
+ id: row.id, title: row.title, goal: row.prompt, status: row.status, revision: row.updatedAt,
36
+ next: row.status === 'active' ? row.scheduledAt : null, scheduledAt: row.scheduledAt, lastDelivery: row.lastDelivery?.deliveredAt,
37
+ repeat: row.kind === 'at' ? 'once' : row.kind, timeZone: row.timeZone, time: row.time?.slice(0, 5), weekday: row.weekdays?.[0],
38
+ ...(task ? { taskId: task.id, result: task.result, latest: task.history.at(-1)?.text } : { native: true }),
39
+ })
40
+ function requireSchedule() {
41
+ const service = native()
42
+ if (!service) throw new InputError('此 DSH 配置未启用定时任务。')
43
+ return service
44
+ }
45
+
46
+ async function list(state = store.read()) {
47
+ const service = native()
48
+ if (!service) return []
49
+ const bySession = new Map(state.tasks.filter(task => task.kind === 'schedule').map(task => [task.sessionId, task]))
50
+ return (await service.catalog()).flatMap(row => {
51
+ const task = bySession.get(row.target.sessionId)
52
+ const related = row.target.sessionId === runtime.main || row.involvedSessionIds?.includes(runtime.main)
53
+ return task || related ? [toMaid(row, task)] : []
54
+ })
55
+ }
56
+
57
+ const creating = new Map()
58
+ function realize(task) {
59
+ if (creating.has(task.id)) return creating.get(task.id)
60
+ const run = (async () => {
61
+ const service = requireSchedule()
62
+ let row = (await service.catalog()).find(row => row.target.kind === 'session' && row.target.sessionId === task.sessionId)
63
+ if (!row) {
64
+ await runtime.ensureSession(task.sessionId)
65
+ try {
66
+ row = await service.create({ title: task.title, prompt: task.goal, timing: task.scheduleTiming,
67
+ target: { kind: 'session', sessionId: task.sessionId } })
68
+ } catch (error) {
69
+ const invalid = onceTimingError(error, task.scheduleTiming.kind)
70
+ if (!invalid) throw error
71
+ // A rejected timing never reached native storage and cannot succeed by retrying it.
72
+ await store.mutate(state => { state.tasks = state.tasks.filter(item => item.id !== task.id) })
73
+ throw invalid
74
+ }
75
+ }
76
+ await store.mutate(state => { runtime.readTask(task.id, state).schedulePending = false })
77
+ return toMaid(row, task)
78
+ })().finally(() => creating.delete(task.id))
79
+ creating.set(task.id, run)
80
+ return run
81
+ }
82
+
83
+ async function create(input, origin) {
84
+ requireSchedule()
85
+ const title = required(input.title, '定时任务名称', 120)
86
+ const goal = required(input.goal, '定时任务目标', 12000)
87
+ const timing = scheduleTiming(input)
88
+ const task = await store.mutate(state => {
89
+ const prior = origin && state.tasks.find(item => item.origin === origin && item.kind === 'schedule'
90
+ && item.title === title && item.goal === goal)
91
+ if (prior) return prior
92
+ const row = { id: randomUUID(), sessionId: 'session-' + randomUUID(), kind: 'schedule',
93
+ title, goal, origin, status: 'waiting', scheduleTiming: timing, schedulePending: true, createdAt: Date.now(),
94
+ history: [], result: '', workspaceId: null }
95
+ state.tasks.push(row)
96
+ return row
97
+ })
98
+ return realize(task)
99
+ }
100
+
101
+ async function edit(input) {
102
+ const service = requireSchedule()
103
+ const current = (await list()).find(row => row.id === input.id)
104
+ if (!current) throw new InputError('找不到这项定时任务。')
105
+ if (current.native && typeof input.active !== 'boolean') {
106
+ throw new InputError('请在 DSH 的「自动化任务」中调整这项安排的时间规则。')
107
+ }
108
+ const patch = typeof input.active === 'boolean' ? { active: input.active } : { timing: scheduleTiming(input) }
109
+ let row
110
+ try {
111
+ row = await service.edit({ id: current.id, action: 'update', patch,
112
+ expectedUpdatedAt: input.revision ?? null })
113
+ } catch (error) {
114
+ throw onceTimingError(error, patch.timing?.kind ?? (current.repeat === 'once' ? 'at' : undefined)) ?? error
115
+ }
116
+ if (row.code) throw new InputError('定时安排已变化,请刷新后再操作。')
117
+ return toMaid(row, current.taskId === undefined ? undefined : runtime.readTask(current.taskId))
118
+ }
119
+
120
+ return { available, list, create, edit,
121
+ async recover() {
122
+ if (!available()) return
123
+ const state = store.read()
124
+ for (const task of state.tasks.filter(item => item.kind === 'schedule' && item.schedulePending)) {
125
+ try { await realize(task) }
126
+ catch (error) { ctx.logger?.warn('Maid 定时任务待恢复:' + error.message) }
127
+ }
128
+ },
129
+ }
130
+ }