@dinoxx/dinox-cli 2.13.0 → 2.14.0

package/dist/cli.js

@@ -21,8 +21,9 @@ import { registerTagsCommand } from './commands/tags/index.js';
 import { registerTemplateCommands } from './commands/templates/index.js';
 import { registerTodoCommands } from './commands/todo/index.js';
 import { getPackageVersion } from './utils/version.js';
+import { validateRequestId } from './requests/store.js';
 import { buildStructuredErrorPayload, DinoxError } from './utils/errors.js';
-import { clearRequestedStructuredOutputFormat, parseStructuredOutputFormatFromArgv, printError, resolveStructuredOutputFormat, setRequestedStructuredOutputFormat, } from './utils/output.js';
+import { writeToStdout, writeToStderr, clearRequestedStructuredOutputFormat, parseStructuredOutputFormatFromArgv, printError, resolveStructuredOutputFormat, setRequestedStructuredOutputFormat, } from './utils/output.js';
 export function createCli() {
     clearRequestedStructuredOutputFormat();
     const program = new Command();
@@ -33,9 +34,10 @@ export function createCli() {
         .version(getPackageVersion())
         .showHelpAfterError()
         .configureOutput({
+        writeOut: writeToStdout,
         writeErr: (text) => {
             if (!structuredCommanderErrorWritten) {
-                process.stderr.write(text);
+                writeToStderr(text);
             }
         },
         outputError: (text, write) => {
@@ -68,6 +70,7 @@ export function createCli() {
         .option('--offline', 'skip connect/sync and only use local cache')
         .option('--require-sync', 'fail if the local PowerSync cache cannot be confirmed fresh before reading')
         .option('--sync-timeout <ms>', 'override sync/connect timeout (milliseconds)')
+        .option('--request-id <id>', 'idempotency key: replays the stored result instead of running the command again (24h)', validateRequestId)
         .option('--verbose', 'enable verbose logging');
     program.hook('preAction', (_thisCommand, actionCommand) => {
         const options = actionCommand.optsWithGlobals?.() ?? {};

package/dist/commands/auth/index.d.ts

@@ -3,24 +3,19 @@ import { fetchUserInfoWithAuthorization } from '../../auth/userInfo.js';
 import { loadConfig, updateConfig } from '../../config/store.js';
 import { resolveConfig } from '../../config/resolve.js';
 import { restoreSuspendedDaemonLocked, suspendDaemonForExclusiveAccessLocked } from '../../daemon/lifecycle.js';
-import { acquireDaemonStartLock } from '../../daemon/pid.js';
+import { acquireDaemonExclusiveIntentLock, acquireDaemonStartLock } from '../../daemon/pid.js';
 import { fetchCredentialsWithAuthorization } from '../../powersync/connector.js';
-import { closePowerSyncAndReleaseOwner, connectPowerSync, getStatusSnapshot } from '../../powersync/runtime.js';
-import { runSingleSyncPass } from '../../powersync/syncPass.js';
 import type { CommandGroupDescriptor } from '../descriptor/types.js';
 import { printHumanReadableWarning } from '../../utils/output.js';
 export declare function releaseOwnerLeases(releases: ReadonlyArray<() => Promise<void>>): Promise<unknown[]>;
 type AuthLoginDependencies = {
     acquireDaemonStartLock: typeof acquireDaemonStartLock;
+    acquireDaemonIntentLock: typeof acquireDaemonExclusiveIntentLock;
     loadConfig: typeof loadConfig;
     resolveConfig: typeof resolveConfig;
     fetchCredentials: typeof fetchCredentialsWithAuthorization;
     fetchUserInfo: typeof fetchUserInfoWithAuthorization;
     suspendDaemon: typeof suspendDaemonForExclusiveAccessLocked;
-    connectPowerSync: typeof connectPowerSync;
-    runSingleSyncPass: typeof runSingleSyncPass;
-    getStatusSnapshot: typeof getStatusSnapshot;
-    closePowerSyncAndReleaseOwner: typeof closePowerSyncAndReleaseOwner;
     updateConfig: typeof updateConfig;
     restoreDaemon: typeof restoreSuspendedDaemonLocked;
     printWarning: typeof printHumanReadableWarning;

package/dist/commands/auth/index.js

@@ -10,11 +10,10 @@ import { getDaemonInfo } from '../../daemon/client.js';
 import { restoreSuspendedDaemonLocked, suspendDaemonForExclusiveAccessLocked, } from '../../daemon/lifecycle.js';
 import { stopDaemonLocked } from '../../daemon/index.js';
 import { autoInstallDaemonService, describeDaemonServiceAutoInstall } from '../../daemon/autoInstall.js';
-import { acquireDaemonStartLock } from '../../daemon/pid.js';
+import { acquireDaemonExclusiveIntentLock, acquireDaemonStartLock } from '../../daemon/pid.js';
 import { fetchCredentialsWithAuthorization } from '../../powersync/connector.js';
 import { withExclusivePowerSync } from '../../powersync/exclusiveRuntime.js';
-import { acquirePowerSyncOwnerLease, closePowerSyncAndReleaseOwner, connectPowerSync, getStatusSnapshot, } from '../../powersync/runtime.js';
-import { runSingleSyncPass } from '../../powersync/syncPass.js';
+import { acquirePowerSyncOwnerLease, getStatusSnapshot, } from '../../powersync/runtime.js';
 import { registerCommandGroup } from '../descriptor/register.js';
 import { FORMAT_OPTIONS, OFFLINE_OPTIONS, SYNC_TIMEOUT_OPTIONS } from '../schema/globalOptions.js';
 import { normalizeAuthToken, readEnvAuthToken } from '../../utils/authToken.js';
@@ -23,6 +22,7 @@ import { getRequestedStructuredOutputFormat, printHumanReadableLine, printHumanR
 import { redactAuthorization } from '../../utils/redact.js';
 import { withAsyncRelease } from '../../utils/asyncRelease.js';
 import { parseSyncTimeoutMs } from '../../utils/syncTimeout.js';
+import { assertStdinAvailable } from '../../utils/requestContext.js';
 const AUTH_LOGIN_GLOBAL_OPTIONS = [...FORMAT_OPTIONS, ...SYNC_TIMEOUT_OPTIONS];
 const AUTH_STATUS_GLOBAL_OPTIONS = [...FORMAT_OPTIONS, ...OFFLINE_OPTIONS, ...SYNC_TIMEOUT_OPTIONS];
 const MAX_STDIN_TOKEN_BYTES = 64 * 1024;
@@ -81,6 +81,7 @@ export async function releaseOwnerLeases(releases) {
     return errors;
 }
 async function readAuthTokenFromStdin() {
+    assertStdinAvailable();
     if (process.stdin.isTTY) {
         throw new DinoxError('--token-stdin requires piped stdin', {
             code: 'USAGE_ERROR',
@@ -101,15 +102,12 @@ async function readAuthTokenFromStdin() {
 }
 const authLoginDependencies = {
     acquireDaemonStartLock,
+    acquireDaemonIntentLock: acquireDaemonExclusiveIntentLock,
     loadConfig,
     resolveConfig,
     fetchCredentials: fetchCredentialsWithAuthorization,
     fetchUserInfo: fetchUserInfoWithAuthorization,
     suspendDaemon: suspendDaemonForExclusiveAccessLocked,
-    connectPowerSync,
-    runSingleSyncPass,
-    getStatusSnapshot,
-    closePowerSyncAndReleaseOwner,
     updateConfig,
     restoreDaemon: restoreSuspendedDaemonLocked,
     printWarning: printHumanReadableWarning,
@@ -122,7 +120,15 @@ export async function performAuthLogin(rawToken, syncTimeout, overrides = {}) {
     const releaseStartLock = await dependencies.acquireDaemonStartLock(parseSyncTimeoutMs(syncTimeout) ?? 10_000);
     let previousConfig = null;
     let suspended = null;
-    let restoreAllowed = true;
+    // Held from stopping the daemon until the new login is saved, so a daemon
+    // the service manager respawns meanwhile starts with the new identity.
+    // Released before any restore, which waits for the daemon to come up.
+    let releaseIntentLock = null;
+    const releaseIntent = async () => {
+        const release = releaseIntentLock;
+        releaseIntentLock = null;
+        await release?.();
+    };
     let lifecycleLockReleaseError;
     let outcome;
     try {
@@ -144,38 +150,8 @@ export async function performAuthLogin(rawToken, syncTimeout, overrides = {}) {
         });
         const verifiedConfig = mergeAuthIdentityIntoConfig(previousConfig, rawToken, identity);
         const verifiedResolved = dependencies.resolveConfig(verifiedConfig);
+        releaseIntentLock = await dependencies.acquireDaemonIntentLock(timeoutMs);
         suspended = await dependencies.suspendDaemon(previousResolved, timeoutMs, { forceStop: true });
-        const { db, dbPath, stale, releaseOwner } = await dependencies.connectPowerSync({
-            config: verifiedResolved,
-            offline: false,
-            timeoutMs,
-        });
-        let syncOutcome;
-        try {
-            await dependencies.runSingleSyncPass(db, timeoutMs);
-            syncOutcome = {
-                ok: true,
-                lastSyncedAt: dependencies.getStatusSnapshot(db).lastSyncedAt,
-            };
-        }
-        catch (error) {
-            syncOutcome = { ok: false, error };
-        }
-        let cleanupError;
-        try {
-            await dependencies.closePowerSyncAndReleaseOwner(db, releaseOwner);
-        }
-        catch (error) {
-            cleanupError = error;
-            restoreAllowed = false;
-            dependencies.printWarning(`warning: failed to close the login verification runtime safely: ${authLoginErrorMessage(error)}`);
-        }
-        if (!syncOutcome.ok) {
-            throw syncOutcome.error;
-        }
-        if (cleanupError) {
-            throw cleanupError;
-        }
         await dependencies.updateConfig((current) => {
             if (!persistedAuthStateMatches(current, previousConfig)) {
                 throw new DinoxError('Authentication changed while login was being verified.', {
@@ -186,22 +162,26 @@ export async function performAuthLogin(rawToken, syncTimeout, overrides = {}) {
             }
             return rotatePersistedAuthStateRevision(mergeAuthIdentityIntoConfig(current, rawToken, identity));
         }, { timeoutMs });
+        await releaseIntent();
         outcome = {
             ok: true,
             value: {
                 ok: true,
                 verified: true,
                 endpoint: verifiedResolved.powersync.endpoint,
-                dbPath,
-                stale,
-                lastSyncedAt: syncOutcome.lastSyncedAt,
+                dbPath: getPowerSyncDbPath(identity.userId),
+                stale: true,
+                lastSyncedAt: null,
                 userId: identity.userId,
             },
         };
     }
     catch (error) {
         outcome = { ok: false, error };
-        if (previousConfig && suspended && restoreAllowed) {
+        await releaseIntent().catch((releaseError) => {
+            dependencies.printWarning(`warning: failed to release daemon intent lock: ${authLoginErrorMessage(releaseError)}`);
+        });
+        if (previousConfig && suspended) {
             try {
                 const current = await dependencies.loadConfig();
                 if (persistedAuthStateMatches(current, previousConfig)) {
@@ -315,12 +295,7 @@ async function runAuthLogin(context) {
     printHumanReadableLine(`- endpoint: ${result.endpoint}`);
     printHumanReadableLine(`- db: ${result.dbPath}`);
     printHumanReadableLine(`- userId: ${result.userId}`);
-    if (result.lastSyncedAt) {
-        printHumanReadableLine(`- lastSyncedAt: ${result.lastSyncedAt}`);
-    }
-    if (result.stale) {
-        printHumanReadableLine('- warning: initial sync timed out; local cache may be stale');
-    }
+    printHumanReadableLine('- initial sync continues in the background; run `dino sync` to wait for it');
     const serviceNote = describeDaemonServiceAutoInstall(daemonService);
     if (serviceNote)
         printHumanReadableWarning(serviceNote);
@@ -567,7 +542,7 @@ export const authCommandGroup = {
     commands: [
         {
             name: 'login',
-            description: 'Log in by scanning a QR code, or save a token and verify PowerSync connectivity',
+            description: 'Log in by scanning a QR code or with a token; the initial sync continues in the background',
             arguments: [{ syntax: '[token]', description: 'Login token (omit to scan a QR code, or when using --token-stdin)' }],
             options: [{ flags: '--token-stdin', description: 'Read the login token from piped stdin instead of argv', type: 'boolean' }],
             schema: {
@@ -577,7 +552,7 @@ export const authCommandGroup = {
                 globalOptions: AUTH_LOGIN_GLOBAL_OPTIONS,
                 output: {
                     type: 'structured',
-                    summary: 'Login verification result',
+                    summary: 'Login verification result (initial sync is not awaited)',
                     fields: ['verified', 'endpoint', 'dbPath', 'stale', 'lastSyncedAt', 'userId', 'daemonService'],
                 },
                 examples: [

package/dist/commands/doctor.d.ts

@@ -5,7 +5,7 @@ import { resolveConfig } from '../config/resolve.js';
 import type { ResolvedDinoxConfig } from '../config/types.js';
 import { shutdownDaemonForExclusiveAccess } from '../daemon/client.js';
 import { restartDaemonLocked } from '../daemon/index.js';
-import { acquireDaemonStartLock } from '../daemon/pid.js';
+import { acquireDaemonExclusiveIntentLock, acquireDaemonStartLock } from '../daemon/pid.js';
 import type { DaemonPidInfo } from '../daemon/pid.js';
 import { type DaemonPingResult } from '../daemon/types.js';
 import { connectPowerSync } from '../powersync/runtime.js';
@@ -89,6 +89,8 @@ type DoctorRuntime = {
     daemonBefore: DoctorDaemonSnapshot;
     daemonWasStopped: boolean;
     releaseDaemonStartLock: () => Promise<void>;
+    /** Held while doctor owns the database; see acquireDaemonExclusiveIntentLock. */
+    releaseIntentLock?: () => Promise<void>;
     daemonStartLockReleased: boolean;
     released: boolean;
 };
@@ -102,6 +104,7 @@ type DoctorPreparationDependencies = {
     resolveConfig: typeof resolveConfig;
     hydrateAuthIdentity: typeof hydrateResolvedAuthIdentity;
     acquireDaemonStartLock: typeof acquireDaemonStartLock;
+    acquireDaemonIntentLock: typeof acquireDaemonExclusiveIntentLock;
     captureDaemonSnapshot: typeof captureDaemonSnapshot;
     shutdownDaemon: typeof shutdownDaemonForExclusiveAccess;
     connectPowerSync: typeof connectPowerSync;

package/dist/commands/doctor.js

@@ -5,7 +5,7 @@ import { loadConfig } from '../config/store.js';
 import { fingerprintDaemonRuntimeConfig, resolveConfig } from '../config/resolve.js';
 import { getDaemonInfo, isDaemonFresh, shutdownDaemonForExclusiveAccess } from '../daemon/client.js';
 import { restartDaemonLocked } from '../daemon/index.js';
-import { acquireDaemonStartLock, getDaemonSocketPath, isProcessRunning, readPid, } from '../daemon/pid.js';
+import { acquireDaemonExclusiveIntentLock, acquireDaemonStartLock, getDaemonSocketPath, isProcessRunning, readPid, } from '../daemon/pid.js';
 import { DEFAULT_DAEMON_PORT } from '../daemon/types.js';
 import { closePowerSyncAndReleaseOwner, connectPowerSync, getStatusSnapshot, waitForUploadQueueEmpty, } from '../powersync/runtime.js';
 import { inspectNoteTokenIndex, rebuildNoteTokenIndex, } from '../powersync/tokenIndex.js';
@@ -20,6 +20,7 @@ const doctorPreparationDependencies = {
     resolveConfig,
     hydrateAuthIdentity: hydrateResolvedAuthIdentity,
     acquireDaemonStartLock,
+    acquireDaemonIntentLock: acquireDaemonExclusiveIntentLock,
     captureDaemonSnapshot,
     shutdownDaemon: shutdownDaemonForExclusiveAccess,
     connectPowerSync,
@@ -39,6 +40,14 @@ function doctorTimeoutMs(globals, config) {
 export async function prepareDoctorRuntime(context, overrides = {}) {
     const dependencies = { ...doctorPreparationDependencies, ...overrides };
     const releaseDaemonStartLock = await dependencies.acquireDaemonStartLock(parseSyncTimeoutMs(context.globals.syncTimeout) ?? DEFAULT_DOCTOR_TIMEOUT_MS);
+    let releaseIntentLock;
+    const releaseIntent = async () => {
+        const release = releaseIntentLock;
+        releaseIntentLock = undefined;
+        await release?.().catch((error) => {
+            printHumanReadableWarning(`warning: failed to release daemon intent lock: ${errorMessage(error)}`);
+        });
+    };
     try {
         const rawConfig = await dependencies.loadConfig();
         const baseConfig = dependencies.resolveConfig(rawConfig);
@@ -56,6 +65,7 @@ export async function prepareDoctorRuntime(context, overrides = {}) {
                 authError = errorMessage(error);
             }
         }
+        releaseIntentLock = await dependencies.acquireDaemonIntentLock(timeoutMs);
         const daemonBefore = await dependencies.captureDaemonSnapshot();
         const daemonDbPath = daemonBefore.info ? getPowerSyncDbPath(daemonBefore.info.userId) : null;
         const targetDbPath = getPowerSyncDbPath(config.auth.userId);
@@ -83,6 +93,7 @@ export async function prepareDoctorRuntime(context, overrides = {}) {
                         daemonBefore,
                         daemonWasStopped,
                         releaseDaemonStartLock,
+                        releaseIntentLock,
                         daemonStartLockReleased: false,
                         released: false,
                     };
@@ -109,16 +120,19 @@ export async function prepareDoctorRuntime(context, overrides = {}) {
                 daemonBefore,
                 daemonWasStopped,
                 releaseDaemonStartLock,
+                releaseIntentLock,
                 daemonStartLockReleased: false,
                 released: false,
             };
         }
         catch (error) {
+            await releaseIntent();
             await restoreStoppedDoctorDaemon(config, daemonBefore, daemonWasStopped, dependencies.restartDaemon);
             throw error;
         }
     }
     catch (error) {
+        await releaseIntent();
         await releaseDaemonStartLock().catch((releaseError) => {
             printHumanReadableWarning(`warning: failed to release daemon lifecycle lock: ${errorMessage(releaseError)}`);
         });
@@ -357,6 +371,11 @@ export async function releaseDoctorRuntime(runtime) {
     }
     await closePowerSyncAndReleaseOwner(runtime.db, runtime.releaseOwner);
     runtime.released = true;
+    const releaseIntentLock = runtime.releaseIntentLock;
+    runtime.releaseIntentLock = undefined;
+    await releaseIntentLock?.().catch((error) => {
+        printHumanReadableWarning(`warning: failed to release daemon intent lock: ${errorMessage(error)}`);
+    });
 }
 export async function releaseDoctorDaemonStartLock(runtime) {
     if (runtime.daemonStartLockReleased) {

package/dist/commands/graph/index.js

@@ -4,6 +4,7 @@ import { registerCommandGroup } from '../descriptor/register.js';
 import { FORMAT_OPTIONS, OFFLINE_OPTIONS, REQUIRE_SYNC_OPTIONS, SYNC_TIMEOUT_OPTIONS } from '../schema/globalOptions.js';
 import { DinoxError } from '../../utils/errors.js';
 import { printSuccess } from '../../utils/output.js';
+import { localCommandExecution, requestContext } from '../../utils/requestContext.js';
 import { commandStale, syncBeforeCommand, withCommandRuntime } from '../runtime.js';
 import { getBacklinks, getGraphStats, getOutlinks, getRelatedNotes } from './repo.js';
 const GRAPH_GLOBAL_OPTIONS = [...FORMAT_OPTIONS, ...OFFLINE_OPTIONS, ...REQUIRE_SYNC_OPTIONS, ...SYNC_TIMEOUT_OPTIONS];
@@ -26,7 +27,7 @@ function parseDepth(value) {
 }
 async function runGraphCommand(context, onlineAction, offlineAction) {
     const globals = context.globals;
-    if (Boolean(globals.offline) || Boolean(globals.requireSync)) {
+    if (requestContext.getStore()?.daemon || localCommandExecution.getStore() || Boolean(globals.offline) || Boolean(globals.requireSync)) {
         await withCommandRuntime(context, async (runtime) => {
             await syncBeforeCommand(runtime);
             printSuccess({

package/dist/commands/notes/contentPatch.js

@@ -11,6 +11,7 @@ import { nowIsoUtc } from '../../utils/time.js';
 import { deriveImageDetailFromContentJson } from '../todo/contentModel.js';
 import { applyJsonPatchToDocument, buildNoteContentBlocks, buildNoteContentOutline, getNoteContentHash, parseStoredNoteDocument, projectNoteContent, } from './contentEngine.js';
 import { parseStoredTags } from './repo.js';
+import { resolveUserPath } from '../../utils/requestContext.js';
 const READ_TOKEN_TTL_MS = 30 * 60 * 1000;
 const MAX_STORED_READ_TOKENS = 500;
 const TOKEN_STORE_FILE = 'note-content-read-tokens.json';
@@ -111,7 +112,7 @@ async function loadTokenStore(nowMs = Date.now()) {
     const filePath = tokenStorePath();
     let tokens = [];
     try {
-        const raw = await fs.readFile(filePath, 'utf8');
+        const raw = await fs.readFile(resolveUserPath(filePath), 'utf8');
         const parsed = JSON.parse(raw);
         if (Array.isArray(parsed.tokens)) {
             tokens = parsed.tokens.filter((token) => typeof token?.token === 'string' &&

package/dist/commands/notes/export.js

@@ -6,6 +6,7 @@ import { getRequestedStructuredOutputFormat, printHumanReadableLine, printHumanR
 import { commandStale, } from '../runtime.js';
 import { getNoteExportItems, } from './repo.js';
 import { parseTargetNoteIds, syncBeforeNoteCommand, withNoteDatabase, } from './runtime.js';
+import { resolveUserPath } from '../../utils/requestContext.js';
 export function parseExportFormat(value) {
     if (value === undefined || value === null || value === '') {
         return 'markdown';
@@ -107,7 +108,7 @@ async function pathExists(filePath) {
 }
 async function resolveOutputTargets(args) {
     const outputLooksLikeDirectory = /[\\/]$/.test(args.outputPath);
-    const outputPath = path.resolve(args.outputPath);
+    const outputPath = resolveUserPath(args.outputPath);
     if (args.notes.length === 1) {
         if (outputLooksLikeDirectory) {
             return [{
@@ -160,7 +161,7 @@ export async function writeExportFiles(args) {
         }
     }
     if (args.notes.length > 1) {
-        await fs.mkdir(path.resolve(args.outputPath), { recursive: true, mode: 0o700 });
+        await fs.mkdir(resolveUserPath(args.outputPath), { recursive: true, mode: 0o700 });
     }
     else {
         await fs.mkdir(path.dirname(targets[0].path), { recursive: true, mode: 0o700 });

package/dist/commands/runtime.d.ts

@@ -43,4 +43,12 @@ export declare function waitForMutationUpload(runtime: CommandRuntime, options?:
     durability?: unknown;
 }): Promise<MutationUploadReceipt>;
 export declare function printStaleCacheWarning(runtime: CommandRuntime, message?: string): void;
+/**
+ * Freshness on the daemon's long-lived stream. The server pushes every change,
+ * so a connected, error-free stream is current without a new checkpoint; an
+ * idle stream may not produce one before the timeout. After a reconnect (wake,
+ * network change) it may have been a dead connection, so then a checkpoint
+ * completed after the reconnect is required.
+ */
+export declare function waitForDaemonCurrent(db: AbstractPowerSyncDatabase, _startedAt: string, timeoutMs: number): Promise<boolean>;
 export {};

package/dist/commands/runtime.js

@@ -8,6 +8,7 @@ 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 { requestContext } from '../utils/requestContext.js';
 import { parseSyncTimeoutMs } from '../utils/syncTimeout.js';
 import { parseWriteDurability } from './writeDurability.js';
 const PRE_SYNC_TIMEOUT_MS = 10_000;
@@ -44,6 +45,22 @@ export function resolveWriteDurabilityForRuntime(runtime, value) {
 export async function withCommandRuntime(source, run) {
     const startedAtIso = new Date().toISOString();
     const globals = resolveGlobals(source);
+    const daemon = requestContext.getStore()?.daemon;
+    if (daemon) {
+        const offline = Boolean(globals.offline);
+        const status = getStatusSnapshot(daemon.db);
+        const stale = offline || !status.connected || !status.hasSynced || Boolean(daemon.syncUnconfirmedSince?.());
+        return run({
+            db: daemon.db,
+            config: daemon.config,
+            rawConfig: {},
+            offline,
+            timeoutMs: parseSyncTimeoutMs(globals.syncTimeout) ?? daemon.config.sync.timeoutMs,
+            stale,
+            requireSync: Boolean(globals.requireSync),
+            sync: { firstSyncStale: stale, preSyncIdle: null, recentSync: null, gate: null, startedAtIso },
+        });
+    }
     const rawConfig = await loadConfig();
     const baseConfig = resolveConfig(rawConfig);
     const timeoutMs = parseSyncTimeoutMs(globals.syncTimeout) ?? baseConfig.sync.timeoutMs;
@@ -99,7 +116,7 @@ export async function syncBeforeCommand(runtime, options = {}) {
     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.max(1, remainingTimeoutMs()))
+        ? await (requestContext.getStore()?.daemon ? waitForDaemonCurrent : 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()));
@@ -178,3 +195,34 @@ export function printStaleCacheWarning(runtime, message = 'warning: sync timed o
         printHumanReadableWarning(message);
     }
 }
+/**
+ * Freshness on the daemon's long-lived stream. The server pushes every change,
+ * so a connected, error-free stream is current without a new checkpoint; an
+ * idle stream may not produce one before the timeout. After a reconnect (wake,
+ * network change) it may have been a dead connection, so then a checkpoint
+ * completed after the reconnect is required.
+ */
+export async function waitForDaemonCurrent(db, _startedAt, timeoutMs) {
+    const unconfirmedSince = requestContext.getStore()?.daemon?.syncUnconfirmedSince?.();
+    if (unconfirmedSince) {
+        return await waitForLastSyncedAfter(db, unconfirmedSince, timeoutMs)
+            && !getStatusSnapshot(db).dataFlowStatus.downloadError;
+    }
+    const current = () => {
+        const status = getStatusSnapshot(db);
+        return status.connected && status.hasSynced && !status.dataFlowStatus.downloadError;
+    };
+    if (current())
+        return true;
+    const timeout = createTimeoutSignal(timeoutMs);
+    try {
+        await db.waitForStatus(() => current(), timeout.signal);
+        return !timeout.signal.aborted && current();
+    }
+    catch {
+        return false;
+    }
+    finally {
+        timeout.cancel();
+    }
+}

package/dist/commands/schema/globalOptions.d.ts

@@ -2,3 +2,4 @@ export declare const FORMAT_OPTIONS: string[];
 export declare const OFFLINE_OPTIONS: string[];
 export declare const REQUIRE_SYNC_OPTIONS: string[];
 export declare const SYNC_TIMEOUT_OPTIONS: string[];
+export declare const REQUEST_ID_OPTIONS: string[];

package/dist/commands/schema/globalOptions.js

@@ -2,3 +2,4 @@ export const FORMAT_OPTIONS = ['--format <yaml|json>', '--json'];
 export const OFFLINE_OPTIONS = ['--offline'];
 export const REQUIRE_SYNC_OPTIONS = ['--require-sync'];
 export const SYNC_TIMEOUT_OPTIONS = ['--sync-timeout <ms>'];
+export const REQUEST_ID_OPTIONS = ['--request-id <id>'];

package/dist/commands/schema/renderSkills.js

@@ -33,6 +33,7 @@ const GLOBAL_OPTIONS = [
     ['`--offline`', 'Skip sync, use local cache only'],
     ['`--require-sync`', 'Fail if the local PowerSync cache cannot be confirmed fresh before reading'],
     ['`--sync-timeout <ms>`', 'Override default 300000 ms (5 min) sync/connect timeout'],
+    ['`--request-id <id>`', 'Idempotency key for data commands: rerunning with the same id within 24h replays the stored result'],
     ['`--verbose`', 'Enable verbose logging'],
 ];
 function buildCommandSignature(schema) {

package/dist/commands/schema/spec.js

@@ -1,5 +1,6 @@
 import { authCommandGroup } from '../auth/index.js';
 import { boxCommandGroup } from '../boxes/index.js';
+import { commandExecutionTarget } from '../../daemon/forward.js';
 import { commandSchemasFromGroupDescriptor } from '../descriptor/register.js';
 import { standaloneCommandSchemaFromDescriptor } from '../descriptor/register.js';
 import { configCommandGroup } from '../config/index.js';
@@ -14,6 +15,7 @@ import { promptCommandGroup } from '../prompt/index.js';
 import { propertyCommandGroup } from '../properties/index.js';
 import { savedViewCommandGroup } from '../savedViews/index.js';
 import { schemaCommandMetadata } from './commandMetadata.js';
+import { REQUEST_ID_OPTIONS } from './globalOptions.js';
 import { skillsCommandGroup } from '../skills/index.js';
 import { syncCommandDescriptor } from '../sync.js';
 import { storageCommandGroup } from '../storage/index.js';
@@ -21,6 +23,12 @@ import { tagCommandGroup } from '../tags/index.js';
 import { templateCommandGroup } from '../templates/index.js';
 import { todoCommandGroup } from '../todo/index.js';
 import { updateCommandDescriptor } from '../update.js';
+/** Every command that runs inside the daemon accepts an idempotency key. */
+function withRequestId(schema) {
+    if (commandExecutionTarget(schema.path.split('.')) !== 'daemon')
+        return schema;
+    return { ...schema, globalOptions: [...schema.globalOptions, ...REQUEST_ID_OPTIONS] };
+}
 export const COMMAND_SCHEMAS = [
     ...commandSchemasFromGroupDescriptor(authCommandGroup),
     ...commandSchemasFromGroupDescriptor(configCommandGroup),
@@ -43,7 +51,7 @@ export const COMMAND_SCHEMAS = [
     ...commandSchemasFromGroupDescriptor(noteCommandGroup),
     ...commandSchemasFromGroupDescriptor(graphCommandGroup),
     ...commandSchemasFromGroupDescriptor(todoCommandGroup),
-];
+].map(withRequestId);
 const COMMAND_SCHEMA_MAP = new Map(COMMAND_SCHEMAS.map((schema) => [schema.path, schema]));
 export function listCommandSchemas() {
     return [...COMMAND_SCHEMAS];

package/dist/commands/storage/repo/operations.js

@@ -1,6 +1,7 @@
 // Storage commands: inspect/test/upload orchestration with cleanup on partial failure.
 import fsp from 'node:fs/promises';
 import { DinoxError } from '../../../utils/errors.js';
+import { resolveUserPath } from '../../../utils/requestContext.js';
 import { buildStorageTestPlan, buildStorageUploadPlan, getActiveCustomStorageConfigId, listStoredCustomStorageConfigs, resolveStorageSelection, } from './configs.js';
 import { createStorageCollisionError, createStorageUploadOutcomeUnknownError, defaultDeleteObject, defaultUploadBytes, defaultUploadObject, generateThumbnailBuffer, isObjectCollisionError, loadSharp, } from './remote.js';
 import { normalizeText, } from './shared.js';
@@ -8,7 +9,8 @@ import { persistUploadedResource } from './resources.js';
 import { buildStorageTarget, generateThumbnailKey } from './targets.js';
 export async function inspectStorageUpload(db, input, deps) {
     const statFile = deps?.statFile ?? fsp.stat;
-    const filePath = input.filePath.trim();
+    const suppliedPath = input.filePath.trim();
+    const filePath = suppliedPath ? resolveUserPath(suppliedPath) : suppliedPath;
     if (!filePath) {
         throw new DinoxError('File path is required.');
     }

package/dist/commands/sync.d.ts

@@ -5,7 +5,7 @@ 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 { getStatusSnapshot, waitForLastSyncedAfter, waitForUploadQueueEmpty } from '../powersync/runtime.js';
 import { runSingleSyncPass } from '../powersync/syncPass.js';
 type SyncCommandDependencies = {
     loadConfig: typeof loadConfig;
@@ -15,6 +15,7 @@ type SyncCommandDependencies = {
     getRequestedStructuredOutputFormat: typeof getRequestedStructuredOutputFormat;
     getStatusSnapshot: typeof getStatusSnapshot;
     waitForLastSyncedAfter: typeof waitForLastSyncedAfter;
+    waitForUploadQueueEmpty: typeof waitForUploadQueueEmpty;
     runSingleSyncPass: typeof runSingleSyncPass;
     printHumanReadableLine: typeof printHumanReadableLine;
     printSuccess: typeof printSuccess;

package/dist/commands/sync.js

@@ -1,12 +1,15 @@
+import { getPowerSyncDbPath } from '../config/paths.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 { requestContext } from '../utils/requestContext.js';
 import { registerStandaloneCommand } from './descriptor/register.js';
+import { waitForDaemonCurrent } from './runtime.js';
 import { FORMAT_OPTIONS, SYNC_TIMEOUT_OPTIONS } from './schema/globalOptions.js';
 import { getRequestedStructuredOutputFormat, printHumanReadableLine, printSuccess, } from '../utils/output.js';
 import { parseSyncTimeoutMs } from '../utils/syncTimeout.js';
-import { getStatusSnapshot, waitForLastSyncedAfter, } from '../powersync/runtime.js';
+import { getStatusSnapshot, waitForLastSyncedAfter, waitForUploadQueueEmpty, } 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;
@@ -18,6 +21,7 @@ const syncCommandDependencies = {
     getRequestedStructuredOutputFormat,
     getStatusSnapshot,
     waitForLastSyncedAfter,
+    waitForUploadQueueEmpty,
     runSingleSyncPass,
     printHumanReadableLine,
     printSuccess,
@@ -27,18 +31,26 @@ 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 daemon = requestContext.getStore()?.daemon;
+    const baseConfig = daemon?.config ?? 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, {
+    const { config } = daemon ? { config: daemon.config } : await dependencies.hydrateResolvedAuthIdentity(baseConfig, {
         timeoutMs: remainingTimeoutMs(),
     });
     const strict = Boolean(context.options.strict);
-    const result = await dependencies.withExclusivePowerSync({
+    const withRuntime = daemon
+        ? async (_args, run) => {
+            const status = dependencies.getStatusSnapshot(daemon.db);
+            return run({ db: daemon.db, dbPath: getPowerSyncDbPath(config.auth.userId),
+                stale: !status.connected || !status.hasSynced, releaseOwner: async () => { } });
+        }
+        : dependencies.withExclusivePowerSync;
+    const result = await withRuntime({
         config,
         offline: false,
         timeoutMs: remainingTimeoutMs(),
@@ -49,9 +61,16 @@ export async function executeSyncCommand(context, overrides = {}) {
         cleanupFailureMode: 'throw',
     }, async ({ db, dbPath, stale }) => {
         const recentSync = strict
-            ? await dependencies.waitForLastSyncedAfter(db, startedAtIso, remainingTimeoutMs(cleanupReserveMs))
+            ? await (daemon ? waitForDaemonCurrent : dependencies.waitForLastSyncedAfter)(db, startedAtIso, remainingTimeoutMs(cleanupReserveMs))
             : true;
         const syncPass = await dependencies.runSingleSyncPass(db, remainingTimeoutMs(cleanupReserveMs));
+        const uploadQueue = daemon
+            ? await dependencies.waitForUploadQueueEmpty(db, remainingTimeoutMs(cleanupReserveMs))
+            : null;
+        if (uploadQueue) {
+            syncPass.uploadIdle = uploadQueue.ok;
+            syncPass.idle = syncPass.downloadIdle && uploadQueue.ok;
+        }
         const status = dependencies.getStatusSnapshot(db);
         const gate = evaluateSyncGate({
             offline: false,