@dinoxx/dinox-cli 1.0.22 → 1.1.1

package/dist/commands/auth/index.js

@@ -1,27 +1,239 @@
 import fs from 'node:fs/promises';
-import { buildPendingAuthConfig, fetchUserInfoWithAuthorization, hydrateResolvedAuthIdentity, mergeAuthIdentityIntoConfig, } from '../../auth/userInfo.js';
+import { buildPendingAuthConfig, fetchUserInfoWithAuthorization, hydrateResolvedAuthIdentity, mergeAuthIdentityIntoConfig, persistedAuthStateMatches, rotatePersistedAuthStateRevision, } from '../../auth/userInfo.js';
 import { getLegacyPowerSyncDbPath, getPowerSyncDbPath } from '../../config/paths.js';
-import { loadConfig, saveConfig } from '../../config/store.js';
+import { loadConfig, updateConfig } from '../../config/store.js';
 import { resolveConfig } from '../../config/resolve.js';
+import { getDaemonInfo } from '../../daemon/client.js';
+import { restoreSuspendedDaemonLocked, suspendDaemonForExclusiveAccessLocked, } from '../../daemon/lifecycle.js';
+import { stopDaemonLocked } from '../../daemon/index.js';
+import { acquireDaemonStartLock } from '../../daemon/pid.js';
 import { fetchCredentialsWithAuthorization } from '../../powersync/connector.js';
-import { connectPowerSync, getStatusSnapshot } from '../../powersync/runtime.js';
+import { withExclusivePowerSync } from '../../powersync/exclusiveRuntime.js';
+import { acquirePowerSyncOwnerLease, closePowerSyncAndReleaseOwner, connectPowerSync, getStatusSnapshot, } from '../../powersync/runtime.js';
 import { runSingleSyncPass } from '../../powersync/syncPass.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';
 import { DinoxError } from '../../utils/errors.js';
-import { getRequestedStructuredOutputFormat, printHumanReadableLine, printSuccess, } from '../../utils/output.js';
+import { getRequestedStructuredOutputFormat, printHumanReadableLine, printHumanReadableWarning, printSuccess, } from '../../utils/output.js';
 import { redactAuthorization } from '../../utils/redact.js';
+import { withAsyncRelease } from '../../utils/asyncRelease.js';
 import { parseSyncTimeoutMs } from '../../utils/syncTimeout.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;
+async function withDaemonStartLock(run) {
+    return withAsyncRelease(() => acquireDaemonStartLock(), run);
+}
 async function removeSqliteArtifacts(dbPath) {
-    for (const suffix of ['', '-wal', '-shm']) {
-        await fs.rm(`${dbPath}${suffix}`, { force: true }).catch(() => undefined);
+    for (const suffix of ['', '-wal', '-shm', '-journal']) {
+        await fs.rm(`${dbPath}${suffix}`, { force: true });
+    }
+}
+function createPartialLogoutError(input) {
+    const original = input.failure.error instanceof DinoxError ? input.failure.error : null;
+    return new DinoxError('Saved credentials were cleared, but logout cleanup could not be completed safely.', {
+        code: original?.code ?? 'CACHE_CLEANUP_FAILED',
+        cause: input.failure.error,
+        details: {
+            persistedCredentialsCleared: true,
+            environmentTokenActive: input.environmentTokenActive,
+            cleanupPhase: input.failure.phase,
+            cachePaths: [...input.paths],
+        },
+        suggestion: original?.suggestion
+            ?? 'Stop other Dinox processes, then retry `dino auth logout --clear-local-db`.',
+        recoverable: true,
+    });
+}
+function createOwnerLeaseReleaseError(input) {
+    const cause = input.errors.length === 1
+        ? input.errors[0]
+        : new AggregateError(input.errors, 'Multiple PowerSync owner leases failed to release.');
+    return new DinoxError('Saved credentials were cleared, but local database ownership could not be released cleanly.', {
+        code: 'CACHE_CLEANUP_FAILED',
+        cause,
+        details: {
+            persistedCredentialsCleared: true,
+            environmentTokenActive: input.environmentTokenActive,
+            cleanupPhase: 'owner-release',
+            cachePaths: [...input.paths],
+            releaseErrorCount: input.errors.length,
+        },
+        suggestion: 'Exit other Dinox processes, then retry the command before opening the affected local database again.',
+        recoverable: true,
+    });
+}
+export async function releaseOwnerLeases(releases) {
+    const errors = [];
+    for (const release of [...releases].reverse()) {
+        try {
+            await release();
+        }
+        catch (error) {
+            errors.push(error);
+        }
     }
+    return errors;
+}
+async function readAuthTokenFromStdin() {
+    if (process.stdin.isTTY) {
+        throw new DinoxError('--token-stdin requires piped stdin', {
+            code: 'USAGE_ERROR',
+            suggestion: 'Pipe the token from a password manager or secret store into `dino auth login --token-stdin`.',
+        });
+    }
+    const chunks = [];
+    let totalBytes = 0;
+    for await (const chunk of process.stdin) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        totalBytes += buffer.length;
+        if (totalBytes > MAX_STDIN_TOKEN_BYTES) {
+            throw new DinoxError('Token from stdin is too large');
+        }
+        chunks.push(buffer);
+    }
+    return Buffer.concat(chunks).toString('utf8');
+}
+const authLoginDependencies = {
+    acquireDaemonStartLock,
+    loadConfig,
+    resolveConfig,
+    fetchCredentials: fetchCredentialsWithAuthorization,
+    fetchUserInfo: fetchUserInfoWithAuthorization,
+    suspendDaemon: suspendDaemonForExclusiveAccessLocked,
+    connectPowerSync,
+    runSingleSyncPass,
+    getStatusSnapshot,
+    closePowerSyncAndReleaseOwner,
+    updateConfig,
+    restoreDaemon: restoreSuspendedDaemonLocked,
+    printWarning: printHumanReadableWarning,
+};
+function authLoginErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export async function performAuthLogin(rawToken, syncTimeout, overrides = {}) {
+    const dependencies = { ...authLoginDependencies, ...overrides };
+    const releaseStartLock = await dependencies.acquireDaemonStartLock(parseSyncTimeoutMs(syncTimeout) ?? 10_000);
+    let previousConfig = null;
+    let suspended = null;
+    let restoreAllowed = true;
+    let lifecycleLockReleaseError;
+    let outcome;
+    try {
+        previousConfig = await dependencies.loadConfig();
+        const previousResolved = dependencies.resolveConfig(previousConfig);
+        const pendingConfig = buildPendingAuthConfig(previousConfig, rawToken);
+        const resolved = dependencies.resolveConfig(pendingConfig);
+        const timeoutMs = parseSyncTimeoutMs(syncTimeout) ?? resolved.sync.timeoutMs;
+        await dependencies.fetchCredentials({
+            authorization: rawToken,
+            endpoint: resolved.powersync.endpoint,
+            credentialsUrl: resolved.powersync.tokenEndpoint,
+            timeoutMs,
+        });
+        const identity = await dependencies.fetchUserInfo({
+            authorization: rawToken,
+            config: resolved,
+            timeoutMs,
+        });
+        const verifiedConfig = mergeAuthIdentityIntoConfig(previousConfig, rawToken, identity);
+        const verifiedResolved = dependencies.resolveConfig(verifiedConfig);
+        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.', {
+                    code: 'AUTH_STATE_CHANGED',
+                    suggestion: 'Retry `dino auth login` if you still want to replace the current login.',
+                    recoverable: true,
+                });
+            }
+            return rotatePersistedAuthStateRevision(mergeAuthIdentityIntoConfig(current, rawToken, identity));
+        }, { timeoutMs });
+        outcome = {
+            ok: true,
+            value: {
+                ok: true,
+                verified: true,
+                endpoint: verifiedResolved.powersync.endpoint,
+                dbPath,
+                stale,
+                lastSyncedAt: syncOutcome.lastSyncedAt,
+                userId: identity.userId,
+            },
+        };
+    }
+    catch (error) {
+        outcome = { ok: false, error };
+        if (previousConfig && suspended && restoreAllowed) {
+            try {
+                const current = await dependencies.loadConfig();
+                if (persistedAuthStateMatches(current, previousConfig)) {
+                    await dependencies.restoreDaemon(suspended);
+                }
+            }
+            catch (restoreError) {
+                dependencies.printWarning(`warning: failed to restore daemon after login failure: ${authLoginErrorMessage(restoreError)}`);
+            }
+        }
+    }
+    finally {
+        try {
+            await releaseStartLock();
+        }
+        catch (error) {
+            lifecycleLockReleaseError = error;
+            dependencies.printWarning(`warning: failed to release daemon lifecycle lock: ${authLoginErrorMessage(error)}`);
+        }
+    }
+    if (!outcome.ok) {
+        throw outcome.error;
+    }
+    if (lifecycleLockReleaseError) {
+        throw lifecycleLockReleaseError;
+    }
+    return outcome.value;
 }
 async function runAuthLogin(context) {
-    const token = context.args.token;
+    const options = context.options;
+    if (context.args.token && options.tokenStdin) {
+        throw new DinoxError('Provide the token either as an argument or with --token-stdin, not both', {
+            code: 'USAGE_ERROR',
+        });
+    }
+    const token = options.tokenStdin ? await readAuthTokenFromStdin() : context.args.token;
     const rawToken = normalizeAuthToken(token);
     if (!rawToken) {
         throw new DinoxError('Token is required');
@@ -30,83 +242,172 @@ async function runAuthLogin(context) {
     if (envToken && envToken !== rawToken) {
         throw new DinoxError('DINOX_TOKEN is set and differs from the login token. Unset DINOX_TOKEN before running `dino auth login`, or use the same token.');
     }
-    const previousConfig = await loadConfig();
-    const pendingConfig = buildPendingAuthConfig(previousConfig, rawToken);
-    const resolved = resolveConfig(pendingConfig);
-    const timeoutMs = parseSyncTimeoutMs(context.globals.syncTimeout) ?? resolved.sync.timeoutMs;
     const structuredOutput = getRequestedStructuredOutputFormat() !== null;
-    await fetchCredentialsWithAuthorization({
-        authorization: rawToken,
-        endpoint: resolved.powersync.endpoint,
-        credentialsUrl: resolved.powersync.tokenEndpoint,
-        timeoutMs,
-    });
-    const identity = await fetchUserInfoWithAuthorization({
-        authorization: rawToken,
-        config: resolved,
-        timeoutMs,
-    });
-    const verifiedConfig = mergeAuthIdentityIntoConfig(previousConfig, rawToken, identity);
-    const verifiedResolved = resolveConfig(verifiedConfig);
-    const { db, dbPath, stale } = await connectPowerSync({
-        config: verifiedResolved,
-        offline: false,
-        timeoutMs,
-    });
+    const result = await performAuthLogin(rawToken, context.globals.syncTimeout);
+    if (structuredOutput) {
+        printSuccess(result);
+        return;
+    }
+    printHumanReadableLine('Login verified.');
+    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');
+    }
+}
+async function runAuthLogoutLocked(options) {
+    const config = await loadConfig();
+    const resolved = resolveConfig(config);
+    const envTokenActive = Boolean(readEnvAuthToken());
+    const daemonInfo = await getDaemonInfo();
+    let initiallyResolvedUserId = resolved.auth.userId;
+    if (!initiallyResolvedUserId
+        && daemonInfo?.authenticated
+        && daemonInfo.tokenFingerprint === (resolved.auth.tokenFingerprint ?? null)) {
+        initiallyResolvedUserId = daemonInfo.userId ?? undefined;
+    }
+    let daemonStopped = false;
+    let cleanupFailure = null;
     try {
-        await runSingleSyncPass(db, timeoutMs);
-        await saveConfig(verifiedConfig);
-        const status = getStatusSnapshot(db);
-        const result = {
-            ok: true,
-            verified: true,
-            endpoint: verifiedResolved.powersync.endpoint,
-            dbPath,
-            stale,
-            lastSyncedAt: status.lastSyncedAt,
-            userId: identity.userId,
-        };
-        if (structuredOutput) {
-            printSuccess(result);
-            return;
+        daemonStopped = (await stopDaemonLocked()).stopped;
+    }
+    catch (error) {
+        cleanupFailure = { error, phase: 'daemon' };
+    }
+    let paths = new Set();
+    const releases = [];
+    let operationFailed = false;
+    let operationError;
+    let result = null;
+    try {
+        await updateConfig(async (current) => {
+            const currentResolved = resolveConfig(current);
+            let effectiveUserId = currentResolved.auth.userId;
+            if (!effectiveUserId
+                && daemonInfo?.authenticated
+                && daemonInfo.tokenFingerprint === (currentResolved.auth.tokenFingerprint ?? null)) {
+                effectiveUserId = daemonInfo.userId ?? undefined;
+            }
+            if (!effectiveUserId
+                && currentResolved.auth.tokenFingerprint === resolved.auth.tokenFingerprint) {
+                effectiveUserId = initiallyResolvedUserId;
+            }
+            if (options.clearLocalDb && currentResolved.auth.authorization && !effectiveUserId && !cleanupFailure) {
+                try {
+                    const hydrated = await hydrateResolvedAuthIdentity(currentResolved, {
+                        timeoutMs: currentResolved.sync.timeoutMs,
+                    });
+                    effectiveUserId = hydrated.config.auth.userId;
+                }
+                catch (error) {
+                    cleanupFailure ??= { error, phase: 'identity' };
+                }
+            }
+            paths = options.clearLocalDb
+                ? new Set([
+                    getPowerSyncDbPath(current.auth?.userId),
+                    getPowerSyncDbPath(effectiveUserId),
+                    getLegacyPowerSyncDbPath(),
+                ].sort())
+                : new Set();
+            if (!cleanupFailure) {
+                for (const dbPath of paths) {
+                    try {
+                        releases.push(await acquirePowerSyncOwnerLease(dbPath, currentResolved.sync.timeoutMs));
+                    }
+                    catch (error) {
+                        cleanupFailure = { error, phase: 'owner-lease' };
+                        break;
+                    }
+                }
+            }
+            return rotatePersistedAuthStateRevision({
+                ...current,
+                auth: {
+                    ...(current.auth ?? {}),
+                    authorization: undefined,
+                    userId: undefined,
+                    username: undefined,
+                    email: undefined,
+                    userInfoSyncedAt: undefined,
+                },
+            });
+        }, { timeoutMs: resolved.sync.timeoutMs });
+        if (cleanupFailure) {
+            throw createPartialLogoutError({
+                failure: cleanupFailure,
+                environmentTokenActive: envTokenActive,
+                paths,
+            });
         }
-        printHumanReadableLine('Login verified.');
-        printHumanReadableLine(`- endpoint: ${result.endpoint}`);
-        printHumanReadableLine(`- db: ${result.dbPath}`);
-        printHumanReadableLine(`- userId: ${result.userId}`);
-        if (result.lastSyncedAt) {
-            printHumanReadableLine(`- lastSyncedAt: ${result.lastSyncedAt}`);
+        for (const dbPath of paths) {
+            try {
+                await removeSqliteArtifacts(dbPath);
+            }
+            catch (error) {
+                throw new DinoxError('Saved credentials were cleared, but the local cache could not be fully removed.', {
+                    code: 'CACHE_CLEANUP_FAILED',
+                    cause: error,
+                    details: {
+                        persistedCredentialsCleared: true,
+                        environmentTokenActive: envTokenActive,
+                        cachePath: dbPath,
+                    },
+                    suggestion: `Stop Dinox processes, inspect filesystem permissions, and remove the reported cache path: ${dbPath}`,
+                    recoverable: true,
+                });
+            }
         }
-        if (stale) {
-            printHumanReadableLine('- warning: initial sync timed out; local cache may be stale');
+        result = {
+            ok: true,
+            loggedOut: !envTokenActive,
+            persistedCredentialsCleared: true,
+            environmentTokenActive: envTokenActive,
+            daemonStopped,
+            clearedLocalDb: Boolean(options.clearLocalDb),
+        };
+    }
+    catch (error) {
+        operationFailed = true;
+        operationError = error;
+    }
+    const releaseErrors = await releaseOwnerLeases(releases);
+    if (operationFailed) {
+        if (releaseErrors.length > 0) {
+            printHumanReadableWarning(`warning: logout also failed to release ${releaseErrors.length} local database owner lease(s); the primary error was preserved.`);
         }
+        throw operationError;
     }
-    finally {
-        await db.close().catch(() => undefined);
+    if (releaseErrors.length > 0) {
+        throw createOwnerLeaseReleaseError({
+            errors: releaseErrors,
+            environmentTokenActive: envTokenActive,
+            paths,
+        });
     }
+    return result;
 }
 async function runAuthLogout(context) {
     const options = context.options;
-    const config = await loadConfig();
-    const currentUserId = config.auth?.userId;
-    if (config.auth) {
-        config.auth.authorization = undefined;
-        config.auth.userId = undefined;
-        config.auth.username = undefined;
-        config.auth.email = undefined;
-        config.auth.userInfoSyncedAt = undefined;
-    }
-    await saveConfig(config);
-    if (options.clearLocalDb) {
-        await removeSqliteArtifacts(getPowerSyncDbPath(currentUserId));
-        await removeSqliteArtifacts(getLegacyPowerSyncDbPath());
-    }
+    const result = await withDaemonStartLock(() => runAuthLogoutLocked(options));
     if (getRequestedStructuredOutputFormat()) {
-        printSuccess({
-            ok: true,
-            loggedOut: true,
-            clearedLocalDb: Boolean(options.clearLocalDb),
-        });
+        printSuccess(result);
+        return;
+    }
+    printHumanReadableLine('Saved login credentials cleared.');
+    printHumanReadableLine(`- daemonStopped: ${result.daemonStopped ? 'yes' : 'no'}`);
+    if (result.clearedLocalDb) {
+        printHumanReadableLine('- local cache: cleared');
+    }
+    if (result.environmentTokenActive) {
+        printHumanReadableLine('warning: DINOX_TOKEN is still set, so commands remain authenticated in this environment.');
+    }
+    else {
+        printHumanReadableLine('Logged out.');
     }
 }
 async function runAuthStatus(context) {
@@ -150,12 +451,12 @@ async function runAuthStatus(context) {
         printHumanReadableLine(`powersync.uploadBaseUrl: ${payload.powersync.uploadBaseUrl ?? '(unset)'}`);
         return;
     }
-    const { db, stale } = await connectPowerSync({
+    await withExclusivePowerSync({
         config: resolved,
         offline: false,
         timeoutMs,
-    });
-    try {
+        expectedTokenFingerprint: resolved.auth.tokenFingerprint ?? null,
+    }, async ({ db, stale }) => {
         const status = getStatusSnapshot(db);
         const payload = { ...base, offline: false, stale, status };
         if (structuredOutput) {
@@ -175,10 +476,7 @@ async function runAuthStatus(context) {
         if (payload.stale) {
             printHumanReadableLine('warning: sync timed out; local cache may be stale');
         }
-    }
-    finally {
-        await db.close().catch(() => undefined);
-    }
+    });
 }
 export const authCommandGroup = {
     name: 'auth',
@@ -187,7 +485,8 @@ export const authCommandGroup = {
         {
             name: 'login',
             description: 'Save login token and verify PowerSync connectivity',
-            arguments: [{ syntax: '<token>', description: 'Login token (without Bearer prefix)' }],
+            arguments: [{ syntax: '[token]', description: 'Login token (omit when using --token-stdin)' }],
+            options: [{ flags: '--token-stdin', description: 'Read the login token from piped stdin instead of argv', type: 'boolean' }],
             schema: {
                 path: 'auth.login',
                 risk: 'write',
@@ -198,7 +497,7 @@ export const authCommandGroup = {
                     summary: 'Login verification result',
                     fields: ['verified', 'endpoint', 'dbPath', 'stale', 'lastSyncedAt', 'userId'],
                 },
-                examples: ['dino auth login "<token>" --format json'],
+                examples: ['dino auth login --token-stdin --format json'],
             },
             action: runAuthLogin,
         },
@@ -214,7 +513,7 @@ export const authCommandGroup = {
                 output: {
                     type: 'structured',
                     summary: 'Logout acknowledgement',
-                    fields: ['loggedOut', 'clearedLocalDb'],
+                    fields: ['loggedOut', 'persistedCredentialsCleared', 'environmentTokenActive', 'daemonStopped', 'clearedLocalDb'],
                 },
                 examples: ['dino auth logout --format json', 'dino auth logout --clear-local-db --format json'],
             },

package/dist/commands/boxes/index.js

@@ -5,7 +5,7 @@ import { buildBoxAddDryRunPreview, buildBoxMutationDryRunPreview } from '../writ
 import { printDryRunPreview } from '../../utils/dryRun.js';
 import { DinoxError } from '../../utils/errors.js';
 import { getRequestedStructuredOutputFormat, printHumanReadableLine, printSuccess, } from '../../utils/output.js';
-import { commandStale, printStaleCacheWarning, printUploadDisabledWarning, syncBeforeCommand, waitForMutationUpload, withCommandRuntime, } from '../runtime.js';
+import { commandStale, printStaleCacheWarning, syncBeforeCommand, waitForMutationUpload, withCommandRuntime, } from '../runtime.js';
 import { addBox, inspectAddBox, listBoxes } from './repo.js';
 import { getBoxStats, getBoxTree, inspectBoxCleanup, mergeBox, moveBox, renameBox, } from './operations.js';
 const BOX_GLOBAL_OPTIONS = [...FORMAT_OPTIONS, ...OFFLINE_OPTIONS, ...REQUIRE_SYNC_OPTIONS, ...SYNC_TIMEOUT_OPTIONS];
@@ -71,7 +71,6 @@ async function runBoxAdd(context) {
             description,
             color,
         });
-        printUploadDisabledWarning(runtime);
         await waitForMutationUpload(runtime);
         const payload = { ok: true, stale: commandStale(runtime), ...result };
         if (structuredOutput) {
@@ -114,7 +113,6 @@ async function runBoxRename(context) {
             }));
             return;
         }
-        printUploadDisabledWarning(runtime);
         await waitForMutationUpload(runtime);
         printSuccess({ ok: true, stale: commandStale(runtime), ...result });
     });
@@ -140,7 +138,6 @@ async function runBoxMove(context) {
             }));
             return;
         }
-        printUploadDisabledWarning(runtime);
         await waitForMutationUpload(runtime);
         printSuccess({ ok: true, stale: commandStale(runtime), ...result });
     });
@@ -166,7 +163,6 @@ async function runBoxMerge(context) {
             }));
             return;
         }
-        printUploadDisabledWarning(runtime);
         await waitForMutationUpload(runtime);
         printSuccess({ ok: true, stale: commandStale(runtime), ...result });
     });
@@ -182,7 +178,7 @@ async function runBoxCleanup(context) {
                 offline: runtime.offline,
                 command: 'dino box cleanup',
                 action: 'cleanup_boxes',
-                risk: 'write',
+                risk: 'read',
                 summary: `Inspect zettel box cleanup candidates (${result.issues.length} issues).`,
                 inputs: {},
                 targets: result.issues,

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

@@ -31,4 +31,7 @@ export declare function trimString(value: string | null | undefined): string;
 export declare function toNullableId(value: string | null | undefined): string | null;
 export declare function getLeafName(path: string): string;
 export declare function assertMaxLength(label: string, value: string, maxLength: number): void;
+export declare function assertMaxUtf8ByteLength(label: string, value: string, maxBytes: number): void;
+export declare function assertTextLimits(label: string, value: string, maxLength: number): void;
+export declare function assertBoxPathLimits(path: string, label?: string): void;
 export declare function parseStoredBoxIds(raw: string | null): string[];

package/dist/commands/boxes/model.js

@@ -1,3 +1,4 @@
+import { DinoxError } from '../../utils/errors.js';
 export const MAX_BOX_NAME_LENGTH = 500;
 export const MAX_BOX_PATH_LENGTH = 2000;
 export const MAX_BOX_DESCRIPTION_LENGTH = 200_000;
@@ -50,6 +51,21 @@ export function assertMaxLength(label, value, maxLength) {
         throw new DinoxError(`${label} must be at most ${maxLength} characters`);
     }
 }
+export function assertMaxUtf8ByteLength(label, value, maxBytes) {
+    if (Buffer.byteLength(value, 'utf8') > maxBytes) {
+        throw new DinoxError(`${label} must be at most ${maxBytes} UTF-8 bytes`);
+    }
+}
+export function assertTextLimits(label, value, maxLength) {
+    assertMaxLength(label, value, maxLength);
+    assertMaxUtf8ByteLength(label, value, maxLength);
+}
+export function assertBoxPathLimits(path, label = 'Box path') {
+    assertTextLimits(label, path, MAX_BOX_PATH_LENGTH);
+    for (const segment of path.split('/')) {
+        assertTextLimits('Box path segment', segment, MAX_BOX_NAME_LENGTH);
+    }
+}
 export function parseStoredBoxIds(raw) {
     if (!raw) {
         return [];
@@ -75,4 +91,3 @@ export function parseStoredBoxIds(raw) {
         return [];
     }
 }
-import { DinoxError } from '../../utils/errors.js';