@dinoxx/dinox-cli 2.13.1 → 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,13 +3,14 @@ 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 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;

package/dist/commands/auth/index.js

@@ -10,7 +10,7 @@ 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, getStatusSnapshot, } from '../../powersync/runtime.js';
@@ -22,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;
@@ -80,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',
@@ -100,6 +102,7 @@ async function readAuthTokenFromStdin() {
 }
 const authLoginDependencies = {
     acquireDaemonStartLock,
+    acquireDaemonIntentLock: acquireDaemonExclusiveIntentLock,
     loadConfig,
     resolveConfig,
     fetchCredentials: fetchCredentialsWithAuthorization,
@@ -117,6 +120,15 @@ export async function performAuthLogin(rawToken, syncTimeout, overrides = {}) {
     const releaseStartLock = await dependencies.acquireDaemonStartLock(parseSyncTimeoutMs(syncTimeout) ?? 10_000);
     let previousConfig = null;
     let suspended = null;
+    // 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 {
@@ -138,6 +150,7 @@ 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 });
         await dependencies.updateConfig((current) => {
             if (!persistedAuthStateMatches(current, previousConfig)) {
@@ -149,6 +162,7 @@ export async function performAuthLogin(rawToken, syncTimeout, overrides = {}) {
             }
             return rotatePersistedAuthStateRevision(mergeAuthIdentityIntoConfig(current, rawToken, identity));
         }, { timeoutMs });
+        await releaseIntent();
         outcome = {
             ok: true,
             value: {
@@ -164,6 +178,9 @@ export async function performAuthLogin(rawToken, syncTimeout, overrides = {}) {
     }
     catch (error) {
         outcome = { ok: false, error };
+        await releaseIntent().catch((releaseError) => {
+            dependencies.printWarning(`warning: failed to release daemon intent lock: ${authLoginErrorMessage(releaseError)}`);
+        });
         if (previousConfig && suspended) {
             try {
                 const current = await dependencies.loadConfig();

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,

package/dist/daemon/client.js

@@ -1,6 +1,7 @@
 import { request as httpRequest } from 'node:http';
 import { existsSync } from 'node:fs';
 import { getDaemonSocketPath, isLegacyDaemonProcess, isProcessRunning, readPid, removePid, } from './pid.js';
+import { getPackageVersion } from '../utils/version.js';
 import { remainingDeadlineMs } from '../utils/deadline.js';
 import { DinoxError, wireErrorCode } from '../utils/errors.js';
 const DEFAULT_DAEMON_REQUEST_TIMEOUT_MS = 10_000;
@@ -34,6 +35,7 @@ export async function sendDaemonRequest(method, params, requestOptions = {}) {
     };
     return new Promise((resolve, reject) => {
         let settled = false;
+        let connected = false;
         let deadlineTimer;
         const finalize = (error, value) => {
             if (settled)
@@ -43,6 +45,8 @@ export async function sendDaemonRequest(method, params, requestOptions = {}) {
                 clearTimeout(deadlineTimer);
             }
             if (error) {
+                if (error instanceof Error)
+                    Object.assign(error, { requestWritten: connected });
                 reject(error);
                 return;
             }
@@ -66,7 +70,7 @@ export async function sendDaemonRequest(method, params, requestOptions = {}) {
             let totalBytes = 0;
             res.on('data', (chunk) => {
                 totalBytes += chunk.length;
-                if (totalBytes > MAX_DAEMON_RESPONSE_BYTES) {
+                if (method !== 'command.execute' && totalBytes > MAX_DAEMON_RESPONSE_BYTES) {
                     req.destroy(new Error('Daemon response too large'));
                     return;
                 }
@@ -92,10 +96,19 @@ export async function sendDaemonRequest(method, params, requestOptions = {}) {
                 }
             });
         });
+        req.on('socket', socket => {
+            if (!socket.connecting)
+                connected = true;
+            socket.once('connect', () => { connected = true; });
+        });
         req.on('timeout', () => {
             req.destroy(new Error('Daemon request timed out'));
         });
         req.on('error', (error) => finalize(error));
+        req.on('response', res => {
+            res.on('aborted', () => finalize(new Error('Daemon response interrupted')));
+            res.on('error', error => finalize(error));
+        });
         deadlineTimer = setTimeout(() => {
             req.destroy(new Error('Daemon request timed out'));
         }, timeoutMs);
@@ -282,6 +295,16 @@ export async function waitForFreshDaemon(expectedVersion, expectedUserId, expect
         }
     }
 }
+/** Daemon log context for a stop request; never carries credentials. */
+function redactRequesterCommand(argv) {
+    return argv.join(' ')
+        .replace(/(auth\s+login)\b[\s\S]*/i, '$1 [REDACTED]')
+        .replace(/((?:--)?[\w-]*(?:token|authorization|secret|password|api[-_]?key)[\w-]*[=\s]+)(?:Bearer\s+)?[^\s]+/gi, '$1[REDACTED]')
+        .replace(/\bBearer\s+\S+/gi, 'Bearer [REDACTED]')
+        .replace(/\beyJ[A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+){1,2}\b/g, '[REDACTED]')
+        .replace(/\b[A-Za-z0-9_-]{32,}\b/g, '[REDACTED]')
+        .slice(0, 200);
+}
 /** Request shutdown of one exact daemon instance and reject if the socket changed owners. */
 export async function requestDaemonShutdown(expectedInstanceId, timeoutMs = 2_000) {
     if (!expectedInstanceId) {
@@ -290,7 +313,14 @@ export async function requestDaemonShutdown(expectedInstanceId, timeoutMs = 2_00
             recoverable: true,
         });
     }
-    const result = await sendDaemonRequest('shutdown', { expectedInstanceId }, { timeoutMs });
+    const result = await sendDaemonRequest('shutdown', {
+        expectedInstanceId,
+        requester: {
+            pid: process.pid,
+            version: getPackageVersion(),
+            command: redactRequesterCommand(process.argv.slice(2)),
+        },
+    }, { timeoutMs });
     if (!result
         || typeof result !== 'object'
         || result.stopping !== true