@dinoxx/dinox-cli 1.1.0 → 1.1.1

package/README.md

@@ -681,13 +681,16 @@ dino auth logout --clear-local-db
 
 ```bash
 dino sync
-dino sync --sync-timeout 600000
+dino sync --sync-timeout 20000
 ```
 
 用途说明：
 
 - 主动执行一次连接与同步
 - 首次使用、网络恢复后、或想刷新本地缓存时最常用
+- `--sync-timeout` 是包含 checkpoint、下载、本地索引和前台运行时准备在内的总预算；AI/CI 外层命令超时应至少比它多几秒
+- 上传仍在进行不会阻塞下载新鲜度。判断成功应看 `stale`、`downloadIdle` 和 `gate`，不能只看兼容字段 `idle`
+- 结构化成功结果会在数据库关闭、owner lease 释放和 daemon 恢复完成后输出
 
 ### 6.4 `note`：笔记管理
 

package/dist/commands/runtime.js

@@ -2,9 +2,10 @@ import { hydrateResolvedAuthIdentity } from '../auth/userInfo.js';
 import { loadConfig } from '../config/store.js';
 import { resolveConfig } from '../config/resolve.js';
 import { withExclusivePowerSync } from '../powersync/exclusiveRuntime.js';
-import { getStatusSnapshot, waitForIdleDataFlow, waitForLastSyncedAfter, waitForUploadQueueEmpty, } from '../powersync/runtime.js';
+import { getStatusSnapshot, waitForDownloadIdle, waitForLastSyncedAfter, waitForUploadQueueEmpty, } from '../powersync/runtime.js';
 import { createSyncRequiredError, evaluateSyncGate } from '../powersync/syncGate.js';
 import { syncNoteTokenIndex } from '../powersync/tokenIndex.js';
+import { createTimeoutSignal } from '../utils/abort.js';
 import { DinoxError } from '../utils/errors.js';
 import { printHumanReadableWarning } from '../utils/output.js';
 import { parseSyncTimeoutMs } from '../utils/syncTimeout.js';
@@ -94,20 +95,30 @@ export async function syncBeforeCommand(runtime, options = {}) {
         }
         return;
     }
-    const idle = await waitForIdleDataFlow(runtime.db, Math.min(runtime.timeoutMs, options.timeoutMs ?? PRE_SYNC_TIMEOUT_MS));
-    runtime.sync.preSyncIdle = idle;
+    const timeoutMs = Math.min(runtime.timeoutMs, options.timeoutMs ?? PRE_SYNC_TIMEOUT_MS);
+    const deadlineAtMs = Date.now() + timeoutMs;
+    const remainingTimeoutMs = () => Math.max(0, deadlineAtMs - Date.now());
     const recentSync = runtime.requireSync
-        ? await waitForLastSyncedAfter(runtime.db, runtime.sync.startedAtIso, Math.min(runtime.timeoutMs, options.timeoutMs ?? PRE_SYNC_TIMEOUT_MS))
+        ? await waitForLastSyncedAfter(runtime.db, runtime.sync.startedAtIso, Math.max(1, remainingTimeoutMs()))
         : true;
     runtime.sync.recentSync = recentSync;
+    const downloadIdle = await waitForDownloadIdle(runtime.db, Math.max(1, remainingTimeoutMs()));
+    runtime.sync.preSyncIdle = downloadIdle;
+    let indexComplete;
     if (options.syncTokenIndex) {
-        await syncNoteTokenIndex(runtime.db);
+        const indexTimeoutMs = remainingTimeoutMs();
+        const timeout = indexTimeoutMs > 0 ? createTimeoutSignal(indexTimeoutMs) : null;
+        const tokenIndex = await syncNoteTokenIndex(runtime.db, {
+            signal: timeout?.signal ?? AbortSignal.abort(),
+        }).finally(() => timeout?.cancel());
+        indexComplete = tokenIndex.complete;
     }
     const status = getStatusSnapshot(runtime.db);
     const gate = evaluateSyncGate({
         offline: runtime.offline,
         firstSyncStale: runtime.sync.firstSyncStale,
-        idle,
+        idle: downloadIdle,
+        indexComplete,
         recentSync,
         status,
     });

package/dist/commands/sync.d.ts

@@ -1,4 +1,26 @@
 import { Command } from 'commander';
-import type { CommandDescriptor } from './descriptor/types.js';
+import { loadConfig } from '../config/store.js';
+import { resolveConfig } from '../config/resolve.js';
+import { hydrateResolvedAuthIdentity } from '../auth/userInfo.js';
+import { withExclusivePowerSync } from '../powersync/exclusiveRuntime.js';
+import type { CommandDescriptor, CommandExecutionContext } from './descriptor/types.js';
+import { getRequestedStructuredOutputFormat, printHumanReadableLine, printSuccess } from '../utils/output.js';
+import { getStatusSnapshot, waitForLastSyncedAfter } from '../powersync/runtime.js';
+import { runSingleSyncPass } from '../powersync/syncPass.js';
+type SyncCommandDependencies = {
+    loadConfig: typeof loadConfig;
+    resolveConfig: typeof resolveConfig;
+    hydrateResolvedAuthIdentity: typeof hydrateResolvedAuthIdentity;
+    withExclusivePowerSync: typeof withExclusivePowerSync;
+    getRequestedStructuredOutputFormat: typeof getRequestedStructuredOutputFormat;
+    getStatusSnapshot: typeof getStatusSnapshot;
+    waitForLastSyncedAfter: typeof waitForLastSyncedAfter;
+    runSingleSyncPass: typeof runSingleSyncPass;
+    printHumanReadableLine: typeof printHumanReadableLine;
+    printSuccess: typeof printSuccess;
+    now: () => number;
+};
+export declare function executeSyncCommand(context: CommandExecutionContext, overrides?: Partial<SyncCommandDependencies>): Promise<void>;
 export declare const syncCommandDescriptor: CommandDescriptor;
 export declare function registerSyncCommand(program: Command): void;
+export {};

package/dist/commands/sync.js

@@ -9,13 +9,108 @@ 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 +122,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/daemon/lifecycle.d.ts

@@ -38,5 +38,7 @@ export declare function suspendDaemonForExclusiveAccessLocked(config: ResolvedDi
 }): Promise<SuspendedDaemon>;
 /** Caller must hold the daemon start lock. */
 export declare function restoreSuspendedDaemonLocked(suspended: SuspendedDaemon, overrides?: Partial<DaemonLifecycleDependencies>): Promise<boolean>;
-export declare function withDaemonExclusiveAccess<T>(config: ResolvedDinoxConfig, timeoutMs: number, run: (control: DaemonExclusiveAccessControl) => Promise<T>, overrides?: Partial<DaemonLifecycleDependencies>): Promise<T>;
+export declare function withDaemonExclusiveAccess<T>(config: ResolvedDinoxConfig, timeoutMs: number, run: (control: DaemonExclusiveAccessControl) => Promise<T>, overrides?: Partial<DaemonLifecycleDependencies>, options?: {
+    deadlineAtMs?: number;
+}): Promise<T>;
 export {};

package/dist/daemon/lifecycle.js

@@ -67,9 +67,12 @@ export async function restoreSuspendedDaemonLocked(suspended, overrides = {}) {
     await deps.startDaemonLocked(suspended.port, true, { quiet: true });
     return true;
 }
-export async function withDaemonExclusiveAccess(config, timeoutMs, run, overrides = {}) {
+export async function withDaemonExclusiveAccess(config, timeoutMs, run, overrides = {}, options = {}) {
     const deps = dependencies(overrides);
-    const releaseStartLock = await deps.acquireStartLock(timeoutMs);
+    const remainingTimeoutMs = () => options.deadlineAtMs === undefined
+        ? timeoutMs
+        : Math.max(1, Math.min(timeoutMs, options.deadlineAtMs - Date.now()));
+    const releaseStartLock = await deps.acquireStartLock(remainingTimeoutMs());
     let suspended = null;
     let restoreAllowed = true;
     let outcome;
@@ -79,7 +82,7 @@ export async function withDaemonExclusiveAccess(config, timeoutMs, run, override
         },
     };
     try {
-        suspended = await suspendDaemonForExclusiveAccessLocked(config, timeoutMs, {
+        suspended = await suspendDaemonForExclusiveAccessLocked(config, remainingTimeoutMs(), {
             dependencies: deps,
         });
         try {

package/dist/powersync/exclusiveRuntime.d.ts

@@ -12,6 +12,7 @@ export declare function withExclusivePowerSync<T>(args: {
     config: ResolvedDinoxConfig;
     offline: boolean;
     timeoutMs: number;
+    deadlineAtMs?: number;
     waitForInitialSync?: boolean;
     expectedTokenFingerprint?: string | null;
     cleanupFailureMode?: 'warn' | 'throw';

package/dist/powersync/exclusiveRuntime.js

@@ -12,9 +12,15 @@ function errorMessage(error) {
 }
 export async function withExclusivePowerSync(args, run, overrides = {}) {
     const dependencies = { ...exclusivePowerSyncDependencies, ...overrides };
-    const { cleanupFailureMode, ...connectArgs } = args;
-    return dependencies.withDaemonExclusiveAccess(args.config, args.timeoutMs, async (daemonLifecycle) => {
-        const connected = await dependencies.connectPowerSync(connectArgs);
+    const { cleanupFailureMode, deadlineAtMs, ...connectArgs } = args;
+    const remainingTimeoutMs = () => deadlineAtMs === undefined
+        ? args.timeoutMs
+        : Math.max(1, Math.min(args.timeoutMs, deadlineAtMs - Date.now()));
+    return dependencies.withDaemonExclusiveAccess(args.config, remainingTimeoutMs(), async (daemonLifecycle) => {
+        const connected = await dependencies.connectPowerSync({
+            ...connectArgs,
+            timeoutMs: remainingTimeoutMs(),
+        });
         let outcome;
         try {
             outcome = { ok: true, value: await run(connected) };
@@ -38,5 +44,5 @@ export async function withExclusivePowerSync(args, run, overrides = {}) {
             throw cleanupError;
         }
         return outcome.value;
-    });
+    }, {}, { deadlineAtMs });
 }

package/dist/powersync/runtime.d.ts

@@ -39,6 +39,7 @@ export declare function connectPowerSync(args: {
     expectedTokenFingerprint?: string | null;
 }): Promise<ConnectResult>;
 export declare function waitForIdleDataFlow(db: AbstractPowerSyncDatabase, timeoutMs: number): Promise<boolean>;
+export declare function waitForDownloadIdle(db: AbstractPowerSyncDatabase, timeoutMs: number): Promise<boolean>;
 export declare function waitForLastSyncedAfter(db: AbstractPowerSyncDatabase, startedAtIso: string, timeoutMs: number): Promise<boolean>;
 export type UploadQueueWaitResult = {
     ok: boolean;

package/dist/powersync/runtime.js

@@ -239,13 +239,33 @@ export async function waitForIdleDataFlow(db, timeoutMs) {
         cancel();
     }
 }
+export async function waitForDownloadIdle(db, timeoutMs) {
+    const { signal, cancel } = createTimeoutSignal(timeoutMs);
+    try {
+        await db.waitForStatus(status => {
+            const flow = status.dataFlowStatus;
+            return Boolean(status.connected) && Boolean(status.hasSynced) && !flow.downloading;
+        }, signal);
+        return !signal.aborted;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        cancel();
+    }
+}
 export async function waitForLastSyncedAfter(db, startedAtIso, timeoutMs) {
     const startedAtMs = Date.parse(startedAtIso);
     if (!Number.isFinite(startedAtMs)) {
         return false;
     }
+    // PowerSync reports checkpoint timestamps with whole-second precision.
+    const startedAtCheckpointPrecisionMs = Math.floor(startedAtMs / 1_000) * 1_000;
     const status = getStatusSnapshot(db);
-    if (status.connected && status.lastSyncedAt && Date.parse(status.lastSyncedAt) >= startedAtMs) {
+    if (status.connected
+        && status.lastSyncedAt
+        && Date.parse(status.lastSyncedAt) >= startedAtCheckpointPrecisionMs) {
         return true;
     }
     const { signal, cancel } = createTimeoutSignal(timeoutMs);
@@ -253,7 +273,9 @@ export async function waitForLastSyncedAfter(db, startedAtIso, timeoutMs) {
         await db.waitForStatus((nextStatus) => {
             const value = nextStatus.lastSyncedAt;
             const lastSyncedAt = value instanceof Date ? value.toISOString() : value ?? null;
-            return Boolean(nextStatus.connected && lastSyncedAt && Date.parse(lastSyncedAt) >= startedAtMs);
+            return Boolean(nextStatus.connected
+                && lastSyncedAt
+                && Date.parse(lastSyncedAt) >= startedAtCheckpointPrecisionMs);
         }, signal);
         return !signal.aborted;
     }

package/dist/powersync/syncGate.d.ts

@@ -1,6 +1,6 @@
 import type { SyncStatusOptions } from '@powersync/common';
 import { DinoxError } from '../utils/errors.js';
-export type SyncGateFailureReason = 'offline' | 'first-sync-timeout' | 'checkpoint-timeout' | 'data-flow-timeout' | 'not-connected' | 'not-synced' | 'download-error';
+export type SyncGateFailureReason = 'offline' | 'first-sync-timeout' | 'checkpoint-timeout' | 'data-flow-timeout' | 'index-timeout' | 'not-connected' | 'not-synced' | 'download-error';
 export type SyncGateResult = {
     ok: boolean;
     reasons: SyncGateFailureReason[];
@@ -9,6 +9,7 @@ export type SyncGateInput = {
     offline: boolean;
     firstSyncStale: boolean;
     idle: boolean;
+    indexComplete?: boolean;
     recentSync?: boolean;
     status: {
         connected: boolean;

package/dist/powersync/syncGate.js

@@ -16,6 +16,9 @@ export function evaluateSyncGate(input) {
     if (!input.idle) {
         reasons.push('data-flow-timeout');
     }
+    if (input.indexComplete === false) {
+        reasons.push('index-timeout');
+    }
     if (!input.status.connected) {
         reasons.push('not-connected');
     }
@@ -37,6 +40,6 @@ export function createSyncRequiredError(gate, details) {
             reasons: gate.reasons,
             ...(details !== undefined ? { status: details } : {}),
         },
-        suggestion: 'Run `dino sync --strict --sync-timeout 600000 --format json`, then retry the command.',
+        suggestion: 'Run `dino sync --strict --sync-timeout 20000 --format json`, then retry the command.',
     });
 }

package/dist/powersync/syncPass.d.ts

@@ -2,6 +2,8 @@ import type { AbstractPowerSyncDatabase } from '@powersync/common';
 import { type NoteTokenIndexResult } from './tokenIndex.js';
 export type SyncPassResult = {
     idle: boolean;
+    downloadIdle: boolean;
+    uploadIdle: boolean;
     tokenIndex: NoteTokenIndexResult;
 };
 export declare function runSingleSyncPass(db: AbstractPowerSyncDatabase, timeoutMs: number): Promise<SyncPassResult>;

package/dist/powersync/syncPass.js

@@ -1,10 +1,21 @@
-import { waitForIdleDataFlow } from './runtime.js';
+import { createTimeoutSignal } from '../utils/abort.js';
+import { getStatusSnapshot, waitForDownloadIdle } from './runtime.js';
 import { syncNoteTokenIndex } from './tokenIndex.js';
 export async function runSingleSyncPass(db, timeoutMs) {
-    const idle = await waitForIdleDataFlow(db, Math.min(timeoutMs, 60_000));
-    const tokenIndex = await syncNoteTokenIndex(db);
+    const deadline = Date.now() + Math.max(1, timeoutMs);
+    const remainingMs = () => Math.max(0, deadline - Date.now());
+    const downloadIdle = await waitForDownloadIdle(db, Math.max(1, Math.min(remainingMs(), 60_000)));
+    const indexTimeoutMs = remainingMs();
+    const timeout = indexTimeoutMs > 0 ? createTimeoutSignal(indexTimeoutMs) : null;
+    const tokenIndex = await syncNoteTokenIndex(db, {
+        signal: timeout?.signal ?? AbortSignal.abort(),
+    }).finally(() => timeout?.cancel());
+    const status = getStatusSnapshot(db);
+    const uploadIdle = !status.dataFlowStatus.uploading;
     return {
-        idle,
+        idle: downloadIdle && uploadIdle,
+        downloadIdle,
+        uploadIdle,
         tokenIndex,
     };
 }

package/dist/powersync/tokenIndex.d.ts

@@ -1,5 +1,6 @@
 import type { AbstractPowerSyncDatabase } from '@powersync/common';
 export type NoteTokenIndexResult = {
+    complete: boolean;
     scanned: number;
     reindexed: number;
     skipped: number;
@@ -23,6 +24,7 @@ export declare function syncNoteTokenIndex(db: AbstractPowerSyncDatabase, option
     batchSize?: number;
     nowIso?: () => string;
     tokenize?: (text: string, limit?: number) => string[];
+    signal?: AbortSignal;
 }): Promise<NoteTokenIndexResult>;
 export declare function inspectNoteTokenIndex(db: AbstractPowerSyncDatabase): Promise<NoteTokenIndexInspection>;
 export declare function rebuildNoteTokenIndex(db: AbstractPowerSyncDatabase, options?: Parameters<typeof syncNoteTokenIndex>[1]): Promise<NoteTokenIndexResult>;

package/dist/powersync/tokenIndex.js

@@ -9,22 +9,27 @@ export async function syncNoteTokenIndex(db, options) {
     const batchSize = Math.max(1, Math.trunc(options?.batchSize ?? DEFAULT_BATCH_SIZE));
     const nowIso = options?.nowIso ?? nowIsoUtc;
     const tokenize = options?.tokenize ?? tokenizeWithJieba;
+    const signal = options?.signal;
+    if (signal?.aborted) {
+        return createIndexResult('', '', false);
+    }
     await ensureFtsTable(db);
+    if (signal?.aborted) {
+        return createIndexResult('', '', false);
+    }
     const state = await ensureIndexState(db, nowIso);
     let cursorUpdatedAt = state.cursor_updated_at ?? '';
     let cursorId = state.cursor_id ?? '';
-    const result = {
-        scanned: 0,
-        reindexed: 0,
-        skipped: 0,
-        removed: 0,
-        ftsRowsUpserted: 0,
-        cursor: {
-            updatedAt: cursorUpdatedAt,
-            id: cursorId,
-        },
-    };
+    const result = createIndexResult(cursorUpdatedAt, cursorId, true);
+    if (signal?.aborted) {
+        result.complete = false;
+        return result;
+    }
     while (true) {
+        if (signal?.aborted) {
+            result.complete = false;
+            return result;
+        }
         const rows = await db.getAll(`
       SELECT
         id,
@@ -50,23 +55,40 @@ export async function syncNoteTokenIndex(db, options) {
             break;
         }
         for (const row of rows) {
+            if (signal?.aborted) {
+                result.complete = false;
+                await updateIndexCursor(db, cursorUpdatedAt, cursorId, nowIso);
+                result.cursor = { updatedAt: cursorUpdatedAt, id: cursorId };
+                return result;
+            }
             const sortKey = await indexNoteRow(db, row, result, nowIso, tokenize);
             cursorUpdatedAt = sortKey;
             cursorId = row.id;
         }
-        await db.execute(`
-      UPDATE note_local_index_state
-      SET cursor_updated_at = ?, cursor_id = ?, updated_at = ?
-      WHERE id = ?
-      `, [cursorUpdatedAt, cursorId, nowIso(), INDEX_STATE_ID]);
+        await updateIndexCursor(db, cursorUpdatedAt, cursorId, nowIso);
+        result.cursor = { updatedAt: cursorUpdatedAt, id: cursorId };
     }
-    await reconcileSkippedRows(db, result, batchSize, nowIso, tokenize);
+    result.complete = await reconcileSkippedRows(db, result, batchSize, nowIso, tokenize, signal);
     result.cursor = {
         updatedAt: cursorUpdatedAt,
         id: cursorId,
     };
     return result;
 }
+function createIndexResult(cursorUpdatedAt, cursorId, complete) {
+    return {
+        complete,
+        scanned: 0,
+        reindexed: 0,
+        skipped: 0,
+        removed: 0,
+        ftsRowsUpserted: 0,
+        cursor: {
+            updatedAt: cursorUpdatedAt,
+            id: cursorId,
+        },
+    };
+}
 export async function inspectNoteTokenIndex(db) {
     const notes = await countRows(db, `
     SELECT COUNT(*) AS count
@@ -154,8 +176,11 @@ async function indexNoteRow(db, row, result, nowIso, tokenize) {
     }
     return sortKey;
 }
-async function reconcileSkippedRows(db, result, batchSize, nowIso, tokenize) {
+async function reconcileSkippedRows(db, result, batchSize, nowIso, tokenize, signal) {
     while (true) {
+        if (signal?.aborted) {
+            return false;
+        }
         const rows = await db.getAll(`
       SELECT
         n.id,
@@ -180,10 +205,16 @@ async function reconcileSkippedRows(db, result, batchSize, nowIso, tokenize) {
             break;
         }
         for (const row of rows) {
+            if (signal?.aborted) {
+                return false;
+            }
             await indexNoteRow(db, row, result, nowIso, tokenize);
         }
     }
     while (true) {
+        if (signal?.aborted) {
+            return false;
+        }
         const rows = await db.getAll(`
       SELECT m.id
       FROM note_local_index_meta m
@@ -195,11 +226,22 @@ async function reconcileSkippedRows(db, result, batchSize, nowIso, tokenize) {
             break;
         }
         for (const row of rows) {
+            if (signal?.aborted) {
+                return false;
+            }
             await db.execute(`DELETE FROM ${NOTE_LOCAL_FTS_TABLE} WHERE note_id = ?`, [row.id]);
             await db.execute('DELETE FROM note_local_index_meta WHERE id = ?', [row.id]);
             result.removed += 1;
         }
     }
+    return true;
+}
+async function updateIndexCursor(db, cursorUpdatedAt, cursorId, nowIso) {
+    await db.execute(`
+    UPDATE note_local_index_state
+    SET cursor_updated_at = ?, cursor_id = ?, updated_at = ?
+    WHERE id = ?
+    `, [cursorUpdatedAt, cursorId, nowIso(), INDEX_STATE_ID]);
 }
 async function ensureFtsTable(db) {
     try {

package/dist/utils/errors.js

@@ -147,7 +147,7 @@ function defaultSuggestionForCode(code) {
             return 'Run `dino auth status --format json`; if auth is missing, set DINOX_TOKEN or pipe a token to `dino auth login --token-stdin` in your own terminal.';
         case 'SYNC_REQUIRED':
         case 'SYNC_STALE':
-            return 'Run `dino sync --strict --sync-timeout 600000 --format json`, then retry the command.';
+            return 'Run `dino sync --strict --sync-timeout 20000 --format json`, then retry the command.';
         case 'UPLOAD_PENDING':
             return 'Run `dino doctor --fix --format json` to wait for pending uploads and inspect sync health.';
         case 'DAEMON_STALE':
@@ -163,7 +163,7 @@ function defaultSuggestionForCode(code) {
                 return 'Run `dino auth status --format json`; if auth is missing, set DINOX_TOKEN or pipe a token to `dino auth login --token-stdin` in your own terminal.';
             }
             if (normalized.startsWith('SYNC_')) {
-                return 'Run `dino sync --strict --sync-timeout 600000 --format json`, then retry the command.';
+                return 'Run `dino sync --strict --sync-timeout 20000 --format json`, then retry the command.';
             }
             if (normalized.startsWith('DAEMON_')) {
                 return 'Run `dino doctor --fix --format json` to restart a stale daemon and inspect local health.';
@@ -196,7 +196,7 @@ function defaultSuggestedActionForCode(code, message) {
     }
     if (normalized === 'SYNC_REQUIRED' || normalized === 'SYNC_STALE' || normalized.startsWith('SYNC_')) {
         return {
-            command: 'dino sync --strict --sync-timeout 600000 --format json',
+            command: 'dino sync --strict --sync-timeout 20000 --format json',
             reason: 'Refresh the local PowerSync cache and prove freshness before retrying the read.',
         };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dinoxx/dinox-cli",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Dinox CLI",
   "main": "dist/dinox.js",
   "scripts": {
@@ -11,6 +11,8 @@
     "publish:npm:dry-run": "sh ./publish-npm.sh --dry-run",
     "skills:check": "tsx scripts/check-skills.ts",
     "skills:sync:standalone": "tsx scripts/sync-standalone-skills-repo.ts",
+    "skills:sync:standalone:check": "tsx scripts/sync-standalone-skills-repo.ts --check",
+    "skills:sync:standalone:dry-run": "tsx scripts/sync-standalone-skills-repo.ts --dry-run",
     "skills:sync": "tsx scripts/sync-skills-reference.ts",
     "start": "node dist/dinox.js",
     "test": "node scripts/run-tests.mjs",