@xopcai/xopc 0.0.313 → 0.0.314

package/dist/src/notes/service.js

@@ -1,22 +1,29 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
+import { currentOperationId, init_operation_context } from "../infra/operation-context.js";
+import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
 import { buildNoteAttachmentRef } from "./attachment-ref.js";
 import { parseNoteMarkdown } from "./note-markdown.js";
 import { listNoteProjectSummaries } from "../storage/sqlite/notes-repository.js";
 import { changedFieldsFromPatch, emitActivity, previewText, systemActivityActor, systemActivitySource } from "../activity/emitter.js";
 import { getDefaultModelSync, init_providers, resolveModel } from "../providers/index.js";
-import { completeWithResolvedCredentials } from "../providers/model-call.js";
+import { DomainOutboxDispatcher } from "../infra/domain-outbox-dispatcher.js";
 import { publishAutomationProductEvent } from "../automations/product-events.js";
-import { NotesStore } from "./store.js";
+import { completeWithResolvedCredentials } from "../providers/model-call.js";
 import { partitionAttachmentsByReference } from "./note-attachment-sync.js";
 import { buildNoteAgentContextArtifact, getCachedNoteAgentContextArtifact } from "./agent-context.js";
+import { revokeNoteShareRecords } from "../share/note-share-revocation.js";
+import { NotesStore } from "./store.js";
 import { createHash, randomUUID } from "node:crypto";
 //#region src/notes/service.ts
 init_providers();
 init_logger();
+init_transaction();
+init_operation_context();
 const log = createLogger("NotesService");
 const MAX_SNAPSHOTS_PER_NOTE = 50;
 const SNAPSHOT_THROTTLE_MS = 6e4;
+var NoteRevisionConflictError = class extends Error {};
 function quickCaptureId(idempotencyKey) {
 	return `capture_${createHash("sha256").update(`xopc:quick-capture:${idempotencyKey}`).digest("hex").slice(0, 32)}`;
 }
@@ -46,21 +53,21 @@ function splitMeaningfulLines(markdown) {
 function summarizeIdea(markdown) {
 	return splitMeaningfulLines(markdown).slice(0, 3).join("；").slice(0, 140);
 }
-function publishNoteEvent(type, note, extra) {
-	publishAutomationProductEvent({
-		type,
-		source: "notes",
-		payload: {
-			noteId: note.id,
-			kind: note.kind,
-			status: note.status,
-			title: note.title,
-			capturedVia: note.capturedVia,
-			tagCount: note.tags?.length ?? 0,
-			hasAttachments: Boolean(note.attachments?.length),
-			...extra
-		}
-	});
+function enqueueNoteEvent(type, note, extra) {
+	const payload = {
+		noteId: note.id,
+		kind: note.kind,
+		status: note.status,
+		title: note.title,
+		capturedVia: note.capturedVia,
+		tagCount: note.tags?.length ?? 0,
+		hasAttachments: Boolean(note.attachments?.length),
+		revision: note.remoteVersion ?? 1,
+		...extra
+	};
+	getSqliteDatabase().prepare(`INSERT INTO domain_outbox
+    (event_id, event_type, subject_kind, subject_id, correlation_id, payload_json, created_at, operation_id)
+    VALUES (?, ?, 'note', ?, ?, ?, ?, ?)`).run(randomUUID(), type, note.id, note.id, JSON.stringify(payload), note.updatedAt, currentOperationId() ?? null);
 }
 function inferCatalysisStage(note) {
 	const text = `${note.title ?? ""}\n${note.markdown}`;
@@ -152,82 +159,49 @@ async function buildAiCatalysisReport(note, config) {
 	return normalizeAiCatalysisReport(note, JSON.parse(raw));
 }
 var NotesService = class {
-	lastSnapshotAt = /* @__PURE__ */ new Map();
-	quickCapturesInFlight = /* @__PURE__ */ new Map();
-	noteCapturesInFlight = /* @__PURE__ */ new Map();
 	noteAttachmentsInFlight = /* @__PURE__ */ new Map();
 	constructor(store = new NotesStore()) {
 		this.store = store;
 	}
 	async initialize() {
 		await this.store.initialize();
+		this.flushCommittedEffects();
+	}
+	flushCommittedEffects() {
+		this.store.drainAttachmentCleanup();
+		this.store.drainDeletionCleanup();
+		new DomainOutboxDispatcher(publishAutomationProductEvent).drain(100, "note");
 	}
 	async quickCapture(markdown, source, idempotencyKey) {
-		const id = idempotencyKey ? quickCaptureId(idempotencyKey) : randomUUID();
-		if (idempotencyKey) {
-			const existing = await this.store.getNote(id);
-			if (existing) return existing;
-			const inFlight = this.quickCapturesInFlight.get(id);
-			if (inFlight) return inFlight;
-			const capture = this.createQuickCapture(id, markdown, source).finally(() => this.quickCapturesInFlight.delete(id));
-			this.quickCapturesInFlight.set(id, capture);
-			return capture;
-		}
-		return this.createQuickCapture(id, markdown, source);
+		const note = this.quickCaptureAtomically(markdown, source, idempotencyKey);
+		this.flushCommittedEffects();
+		return note;
 	}
-	async createQuickCapture(id, markdown, source) {
-		const now = Date.now();
-		const note = {
-			id,
-			title: deriveDefaultTitle(markdown),
-			kind: inferKind(markdown),
-			status: "inbox",
-			markdown,
-			createdAt: now,
-			updatedAt: now,
-			capturedVia: source,
-			remoteVersion: 1,
-			localVersion: 1
-		};
-		await this.store.addNote(note);
-		emitActivity({
-			type: "note.created",
-			primaryObject: {
-				kind: "note",
-				id: note.id,
-				title: note.title
-			},
-			actor: systemActivityActor(),
-			source: systemActivitySource(),
-			payload: {
-				title: note.title,
-				kind: note.kind,
-				tags: note.tags,
-				contentPreview: previewText(note.markdown),
-				contentLength: note.markdown.length
-			},
-			nowMs: note.createdAt
+	quickCaptureAtomically(markdown, source, idempotencyKey) {
+		return runSqliteWriteTransaction(() => {
+			const id = idempotencyKey ? quickCaptureId(idempotencyKey) : randomUUID();
+			return (idempotencyKey ? this.store.getNote(id) : null) ?? this.createNoteWithId(id, {
+				markdown,
+				capturedVia: source
+			});
 		});
-		log.debug({
-			id: note.id,
-			kind: note.kind
-		}, "Quick capture");
-		return note;
 	}
 	async createNote(params, idempotencyKey) {
-		const id = idempotencyKey ? noteCaptureId(idempotencyKey) : randomUUID();
-		if (idempotencyKey) {
-			const existing = await this.store.getNote(id);
-			if (existing) return existing;
-			const inFlight = this.noteCapturesInFlight.get(id);
-			if (inFlight) return inFlight;
-			const capture = this.createNoteWithId(id, params).finally(() => this.noteCapturesInFlight.delete(id));
-			this.noteCapturesInFlight.set(id, capture);
-			return capture;
-		}
-		return this.createNoteWithId(id, params);
+		const note = this.createNoteAtomically(params, idempotencyKey);
+		this.flushCommittedEffects();
+		return note;
+	}
+	createNoteAtomically(params, idempotencyKey) {
+		return runSqliteWriteTransaction(() => {
+			const id = idempotencyKey ? noteCaptureId(idempotencyKey) : randomUUID();
+			if (idempotencyKey) {
+				const existing = this.store.getNote(id);
+				if (existing) return existing;
+			}
+			return this.createNoteWithId(id, params);
+		});
 	}
-	async createNoteWithId(id, params) {
+	createNoteWithId(id, params) {
 		const now = Date.now();
 		const markdown = params.markdown ?? "";
 		const note = {
@@ -247,7 +221,7 @@ var NotesService = class {
 			remoteVersion: 1,
 			localVersion: 1
 		};
-		await this.store.addNote(note);
+		this.store.addNote(note);
 		emitActivity({
 			type: "note.created",
 			primaryObject: {
@@ -266,7 +240,7 @@ var NotesService = class {
 			},
 			nowMs: note.createdAt
 		});
-		publishNoteEvent("note.created", note);
+		enqueueNoteEvent("note.created", note);
 		log.debug({
 			id: note.id,
 			kind: note.kind
@@ -277,57 +251,63 @@ var NotesService = class {
 		return this.store.getNote(id);
 	}
 	async updateNote(id, patch, trigger = "edit") {
-		const existing = await this.store.getNote(id);
-		if (!existing) return null;
-		const contentTouched = patch.markdown !== void 0 || patch.title !== void 0;
-		if (contentTouched) await this.maybeSaveSnapshot(existing, trigger);
-		const normalizedPatch = { ...patch };
-		if (contentTouched) normalizedPatch.lastEditTrigger = trigger;
-		if (patch.markdown !== void 0) normalizedPatch.kind = patch.kind ?? inferKind(patch.markdown, Boolean(existing.attachments?.length), existing.attachments);
-		if (contentTouched || patch.attachments) {
+		const note = this.updateNoteAtomically(id, patch, trigger);
+		this.flushCommittedEffects();
+		return note;
+	}
+	updateNoteAtomically(id, patch, trigger = "edit", expectedRevision) {
+		return runSqliteWriteTransaction(() => {
+			const existing = this.store.getNote(id);
+			if (!existing) return null;
+			if (expectedRevision !== void 0 && (existing.remoteVersion ?? 1) !== expectedRevision) throw new NoteRevisionConflictError("Note revision conflict");
+			const contentTouched = patch.markdown !== void 0 || patch.title !== void 0;
+			if (contentTouched) this.maybeSaveSnapshot(existing, trigger);
+			const normalizedPatch = { ...patch };
+			if (contentTouched) normalizedPatch.lastEditTrigger = trigger;
+			if (patch.markdown !== void 0) normalizedPatch.kind = patch.kind ?? inferKind(patch.markdown, Boolean(existing.attachments?.length), existing.attachments);
 			normalizedPatch.remoteVersion = (existing.remoteVersion ?? 1) + 1;
-			normalizedPatch.localVersion = patch.localVersion ?? (existing.localVersion ?? 1) + 1;
-		}
-		const updatedRaw = await this.store.updateNote(id, normalizedPatch);
-		const updated = updatedRaw ? await this.reconcileAttachments(updatedRaw) : null;
-		if (updated) {
-			const changes = changedFieldsFromPatch(patch);
-			emitActivity({
-				type: existing.status !== updated.status ? "note.status_changed" : "note.updated",
-				primaryObject: {
-					kind: "note",
-					id: updated.id,
-					title: updated.title
-				},
-				actor: systemActivityActor(),
-				source: systemActivitySource(),
-				payload: {
-					changes,
+			if (contentTouched || patch.attachments) normalizedPatch.localVersion = patch.localVersion ?? (existing.localVersion ?? 1) + 1;
+			const updatedRaw = this.store.updateNote(id, normalizedPatch);
+			const updated = updatedRaw ? this.reconcileAttachments(updatedRaw) : null;
+			if (updated) {
+				const changes = changedFieldsFromPatch(patch);
+				emitActivity({
+					type: existing.status !== updated.status ? "note.status_changed" : "note.updated",
+					primaryObject: {
+						kind: "note",
+						id: updated.id,
+						title: updated.title
+					},
+					actor: systemActivityActor(),
+					source: systemActivitySource(),
+					payload: {
+						changes,
+						contentTouched,
+						...existing.status !== updated.status ? {
+							from: existing.status,
+							to: updated.status
+						} : {}
+					},
+					nowMs: updated.updatedAt
+				});
+				enqueueNoteEvent("note.updated", updated, {
 					contentTouched,
-					...existing.status !== updated.status ? {
-						from: existing.status,
-						to: updated.status
-					} : {}
-				},
-				nowMs: updated.updatedAt
-			});
-			publishNoteEvent("note.updated", updated, {
-				contentTouched,
-				trigger
-			});
-		}
-		return updated;
+					trigger
+				});
+			}
+			return updated;
+		});
 	}
-	async reconcileAttachments(note) {
+	reconcileAttachments(note) {
 		const { kept, removed } = partitionAttachmentsByReference(note);
 		if (removed.length === 0) return note;
-		for (const attachment of removed) await this.store.deleteAttachmentFile(note.id, attachment.relativePath);
+		for (const attachment of removed) this.store.queueAttachmentCleanup(note.id, attachment.relativePath);
 		log.debug({
 			noteId: note.id,
 			removedIds: removed.map((attachment) => attachment.id)
 		}, "Pruned orphan note attachments");
 		const hasAttachments = kept.length > 0;
-		return await this.store.updateNote(note.id, {
+		return this.store.updateNote(note.id, {
 			attachments: kept,
 			kind: inferKind(note.markdown, hasAttachments, kept)
 		}) ?? {
@@ -336,19 +316,20 @@ var NotesService = class {
 		};
 	}
 	async syncNote(id, patch, baseRemoteVersion) {
-		const existing = await this.store.getNote(id);
-		if (!existing) return {
-			note: null,
-			conflict: false
-		};
-		if (baseRemoteVersion !== void 0 && existing.remoteVersion !== void 0 && baseRemoteVersion < existing.remoteVersion) return {
-			note: existing,
-			conflict: true
-		};
-		return {
-			note: await this.updateNote(id, patch, "sync"),
-			conflict: false
-		};
+		try {
+			const note = this.updateNoteAtomically(id, patch, "sync", baseRemoteVersion);
+			this.flushCommittedEffects();
+			return {
+				note,
+				conflict: false
+			};
+		} catch (error) {
+			if (error instanceof NoteRevisionConflictError) return {
+				note: this.store.getNote(id),
+				conflict: true
+			};
+			throw error;
+		}
 	}
 	async createAiEditPatch(id, instruction, markdownOverride) {
 		const note = await this.store.getNote(id);
@@ -470,18 +451,48 @@ var NotesService = class {
 		};
 	}
 	async appendTextToNote(id, content, heading = "AI 讨论沉淀") {
-		const note = await this.store.getNote(id);
-		if (!note) return null;
-		const trimmed = content.trim();
-		if (!trimmed) return note;
-		const current = note.markdown.trimEnd();
-		const nextMarkdown = `${current}${current ? "\n\n" : ""}## ${heading}\n\n${trimmed}\n`;
-		return this.updateNote(id, { markdown: nextMarkdown }, "ai_edit");
+		const note = this.appendTextToNoteAtomically(id, content, heading);
+		this.flushCommittedEffects();
+		return note;
+	}
+	appendTextToNoteAtomically(id, content, heading = "AI 讨论沉淀", expectedRevision) {
+		return runSqliteWriteTransaction(() => {
+			const note = this.store.getNote(id);
+			if (!note) return null;
+			if (expectedRevision !== void 0 && (note.remoteVersion ?? 1) !== expectedRevision) throw new NoteRevisionConflictError("Note revision conflict");
+			const trimmed = content.trim();
+			if (!trimmed) return note;
+			const current = note.markdown.trimEnd();
+			const nextMarkdown = `${current}${current ? "\n\n" : ""}## ${heading}\n\n${trimmed}\n`;
+			return this.updateNoteAtomically(id, { markdown: nextMarkdown }, "ai_edit", expectedRevision);
+		});
 	}
 	async deleteNote(id) {
-		const removed = await this.store.deleteNote(id);
-		if (removed) await this.store.deleteAllSnapshots(id);
-		return removed;
+		const result = this.deleteNoteAtomically(id);
+		this.flushCommittedEffects();
+		return result.deleted;
+	}
+	deleteNoteAtomically(id, expectedRevision, revokeShares = true) {
+		return runSqliteWriteTransaction(() => {
+			const note = this.store.getNote(id);
+			if (!note) return {
+				deleted: false,
+				revokedShares: 0
+			};
+			if (expectedRevision !== void 0 && expectedRevision !== (note.remoteVersion ?? 1)) throw new NoteRevisionConflictError("Note revision conflict");
+			const shareIds = revokeShares ? revokeNoteShareRecords(id) : [];
+			for (const shareId of shareIds) this.store.queueDeletionCleanup("share", shareId);
+			this.store.deleteNoteAtomically(id);
+			enqueueNoteEvent("note.deleted", {
+				...note,
+				remoteVersion: (note.remoteVersion ?? 1) + 1,
+				updatedAt: Math.max(Date.now(), note.updatedAt + 1)
+			});
+			return {
+				deleted: true,
+				revokedShares: shareIds.length
+			};
+		});
 	}
 	async listNotes(query = {}) {
 		return this.store.listNotes(query);
@@ -515,9 +526,16 @@ var NotesService = class {
 			duration: file.duration,
 			retainWithoutReference: file.retainWithoutReference
 		};
-		const attachments = [...note.attachments || [], attachment];
-		const kind = note.kind === "thought" && attachment.type === "audio" ? "voice" : note.kind === "thought" ? "media" : note.kind;
-		await this.store.updateNote(noteId, {
+		const current = this.store.getNote(noteId);
+		if (!current || current.createdAt !== note.createdAt) {
+			this.store.queueAttachmentCleanup(noteId, relativePath);
+			if (!current) this.store.queueDeletionCleanup("media", noteId);
+			this.flushCommittedEffects();
+			return null;
+		}
+		const attachments = [...current.attachments || [], attachment];
+		const kind = current.kind === "thought" && attachment.type === "audio" ? "voice" : current.kind === "thought" ? "media" : current.kind;
+		this.store.updateNote(noteId, {
 			attachments,
 			kind
 		});
@@ -550,19 +568,21 @@ var NotesService = class {
 		return this.store.getSnapshot(noteId, timestamp);
 	}
 	async restoreNoteSnapshot(noteId, timestamp) {
-		const snapshot = await this.store.getSnapshot(noteId, timestamp);
-		const existing = await this.store.getNote(noteId);
-		if (!snapshot || !existing) return null;
-		await this.maybeSaveSnapshot(existing, "restore");
-		this.lastSnapshotAt.set(noteId, Date.now());
-		await this.store.pruneSnapshots(noteId, MAX_SNAPSHOTS_PER_NOTE);
-		return this.store.updateNote(noteId, {
-			title: snapshot.title,
-			markdown: snapshot.markdown,
-			tags: snapshot.tags,
-			kind: snapshot.kind,
-			status: snapshot.status,
-			lastEditTrigger: "restore"
+		const note = this.restoreNoteSnapshotAtomically(noteId, timestamp);
+		this.flushCommittedEffects();
+		return note;
+	}
+	restoreNoteSnapshotAtomically(noteId, timestamp, expectedRevision) {
+		return runSqliteWriteTransaction(() => {
+			const snapshot = this.store.getSnapshot(noteId, timestamp);
+			if (!snapshot) return null;
+			return this.updateNoteAtomically(noteId, {
+				title: snapshot.title,
+				markdown: snapshot.markdown,
+				tags: snapshot.tags,
+				kind: snapshot.kind,
+				status: snapshot.status
+			}, "restore", expectedRevision);
 		});
 	}
 	async moveToGroup(noteId, groupId) {
@@ -609,19 +629,12 @@ var NotesService = class {
 	async recordOpen(noteId) {
 		return this.updateNote(noteId, { lastOpenedAt: Date.now() });
 	}
-	async maybeSaveSnapshot(note, trigger) {
-		if (trigger !== "edit") {
-			await this.store.saveSnapshot(note, trigger);
-			this.lastSnapshotAt.set(note.id, Date.now());
-			await this.store.pruneSnapshots(note.id, MAX_SNAPSHOTS_PER_NOTE);
-			return;
-		}
-		const last = this.lastSnapshotAt.get(note.id) ?? 0;
-		if (Date.now() - last < SNAPSHOT_THROTTLE_MS) return;
-		await this.store.saveSnapshot(note, trigger);
-		this.lastSnapshotAt.set(note.id, Date.now());
-		await this.store.pruneSnapshots(note.id, MAX_SNAPSHOTS_PER_NOTE);
+	maybeSaveSnapshot(note, trigger) {
+		const last = this.store.listSnapshots(note.id)[0]?.timestamp ?? 0;
+		if (trigger === "edit" && Date.now() - last < SNAPSHOT_THROTTLE_MS) return;
+		this.store.saveSnapshot(note, trigger);
+		this.store.pruneSnapshots(note.id, MAX_SNAPSHOTS_PER_NOTE);
 	}
 };
 //#endregion
-export { NotesService, buildNoteAttachmentRef };
+export { NoteRevisionConflictError, NotesService, buildNoteAttachmentRef };

package/dist/src/notes/store.d.ts

@@ -2,11 +2,12 @@ import { buildNoteIndexMeta } from './note-index-meta.js';
 import type { Note, NoteIndexEntry, NoteSnapshot, NoteSnapshotEntry, NotesListQuery, SnapshotTrigger } from './types.js';
 export declare class NotesStore {
     private initialized;
+    private readonly failedCleanupPaths;
     initialize(): Promise<void>;
-    addNote(note: Note): Promise<void>;
-    getNote(id: string): Promise<Note | null>;
-    updateNote(id: string, patch: Partial<Note>): Promise<Note | null>;
-    deleteNote(id: string): Promise<boolean>;
+    addNote(note: Note): void;
+    getNote(id: string): Note | null;
+    updateNote(id: string, patch: Partial<Note>): Note | null;
+    deleteNoteAtomically(id: string): boolean;
     listNotes(query?: NotesListQuery): Promise<{
         items: NoteIndexEntry[];
         total: number;
@@ -22,10 +23,14 @@ export declare class NotesStore {
     }>;
     resolveAttachmentPath(noteId: string, relativePath: string): string;
     deleteAttachmentFile(noteId: string, relativePath: string): Promise<void>;
-    saveSnapshot(note: Note, trigger: SnapshotTrigger): Promise<void>;
-    listSnapshots(noteId: string): Promise<NoteSnapshotEntry[]>;
-    getSnapshot(noteId: string, timestamp: number): Promise<NoteSnapshot | null>;
-    pruneSnapshots(noteId: string, maxCount: number): Promise<void>;
-    deleteAllSnapshots(noteId: string): Promise<void>;
+    saveSnapshot(note: Note, trigger: SnapshotTrigger): void;
+    listSnapshots(noteId: string): NoteSnapshotEntry[];
+    getSnapshot(noteId: string, timestamp: number): NoteSnapshot | null;
+    pruneSnapshots(noteId: string, maxCount: number): void;
+    queueAttachmentCleanup(noteId: string, relativePath: string): void;
+    queueDeletionCleanup(kind: 'media' | 'share', id: string): void;
+    drainDeletionCleanup(limit?: number): void;
+    /** Called after commit and on startup. A failed deletion remains durable for the next attempt. */
+    drainAttachmentCleanup(limit?: number): void;
 }
 export { buildNoteIndexMeta };