@dinoxx/dinox-cli 1.0.19 → 1.0.21

package/dist/commands/mcp/server.d.ts

@@ -17,11 +17,14 @@ type MCPResponse = {
 };
 export declare class MCPServer {
     private db;
+    private readonly noteContent;
     initialize(): Promise<void>;
     handleRequest(req: MCPRequest): Promise<MCPResponse | null>;
     private handleInitialize;
     private handleToolsList;
     private handleToolsCall;
+    private requireDb;
+    private getRuntime;
     close(): Promise<void>;
 }
 export declare function startMCPServer(port?: number, host?: string, authToken?: string): Promise<{

package/dist/commands/mcp/server.js

@@ -2,6 +2,7 @@ import { createServer } from 'node:http';
 import { DEFAULT_MCP_PORT } from './types.js';
 import { mcpTools } from './tools.js';
 import { isAuthorizedMCPRequest } from './auth.js';
+import { NOTE_CONTENT_EDIT_TOOL_NAME, NOTE_CONTENT_READ_TOOL_NAME, NoteContentMcpService, buildNoteContentToolError, } from './noteContentTools.js';
 import { resolveAuthIdentity } from '../../auth/userInfo.js';
 import { loadConfig } from '../../config/store.js';
 import { resolveConfig } from '../../config/resolve.js';
@@ -141,6 +142,7 @@ async function readJsonBody(req) {
 }
 export class MCPServer {
     db = null;
+    noteContent = new NoteContentMcpService(() => this.requireDb());
     async initialize() {
         const config = resolveConfig(await loadConfig());
         const { db } = await connectPowerSync({ config, offline: false, timeoutMs: config.sync.timeoutMs });
@@ -204,9 +206,7 @@ export class MCPServer {
         return buildResponse(req, { result: { tools: mcpTools } });
     }
     async handleToolsCall(req) {
-        if (!this.db) {
-            throw new Error('Database not initialized');
-        }
+        const db = this.requireDb();
         const name = req.params?.name;
         const args = req.params?.arguments ?? {};
         if (typeof name !== 'string') {
@@ -216,8 +216,9 @@ export class MCPServer {
             case 'dinox_search_notes': {
                 const keyword = typeof args.query === 'string' ? args.query : '';
                 const tagsExpression = typeof args.tags === 'string' ? args.tags.trim() : '';
-                const { names: boxNames, matchEmpty: matchEmptyBoxes } = parseBoxFilter(args.box);
-                const zettelBoxIds = await resolveZettelBoxIdsForSearch(this.db, boxNames);
+                const rawBoxes = args.boxes ?? args.box;
+                const { names: boxNames, matchEmpty: matchEmptyBoxes } = parseBoxFilter(rawBoxes);
+                const zettelBoxIds = await resolveZettelBoxIdsForSearch(db, boxNames);
                 const daysInput = typeof args.days === 'number' ? String(args.days) : args.days;
                 const { createdAtFrom, createdAtTo } = parseCreatedAtRange({
                     from: args.from,
@@ -227,7 +228,7 @@ export class MCPServer {
                 const limit = normalizeLimit(args.limit);
                 const offset = normalizeOffset(args.offset);
                 const fields = parseNoteSearchFields(args.fields, 'dinox_search_notes.fields');
-                const rows = await searchNotes(this.db, keyword, {
+                const rows = await searchNotes(db, keyword, {
                     includeDeleted: false,
                     tagsExpression: tagsExpression || undefined,
                     createdAtFrom,
@@ -255,7 +256,7 @@ export class MCPServer {
                 if (typeof args.id !== 'string' || !args.id.trim()) {
                     throw new Error('dinox_get_note: id is required');
                 }
-                const notes = await getNoteDetails(this.db, [args.id.trim()]);
+                const notes = await getNoteDetails(db, [args.id.trim()]);
                 const text = JSON.stringify(notes[0] ?? null);
                 return buildResponse(req, { result: { content: [{ type: 'text', text }] } });
             }
@@ -271,12 +272,12 @@ export class MCPServer {
                 const rawConfig = await loadConfig();
                 const config = resolveConfig(rawConfig);
                 const identity = await resolveAuthIdentity(rawConfig, config);
-                const canonicalContentMd = await canonicalizeBidlinksInMarkdown(this.db, contentMd, identity.userId);
+                const canonicalContentMd = await canonicalizeBidlinksInMarkdown(db, contentMd, identity.userId);
                 const { contentJson, contentText } = convertMarkdownToNoteContent(canonicalContentMd);
-                const tags = await validateTagsForCreate(this.db, normalizeStringArray(args.tags));
-                const zettelBoxIds = await resolveZettelBoxIdsForCreate(this.db, normalizeStringArray(args.boxes));
+                const tags = await validateTagsForCreate(db, normalizeStringArray(args.tags));
+                const zettelBoxIds = await resolveZettelBoxIdsForCreate(db, normalizeStringArray(args.boxes));
                 const id = generateId();
-                await createNote(this.db, {
+                await createNote(db, {
                     id,
                     title,
                     noteType: 'crawl',
@@ -294,7 +295,7 @@ export class MCPServer {
                 if (typeof args.id !== 'string' || !args.id.trim()) {
                     throw new Error('dinox_graph_backlinks: id is required');
                 }
-                const result = await getBacklinks(this.db, args.id.trim());
+                const result = await getBacklinks(db, args.id.trim());
                 const text = JSON.stringify(result);
                 return buildResponse(req, { result: { content: [{ type: 'text', text }] } });
             }
@@ -302,7 +303,7 @@ export class MCPServer {
                 if (typeof args.id !== 'string' || !args.id.trim()) {
                     throw new Error('dinox_graph_outlinks: id is required');
                 }
-                const result = await getOutlinks(this.db, args.id.trim());
+                const result = await getOutlinks(db, args.id.trim());
                 const text = JSON.stringify(result);
                 return buildResponse(req, { result: { content: [{ type: 'text', text }] } });
             }
@@ -314,12 +315,12 @@ export class MCPServer {
                     ? Math.trunc(args.depth)
                     : 2;
                 const depth = Math.min(Math.max(depthRaw, 1), 5);
-                const result = await getRelatedNotes(this.db, args.id.trim(), depth);
+                const result = await getRelatedNotes(db, args.id.trim(), depth);
                 const text = JSON.stringify(result);
                 return buildResponse(req, { result: { content: [{ type: 'text', text }] } });
             }
             case 'dinox_graph_stats': {
-                const result = await getGraphStats(this.db);
+                const result = await getGraphStats(db);
                 const text = JSON.stringify(result);
                 return buildResponse(req, { result: { content: [{ type: 'text', text }] } });
             }
@@ -329,7 +330,7 @@ export class MCPServer {
                     ? args.status
                     : 'all';
                 const limit = normalizeLimit(args.limit);
-                const result = await searchTodoTasks(this.db, query, {
+                const result = await searchTodoTasks(db, query, {
                     includeDeleted: false,
                     taskStatus: status || 'all',
                     taskTagFilter: normalizeStringArray(args.tags),
@@ -339,10 +340,38 @@ export class MCPServer {
                 const text = JSON.stringify(result);
                 return buildResponse(req, { result: { content: [{ type: 'text', text }] } });
             }
+            case NOTE_CONTENT_READ_TOOL_NAME: {
+                const runtime = await this.getRuntime();
+                const result = await this.noteContent.read(args, runtime).catch((error) => buildNoteContentToolError(error));
+                const text = JSON.stringify(result);
+                return buildResponse(req, { result: { content: [{ type: 'text', text }] } });
+            }
+            case NOTE_CONTENT_EDIT_TOOL_NAME: {
+                const runtime = await this.getRuntime();
+                const operations = Array.isArray(args.operations) ? args.operations : [];
+                const result = await this.noteContent.edit({
+                    readToken: args.readToken,
+                    operations,
+                }, runtime).catch((error) => buildNoteContentToolError(error, operations));
+                const text = JSON.stringify(result);
+                return buildResponse(req, { result: { content: [{ type: 'text', text }] } });
+            }
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }
     }
+    requireDb() {
+        if (!this.db) {
+            throw new Error('Database not initialized');
+        }
+        return this.db;
+    }
+    async getRuntime() {
+        const rawConfig = await loadConfig();
+        const config = resolveConfig(rawConfig);
+        const identity = await resolveAuthIdentity(rawConfig, config);
+        return { userId: identity.userId };
+    }
     async close() {
         if (this.db) {
             await this.db.close().catch(() => undefined);

package/dist/commands/mcp/tools.js

@@ -1,4 +1,5 @@
 import { listMcpCommandSchemas } from '../schema/spec.js';
+import { noteContentMcpTools } from './noteContentTools.js';
 function toMcpProperty(property) {
     if (property.type === 'string[]') {
         return {
@@ -14,7 +15,7 @@ function toMcpProperty(property) {
         ...(property.enum ? { enum: property.enum } : {}),
     };
 }
-export const mcpTools = listMcpCommandSchemas().map((schema) => {
+const schemaBackedMcpTools = listMcpCommandSchemas().map((schema) => {
     const mcp = schema.mcp;
     const properties = Object.fromEntries(mcp.properties.map((property) => [property.name, toMcpProperty(property)]));
     const required = mcp.properties.filter((property) => property.required).map((property) => property.name);
@@ -28,3 +29,4 @@ export const mcpTools = listMcpCommandSchemas().map((schema) => {
         },
     };
 });
+export const mcpTools = [...schemaBackedMcpTools, ...noteContentMcpTools];

package/dist/commands/mcp/types.d.ts

@@ -4,12 +4,16 @@ export type MCPTool = {
     inputSchema: {
         type: 'object';
         properties: Record<string, {
-            type: 'string' | 'number' | 'boolean' | 'array';
+            type: 'string' | 'number' | 'boolean' | 'array' | 'object';
             description?: string;
             enum?: string[];
             items?: {
-                type: 'string';
+                type: 'string' | 'object';
             };
+            properties?: Record<string, {
+                type: 'string' | 'number' | 'boolean' | 'array' | 'object';
+                description?: string;
+            }>;
         }>;
         required?: string[];
     };

package/dist/commands/meta/index.js

@@ -1,32 +1,16 @@
-import { loadConfig } from '../../config/store.js';
-import { resolveConfig } from '../../config/resolve.js';
-import { connectPowerSync, waitForIdleDataFlow } from '../../powersync/runtime.js';
 import { registerCommandGroup } from '../descriptor/register.js';
 import { OFFLINE_OPTIONS, SYNC_TIMEOUT_OPTIONS } from '../schema/globalOptions.js';
 import { printSuccess } from '../../utils/output.js';
-import { parseSyncTimeoutMs } from '../../utils/syncTimeout.js';
+import { commandStale, syncBeforeCommand, withCommandRuntime } from '../runtime.js';
 import { getMetaSchema, getMetaStats } from './repo.js';
-async function syncBeforeMetaCommand(db, offline, timeoutMs) {
-    if (offline) {
-        return;
-    }
-    await waitForIdleDataFlow(db, Math.min(timeoutMs, 10_000));
-}
 async function runMetaStats(context) {
-    const config = resolveConfig(await loadConfig());
-    const offline = Boolean(context.globals.offline);
-    const timeoutMs = parseSyncTimeoutMs(context.globals.syncTimeout) ?? config.sync.timeoutMs;
-    const { db, stale } = await connectPowerSync({ config, offline, timeoutMs });
-    try {
-        await syncBeforeMetaCommand(db, offline, timeoutMs);
+    await withCommandRuntime(context, async (runtime) => {
+        await syncBeforeCommand(runtime);
         printSuccess({
-            stale: offline ? true : stale,
-            stats: await getMetaStats(db),
+            stale: commandStale(runtime),
+            stats: await getMetaStats(runtime.db),
         });
-    }
-    finally {
-        await db.close().catch(() => undefined);
-    }
+    });
 }
 async function runMetaSchema() {
     printSuccess(getMetaSchema());

package/dist/commands/meta/repo.d.ts

@@ -24,9 +24,6 @@ export type MetaSchema = {
         command_schema: {
             fields: string[];
         };
-        mcp_tool: {
-            fields: string[];
-        };
     };
 };
 export declare function getMetaStats(db: AbstractPowerSyncDatabase): Promise<MetaStats>;

package/dist/commands/meta/repo.js

@@ -67,10 +67,7 @@ export function getMetaSchema() {
                 fields: ['notes_count', 'tags_count', 'boxes_count', 'latest_note_updated_at'],
             },
             command_schema: {
-                fields: ['path', 'command', 'summary', 'risk', 'auth', 'globalOptions', 'arguments', 'options', 'output', 'examples', 'mcp'],
-            },
-            mcp_tool: {
-                fields: ['name', 'description', 'inputSchema'],
+                fields: ['path', 'command', 'summary', 'risk', 'auth', 'globalOptions', 'arguments', 'options', 'output', 'examples'],
             },
         },
     };

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

@@ -6,5 +6,7 @@ export declare function runNoteDetail({ command, options, args }: CommandExecuti
 export declare function runNoteCreate({ command, options }: CommandExecutionContext): Promise<void>;
 export declare function runNoteDelete({ command, options, args }: CommandExecutionContext): Promise<void>;
 export declare function runNoteUpdate({ command, options, args }: CommandExecutionContext): Promise<void>;
+export declare function runNoteTag({ command, options, args }: CommandExecutionContext): Promise<void>;
+export declare function runNoteMove({ command, options, args }: CommandExecutionContext): Promise<void>;
 export declare function runNoteStar({ command, options, args }: CommandExecutionContext): Promise<void>;
 export declare function runNoteUnstar({ command, options, args }: CommandExecutionContext): Promise<void>;

package/dist/commands/notes/actions.js

@@ -5,9 +5,10 @@ import { generateId } from '../../utils/id.js';
 import { convertMarkdownToNoteContent } from '../../utils/tiptapMarkdown.js';
 import { getRequestedStructuredOutputFormat, printHumanReadableLine, printSuccess, } from '../../utils/output.js';
 import { DinoxError } from '../../utils/errors.js';
-import { waitForIdleDataFlow } from '../../powersync/runtime.js';
+import { commandStale, printStaleCacheWarning, printUploadDisabledWarning, waitForMutationUpload, } from '../runtime.js';
 import { createNote, getNote, getNoteContext, getNoteDetails, getNotePreview, assertNotesUpdatable, resolveZettelBoxIdsForCreate, resolveZettelBoxIdsForSearch, resolveZettelBoxIdsForUpdate, searchNotes, softDeleteNote, updateNote, validateTagsForCreate, validateTagsForUpdate, } from './repo.js';
 import { buildNoteCreateDryRunPreview, buildNoteDeleteDryRunPreview, buildNoteUpdateDryRunPreview, } from './dryRun.js';
+import { applyNoteMetadataMutation, planNoteMetadataMutation, } from './metadataMutation.js';
 import { parseNoteSearchFields, projectNoteSearchFields } from './searchOutput.js';
 import { parseCreatedAtRange } from './searchTime.js';
 import { buildNoteSearchResponse, normalizeDaysForMeta } from './searchResponse.js';
@@ -39,13 +40,11 @@ function toPublicNote(note) {
         ...(zettel_boxes !== undefined ? { boxes: zettel_boxes } : {}),
     };
 }
-async function settleMutation(db, timeoutMs) {
-    await waitForIdleDataFlow(db, Math.min(timeoutMs, 5_000));
-}
 async function executeNoteUpdateOperation(args) {
     const structuredOutput = getRequestedStructuredOutputFormat() !== null;
-    await withNoteDatabase(args.command, async ({ db, config, offline, timeoutMs, stale }) => {
-        await syncBeforeNoteCommand(db, offline, timeoutMs);
+    await withNoteDatabase(args.command, async (runtime) => {
+        const { db, config, offline } = runtime;
+        await syncBeforeNoteCommand(runtime);
         const ids = await parseTargetNoteIds(args.id, args.idsOption, 'update');
         const hasTags = typeof args.tagsOption === 'string';
         const hasBoxes = typeof args.boxOption === 'string';
@@ -85,12 +84,8 @@ async function executeNoteUpdateOperation(args) {
             }));
         }
         const updatedCount = results.filter((item) => item.updated).length;
-        if (!offline && !config.powersync.uploadBaseUrl) {
-            printHumanReadableLine('warning: upload disabled (powersync.uploadBaseUrl is unset); changes are local-only for now');
-        }
-        if (!offline) {
-            await settleMutation(db, timeoutMs);
-        }
+        printUploadDisabledWarning(runtime);
+        await waitForMutationUpload(runtime);
         const payload = {
             ok: true,
             total: results.length,
@@ -102,7 +97,7 @@ async function executeNoteUpdateOperation(args) {
                 boxes: item.zettelBoxIds,
                 is_starred: item.is_starred,
             })),
-            stale: offline ? true : stale,
+            stale: commandStale(runtime),
         };
         if (structuredOutput) {
             printSuccess(payload);
@@ -125,15 +120,101 @@ async function executeNoteUpdateOperation(args) {
         else {
             printHumanReadableLine(`Updated ${updatedCount}/${results.length} notes`);
         }
-        if (stale && !offline) {
-            printHumanReadableLine('warning: sync timed out; local cache may be stale');
+        printStaleCacheWarning(runtime);
+    });
+}
+function selectMetadataOperation(options) {
+    const candidates = [
+        ['--add', options.add],
+        ['--remove', options.remove],
+        ['--replace', options.replace],
+    ].filter((entry) => typeof entry[1] === 'string');
+    if (candidates.length !== 1) {
+        throw new DinoxError('Provide exactly one of --add, --remove, or --replace');
+    }
+    const [optionName, rawValues] = candidates[0];
+    return {
+        operation: optionName === '--add' ? 'add' : optionName === '--remove' ? 'remove' : 'replace',
+        rawValues,
+        optionName,
+    };
+}
+async function executeNoteMetadataListOperation(args) {
+    const structuredOutput = getRequestedStructuredOutputFormat() !== null;
+    await withNoteDatabase(args.command, async (runtime) => {
+        const { db, config, offline } = runtime;
+        await syncBeforeNoteCommand(runtime);
+        const ids = await parseTargetNoteIds(args.id, args.idsOption, 'update');
+        const selected = selectMetadataOperation(args.options);
+        const requestedValues = await parseStringListInput(selected.rawValues, selected.optionName);
+        const values = args.field === 'tags'
+            ? await validateTagsForUpdate(db, requestedValues)
+            : await resolveZettelBoxIdsForUpdate(db, requestedValues);
+        const plan = await planNoteMetadataMutation(db, {
+            ids,
+            field: args.field,
+            operation: selected.operation,
+            values,
+            displayValues: requestedValues,
+        });
+        if (args.options.dryRun) {
+            printDryRunPreview({
+                dry_run: true,
+                command: args.commandName,
+                action: args.actionName,
+                risk: 'write',
+                summary: `Preview ${args.field} ${selected.operation} for ${plan.total} note(s); ${plan.changedCount} note(s) would change.`,
+                warnings: [
+                    ...(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: {
+                    ids,
+                    operation: selected.operation,
+                    [args.field]: args.field === 'tags' ? values : requestedValues,
+                },
+                targets: plan.results.map((item) => ({ id: item.id, title: item.title })),
+                changes: plan.results.map((item) => ({
+                    id: item.id,
+                    title: item.title,
+                    [`${args.field}_from`]: item.before,
+                    [`${args.field}_to`]: item.after,
+                    changed: item.changed,
+                })),
+            });
+            return;
+        }
+        await applyNoteMetadataMutation(db, plan);
+        printUploadDisabledWarning(runtime);
+        await waitForMutationUpload(runtime);
+        const payload = {
+            ok: true,
+            field: args.field,
+            operation: selected.operation,
+            total: plan.total,
+            updatedCount: plan.changedCount,
+            results: plan.results.map((item) => ({
+                id: item.id,
+                updated: item.changed,
+                [args.field]: item.after,
+            })),
+            stale: commandStale(runtime),
+        };
+        if (structuredOutput) {
+            printSuccess(payload);
+            return;
         }
+        printHumanReadableLine(`Updated ${plan.changedCount}/${plan.total} notes`);
+        printStaleCacheWarning(runtime);
     });
 }
 export async function runNoteSearch({ command, options, args }) {
     const searchOptions = options;
-    await withNoteDatabase(command, async ({ db, offline, timeoutMs, stale }) => {
-        await syncBeforeNoteCommand(db, offline, timeoutMs);
+    await withNoteDatabase(command, async (runtime) => {
+        const { db } = runtime;
+        await syncBeforeNoteCommand(runtime);
         const keyword = args.query?.trim() ?? '';
         const tagsExpression = typeof searchOptions.tags === 'string' ? searchOptions.tags.trim() : '';
         const { createdAtFrom, createdAtTo } = parseCreatedAtRange({
@@ -167,7 +248,7 @@ export async function runNoteSearch({ command, options, args }) {
             query: keyword,
             notes: projectNoteSearchFields(rows.slice(offset, offset + limit), fields),
             totalCount: rows.length,
-            stale: offline ? true : stale,
+            stale: commandStale(runtime),
             includeDeleted: Boolean(searchOptions.includeDeleted),
             limit,
             offset,
@@ -191,8 +272,9 @@ export async function runNoteGet({ command, options, args }) {
         throw new DinoxError('Note id is required');
     }
     const structuredOutput = getRequestedStructuredOutputFormat() !== null;
-    await withNoteDatabase(command, async ({ db, offline, timeoutMs, stale }) => {
-        await syncBeforeNoteCommand(db, offline, timeoutMs);
+    await withNoteDatabase(command, async (runtime) => {
+        const { db } = runtime;
+        await syncBeforeNoteCommand(runtime);
         if (getOptions.contextOnly) {
             const context = await getNoteContext(db, id);
             if (!context) {
@@ -202,7 +284,7 @@ export async function runNoteGet({ command, options, args }) {
                     recoverable: true,
                 });
             }
-            printSuccess({ stale: offline ? true : stale, note: toPublicNoteContext(context) });
+            printSuccess({ stale: commandStale(runtime), note: toPublicNoteContext(context) });
             return;
         }
         const note = await getNote(db, id);
@@ -214,12 +296,10 @@ export async function runNoteGet({ command, options, args }) {
             });
         }
         if (structuredOutput) {
-            printSuccess({ stale, note: toPublicNote(note) });
+            printSuccess({ stale: commandStale(runtime), note: toPublicNote(note) });
             return;
         }
-        if (stale && !offline) {
-            printHumanReadableLine('warning: sync timed out; result may be stale');
-        }
+        printStaleCacheWarning(runtime, 'warning: sync timed out; result may be stale');
         printHumanReadableLine(`${note.id}`);
         printHumanReadableLine(`title: ${note.title ?? ''}`);
         if (note.updated_at) {
@@ -239,8 +319,9 @@ export async function runNotePreview({ command, options, args }) {
     if (!id) {
         throw new DinoxError('Note id is required');
     }
-    await withNoteDatabase(command, async ({ db, offline, timeoutMs, stale }) => {
-        await syncBeforeNoteCommand(db, offline, timeoutMs);
+    await withNoteDatabase(command, async (runtime) => {
+        const { db } = runtime;
+        await syncBeforeNoteCommand(runtime);
         const preview = await getNotePreview(db, id, parsePreviewLineCount(previewOptions.lines));
         if (!preview) {
             throw new DinoxError(`Note not found: ${id}`, {
@@ -249,13 +330,14 @@ export async function runNotePreview({ command, options, args }) {
                 recoverable: true,
             });
         }
-        printSuccess({ stale: offline ? true : stale, note: preview });
+        printSuccess({ stale: commandStale(runtime), note: preview });
     });
 }
 export async function runNoteDetail({ command, options, args }) {
     const detailOptions = options;
-    await withNoteDatabase(command, async ({ db, offline, timeoutMs }) => {
-        await syncBeforeNoteCommand(db, offline, timeoutMs);
+    await withNoteDatabase(command, async (runtime) => {
+        const { db } = runtime;
+        await syncBeforeNoteCommand(runtime);
         const ids = await parseTargetNoteIds(args.id, detailOptions.ids, 'detail');
         const notes = await getNoteDetails(db, ids);
         const foundIds = new Set(notes.map((note) => note.id));
@@ -270,9 +352,10 @@ export async function runNoteDetail({ command, options, args }) {
 export async function runNoteCreate({ command, options }) {
     const createOptions = options;
     const structuredOutput = getRequestedStructuredOutputFormat() !== null;
-    await withNoteDatabase(command, async ({ db, rawConfig, config, offline, timeoutMs, stale }) => {
-        await syncBeforeNoteCommand(db, offline, timeoutMs);
-        const identity = await resolveAuthIdentity(rawConfig, config);
+    await withNoteDatabase(command, async (runtime) => {
+        const { db, config, offline } = runtime;
+        await syncBeforeNoteCommand(runtime);
+        const identity = await resolveAuthIdentity(config);
         const contentMd = await parseStringInput(String(createOptions.content));
         const canonicalContentMd = await canonicalizeBidlinksInMarkdown(db, contentMd, identity.userId);
         const { contentJson, contentText } = convertMarkdownToNoteContent(canonicalContentMd);
@@ -309,21 +392,15 @@ export async function runNoteCreate({ command, options }) {
             zettelBoxIds: await resolveZettelBoxIdsForCreate(db, boxNames),
             userId: identity.userId,
         });
-        if (!offline && !config.powersync.uploadBaseUrl) {
-            printHumanReadableLine('warning: upload disabled (powersync.uploadBaseUrl is unset); changes are local-only for now');
-        }
-        if (!offline) {
-            await settleMutation(db, timeoutMs);
-        }
-        const payload = { ok: true, id, stale: offline ? true : stale };
+        printUploadDisabledWarning(runtime);
+        await waitForMutationUpload(runtime);
+        const payload = { ok: true, id, stale: commandStale(runtime) };
         if (structuredOutput) {
             printSuccess(payload);
             return;
         }
         printHumanReadableLine(id);
-        if (stale && !offline) {
-            printHumanReadableLine('warning: sync timed out; local cache may be stale');
-        }
+        printStaleCacheWarning(runtime);
     });
 }
 export async function runNoteDelete({ command, options, args }) {
@@ -333,28 +410,23 @@ export async function runNoteDelete({ command, options, args }) {
         throw new DinoxError('Note id is required');
     }
     const structuredOutput = getRequestedStructuredOutputFormat() !== null;
-    await withNoteDatabase(command, async ({ db, config, offline, timeoutMs, stale }) => {
-        await syncBeforeNoteCommand(db, offline, timeoutMs);
+    await withNoteDatabase(command, async (runtime) => {
+        const { db, config, offline } = runtime;
+        await syncBeforeNoteCommand(runtime);
         if (Boolean(deleteOptions.dryRun)) {
             printDryRunPreview(await buildNoteDeleteDryRunPreview({ db, config, offline, id }));
             return;
         }
         await softDeleteNote(db, id);
-        if (!offline && !config.powersync.uploadBaseUrl) {
-            printHumanReadableLine('warning: upload disabled (powersync.uploadBaseUrl is unset); changes are local-only for now');
-        }
-        if (!offline) {
-            await settleMutation(db, timeoutMs);
-        }
-        const payload = { ok: true, id, stale: offline ? true : stale };
+        printUploadDisabledWarning(runtime);
+        await waitForMutationUpload(runtime);
+        const payload = { ok: true, id, stale: commandStale(runtime) };
         if (structuredOutput) {
             printSuccess(payload);
             return;
         }
         printHumanReadableLine('OK');
-        if (stale && !offline) {
-            printHumanReadableLine('warning: sync timed out; local cache may be stale');
-        }
+        printStaleCacheWarning(runtime);
     });
 }
 export async function runNoteUpdate({ command, options, args }) {
@@ -373,6 +445,28 @@ export async function runNoteUpdate({ command, options, args }) {
         actionName: 'update_note',
     });
 }
+export async function runNoteTag({ command, options, args }) {
+    await executeNoteMetadataListOperation({
+        command,
+        id: args.id,
+        idsOption: options.ids,
+        options: options,
+        field: 'tags',
+        commandName: 'dino note tag',
+        actionName: 'mutate_note_tags',
+    });
+}
+export async function runNoteMove({ command, options, args }) {
+    await executeNoteMetadataListOperation({
+        command,
+        id: args.id,
+        idsOption: options.ids,
+        options: options,
+        field: 'boxes',
+        commandName: 'dino note move',
+        actionName: 'mutate_note_boxes',
+    });
+}
 export async function runNoteStar({ command, options, args }) {
     const starOptions = options;
     await executeNoteUpdateOperation({

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

@@ -0,0 +1,34 @@
+import type { CommandExecutionContext } from '../descriptor/types.js';
+import type { NoteMetadataListField, NoteMetadataOperation } from './metadataMutation.js';
+type NoteBulkOptions = {
+    tags?: string;
+    from?: string;
+    to?: string;
+    days?: string;
+    starred?: string;
+    boxes?: string;
+    all?: boolean;
+    tagAdd?: string;
+    tagRemove?: string;
+    tagReplace?: string;
+    boxAdd?: string;
+    boxRemove?: string;
+    boxReplace?: string;
+    expectedCount?: string;
+    confirm?: boolean;
+    dryRun?: boolean;
+};
+type NoteBulkMutationSelection = {
+    field: NoteMetadataListField;
+    operation: NoteMetadataOperation;
+    rawValues: string;
+    optionName: '--tag-add' | '--tag-remove' | '--tag-replace' | '--box-add' | '--box-remove' | '--box-replace';
+};
+export declare function selectBulkMutation(options: NoteBulkOptions): NoteBulkMutationSelection;
+export declare function parseExpectedCount(value: unknown): number | null;
+export declare function assertBulkTargetFilter(input: {
+    query: string;
+    options: NoteBulkOptions;
+}): void;
+export declare function runNoteBulk({ command, options, args }: CommandExecutionContext): Promise<void>;
+export {};