@thready-web/dsh-bot-plugin 0.0.0-stage → 0.1.0-beta.0

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/dist/store.js ADDED
@@ -0,0 +1,598 @@
1
+ import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
2
+ import { join } from 'node:path';
3
+ import { DatabaseSync, backup } from 'node:sqlite';
4
+ import { ensureDir, sha256, writeAtomic } from "./fs-safe.js";
5
+ export const SCHEMA_VERSION = 4;
6
+ const MIGRATION = `
7
+ PRAGMA foreign_keys = ON;
8
+
9
+ CREATE TABLE IF NOT EXISTS schema_migrations (
10
+ version INTEGER PRIMARY KEY,
11
+ applied_at TEXT NOT NULL
12
+ );
13
+
14
+ CREATE TABLE IF NOT EXISTS persona_versions (
15
+ id INTEGER PRIMARY KEY,
16
+ content_hash TEXT NOT NULL UNIQUE,
17
+ byte_length INTEGER NOT NULL,
18
+ note TEXT,
19
+ created_by TEXT NOT NULL CHECK (created_by IN ('user','import')),
20
+ created_at TEXT NOT NULL
21
+ );
22
+
23
+ CREATE TABLE IF NOT EXISTS session_bindings (
24
+ session_id TEXT PRIMARY KEY,
25
+ kind TEXT NOT NULL DEFAULT 'session' CHECK (kind IN ('session','bot')),
26
+ status TEXT NOT NULL CHECK (status IN
27
+ ('initializing','active','paused','archived','error')),
28
+ schema_version INTEGER NOT NULL,
29
+ persona_version_id INTEGER REFERENCES persona_versions(id),
30
+ fork_parent_session_id TEXT,
31
+ fork_seeded INTEGER NOT NULL DEFAULT 0 CHECK (fork_seeded IN (0,1)),
32
+ last_view_revision INTEGER NOT NULL DEFAULT 0,
33
+ last_event_watermark TEXT,
34
+ compaction_epoch INTEGER NOT NULL DEFAULT 0,
35
+ error_code TEXT,
36
+ created_at TEXT NOT NULL,
37
+ updated_at TEXT NOT NULL
38
+ );
39
+
40
+ CREATE TABLE IF NOT EXISTS facts (
41
+ id INTEGER PRIMARY KEY,
42
+ session_id TEXT NOT NULL REFERENCES session_bindings(session_id),
43
+ kind TEXT NOT NULL DEFAULT 'user_fact',
44
+ content TEXT NOT NULL,
45
+ status TEXT NOT NULL CHECK (status IN
46
+ ('candidate','active','superseded','forgotten')),
47
+ source_event_id TEXT,
48
+ source_type TEXT NOT NULL CHECK (source_type IN
49
+ ('explicit_tool','user_confirm','candidate_extract')),
50
+ supersedes INTEGER REFERENCES facts(id),
51
+ revision INTEGER NOT NULL,
52
+ priority INTEGER NOT NULL DEFAULT 100,
53
+ created_at TEXT NOT NULL,
54
+ updated_at TEXT NOT NULL
55
+ );
56
+ CREATE INDEX IF NOT EXISTS facts_session_status ON facts(session_id, status);
57
+
58
+ CREATE TABLE IF NOT EXISTS memories (
59
+ id INTEGER PRIMARY KEY,
60
+ session_id TEXT NOT NULL REFERENCES session_bindings(session_id),
61
+ title TEXT,
62
+ content TEXT NOT NULL,
63
+ status TEXT NOT NULL CHECK (status IN
64
+ ('candidate','active','superseded','forgotten')),
65
+ source_event_id TEXT,
66
+ source_type TEXT NOT NULL CHECK (source_type IN
67
+ ('explicit_tool','user_confirm','candidate_extract')),
68
+ supersedes INTEGER REFERENCES memories(id),
69
+ revision INTEGER NOT NULL,
70
+ created_at TEXT NOT NULL,
71
+ updated_at TEXT NOT NULL
72
+ );
73
+ CREATE INDEX IF NOT EXISTS memories_session_status ON memories(session_id, status);
74
+
75
+ CREATE TABLE IF NOT EXISTS working_state (
76
+ session_id TEXT PRIMARY KEY REFERENCES session_bindings(session_id),
77
+ revision INTEGER NOT NULL,
78
+ payload_json TEXT NOT NULL,
79
+ updated_at TEXT NOT NULL
80
+ );
81
+
82
+ CREATE TABLE IF NOT EXISTS skill_bindings (
83
+ session_id TEXT NOT NULL REFERENCES session_bindings(session_id),
84
+ skill_id TEXT NOT NULL,
85
+ scope TEXT NOT NULL CHECK (scope IN ('private','public')),
86
+ version TEXT NOT NULL,
87
+ content_hash TEXT NOT NULL,
88
+ summary TEXT NOT NULL DEFAULT '',
89
+ enabled INTEGER NOT NULL CHECK (enabled IN (0,1)),
90
+ revoked INTEGER NOT NULL DEFAULT 0 CHECK (revoked IN (0,1)),
91
+ bound_at TEXT NOT NULL,
92
+ PRIMARY KEY (session_id, skill_id)
93
+ );
94
+
95
+ CREATE TABLE IF NOT EXISTS mutations (
96
+ id INTEGER PRIMARY KEY,
97
+ scope TEXT NOT NULL,
98
+ idempotency_key TEXT NOT NULL,
99
+ payload_hash TEXT NOT NULL,
100
+ tool_name TEXT NOT NULL,
101
+ request_json TEXT NOT NULL,
102
+ result_json TEXT NOT NULL,
103
+ outcome TEXT NOT NULL CHECK (outcome IN
104
+ ('applied','replayed','rejected')),
105
+ created_at TEXT NOT NULL,
106
+ UNIQUE (scope, idempotency_key)
107
+ );
108
+
109
+ CREATE TABLE IF NOT EXISTS view_revisions (
110
+ session_id TEXT NOT NULL REFERENCES session_bindings(session_id),
111
+ revision INTEGER NOT NULL,
112
+ frozen_at TEXT NOT NULL,
113
+ event_watermark TEXT,
114
+ persona_version_id INTEGER,
115
+ working_state_rev INTEGER,
116
+ snapshot_hash TEXT NOT NULL,
117
+ compaction_epoch INTEGER NOT NULL,
118
+ presence TEXT NOT NULL CHECK (presence IN
119
+ ('present','unknown','needs_reinject')),
120
+ selected_json TEXT NOT NULL,
121
+ PRIMARY KEY (session_id, revision)
122
+ );
123
+
124
+ CREATE TABLE IF NOT EXISTS export_outbox (
125
+ id INTEGER PRIMARY KEY,
126
+ session_id TEXT NOT NULL,
127
+ mutation_id INTEGER REFERENCES mutations(id),
128
+ status TEXT NOT NULL CHECK (status IN
129
+ ('pending','done','failed')),
130
+ attempts INTEGER NOT NULL DEFAULT 0,
131
+ last_error TEXT,
132
+ updated_at TEXT NOT NULL
133
+ );
134
+
135
+ CREATE VIRTUAL TABLE IF NOT EXISTS facts_fts USING fts5(
136
+ content,
137
+ content='facts',
138
+ content_rowid='id',
139
+ tokenize='unicode61'
140
+ );
141
+ CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
142
+ title, content,
143
+ content='memories',
144
+ content_rowid='id',
145
+ tokenize='unicode61'
146
+ );
147
+ `;
148
+ const MIGRATION_V2 = `
149
+ CREATE TABLE IF NOT EXISTS delivery_acl (
150
+ target_session_id TEXT NOT NULL,
151
+ sender_session_id TEXT NOT NULL,
152
+ created_at TEXT NOT NULL,
153
+ PRIMARY KEY (target_session_id, sender_session_id)
154
+ );
155
+
156
+ CREATE TABLE IF NOT EXISTS delivery_block (
157
+ target_session_id TEXT NOT NULL,
158
+ sender_session_id TEXT NOT NULL,
159
+ created_at TEXT NOT NULL,
160
+ PRIMARY KEY (target_session_id, sender_session_id)
161
+ );
162
+
163
+ CREATE TABLE IF NOT EXISTS deliveries (
164
+ id TEXT PRIMARY KEY,
165
+ kind TEXT NOT NULL CHECK (kind IN ('message','timer','webhook')),
166
+ idempotency_key TEXT NOT NULL,
167
+ sender_session_id TEXT NOT NULL DEFAULT '',
168
+ target_session_id TEXT NOT NULL,
169
+ correlation_id TEXT NOT NULL,
170
+ causation_id TEXT,
171
+ hop INTEGER NOT NULL,
172
+ body TEXT NOT NULL,
173
+ body_hash TEXT NOT NULL,
174
+ status TEXT NOT NULL CHECK (status IN (
175
+ 'intent','flushing','accepted','claimed','started','completed',
176
+ 'interrupted','failed','ambiguous','dead','rejected','skipped'
177
+ )),
178
+ splice_seq INTEGER,
179
+ turn_number INTEGER,
180
+ attempts INTEGER NOT NULL DEFAULT 0,
181
+ flush_pid INTEGER,
182
+ last_error TEXT,
183
+ expires_at TEXT,
184
+ created_at TEXT NOT NULL,
185
+ updated_at TEXT NOT NULL,
186
+ UNIQUE (kind, sender_session_id, target_session_id, idempotency_key)
187
+ );
188
+ CREATE INDEX IF NOT EXISTS deliveries_target_status ON deliveries(target_session_id, status);
189
+ CREATE INDEX IF NOT EXISTS deliveries_correlation ON deliveries(correlation_id);
190
+
191
+ CREATE TABLE IF NOT EXISTS schedules (
192
+ id TEXT PRIMARY KEY,
193
+ session_id TEXT NOT NULL,
194
+ kind TEXT NOT NULL CHECK (kind IN ('one-shot','cron')),
195
+ cron_expr TEXT,
196
+ timezone TEXT NOT NULL,
197
+ run_at TEXT,
198
+ next_due TEXT,
199
+ enabled INTEGER NOT NULL CHECK (enabled IN (0,1)),
200
+ deleted INTEGER NOT NULL DEFAULT 0 CHECK (deleted IN (0,1)),
201
+ note TEXT NOT NULL DEFAULT '',
202
+ created_at TEXT NOT NULL,
203
+ updated_at TEXT NOT NULL
204
+ );
205
+
206
+ CREATE TABLE IF NOT EXISTS schedule_fires (
207
+ occurrence_id TEXT PRIMARY KEY,
208
+ schedule_id TEXT NOT NULL,
209
+ delivery_id TEXT,
210
+ slot_at TEXT NOT NULL,
211
+ status TEXT NOT NULL CHECK (status IN ('armed','enqueued','coalesced','skipped','failed')),
212
+ created_at TEXT NOT NULL
213
+ );
214
+
215
+ CREATE TABLE IF NOT EXISTS webhook_hooks (
216
+ id TEXT PRIMARY KEY,
217
+ target_session_id TEXT NOT NULL,
218
+ secret TEXT NOT NULL,
219
+ enabled INTEGER NOT NULL CHECK (enabled IN (0,1)),
220
+ created_at TEXT NOT NULL,
221
+ revoked_at TEXT
222
+ );
223
+
224
+ CREATE TABLE IF NOT EXISTS webhook_receipts (
225
+ hook_id TEXT NOT NULL,
226
+ event_id TEXT NOT NULL,
227
+ body_hash TEXT NOT NULL,
228
+ delivery_id TEXT,
229
+ received_at TEXT NOT NULL,
230
+ PRIMARY KEY (hook_id, event_id)
231
+ );
232
+ `;
233
+ const MIGRATION_V4 = `
234
+ CREATE TABLE IF NOT EXISTS work_tickets (
235
+ id TEXT PRIMARY KEY,
236
+ owner_session_id TEXT NOT NULL,
237
+ child_session_id TEXT,
238
+ revision INTEGER NOT NULL,
239
+ briefing_revision INTEGER NOT NULL,
240
+ status TEXT NOT NULL CHECK (status IN (
241
+ 'accepted','enqueued','started','needs_user','ready',
242
+ 'delivered','cancelled','failed'
243
+ )),
244
+ review_status TEXT NOT NULL CHECK (review_status IN ('none','candidate','rejected')),
245
+ active_attempt_id TEXT,
246
+ briefing_hash TEXT NOT NULL,
247
+ correlation_id TEXT NOT NULL DEFAULT '',
248
+ idempotency_key TEXT,
249
+ parent_ticket_id TEXT,
250
+ budget_json TEXT NOT NULL,
251
+ cancel_requested_revision INTEGER,
252
+ created_at TEXT NOT NULL,
253
+ updated_at TEXT NOT NULL,
254
+ UNIQUE (owner_session_id, idempotency_key)
255
+ );
256
+ CREATE INDEX IF NOT EXISTS work_tickets_owner_status ON work_tickets(owner_session_id, status);
257
+
258
+ CREATE TABLE IF NOT EXISTS work_attempts (
259
+ id TEXT PRIMARY KEY,
260
+ ticket_id TEXT NOT NULL,
261
+ child_session_id TEXT,
262
+ fencing_token INTEGER NOT NULL,
263
+ briefing_revision INTEGER NOT NULL,
264
+ current_input_id TEXT,
265
+ status TEXT NOT NULL CHECK (status IN (
266
+ 'starting','enqueued','started','succeeded','failed','superseded','cancelled'
267
+ )),
268
+ lease_until TEXT,
269
+ lease_observed_seq INTEGER,
270
+ started_at TEXT,
271
+ ended_at TEXT
272
+ );
273
+ CREATE INDEX IF NOT EXISTS work_attempts_ticket ON work_attempts(ticket_id);
274
+ CREATE INDEX IF NOT EXISTS work_attempts_child ON work_attempts(child_session_id);
275
+
276
+ CREATE TABLE IF NOT EXISTS work_inputs (
277
+ id TEXT PRIMARY KEY,
278
+ ticket_id TEXT NOT NULL,
279
+ attempt_id TEXT NOT NULL,
280
+ briefing_revision INTEGER NOT NULL,
281
+ kind TEXT NOT NULL CHECK (kind IN ('briefing','supply','redirect','cancel_note')),
282
+ native_message_id TEXT NOT NULL,
283
+ payload_hash TEXT NOT NULL,
284
+ flush_status TEXT NOT NULL CHECK (flush_status IN ('intent','flushing','accepted','ambiguous','dead')),
285
+ flush_pid INTEGER,
286
+ flush_attempts INTEGER NOT NULL DEFAULT 0,
287
+ last_error TEXT NOT NULL DEFAULT '',
288
+ log_seq INTEGER,
289
+ created_at TEXT NOT NULL,
290
+ updated_at TEXT NOT NULL
291
+ );
292
+ CREATE INDEX IF NOT EXISTS work_inputs_attempt ON work_inputs(attempt_id, briefing_revision);
293
+
294
+ CREATE TABLE IF NOT EXISTS work_notices (
295
+ id TEXT PRIMARY KEY,
296
+ ticket_id TEXT NOT NULL,
297
+ event_id TEXT NOT NULL,
298
+ owner_session_id TEXT NOT NULL,
299
+ native_message_id TEXT NOT NULL,
300
+ flush_status TEXT NOT NULL CHECK (flush_status IN ('intent','flushing','accepted','ambiguous','dead')),
301
+ flush_pid INTEGER,
302
+ flush_attempts INTEGER NOT NULL DEFAULT 0,
303
+ last_error TEXT NOT NULL DEFAULT '',
304
+ log_seq INTEGER,
305
+ observe_status TEXT NOT NULL CHECK (observe_status IN ('none','claimed','started','completed')),
306
+ created_at TEXT NOT NULL,
307
+ updated_at TEXT NOT NULL,
308
+ UNIQUE (ticket_id, event_id)
309
+ );
310
+ CREATE INDEX IF NOT EXISTS work_notices_owner ON work_notices(owner_session_id, flush_status);
311
+
312
+ CREATE TABLE IF NOT EXISTS work_events (
313
+ event_id TEXT PRIMARY KEY,
314
+ ticket_id TEXT NOT NULL,
315
+ attempt_id TEXT NOT NULL,
316
+ fencing_token INTEGER NOT NULL,
317
+ briefing_revision INTEGER NOT NULL,
318
+ kind TEXT NOT NULL CHECK (kind IN ('progress','question','artifact','result','failure')),
319
+ apply_status TEXT NOT NULL CHECK (apply_status IN ('pending_completion','applied','stale')),
320
+ turn_end_reason TEXT,
321
+ payload_hash TEXT NOT NULL,
322
+ notice_id TEXT,
323
+ created_at TEXT NOT NULL
324
+ );
325
+ CREATE INDEX IF NOT EXISTS work_events_ticket ON work_events(ticket_id, created_at);
326
+
327
+ CREATE TABLE IF NOT EXISTS user_deliveries (
328
+ publish_id TEXT PRIMARY KEY,
329
+ ticket_id TEXT NOT NULL,
330
+ result_event_id TEXT NOT NULL,
331
+ owner_session_id TEXT NOT NULL,
332
+ attempt_id TEXT NOT NULL,
333
+ fencing_token INTEGER NOT NULL,
334
+ briefing_revision INTEGER NOT NULL,
335
+ text_hash TEXT NOT NULL,
336
+ status TEXT NOT NULL CHECK (status IN ('intent','log_bound','abandoned')),
337
+ assistant_seq INTEGER,
338
+ turn_native_id TEXT,
339
+ client_ack_at TEXT,
340
+ created_at TEXT NOT NULL,
341
+ UNIQUE (ticket_id, result_event_id)
342
+ );
343
+ `;
344
+ /**
345
+ * @param {string} dataDir
346
+ */
347
+ export function openStore(dataDir) {
348
+ const root = ensureDir(dataDir);
349
+ for (const dir of ['blobs/persona', 'blobs/skills', 'src/soul', 'src/skills/public', 'src/skills/private', 'export', 'backups', 'secrets/webhooks']) {
350
+ mkdirSync(join(root, dir), { recursive: true, mode: 0o700 });
351
+ }
352
+ const db = new DatabaseSync(join(root, 'persona.sqlite'));
353
+ db.exec('PRAGMA foreign_keys = ON');
354
+ db.exec('PRAGMA journal_mode = WAL');
355
+ db.exec('PRAGMA busy_timeout = 5000');
356
+ migrate(db);
357
+ return new Store(db, root);
358
+ }
359
+ /**
360
+ * @param {DatabaseSync} db
361
+ */
362
+ function migrate(db) {
363
+ db.exec(MIGRATION);
364
+ db.exec(MIGRATION_V2);
365
+ db.exec(MIGRATION_V4);
366
+ const columns = db.prepare('PRAGMA table_info(session_bindings)').all();
367
+ if (!columns.some(column => column.name === 'kind')) {
368
+ db.exec(`ALTER TABLE session_bindings ADD COLUMN kind TEXT NOT NULL DEFAULT 'session' CHECK (kind IN ('session','bot'))`);
369
+ }
370
+ for (const version of [1, 2, 3, SCHEMA_VERSION]) {
371
+ const row = db.prepare('SELECT version FROM schema_migrations WHERE version = ?').get(version);
372
+ if (!row)
373
+ db.prepare('INSERT INTO schema_migrations (version, applied_at) VALUES (?, ?)').run(version, now());
374
+ }
375
+ }
376
+ function now() {
377
+ return new Date().toISOString();
378
+ }
379
+ class KeyedLock {
380
+ tails;
381
+ constructor() {
382
+ /** @type {Map<string, Promise<void>>} */
383
+ this.tails = new Map();
384
+ }
385
+ /**
386
+ * @param {string} key
387
+ * @param {() => unknown} fn
388
+ * @param {number} timeoutMs
389
+ */
390
+ async run(key, fn, timeoutMs) {
391
+ const prev = this.tails.get(key) ?? Promise.resolve();
392
+ let release = () => { };
393
+ const current = new Promise(resolve => { release = () => resolve(); });
394
+ this.tails.set(key, current);
395
+ let timer;
396
+ const acquired = await Promise.race([
397
+ prev.then(() => 'ok'),
398
+ new Promise(resolve => { timer = setTimeout(() => resolve('busy'), timeoutMs); }),
399
+ ]);
400
+ clearTimeout(timer);
401
+ if (acquired !== 'ok') {
402
+ prev.then(() => release());
403
+ const error = Object.assign(new Error('BUSY'), { code: 'BUSY' });
404
+ throw error;
405
+ }
406
+ try {
407
+ return await fn();
408
+ }
409
+ finally {
410
+ release();
411
+ if (this.tails.get(key) === current)
412
+ this.tails.delete(key);
413
+ }
414
+ }
415
+ }
416
+ export class Store {
417
+ db;
418
+ root;
419
+ lock;
420
+ busyTimeoutMs;
421
+ /**
422
+ * @param {DatabaseSync} db
423
+ * @param {string} root
424
+ */
425
+ constructor(db, root) {
426
+ this.db = db;
427
+ this.root = root;
428
+ this.lock = new KeyedLock();
429
+ this.busyTimeoutMs = 5000;
430
+ }
431
+ close() {
432
+ this.db.close();
433
+ }
434
+ /**
435
+ * @param {string} scope
436
+ * @param {() => unknown} fn
437
+ */
438
+ async write(scope, fn) {
439
+ return this.lock.run(scope, () => {
440
+ this.db.exec('BEGIN IMMEDIATE');
441
+ try {
442
+ const value = fn();
443
+ this.db.exec('COMMIT');
444
+ return value;
445
+ }
446
+ catch (error) {
447
+ try {
448
+ this.db.exec('ROLLBACK');
449
+ }
450
+ catch { /* already closed */ }
451
+ throw error;
452
+ }
453
+ }, this.busyTimeoutMs);
454
+ }
455
+ /**
456
+ * @param {() => unknown} fn
457
+ */
458
+ read(fn) {
459
+ this.db.exec('BEGIN');
460
+ try {
461
+ return fn();
462
+ }
463
+ finally {
464
+ this.db.exec('ROLLBACK');
465
+ }
466
+ }
467
+ /**
468
+ * @param {string} kind
469
+ * @param {string} hash
470
+ * @param {Buffer | string} bytes
471
+ */
472
+ writeBlob(kind, hash, bytes) {
473
+ const dir = join(this.root, 'blobs', kind === 'persona' ? 'persona' : join('skills', hash));
474
+ if (kind === 'persona') {
475
+ const file = join(this.root, 'blobs', 'persona', `${hash}.md`);
476
+ if (!existsSync(file))
477
+ writeAtomic(file, bytes);
478
+ return file;
479
+ }
480
+ mkdirSync(dir, { recursive: true, mode: 0o700 });
481
+ const file = join(dir, 'SKILL.md');
482
+ if (!existsSync(file))
483
+ writeAtomic(file, bytes);
484
+ return file;
485
+ }
486
+ /**
487
+ * @param {'persona' | 'skill'} kind
488
+ * @param {string} hash
489
+ */
490
+ readBlob(kind, hash) {
491
+ const file = kind === 'persona'
492
+ ? join(this.root, 'blobs', 'persona', `${hash}.md`)
493
+ : join(this.root, 'blobs', 'skills', hash, 'SKILL.md');
494
+ if (!existsSync(file))
495
+ return null;
496
+ return readFileSync(file);
497
+ }
498
+ /**
499
+ * Consistent snapshot. Callers must not copy persona.sqlite* while this
500
+ * connection is open and pretend that copy is consistent.
501
+ * @param {string} destDir
502
+ */
503
+ async backupTo(destDir) {
504
+ mkdirSync(destDir, { recursive: true, mode: 0o700 });
505
+ const dbFile = join(destDir, 'persona.sqlite');
506
+ await backup(this.db, dbFile, { rate: 1 });
507
+ const copied = [];
508
+ const personas = this.db.prepare('SELECT content_hash FROM persona_versions').all();
509
+ for (const row of personas) {
510
+ const bytes = this.readBlob('persona', row.content_hash);
511
+ if (!bytes)
512
+ continue;
513
+ const target = join(destDir, 'blobs', 'persona', `${row.content_hash}.md`);
514
+ mkdirSync(join(destDir, 'blobs', 'persona'), { recursive: true, mode: 0o700 });
515
+ writeAtomic(target, bytes);
516
+ copied.push({ kind: 'persona', hash: row.content_hash, sha256: sha256(bytes) });
517
+ }
518
+ const skills = this.db.prepare('SELECT DISTINCT content_hash FROM skill_bindings').all();
519
+ for (const row of skills) {
520
+ const bytes = this.readBlob('skill', row.content_hash);
521
+ if (!bytes)
522
+ continue;
523
+ const target = join(destDir, 'blobs', 'skills', row.content_hash, 'SKILL.md');
524
+ mkdirSync(join(destDir, 'blobs', 'skills', row.content_hash), { recursive: true, mode: 0o700 });
525
+ writeAtomic(target, bytes);
526
+ copied.push({ kind: 'skill', hash: row.content_hash, sha256: sha256(bytes) });
527
+ }
528
+ const manifest = {
529
+ createdAt: now(),
530
+ schemaVersion: SCHEMA_VERSION,
531
+ method: 'node:sqlite backup()',
532
+ files: copied,
533
+ };
534
+ writeFileSync(join(destDir, 'manifest.json'), JSON.stringify(manifest, null, 2), { mode: 0o600 });
535
+ return manifest;
536
+ }
537
+ }
538
+ export { now };
539
+ /**
540
+ * Replace a stopped store directory from a backup produced by backupTo.
541
+ * Refuses when ownerPid is still running. Does not copy sqlite WAL files.
542
+ * @param {string} dataDir
543
+ * @param {string} backupDir
544
+ * @param {number | null} ownerPid
545
+ */
546
+ export async function restoreBackup(dataDir, backupDir, ownerPid) {
547
+ if (ownerPid != null && pidAlive(ownerPid)) {
548
+ throw Object.assign(new Error('profile store is open; stop dsh before restore'), { code: 'BUSY' });
549
+ }
550
+ const snapshot = join(backupDir, 'persona.sqlite');
551
+ if (!existsSync(snapshot))
552
+ throw new Error('backup has no persona.sqlite');
553
+ mkdirSync(dataDir, { recursive: true, mode: 0o700 });
554
+ const source = new DatabaseSync(snapshot, { readOnly: true });
555
+ const staging = join(dataDir, `persona.restore-${Date.now()}.sqlite`);
556
+ try {
557
+ await backup(source, staging);
558
+ }
559
+ finally {
560
+ source.close();
561
+ }
562
+ const next = join(dataDir, 'persona.sqlite.next');
563
+ writeAtomic(next, readFileSync(staging));
564
+ rmSync(staging, { force: true });
565
+ for (const suffix of ['-wal', '-shm'])
566
+ rmSync(join(dataDir, `persona.sqlite${suffix}`), { force: true });
567
+ renameSync(next, join(dataDir, 'persona.sqlite'));
568
+ const blobRoot = join(backupDir, 'blobs');
569
+ if (existsSync(blobRoot))
570
+ copyTree(blobRoot, join(dataDir, 'blobs'));
571
+ }
572
+ /**
573
+ * @param {number} pid
574
+ */
575
+ export function pidAlive(pid) {
576
+ try {
577
+ process.kill(pid, 0);
578
+ return true;
579
+ }
580
+ catch {
581
+ return false;
582
+ }
583
+ }
584
+ /**
585
+ * @param {string} from
586
+ * @param {string} to
587
+ */
588
+ function copyTree(from, to) {
589
+ mkdirSync(to, { recursive: true, mode: 0o700 });
590
+ for (const name of readdirSync(from, { withFileTypes: true })) {
591
+ const src = join(from, name.name);
592
+ const dest = join(to, name.name);
593
+ if (name.isDirectory())
594
+ copyTree(src, dest);
595
+ else
596
+ writeAtomic(dest, readFileSync(src));
597
+ }
598
+ }