@thready-web/dsh-bot-plugin 0.1.0-beta.10 → 0.1.0-beta.12
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/README.md +19 -2
- package/dist/approvals.js +19 -1
- package/dist/canvas-compose.js +73 -0
- package/dist/canvas-http.js +379 -0
- package/dist/canvas-skills.js +56 -0
- package/dist/canvas-store.js +1015 -0
- package/dist/canvas-tools.js +380 -0
- package/dist/card-log.js +216 -0
- package/dist/context.js +6 -3
- package/dist/deleting.js +54 -0
- package/dist/desk-ledger.js +18 -0
- package/dist/desk.js +30 -5
- package/dist/http-plugin.js +2 -1
- package/dist/http.js +218 -3
- package/dist/inbox.js +24 -2
- package/dist/index.js +75 -12
- package/dist/questions.js +10 -0
- package/dist/runtime-registry.js +20 -0
- package/dist/session-delete-job.js +77 -0
- package/dist/session-files.js +33 -1
- package/dist/session-wipe.js +204 -0
- package/dist/store.js +46 -3
- package/dist/triggers.js +8 -0
- package/dist/work-admit.js +9 -20
- package/dist/work-child.js +27 -10
- package/dist/work-http.js +19 -0
- package/dist/work-ledger.js +5 -1
- package/dist/work-mock.js +10 -0
- package/dist/work-tickets.js +5 -3
- package/dist/work-tools.js +11 -9
- package/dist/work-worker.js +245 -6
- package/dist/worker-handles.js +33 -0
- package/dist/workspace-files.js +98 -17
- package/package.json +2 -1
- package/public/assets/{SourceEditor-BEQaScgR.js → SourceEditor-BjtoMvcX.js} +3 -3
- package/public/assets/{cssMode-gpcjCFFS.js → cssMode--96PQtWh.js} +1 -1
- package/public/assets/{freemarker2-C1qemGIt.js → freemarker2-Bz-HlISL.js} +1 -1
- package/public/assets/{handlebars-sZqIfAlP.js → handlebars-D9ScJ8AM.js} +1 -1
- package/public/assets/{html-Bn1WXB8L.js → html-Czc0jojJ.js} +1 -1
- package/public/assets/{htmlMode-CvQyXnaW.js → htmlMode-CCww5Z1w.js} +1 -1
- package/public/assets/index-DRCgKxWk.css +1 -0
- package/public/assets/index-ztUdW074.js +72 -0
- package/public/assets/{javascript-Ox4Jg12j.js → javascript-B-yRZSiz.js} +1 -1
- package/public/assets/{jsonMode-DMR7R2dQ.js → jsonMode-ASWsY833.js} +1 -1
- package/public/assets/{liquid-B6HxtpBd.js → liquid-BGoox2vJ.js} +1 -1
- package/public/assets/{mdx--jDhmrXq.js → mdx-DHgvnl_U.js} +1 -1
- package/public/assets/{python-YjG50skX.js → python-BJvVD30_.js} +1 -1
- package/public/assets/{razor-CEcFE3UK.js → razor-0PwR35mu.js} +1 -1
- package/public/assets/{tsMode-g4kTQl09.js → tsMode-3ETp8Gdh.js} +1 -1
- package/public/assets/{typescript-CnHeFmPW.js → typescript-BT0iTK6K.js} +1 -1
- package/public/assets/{xml-BFXMY9nb.js → xml-BTaNc_uT.js} +1 -1
- package/public/assets/{yaml-DNm87nSf.js → yaml-Dr7LW3tK.js} +1 -1
- package/public/index.html +2 -2
- package/skills/ui/baseline-ui/SKILL.md +85 -0
- package/skills/ui/bencium-innovative-ux-designer/SKILL.md +227 -0
- package/skills/ui/better-ui/SKILL.md +133 -0
- package/skills/ui/design-lab/SKILL.md +920 -0
- package/skills/ui/frontend-design/SKILL.md +71 -0
- package/skills/ui/impeccable/SKILL.md +93 -0
- package/skills/ui/interface-design/SKILL.md +320 -0
- package/skills/ui/sources.json +66 -0
- package/skills/ui/ui-design/SKILL.md +41 -0
- package/skills/ui/ui-skills-root/SKILL.md +59 -0
- package/skills/ui/visual-design-foundations/SKILL.md +318 -0
- package/skills/ui/web-design-guidelines/SKILL.md +39 -0
- package/public/assets/index-DRNkUrer.css +0 -1
- package/public/assets/index-DhL5Kdlz.js +0 -63
package/dist/index.js
CHANGED
|
@@ -5,17 +5,22 @@ import { createEngine } from "./engine.js";
|
|
|
5
5
|
import { renderPeers, renderSession, renderTickets, WORKER_MEMORY } from "./context.js";
|
|
6
6
|
import { callMemoryTool, memorySessionFor, toolDefinitions } from "./tools.js";
|
|
7
7
|
import { createTriggers } from "./triggers.js";
|
|
8
|
-
import { followupDurable, liveAgent, logHasMessage, removePending } from "./inbox.js";
|
|
8
|
+
import { followupDurable, liveAgent, logHasMessage, removePending, steerDurable } from "./inbox.js";
|
|
9
9
|
import { createLogSource } from "./log/source.js";
|
|
10
10
|
import { toolError } from "./errors.js";
|
|
11
11
|
import { createQuestionAnswerer, publishQuestionAnswerer, questionAnswererFor } from "./questions.js";
|
|
12
12
|
import { createApprovalAnswerer, publishApprovalAnswerer, approvalAnswererFor } from "./approvals.js";
|
|
13
13
|
import { createAuthorizationController, publishAuthorization, authorizationFor } from "./authorization.js";
|
|
14
|
-
import {
|
|
14
|
+
import { isFenced } from "./deleting.js";
|
|
15
|
+
import { publishRuntime, publishSessionDrop, publishWorkRuntime, runtimeFor } from "./runtime-registry.js";
|
|
15
16
|
import { childCreateOptions, effectiveWorkLimits, pinMainReasoning, resolveWorkBudget, workerModelSelection, WORK_BUDGET_ENV, } from "./work-admit.js";
|
|
16
|
-
import { ensureWorkerFilePreset, WORKER_FILE_PRESET, workerFileSetup } from "./work-child.js";
|
|
17
|
+
import { CANVAS_WORKER_PRESET, ensureWorkerFilePreset, WORKER_FILE_PRESET, workerFileSetup } from "./work-child.js";
|
|
17
18
|
import { BUDGET_NOTICE_PREFIX, createWorkRuntime } from "./work-worker.js";
|
|
18
19
|
import { workToolDefinitions } from "./work-tools.js";
|
|
20
|
+
import { openCanvasStore } from "./canvas-store.js";
|
|
21
|
+
import { backlogCanvases, bindCanvasCards, createCardLog, publishCardLog } from "./card-log.js";
|
|
22
|
+
import { canvasToolDefinitions } from "./canvas-tools.js";
|
|
23
|
+
import { forgetWorker, rememberWorker } from "./worker-handles.js";
|
|
19
24
|
export const name = 'session-foundations';
|
|
20
25
|
// Cordis throws if a plugin reads a service it did not inject. Crash recovery reads the session log through this one.
|
|
21
26
|
export const inject = [
|
|
@@ -37,6 +42,11 @@ export function apply(ctx, config = {}) {
|
|
|
37
42
|
if (dataDir === '')
|
|
38
43
|
throw new Error('session-foundations: pass dataDir or launch with dsh profileContext');
|
|
39
44
|
const store = openStore(dataDir);
|
|
45
|
+
const cards = createCardLog(store.db);
|
|
46
|
+
publishCardLog(dataDir, cards);
|
|
47
|
+
const canvas = openCanvasStore(join(dataDir, 'canvas.sqlite'));
|
|
48
|
+
bindCanvasCards(canvas, ctx, dataDir);
|
|
49
|
+
backlogCanvases(canvas, ctx, dataDir);
|
|
40
50
|
const engine = createEngine(store);
|
|
41
51
|
const recovery = engine.recover();
|
|
42
52
|
const ownerFile = join(dataDir, 'owner.json');
|
|
@@ -50,12 +60,19 @@ export function apply(ctx, config = {}) {
|
|
|
50
60
|
catch {
|
|
51
61
|
/* already gone */
|
|
52
62
|
}
|
|
63
|
+
publishCardLog(dataDir, null);
|
|
53
64
|
try {
|
|
54
65
|
store.close();
|
|
55
66
|
}
|
|
56
67
|
catch {
|
|
57
68
|
/* closed */
|
|
58
69
|
}
|
|
70
|
+
try {
|
|
71
|
+
canvas.close();
|
|
72
|
+
}
|
|
73
|
+
catch {
|
|
74
|
+
/* closed */
|
|
75
|
+
}
|
|
59
76
|
});
|
|
60
77
|
/** @type {ReturnType<typeof createTriggers> | null} */
|
|
61
78
|
let triggers = null;
|
|
@@ -213,7 +230,12 @@ export function apply(ctx, config = {}) {
|
|
|
213
230
|
pinMainReasoning(payload?.agent, id => engine.isBot(id));
|
|
214
231
|
});
|
|
215
232
|
triggers = ctx.agents ? startTriggers(ctx, store, engine) : null;
|
|
216
|
-
work = ctx.agents
|
|
233
|
+
work = ctx.agents
|
|
234
|
+
? startWork(ctx, store, engine, config, cards, sessionIds => {
|
|
235
|
+
for (const sessionId of sessionIds)
|
|
236
|
+
rendered.delete(sessionId);
|
|
237
|
+
})
|
|
238
|
+
: null;
|
|
217
239
|
if (triggers) {
|
|
218
240
|
for (const definition of triggerTools(triggers, engine))
|
|
219
241
|
ctx.tools.register(definition);
|
|
@@ -221,6 +243,18 @@ export function apply(ctx, config = {}) {
|
|
|
221
243
|
if (work) {
|
|
222
244
|
for (const definition of workToolDefinitions(work, engine))
|
|
223
245
|
ctx.tools.register(definition);
|
|
246
|
+
for (const definition of canvasToolDefinitions(canvas, work, engine, {
|
|
247
|
+
workspaceCwd(sessionId) {
|
|
248
|
+
try {
|
|
249
|
+
const cwd = ctx.sessions?.get(sessionId)?.header?.cwd;
|
|
250
|
+
return typeof cwd === 'string' ? cwd : '';
|
|
251
|
+
}
|
|
252
|
+
catch {
|
|
253
|
+
return '';
|
|
254
|
+
}
|
|
255
|
+
},
|
|
256
|
+
}))
|
|
257
|
+
ctx.tools.register(definition);
|
|
224
258
|
const gate = work;
|
|
225
259
|
// Main-session step budget: refuse the next step instead of cancelling a
|
|
226
260
|
// step that already ended. A refused step ends the turn as `blocked`.
|
|
@@ -257,7 +291,19 @@ export function apply(ctx, config = {}) {
|
|
|
257
291
|
if (questionAnswererFor(store.root) === questions)
|
|
258
292
|
publishQuestionAnswerer(store.root, null);
|
|
259
293
|
});
|
|
260
|
-
const approvals = createApprovalAnswerer(
|
|
294
|
+
const approvals = createApprovalAnswerer(entry => {
|
|
295
|
+
cards.record(ctx, {
|
|
296
|
+
kind: 'approval',
|
|
297
|
+
key: entry.requestId,
|
|
298
|
+
sessionId: entry.sessionId,
|
|
299
|
+
payload: {
|
|
300
|
+
requestId: entry.requestId,
|
|
301
|
+
toolName: entry.toolName,
|
|
302
|
+
reason: entry.reason,
|
|
303
|
+
...(entry.callId ? { callId: entry.callId } : {}),
|
|
304
|
+
},
|
|
305
|
+
});
|
|
306
|
+
});
|
|
261
307
|
publishApprovalAnswerer(store.root, approvals);
|
|
262
308
|
ctx.effect(() => approvals.listen(ctx));
|
|
263
309
|
ctx.effect(() => () => {
|
|
@@ -316,9 +362,7 @@ function startTriggers(ctx, store, engine) {
|
|
|
316
362
|
* @param {import('./src/engine.js').Engine} engine
|
|
317
363
|
* @param {{ work?: Partial<import('./src/work-admit.js').DEFAULT_WORK_BUDGET> }} config
|
|
318
364
|
*/
|
|
319
|
-
function startWork(ctx, store, engine, config) {
|
|
320
|
-
/** @type {Map<string, { dispose?: () => Promise<void> }>} */
|
|
321
|
-
const workerHandles = new Map();
|
|
365
|
+
function startWork(ctx, store, engine, config, cards, onDrop = () => { }) {
|
|
322
366
|
const filePreset = ensureWorkerFilePreset(ctx);
|
|
323
367
|
const resolved = resolveWorkBudget(config.work ?? {}, process.env[WORK_BUDGET_ENV]);
|
|
324
368
|
if (resolved.ignored.length > 0) {
|
|
@@ -351,6 +395,9 @@ function startWork(ctx, store, engine, config) {
|
|
|
351
395
|
});
|
|
352
396
|
},
|
|
353
397
|
createChild: async (spec) => {
|
|
398
|
+
if (isFenced(spec.ownerSessionId) || isFenced(spec.sessionId)) {
|
|
399
|
+
throw Object.assign(new Error('session is being deleted'), { code: 'DELETING' });
|
|
400
|
+
}
|
|
354
401
|
let cwd = '';
|
|
355
402
|
let model = null;
|
|
356
403
|
try {
|
|
@@ -374,14 +421,22 @@ function startWork(ctx, store, engine, config) {
|
|
|
374
421
|
const options = childCreateOptions(spec.sessionId, cwd, model, cap);
|
|
375
422
|
const presetId = await filePreset;
|
|
376
423
|
if (presetId) {
|
|
377
|
-
|
|
378
|
-
options.
|
|
424
|
+
const preset = spec.canvas ? CANVAS_WORKER_PRESET : WORKER_FILE_PRESET;
|
|
425
|
+
options.meta = { ...(options.meta ?? {}), agentPreset: preset };
|
|
426
|
+
options.setup = workerFileSetup(ctx, preset);
|
|
379
427
|
}
|
|
380
428
|
const handle = await ctx.agents.create(options);
|
|
381
|
-
|
|
429
|
+
rememberWorker(spec.sessionId, handle);
|
|
382
430
|
return spec.sessionId;
|
|
383
431
|
},
|
|
432
|
+
recordCard: input => {
|
|
433
|
+
cards.record(ctx, input);
|
|
434
|
+
},
|
|
435
|
+
flushCards: () => {
|
|
436
|
+
cards.flush(ctx);
|
|
437
|
+
},
|
|
384
438
|
push: (sessionId, messageId, text) => followupDurable(ctx, sessionId, messageId, text),
|
|
439
|
+
steer: (sessionId, messageId, text) => steerDurable(ctx, sessionId, messageId, text),
|
|
385
440
|
logHas: (sessionId, messageId) => logHasDurable(ctx, sessionId, messageId),
|
|
386
441
|
remove: (sessionId, messageId) => removePending(ctx, sessionId, messageId),
|
|
387
442
|
pendingIds: async (sessionId) => {
|
|
@@ -412,9 +467,17 @@ function startWork(ctx, store, engine, config) {
|
|
|
412
467
|
childPresent: sessionId => liveAgent(ctx, sessionId) != null,
|
|
413
468
|
});
|
|
414
469
|
publishWorkRuntime(store.root, work);
|
|
470
|
+
publishSessionDrop(store.root, sessionIds => {
|
|
471
|
+
onDrop(sessionIds);
|
|
472
|
+
for (const sessionId of sessionIds) {
|
|
473
|
+
engine.openViews.delete(sessionId);
|
|
474
|
+
engine.surface.delete(sessionId);
|
|
475
|
+
void forgetWorker(sessionId);
|
|
476
|
+
}
|
|
477
|
+
});
|
|
415
478
|
ctx.effect(() => () => {
|
|
416
479
|
publishWorkRuntime(store.root, null);
|
|
417
|
-
|
|
480
|
+
publishSessionDrop(store.root, null);
|
|
418
481
|
});
|
|
419
482
|
ctx.on('agent/inbox/claimed', (payload) => {
|
|
420
483
|
if (payload == null)
|
package/dist/questions.js
CHANGED
|
@@ -323,6 +323,15 @@ export function createQuestionAnswerer() {
|
|
|
323
323
|
matched.entry.reject(questionRejection('ASK_CANCELLED', 'The user requested changes or cancelled the question.'));
|
|
324
324
|
return { ok: true, path: 'cancelled' };
|
|
325
325
|
}
|
|
326
|
+
function cancelSession(sessionId) {
|
|
327
|
+
for (const entry of [...pending]) {
|
|
328
|
+
if (entry.sessionId !== sessionId)
|
|
329
|
+
continue;
|
|
330
|
+
if (!detach(entry))
|
|
331
|
+
continue;
|
|
332
|
+
entry.reject(questionRejection('ASK_CANCELLED', 'This session is being deleted.'));
|
|
333
|
+
}
|
|
334
|
+
}
|
|
326
335
|
function timeout(input) {
|
|
327
336
|
if (typeof input.sessionId !== 'string' || input.sessionId === '') {
|
|
328
337
|
return toolError('VALIDATION', 'sessionId is required.');
|
|
@@ -397,6 +406,7 @@ export function createQuestionAnswerer() {
|
|
|
397
406
|
handle,
|
|
398
407
|
submit,
|
|
399
408
|
cancel,
|
|
409
|
+
cancelSession,
|
|
400
410
|
timeout,
|
|
401
411
|
takeTime,
|
|
402
412
|
snapshot,
|
package/dist/runtime-registry.js
CHANGED
|
@@ -34,3 +34,23 @@ export function publishWorkRuntime(dataDir, runtime) {
|
|
|
34
34
|
export function workRuntimeFor(dataDir) {
|
|
35
35
|
return workRuntimes.get(dataDir) ?? null;
|
|
36
36
|
}
|
|
37
|
+
/** @type {Map<string, (sessionIds: readonly string[]) => void>} */
|
|
38
|
+
const sessionDrops = new Map();
|
|
39
|
+
/**
|
|
40
|
+
* The main plugin drops in-memory views when the HTTP plugin deletes a bot.
|
|
41
|
+
* @param {string} dataDir
|
|
42
|
+
* @param {((sessionIds: readonly string[]) => void) | null} drop
|
|
43
|
+
*/
|
|
44
|
+
export function publishSessionDrop(dataDir, drop) {
|
|
45
|
+
if (drop)
|
|
46
|
+
sessionDrops.set(dataDir, drop);
|
|
47
|
+
else
|
|
48
|
+
sessionDrops.delete(dataDir);
|
|
49
|
+
}
|
|
50
|
+
/**
|
|
51
|
+
* @param {string} dataDir
|
|
52
|
+
* @param {readonly string[]} sessionIds
|
|
53
|
+
*/
|
|
54
|
+
export function dropSessions(dataDir, sessionIds) {
|
|
55
|
+
sessionDrops.get(dataDir)?.(sessionIds);
|
|
56
|
+
}
|
|
@@ -0,0 +1,77 @@
|
|
|
1
|
+
/** Quiesce a bot and its workers, then delete the data that belongs to them. */
|
|
2
|
+
import { fence, unfence } from "./deleting.js";
|
|
3
|
+
import { deleteOwnedCanvases, deleteOwnedLogs, deleteOwnedSessions, quietSessions, sessionClosure, } from "./session-wipe.js";
|
|
4
|
+
const ROUNDS = 3;
|
|
5
|
+
export async function executeDelete(host, ownerId, publish) {
|
|
6
|
+
const ids = new Set([ownerId]);
|
|
7
|
+
fence([ownerId]);
|
|
8
|
+
publish({ phase: 'fence', percent: 10 });
|
|
9
|
+
try {
|
|
10
|
+
const stopped = await quiesce(host, ownerId, ids, publish);
|
|
11
|
+
if (!stopped.ok) {
|
|
12
|
+
publish({ phase: 'error', percent: 45, error: stopped.error });
|
|
13
|
+
return;
|
|
14
|
+
}
|
|
15
|
+
const sessionIds = [...ids];
|
|
16
|
+
publish({ phase: 'store', percent: 65 });
|
|
17
|
+
await deleteOwnedSessions(host.store, sessionIds);
|
|
18
|
+
publish({ phase: 'canvas', percent: 78 });
|
|
19
|
+
if (host.canvas)
|
|
20
|
+
deleteOwnedCanvases(host.canvas, sessionIds);
|
|
21
|
+
publish({ phase: 'files', percent: 90 });
|
|
22
|
+
deleteOwnedLogs({ sessionsRoot: host.sessionsRoot, stateRoot: host.stateRoot, sessionIds });
|
|
23
|
+
host.forgetDesk(sessionIds);
|
|
24
|
+
host.dropMemory(sessionIds);
|
|
25
|
+
unfence(sessionIds);
|
|
26
|
+
publish({ phase: 'done', percent: 90, deletedSessionIds: sessionIds });
|
|
27
|
+
}
|
|
28
|
+
catch (error) {
|
|
29
|
+
publish({
|
|
30
|
+
phase: 'error',
|
|
31
|
+
percent: 45,
|
|
32
|
+
error: error instanceof Error ? error.message : 'delete failed',
|
|
33
|
+
});
|
|
34
|
+
}
|
|
35
|
+
}
|
|
36
|
+
async function quiesce(host, ownerId, ids, publish) {
|
|
37
|
+
publish({ phase: 'stop', percent: 30 });
|
|
38
|
+
for (let round = 0; round < ROUNDS; round += 1) {
|
|
39
|
+
const found = sessionClosure(host.store.db, ownerId);
|
|
40
|
+
for (const id of found)
|
|
41
|
+
ids.add(id);
|
|
42
|
+
fence(found);
|
|
43
|
+
await quietSessions(host.store, found);
|
|
44
|
+
const ordered = [...found.filter(id => id !== ownerId), ownerId];
|
|
45
|
+
let timedOut = false;
|
|
46
|
+
for (const id of ordered) {
|
|
47
|
+
host.silence(id);
|
|
48
|
+
host.cancelQuestions(id);
|
|
49
|
+
host.abandonApprovals(id);
|
|
50
|
+
const stopped = await host.stop(id);
|
|
51
|
+
if (!stopped)
|
|
52
|
+
timedOut = true;
|
|
53
|
+
}
|
|
54
|
+
publish({ phase: 'idle', percent: 45 });
|
|
55
|
+
let busy = timedOut;
|
|
56
|
+
let unknown = false;
|
|
57
|
+
for (const id of found) {
|
|
58
|
+
const running = await host.running(id);
|
|
59
|
+
if (running === null)
|
|
60
|
+
unknown = true;
|
|
61
|
+
if (running === true)
|
|
62
|
+
busy = true;
|
|
63
|
+
}
|
|
64
|
+
if (unknown)
|
|
65
|
+
return { ok: false, error: 'session_unreadable' };
|
|
66
|
+
const again = sessionClosure(host.store.db, ownerId);
|
|
67
|
+
const same = again.length === found.length && again.every(id => found.includes(id));
|
|
68
|
+
if (!busy && same) {
|
|
69
|
+
for (const id of again)
|
|
70
|
+
ids.add(id);
|
|
71
|
+
return { ok: true };
|
|
72
|
+
}
|
|
73
|
+
for (const id of again)
|
|
74
|
+
ids.add(id);
|
|
75
|
+
}
|
|
76
|
+
return { ok: false, error: 'running' };
|
|
77
|
+
}
|
package/dist/session-files.js
CHANGED
|
@@ -1,7 +1,8 @@
|
|
|
1
1
|
/** Remove one session's on-disk log. DSH has no delete RPC; session/list rescans these directories. */
|
|
2
|
-
import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
|
|
2
|
+
import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, realpathSync, rmSync, writeFileSync, } from 'node:fs';
|
|
3
3
|
import { join, resolve, sep } from 'node:path';
|
|
4
4
|
const SESSION_ID = /^session-[A-Za-z0-9-]+$/;
|
|
5
|
+
const STORED_ID = /^(?:session|worker)-[A-Za-z0-9-]+$/;
|
|
5
6
|
/**
|
|
6
7
|
* Same project-directory key as @deepseek-ai/dsh-session-persistence-jsonl.
|
|
7
8
|
* @param {string} cwd
|
|
@@ -85,6 +86,37 @@ export function purgeSessionFiles(input) {
|
|
|
85
86
|
}
|
|
86
87
|
forgetWorkspaceId(input.workspaceFile, input.sessionId);
|
|
87
88
|
}
|
|
89
|
+
/**
|
|
90
|
+
* Remove one session's log directory, project cache, and workspace.json id.
|
|
91
|
+
* The directory is found by name under the sessions root, so a worker does not
|
|
92
|
+
* need the owner's cwd. The workspace directory itself stays.
|
|
93
|
+
* @param {{ sessionsRoot: string, stateRoot: string, sessionId: string }} input
|
|
94
|
+
*/
|
|
95
|
+
export function eraseSessionStorage(input) {
|
|
96
|
+
if (!STORED_ID.test(input.sessionId))
|
|
97
|
+
throw new Error('session id is not a storage name');
|
|
98
|
+
if (input.sessionsRoot !== '' && existsSync(input.sessionsRoot)) {
|
|
99
|
+
const realRoot = realpathSync(input.sessionsRoot);
|
|
100
|
+
for (const project of readdirSync(realRoot)) {
|
|
101
|
+
const dir = join(realRoot, project, input.sessionId);
|
|
102
|
+
if (!existsSync(dir))
|
|
103
|
+
continue;
|
|
104
|
+
if (lstatSync(dir).isSymbolicLink())
|
|
105
|
+
throw new Error('refusing to delete a symlink');
|
|
106
|
+
const realDir = realpathSync(dir);
|
|
107
|
+
if (!inside(realRoot, realDir))
|
|
108
|
+
throw new Error('session path escapes the session root');
|
|
109
|
+
rmSync(realDir, { recursive: true, force: true });
|
|
110
|
+
}
|
|
111
|
+
}
|
|
112
|
+
const cache = input.stateRoot === ''
|
|
113
|
+
? ''
|
|
114
|
+
: join(input.stateRoot, 'storages', 'session_projcache', 'sessions', `${input.sessionId}.json`);
|
|
115
|
+
if (cache !== '' && existsSync(cache) && !lstatSync(cache).isSymbolicLink())
|
|
116
|
+
rmSync(cache, { force: true });
|
|
117
|
+
if (input.stateRoot !== '')
|
|
118
|
+
forgetWorkspaceId(join(input.stateRoot, 'storages', 'workspace.json'), input.sessionId);
|
|
119
|
+
}
|
|
88
120
|
/**
|
|
89
121
|
* @param {string} workspaceFile
|
|
90
122
|
* @param {string} sessionId
|
|
@@ -0,0 +1,204 @@
|
|
|
1
|
+
/** Remove rows and files that belong to a bot and the workers derived from it. */
|
|
2
|
+
import { existsSync, lstatSync, readdirSync, rmSync } from 'node:fs';
|
|
3
|
+
import { join } from 'node:path';
|
|
4
|
+
import { eraseSessionStorage } from "./session-files.js";
|
|
5
|
+
import { now } from "./store.js";
|
|
6
|
+
const STORED_ID = /^(?:session|worker)-[A-Za-z0-9-]+$/;
|
|
7
|
+
export function sessionClosure(db, ownerId) {
|
|
8
|
+
const ids = new Set([ownerId]);
|
|
9
|
+
let grew = true;
|
|
10
|
+
while (grew) {
|
|
11
|
+
grew = false;
|
|
12
|
+
const list = [...ids];
|
|
13
|
+
const marks = list.map(() => '?').join(', ');
|
|
14
|
+
const rows = db
|
|
15
|
+
.prepare(`SELECT child_session_id AS id FROM work_tickets
|
|
16
|
+
WHERE owner_session_id IN (${marks}) AND child_session_id IS NOT NULL
|
|
17
|
+
UNION
|
|
18
|
+
SELECT a.child_session_id AS id FROM work_attempts a
|
|
19
|
+
JOIN work_tickets t ON t.id = a.ticket_id
|
|
20
|
+
WHERE t.owner_session_id IN (${marks}) AND a.child_session_id IS NOT NULL
|
|
21
|
+
UNION
|
|
22
|
+
SELECT session_id AS id FROM session_bindings
|
|
23
|
+
WHERE fork_parent_session_id IN (${marks}) AND session_id IS NOT NULL`)
|
|
24
|
+
.all(...list, ...list, ...list);
|
|
25
|
+
for (const row of rows) {
|
|
26
|
+
if (typeof row.id !== 'string' || row.id === '' || ids.has(row.id))
|
|
27
|
+
continue;
|
|
28
|
+
ids.add(row.id);
|
|
29
|
+
grew = true;
|
|
30
|
+
}
|
|
31
|
+
}
|
|
32
|
+
return [...ids];
|
|
33
|
+
}
|
|
34
|
+
/** Stop schedules and open tickets before the turns are cancelled. */
|
|
35
|
+
export async function quietSessions(store, sessionIds) {
|
|
36
|
+
const ids = unique(sessionIds);
|
|
37
|
+
if (ids.length === 0)
|
|
38
|
+
return;
|
|
39
|
+
const marks = ids.map(() => '?').join(', ');
|
|
40
|
+
const stamp = now();
|
|
41
|
+
await store.write('work', () => {
|
|
42
|
+
store.db
|
|
43
|
+
.prepare(`UPDATE schedules SET enabled = 0, updated_at = ? WHERE session_id IN (${marks})`)
|
|
44
|
+
.run(stamp, ...ids);
|
|
45
|
+
store.db
|
|
46
|
+
.prepare(`UPDATE work_tickets SET status = 'cancelled', updated_at = ?
|
|
47
|
+
WHERE owner_session_id IN (${marks})
|
|
48
|
+
AND status IN ('accepted','enqueued','started','needs_user','ready')`)
|
|
49
|
+
.run(stamp, ...ids);
|
|
50
|
+
store.db
|
|
51
|
+
.prepare(`UPDATE work_attempts SET status = 'cancelled', ended_at = ?
|
|
52
|
+
WHERE status IN ('starting','enqueued','started')
|
|
53
|
+
AND (
|
|
54
|
+
child_session_id IN (${marks})
|
|
55
|
+
OR ticket_id IN (SELECT id FROM work_tickets WHERE owner_session_id IN (${marks}))
|
|
56
|
+
)`)
|
|
57
|
+
.run(stamp, ...ids, ...ids);
|
|
58
|
+
});
|
|
59
|
+
}
|
|
60
|
+
/**
|
|
61
|
+
* Delete session-owned rows, then content-addressed files nothing else references.
|
|
62
|
+
* Shared persona text, public skill blobs, and the workspace directory stay.
|
|
63
|
+
*/
|
|
64
|
+
export async function deleteOwnedSessions(store, sessionIds) {
|
|
65
|
+
const ids = unique(sessionIds);
|
|
66
|
+
if (ids.length === 0)
|
|
67
|
+
return;
|
|
68
|
+
const written = await store.write('session-delete', () => deleteOwnedRows(store.db, ids));
|
|
69
|
+
const hookIds = Array.isArray(written) ? written.filter((id) => typeof id === 'string') : [];
|
|
70
|
+
removeOwnedFiles(store, ids, hookIds);
|
|
71
|
+
}
|
|
72
|
+
export function deleteOwnedCanvases(canvas, sessionIds) {
|
|
73
|
+
canvas.deleteSessions(unique(sessionIds));
|
|
74
|
+
}
|
|
75
|
+
export function deleteOwnedLogs(input) {
|
|
76
|
+
for (const sessionId of unique(input.sessionIds)) {
|
|
77
|
+
if (!STORED_ID.test(sessionId))
|
|
78
|
+
continue;
|
|
79
|
+
eraseSessionStorage({ sessionsRoot: input.sessionsRoot, stateRoot: input.stateRoot, sessionId });
|
|
80
|
+
}
|
|
81
|
+
}
|
|
82
|
+
function deleteOwnedRows(db, ids) {
|
|
83
|
+
const marks = ids.map(() => '?').join(', ');
|
|
84
|
+
const ticketIds = db
|
|
85
|
+
.prepare(`SELECT id FROM work_tickets WHERE owner_session_id IN (${marks})`)
|
|
86
|
+
.all(...ids);
|
|
87
|
+
const tickets = ticketIds.map(row => row.id);
|
|
88
|
+
const ticketMarks = tickets.length > 0 ? tickets.map(() => '?').join(', ') : '';
|
|
89
|
+
const hookRows = db
|
|
90
|
+
.prepare(`SELECT id FROM webhook_hooks WHERE target_session_id IN (${marks})`)
|
|
91
|
+
.all(...ids);
|
|
92
|
+
db.prepare(`DELETE FROM user_deliveries WHERE owner_session_id IN (${marks})
|
|
93
|
+
${ticketMarks ? `OR ticket_id IN (${ticketMarks})` : ''}`).run(...ids, ...tickets);
|
|
94
|
+
if (ticketMarks) {
|
|
95
|
+
db.prepare(`DELETE FROM work_events WHERE ticket_id IN (${ticketMarks})`).run(...tickets);
|
|
96
|
+
db.prepare(`DELETE FROM work_notices WHERE owner_session_id IN (${marks}) OR ticket_id IN (${ticketMarks})`).run(...ids, ...tickets);
|
|
97
|
+
db.prepare(`DELETE FROM work_inputs WHERE ticket_id IN (${ticketMarks})`).run(...tickets);
|
|
98
|
+
db.prepare(`DELETE FROM work_attempts WHERE ticket_id IN (${ticketMarks}) OR child_session_id IN (${marks})`).run(...tickets, ...ids);
|
|
99
|
+
}
|
|
100
|
+
else {
|
|
101
|
+
db.prepare(`DELETE FROM work_notices WHERE owner_session_id IN (${marks})`).run(...ids);
|
|
102
|
+
db.prepare(`DELETE FROM work_attempts WHERE child_session_id IN (${marks})`).run(...ids);
|
|
103
|
+
}
|
|
104
|
+
db.prepare(`DELETE FROM work_tickets WHERE owner_session_id IN (${marks})`).run(...ids);
|
|
105
|
+
db.prepare(`DELETE FROM schedule_fires WHERE schedule_id IN (SELECT id FROM schedules WHERE session_id IN (${marks}))`).run(...ids);
|
|
106
|
+
db.prepare(`DELETE FROM schedules WHERE session_id IN (${marks})`).run(...ids);
|
|
107
|
+
db.prepare(`DELETE FROM webhook_receipts WHERE hook_id IN (SELECT id FROM webhook_hooks WHERE target_session_id IN (${marks}))`).run(...ids);
|
|
108
|
+
db.prepare(`DELETE FROM webhook_hooks WHERE target_session_id IN (${marks})`).run(...ids);
|
|
109
|
+
db.prepare(`DELETE FROM deliveries WHERE target_session_id IN (${marks}) OR sender_session_id IN (${marks})`).run(...ids, ...ids);
|
|
110
|
+
db.prepare(`DELETE FROM delivery_acl WHERE target_session_id IN (${marks}) OR sender_session_id IN (${marks})`).run(...ids, ...ids);
|
|
111
|
+
db.prepare(`DELETE FROM delivery_block WHERE target_session_id IN (${marks}) OR sender_session_id IN (${marks})`).run(...ids, ...ids);
|
|
112
|
+
db.prepare(`DELETE FROM export_outbox WHERE session_id IN (${marks})
|
|
113
|
+
OR mutation_id IN (SELECT id FROM mutations WHERE scope IN (${marks}))`).run(...ids, ...ids);
|
|
114
|
+
db.prepare(`DELETE FROM mutations WHERE scope IN (${marks})`).run(...ids);
|
|
115
|
+
db.prepare(`DELETE FROM view_revisions WHERE session_id IN (${marks})`).run(...ids);
|
|
116
|
+
db.prepare(`DELETE FROM skill_bindings WHERE session_id IN (${marks})`).run(...ids);
|
|
117
|
+
db.prepare(`DELETE FROM working_state WHERE session_id IN (${marks})`).run(...ids);
|
|
118
|
+
db.prepare(`UPDATE facts SET supersedes = NULL WHERE supersedes IN (SELECT id FROM facts WHERE session_id IN (${marks}))`).run(...ids);
|
|
119
|
+
db.prepare(`DELETE FROM facts WHERE session_id IN (${marks})`).run(...ids);
|
|
120
|
+
rebuildFts(db, 'facts_fts', 'content', db.prepare('SELECT id, content FROM facts').all());
|
|
121
|
+
db.prepare(`UPDATE memories SET supersedes = NULL WHERE supersedes IN (SELECT id FROM memories WHERE session_id IN (${marks}))`).run(...ids);
|
|
122
|
+
db.prepare(`DELETE FROM memories WHERE session_id IN (${marks})`).run(...ids);
|
|
123
|
+
rebuildMemoryFts(db);
|
|
124
|
+
db.prepare(`DELETE FROM session_bindings WHERE session_id IN (${marks})`).run(...ids);
|
|
125
|
+
db.prepare(`DELETE FROM persona_versions WHERE id NOT IN (
|
|
126
|
+
SELECT persona_version_id FROM session_bindings WHERE persona_version_id IS NOT NULL
|
|
127
|
+
UNION
|
|
128
|
+
SELECT persona_version_id FROM view_revisions WHERE persona_version_id IS NOT NULL
|
|
129
|
+
)`).run();
|
|
130
|
+
return hookRows.map(row => row.id);
|
|
131
|
+
}
|
|
132
|
+
function rebuildFts(db, table, column, rows) {
|
|
133
|
+
db.exec(`INSERT INTO ${table}(${table}) VALUES('delete-all')`);
|
|
134
|
+
const insert = db.prepare(`INSERT INTO ${table}(rowid, ${column}) VALUES (?, ?)`);
|
|
135
|
+
for (const row of rows)
|
|
136
|
+
insert.run(row.id, row.content);
|
|
137
|
+
}
|
|
138
|
+
function rebuildMemoryFts(db) {
|
|
139
|
+
db.exec(`INSERT INTO memories_fts(memories_fts) VALUES('delete-all')`);
|
|
140
|
+
const insert = db.prepare('INSERT INTO memories_fts(rowid, title, content) VALUES (?, ?, ?)');
|
|
141
|
+
const rows = db.prepare('SELECT id, title, content FROM memories').all();
|
|
142
|
+
for (const row of rows)
|
|
143
|
+
insert.run(row.id, row.title ?? '', row.content);
|
|
144
|
+
}
|
|
145
|
+
function removeOwnedFiles(store, sessionIds, hookIds) {
|
|
146
|
+
const root = store.root;
|
|
147
|
+
for (const sessionId of sessionIds) {
|
|
148
|
+
if (!STORED_ID.test(sessionId))
|
|
149
|
+
continue;
|
|
150
|
+
removeTree(join(root, 'export', sessionId));
|
|
151
|
+
removeTree(join(root, 'src', 'skills', 'private', sessionId));
|
|
152
|
+
}
|
|
153
|
+
for (const hookId of hookIds) {
|
|
154
|
+
if (!/^[A-Za-z0-9-]+$/.test(hookId))
|
|
155
|
+
continue;
|
|
156
|
+
removeFile(join(root, 'secrets', 'webhooks', `${hookId}.key`));
|
|
157
|
+
}
|
|
158
|
+
const personaHashes = hashSet(store.db, 'SELECT content_hash AS hash FROM persona_versions');
|
|
159
|
+
sweepDirectory(join(root, 'blobs', 'persona'), file => file.endsWith('.md') && !personaHashes.has(file.slice(0, -3)));
|
|
160
|
+
const skillHashes = hashSet(store.db, 'SELECT content_hash AS hash FROM skill_bindings');
|
|
161
|
+
sweepDirectory(join(root, 'blobs', 'skills'), name => !skillHashes.has(name), true);
|
|
162
|
+
const workHashes = hashSet(store.db, `SELECT briefing_hash AS hash FROM work_tickets
|
|
163
|
+
UNION SELECT payload_hash AS hash FROM work_inputs
|
|
164
|
+
UNION SELECT payload_hash AS hash FROM work_events`);
|
|
165
|
+
sweepDirectory(join(root, 'blobs', 'work'), file => file.endsWith('.txt') && !workHashes.has(file.slice(0, -4)));
|
|
166
|
+
}
|
|
167
|
+
function hashSet(db, sql) {
|
|
168
|
+
const rows = db.prepare(sql).all();
|
|
169
|
+
const hashes = new Set();
|
|
170
|
+
for (const row of rows)
|
|
171
|
+
if (typeof row.hash === 'string' && row.hash !== '')
|
|
172
|
+
hashes.add(row.hash);
|
|
173
|
+
return hashes;
|
|
174
|
+
}
|
|
175
|
+
function sweepDirectory(dir, unused, directory = false) {
|
|
176
|
+
if (!existsSync(dir))
|
|
177
|
+
return;
|
|
178
|
+
for (const name of readdirSync(dir)) {
|
|
179
|
+
if (name === '.' || name === '..' || !unused(name))
|
|
180
|
+
continue;
|
|
181
|
+
const target = join(dir, name);
|
|
182
|
+
if (lstatSync(target).isSymbolicLink())
|
|
183
|
+
continue;
|
|
184
|
+
if (directory)
|
|
185
|
+
rmSync(target, { recursive: true, force: true });
|
|
186
|
+
else
|
|
187
|
+
removeFile(target);
|
|
188
|
+
}
|
|
189
|
+
}
|
|
190
|
+
function removeTree(dir) {
|
|
191
|
+
if (!existsSync(dir))
|
|
192
|
+
return;
|
|
193
|
+
if (lstatSync(dir).isSymbolicLink())
|
|
194
|
+
return;
|
|
195
|
+
rmSync(dir, { recursive: true, force: true });
|
|
196
|
+
}
|
|
197
|
+
function removeFile(file) {
|
|
198
|
+
if (!existsSync(file) || lstatSync(file).isSymbolicLink())
|
|
199
|
+
return;
|
|
200
|
+
rmSync(file, { force: true });
|
|
201
|
+
}
|
|
202
|
+
function unique(sessionIds) {
|
|
203
|
+
return [...new Set(sessionIds.filter(id => id !== ''))];
|
|
204
|
+
}
|
package/dist/store.js
CHANGED
|
@@ -2,7 +2,7 @@ import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, w
|
|
|
2
2
|
import { join } from 'node:path';
|
|
3
3
|
import { DatabaseSync, backup } from 'node:sqlite';
|
|
4
4
|
import { ensureDir, sha256, writeAtomic } from "./fs-safe.js";
|
|
5
|
-
export const SCHEMA_VERSION =
|
|
5
|
+
export const SCHEMA_VERSION = 5;
|
|
6
6
|
const MIGRATION = `
|
|
7
7
|
PRAGMA foreign_keys = ON;
|
|
8
8
|
|
|
@@ -278,7 +278,7 @@ CREATE TABLE IF NOT EXISTS work_inputs (
|
|
|
278
278
|
ticket_id TEXT NOT NULL,
|
|
279
279
|
attempt_id TEXT NOT NULL,
|
|
280
280
|
briefing_revision INTEGER NOT NULL,
|
|
281
|
-
kind TEXT NOT NULL CHECK (kind IN ('briefing','supply','redirect','cancel_note')),
|
|
281
|
+
kind TEXT NOT NULL CHECK (kind IN ('briefing','supply','redirect','steer','cancel_note')),
|
|
282
282
|
native_message_id TEXT NOT NULL,
|
|
283
283
|
payload_hash TEXT NOT NULL,
|
|
284
284
|
flush_status TEXT NOT NULL CHECK (flush_status IN ('intent','flushing','accepted','ambiguous','dead')),
|
|
@@ -365,6 +365,38 @@ export function openStore(dataDir) {
|
|
|
365
365
|
migrate(db);
|
|
366
366
|
return new Store(db, root);
|
|
367
367
|
}
|
|
368
|
+
/**
|
|
369
|
+
* SQLite cannot alter a CHECK. Databases created before steer rebuild the table.
|
|
370
|
+
* @param {DatabaseSync} db
|
|
371
|
+
*/
|
|
372
|
+
function allowSteerInput(db) {
|
|
373
|
+
const row = db.prepare(`SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'work_inputs'`).get();
|
|
374
|
+
const sql = row?.sql ?? '';
|
|
375
|
+
if (sql === '' || sql.includes("'steer'"))
|
|
376
|
+
return;
|
|
377
|
+
db.exec(`
|
|
378
|
+
CREATE TABLE work_inputs_v5 (
|
|
379
|
+
id TEXT PRIMARY KEY,
|
|
380
|
+
ticket_id TEXT NOT NULL,
|
|
381
|
+
attempt_id TEXT NOT NULL,
|
|
382
|
+
briefing_revision INTEGER NOT NULL,
|
|
383
|
+
kind TEXT NOT NULL CHECK (kind IN ('briefing','supply','redirect','steer','cancel_note')),
|
|
384
|
+
native_message_id TEXT NOT NULL,
|
|
385
|
+
payload_hash TEXT NOT NULL,
|
|
386
|
+
flush_status TEXT NOT NULL CHECK (flush_status IN ('intent','flushing','accepted','ambiguous','dead')),
|
|
387
|
+
flush_pid INTEGER,
|
|
388
|
+
flush_attempts INTEGER NOT NULL DEFAULT 0,
|
|
389
|
+
last_error TEXT NOT NULL DEFAULT '',
|
|
390
|
+
log_seq INTEGER,
|
|
391
|
+
created_at TEXT NOT NULL,
|
|
392
|
+
updated_at TEXT NOT NULL
|
|
393
|
+
);
|
|
394
|
+
INSERT INTO work_inputs_v5 SELECT * FROM work_inputs;
|
|
395
|
+
DROP TABLE work_inputs;
|
|
396
|
+
ALTER TABLE work_inputs_v5 RENAME TO work_inputs;
|
|
397
|
+
CREATE INDEX IF NOT EXISTS work_inputs_attempt ON work_inputs(attempt_id, briefing_revision);
|
|
398
|
+
`);
|
|
399
|
+
}
|
|
368
400
|
/**
|
|
369
401
|
* @param {DatabaseSync} db
|
|
370
402
|
*/
|
|
@@ -372,11 +404,22 @@ function migrate(db) {
|
|
|
372
404
|
db.exec(MIGRATION);
|
|
373
405
|
db.exec(MIGRATION_V2);
|
|
374
406
|
db.exec(MIGRATION_V4);
|
|
407
|
+
allowSteerInput(db);
|
|
408
|
+
db.exec(`
|
|
409
|
+
CREATE TABLE IF NOT EXISTS card_log (
|
|
410
|
+
kind TEXT NOT NULL,
|
|
411
|
+
key TEXT NOT NULL,
|
|
412
|
+
session_id TEXT NOT NULL,
|
|
413
|
+
payload TEXT NOT NULL,
|
|
414
|
+
seq INTEGER,
|
|
415
|
+
PRIMARY KEY (kind, key)
|
|
416
|
+
)
|
|
417
|
+
`);
|
|
375
418
|
const columns = db.prepare('PRAGMA table_info(session_bindings)').all();
|
|
376
419
|
if (!columns.some(column => column.name === 'kind')) {
|
|
377
420
|
db.exec(`ALTER TABLE session_bindings ADD COLUMN kind TEXT NOT NULL DEFAULT 'session' CHECK (kind IN ('session','bot'))`);
|
|
378
421
|
}
|
|
379
|
-
for (
|
|
422
|
+
for (let version = 1; version <= SCHEMA_VERSION; version++) {
|
|
380
423
|
const row = db.prepare('SELECT version FROM schema_migrations WHERE version = ?').get(version);
|
|
381
424
|
if (!row)
|
|
382
425
|
db.prepare('INSERT INTO schema_migrations (version, applied_at) VALUES (?, ?)').run(version, now());
|
package/dist/triggers.js
CHANGED
|
@@ -1,6 +1,7 @@
|
|
|
1
1
|
import { createHmac, randomUUID, timingSafeEqual, createHash } from 'node:crypto';
|
|
2
2
|
import { writeFileSync } from 'node:fs';
|
|
3
3
|
import { join } from 'node:path';
|
|
4
|
+
import { isFenced } from "./deleting.js";
|
|
4
5
|
import { toolError } from "./errors.js";
|
|
5
6
|
import { nextCron } from "./cron.js";
|
|
6
7
|
const SESSION_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,200}$/;
|
|
@@ -518,6 +519,9 @@ export function createTriggers(store, options) {
|
|
|
518
519
|
* @param {Record<string, unknown>} input
|
|
519
520
|
*/
|
|
520
521
|
async function enqueueNew(input) {
|
|
522
|
+
if (isFenced(String(input.target ?? '')) || isFenced(String(input.sender ?? ''))) {
|
|
523
|
+
return toolError('FORBIDDEN', 'This session is being deleted.');
|
|
524
|
+
}
|
|
521
525
|
const hash = sha(String(input.body));
|
|
522
526
|
const existing = db
|
|
523
527
|
.prepare(`
|
|
@@ -592,6 +596,10 @@ export function createTriggers(store, options) {
|
|
|
592
596
|
* @param {Record<string, any>} row
|
|
593
597
|
*/
|
|
594
598
|
async function fireSchedule(row) {
|
|
599
|
+
if (isFenced(row.session_id)) {
|
|
600
|
+
db.prepare('UPDATE schedules SET enabled = 0, updated_at = ? WHERE id = ?').run(iso(), row.id);
|
|
601
|
+
return;
|
|
602
|
+
}
|
|
595
603
|
if (requireBot(row.session_id)) {
|
|
596
604
|
db.prepare('UPDATE schedules SET enabled = 0, updated_at = ? WHERE id = ?').run(iso(), row.id);
|
|
597
605
|
return;
|