@dinoxx/dinox-cli 1.0.18 → 1.0.20

package/dist/auth/userInfo.d.ts

@@ -5,6 +5,8 @@ export type AuthIdentity = {
     email: string | null;
     syncedAt: string;
 };
+export declare function buildPendingAuthConfig(rawConfig: DinoxConfig, authorization: string): DinoxConfig;
+export declare function mergeAuthIdentityIntoConfig(rawConfig: DinoxConfig, authorization: string, identity: AuthIdentity): DinoxConfig;
 export declare function fetchUserInfoWithAuthorization(input: {
     authorization: string;
     config: ResolvedDinoxConfig;

package/dist/auth/userInfo.js

@@ -3,6 +3,33 @@ import { DinoxError } from '../utils/errors.js';
 import { createTimeoutSignal, mergeAbortSignals } from '../utils/abort.js';
 import { toAuthorizationHeaderValue } from '../utils/authToken.js';
 const AUTH_CODE_OK = '000000';
+export function buildPendingAuthConfig(rawConfig, authorization) {
+    return {
+        ...rawConfig,
+        auth: {
+            ...(rawConfig.auth ?? {}),
+            authorization,
+            userId: undefined,
+            username: undefined,
+            email: undefined,
+            userInfoSyncedAt: undefined,
+        },
+    };
+}
+export function mergeAuthIdentityIntoConfig(rawConfig, authorization, identity) {
+    const pendingConfig = buildPendingAuthConfig(rawConfig, authorization);
+    return {
+        ...pendingConfig,
+        auth: {
+            ...(pendingConfig.auth ?? {}),
+            authorization,
+            userId: identity.userId,
+            username: identity.username,
+            email: identity.email,
+            userInfoSyncedAt: identity.syncedAt,
+        },
+    };
+}
 function normalizeOptionalString(value) {
     if (typeof value !== 'string') {
         return undefined;
@@ -105,17 +132,7 @@ export async function refreshAndPersistAuthIdentity(rawConfig, resolvedConfig) {
         authorization,
         config: resolvedConfig,
     });
-    const nextConfig = {
-        ...rawConfig,
-        auth: {
-            ...(rawConfig.auth ?? {}),
-            authorization: rawConfig.auth?.authorization ?? authorization,
-            userId: identity.userId,
-            username: identity.username,
-            email: identity.email,
-            userInfoSyncedAt: identity.syncedAt,
-        },
-    };
+    const nextConfig = mergeAuthIdentityIntoConfig(rawConfig, authorization, identity);
     await saveConfig(nextConfig);
     return identity;
 }

package/dist/cli.js

@@ -9,12 +9,16 @@ import { registerMCPCommands } from './commands/mcp/index.js';
 import { registerMetaCommands } from './commands/meta/index.js';
 import { registerNoteCommands } from './commands/notes/index.js';
 import { registerPromptCommands } from './commands/prompt/index.js';
+import { registerSchemaCommands } from './commands/schema/index.js';
 import { registerSyncCommand } from './commands/sync.js';
+import { registerStorageCommands } from './commands/storage/index.js';
 import { registerUpdateCommand } from './commands/update.js';
 import { registerTagsCommand } from './commands/tags/index.js';
 import { registerTodoCommands } from './commands/todo/index.js';
 import { getPackageVersion } from './utils/version.js';
+import { clearRequestedStructuredOutputFormat, resolveStructuredOutputFormat, setRequestedStructuredOutputFormat, } from './utils/output.js';
 export function createCli() {
+    clearRequestedStructuredOutputFormat();
     const program = new Command();
     program
         .name('dino')
@@ -22,10 +26,18 @@ export function createCli() {
         .version(getPackageVersion())
         .showHelpAfterError();
     program
-        .option('--json', 'output machine-readable YAML')
+        .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('--sync-timeout <ms>', 'override sync/connect timeout (milliseconds)')
         .option('--verbose', 'enable verbose logging');
+    program.hook('preAction', (_thisCommand, actionCommand) => {
+        const options = actionCommand.optsWithGlobals?.() ?? {};
+        setRequestedStructuredOutputFormat(resolveStructuredOutputFormat(options));
+    });
+    program.hook('postAction', () => {
+        clearRequestedStructuredOutputFormat();
+    });
     registerAuthCommands(program);
     registerBoxesCommand(program);
     registerConfigCommands(program);
@@ -37,6 +49,8 @@ export function createCli() {
     registerSyncCommand(program);
     registerUpdateCommand(program);
     registerPromptCommands(program);
+    registerSchemaCommands(program);
+    registerStorageCommands(program);
     registerTagsCommand(program);
     registerTodoCommands(program);
     registerNoteCommands(program);

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

@@ -1,2 +1,4 @@
 import { Command } from 'commander';
+import type { CommandGroupDescriptor } from '../descriptor/types.js';
+export declare const authCommandGroup: CommandGroupDescriptor;
 export declare function registerAuthCommands(program: Command): void;

package/dist/commands/auth/index.js

@@ -1,183 +1,237 @@
 import fs from 'node:fs/promises';
+import { buildPendingAuthConfig, fetchUserInfoWithAuthorization, mergeAuthIdentityIntoConfig, } from '../../auth/userInfo.js';
+import { getLegacyPowerSyncDbPath, getPowerSyncDbPath } from '../../config/paths.js';
 import { loadConfig, saveConfig } from '../../config/store.js';
 import { resolveConfig } from '../../config/resolve.js';
-import { getPowerSyncDbPath } from '../../config/paths.js';
-import { redactAuthorization } from '../../utils/redact.js';
-import { DinoxError } from '../../utils/errors.js';
-import { printYaml } from '../../utils/output.js';
-import { parseSyncTimeoutMs } from '../../utils/syncTimeout.js';
-import { normalizeAuthToken } from '../../utils/authToken.js';
-import { refreshAndPersistAuthIdentity } from '../../auth/userInfo.js';
-import { connectPowerSync, getStatusSnapshot } from '../../powersync/runtime.js';
 import { fetchCredentialsWithAuthorization } from '../../powersync/connector.js';
+import { 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 } from '../../utils/authToken.js';
+import { DinoxError } from '../../utils/errors.js';
+import { getRequestedStructuredOutputFormat, printHumanReadableLine, printSuccess, } from '../../utils/output.js';
+import { redactAuthorization } from '../../utils/redact.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];
 async function removeSqliteArtifacts(dbPath) {
-    const artifacts = ['', '-wal', '-shm'];
-    for (const suffix of artifacts) {
+    for (const suffix of ['', '-wal', '-shm']) {
         await fs.rm(`${dbPath}${suffix}`, { force: true }).catch(() => undefined);
     }
 }
-export function registerAuthCommands(program) {
-    const auth = program
-        .command('auth')
-        .description('Authentication and PowerSync connectivity commands');
-    auth
-        .command('login')
-        .description('Save login token and verify PowerSync connectivity')
-        .argument('<token>', 'login token (pass the raw token string, without Bearer prefix)')
-        .action(async (token, _options, command) => {
-        const rawToken = normalizeAuthToken(token);
-        if (!rawToken) {
-            throw new DinoxError('Token is required');
-        }
-        const config = await loadConfig();
-        config.auth = { ...(config.auth ?? {}), authorization: rawToken };
-        await saveConfig(config);
-        const resolved = resolveConfig(config);
-        const globals = command.optsWithGlobals?.() ?? {};
-        const timeoutMs = parseSyncTimeoutMs(globals.syncTimeout) ?? resolved.sync.timeoutMs;
-        const jsonOutput = Boolean(globals.json);
-        // 1) Token exchange sanity check.
-        await fetchCredentialsWithAuthorization({
-            authorization: rawToken,
-            endpoint: resolved.powersync.endpoint,
-            credentialsUrl: resolved.powersync.tokenEndpoint,
-            timeoutMs,
-        });
-        // 1.5) Fetch and persist user identity.
-        const identity = await refreshAndPersistAuthIdentity(config, resolved);
-        // 2) Connect + initial sync.
-        const { db, dbPath, stale } = await connectPowerSync({
-            config: resolved,
-            offline: false,
-            timeoutMs,
-        });
-        try {
-            await runSingleSyncPass(db, timeoutMs);
-            const status = getStatusSnapshot(db);
-            const result = {
-                ok: true,
-                verified: true,
-                endpoint: resolved.powersync.endpoint,
-                dbPath,
-                stale,
-                lastSyncedAt: status.lastSyncedAt,
-                userId: identity.userId,
-            };
-            if (jsonOutput) {
-                printYaml(result);
-            }
-            else {
-                console.log('Login verified.');
-                console.log(`- endpoint: ${result.endpoint}`);
-                console.log(`- db: ${result.dbPath}`);
-                console.log(`- userId: ${result.userId}`);
-                if (result.lastSyncedAt) {
-                    console.log(`- lastSyncedAt: ${result.lastSyncedAt}`);
-                }
-                if (stale) {
-                    console.log('- warning: initial sync timed out; local cache may be stale');
-                }
-            }
-        }
-        finally {
-            await db.close().catch(() => undefined);
-        }
+async function runAuthLogin(context) {
+    const token = context.args.token;
+    const rawToken = normalizeAuthToken(token);
+    if (!rawToken) {
+        throw new DinoxError('Token is required');
+    }
+    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,
     });
-    auth
-        .command('logout')
-        .description('Clear saved login token')
-        .option('--clear-local-db', 'delete the local PowerSync SQLite database')
-        .action(async (options) => {
-        const config = await loadConfig();
-        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) {
-            const dbPath = getPowerSyncDbPath();
-            await removeSqliteArtifacts(dbPath);
-        }
+    const identity = await fetchUserInfoWithAuthorization({
+        authorization: rawToken,
+        config: resolved,
+        timeoutMs,
     });
-    auth
-        .command('status')
-        .description('Show current login and sync status')
-        .action(async (_options, command) => {
-        const config = await loadConfig();
-        const resolved = resolveConfig(config);
-        const globals = command.optsWithGlobals?.() ?? {};
-        const offline = Boolean(globals.offline);
-        const jsonOutput = Boolean(globals.json);
-        const timeoutMs = parseSyncTimeoutMs(globals.syncTimeout) ?? resolved.sync.timeoutMs;
-        const dbPath = getPowerSyncDbPath();
-        const base = {
-            loggedIn: Boolean(resolved.auth.authorization),
-            authorization: redactAuthorization(resolved.auth.authorization),
-            userId: resolved.auth.userId ?? null,
-            username: resolved.auth.username ?? null,
-            email: resolved.auth.email ?? null,
-            powersync: {
-                endpoint: resolved.powersync.endpoint ?? null,
-                tokenEndpoint: resolved.powersync.tokenEndpoint ?? null,
-                uploadBaseUrl: resolved.powersync.uploadBaseUrl ?? null,
-                uploadV4Path: resolved.powersync.uploadV4Path,
-                uploadV2Path: resolved.powersync.uploadV2Path,
-            },
+    const verifiedConfig = mergeAuthIdentityIntoConfig(previousConfig, rawToken, identity);
+    const verifiedResolved = resolveConfig(verifiedConfig);
+    const { db, dbPath, stale } = await connectPowerSync({
+        config: verifiedResolved,
+        offline: false,
+        timeoutMs,
+    });
+    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 (offline || !resolved.auth.authorization || !resolved.powersync.endpoint || !resolved.powersync.tokenEndpoint) {
-            const payload = { ...base, offline: true };
-            if (jsonOutput) {
-                printYaml(payload);
-            }
-            else {
-                console.log(`loggedIn: ${payload.loggedIn ? 'yes' : 'no'}`);
-                if (payload.userId) {
-                    console.log(`userId: ${payload.userId}`);
-                }
-                console.log(`db: ${payload.dbPath}`);
-                console.log(`powersync.endpoint: ${payload.powersync.endpoint ?? '(unset)'}`);
-                console.log(`powersync.tokenEndpoint: ${payload.powersync.tokenEndpoint ?? '(unset)'}`);
-                console.log(`powersync.uploadBaseUrl: ${payload.powersync.uploadBaseUrl ?? '(unset)'}`);
-            }
+        if (structuredOutput) {
+            printSuccess(result);
             return;
         }
-        const { db, stale } = await connectPowerSync({
-            config: resolved,
-            offline: false,
-            timeoutMs,
+        printHumanReadableLine('Login verified.');
+        printHumanReadableLine(`- endpoint: ${result.endpoint}`);
+        printHumanReadableLine(`- db: ${result.dbPath}`);
+        printHumanReadableLine(`- userId: ${result.userId}`);
+        if (result.lastSyncedAt) {
+            printHumanReadableLine(`- lastSyncedAt: ${result.lastSyncedAt}`);
+        }
+        if (stale) {
+            printHumanReadableLine('- warning: initial sync timed out; local cache may be stale');
+        }
+    }
+    finally {
+        await db.close().catch(() => undefined);
+    }
+}
+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());
+    }
+    if (getRequestedStructuredOutputFormat()) {
+        printSuccess({
+            ok: true,
+            loggedOut: true,
+            clearedLocalDb: Boolean(options.clearLocalDb),
         });
-        try {
-            const status = getStatusSnapshot(db);
-            const payload = { ...base, offline: false, stale, status };
-            if (jsonOutput) {
-                printYaml(payload);
-            }
-            else {
-                console.log(`loggedIn: ${payload.loggedIn ? 'yes' : 'no'}`);
-                if (payload.userId) {
-                    console.log(`userId: ${payload.userId}`);
-                }
-                console.log(`db: ${payload.dbPath}`);
-                console.log(`connected: ${payload.status.connected ? 'yes' : 'no'}`);
-                if (payload.status.lastSyncedAt) {
-                    console.log(`lastSyncedAt: ${payload.status.lastSyncedAt}`);
-                }
-                console.log(`dataFlow: downloading=${payload.status.dataFlowStatus.downloading} uploading=${payload.status.dataFlowStatus.uploading}`);
-                if (payload.stale) {
-                    console.log('warning: sync timed out; local cache may be stale');
-                }
-            }
+    }
+}
+async function runAuthStatus(context) {
+    const config = await loadConfig();
+    const resolved = resolveConfig(config);
+    const offline = Boolean(context.globals.offline);
+    const structuredOutput = getRequestedStructuredOutputFormat() !== null;
+    const timeoutMs = parseSyncTimeoutMs(context.globals.syncTimeout) ?? resolved.sync.timeoutMs;
+    const dbPath = getPowerSyncDbPath(resolved.auth.userId);
+    const base = {
+        loggedIn: Boolean(resolved.auth.authorization),
+        authorization: redactAuthorization(resolved.auth.authorization),
+        userId: resolved.auth.userId ?? null,
+        username: resolved.auth.username ?? null,
+        email: resolved.auth.email ?? null,
+        powersync: {
+            endpoint: resolved.powersync.endpoint ?? null,
+            tokenEndpoint: resolved.powersync.tokenEndpoint ?? null,
+            uploadBaseUrl: resolved.powersync.uploadBaseUrl ?? null,
+            uploadV4Path: resolved.powersync.uploadV4Path,
+            uploadV2Path: resolved.powersync.uploadV2Path,
+        },
+        dbPath,
+    };
+    if (offline || !resolved.auth.authorization || !resolved.powersync.endpoint || !resolved.powersync.tokenEndpoint) {
+        const payload = { ...base, offline: true };
+        if (structuredOutput) {
+            printSuccess(payload);
+            return;
         }
-        finally {
-            await db.close().catch(() => undefined);
+        printHumanReadableLine(`loggedIn: ${payload.loggedIn ? 'yes' : 'no'}`);
+        if (payload.userId) {
+            printHumanReadableLine(`userId: ${payload.userId}`);
         }
+        printHumanReadableLine(`db: ${payload.dbPath}`);
+        printHumanReadableLine(`powersync.endpoint: ${payload.powersync.endpoint ?? '(unset)'}`);
+        printHumanReadableLine(`powersync.tokenEndpoint: ${payload.powersync.tokenEndpoint ?? '(unset)'}`);
+        printHumanReadableLine(`powersync.uploadBaseUrl: ${payload.powersync.uploadBaseUrl ?? '(unset)'}`);
+        return;
+    }
+    const { db, stale } = await connectPowerSync({
+        config: resolved,
+        offline: false,
+        timeoutMs,
     });
-    auth.action((_options, command) => {
-        command.outputHelp();
-    });
+    try {
+        const status = getStatusSnapshot(db);
+        const payload = { ...base, offline: false, stale, status };
+        if (structuredOutput) {
+            printSuccess(payload);
+            return;
+        }
+        printHumanReadableLine(`loggedIn: ${payload.loggedIn ? 'yes' : 'no'}`);
+        if (payload.userId) {
+            printHumanReadableLine(`userId: ${payload.userId}`);
+        }
+        printHumanReadableLine(`db: ${payload.dbPath}`);
+        printHumanReadableLine(`connected: ${payload.status.connected ? 'yes' : 'no'}`);
+        if (payload.status.lastSyncedAt) {
+            printHumanReadableLine(`lastSyncedAt: ${payload.status.lastSyncedAt}`);
+        }
+        printHumanReadableLine(`dataFlow: downloading=${payload.status.dataFlowStatus.downloading} uploading=${payload.status.dataFlowStatus.uploading}`);
+        if (payload.stale) {
+            printHumanReadableLine('warning: sync timed out; local cache may be stale');
+        }
+    }
+    finally {
+        await db.close().catch(() => undefined);
+    }
+}
+export const authCommandGroup = {
+    name: 'auth',
+    description: 'Authentication and PowerSync connectivity commands',
+    commands: [
+        {
+            name: 'login',
+            description: 'Save login token and verify PowerSync connectivity',
+            arguments: [{ syntax: '<token>', description: 'Login token (without Bearer prefix)' }],
+            schema: {
+                path: 'auth.login',
+                risk: 'write',
+                auth: 'optional',
+                globalOptions: AUTH_LOGIN_GLOBAL_OPTIONS,
+                output: {
+                    type: 'structured',
+                    summary: 'Login verification result',
+                    fields: ['verified', 'endpoint', 'dbPath', 'stale', 'lastSyncedAt', 'userId'],
+                },
+                examples: ['dino auth login "<token>" --format json'],
+            },
+            action: runAuthLogin,
+        },
+        {
+            name: 'logout',
+            description: 'Clear saved login token and optionally remove the local cache',
+            options: [{ flags: '--clear-local-db', description: 'Delete the local PowerSync SQLite database' }],
+            schema: {
+                path: 'auth.logout',
+                risk: 'write',
+                auth: 'optional',
+                globalOptions: FORMAT_OPTIONS,
+                output: {
+                    type: 'structured',
+                    summary: 'Logout acknowledgement',
+                    fields: ['loggedOut', 'clearedLocalDb'],
+                },
+                examples: ['dino auth logout --format json', 'dino auth logout --clear-local-db --format json'],
+            },
+            action: runAuthLogout,
+        },
+        {
+            name: 'status',
+            description: 'Show current login, local cache, and sync status',
+            schema: {
+                path: 'auth.status',
+                risk: 'read',
+                auth: 'optional',
+                globalOptions: AUTH_STATUS_GLOBAL_OPTIONS,
+                output: {
+                    type: 'structured',
+                    summary: 'Auth and connectivity status envelope',
+                    fields: ['loggedIn', 'authorization', 'userId', 'username', 'email', 'powersync', 'dbPath', 'offline', 'stale', 'status'],
+                },
+                examples: ['dino auth status --format json', 'dino auth status --offline --format json'],
+            },
+            action: runAuthStatus,
+        },
+    ],
+};
+export function registerAuthCommands(program) {
+    registerCommandGroup(program, authCommandGroup);
 }

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

@@ -1,2 +1,4 @@
 import { Command } from 'commander';
+import type { CommandGroupDescriptor } from '../descriptor/types.js';
+export declare const boxCommandGroup: CommandGroupDescriptor;
 export declare function registerBoxesCommand(program: Command): void;