@dinoxx/dinox-cli 1.0.21 → 1.0.22

package/dist/cli.js

@@ -28,6 +28,7 @@ export function createCli() {
         .option('--json', 'legacy machine-readable YAML output (equivalent to --format yaml)')
         .option('--format <format>', 'structured output format: yaml | json')
         .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('--verbose', 'enable verbose logging');
     program.hook('preAction', (_thisCommand, actionCommand) => {

package/dist/cliTypes.d.ts

@@ -1,6 +1,7 @@
 export type GlobalOptions = {
     json?: boolean;
     offline?: boolean;
+    requireSync?: boolean;
     syncTimeout?: string;
     verbose?: boolean;
 };

package/dist/commands/boxes/index.js

@@ -1,6 +1,6 @@
 import { resolveAuthIdentity } from '../../auth/userInfo.js';
 import { registerCommandGroup } from '../descriptor/register.js';
-import { FORMAT_OPTIONS, OFFLINE_OPTIONS, SYNC_TIMEOUT_OPTIONS } from '../schema/globalOptions.js';
+import { FORMAT_OPTIONS, OFFLINE_OPTIONS, REQUIRE_SYNC_OPTIONS, SYNC_TIMEOUT_OPTIONS } from '../schema/globalOptions.js';
 import { buildBoxAddDryRunPreview, buildBoxMutationDryRunPreview } from '../writeDryRun.js';
 import { printDryRunPreview } from '../../utils/dryRun.js';
 import { DinoxError } from '../../utils/errors.js';
@@ -8,7 +8,7 @@ import { getRequestedStructuredOutputFormat, printHumanReadableLine, printSucces
 import { commandStale, printStaleCacheWarning, printUploadDisabledWarning, 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, ...SYNC_TIMEOUT_OPTIONS];
+const BOX_GLOBAL_OPTIONS = [...FORMAT_OPTIONS, ...OFFLINE_OPTIONS, ...REQUIRE_SYNC_OPTIONS, ...SYNC_TIMEOUT_OPTIONS];
 async function runBoxList(context) {
     await withCommandRuntime(context, async (runtime) => {
         const identity = await resolveAuthIdentity(runtime.config);

package/dist/commands/graph/index.js

@@ -1,12 +1,12 @@
 import { sendDaemonRequest } from '../../daemon/client.js';
 import { ensureDaemonRunning } from '../../daemon/ensure.js';
 import { registerCommandGroup } from '../descriptor/register.js';
-import { FORMAT_OPTIONS, OFFLINE_OPTIONS, SYNC_TIMEOUT_OPTIONS } from '../schema/globalOptions.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 { withCommandRuntime } from '../runtime.js';
+import { syncBeforeCommand, withCommandRuntime } from '../runtime.js';
 import { getBacklinks, getGraphStats, getOutlinks, getRelatedNotes } from './repo.js';
-const GRAPH_GLOBAL_OPTIONS = [...FORMAT_OPTIONS, ...OFFLINE_OPTIONS, ...SYNC_TIMEOUT_OPTIONS];
+const GRAPH_GLOBAL_OPTIONS = [...FORMAT_OPTIONS, ...OFFLINE_OPTIONS, ...REQUIRE_SYNC_OPTIONS, ...SYNC_TIMEOUT_OPTIONS];
 function parseDepth(value) {
     if (value === undefined || value === null || value === '') {
         return 2;
@@ -37,6 +37,13 @@ async function runGraphCommand(context, onlineAction, offlineAction) {
         printSuccess(await withOfflineDb(context.command, offlineAction));
         return;
     }
+    if (Boolean(globals.requireSync)) {
+        await withCommandRuntime(context, async (runtime) => {
+            await syncBeforeCommand(runtime, { syncTokenIndex: true });
+            printSuccess(await offlineAction(runtime.db));
+        });
+        return;
+    }
     await ensureDaemonRunning();
     printSuccess(await onlineAction());
 }

package/dist/commands/meta/index.js

@@ -1,5 +1,5 @@
 import { registerCommandGroup } from '../descriptor/register.js';
-import { OFFLINE_OPTIONS, SYNC_TIMEOUT_OPTIONS } from '../schema/globalOptions.js';
+import { OFFLINE_OPTIONS, REQUIRE_SYNC_OPTIONS, SYNC_TIMEOUT_OPTIONS } from '../schema/globalOptions.js';
 import { printSuccess } from '../../utils/output.js';
 import { commandStale, syncBeforeCommand, withCommandRuntime } from '../runtime.js';
 import { getMetaSchema, getMetaStats } from './repo.js';
@@ -26,7 +26,7 @@ export const metaCommandGroup = {
                 path: 'meta.stats',
                 risk: 'read',
                 auth: 'required',
-                globalOptions: [...OFFLINE_OPTIONS, ...SYNC_TIMEOUT_OPTIONS],
+                globalOptions: [...OFFLINE_OPTIONS, ...REQUIRE_SYNC_OPTIONS, ...SYNC_TIMEOUT_OPTIONS],
                 output: {
                     type: 'structured',
                     summary: 'Metadata stats payload',

package/dist/commands/notes/descriptors.js

@@ -1,10 +1,10 @@
 import { registerCommandGroup } from '../descriptor/register.js';
-import { FORMAT_OPTIONS, OFFLINE_OPTIONS, SYNC_TIMEOUT_OPTIONS } from '../schema/globalOptions.js';
+import { FORMAT_OPTIONS, OFFLINE_OPTIONS, REQUIRE_SYNC_OPTIONS, SYNC_TIMEOUT_OPTIONS } from '../schema/globalOptions.js';
 import { runNoteCreate, runNoteDelete, runNoteDetail, runNoteGet, runNoteMove, runNotePreview, runNoteSearch, runNoteStar, runNoteTag, runNoteUnstar, runNoteUpdate, } from './actions.js';
 import { runNoteBulk as runNoteBulkAction } from './bulk.js';
 import { runNoteContentRead, runNotePatch } from './contentPatchCommand.js';
 import { runNoteExport } from './export.js';
-const NOTE_GLOBAL_OPTIONS = [...FORMAT_OPTIONS, ...OFFLINE_OPTIONS, ...SYNC_TIMEOUT_OPTIONS];
+const NOTE_GLOBAL_OPTIONS = [...FORMAT_OPTIONS, ...OFFLINE_OPTIONS, ...REQUIRE_SYNC_OPTIONS, ...SYNC_TIMEOUT_OPTIONS];
 export const noteCommandGroup = {
     name: 'note',
     description: 'Manage notes',

package/dist/commands/prompt/index.js

@@ -1,13 +1,13 @@
 import { resolveAuthIdentity } from '../../auth/userInfo.js';
 import { registerCommandGroup } from '../descriptor/register.js';
-import { FORMAT_OPTIONS, OFFLINE_OPTIONS, SYNC_TIMEOUT_OPTIONS } from '../schema/globalOptions.js';
+import { FORMAT_OPTIONS, OFFLINE_OPTIONS, REQUIRE_SYNC_OPTIONS, SYNC_TIMEOUT_OPTIONS } from '../schema/globalOptions.js';
 import { buildPromptAddDryRunPreview } from '../writeDryRun.js';
 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 { addPrompt, inspectAddPrompt, listPrompts } from './repo.js';
-const PROMPT_GLOBAL_OPTIONS = [...FORMAT_OPTIONS, ...OFFLINE_OPTIONS, ...SYNC_TIMEOUT_OPTIONS];
+const PROMPT_GLOBAL_OPTIONS = [...FORMAT_OPTIONS, ...OFFLINE_OPTIONS, ...REQUIRE_SYNC_OPTIONS, ...SYNC_TIMEOUT_OPTIONS];
 async function runPromptList(context) {
     await withCommandRuntime(context, async (runtime) => {
         await syncBeforeCommand(runtime, { syncTokenIndex: true });

package/dist/commands/runtime.d.ts

@@ -2,7 +2,13 @@ import type { AbstractPowerSyncDatabase } from '@powersync/common';
 import type { Command } from 'commander';
 import { loadConfig } from '../config/store.js';
 import type { ResolvedDinoxConfig } from '../config/types.js';
+import { type SyncGateResult } from '../powersync/syncGate.js';
 import type { CommandExecutionContext } from './descriptor/types.js';
+export type CommandSyncState = {
+    firstSyncStale: boolean;
+    preSyncIdle: boolean | null;
+    gate: SyncGateResult | null;
+};
 export type CommandRuntime = {
     db: AbstractPowerSyncDatabase;
     config: ResolvedDinoxConfig;
@@ -10,6 +16,8 @@ export type CommandRuntime = {
     offline: boolean;
     timeoutMs: number;
     stale: boolean;
+    requireSync: boolean;
+    sync: CommandSyncState;
 };
 type RuntimeSource = CommandExecutionContext | Command | Record<string, unknown>;
 export declare function commandStale(runtime: Pick<CommandRuntime, 'offline' | 'stale'>): boolean;

package/dist/commands/runtime.js

@@ -1,7 +1,8 @@
 import { hydrateResolvedAuthIdentity } from '../auth/userInfo.js';
 import { loadConfig } from '../config/store.js';
 import { resolveConfig } from '../config/resolve.js';
-import { connectPowerSync, waitForIdleDataFlow } from '../powersync/runtime.js';
+import { connectPowerSync, getStatusSnapshot, waitForIdleDataFlow } from '../powersync/runtime.js';
+import { createSyncRequiredError, evaluateSyncGate } from '../powersync/syncGate.js';
 import { syncNoteTokenIndex } from '../powersync/tokenIndex.js';
 import { printHumanReadableLine } from '../utils/output.js';
 import { parseSyncTimeoutMs } from '../utils/syncTimeout.js';
@@ -31,6 +32,7 @@ export async function withCommandRuntime(source, run) {
     const baseConfig = resolveConfig(rawConfig);
     const timeoutMs = parseSyncTimeoutMs(globals.syncTimeout) ?? baseConfig.sync.timeoutMs;
     const offline = Boolean(globals.offline);
+    const requireSync = Boolean(globals.requireSync);
     const { config } = offline
         ? { config: baseConfig }
         : await hydrateResolvedAuthIdentity(baseConfig, { timeoutMs });
@@ -43,6 +45,12 @@ export async function withCommandRuntime(source, run) {
             offline,
             timeoutMs,
             stale,
+            requireSync,
+            sync: {
+                firstSyncStale: stale,
+                preSyncIdle: null,
+                gate: null,
+            },
         });
     }
     finally {
@@ -51,12 +59,38 @@ export async function withCommandRuntime(source, run) {
 }
 export async function syncBeforeCommand(runtime, options = {}) {
     if (runtime.offline) {
+        if (runtime.requireSync) {
+            const gate = evaluateSyncGate({
+                offline: true,
+                firstSyncStale: runtime.sync.firstSyncStale,
+                idle: false,
+                status: {
+                    hasSynced: false,
+                    dataFlowStatus: {},
+                },
+            });
+            runtime.sync.gate = gate;
+            throw createSyncRequiredError(gate);
+        }
         return;
     }
-    await waitForIdleDataFlow(runtime.db, Math.min(runtime.timeoutMs, options.timeoutMs ?? PRE_SYNC_TIMEOUT_MS));
+    const idle = await waitForIdleDataFlow(runtime.db, Math.min(runtime.timeoutMs, options.timeoutMs ?? PRE_SYNC_TIMEOUT_MS));
+    runtime.sync.preSyncIdle = idle;
     if (options.syncTokenIndex) {
         await syncNoteTokenIndex(runtime.db);
     }
+    const status = getStatusSnapshot(runtime.db);
+    const gate = evaluateSyncGate({
+        offline: runtime.offline,
+        firstSyncStale: runtime.sync.firstSyncStale,
+        idle,
+        status,
+    });
+    runtime.sync.gate = gate;
+    runtime.stale = !gate.ok;
+    if (runtime.requireSync && !gate.ok) {
+        throw createSyncRequiredError(gate, status);
+    }
 }
 export async function waitForMutationUpload(runtime, options = {}) {
     if (runtime.offline) {

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

@@ -1,3 +1,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[];

package/dist/commands/schema/globalOptions.js

@@ -1,3 +1,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>'];

package/dist/commands/schema/renderSkills.js

@@ -21,6 +21,7 @@ const GLOBAL_OPTIONS = [
     ['`--format <yaml|json>`', 'Structured output format. Prefer `json` for agent and script integrations.'],
     ['`--json`', 'Legacy alias for machine-readable YAML output. Keep only for backward compatibility.'],
     ['`--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'],
     ['`--verbose`', 'Enable verbose logging'],
 ];

package/dist/commands/storage/index.js

@@ -1,13 +1,13 @@
 import { resolveAuthIdentity } from '../../auth/userInfo.js';
 import { registerCommandGroup } from '../descriptor/register.js';
-import { FORMAT_OPTIONS, OFFLINE_OPTIONS, SYNC_TIMEOUT_OPTIONS } from '../schema/globalOptions.js';
+import { FORMAT_OPTIONS, OFFLINE_OPTIONS, REQUIRE_SYNC_OPTIONS, SYNC_TIMEOUT_OPTIONS } from '../schema/globalOptions.js';
 import { buildStorageTestDryRunPreview, buildStorageUploadDryRunPreview } from '../writeDryRun.js';
 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 { getStorageStats, inspectStorageTest, inspectStorageUpload, listStorageConfigs, parseStorageUploadCategory, testStorageUpload, uploadFileToStorage, } from './repo.js';
-const STORAGE_GLOBAL_OPTIONS = [...FORMAT_OPTIONS, ...OFFLINE_OPTIONS, ...SYNC_TIMEOUT_OPTIONS];
+const STORAGE_GLOBAL_OPTIONS = [...FORMAT_OPTIONS, ...OFFLINE_OPTIONS, ...REQUIRE_SYNC_OPTIONS, ...SYNC_TIMEOUT_OPTIONS];
 async function runStorageList(context) {
     await withCommandRuntime(context, async (runtime) => {
         const identity = await resolveAuthIdentity(runtime.config);

package/dist/commands/sync.js

@@ -7,9 +7,13 @@ import { getRequestedStructuredOutputFormat, printHumanReadableLine, printSucces
 import { parseSyncTimeoutMs } from '../utils/syncTimeout.js';
 import { connectPowerSync, getStatusSnapshot } from '../powersync/runtime.js';
 import { runSingleSyncPass } from '../powersync/syncPass.js';
+import { createSyncRequiredError, evaluateSyncGate } from '../powersync/syncGate.js';
 export const syncCommandDescriptor = {
     name: 'sync',
     description: 'Connect and synchronize the local PowerSync database',
+    options: [
+        { flags: '--strict', description: 'Fail unless first sync completed, data flow is idle, and no download error exists', type: 'boolean' },
+    ],
     schema: {
         path: 'sync',
         risk: 'write',
@@ -18,9 +22,9 @@ export const syncCommandDescriptor = {
         output: {
             type: 'structured',
             summary: 'Sync result with connection status and token index counters',
-            fields: ['dbPath', 'stale', 'idle', 'uploadEnabled', 'tokenIndex', 'status'],
+            fields: ['dbPath', 'stale', 'idle', 'strict', 'gate', 'uploadEnabled', 'tokenIndex', 'status'],
         },
-        examples: ['dino sync --format json', 'dino sync --sync-timeout 600000 --format json'],
+        examples: ['dino sync --format json', 'dino sync --strict --sync-timeout 600000 --format json'],
     },
     action: async (context) => {
         const baseConfig = resolveConfig(await loadConfig());
@@ -35,15 +39,26 @@ export const syncCommandDescriptor = {
         try {
             const syncPass = await runSingleSyncPass(db, timeoutMs);
             const status = getStatusSnapshot(db);
+            const gate = evaluateSyncGate({
+                offline: false,
+                firstSyncStale: stale,
+                idle: syncPass.idle,
+                status,
+            });
             const payload = {
                 ok: true,
                 dbPath,
-                stale,
+                stale: !gate.ok,
                 idle: syncPass.idle,
+                strict: Boolean(context.options.strict),
+                gate,
                 uploadEnabled: Boolean(config.powersync.uploadBaseUrl),
                 tokenIndex: syncPass.tokenIndex,
                 status,
             };
+            if (context.options.strict && !gate.ok) {
+                throw createSyncRequiredError(gate, status);
+            }
             if (structuredOutput) {
                 printSuccess(payload);
                 return;

package/dist/commands/tags/index.js

@@ -1,6 +1,6 @@
 import { resolveAuthIdentity } from '../../auth/userInfo.js';
 import { registerCommandGroup } from '../descriptor/register.js';
-import { FORMAT_OPTIONS, OFFLINE_OPTIONS, SYNC_TIMEOUT_OPTIONS } from '../schema/globalOptions.js';
+import { FORMAT_OPTIONS, OFFLINE_OPTIONS, REQUIRE_SYNC_OPTIONS, SYNC_TIMEOUT_OPTIONS } from '../schema/globalOptions.js';
 import { buildTagAddDryRunPreview, buildTagMutationDryRunPreview } from '../writeDryRun.js';
 import { printDryRunPreview } from '../../utils/dryRun.js';
 import { DinoxError } from '../../utils/errors.js';
@@ -8,7 +8,7 @@ import { getRequestedStructuredOutputFormat, printHumanReadableLine, printSucces
 import { commandStale, printStaleCacheWarning, printUploadDisabledWarning, syncBeforeCommand, waitForMutationUpload, withCommandRuntime, } from '../runtime.js';
 import { addTag, inspectAddTag, listTags } from './repo.js';
 import { getTagStats, getTagTree, inspectTagCleanup, mergeTag, moveTag, renameTag, suggestTagMerges, } from './operations.js';
-const TAG_GLOBAL_OPTIONS = [...FORMAT_OPTIONS, ...OFFLINE_OPTIONS, ...SYNC_TIMEOUT_OPTIONS];
+const TAG_GLOBAL_OPTIONS = [...FORMAT_OPTIONS, ...OFFLINE_OPTIONS, ...REQUIRE_SYNC_OPTIONS, ...SYNC_TIMEOUT_OPTIONS];
 async function runTagList(context) {
     const structuredOutput = getRequestedStructuredOutputFormat() !== null;
     await withCommandRuntime(context, async (runtime) => {

package/dist/commands/todo/index.js

@@ -1,6 +1,6 @@
 import { resolveAuthIdentity } from '../../auth/userInfo.js';
 import { registerCommandGroup } from '../descriptor/register.js';
-import { FORMAT_OPTIONS, OFFLINE_OPTIONS, SYNC_TIMEOUT_OPTIONS } from '../schema/globalOptions.js';
+import { FORMAT_OPTIONS, OFFLINE_OPTIONS, REQUIRE_SYNC_OPTIONS, SYNC_TIMEOUT_OPTIONS } from '../schema/globalOptions.js';
 import { readStringOrFile } from '../../utils/argValue.js';
 import { printDryRunPreview } from '../../utils/dryRun.js';
 import { DinoxError } from '../../utils/errors.js';
@@ -14,7 +14,7 @@ const DEFAULT_TASK_LIMIT = 50;
 const DEFAULT_NOTE_SCAN_LIMIT = 200;
 const MAX_TASK_LIMIT = 500;
 const MAX_NOTE_SCAN_LIMIT = 5000;
-const TODO_GLOBAL_OPTIONS = [...FORMAT_OPTIONS, ...OFFLINE_OPTIONS, ...SYNC_TIMEOUT_OPTIONS];
+const TODO_GLOBAL_OPTIONS = [...FORMAT_OPTIONS, ...OFFLINE_OPTIONS, ...REQUIRE_SYNC_OPTIONS, ...SYNC_TIMEOUT_OPTIONS];
 function parseTaskStatus(value) {
     const normalized = typeof value === 'string' ? value.trim().toLowerCase() : '';
     if (normalized === 'all' || normalized === 'completed' || normalized === 'uncompleted') {

package/dist/powersync/runtime.js

@@ -82,6 +82,12 @@ export async function connectPowerSync(args) {
         await db.waitForFirstSync(signal);
         return { db, dbPath, stale: signal.aborted };
     }
+    catch (error) {
+        if (signal.aborted) {
+            return { db, dbPath, stale: true };
+        }
+        throw error;
+    }
     finally {
         cancel();
     }

package/dist/powersync/syncGate.d.ts

@@ -0,0 +1,24 @@
+import type { SyncStatusOptions } from '@powersync/common';
+import { DinoxError } from '../utils/errors.js';
+export type SyncGateFailureReason = 'offline' | 'first-sync-timeout' | 'data-flow-timeout' | 'not-synced' | 'download-error';
+export type SyncGateResult = {
+    ok: boolean;
+    reasons: SyncGateFailureReason[];
+};
+export type SyncGateInput = {
+    offline: boolean;
+    firstSyncStale: boolean;
+    idle: boolean;
+    status: {
+        hasSynced: boolean;
+        dataFlowStatus: {
+            downloadError?: {
+                name: string;
+                message: string;
+            };
+        };
+        raw?: SyncStatusOptions;
+    };
+};
+export declare function evaluateSyncGate(input: SyncGateInput): SyncGateResult;
+export declare function createSyncRequiredError(gate: SyncGateResult, details?: unknown): DinoxError;

package/dist/powersync/syncGate.js

@@ -0,0 +1,36 @@
+import { DinoxError } from '../utils/errors.js';
+export function evaluateSyncGate(input) {
+    const reasons = [];
+    if (input.offline) {
+        return {
+            ok: false,
+            reasons: ['offline'],
+        };
+    }
+    if (input.firstSyncStale) {
+        reasons.push('first-sync-timeout');
+    }
+    if (!input.idle) {
+        reasons.push('data-flow-timeout');
+    }
+    if (!input.status.hasSynced) {
+        reasons.push('not-synced');
+    }
+    if (input.status.dataFlowStatus.downloadError) {
+        reasons.push('download-error');
+    }
+    return {
+        ok: reasons.length === 0,
+        reasons,
+    };
+}
+export function createSyncRequiredError(gate, details) {
+    return new DinoxError('Local PowerSync cache is not fully synchronized; refusing to use stale data.', {
+        code: 'SYNC_REQUIRED',
+        details: {
+            reasons: gate.reasons,
+            ...(details !== undefined ? { status: details } : {}),
+        },
+        suggestion: 'Run `dino sync --strict --sync-timeout 600000 --format json`, then retry the command.',
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dinoxx/dinox-cli",
-  "version": "1.0.21",
+  "version": "1.0.22",
   "description": "Dinox CLI",
   "main": "dist/dinox.js",
   "scripts": {