@dinoxx/dinox-cli 1.0.22 → 1.1.1

package/dist/commands/notes/bulk.js

@@ -1,12 +1,14 @@
+import { resolveAuthIdentity } from '../../auth/userInfo.js';
 import { printDryRunPreview } from '../../utils/dryRun.js';
 import { getRequestedStructuredOutputFormat, printHumanReadableLine, printSuccess, } from '../../utils/output.js';
 import { DinoxError } from '../../utils/errors.js';
-import { commandStale, printStaleCacheWarning, printUploadDisabledWarning, waitForMutationUpload, } from '../runtime.js';
+import { commandStale, printStaleCacheWarning, resolveWriteDurabilityForRuntime, waitForMutationUpload, } from '../runtime.js';
 import { resolveZettelBoxIdsForBulk, resolveZettelBoxIdsForSearch, searchNotes, validateTagsForBulk, } from './repo.js';
 import { applyNoteMetadataMutation, planNoteMetadataMutation, } from './metadataMutation.js';
 import { parseCreatedAtRange } from './searchTime.js';
 import { normalizeDaysForMeta, } from './searchResponse.js';
-import { parseSearchListInput, parseStarredOption, parseStringListInput, syncBeforeNoteCommand, withNoteDatabase, } from './runtime.js';
+import { parseMutationListInput, parseSearchListInput, parseStarredOption, syncBeforeNoteCommand, withNoteDatabase, } from './runtime.js';
+import { buildBatchWriteReceiptFields, readNoteRevisionReceipts, } from './writeReceipt.js';
 const BULK_PREVIEW_LIMIT = 100;
 export function selectBulkMutation(options) {
     const candidates = [
@@ -42,13 +44,14 @@ export function parseExpectedCount(value) {
 }
 function hasConcreteTargetFilter(input) {
     const { query, options } = input;
-    return Boolean(query ||
-        options.tags ||
-        options.from ||
-        options.to ||
-        options.days ||
-        options.starred ||
-        options.boxes);
+    const hasValue = (value) => typeof value === 'string' && value.trim().length > 0;
+    return Boolean(hasValue(query) ||
+        hasValue(options.tags) ||
+        hasValue(options.from) ||
+        hasValue(options.to) ||
+        hasValue(options.days) ||
+        hasValue(options.starred) ||
+        hasValue(options.boxes));
 }
 export function assertBulkTargetFilter(input) {
     const hasFilter = hasConcreteTargetFilter(input);
@@ -64,9 +67,6 @@ function buildExecutionWarnings(input) {
     if (input.offline) {
         warnings.push('Execution would run in offline mode and only use the local cache.');
     }
-    if (!input.offline && !input.uploadEnabled) {
-        warnings.push('Execution would be local-only because powersync.uploadBaseUrl is unset.');
-    }
     if (input.total > BULK_PREVIEW_LIMIT) {
         warnings.push(`Preview is truncated to the first ${BULK_PREVIEW_LIMIT} matched notes.`);
     }
@@ -81,12 +81,16 @@ export async function runNoteBulk({ command, options, args }) {
     await withNoteDatabase(command, async (runtime) => {
         const { db, config, offline } = runtime;
         await syncBeforeNoteCommand(runtime);
+        const durability = resolveWriteDurabilityForRuntime(runtime, bulkOptions.durability);
         const query = args.query?.trim() ?? '';
         assertBulkTargetFilter({ query, options: bulkOptions });
         const selected = selectBulkMutation(bulkOptions);
-        const requestedValues = await parseStringListInput(selected.rawValues, selected.optionName);
+        const requestedValues = await parseMutationListInput(selected.rawValues, selected.optionName);
+        const tagUserId = selected.field === 'tags'
+            ? (await resolveAuthIdentity(config)).userId
+            : undefined;
         const values = selected.field === 'tags'
-            ? await validateTagsForBulk(db, requestedValues)
+            ? await validateTagsForBulk(db, requestedValues, tagUserId)
             : await resolveZettelBoxIdsForBulk(db, requestedValues);
         const tagsExpression = typeof bulkOptions.tags === 'string' ? bulkOptions.tags.trim() : '';
         const { createdAtFrom, createdAtTo } = parseCreatedAtRange({
@@ -178,8 +182,9 @@ export async function runNoteBulk({ command, options, args }) {
             throw new DinoxError(`--expected-count ${expectedCount} does not match current target count ${plan.total}`);
         }
         await applyNoteMetadataMutation(db, plan);
-        printUploadDisabledWarning(runtime);
-        await waitForMutationUpload(runtime);
+        const upload = await waitForMutationUpload(runtime, { durability });
+        const stale = commandStale(runtime);
+        const revisions = await readNoteRevisionReceipts(db, plan.results.map((item) => item.id), new Map(plan.results.map((item) => [item.id, item.changed ? [selected.field] : []])));
         const payload = {
             ok: true,
             field: selected.field,
@@ -187,12 +192,13 @@ export async function runNoteBulk({ command, options, args }) {
             total: plan.total,
             updatedCount: plan.changedCount,
             filters: filterMeta,
+            ...buildBatchWriteReceiptFields(upload, stale),
             results: plan.results.map((item) => ({
                 id: item.id,
                 updated: item.changed,
                 [selected.field]: item.after,
+                ...revisions.get(item.id),
             })),
-            stale: commandStale(runtime),
         };
         if (structuredOutput) {
             printSuccess(payload);

package/dist/commands/notes/contentEngine.js

@@ -2,6 +2,8 @@ import crypto from 'node:crypto';
 import { DinoxError } from '../../utils/errors.js';
 import { generateId } from '../../utils/id.js';
 import { convertMarkdownToNoteContent } from '../../utils/tiptapMarkdown.js';
+import { normalizeStoredImageWidthPercent } from '../../utils/tiptapMarkdownSchemaUtils.js';
+import { escapeLiteralMarkdownText } from '../../utils/tiptapMarkdownSyntax.js';
 const CONTENT_TEXT_MAX_LENGTH = 300;
 const MAX_REPLACE_BLOCK_RANGE = 50;
 const ANCHOR_ATTRIBUTE_KEYS = ['anchorKey', 'data-toc-id', 'id', 'uniqueId'];
@@ -208,11 +210,18 @@ function findSerializedBlockRanges(nodes, match) {
     return ranges;
 }
 function assertProtectedReplacementAllowed(nodes, allowed) {
-    const protectedNodes = nodes.filter((node) => isProtectedBlock(node.type));
-    if (!protectedNodes.length || allowed) {
+    const protectedTypes = new Set();
+    for (const node of nodes) {
+        visit(node, (candidate) => {
+            if (isProtectedBlock(candidate.type)) {
+                protectedTypes.add(candidate.type);
+            }
+        });
+    }
+    if (!protectedTypes.size || allowed) {
         return;
     }
-    const types = Array.from(new Set(protectedNodes.map((node) => node.type))).join(', ');
+    const types = Array.from(protectedTypes).join(', ');
     throw new DinoxError(`Target includes protected block(s): ${types}. Re-run with --allow-protected-replace after content-read if this replacement is intentional.`);
 }
 function buildHeadingRanges(document) {
@@ -425,7 +434,7 @@ function blockToMarkdown(node, depth) {
         case 'heading': return `${'#'.repeat(normalizeHeadingLevel(node.attrs?.level))} ${text}`.trim();
         case 'paragraph': return text;
         case 'blockquote': return childBlocks(node).map((child) => blockToMarkdown(child, depth)).join('\n').split('\n').map((line) => `> ${line}`).join('\n').trim();
-        case 'codeBlock': return `\`\`\`${stringAttr(node, 'language') || stringAttr(node, 'lang')}\n${extractPlainText(node)}\n\`\`\``;
+        case 'codeBlock': return fencedMarkdown(stringAttr(node, 'language') || stringAttr(node, 'lang'), extractPlainText(node));
         case 'bulletList': return listToMarkdown(node, depth, '-');
         case 'orderedList': return listToMarkdown(node, depth, '1.');
         case 'taskList': return taskListToMarkdown(node, depth);
@@ -462,8 +471,10 @@ function inlineMarkdown(nodes) {
     }).join('');
 }
 function markedText(node) {
-    let text = node.text ?? '';
-    for (const mark of Array.isArray(node.marks) ? node.marks : []) {
+    const marks = Array.isArray(node.marks) ? node.marks : [];
+    const codeMark = marks.find((mark) => mark?.type === 'code');
+    let text = codeMark ? inlineCodeMarkdown(node.text ?? '') : escapeLiteralMarkdownText(node.text ?? '');
+    for (const mark of marks) {
         if (mark?.type === 'bold')
             text = `**${text}**`;
         if (mark?.type === 'italic')
@@ -471,12 +482,14 @@ function markedText(node) {
         if (mark?.type === 'strike')
             text = `~~${text}~~`;
         if (mark?.type === 'code')
-            text = `\`${text.replace(/`/g, '\\`')}\``;
+            continue;
         if (mark?.type === 'link') {
             const href = stringFromAttrs(mark.attrs, 'href');
             const title = stringFromAttrs(mark.attrs, 'title');
-            if (href)
-                text = `[${text}](${href}${title ? ` "${title.replace(/"/g, '\\"')}"` : ''})`;
+            if (href) {
+                const serializedTitle = title ? ` "${escapeMarkdownLinkTitle(title)}"` : '';
+                text = `[${text}](${markdownLinkDestination(href)}${serializedTitle})`;
+            }
         }
     }
     return text;
@@ -515,7 +528,34 @@ function imageToMarkdown(node) {
     const src = stringAttr(node, 'src');
     const alt = stringAttr(node, 'alt') || stringAttr(node, 'title') || inlineMarkdown(node.content ?? []);
     const caption = stringAttr(node, 'caption') || inlineMarkdown(node.content ?? []);
-    return [src ? `![${alt}](${src})` : placeholderMarkdown('image', node), caption && caption !== alt ? caption : ''].filter(Boolean).join('\n');
+    const image = src
+        ? `![${escapeLiteralMarkdownText(alt)}](${markdownLinkDestination(src)})${imageMetadataComment(node)}`
+        : placeholderMarkdown('image', node);
+    return [image, caption && caption !== alt ? caption : ''].filter(Boolean).join('\n');
+}
+function markdownLinkDestination(value) {
+    const safe = value.replace(/[\u0000-\u001F\u007F<>\\]/g, (character) => {
+        return `%${character.charCodeAt(0).toString(16).toUpperCase().padStart(2, '0')}`;
+    });
+    return `<${safe}>`;
+}
+function escapeMarkdownLinkTitle(value) {
+    return value
+        .replace(/\\/g, '\\\\')
+        .replace(/"/g, '\\"')
+        .replace(/\r?\n/g, ' ');
+}
+function imageMetadataComment(node) {
+    const resourceId = stringAttr(node, 'resourceId');
+    const widthPercent = normalizeStoredImageWidthPercent(node.attrs?.widthPercent);
+    if (!resourceId && widthPercent == null) {
+        return '';
+    }
+    return `<!-- ${JSON.stringify({
+        kind: 'image',
+        ...(resourceId ? { resourceId } : {}),
+        ...(widthPercent == null ? {} : { widthPercent }),
+    })} -->`;
 }
 function atomicReferenceMarkdown(node) {
     if (node.type === 'video' || node.type === 'audio' || node.type === 'file' || node.type === 'bookmark' || node.type === 'iframe' || node.type === 'audiosegment' || node.type === 'pdfAnnotation') {
@@ -524,7 +564,25 @@ function atomicReferenceMarkdown(node) {
     return '';
 }
 function fencedAttrMarkdown(language, text) {
-    return text ? `\`\`\`${language}\n${text}\n\`\`\`` : `[${language}]`;
+    return text ? fencedMarkdown(language, text) : `[${language}]`;
+}
+function longestBacktickRun(value) {
+    let longest = 0;
+    for (const match of value.matchAll(/`+/g)) {
+        longest = Math.max(longest, match[0].length);
+    }
+    return longest;
+}
+function fencedMarkdown(language, value) {
+    const fence = '`'.repeat(Math.max(3, longestBacktickRun(value) + 1));
+    const safeLanguage = language.replace(/[`\r\n]/g, '').trim();
+    return `${fence}${safeLanguage}\n${value}${value.endsWith('\n') ? '' : '\n'}${fence}`;
+}
+function inlineCodeMarkdown(value) {
+    const fence = '`'.repeat(Math.max(1, longestBacktickRun(value) + 1));
+    const needsPadding = value.startsWith('`') || value.endsWith('`') ||
+        (value.startsWith(' ') && value.endsWith(' ') && value.trim().length > 0);
+    return `${fence}${needsPadding ? ` ${value} ` : value}${fence}`;
 }
 function placeholderMarkdown(type, node, label) {
     const attrs = [

package/dist/commands/notes/contentPatch.d.ts

@@ -72,13 +72,16 @@ export declare function planMarkdownPatch(input: {
     contentMd: string;
     operation: NoteContentPatchOperation;
 }): NoteContentPatchPlan;
-export declare function readNoteContentForPatch(db: AbstractPowerSyncDatabase, id: string): Promise<NoteContentReadResult>;
+export declare function readNoteContentForPatch(db: AbstractPowerSyncDatabase, id: string, databaseScope: string, userId: string): Promise<NoteContentReadResult>;
 export declare function planNoteContentPatch(db: AbstractPowerSyncDatabase, input: {
     id: string;
+    userId: string;
     operation: NoteContentPatchOperation;
 }): Promise<NoteContentPatchPlan>;
 export declare function applyNoteContentPatch(db: AbstractPowerSyncDatabase, input: {
     id: string;
+    databaseScope: string;
+    userId: string;
     readToken: string;
     operation: NoteContentPatchOperation;
 }): Promise<NoteContentPatchResult>;

package/dist/commands/notes/contentPatch.js

@@ -1,18 +1,31 @@
+import crypto from 'node:crypto';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { getDataDir } from '../../config/paths.js';
 import { withPowerSyncWriteTransaction } from '../../powersync/runtime.js';
 import { DinoxError } from '../../utils/errors.js';
 import { generateId } from '../../utils/id.js';
+import { acquireExclusiveSqliteLease } from '../../utils/sqliteLease.js';
+import { withAsyncRelease } from '../../utils/asyncRelease.js';
 import { nowIsoUtc } from '../../utils/time.js';
+import { deriveImageDetailFromContentJson } from '../todo/contentModel.js';
 import { applyJsonPatchToDocument, buildNoteContentBlocks, buildNoteContentOutline, getNoteContentHash, parseStoredNoteDocument, projectNoteContent, } from './contentEngine.js';
+import { parseStoredTags } from './repo.js';
 const READ_TOKEN_TTL_MS = 30 * 60 * 1000;
 const MAX_STORED_READ_TOKENS = 500;
 const TOKEN_STORE_FILE = 'note-content-read-tokens.json';
+const TOKEN_STORE_LOCK_TIMEOUT_MS = 5_000;
 function normalizeVersion(value) {
     const parsed = Number(value);
     return Number.isFinite(parsed) ? parsed : null;
 }
+function fingerprintDatabaseScope(value) {
+    const normalized = value.trim();
+    if (!normalized) {
+        throw new DinoxError('Database scope is required for note content read tokens.');
+    }
+    return `sha256:${crypto.createHash('sha256').update(normalized, 'utf8').digest('hex')}`;
+}
 function canonicalTagPath(value) {
     return value
         .split(/[\\/]+/g)
@@ -23,7 +36,11 @@ function canonicalTagPath(value) {
 function tagPathKey(value) {
     return canonicalTagPath(value).toLowerCase();
 }
-async function loadTagReferenceLookup(db) {
+async function loadTagReferenceLookup(db, userId) {
+    const normalizedUserId = userId.trim();
+    if (!normalizedUserId) {
+        throw new DinoxError('Note content tag resolution requires the current userId. Run `dino auth login` first, or set DINOX_TOKEN and run an online command so the CLI can resolve the token identity.');
+    }
     const rows = await db.getAll(`
     SELECT
       TRIM(COALESCE(id, '')) AS id,
@@ -34,11 +51,12 @@ async function loadTagReferenceLookup(db) {
       AND TRIM(COALESCE(full_path, path_key, '')) <> ''
       AND (is_del IS NULL OR is_del = 0)
       AND (is_actual IS NULL OR is_actual != 0)
+      AND TRIM(COALESCE(user_id, '')) = ?
     ORDER BY
       updated_at DESC,
       created_at DESC,
       id DESC
-    `, []);
+    `, [normalizedUserId]);
     const byId = new Map();
     const byPathKey = new Map();
     for (const row of rows) {
@@ -75,6 +93,20 @@ function createHashtagReferenceResolver(lookup, options) {
 function tokenStorePath() {
     return path.join(getDataDir(), TOKEN_STORE_FILE);
 }
+function tokenStoreLockPath() {
+    return `${tokenStorePath()}.lock.sqlite`;
+}
+async function waitForTokenStoreLock() {
+    return acquireExclusiveSqliteLease({
+        lockPath: tokenStoreLockPath(),
+        timeoutMs: TOKEN_STORE_LOCK_TIMEOUT_MS,
+        pollIntervalMs: 20,
+        createBusyError: () => new DinoxError('Timed out waiting for the note content token store lock. Retry the command.'),
+    });
+}
+async function withTokenStoreLock(run) {
+    return withAsyncRelease(waitForTokenStoreLock, run);
+}
 async function loadTokenStore(nowMs = Date.now()) {
     const filePath = tokenStorePath();
     let tokens = [];
@@ -83,6 +115,7 @@ async function loadTokenStore(nowMs = Date.now()) {
         const parsed = JSON.parse(raw);
         if (Array.isArray(parsed.tokens)) {
             tokens = parsed.tokens.filter((token) => typeof token?.token === 'string' &&
+                typeof token.databaseScopeFingerprint === 'string' &&
                 typeof token.noteId === 'string' &&
                 typeof token.contentHash === 'string' &&
                 typeof token.expiresAt === 'string');
@@ -110,41 +143,42 @@ async function saveTokenStore(store) {
     await fs.rename(tmpPath, filePath);
 }
 async function rememberReadToken(input) {
-    const nowMs = Date.now();
-    const store = await loadTokenStore(nowMs);
-    const expiresAt = new Date(nowMs + READ_TOKEN_TTL_MS).toISOString();
-    const token = {
-        token: generateId(),
-        noteId: input.noteId,
-        contentHash: input.contentHash,
-        updatedAt: input.updatedAt,
-        version: input.version,
-        createdAt: new Date(nowMs).toISOString(),
-        expiresAt,
-    };
-    store.tokens.push(token);
-    store.tokens = store.tokens.slice(-MAX_STORED_READ_TOKENS);
-    await saveTokenStore(store);
-    return token;
+    return withTokenStoreLock(async () => {
+        const nowMs = Date.now();
+        const store = await loadTokenStore(nowMs);
+        const expiresAt = new Date(nowMs + READ_TOKEN_TTL_MS).toISOString();
+        const token = {
+            token: generateId(),
+            databaseScopeFingerprint: fingerprintDatabaseScope(input.databaseScope),
+            noteId: input.noteId,
+            contentHash: input.contentHash,
+            updatedAt: input.updatedAt,
+            version: input.version,
+            createdAt: new Date(nowMs).toISOString(),
+            expiresAt,
+        };
+        store.tokens.push(token);
+        store.tokens = store.tokens.slice(-MAX_STORED_READ_TOKENS);
+        await saveTokenStore(store);
+        return token;
+    });
 }
 async function consumeReadToken(tokenId) {
     const normalized = tokenId.trim();
     if (!normalized) {
         throw new DinoxError('Missing --read-token. Run `dino note content-read <id>` before editing.');
     }
-    const store = await loadTokenStore();
-    const token = store.tokens.find((candidate) => candidate.token === normalized);
-    if (!token) {
-        throw new DinoxError('read token is expired or unknown. Run `dino note content-read <id>` again.');
-    }
-    return token;
-}
-async function forgetReadToken(tokenId) {
-    const store = await loadTokenStore();
-    const next = store.tokens.filter((token) => token.token !== tokenId);
-    if (next.length !== store.tokens.length) {
-        await saveTokenStore({ tokens: next });
-    }
+    return withTokenStoreLock(async () => {
+        const store = await loadTokenStore();
+        const token = store.tokens.find((candidate) => candidate.token === normalized);
+        if (!token) {
+            throw new DinoxError('read token is expired, unknown, or already used. Run `dino note content-read <id>` again.');
+        }
+        await saveTokenStore({
+            tokens: store.tokens.filter((candidate) => candidate.token !== normalized),
+        });
+        return token;
+    });
 }
 async function readNoteContentRow(db, id) {
     const noteId = id.trim();
@@ -152,7 +186,7 @@ async function readNoteContentRow(db, id) {
         throw new DinoxError('Note id is required');
     }
     const row = await db.getOptional(`
-    SELECT id, title, content_md, content_json, content_text, updated_at, version, is_del
+    SELECT id, title, content_md, content_json, content_text, tags, updated_at, version, is_del
     FROM c_note
     WHERE id = ?
     `, [noteId]);
@@ -180,6 +214,10 @@ async function updateNoteContentProjection(tx, input) {
         setParts.push('images = ?');
         params.push(JSON.stringify(input.images));
     }
+    if (columns.has('image_detail')) {
+        setParts.push('image_detail = ?');
+        params.push(JSON.stringify(input.imageDetail));
+    }
     if (columns.has('tags')) {
         setParts.push('tags = ?');
         params.push(JSON.stringify(input.tags));
@@ -191,12 +229,33 @@ async function updateNoteContentProjection(tx, input) {
     setParts.push('updated_at = ?');
     params.push(nowIsoUtc());
     setParts.push('version = COALESCE(version, 0) + 1');
-    params.push(input.rowId);
-    await tx.execute(`
+    params.push(input.rowId, input.expectedVersion);
+    const result = await tx.execute(`
     UPDATE c_note
     SET ${setParts.join(',\n        ')}
     WHERE id = ?
+      AND COALESCE(version, 0) = ?
+      AND (is_del IS NULL OR is_del = 0)
+    RETURNING id
     `, params);
+    if (result.rows?.length !== 1) {
+        throw new DinoxError('Note content changed while applying the patch. Run `dino note content-read <id>` again.');
+    }
+}
+function mergeProjectedTags(storedTags, beforeHashtags, afterHashtags) {
+    const contentTagKeys = new Set(beforeHashtags.map((tag) => tag.trim().toLowerCase()).filter(Boolean));
+    const result = storedTags.filter((tag) => !contentTagKeys.has(tag.trim().toLowerCase()));
+    const seen = new Set(result.map((tag) => tag.trim().toLowerCase()).filter(Boolean));
+    for (const tag of afterHashtags) {
+        const normalized = tag.trim();
+        const key = normalized.toLowerCase();
+        if (!normalized || seen.has(key)) {
+            continue;
+        }
+        result.push(normalized);
+        seen.add(key);
+    }
+    return result;
 }
 function buildPatchPlan(input) {
     const document = parseStoredNoteDocument({
@@ -237,9 +296,9 @@ export function planMarkdownPatch(input) {
     });
     return plan;
 }
-export async function readNoteContentForPatch(db, id) {
+export async function readNoteContentForPatch(db, id, databaseScope, userId) {
     const row = await readNoteContentRow(db, id);
-    const tagLookup = await loadTagReferenceLookup(db);
+    const tagLookup = await loadTagReferenceLookup(db, userId);
     const document = parseStoredNoteDocument({
         contentJson: row.content_json,
         contentMd: row.content_md,
@@ -250,6 +309,7 @@ export async function readNoteContentForPatch(db, id) {
     const contentHash = getNoteContentHash(document);
     const version = normalizeVersion(row.version);
     const token = await rememberReadToken({
+        databaseScope,
         noteId: row.id,
         contentHash,
         updatedAt: row.updated_at ?? null,
@@ -277,7 +337,7 @@ export async function readNoteContentForPatch(db, id) {
 }
 export async function planNoteContentPatch(db, input) {
     const row = await readNoteContentRow(db, input.id);
-    const tagLookup = await loadTagReferenceLookup(db);
+    const tagLookup = await loadTagReferenceLookup(db, input.userId);
     const { afterProjection: _afterProjection, ...plan } = buildPatchPlan({
         id: row.id,
         title: row.title?.trim() ?? '',
@@ -290,8 +350,11 @@ export async function planNoteContentPatch(db, input) {
 }
 export async function applyNoteContentPatch(db, input) {
     const token = await consumeReadToken(input.readToken);
+    if (token.databaseScopeFingerprint !== fingerprintDatabaseScope(input.databaseScope)) {
+        throw new DinoxError('read token was issued for a different local account database. Run `dino note content-read <id>` again.');
+    }
     const result = await withPowerSyncWriteTransaction(db, async (tx) => {
-        const tagLookup = await loadTagReferenceLookup(tx);
+        const tagLookup = await loadTagReferenceLookup(tx, input.userId);
         const row = await readNoteContentRow(tx, input.id);
         if (row.id !== token.noteId) {
             throw new DinoxError('read token does not match target note. Run `dino note content-read <id>` again.');
@@ -303,7 +366,6 @@ export async function applyNoteContentPatch(db, input) {
         if (token.updatedAt !== (row.updated_at ?? null) ||
             token.version !== normalizeVersion(row.version) ||
             token.contentHash !== getNoteContentHash(currentDocument)) {
-            await forgetReadToken(token.token);
             throw new DinoxError('Note content changed after content-read. Run `dino note content-read <id>` again.');
         }
         const plan = buildPatchPlan({
@@ -315,20 +377,22 @@ export async function applyNoteContentPatch(db, input) {
             resolveHashtagReference: createHashtagReferenceResolver(tagLookup, { strictMissingPaths: true }),
         });
         if (plan.changed) {
+            const nextTags = mergeProjectedTags(parseStoredTags(row.tags), plan.derived.beforeHashtags, plan.derived.afterHashtags);
             await updateNoteContentProjection(tx, {
                 rowId: row.id,
                 contentMd: plan.afterProjection.contentMd,
                 contentJson: plan.afterProjection.contentJson,
                 contentText: plan.afterProjection.contentText,
-                tags: plan.afterProjection.hashtags,
+                tags: nextTags,
                 images: plan.afterProjection.images,
                 bidLinks: plan.afterProjection.bidLinks,
+                imageDetail: deriveImageDetailFromContentJson(plan.afterProjection.document, row.id),
+                expectedVersion: normalizeVersion(row.version) ?? 0,
             });
         }
         const { afterProjection: _afterProjection, ...publicPlan } = plan;
         return publicPlan;
     });
-    await forgetReadToken(token.token);
     const { beforeContent: _beforeContent, afterContent: _afterContent, ...publicResult } = result;
     return {
         ...publicResult,

package/dist/commands/notes/contentPatchCommand.js

@@ -1,7 +1,10 @@
+import { resolveAuthIdentity } from '../../auth/userInfo.js';
+import { getPowerSyncDbPath } from '../../config/paths.js';
 import { printDryRunPreview } from '../../utils/dryRun.js';
 import { DinoxError } from '../../utils/errors.js';
 import { getRequestedStructuredOutputFormat, printHumanReadableLine, printSuccess, } from '../../utils/output.js';
-import { commandStale, printStaleCacheWarning, printUploadDisabledWarning, waitForMutationUpload, } from '../runtime.js';
+import { commandStale, printStaleCacheWarning, resolveWriteDurabilityForRuntime, waitForMutationUpload, } from '../runtime.js';
+import { readNoteWriteReceipt } from './writeReceipt.js';
 import { applyNoteContentPatch, planNoteContentPatch, readNoteContentForPatch, } from './contentPatch.js';
 import { parseStringInput, syncBeforeNoteCommand, withNoteDatabase, } from './runtime.js';
 function requireNoteId(id) {
@@ -56,7 +59,8 @@ export async function runNoteContentRead({ command, options, args }) {
     const id = requireNoteId(args.id);
     await withNoteDatabase(command, async (runtime) => {
         await syncBeforeNoteCommand(runtime);
-        const result = await readNoteContentForPatch(runtime.db, id);
+        const identity = await resolveAuthIdentity(runtime.config);
+        const result = await readNoteContentForPatch(runtime.db, id, getPowerSyncDbPath(identity.userId), identity.userId);
         const { content, ...rest } = result;
         const payload = readOptions.includeContent
             ? { ...rest, content, stale: commandStale(runtime) }
@@ -72,8 +76,10 @@ export async function runNotePatch({ command, options, args }) {
     await withNoteDatabase(command, async (runtime) => {
         const { db, config, offline } = runtime;
         await syncBeforeNoteCommand(runtime);
+        const identity = await resolveAuthIdentity(config);
+        const durability = resolveWriteDurabilityForRuntime(runtime, patchOptions.durability);
         if (patchOptions.dryRun) {
-            const plan = await planNoteContentPatch(db, { id, operation });
+            const plan = await planNoteContentPatch(db, { id, userId: identity.userId, operation });
             printDryRunPreview({
                 dry_run: true,
                 command: 'dino note patch',
@@ -83,9 +89,6 @@ export async function runNotePatch({ command, options, args }) {
                 warnings: [
                     'Run `dino note content-read <id> --format json` before the real edit and pass the returned readToken as --read-token.',
                     ...(offline ? ['Execution would run in offline mode and only use the local cache.'] : []),
-                    ...(!offline && !config.powersync.uploadBaseUrl
-                        ? ['Execution would be local-only because powersync.uploadBaseUrl is unset.']
-                        : []),
                 ],
                 inputs: {
                     id,
@@ -106,13 +109,27 @@ export async function runNotePatch({ command, options, args }) {
         if (!readToken) {
             throw new DinoxError('Real note content edits require --read-token from `dino note content-read <id>`.');
         }
-        const result = await applyNoteContentPatch(db, { id, readToken, operation });
-        printUploadDisabledWarning(runtime);
-        await waitForMutationUpload(runtime);
+        const result = await applyNoteContentPatch(db, {
+            id,
+            databaseScope: getPowerSyncDbPath(identity.userId),
+            userId: identity.userId,
+            readToken,
+            operation,
+        });
+        const upload = await waitForMutationUpload(runtime, { durability });
+        const receipt = await readNoteWriteReceipt(db, id, {
+            changed: result.saved
+                ? ['content_md', 'content_json', 'content_text', 'images', 'image_detail', 'tags', 'bid_links']
+                : [],
+            upload,
+            stale: commandStale(runtime),
+        });
+        const { changed: contentChanged, ...publicResult } = result;
         const payload = {
             ok: true,
-            ...result,
-            stale: commandStale(runtime),
+            ...publicResult,
+            content_changed: contentChanged,
+            ...receipt,
         };
         if (structuredOutput) {
             printSuccess(payload);