@dinoxx/dinox-cli 1.0.22 → 1.1.1

package/dist/commands/update.js

@@ -1,41 +1,121 @@
 import { spawn } from 'node:child_process';
+import { realpathSync } from 'node:fs';
 import { registerStandaloneCommand } from './descriptor/register.js';
+import { FORMAT_OPTIONS } from './schema/globalOptions.js';
 import { SKILLS_REPO_URL } from '../constants/links.js';
-import { printHumanReadableLine } from '../utils/output.js';
+import { getRequestedStructuredOutputFormat, printHumanReadableLine, printSuccess, } from '../utils/output.js';
+import { DinoxError } from '../utils/errors.js';
 import { getPackageVersion } from '../utils/version.js';
 const PACKAGE_NAME = '@dinoxx/dinox-cli';
+const MAX_CAPTURED_UPDATE_OUTPUT_BYTES = 64 * 1024;
 function logHumanReadable(...parts) {
     printHumanReadableLine(parts.map((part) => String(part)).join(' '));
 }
-function detectPackageManager() {
-    const scriptPath = process.argv[1] ?? '';
-    if (scriptPath.includes('/.bun/'))
+function packageManagerFromHint(value) {
+    const hint = value?.trim().toLowerCase().replaceAll('\\', '/');
+    if (!hint)
+        return null;
+    if (hint.startsWith('bun/') || hint.includes('/.bun/') || /\/bun(?:\.exe)?$/.test(hint))
         return 'bun';
-    if (scriptPath.includes('/pnpm/'))
+    if (hint.startsWith('pnpm/') || hint.includes('/.pnpm/') || /\/pnpm(?:\.c?js|\.cmd|\.exe)?$/.test(hint))
         return 'pnpm';
-    if (scriptPath.includes('/.yarn/') || scriptPath.includes('/yarn/global'))
+    if (hint.startsWith('yarn/') || hint.includes('/.yarn/') || hint.includes('/yarn/global') || /\/yarn(?:\.c?js|\.cmd|\.exe)?$/.test(hint))
         return 'yarn';
+    if (hint.startsWith('npm/') || /\/npm(?:-cli\.js|\.cmd|\.exe)?$/.test(hint))
+        return 'npm';
+    return null;
+}
+export function detectPackageManager(input = {}) {
+    const env = input.env ?? process.env;
+    const scriptPath = input.scriptPath ?? process.argv[1] ?? '';
+    const hints = [env.npm_config_user_agent, env.npm_execpath, scriptPath];
+    try {
+        if (scriptPath)
+            hints.push(realpathSync(scriptPath));
+    }
+    catch {
+        // The entrypoint may disappear while a global package is being replaced.
+    }
+    for (const hint of hints) {
+        const detected = packageManagerFromHint(hint);
+        if (detected)
+            return detected;
+    }
     return 'npm';
 }
 const PM_COMMANDS = {
-    npm: { bin: 'npm', args: ['update', '-g', PACKAGE_NAME] },
-    pnpm: { bin: 'pnpm', args: ['update', '--global', PACKAGE_NAME] },
-    yarn: { bin: 'yarn', args: ['global', 'upgrade', PACKAGE_NAME] },
-    bun: { bin: 'bun', args: ['add', '--global', PACKAGE_NAME] },
+    npm: { bin: 'npm', args: ['install', '--global', `${PACKAGE_NAME}@latest`] },
+    pnpm: { bin: 'pnpm', args: ['add', '--global', `${PACKAGE_NAME}@latest`] },
+    yarn: { bin: 'yarn', args: ['global', 'add', `${PACKAGE_NAME}@latest`] },
+    bun: { bin: 'bun', args: ['add', '--global', `${PACKAGE_NAME}@latest`] },
 };
-function runUpdate(pm) {
+export function resolveUpdateSpawnSpec(pm, platform = process.platform) {
     const { bin, args } = PM_COMMANDS[pm];
+    const usesWindowsCommandShim = platform === 'win32' && bin !== 'bun';
+    if (usesWindowsCommandShim) {
+        return {
+            command: [`${bin}.cmd`, ...args].join(' '),
+            args: [],
+            shell: true,
+        };
+    }
+    return {
+        command: bin,
+        args: [...args],
+        shell: false,
+    };
+}
+function appendBoundedOutput(current, chunk) {
+    if (Buffer.byteLength(current, 'utf8') >= MAX_CAPTURED_UPDATE_OUTPUT_BYTES) {
+        return current;
+    }
+    const remaining = MAX_CAPTURED_UPDATE_OUTPUT_BYTES - Buffer.byteLength(current, 'utf8');
+    return current + chunk.subarray(0, remaining).toString('utf8');
+}
+function runUpdate(pm, options) {
+    const { command, args, shell } = resolveUpdateSpawnSpec(pm);
+    const invocation = [command, ...args].join(' ');
     return new Promise((resolve, reject) => {
-        const child = spawn(bin, args, { stdio: 'inherit', shell: true });
+        let stdout = '';
+        let stderr = '';
+        const child = spawn(command, args, {
+            shell,
+            stdio: options.structuredOutput ? ['ignore', 'pipe', 'pipe'] : 'inherit',
+        });
+        if (options.structuredOutput) {
+            child.stdout?.on('data', (chunk) => {
+                stdout = appendBoundedOutput(stdout, chunk);
+            });
+            child.stderr?.on('data', (chunk) => {
+                stderr = appendBoundedOutput(stderr, chunk);
+            });
+        }
         child.on('close', (code) => {
             if (code === 0) {
                 resolve();
             }
             else {
-                reject(new Error(`${bin} exited with code ${code}`));
+                reject(new DinoxError(`${command} exited with code ${code ?? 'unknown'}`, {
+                    code: 'UPDATE_FAILED',
+                    details: {
+                        packageManager: pm,
+                        exitCode: code,
+                        ...(stdout.trim() ? { stdout: stdout.trim() } : {}),
+                        ...(stderr.trim() ? { stderr: stderr.trim() } : {}),
+                    },
+                    suggestion: `Run ${invocation} manually to inspect the failure.`,
+                    recoverable: true,
+                }));
             }
         });
-        child.on('error', reject);
+        child.on('error', (error) => {
+            reject(new DinoxError(`Failed to start ${command}: ${error.message}`, {
+                code: 'UPDATE_FAILED',
+                cause: error,
+                suggestion: `Verify that ${command} is installed and available on PATH.`,
+                recoverable: true,
+            }));
+        });
     });
 }
 function resolveDeps(overrides) {
@@ -51,28 +131,60 @@ function printSkillsReminder(log) {
     log(`skills repo: ${SKILLS_REPO_URL}`);
     log('ai reminder: review and update local Dinox skills after CLI updates (especially dino-dinox and dino-update-cli).');
 }
+function parsePackageManagerOverride(value) {
+    if (value === undefined || value === null || value === '') {
+        return null;
+    }
+    if (value === 'npm' || value === 'pnpm' || value === 'yarn' || value === 'bun') {
+        return value;
+    }
+    throw new DinoxError('--package-manager must be one of: npm, pnpm, yarn, bun', {
+        code: 'USAGE_ERROR',
+        recoverable: true,
+    });
+}
 export function createUpdateCommandDescriptor(overrides = {}) {
     const deps = resolveDeps(overrides);
     return {
         name: 'update',
         description: `Update ${PACKAGE_NAME} to the latest version`,
+        options: [{
+                flags: '--package-manager <manager>',
+                description: 'Override package manager detection',
+                type: 'string',
+                enum: ['npm', 'pnpm', 'yarn', 'bun'],
+            }],
         schema: {
             path: 'update',
             risk: 'write',
             auth: 'none',
-            globalOptions: [],
+            globalOptions: FORMAT_OPTIONS,
             output: {
                 type: 'structured',
-                summary: 'Human-readable updater progress and bundled skills reminder',
-                fields: ['current version log', 'package manager log', 'skills repo reminder'],
+                summary: 'Updater result and bundled skills reminder',
+                fields: ['previousVersion', 'packageManager', 'package', 'target', 'skillsRepo'],
             },
-            examples: ['dino update'],
+            examples: ['dino update', 'dino update --package-manager pnpm --format json'],
         },
-        action: async () => {
-            const pm = deps.detectPackageManager();
-            deps.log(`current version: ${deps.getVersion()}`);
-            deps.log(`updating ${PACKAGE_NAME} via ${pm}...`);
-            await deps.runUpdate(pm);
+        action: async (context) => {
+            const pm = parsePackageManagerOverride(context.options.packageManager) ?? deps.detectPackageManager();
+            const previousVersion = deps.getVersion();
+            const structuredOutput = getRequestedStructuredOutputFormat() !== null;
+            if (!structuredOutput) {
+                deps.log(`current version: ${previousVersion}`);
+                deps.log(`updating ${PACKAGE_NAME} via ${pm}...`);
+            }
+            await deps.runUpdate(pm, { structuredOutput });
+            if (structuredOutput) {
+                printSuccess({
+                    previousVersion,
+                    packageManager: pm,
+                    package: PACKAGE_NAME,
+                    target: 'latest',
+                    skillsRepo: SKILLS_REPO_URL,
+                });
+                return;
+            }
             deps.log('done');
             printSkillsReminder(deps.log);
         },

package/dist/commands/writeDryRun.d.ts

@@ -14,7 +14,7 @@ export declare function buildTagMutationDryRunPreview(args: {
     command: string;
     action: 'rename_tag' | 'move_tag' | 'merge_tag' | 'cleanup_tags';
     summary: string;
-    risk: 'write' | 'high-risk-write';
+    risk: 'read' | 'write' | 'high-risk-write';
     inputs: Record<string, unknown>;
     changes?: Record<string, unknown> | Array<Record<string, unknown>>;
     targets?: Array<Record<string, unknown>>;
@@ -37,7 +37,7 @@ export declare function buildBoxMutationDryRunPreview(args: {
     command: string;
     action: 'rename_box' | 'move_box' | 'merge_box' | 'cleanup_boxes';
     summary: string;
-    risk: 'write' | 'high-risk-write';
+    risk: 'read' | 'write' | 'high-risk-write';
     inputs: Record<string, unknown>;
     changes?: Record<string, unknown> | Array<Record<string, unknown>>;
     targets?: Array<Record<string, unknown>>;
@@ -68,6 +68,7 @@ export declare function buildStorageUploadDryRunPreview(args: {
     storageKey: string;
     storageUrl: string;
     selectionSource: 'storage_id' | 'active' | 'single_available_config';
+    overwrite: boolean;
 }): DryRunPreview;
 export declare function buildStorageTestDryRunPreview(args: {
     config: ResolvedDinoxConfig;

package/dist/commands/writeDryRun.js

@@ -3,9 +3,6 @@ function buildExecutionWarnings(config, offline) {
     if (offline) {
         warnings.push('Execution would run in offline mode and only use the local cache.');
     }
-    if (!offline && !config.powersync.uploadBaseUrl) {
-        warnings.push('Execution would be local-only because powersync.uploadBaseUrl is unset.');
-    }
     return warnings;
 }
 export function buildTagAddDryRunPreview(args) {
@@ -105,6 +102,9 @@ export function buildStorageUploadDryRunPreview(args) {
     if (args.storage.isPrivate) {
         warnings.push('The target bucket is private; the final storageUrl may require signed read access.');
     }
+    if (args.overwrite) {
+        warnings.push('Existing objects at the explicit key and derived thumbnail key may be replaced.');
+    }
     return {
         dry_run: true,
         command: 'dino storage upload',
@@ -117,6 +117,7 @@ export function buildStorageUploadDryRunPreview(args) {
             category: args.category,
             size_bytes: args.sizeBytes,
             selection_source: args.selectionSource,
+            overwrite: args.overwrite,
         },
         changes: {
             storage_config_id: args.storage.id,

package/dist/commands/writeDurability.d.ts

@@ -0,0 +1,5 @@
+import type { CommandOptionDescriptor } from './descriptor/types.js';
+export declare const WRITE_DURABILITY_VALUES: readonly ["local", "uploaded"];
+export type WriteDurability = typeof WRITE_DURABILITY_VALUES[number];
+export declare const WRITE_DURABILITY_OPTION: CommandOptionDescriptor;
+export declare function parseWriteDurability(value: unknown, optionName?: string): WriteDurability;

package/dist/commands/writeDurability.js

@@ -0,0 +1,22 @@
+import { DinoxError } from '../utils/errors.js';
+export const WRITE_DURABILITY_VALUES = ['local', 'uploaded'];
+export const WRITE_DURABILITY_OPTION = {
+    flags: '--durability <local|uploaded>',
+    description: 'Required write durability before success: local saves to the local DB; uploaded waits for the PowerSync upload queue to drain',
+    type: 'string',
+    defaultValue: 'local',
+    enum: [...WRITE_DURABILITY_VALUES],
+};
+export function parseWriteDurability(value, optionName = '--durability') {
+    if (value === undefined || value === null || value === '') {
+        return 'local';
+    }
+    if (typeof value !== 'string') {
+        throw new DinoxError(`${optionName} must be one of: local, uploaded`, { code: 'USAGE_ERROR' });
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'local' || normalized === 'uploaded') {
+        return normalized;
+    }
+    throw new DinoxError(`${optionName} must be one of: local, uploaded`, { code: 'USAGE_ERROR' });
+}

package/dist/config/paths.js

@@ -2,7 +2,12 @@ import os from 'node:os';
 import path from 'node:path';
 const POWERSYNC_DB_FILENAME = 'dinox-cli.sqlite';
 function normalizeUserPathSegment(userId) {
-    return encodeURIComponent(userId.trim());
+    const normalized = userId.trim();
+    const encoded = encodeURIComponent(normalized);
+    if (encoded === '.' || encoded === '..') {
+        return `user-${Buffer.from(normalized, 'utf8').toString('hex')}`;
+    }
+    return encoded;
 }
 function resolveConfigHome() {
     if (process.env.DINOX_CONFIG_DIR) {

package/dist/config/resolve.d.ts

@@ -1,2 +1,4 @@
 import type { DinoxConfig, ResolvedDinoxConfig } from './types.js';
+export declare function fingerprintAuthToken(authorization: string | undefined): string | undefined;
+export declare function fingerprintDaemonRuntimeConfig(config: ResolvedDinoxConfig): string;
 export declare function resolveConfig(raw: DinoxConfig): ResolvedDinoxConfig;

package/dist/config/resolve.js

@@ -1,5 +1,7 @@
+import crypto from 'node:crypto';
 import { POWERSYNC_DEFAULT_ENDPOINT, POWERSYNC_DEFAULT_TOKEN_ENDPOINT, POWERSYNC_DEFAULT_UPLOAD_BASE_URL, } from './serviceEndpoints.js';
 import { normalizeAuthToken, readEnvAuthToken } from '../utils/authToken.js';
+import { parseSyncTimeoutMs } from '../utils/syncTimeout.js';
 const DEFAULT_UPLOAD_V4_PATH = '/powersync/v4/uploadData';
 const DEFAULT_UPLOAD_V2_PATH = '/powersync/v2/uploadData';
 const DEFAULT_SYNC_TIMEOUT_MS = 300_000;
@@ -10,15 +12,26 @@ function nonEmptyString(value) {
     const trimmed = value.trim();
     return trimmed.length > 0 ? trimmed : undefined;
 }
-function parsePositiveInt(value) {
-    if (typeof value !== 'string' && typeof value !== 'number') {
+export function fingerprintAuthToken(authorization) {
+    if (!authorization) {
         return undefined;
     }
-    const parsed = Number(value);
-    if (!Number.isFinite(parsed) || parsed <= 0) {
-        return undefined;
-    }
-    return Math.trunc(parsed);
+    return `sha256:${crypto.createHash('sha256').update(authorization, 'utf8').digest('hex')}`;
+}
+export function fingerprintDaemonRuntimeConfig(config) {
+    const payload = JSON.stringify({
+        powersync: {
+            endpoint: config.powersync.endpoint,
+            tokenEndpoint: config.powersync.tokenEndpoint,
+            uploadBaseUrl: config.powersync.uploadBaseUrl,
+            uploadV4Path: config.powersync.uploadV4Path,
+            uploadV2Path: config.powersync.uploadV2Path,
+        },
+        sync: {
+            timeoutMs: config.sync.timeoutMs,
+        },
+    });
+    return `sha256:${crypto.createHash('sha256').update(payload, 'utf8').digest('hex')}`;
 }
 export function resolveConfig(raw) {
     const fileAuth = normalizeAuthToken(raw.auth?.authorization);
@@ -29,17 +42,18 @@ export function resolveConfig(raw) {
     const fileTokenEndpoint = nonEmptyString(raw.powersync?.tokenEndpoint);
     const fileUploadV4Path = nonEmptyString(raw.powersync?.uploadV4Path);
     const fileUploadV2Path = nonEmptyString(raw.powersync?.uploadV2Path);
-    const fileTimeoutMs = parsePositiveInt(raw.sync?.timeoutMs);
+    const fileTimeoutMs = parseSyncTimeoutMs(raw.sync?.timeoutMs, { invalid: 'undefined' });
     const envAuth = readEnvAuthToken();
     const envTokenEndpoint = nonEmptyString(process.env.DINOX_POWERSYNC_TOKEN_ENDPOINT) ?? nonEmptyString(process.env.POWERSYNC_TOKEN_ENDPOINT);
     const envUploadV4Path = nonEmptyString(process.env.DINOX_POWERSYNC_UPLOAD_V4_PATH);
     const envUploadV2Path = nonEmptyString(process.env.DINOX_POWERSYNC_UPLOAD_V2_PATH);
-    const envTimeoutMs = parsePositiveInt(process.env.DINOX_SYNC_TIMEOUT_MS);
+    const envTimeoutMs = parseSyncTimeoutMs(process.env.DINOX_SYNC_TIMEOUT_MS, { invalid: 'undefined' });
     const effectiveAuth = envAuth ?? fileAuth;
     const canReusePersistedIdentity = !envAuth || envAuth === fileAuth;
     return {
         auth: {
             authorization: effectiveAuth,
+            tokenFingerprint: fingerprintAuthToken(effectiveAuth),
             userId: canReusePersistedIdentity ? fileUserId : undefined,
             username: canReusePersistedIdentity ? fileUsername : undefined,
             email: canReusePersistedIdentity ? fileEmail : undefined,

package/dist/config/store.d.ts

@@ -1,5 +1,8 @@
 import type { DinoxConfig } from './types.js';
 export declare function loadConfig(): Promise<DinoxConfig>;
 export declare function saveConfig(config: DinoxConfig): Promise<void>;
+export declare function updateConfig(update: (current: DinoxConfig) => DinoxConfig | Promise<DinoxConfig>, options?: {
+    timeoutMs?: number;
+}): Promise<DinoxConfig>;
 export declare function setConfigValue(keyPath: string, value: unknown): Promise<void>;
 export declare function getConfigValue(keyPath?: string): Promise<unknown>;

package/dist/config/store.js

@@ -3,6 +3,9 @@ import path from 'node:path';
 import { getConfigDir, getConfigFilePath } from './paths.js';
 import { generateId } from '../utils/id.js';
 import { DinoxError } from '../utils/errors.js';
+import { acquireExclusiveSqliteLease } from '../utils/sqliteLease.js';
+import { withAsyncRelease } from '../utils/asyncRelease.js';
+const CONFIG_WRITE_LOCK_TIMEOUT_MS = 10_000;
 function isPlainObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -25,6 +28,24 @@ async function ensureConfigDir() {
     await fs.mkdir(dir, { recursive: true, mode: 0o700 });
     return dir;
 }
+function getConfigWriteLockPath() {
+    return `${getConfigFilePath()}.write.sqlite`;
+}
+async function acquireConfigWriteLock(timeoutMs = CONFIG_WRITE_LOCK_TIMEOUT_MS) {
+    return acquireExclusiveSqliteLease({
+        lockPath: getConfigWriteLockPath(),
+        timeoutMs,
+        maxWaitMs: CONFIG_WRITE_LOCK_TIMEOUT_MS,
+        createBusyError: () => new DinoxError('Another Dinox process is updating the configuration.', {
+            code: 'CONFIG_WRITE_BUSY',
+            suggestion: 'Wait for the other Dinox command to finish, then retry.',
+            recoverable: true,
+        }),
+    });
+}
+async function withConfigWriteLock(run, timeoutMs = CONFIG_WRITE_LOCK_TIMEOUT_MS) {
+    return withAsyncRelease(() => acquireConfigWriteLock(timeoutMs), run);
+}
 export async function loadConfig() {
     const filePath = getConfigFilePath();
     try {
@@ -39,27 +60,52 @@ export async function loadConfig() {
         if (error?.code === 'ENOENT') {
             return {};
         }
+        if (error instanceof SyntaxError) {
+            throw new DinoxError(`Invalid config JSON at ${filePath}: ${error.message}`, {
+                code: 'CONFIG_INVALID_JSON',
+                cause: error,
+            });
+        }
         throw error;
     }
 }
-export async function saveConfig(config) {
+async function writeConfigFile(config) {
     const dir = await ensureConfigDir();
     const filePath = getConfigFilePath();
     const tmpPath = path.join(dir, `config.${generateId()}.tmp`);
     const payload = `${JSON.stringify(config, null, 2)}\n`;
-    // Write config atomically to avoid partial reads.
-    const handle = await fs.open(tmpPath, 'wx', 0o600);
     try {
-        await handle.writeFile(payload, 'utf8');
-    }
-    finally {
-        await handle.close();
+        // Write config atomically to avoid partial reads.
+        const handle = await fs.open(tmpPath, 'wx', 0o600);
+        try {
+            await handle.writeFile(payload, 'utf8');
+        }
+        finally {
+            await handle.close();
+        }
+        if (process.platform !== 'win32') {
+            // Best-effort: keep the config private.
+            await fs.chmod(tmpPath, 0o600).catch(() => undefined);
+        }
+        await fs.rename(tmpPath, filePath);
     }
-    if (process.platform !== 'win32') {
-        // Best-effort: keep the config private.
-        await fs.chmod(tmpPath, 0o600).catch(() => undefined);
+    catch (error) {
+        await fs.rm(tmpPath, { force: true }).catch(() => undefined);
+        throw error;
     }
-    await fs.rename(tmpPath, filePath);
+}
+export async function saveConfig(config) {
+    await withConfigWriteLock(async () => {
+        await writeConfigFile(config);
+    });
+}
+export async function updateConfig(update, options = {}) {
+    return withConfigWriteLock(async () => {
+        const current = await loadConfig();
+        const next = await update(current);
+        await writeConfigFile(next);
+        return next;
+    }, options.timeoutMs);
 }
 function setDeepValue(target, keyPath, value) {
     const segments = splitKeyPath(keyPath);
@@ -89,9 +135,10 @@ function getDeepValue(target, keyPath) {
     return cursor;
 }
 export async function setConfigValue(keyPath, value) {
-    const config = await loadConfig();
-    setDeepValue(config, keyPath, value);
-    await saveConfig(config);
+    await updateConfig((config) => {
+        setDeepValue(config, keyPath, value);
+        return config;
+    });
 }
 export async function getConfigValue(keyPath) {
     const config = await loadConfig();

package/dist/config/types.d.ts

@@ -11,6 +11,8 @@ export type DinoxConfig = {
         username?: string | null;
         email?: string | null;
         userInfoSyncedAt?: string;
+        /** Internal CAS token changed by every persisted login/logout transition. */
+        stateRevision?: string;
     };
     powersync?: {
         /** PowerSync sync service endpoint (downloads/subscriptions). */
@@ -32,6 +34,8 @@ export type DinoxConfig = {
 export type ResolvedDinoxConfig = {
     auth: {
         authorization?: string;
+        /** Runtime-only SHA-256 fingerprint used to bind long-lived processes to the active token. */
+        tokenFingerprint?: string;
         userId?: string;
         username?: string | null;
         email?: string | null;

package/dist/daemon/client.d.ts

@@ -1,2 +1,27 @@
-export declare function sendDaemonRequest(method: string, params?: unknown): Promise<unknown>;
+import type { DaemonPingResult, DaemonShutdownResult } from './types.js';
+export declare function sendDaemonRequest(method: string, params?: unknown, requestOptions?: {
+    timeoutMs?: number;
+}): Promise<unknown>;
 export declare function isDaemonRunning(): Promise<boolean>;
+/**
+ * Ping the daemon and return its handshake payload (version + connected identity),
+ * or null when no daemon is reachable. Callers use this to detect a stale daemon
+ * (wrong version or wrong account) rather than only "running / not running".
+ */
+export declare function getDaemonInfo(): Promise<DaemonPingResult | null>;
+/**
+ * Whether a reachable daemon matches the current CLI version and signed-in account.
+ * A mismatch means the daemon was started by an older build or a different user and
+ * must be restarted before its cached data can be trusted.
+ */
+export declare function isDaemonFresh(info: DaemonPingResult, expectedVersion: string, expectedUserId: string | null, expectedTokenFingerprint: string | null, expectedRuntimeConfigFingerprint: string): boolean;
+export declare function isLegacyDaemonInfo(info: DaemonPingResult): boolean;
+export declare function shutdownLegacyDaemon(initialInfo: DaemonPingResult, timeoutMs?: number): Promise<boolean>;
+/** Poll until the daemon answers a ping or the timeout elapses. */
+export declare function waitForDaemonReady(timeoutMs?: number, intervalMs?: number): Promise<boolean>;
+/** Poll until the daemon answers with the expected authenticated identity. */
+export declare function waitForFreshDaemon(expectedVersion: string, expectedUserId: string | null, expectedTokenFingerprint: string | null, expectedRuntimeConfigFingerprint: string, timeoutMs?: number, intervalMs?: number): Promise<boolean>;
+/** Request shutdown of one exact daemon instance and reject if the socket changed owners. */
+export declare function requestDaemonShutdown(expectedInstanceId: string, timeoutMs?: number): Promise<DaemonShutdownResult>;
+/** Stop a reachable daemon before another process acquires the exclusive PowerSync owner lease. */
+export declare function shutdownDaemonForExclusiveAccess(timeoutMs?: number, expectedInstanceId?: string): Promise<boolean>;