@dinoxx/dinox-cli 1.0.22 → 1.1.0

package/dist/commands/notes/repo.js

@@ -3,6 +3,7 @@ import { nowIsoUtc } from '../../utils/time.js';
 import { tokenizeWithJieba } from '../../utils/tokenize.js';
 import { canonicalizeBoxPath, listBoxes } from '../boxes/repo.js';
 import { listTags } from '../tags/repo.js';
+import { deriveImageDetailFromContentJson } from '../todo/contentModel.js';
 import { buildNoteSearchSqlFilter } from './searchSql.js';
 const MAX_SEARCH_SUMMARY_CHARS = 200;
 function normalizeStoredStarred(value) {
@@ -14,7 +15,30 @@ function normalizeStoredStarred(value) {
     }
     return false;
 }
+/**
+ * Resolve box names to ids and run the note search. Shared by the local command path and
+ * the daemon RPC handler so both produce identical results from one implementation.
+ */
+export async function executeNoteSearch(db, params) {
+    const zettelBoxIds = await resolveZettelBoxIdsForSearch(db, params.boxValues);
+    const result = await searchNotesPage(db, params.keyword, {
+        includeDeleted: params.includeDeleted,
+        tagsExpression: params.tagsExpression,
+        createdAtFrom: params.createdAtFrom,
+        createdAtTo: params.createdAtTo,
+        starred: params.starred,
+        zettelBoxIds,
+        matchEmptyZettelBoxes: params.matchEmptyZettelBoxes,
+        sqlExpression: params.sqlExpression,
+        limit: params.limit,
+        offset: params.offset,
+    });
+    return { rows: result.rows, totalCount: result.totalCount, zettelBoxIds };
+}
 export async function searchNotes(db, query, options) {
+    return (await searchNotesPage(db, query, options)).rows;
+}
+export async function searchNotesPage(db, query, options) {
     const normalizedQuery = query.trim();
     const tagFilter = buildTagFilter(options.tagsExpression, 'n');
     const createdAtFilter = buildCreatedAtFilter(options.createdAtFrom, options.createdAtTo, 'n');
@@ -30,8 +54,11 @@ export async function searchNotes(db, query, options) {
         const ftsMatch = buildFtsMatchQuery(normalizedQuery);
         if (ftsMatch) {
             try {
-                rows = await searchNotesWithFts(db, ftsMatch, tagFilter, createdAtFilter, starredFilter, zettelBoxFilter, sqlFilter);
-                return enrichSearchRows(db, rows);
+                const ftsResult = await searchNotesWithFts(db, ftsMatch, tagFilter, createdAtFilter, starredFilter, zettelBoxFilter, sqlFilter, options.limit, options.offset);
+                return {
+                    rows: await enrichSearchRows(db, ftsResult.rows),
+                    totalCount: ftsResult.totalCount,
+                };
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
@@ -54,14 +81,15 @@ export async function searchNotes(db, query, options) {
     ];
     const params = [];
     if (normalizedQuery.length > 0) {
-        const like = `%${normalizedQuery}%`;
+        const like = `%${escapeLikePattern(normalizedQuery)}%`;
         whereClauses.push(`
       (
-        (n.title IS NOT NULL AND n.title LIKE ?)
-        OR (n.content_text IS NOT NULL AND n.content_text LIKE ?)
+        (n.title IS NOT NULL AND n.title LIKE ? ESCAPE '\\')
+        OR (n.content_text IS NOT NULL AND n.content_text LIKE ? ESCAPE '\\')
+        OR (n.content_md IS NOT NULL AND n.content_md LIKE ? ESCAPE '\\')
       )
       `);
-        params.push(like, like);
+        params.push(like, like, like);
     }
     if (tagFilter) {
         whereClauses.push(tagFilter.sql);
@@ -83,6 +111,15 @@ export async function searchNotes(db, query, options) {
         whereClauses.push(sqlFilter.sql);
         params.push(...sqlFilter.params);
     }
+    const baseFromWhere = `
+    FROM c_note n
+    WHERE ${whereClauses.join('\n      AND ')}
+  `;
+    const paginated = typeof options.limit === 'number';
+    const totalCount = paginated ? await countSearchRows(db, baseFromWhere, params) : null;
+    if (totalCount === 0) {
+        return { rows: [], totalCount };
+    }
     rows = await db.getAll(`
     SELECT
       n.id,
@@ -93,13 +130,13 @@ export async function searchNotes(db, query, options) {
       n.zettel_boxes,
       n.created_at,
       n.is_starred
-    FROM c_note n
-    WHERE ${whereClauses.join('\n      AND ')}
-    ORDER BY COALESCE(n.updated_at, n.created_at) DESC
-    `, params);
-    return enrichSearchRows(db, rows);
+    ${baseFromWhere}
+    ORDER BY COALESCE(n.updated_at, n.created_at) DESC, n.id DESC
+    ${buildPaginationSql(options.limit, options.offset)}
+    `, appendPaginationParams(params, options.limit, options.offset));
+    return { rows: await enrichSearchRows(db, rows), totalCount: totalCount ?? rows.length };
 }
-async function searchNotesWithFts(db, matchQuery, tagFilter, createdAtFilter, starredFilter, zettelBoxFilter, sqlFilter) {
+async function searchNotesWithFts(db, matchQuery, tagFilter, createdAtFilter, starredFilter, zettelBoxFilter, sqlFilter, limit, offset) {
     const whereClauses = ['(n.is_del IS NULL OR n.is_del = 0)', 'note_local_fts MATCH ?'];
     const params = [matchQuery];
     if (tagFilter) {
@@ -122,7 +159,17 @@ async function searchNotesWithFts(db, matchQuery, tagFilter, createdAtFilter, st
         whereClauses.push(sqlFilter.sql);
         params.push(...sqlFilter.params);
     }
-    return db.getAll(`
+    const baseFromWhere = `
+    FROM note_local_fts f
+    JOIN c_note n ON n.id = f.note_id
+    WHERE ${whereClauses.join('\n      AND ')}
+  `;
+    const paginated = typeof limit === 'number';
+    const totalCount = paginated ? await countSearchRows(db, baseFromWhere, params) : null;
+    if (totalCount === 0) {
+        return { rows: [], totalCount };
+    }
+    const rows = await db.getAll(`
     SELECT
       n.id,
       n.title,
@@ -132,11 +179,31 @@ async function searchNotesWithFts(db, matchQuery, tagFilter, createdAtFilter, st
       n.zettel_boxes,
       n.created_at,
       n.is_starred
-    FROM note_local_fts f
-    JOIN c_note n ON n.id = f.note_id
-    WHERE ${whereClauses.join('\n      AND ')}
-    ORDER BY bm25(note_local_fts, 8.0, 4.0, 1.0) ASC, COALESCE(n.updated_at, n.created_at) DESC
+    ${baseFromWhere}
+    ORDER BY bm25(note_local_fts, 0.0, 8.0, 4.0, 1.0) ASC, COALESCE(n.updated_at, n.created_at) DESC, n.id DESC
+    ${buildPaginationSql(limit, offset)}
+    `, appendPaginationParams(params, limit, offset));
+    return { rows, totalCount: totalCount ?? rows.length };
+}
+function escapeLikePattern(value) {
+    return value.replace(/[\\%_]/g, (match) => `\\${match}`);
+}
+async function countSearchRows(db, fromWhereSql, params) {
+    const rows = await db.getAll(`
+    SELECT COUNT(*) AS total_count
+    ${fromWhereSql}
     `, params);
+    const value = Number(rows[0]?.total_count ?? 0);
+    return Number.isFinite(value) && value > 0 ? Math.trunc(value) : 0;
+}
+function buildPaginationSql(limit, offset) {
+    return typeof limit === 'number' ? 'LIMIT ? OFFSET ?' : '';
+}
+function appendPaginationParams(params, limit, offset) {
+    if (typeof limit !== 'number') {
+        return params;
+    }
+    return [...params, limit, offset ?? 0];
 }
 async function enrichSearchRows(db, rows) {
     const allBoxIds = Array.from(new Set(rows.flatMap((row) => parseZettelBoxIds(row.zettel_boxes))));
@@ -536,7 +603,7 @@ async function getLinkCount(db, direction, noteId) {
     FROM c_note_link l
     JOIN c_note n ON n.id = l.${column}
     WHERE l.${boundColumn} = ?
-      AND l.is_del = 0
+      AND (l.is_del IS NULL OR l.is_del = 0)
       AND (n.is_del IS NULL OR n.is_del = 0)
     `, [noteId]);
     return Number(row?.count ?? 0);
@@ -636,13 +703,16 @@ function mapNoteDetailRow(note, boxNameMap) {
     return {
         id: note.id,
         created_at: note.created_at,
+        updated_at: note.updated_at,
         title: note.title,
         type: note.type,
         source: note.source,
-        tags: note.tags,
+        tags: parseStoredTags(note.tags),
         is_del: note.is_del,
         is_starred: normalizeStoredStarred(note.is_starred),
         content_md: note.content_md,
+        content_text: note.content_text,
+        content_json: parseStoredJsonValue(note.content_json),
         zettel_boxes: zettelBoxes,
     };
 }
@@ -697,6 +767,7 @@ export async function getNoteDetails(db, ids) {
       SELECT
         id,
         created_at,
+        updated_at,
         title,
         type,
         source,
@@ -704,6 +775,8 @@ export async function getNoteDetails(db, ids) {
         is_del,
         is_starred,
         content_md,
+        content_text,
+        content_json,
         zettel_boxes AS zettel_boxes_raw
       FROM c_note
       WHERE id IN (${placeholders})
@@ -792,7 +865,9 @@ export async function createNote(db, input) {
     const contentJson = JSON.stringify(input.contentJson);
     const tags = JSON.stringify(input.tags);
     const zettelBoxes = JSON.stringify(input.zettelBoxIds);
-    const imageDetail = JSON.stringify(Array.isArray(input.imageDetail) ? input.imageDetail : []);
+    const imageDetail = JSON.stringify(Array.isArray(input.imageDetail)
+        ? input.imageDetail
+        : deriveImageDetailFromContentJson(input.contentJson, input.id));
     const columns = await db.getAll('PRAGMA table_info(c_note)', []);
     const columnNames = new Set(columns
         .map((row) => row.name?.trim().toLowerCase() ?? '')
@@ -893,20 +968,24 @@ function buildZettelBoxRetryQuestion(intent, type) {
     }
     return `Do you want to add these missing boxes and retry \`${command}\`?`;
 }
-export async function validateTagsForCreate(db, requestedTags) {
-    return validateTagsForWrite(db, requestedTags, 'dino note create');
+export async function validateTagsForCreate(db, requestedTags, userId) {
+    return validateTagsForWrite(db, requestedTags, userId, 'dino note create');
 }
-export async function validateTagsForUpdate(db, requestedTags) {
-    return validateTagsForWrite(db, requestedTags, 'dino note update');
+export async function validateTagsForUpdate(db, requestedTags, userId) {
+    return validateTagsForWrite(db, requestedTags, userId, 'dino note update');
 }
-export async function validateTagsForBulk(db, requestedTags) {
-    return validateTagsForWrite(db, requestedTags, 'dino note bulk');
+export async function validateTagsForBulk(db, requestedTags, userId) {
+    return validateTagsForWrite(db, requestedTags, userId, 'dino note bulk');
 }
-async function validateTagsForWrite(db, requestedTags, retryCommand) {
+async function validateTagsForWrite(db, requestedTags, userId, retryCommand) {
+    const normalizedUserId = userId.trim();
+    if (!normalizedUserId) {
+        throw new DinoxError('Tag validation 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.');
+    }
     if (requestedTags.length === 0) {
         return [];
     }
-    const tags = await listTags(db);
+    const tags = await listTags(db, { userId: normalizedUserId });
     const existingTagMap = new Map();
     for (const tag of tags) {
         const key = normalizeLookupKey(tag);
@@ -1026,6 +1105,7 @@ export async function updateNote(db, input) {
         return {
             id,
             updated: false,
+            changed: [],
             tags: currentTags,
             zettelBoxIds: currentZettelBoxIds,
             is_starred: currentStarred,
@@ -1057,6 +1137,11 @@ export async function updateNote(db, input) {
     return {
         id,
         updated: true,
+        changed: [
+            ...(tagsChanged ? ['tags'] : []),
+            ...(boxesChanged ? ['boxes'] : []),
+            ...(starredChanged ? ['is_starred'] : []),
+        ],
         tags: nextTags,
         zettelBoxIds: nextZettelBoxIds,
         is_starred: nextStarred,

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

@@ -9,6 +9,7 @@ export declare function parseStarredOption(value: unknown, optionName: string):
 export declare function parseStringInput(value: string): Promise<string>;
 export declare function parseListInput(raw: string, optionName: string): string[];
 export declare function parseStringListInput(value: string, optionName: string): Promise<string[]>;
+export declare function parseMutationListInput(value: string, optionName: string): Promise<string[]>;
 export type ParsedSearchListInput = {
     values: string[];
     isExplicitEmptyArray: boolean;
@@ -16,4 +17,4 @@ export type ParsedSearchListInput = {
 export declare function parseSearchListInput(value: string, optionName: string): Promise<ParsedSearchListInput>;
 export declare function parseTargetNoteIds(idArg: string | undefined, idsOption: string | undefined, commandName: 'detail' | 'update'): Promise<string[]>;
 export declare function syncBeforeNoteCommand(runtime: CommandRuntime): Promise<void>;
-export declare function withNoteDatabase(command: Command, run: (runtime: NoteCommandRuntime) => Promise<void>): Promise<void>;
+export declare function withNoteDatabase<T = void>(command: Command, run: (runtime: NoteCommandRuntime) => Promise<T>): Promise<T>;

package/dist/commands/notes/runtime.js

@@ -34,6 +34,14 @@ export function parseSearchOffset(value) {
     if (value === undefined || value === null || value === '') {
         return 0;
     }
+    // Commander supplies the option's numeric defaultValue (0) as a number, while an
+    // explicit `--offset N` arrives as a string; accept both.
+    if (typeof value === 'number') {
+        if (!Number.isInteger(value) || value < 0) {
+            throw new DinoxError('--offset must be a non-negative integer');
+        }
+        return value;
+    }
     if (typeof value !== 'string') {
         throw new DinoxError('--offset must be a non-negative integer');
     }
@@ -114,6 +122,14 @@ export async function parseStringListInput(value, optionName) {
     const raw = await readStringOrFile(value);
     return parseListInput(raw, optionName);
 }
+export async function parseMutationListInput(value, optionName) {
+    const raw = await readStringOrFile(value);
+    const values = parseListInput(raw, optionName);
+    if (values.length === 0 && !isExplicitEmptyArrayLiteral(raw)) {
+        throw new DinoxError(`${optionName} requires at least one value. Use [] to explicitly clear the list.`);
+    }
+    return values;
+}
 export async function parseSearchListInput(value, optionName) {
     const raw = await readStringOrFile(value);
     return {
@@ -155,5 +171,5 @@ export async function syncBeforeNoteCommand(runtime) {
     await syncBeforeCommand(runtime, { syncTokenIndex: true });
 }
 export async function withNoteDatabase(command, run) {
-    await withCommandRuntime(command, run);
+    return withCommandRuntime(command, run);
 }

package/dist/commands/notes/searchSql.js

@@ -430,13 +430,20 @@ async function buildZettelBoxIdLookup(ast, resolveZettelBoxNames) {
         seen.add(key);
         uniqueNames.push(raw);
     }
-    const ids = await resolveZettelBoxNames(uniqueNames);
-    if (ids.length !== uniqueNames.length) {
-        throw new DinoxError('Failed to resolve zettel box paths or names in --sql expression');
-    }
+    const batchIds = await resolveZettelBoxNames(uniqueNames);
     const lookup = new Map();
-    for (let i = 0; i < uniqueNames.length; i += 1) {
-        lookup.set(normalizeLookupKey(uniqueNames[i]), ids[i]);
+    if (batchIds.length === uniqueNames.length) {
+        for (let i = 0; i < uniqueNames.length; i += 1) {
+            lookup.set(normalizeLookupKey(uniqueNames[i]), batchIds[i]);
+        }
+        return lookup;
+    }
+    for (const name of uniqueNames) {
+        const ids = await resolveZettelBoxNames([name]);
+        if (ids.length !== 1) {
+            throw new DinoxError('Failed to resolve zettel box paths or names in --sql expression');
+        }
+        lookup.set(normalizeLookupKey(name), ids[0]);
     }
     return lookup;
 }

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

@@ -0,0 +1,20 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+import type { MutationUploadReceipt } from '../runtime.js';
+export type NoteRevisionReceipt = {
+    version: number | null;
+    updated_at: string | null;
+    content_hash: string;
+    changed: string[];
+};
+export type NoteWriteReceipt = MutationUploadReceipt & NoteRevisionReceipt & {
+    stale: boolean;
+};
+export declare function readNoteRevisionReceipts(db: AbstractPowerSyncDatabase, ids: readonly string[], changesById: ReadonlyMap<string, readonly string[]>): Promise<Map<string, NoteRevisionReceipt>>;
+export declare function readNoteWriteReceipt(db: AbstractPowerSyncDatabase, id: string, input: {
+    changed: readonly string[];
+    upload: MutationUploadReceipt;
+    stale: boolean;
+}): Promise<NoteWriteReceipt>;
+export declare function buildBatchWriteReceiptFields(upload: MutationUploadReceipt, stale: boolean): MutationUploadReceipt & {
+    stale: boolean;
+};

package/dist/commands/notes/writeReceipt.js

@@ -0,0 +1,82 @@
+import { DinoxError } from '../../utils/errors.js';
+import { getNoteContentHash, parseStoredNoteDocument, } from './contentEngine.js';
+const NOTE_RECEIPT_BATCH_SIZE = 500;
+function normalizeVersion(value) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function normalizeChangedFields(fields) {
+    const result = [];
+    const seen = new Set();
+    for (const field of fields) {
+        const normalized = field.trim();
+        if (!normalized || seen.has(normalized)) {
+            continue;
+        }
+        seen.add(normalized);
+        result.push(normalized);
+    }
+    return result;
+}
+function toRevisionReceipt(row, changed) {
+    const document = parseStoredNoteDocument({
+        contentJson: row.content_json,
+        contentMd: row.content_md,
+    });
+    return {
+        version: normalizeVersion(row.version),
+        updated_at: row.updated_at ?? null,
+        content_hash: `sha256:${getNoteContentHash(document)}`,
+        changed: normalizeChangedFields(changed),
+    };
+}
+async function loadNoteReceiptRows(db, ids) {
+    const rowsById = new Map();
+    const uniqueIds = Array.from(new Set(ids.map((id) => id.trim()).filter(Boolean)));
+    for (let index = 0; index < uniqueIds.length; index += NOTE_RECEIPT_BATCH_SIZE) {
+        const batch = uniqueIds.slice(index, index + NOTE_RECEIPT_BATCH_SIZE);
+        const placeholders = batch.map(() => '?').join(', ');
+        const rows = await db.getAll(`
+      SELECT id, content_md, content_json, updated_at, version
+      FROM c_note
+      WHERE id IN (${placeholders})
+      `, batch);
+        for (const row of rows) {
+            const id = row.id?.trim() ?? '';
+            if (id) {
+                rowsById.set(id, row);
+            }
+        }
+    }
+    return rowsById;
+}
+export async function readNoteRevisionReceipts(db, ids, changesById) {
+    const uniqueIds = Array.from(new Set(ids.map((id) => id.trim()).filter(Boolean)));
+    const rowsById = await loadNoteReceiptRows(db, uniqueIds);
+    const missing = uniqueIds.filter((id) => !rowsById.has(id));
+    if (missing.length > 0) {
+        throw new DinoxError(`Could not read note write receipt for: ${missing.join(', ')}`, {
+            code: 'PRECONDITION_FAILED',
+            suggestion: 'Run `dino doctor --format json` to inspect the local database, then retry the write.',
+            recoverable: true,
+        });
+    }
+    return new Map(uniqueIds.map((id) => [
+        id,
+        toRevisionReceipt(rowsById.get(id), changesById.get(id) ?? []),
+    ]));
+}
+export async function readNoteWriteReceipt(db, id, input) {
+    const revisions = await readNoteRevisionReceipts(db, [id], new Map([[id, input.changed]]));
+    return {
+        ...input.upload,
+        ...revisions.get(id),
+        stale: input.stale,
+    };
+}
+export function buildBatchWriteReceiptFields(upload, stale) {
+    return {
+        ...upload,
+        stale,
+    };
+}

package/dist/commands/prompt/index.js

@@ -5,13 +5,14 @@ import { buildPromptAddDryRunPreview } from '../writeDryRun.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, syncBeforeCommand, waitForMutationUpload, withCommandRuntime, } from '../runtime.js';
+import { commandStale, printStaleCacheWarning, syncBeforeCommand, waitForMutationUpload, withCommandRuntime, } from '../runtime.js';
 import { addPrompt, inspectAddPrompt, listPrompts } from './repo.js';
 const PROMPT_GLOBAL_OPTIONS = [...FORMAT_OPTIONS, ...OFFLINE_OPTIONS, ...REQUIRE_SYNC_OPTIONS, ...SYNC_TIMEOUT_OPTIONS];
 async function runPromptList(context) {
     await withCommandRuntime(context, async (runtime) => {
+        const identity = await resolveAuthIdentity(runtime.config);
         await syncBeforeCommand(runtime, { syncTokenIndex: true });
-        printSuccess((await listPrompts(runtime.db)).map((prompt) => ({
+        printSuccess((await listPrompts(runtime.db, { userId: identity.userId })).map((prompt) => ({
             name: prompt.name,
             prompt: prompt.cmd,
         })));
@@ -47,7 +48,6 @@ async function runPromptAdd(context) {
             cmd,
             userId: identity.userId,
         });
-        printUploadDisabledWarning(runtime);
         await waitForMutationUpload(runtime);
         const payload = {
             ok: true,

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

@@ -3,6 +3,9 @@ export type PromptListItem = {
     name: string;
     cmd: string;
 };
+export type ListPromptsInput = {
+    userId?: string;
+};
 export type AddPromptInput = {
     name: string;
     cmd: string;
@@ -20,6 +23,6 @@ export type InspectAddPromptResult = {
     restored: boolean;
     existingId?: string;
 };
-export declare function listPrompts(db: AbstractPowerSyncDatabase): Promise<PromptListItem[]>;
+export declare function listPrompts(db: AbstractPowerSyncDatabase, input?: ListPromptsInput): Promise<PromptListItem[]>;
 export declare function addPrompt(db: AbstractPowerSyncDatabase, input: AddPromptInput): Promise<AddPromptResult>;
 export declare function inspectAddPrompt(db: AbstractPowerSyncDatabase, input: AddPromptInput): Promise<InspectAddPromptResult>;

package/dist/commands/prompt/repo.js

@@ -10,7 +10,7 @@ async function getPromptColumns(db) {
     const rows = await db.getAll('PRAGMA table_info(c_cmd)', []);
     return new Set(rows.map((row) => row.name).filter(Boolean));
 }
-async function listPromptRowsForWrite(db, columnNames) {
+async function listPromptRowsForWrite(db, columnNames, userId) {
     const isDelExpr = columnNames.has('is_del') ? 'is_del' : 'NULL';
     const userIdExpr = columnNames.has('user_id') ? `TRIM(COALESCE(user_id, ''))` : `''`;
     const activeFirstExpr = columnNames.has('is_del')
@@ -18,6 +18,7 @@ async function listPromptRowsForWrite(db, columnNames) {
         : '0';
     const updateOrderExpr = columnNames.has('update_at') ? 'update_at DESC,' : '';
     const insertOrderExpr = columnNames.has('insert_at') ? 'insert_at DESC,' : '';
+    const userFilter = columnNames.has('user_id') ? `AND TRIM(COALESCE(user_id, '')) = ?` : '';
     return db.getAll(`
     SELECT
       TRIM(COALESCE(id, '')) AS id,
@@ -27,14 +28,21 @@ async function listPromptRowsForWrite(db, columnNames) {
       ${userIdExpr} AS user_id
     FROM c_cmd
     WHERE TRIM(COALESCE(id, '')) <> ''
+      ${userFilter}
     ORDER BY
       ${activeFirstExpr} ASC,
       ${updateOrderExpr}
       ${insertOrderExpr}
       id DESC
-    `, []);
+    `, columnNames.has('user_id') ? [userId] : []);
 }
-export async function listPrompts(db) {
+export async function listPrompts(db, input = {}) {
+    const userId = normalizeText(input.userId ?? '');
+    const columnNames = await getPromptColumns(db);
+    if (columnNames.has('user_id') && !userId) {
+        throw new DinoxError('c_cmd query requires user_id. Missing resolved userId. Run `dino auth login` first, or set DINOX_TOKEN and run an online command so the CLI can resolve the token identity.');
+    }
+    const userFilter = columnNames.has('user_id') ? `AND TRIM(COALESCE(user_id, '')) = ?` : '';
     const rows = await db.getAll(`
     SELECT DISTINCT
       TRIM(COALESCE(name, '')) AS name,
@@ -43,8 +51,9 @@ export async function listPrompts(db) {
     WHERE (is_del IS NULL OR is_del = 0)
       AND TRIM(COALESCE(name, '')) <> ''
       AND TRIM(COALESCE(cmd, '')) <> ''
+      ${userFilter}
     ORDER BY COALESCE(priority, 0) DESC, name COLLATE NOCASE ASC, cmd COLLATE NOCASE ASC
-    `, []);
+    `, columnNames.has('user_id') ? [userId] : []);
     return rows
         .map((row) => ({
         name: row.name?.trim() ?? '',
@@ -73,7 +82,7 @@ export async function addPrompt(db, input) {
     if (columnNames.has('user_id') && !userId) {
         throw new DinoxError('c_cmd insert requires user_id. Missing resolved 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 listPromptRowsForWrite(db, columnNames);
+    const rows = await listPromptRowsForWrite(db, columnNames, userId);
     const samePromptRows = rows.filter((row) => {
         return normalizeLookup(row.name ?? '') === nameLookup && normalizeLookup(row.cmd ?? '') === cmdLookup;
     });
@@ -113,7 +122,8 @@ export async function addPrompt(db, input) {
         UPDATE c_cmd
         SET ${setParts.join(', ')}
         WHERE id = ?
-        `, params);
+          ${columnNames.has('user_id') ? `AND TRIM(COALESCE(user_id, '')) = ?` : ''}
+        `, columnNames.has('user_id') ? [...params, userId] : params);
         }
         return {
             id: deletedRow.id,
@@ -183,7 +193,7 @@ export async function inspectAddPrompt(db, input) {
     if (columnNames.has('user_id') && !userId) {
         throw new DinoxError('c_cmd insert requires user_id. Missing resolved 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 listPromptRowsForWrite(db, columnNames);
+    const rows = await listPromptRowsForWrite(db, columnNames, userId);
     const samePromptRows = rows.filter((row) => {
         return normalizeLookup(row.name ?? '') === nameLookup && normalizeLookup(row.cmd ?? '') === cmdLookup;
     });

package/dist/commands/runtime.d.ts

@@ -4,10 +4,21 @@ import { loadConfig } from '../config/store.js';
 import type { ResolvedDinoxConfig } from '../config/types.js';
 import { type SyncGateResult } from '../powersync/syncGate.js';
 import type { CommandExecutionContext } from './descriptor/types.js';
+import { type WriteDurability } from './writeDurability.js';
+export type MutationUploadReceipt = {
+    durability: WriteDurability;
+    upload_queue_remaining: number | null;
+    upload_error?: {
+        name: string;
+        message: string;
+    };
+};
 export type CommandSyncState = {
     firstSyncStale: boolean;
     preSyncIdle: boolean | null;
+    recentSync: boolean | null;
     gate: SyncGateResult | null;
+    startedAtIso: string;
 };
 export type CommandRuntime = {
     db: AbstractPowerSyncDatabase;
@@ -21,6 +32,7 @@ export type CommandRuntime = {
 };
 type RuntimeSource = CommandExecutionContext | Command | Record<string, unknown>;
 export declare function commandStale(runtime: Pick<CommandRuntime, 'offline' | 'stale'>): boolean;
+export declare function resolveWriteDurabilityForRuntime(runtime: Pick<CommandRuntime, 'offline'>, value: unknown): WriteDurability;
 export declare function withCommandRuntime<T>(source: RuntimeSource, run: (runtime: CommandRuntime) => Promise<T>): Promise<T>;
 export declare function syncBeforeCommand(runtime: CommandRuntime, options?: {
     syncTokenIndex?: boolean;
@@ -28,7 +40,7 @@ export declare function syncBeforeCommand(runtime: CommandRuntime, options?: {
 }): Promise<void>;
 export declare function waitForMutationUpload(runtime: CommandRuntime, options?: {
     timeoutMs?: number;
-}): Promise<void>;
-export declare function printUploadDisabledWarning(runtime: CommandRuntime, message?: string): void;
+    durability?: unknown;
+}): Promise<MutationUploadReceipt>;
 export declare function printStaleCacheWarning(runtime: CommandRuntime, message?: string): void;
 export {};