@dinoxx/dinox-cli 1.1.0 → 2.0.0

package/dist/commands/sync.js

@@ -9,13 +9,109 @@ import { parseSyncTimeoutMs } from '../utils/syncTimeout.js';
 import { getStatusSnapshot, waitForLastSyncedAfter, } from '../powersync/runtime.js';
 import { runSingleSyncPass } from '../powersync/syncPass.js';
 import { createSyncRequiredError, evaluateSyncGate } from '../powersync/syncGate.js';
+const MAX_SYNC_CLEANUP_RESERVE_MS = 5_000;
+const syncCommandDependencies = {
+    loadConfig,
+    resolveConfig,
+    hydrateResolvedAuthIdentity,
+    withExclusivePowerSync,
+    getRequestedStructuredOutputFormat,
+    getStatusSnapshot,
+    waitForLastSyncedAfter,
+    runSingleSyncPass,
+    printHumanReadableLine,
+    printSuccess,
+    now: Date.now,
+};
+export async function executeSyncCommand(context, overrides = {}) {
+    const dependencies = { ...syncCommandDependencies, ...overrides };
+    const startedAtMs = dependencies.now();
+    const startedAtIso = new Date(startedAtMs).toISOString();
+    const baseConfig = dependencies.resolveConfig(await dependencies.loadConfig());
+    const structuredOutput = dependencies.getRequestedStructuredOutputFormat() !== null;
+    const timeoutMs = parseSyncTimeoutMs(context.globals.syncTimeout) ?? baseConfig.sync.timeoutMs;
+    const deadlineAtMs = startedAtMs + timeoutMs;
+    const cleanupReserveMs = Math.min(MAX_SYNC_CLEANUP_RESERVE_MS, Math.max(1, Math.floor(timeoutMs * 0.2)));
+    const operationDeadlineAtMs = deadlineAtMs - cleanupReserveMs;
+    const remainingTimeoutMs = (reserveMs = 0) => Math.max(1, deadlineAtMs - dependencies.now() - reserveMs);
+    const { config } = await dependencies.hydrateResolvedAuthIdentity(baseConfig, {
+        timeoutMs: remainingTimeoutMs(),
+    });
+    const strict = Boolean(context.options.strict);
+    const result = await dependencies.withExclusivePowerSync({
+        config,
+        offline: false,
+        timeoutMs: remainingTimeoutMs(),
+        deadlineAtMs,
+        operationDeadlineAtMs,
+        waitForInitialSync: false,
+        expectedTokenFingerprint: config.auth.tokenFingerprint ?? null,
+        cleanupFailureMode: 'throw',
+    }, async ({ db, dbPath, stale }) => {
+        const recentSync = strict
+            ? await dependencies.waitForLastSyncedAfter(db, startedAtIso, remainingTimeoutMs(cleanupReserveMs))
+            : true;
+        const syncPass = await dependencies.runSingleSyncPass(db, remainingTimeoutMs(cleanupReserveMs));
+        const status = dependencies.getStatusSnapshot(db);
+        const gate = evaluateSyncGate({
+            offline: false,
+            firstSyncStale: stale,
+            idle: syncPass.downloadIdle,
+            indexComplete: syncPass.tokenIndex.complete,
+            recentSync,
+            status,
+        });
+        const payload = {
+            ok: true,
+            dbPath,
+            stale: !gate.ok,
+            idle: syncPass.idle,
+            downloadIdle: syncPass.downloadIdle,
+            uploadIdle: syncPass.uploadIdle,
+            strict,
+            gate,
+            uploadEnabled: Boolean(config.powersync.uploadBaseUrl),
+            tokenIndex: syncPass.tokenIndex,
+            status,
+        };
+        if (strict && !gate.ok) {
+            throw createSyncRequiredError(gate, status);
+        }
+        return payload;
+    });
+    const payload = {
+        ...result,
+        elapsedMs: Math.max(0, dependencies.now() - startedAtMs),
+    };
+    if (structuredOutput) {
+        dependencies.printSuccess(payload);
+        return;
+    }
+    dependencies.printHumanReadableLine(`db: ${payload.dbPath}`);
+    if (payload.status.lastSyncedAt) {
+        dependencies.printHumanReadableLine(`lastSyncedAt: ${payload.status.lastSyncedAt}`);
+    }
+    if (payload.stale) {
+        dependencies.printHumanReadableLine('warning: sync freshness or local index could not be fully verified');
+    }
+    if (!payload.downloadIdle) {
+        dependencies.printHumanReadableLine('warning: download flow did not settle before timeout');
+    }
+    if (!payload.uploadIdle) {
+        dependencies.printHumanReadableLine('warning: uploads are still active; downloaded data may already be current');
+    }
+    if (!payload.tokenIndex.complete) {
+        dependencies.printHumanReadableLine('warning: local token index did not finish before timeout');
+    }
+    dependencies.printHumanReadableLine(`tokenIndex: complete=${payload.tokenIndex.complete} scanned=${payload.tokenIndex.scanned} reindexed=${payload.tokenIndex.reindexed} skipped=${payload.tokenIndex.skipped} removed=${payload.tokenIndex.removed} ftsRowsUpserted=${payload.tokenIndex.ftsRowsUpserted}`);
+}
 export const syncCommandDescriptor = {
     name: 'sync',
     description: 'Connect and synchronize the local PowerSync database',
     options: [
         {
             flags: '--strict',
-            description: 'Fail unless connected, a new checkpoint completes, data flow is idle, and no download error exists',
+            description: 'Fail unless connected, a current checkpoint completes, downloads settle, and the local index finishes',
             type: 'boolean',
         },
     ],
@@ -27,65 +123,11 @@ export const syncCommandDescriptor = {
         output: {
             type: 'structured',
             summary: 'Sync result with connection status and token index counters',
-            fields: ['dbPath', 'stale', 'idle', 'strict', 'gate', 'uploadEnabled', 'tokenIndex', 'status'],
+            fields: ['dbPath', 'stale', 'idle', 'downloadIdle', 'uploadIdle', 'strict', 'gate', 'uploadEnabled', 'tokenIndex', 'status', 'elapsedMs'],
         },
-        examples: ['dino sync --format json', 'dino sync --strict --sync-timeout 600000 --format json'],
-    },
-    action: async (context) => {
-        const startedAtIso = new Date().toISOString();
-        const baseConfig = resolveConfig(await loadConfig());
-        const structuredOutput = getRequestedStructuredOutputFormat() !== null;
-        const timeoutMs = parseSyncTimeoutMs(context.globals.syncTimeout) ?? baseConfig.sync.timeoutMs;
-        const { config } = await hydrateResolvedAuthIdentity(baseConfig, { timeoutMs });
-        await withExclusivePowerSync({
-            config,
-            offline: false,
-            timeoutMs,
-            expectedTokenFingerprint: config.auth.tokenFingerprint ?? null,
-        }, async ({ db, dbPath, stale }) => {
-            const syncPass = await runSingleSyncPass(db, timeoutMs);
-            const recentSync = context.options.strict
-                ? await waitForLastSyncedAfter(db, startedAtIso, timeoutMs)
-                : true;
-            const status = getStatusSnapshot(db);
-            const gate = evaluateSyncGate({
-                offline: false,
-                firstSyncStale: stale,
-                idle: syncPass.idle,
-                recentSync,
-                status,
-            });
-            const payload = {
-                ok: true,
-                dbPath,
-                stale: !gate.ok,
-                idle: syncPass.idle,
-                strict: Boolean(context.options.strict),
-                gate,
-                uploadEnabled: Boolean(config.powersync.uploadBaseUrl),
-                tokenIndex: syncPass.tokenIndex,
-                status,
-            };
-            if (context.options.strict && !gate.ok) {
-                throw createSyncRequiredError(gate, status);
-            }
-            if (structuredOutput) {
-                printSuccess(payload);
-                return;
-            }
-            printHumanReadableLine(`db: ${payload.dbPath}`);
-            if (payload.status.lastSyncedAt) {
-                printHumanReadableLine(`lastSyncedAt: ${payload.status.lastSyncedAt}`);
-            }
-            if (payload.stale) {
-                printHumanReadableLine('warning: sync timed out; local cache may be stale');
-            }
-            if (!payload.idle) {
-                printHumanReadableLine('warning: data flow did not become idle before timeout');
-            }
-            printHumanReadableLine(`tokenIndex: scanned=${payload.tokenIndex.scanned} reindexed=${payload.tokenIndex.reindexed} skipped=${payload.tokenIndex.skipped} removed=${payload.tokenIndex.removed} ftsRowsUpserted=${payload.tokenIndex.ftsRowsUpserted}`);
-        });
+        examples: ['dino sync --sync-timeout 20000 --format json', 'dino sync --strict --sync-timeout 20000 --format json'],
     },
+    action: executeSyncCommand,
 };
 export function registerSyncCommand(program) {
     registerStandaloneCommand(program, syncCommandDescriptor);

package/dist/commands/tags/index.js

@@ -6,6 +6,7 @@ import { printDryRunPreview } from '../../utils/dryRun.js';
 import { DinoxError } from '../../utils/errors.js';
 import { getRequestedStructuredOutputFormat, printHumanReadableLine, printSuccess, } from '../../utils/output.js';
 import { commandStale, printStaleCacheWarning, syncBeforeCommand, waitForMutationUpload, withCommandRuntime, } from '../runtime.js';
+import { assertWriteConfirmationProvided, parseExpectedCount } from '../writeConfirmation.js';
 import { addTag, inspectAddTag, listTags } from './repo.js';
 import { getTagStats, getTagTree, inspectTagCleanup, mergeTag, moveTag, renameTag, suggestTagMerges, } from './operations.js';
 const TAG_GLOBAL_OPTIONS = [...FORMAT_OPTIONS, ...OFFLINE_OPTIONS, ...REQUIRE_SYNC_OPTIONS, ...SYNC_TIMEOUT_OPTIONS];
@@ -67,7 +68,7 @@ async function runTagAdd(context) {
                     userId: identity.userId,
                     emoji,
                 })),
-            }));
+            }), runtime);
             return;
         }
         const result = await addTag(runtime.db, {
@@ -114,7 +115,7 @@ async function runTagRename(context) {
                 summary: `Rename tag "${result.fromPath}" to "${result.toPath}".`,
                 inputs: { path, new_name: newName },
                 changes: { updated_tags: result.updatedTags, updated_notes: result.updatedNotes },
-            }));
+            }), runtime);
             return;
         }
         await waitForMutationUpload(runtime);
@@ -139,7 +140,7 @@ async function runTagMove(context) {
                 summary: `Move tag "${result.fromPath}" to "${result.toPath}".`,
                 inputs: { path, to },
                 changes: { updated_tags: result.updatedTags, updated_notes: result.updatedNotes },
-            }));
+            }), runtime);
             return;
         }
         await waitForMutationUpload(runtime);
@@ -149,9 +150,17 @@ async function runTagMove(context) {
 async function runTagMerge(context) {
     const from = requireArg(context.args.from, 'Source tag path is required');
     const to = requireArg(context.args.to, 'Target tag path is required');
+    const dryRun = Boolean(context.options.dryRun);
+    const expectedCount = parseExpectedCount(context.options.expectedCount);
+    const writeOptions = {
+        dryRun,
+        confirm: Boolean(context.options.confirm),
+        expectedCount,
+    };
+    assertWriteConfirmationProvided('Tag merge', writeOptions);
     await withTagWriteRuntime(context, async ({ runtime, userId }) => {
-        const result = await mergeTag(runtime.db, { from, to, userId }, { dryRun: Boolean(context.options.dryRun) });
-        if (Boolean(context.options.dryRun)) {
+        const result = await mergeTag(runtime.db, { from, to, userId }, writeOptions);
+        if (dryRun) {
             printDryRunPreview(buildTagMutationDryRunPreview({
                 config: runtime.config,
                 offline: runtime.offline,
@@ -159,12 +168,15 @@ async function runTagMerge(context) {
                 action: 'merge_tag',
                 risk: 'high-risk-write',
                 summary: `Merge tag subtree "${result.fromPath}" into "${result.toPath}".`,
-                inputs: { from, to },
+                inputs: { from, to, expected_count: expectedCount },
                 changes: {
+                    affected_count: result.affectedCount,
+                    soft_deleted_tag_count: result.softDeletedTagIds.length,
+                    updated_note_count: result.updatedNotes.length,
                     soft_deleted_tag_ids: result.softDeletedTagIds,
                     updated_notes: result.updatedNotes,
                 },
-            }));
+            }), runtime);
             return;
         }
         await waitForMutationUpload(runtime);
@@ -193,7 +205,7 @@ async function runTagCleanup(context) {
                 summary: `Inspect tag cleanup candidates (${result.issues.length} issues).`,
                 inputs: {},
                 targets: result.issues,
-            }));
+            }), runtime);
             return;
         }
         printSuccess({ stale: commandStale(runtime), ...result });
@@ -328,7 +340,11 @@ export const tagCommandGroup = {
                 { syntax: '<from>', description: 'Source tag path' },
                 { syntax: '<to>', description: 'Target tag path' },
             ],
-            options: [{ flags: '--dry-run', description: 'Preview the write without executing it' }],
+            options: [
+                { flags: '--expected-count <n>', description: 'Required for real writes; must equal source tags plus notes affected', type: 'number' },
+                { flags: '--confirm', description: 'Required for real writes after reviewing a dry run', type: 'boolean' },
+                { flags: '--dry-run', description: 'Preview the write without executing it', type: 'boolean' },
+            ],
             schema: {
                 path: 'tag.merge',
                 risk: 'high-risk-write',
@@ -337,9 +353,12 @@ export const tagCommandGroup = {
                 output: {
                     type: 'structured',
                     summary: 'Tag merge result',
-                    fields: ['fromId', 'toId', 'fromPath', 'toPath', 'softDeletedTagIds', 'updatedNotes', 'stale'],
+                    fields: ['fromId', 'toId', 'fromPath', 'toPath', 'softDeletedTagIds', 'updatedNotes', 'affectedCount', 'stale'],
                 },
-                examples: ['dino tag merge "ai" "AI" --format json --dry-run'],
+                examples: [
+                    'dino tag merge "ai" "AI" --format json --dry-run',
+                    'dino tag merge "ai" "AI" --expected-count 4 --confirm --format json',
+                ],
             },
             action: runTagMerge,
         },

package/dist/commands/tags/operations.d.ts

@@ -1,4 +1,5 @@
 import type { AbstractPowerSyncDatabase } from '@powersync/common';
+import { type ConfirmedWriteOptions } from '../writeConfirmation.js';
 import type { TagListItem } from './model.js';
 export type TagTreeNode = TagListItem & {
     isActual: boolean;
@@ -63,6 +64,7 @@ export type TagMergeResult = {
         before: string[];
         after: string[];
     }>;
+    affectedCount: number;
 };
 export type TagSuggestResult = {
     suggestions: Array<{
@@ -98,8 +100,6 @@ export declare function renameTag(db: AbstractPowerSyncDatabase, input: TagRenam
 export declare function moveTag(db: AbstractPowerSyncDatabase, input: TagMoveInput, options?: {
     dryRun?: boolean;
 }): Promise<TagRenameMoveResult>;
-export declare function mergeTag(db: AbstractPowerSyncDatabase, input: TagMergeInput, options?: {
-    dryRun?: boolean;
-}): Promise<TagMergeResult>;
+export declare function mergeTag(db: AbstractPowerSyncDatabase, input: TagMergeInput, options?: ConfirmedWriteOptions): Promise<TagMergeResult>;
 export declare function inspectTagCleanup(db: AbstractPowerSyncDatabase, input?: TagReadInput): Promise<TagCleanupResult>;
 export declare function suggestTagMerges(db: AbstractPowerSyncDatabase, input?: TagReadInput): Promise<TagSuggestResult>;

package/dist/commands/tags/operations.js

@@ -1,6 +1,7 @@
 import { withPowerSyncWriteTransaction } from '../../powersync/runtime.js';
 import { DinoxError } from '../../utils/errors.js';
 import { nowIsoUtc } from '../../utils/time.js';
+import { assertConfirmedWrite, assertWriteConfirmationProvided, } from '../writeConfirmation.js';
 import { mergeTagReferencesInNote, renameTagReferencesInNote } from './content.js';
 import { MAX_TAG_SEGMENT_LENGTH, REQUIRED_NOTE_TAG_COLUMNS, REQUIRED_TAG_NODE_COLUMNS, canonicalizeTagPath, getLeafName, isActiveTagNode, isActualTagNode, isTagPathWithinPrefix, normalizeTagLookupKey, parseStoredTags, parentPathOf, renameTagPathWithPrefix, trimString, } from './model.js';
 import { activeTagNodes, actualActiveTagNodes, assertCanWriteTag, assertRequiredColumns, assertWritableTagNodes, descendantsOf, ensureNoTagPathConflict, getTableColumns, loadTagNodes, parentIdForPath, requireActiveTagPath, toTagListItem, } from './store.js';
@@ -297,7 +298,7 @@ export async function moveTag(db, input, options = {}) {
         updatedNotes: noteUpdates.map(({ id, before, after }) => ({ id, before, after })),
     };
 }
-export async function mergeTag(db, input, options = {}) {
+async function buildTagMergePlan(db, input) {
     const from = assertPath(input.from, 'Source tag path');
     const to = assertPath(input.to, 'Target tag path');
     const userId = trimString(input.userId);
@@ -318,28 +319,52 @@ export async function mergeTag(db, input, options = {}) {
         .map((row) => updateNoteTagsForPrefix(row, source.fullPath, target.fullPath, 'merge', lookup))
         .filter((row) => row.id && row.changed);
     const softDeletedTagIds = sourceNodes.map((node) => node.id);
-    if (!options.dryRun) {
-        await withPowerSyncWriteTransaction(db, async (tx) => {
-            const timestamp = nowIsoUtc();
-            await applyNoteUpdates(tx, noteUpdates, timestamp);
-            for (const tagId of softDeletedTagIds) {
-                await tx.execute(`
-          UPDATE c_tag_node
-          SET is_del = 1, updated_at = ?
-          WHERE id = ?
-          `, [timestamp, tagId]);
-            }
-        });
-    }
+    const affectedCount = softDeletedTagIds.length + noteUpdates.length;
     return {
-        fromId: source.id,
-        toId: target.id,
-        fromPath: source.fullPath,
-        toPath: target.fullPath,
-        softDeletedTagIds,
-        updatedNotes: noteUpdates.map(({ id, before, after }) => ({ id, before, after })),
+        result: {
+            fromId: source.id,
+            toId: target.id,
+            fromPath: source.fullPath,
+            toPath: target.fullPath,
+            softDeletedTagIds,
+            updatedNotes: noteUpdates.map(({ id, before, after }) => ({ id, before, after })),
+            affectedCount,
+        },
+        noteUpdates,
+        userId,
     };
 }
+function assertTagMergeCount(plan, options) {
+    assertConfirmedWrite({
+        operation: 'Tag merge',
+        schemaPath: 'tag.merge',
+        actualCount: plan.result.affectedCount,
+        options,
+    });
+}
+export async function mergeTag(db, input, options = {}) {
+    if (options.dryRun) {
+        const plan = await buildTagMergePlan(db, input);
+        assertTagMergeCount(plan, options);
+        return plan.result;
+    }
+    assertWriteConfirmationProvided('Tag merge', options);
+    return withPowerSyncWriteTransaction(db, async (tx) => {
+        const plan = await buildTagMergePlan(tx, input);
+        assertTagMergeCount(plan, options);
+        const timestamp = nowIsoUtc();
+        await applyNoteUpdates(tx, plan.noteUpdates, timestamp);
+        for (const tagId of plan.result.softDeletedTagIds) {
+            await tx.execute(`
+        UPDATE c_tag_node
+        SET is_del = 1, updated_at = ?
+        WHERE id = ?
+          AND TRIM(COALESCE(user_id, '')) = ?
+        `, [timestamp, tagId, plan.userId]);
+        }
+        return plan.result;
+    });
+}
 export async function inspectTagCleanup(db, input = {}) {
     const columns = await getTableColumns(db, 'c_tag_node');
     assertRequiredColumns('c_tag_node', columns, REQUIRED_TAG_NODE_COLUMNS);

package/dist/commands/templates/model.d.ts

@@ -0,0 +1,50 @@
+import { type TiptapNode } from '../notes/contentEngine.js';
+export declare const NOTE_TEMPLATE_PROPERTY_DEF_VERSION = 1;
+export declare const MAX_NOTE_TEMPLATE_PROPERTY_KEYS = 50;
+export declare const MAX_NOTE_TEMPLATE_CONTENT_LENGTH = 200000;
+export type NoteTemplatePropertyDef = {
+    version: typeof NOTE_TEMPLATE_PROPERTY_DEF_VERSION;
+    keys: string[];
+};
+export type NoteTemplateRow = {
+    id: string;
+    user_id: string | null;
+    name: string | null;
+    content: string | null;
+    priority: number | null;
+    is_show: number | null;
+    extra_data: string | null;
+    property_def: string | null;
+    insert_at: string | null;
+    update_at: string | null;
+    is_del: number | null;
+};
+export type NoteTemplateSummary = {
+    id: string;
+    name: string;
+    propertyKeys: string[];
+    content: string;
+    hasContent: boolean;
+    isShow: boolean;
+    priority: number;
+    updateAt: string | null;
+};
+export type NoteTemplateTokenValues = {
+    date: string;
+    datetime: string;
+    time: string;
+    location: string;
+};
+export declare function isNotePropertyKeyValid(value: unknown): value is string;
+export declare function validateNoteTemplatePropertyKeys(keys: readonly unknown[]): string[];
+export declare function parseNoteTemplatePropertyDef(raw: string | null | undefined): NoteTemplatePropertyDef | null;
+export declare function serializeNoteTemplatePropertyDef(keys: readonly string[]): string | null;
+export declare function isNoteTemplateDocumentEmpty(document: TiptapNode | null | undefined): boolean;
+export declare function parseNoteTemplateContent(raw: string | null | undefined): TiptapNode | null;
+export declare function serializeNoteTemplateContent(document: unknown): string;
+export declare function buildNoteTemplateTokenValues(now?: Date, location?: string): NoteTemplateTokenValues;
+export declare function hydrateNoteTemplateDocument(document: TiptapNode, options?: {
+    now?: Date;
+    location?: string;
+}): TiptapNode;
+export declare function mapNoteTemplateRow(row: NoteTemplateRow): NoteTemplateSummary;