@dinoxx/dinox-cli 1.0.18 → 1.0.19

package/dist/commands/schema/spec.js

@@ -0,0 +1,40 @@
+import { authCommandGroup } from '../auth/index.js';
+import { boxCommandGroup } from '../boxes/index.js';
+import { commandSchemasFromGroupDescriptor } from '../descriptor/register.js';
+import { standaloneCommandSchemaFromDescriptor } from '../descriptor/register.js';
+import { configCommandGroup } from '../config/index.js';
+import { graphCommandGroup } from '../graph/index.js';
+import { infoCommandDescriptor } from '../info/index.js';
+import { noteCommandGroup } from '../notes/index.js';
+import { promptCommandGroup } from '../prompt/index.js';
+import { schemaCommandMetadata } from './commandMetadata.js';
+import { syncCommandDescriptor } from '../sync.js';
+import { storageCommandGroup } from '../storage/index.js';
+import { tagCommandGroup } from '../tags/index.js';
+import { todoCommandGroup } from '../todo/index.js';
+import { updateCommandDescriptor } from '../update.js';
+export const COMMAND_SCHEMAS = [
+    ...commandSchemasFromGroupDescriptor(authCommandGroup),
+    ...commandSchemasFromGroupDescriptor(configCommandGroup),
+    standaloneCommandSchemaFromDescriptor(syncCommandDescriptor),
+    standaloneCommandSchemaFromDescriptor({ ...schemaCommandMetadata, action: async () => undefined }),
+    standaloneCommandSchemaFromDescriptor(infoCommandDescriptor),
+    standaloneCommandSchemaFromDescriptor(updateCommandDescriptor),
+    ...commandSchemasFromGroupDescriptor(tagCommandGroup),
+    ...commandSchemasFromGroupDescriptor(boxCommandGroup),
+    ...commandSchemasFromGroupDescriptor(promptCommandGroup),
+    ...commandSchemasFromGroupDescriptor(storageCommandGroup),
+    ...commandSchemasFromGroupDescriptor(noteCommandGroup),
+    ...commandSchemasFromGroupDescriptor(graphCommandGroup),
+    ...commandSchemasFromGroupDescriptor(todoCommandGroup),
+];
+const COMMAND_SCHEMA_MAP = new Map(COMMAND_SCHEMAS.map((schema) => [schema.path, schema]));
+export function listCommandSchemas() {
+    return [...COMMAND_SCHEMAS];
+}
+export function findCommandSchema(path) {
+    return COMMAND_SCHEMA_MAP.get(path) ?? null;
+}
+export function listMcpCommandSchemas() {
+    return COMMAND_SCHEMAS.filter((schema) => schema.mcp);
+}

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

@@ -0,0 +1,47 @@
+export type CommandSchemaRisk = 'read' | 'write' | 'high-risk-write';
+export type CommandSchemaAuth = 'none' | 'optional' | 'required';
+export type CommandSchemaArgument = {
+    name: string;
+    required: boolean;
+    description: string;
+};
+export type CommandSchemaOption = {
+    name: string;
+    description: string;
+    required?: boolean;
+    type?: 'string' | 'number' | 'boolean' | 'string[]';
+    defaultValue?: string | number | boolean | string[];
+    enum?: string[];
+};
+export type CommandSchemaOutput = {
+    type: 'structured';
+    summary: string;
+    entity?: string;
+    fields?: string[];
+    metaFields?: string[];
+};
+export type CommandSchemaMcpProperty = {
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'string[]';
+    description: string;
+    required?: boolean;
+    enum?: string[];
+};
+export type CommandSchemaMcp = {
+    toolName: string;
+    description: string;
+    properties: CommandSchemaMcpProperty[];
+};
+export type CommandSchema = {
+    path: string;
+    command: string;
+    summary: string;
+    risk: CommandSchemaRisk;
+    auth: CommandSchemaAuth;
+    globalOptions: string[];
+    arguments?: CommandSchemaArgument[];
+    options?: CommandSchemaOption[];
+    output: CommandSchemaOutput;
+    mcp?: CommandSchemaMcp;
+    examples: string[];
+};

package/dist/commands/schema/types.js

@@ -0,0 +1 @@
+export {};

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

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

package/dist/commands/storage/index.js

@@ -0,0 +1,292 @@
+import { resolveAuthIdentity } from '../../auth/userInfo.js';
+import { loadConfig } from '../../config/store.js';
+import { resolveConfig } from '../../config/resolve.js';
+import { connectPowerSync, waitForIdleDataFlow } from '../../powersync/runtime.js';
+import { registerCommandGroup } from '../descriptor/register.js';
+import { FORMAT_OPTIONS, OFFLINE_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 { parseSyncTimeoutMs } from '../../utils/syncTimeout.js';
+import { getStorageStats, inspectStorageTest, inspectStorageUpload, listStorageConfigs, parseStorageUploadCategory, testStorageUpload, uploadFileToStorage, } from './repo.js';
+const STORAGE_GLOBAL_OPTIONS = [...FORMAT_OPTIONS, ...OFFLINE_OPTIONS, ...SYNC_TIMEOUT_OPTIONS];
+async function syncBeforeStorageCommand(db, offline, timeoutMs) {
+    if (offline) {
+        return;
+    }
+    await waitForIdleDataFlow(db, Math.min(timeoutMs, 10_000));
+}
+async function withStorageDb(context, run) {
+    const rawConfig = await loadConfig();
+    const config = resolveConfig(rawConfig);
+    const timeoutMs = parseSyncTimeoutMs(context.globals.syncTimeout) ?? config.sync.timeoutMs;
+    const offline = Boolean(context.globals.offline);
+    const { db, stale } = await connectPowerSync({ config, offline, timeoutMs });
+    try {
+        await run({ db, config, rawConfig, offline, timeoutMs, stale });
+    }
+    finally {
+        await db.close().catch(() => undefined);
+    }
+}
+async function runStorageList(context) {
+    await withStorageDb(context, async ({ db, config, rawConfig, offline, timeoutMs, stale }) => {
+        const identity = await resolveAuthIdentity(rawConfig, config);
+        await syncBeforeStorageCommand(db, offline, timeoutMs);
+        printSuccess({
+            stale: offline ? true : stale,
+            ...(await listStorageConfigs(db, identity.userId)),
+        });
+    });
+}
+async function runStorageUpload(context) {
+    const filePath = context.args.file;
+    if (!filePath) {
+        throw new DinoxError('File path is required. Use `dino storage upload <file>`.');
+    }
+    const options = context.options;
+    const category = parseStorageUploadCategory(options.category ?? 'files');
+    const structuredOutput = getRequestedStructuredOutputFormat() !== null;
+    await withStorageDb(context, async ({ db, config, rawConfig, offline, timeoutMs, stale }) => {
+        const identity = await resolveAuthIdentity(rawConfig, config);
+        await syncBeforeStorageCommand(db, offline, timeoutMs);
+        const plan = await inspectStorageUpload(db, {
+            userId: identity.userId,
+            filePath,
+            category,
+            storageId: options.storageId,
+            key: options.key,
+        });
+        if (options.dryRun) {
+            printDryRunPreview(buildStorageUploadDryRunPreview({
+                config,
+                offline,
+                filePath: plan.filePath,
+                fileName: plan.fileName,
+                sizeBytes: plan.sizeBytes,
+                category: plan.category,
+                storage: plan.storage,
+                storageKey: plan.storageKey,
+                storageUrl: plan.storageUrl,
+                selectionSource: plan.selectionSource,
+            }));
+            return;
+        }
+        const result = await uploadFileToStorage(db, {
+            userId: identity.userId,
+            filePath,
+            category,
+            storageId: options.storageId,
+            key: options.key,
+        });
+        if (!offline && !config.powersync.uploadBaseUrl) {
+            printHumanReadableLine('warning: upload disabled (powersync.uploadBaseUrl is unset); resource metadata is local-only for now');
+        }
+        if (!offline) {
+            await waitForIdleDataFlow(db, Math.min(timeoutMs, 5_000));
+        }
+        const payload = {
+            ok: true,
+            stale: offline ? true : stale,
+            ...result,
+        };
+        if (structuredOutput) {
+            printSuccess(payload);
+            return;
+        }
+        printHumanReadableLine(`Uploaded ${result.fileName}`);
+        printHumanReadableLine(`- resourceId: ${result.resourceId}`);
+        printHumanReadableLine(`- storage: ${result.aliasName || result.storageConfigId}`);
+        printHumanReadableLine(`- bucket: ${result.bucket}`);
+        printHumanReadableLine(`- key: ${result.storageKey}`);
+        printHumanReadableLine(`- url: ${result.storageUrl}`);
+        if (result.thumbnailUrl) {
+            printHumanReadableLine(`- thumbnail: ${result.thumbnailUrl}`);
+        }
+        if (stale && !offline) {
+            printHumanReadableLine('warning: sync timed out; local cache may be stale');
+        }
+    });
+}
+function formatBytes(bytes) {
+    if (!Number.isFinite(bytes) || bytes <= 0)
+        return '0 B';
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    if (bytes < 1024 * 1024 * 1024)
+        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}
+async function runStorageTest(context) {
+    const options = context.options;
+    const structuredOutput = getRequestedStructuredOutputFormat() !== null;
+    await withStorageDb(context, async ({ db, config, rawConfig, offline, timeoutMs, stale }) => {
+        const identity = await resolveAuthIdentity(rawConfig, config);
+        await syncBeforeStorageCommand(db, offline, timeoutMs);
+        const plan = await inspectStorageTest(db, {
+            userId: identity.userId,
+            storageId: options.storageId,
+        });
+        if (options.dryRun) {
+            printDryRunPreview(buildStorageTestDryRunPreview({
+                config,
+                offline,
+                storage: plan.storage,
+                storageKey: plan.storageKey,
+                storageUrl: plan.storageUrl,
+                sizeBytes: plan.sizeBytes,
+                selectionSource: plan.selectionSource,
+            }));
+            return;
+        }
+        const result = await testStorageUpload(db, {
+            userId: identity.userId,
+            storageId: options.storageId,
+        });
+        const payload = {
+            ok: true,
+            stale: offline ? true : stale,
+            ...result,
+        };
+        if (structuredOutput) {
+            printSuccess(payload);
+            return;
+        }
+        printHumanReadableLine(`Storage test succeeded for ${result.aliasName || result.storageConfigId}`);
+        printHumanReadableLine(`- bucket: ${result.bucket}`);
+        printHumanReadableLine(`- key: ${result.storageKey}`);
+        printHumanReadableLine(`- url: ${result.storageUrl}`);
+        if (result.isPrivate) {
+            printHumanReadableLine('- note: the target bucket is private; direct reads may still require signed access.');
+        }
+        if (stale && !offline) {
+            printHumanReadableLine('warning: sync timed out; local cache may be stale');
+        }
+    });
+}
+async function runStorageStats(context) {
+    const structuredOutput = getRequestedStructuredOutputFormat() !== null;
+    await withStorageDb(context, async ({ db, config, rawConfig, offline, timeoutMs, stale }) => {
+        const identity = await resolveAuthIdentity(rawConfig, config);
+        await syncBeforeStorageCommand(db, offline, timeoutMs);
+        const stats = await getStorageStats(db, identity.userId);
+        const payload = {
+            ok: true,
+            stale: offline ? true : stale,
+            ...stats,
+        };
+        if (structuredOutput) {
+            printSuccess(payload);
+            return;
+        }
+        printHumanReadableLine(`Storage usage: ${formatBytes(stats.totalBytes)} across ${stats.totalFiles} files`);
+        if (stats.entries.length === 0) {
+            printHumanReadableLine('No uploaded storage resources found.');
+        }
+        else {
+            for (const entry of stats.entries) {
+                printHumanReadableLine(`- ${entry.label}: ${entry.fileCount} files, ${formatBytes(entry.totalBytes)}`);
+            }
+        }
+        if (stale && !offline) {
+            printHumanReadableLine('warning: sync timed out; local cache may be stale');
+        }
+    });
+}
+export const storageCommandGroup = {
+    name: 'storage',
+    description: 'Inspect custom storage configs, test connectivity, upload files, and inspect usage',
+    commands: [
+        {
+            name: 'list',
+            description: 'List custom storage configs from c_storage and mark the active one',
+            schema: {
+                path: 'storage.list',
+                risk: 'read',
+                auth: 'required',
+                globalOptions: STORAGE_GLOBAL_OPTIONS,
+                output: {
+                    type: 'structured',
+                    summary: 'Custom storage configs and active selection payload',
+                    fields: ['activeCustomStorageConfigId', 'usesOfficialStorage', 'items'],
+                },
+                examples: ['dino storage list --format json'],
+            },
+            action: runStorageList,
+        },
+        {
+            name: 'test',
+            description: 'Upload a tiny temporary object to a custom S3 storage target without persisting a c_resource row',
+            options: [
+                { flags: '--storage-id <id>', description: 'Explicit storage config id (otherwise use active custom config)', type: 'string' },
+                { flags: '--dry-run', description: 'Preview the test object target without uploading', type: 'boolean' },
+            ],
+            schema: {
+                path: 'storage.test',
+                risk: 'write',
+                auth: 'required',
+                globalOptions: STORAGE_GLOBAL_OPTIONS,
+                output: {
+                    type: 'structured',
+                    summary: 'Storage connectivity test result',
+                    fields: ['storageConfigId', 'storageKey', 'storageUrl', 'provider', 'bucket', 'contentType', 'sizeBytes', 'stale'],
+                },
+                examples: [
+                    'dino storage test --format json --dry-run',
+                    'dino storage test --storage-id <id> --format json',
+                ],
+            },
+            action: runStorageTest,
+        },
+        {
+            name: 'upload',
+            description: 'Upload one local file to a custom S3 storage target and persist a c_resource row',
+            arguments: [{ syntax: '<file>', description: 'Local file path' }],
+            options: [
+                { flags: '--storage-id <id>', description: 'Explicit storage config id (otherwise use active custom config)', type: 'string' },
+                { flags: '--category <kind>', description: 'Upload category: images|audios|files|videos', type: 'string', defaultValue: 'files', enum: ['images', 'audios', 'files', 'videos'] },
+                { flags: '--key <string>', description: 'Explicit object key override', type: 'string' },
+                { flags: '--dry-run', description: 'Preview the upload target and resource record without uploading', type: 'boolean' },
+            ],
+            schema: {
+                path: 'storage.upload',
+                risk: 'write',
+                auth: 'required',
+                globalOptions: STORAGE_GLOBAL_OPTIONS,
+                output: {
+                    type: 'structured',
+                    summary: 'Storage upload acknowledgement',
+                    fields: ['resourceId', 'storageConfigId', 'storageKey', 'storageUrl', 'thumbnailUrl', 'provider', 'bucket', 'contentType', 'etag', 'stale'],
+                },
+                examples: [
+                    'dino storage upload ./report.pdf --format json --dry-run',
+                    'dino storage upload ./photo.jpg --category images --storage-id <id> --format json',
+                ],
+            },
+            action: runStorageUpload,
+        },
+        {
+            name: 'stats',
+            description: 'Summarize uploaded storage usage grouped by provider and bucket',
+            schema: {
+                path: 'storage.stats',
+                risk: 'read',
+                auth: 'required',
+                globalOptions: STORAGE_GLOBAL_OPTIONS,
+                output: {
+                    type: 'structured',
+                    summary: 'Aggregated storage usage payload',
+                    fields: ['totalBytes', 'totalFiles', 'entries', 'stale'],
+                },
+                examples: ['dino storage stats --format json'],
+            },
+            action: runStorageStats,
+        },
+    ],
+};
+export function registerStorageCommands(program) {
+    registerCommandGroup(program, storageCommandGroup);
+}

package/dist/commands/storage/repo.d.ts

@@ -0,0 +1,162 @@
+import fsp from 'node:fs/promises';
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+declare const UPLOAD_CATEGORY_VALUES: readonly ["images", "audios", "files", "videos"];
+export type StorageUploadCategory = (typeof UPLOAD_CATEGORY_VALUES)[number];
+export type StorageListItem = {
+    id: string;
+    aliasName: string;
+    provider: string;
+    endpoint: string;
+    bucket: string;
+    region: string;
+    forcePathStyle: boolean;
+    pathPrefix: string;
+    customDomain: string;
+    legacyDomains: string[];
+    isPrivate: boolean;
+    hasAccessKeyId: boolean;
+    hasSecretAccessKey: boolean;
+    isActive: boolean;
+};
+export type StorageListResult = {
+    activeCustomStorageConfigId: string | null;
+    usesOfficialStorage: boolean;
+    items: StorageListItem[];
+};
+type StoredCustomStorageConfig = {
+    id: string;
+    aliasName: string;
+    provider: string;
+    endpoint: string;
+    bucket: string;
+    region: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    forcePathStyle: boolean;
+    pathPrefix: string;
+    customDomain: string;
+    legacyDomains: string[];
+    isPrivate: boolean;
+};
+export type StorageUploadPlan = {
+    storage: StorageListItem;
+    selectionSource: 'storage_id' | 'active' | 'single_available_config';
+    filePath: string;
+    fileName: string;
+    sizeBytes: number;
+    category: StorageUploadCategory;
+    contentType: string;
+    storageKey: string;
+    storageUrl: string;
+    domain: string;
+};
+export type StorageUploadResult = {
+    resourceId: string;
+    storageConfigId: string;
+    aliasName: string;
+    provider: string;
+    bucket: string;
+    endpoint: string;
+    domain: string;
+    storageKey: string;
+    storageUrl: string;
+    fileName: string;
+    sizeBytes: number;
+    contentType: string;
+    category: StorageUploadCategory;
+    etag: string | null;
+    thumbnailUrl: string | null;
+    isPrivate: boolean;
+    selectionSource: StorageUploadPlan['selectionSource'];
+};
+export type StorageTestPlan = {
+    storage: StorageListItem;
+    selectionSource: StorageUploadPlan['selectionSource'];
+    contentType: string;
+    sizeBytes: number;
+    storageKey: string;
+    storageUrl: string;
+    domain: string;
+};
+export type StorageTestResult = {
+    storageConfigId: string;
+    aliasName: string;
+    provider: string;
+    bucket: string;
+    endpoint: string;
+    domain: string;
+    storageKey: string;
+    storageUrl: string;
+    contentType: string;
+    sizeBytes: number;
+    selectionSource: StorageUploadPlan['selectionSource'];
+    isPrivate: boolean;
+};
+export type StorageStatsEntry = {
+    provider: string;
+    bucket: string;
+    label: string;
+    totalBytes: number;
+    fileCount: number;
+    storageConfigId: string | null;
+    aliasName: string | null;
+    isOfficial: boolean;
+};
+export type StorageStatsResult = {
+    totalBytes: number;
+    totalFiles: number;
+    entries: StorageStatsEntry[];
+};
+type UploadObjectInput = {
+    localPath: string;
+    bucket: string;
+    key: string;
+    contentType: string;
+    contentLength: number;
+    storage: StoredCustomStorageConfig;
+};
+type UploadObjectResult = {
+    etag: string | null;
+};
+type UploadDeps = {
+    statFile?: typeof fsp.stat;
+    uploadObject?: (input: UploadObjectInput) => Promise<UploadObjectResult>;
+    deleteObject?: (input: {
+        bucket: string;
+        key: string;
+        storage: StoredCustomStorageConfig;
+    }) => Promise<void>;
+    uploadBytes?: (input: {
+        body: Buffer;
+        bucket: string;
+        key: string;
+        contentType: string;
+        storage: StoredCustomStorageConfig;
+    }) => Promise<UploadObjectResult>;
+};
+export declare function parseStorageUploadCategory(value: unknown): StorageUploadCategory;
+export declare function listStorageConfigs(db: AbstractPowerSyncDatabase, userId: string): Promise<StorageListResult>;
+export declare function getStorageStats(db: AbstractPowerSyncDatabase, userId: string): Promise<StorageStatsResult>;
+export declare function inspectStorageUpload(db: AbstractPowerSyncDatabase, input: {
+    userId: string;
+    filePath: string;
+    category: StorageUploadCategory;
+    storageId?: string;
+    key?: string;
+}, deps?: Pick<UploadDeps, 'statFile'>): Promise<StorageUploadPlan>;
+export declare function inspectStorageTest(db: AbstractPowerSyncDatabase, input: {
+    userId: string;
+    storageId?: string;
+}): Promise<StorageTestPlan>;
+export declare function testStorageUpload(db: AbstractPowerSyncDatabase, input: {
+    userId: string;
+    storageId?: string;
+}, deps?: Pick<UploadDeps, 'uploadBytes'>): Promise<StorageTestResult>;
+export declare function uploadFileToStorage(db: AbstractPowerSyncDatabase, input: {
+    userId: string;
+    filePath: string;
+    category: StorageUploadCategory;
+    storageId?: string;
+    key?: string;
+}, deps?: UploadDeps): Promise<StorageUploadResult>;
+export {};