@dinoxx/dinox-cli 2.0.0 → 2.1.1

package/dist/commands/storage/repo.js

@@ -1,1034 +1,4 @@
-import fs from 'node:fs';
-import fsp from 'node:fs/promises';
-import path from 'node:path';
-import { withPowerSyncWriteTransaction } from '../../powersync/runtime.js';
-import { generateId } from '../../utils/id.js';
-import { DinoxError } from '../../utils/errors.js';
-const ACTIVE_CUSTOM_STORAGE_CONFIG_ID_KEY = 'storage:active_custom_config_id';
-const DEFAULT_STORAGE_PROTOCOL = 's3';
-const DEFAULT_STORAGE_PATH_PREFIX = 'dinox_note/';
-const DEFAULT_CONTENT_TYPE = 'application/octet-stream';
-const OFFICIAL_STORAGE_PROVIDER = 'aliyun-official';
-const OFFICIAL_STORAGE_PROVIDER_NAME = '官方云';
-const UPLOAD_CATEGORY_VALUES = ['images', 'audios', 'files', 'videos'];
-function normalizeText(value) {
-    return typeof value === 'string' ? value.trim() : '';
-}
-function normalizeTextArray(raw) {
-    const input = normalizeText(raw);
-    if (!input) {
-        return [];
-    }
-    try {
-        const parsed = JSON.parse(input);
-        if (!Array.isArray(parsed)) {
-            return [];
-        }
-        return parsed
-            .map((entry) => normalizeText(String(entry)))
-            .filter(Boolean);
-    }
-    catch {
-        return [];
-    }
-}
-function normalizeBool(value) {
-    return Number(value ?? 0) === 1;
-}
-function normalizeNumber(value) {
-    const numeric = typeof value === 'number' ? value : Number(value ?? 0);
-    return Number.isFinite(numeric) ? numeric : 0;
-}
-function normalizeStoragePathPrefix(value) {
-    const trimmed = value.trim();
-    if (!trimmed) {
-        return DEFAULT_STORAGE_PATH_PREFIX;
-    }
-    return trimmed.endsWith('/') ? trimmed : `${trimmed}/`;
-}
-function finishStorageHost(value) {
-    const trimmed = value.trim();
-    if (!trimmed) {
-        throw new DinoxError('Storage endpoint is required.');
-    }
-    const candidate = /^https?:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`;
-    try {
-        const parsed = new URL(candidate);
-        parsed.pathname = '';
-        parsed.search = '';
-        parsed.hash = '';
-        return parsed.toString().replace(/\/$/, '');
-    }
-    catch (error) {
-        throw new DinoxError(`Invalid storage endpoint: ${trimmed}`, { cause: error });
-    }
-}
-function encodeStorageKeyForUrl(key) {
-    return key
-        .split('/')
-        .map((segment) => {
-        return encodeURIComponent(segment).replace(/[!'()*]/g, (character) => {
-            return `%${character.charCodeAt(0).toString(16).toUpperCase()}`;
-        });
-    })
-        .join('/');
-}
-function assertStorageKeyUrlSafe(key) {
-    const unsafeSegment = key.split('/').find((segment) => segment === '.' || segment === '..');
-    if (!unsafeSegment) {
-        return;
-    }
-    throw new DinoxError('Storage object key must not contain "." or ".." path segments.', {
-        code: 'INVALID_STORAGE_KEY',
-        suggestion: 'Remove dot-only path segments from --key or the configured storage path prefix.',
-        details: { key },
-    });
-}
-function buildVirtualHostedStyleUrl(bucket, endpoint, key) {
-    const parsed = new URL(endpoint);
-    const protocol = parsed.protocol || 'https:';
-    const port = parsed.port ? `:${parsed.port}` : '';
-    const host = parsed.hostname || parsed.host;
-    const hostWithBucket = host.startsWith(`${bucket}.`) ? host : `${bucket}.${host}`;
-    const encodedKey = encodeStorageKeyForUrl(key);
-    return {
-        finalUrl: `${protocol}//${hostWithBucket}${port}/${encodedKey}`,
-        domain: `${protocol}//${hostWithBucket}${port}`,
-    };
-}
-function buildPathStyleUrl(bucket, endpoint, key) {
-    const parsed = new URL(endpoint);
-    const protocol = parsed.protocol || 'https:';
-    const port = parsed.port ? `:${parsed.port}` : '';
-    const host = parsed.hostname || parsed.host;
-    const encodedKey = encodeStorageKeyForUrl(key);
-    return {
-        finalUrl: `${protocol}//${host}${port}/${bucket}/${encodedKey}`,
-        domain: `${protocol}//${host}${port}`,
-    };
-}
-function getFileExtension(filePath) {
-    const extension = path.extname(filePath).trim().replace(/^\./, '');
-    return extension.toLowerCase();
-}
-function guessContentType(filePath) {
-    const extension = getFileExtension(filePath);
-    switch (extension) {
-        case 'jpg':
-        case 'jpeg':
-            return 'image/jpeg';
-        case 'png':
-            return 'image/png';
-        case 'gif':
-            return 'image/gif';
-        case 'webp':
-            return 'image/webp';
-        case 'svg':
-            return 'image/svg+xml';
-        case 'mp3':
-            return 'audio/mpeg';
-        case 'm4a':
-            return 'audio/mp4';
-        case 'wav':
-            return 'audio/wav';
-        case 'ogg':
-        case 'opus':
-            return 'audio/ogg';
-        case 'mp4':
-            return 'video/mp4';
-        case 'mov':
-            return 'video/quicktime';
-        case 'webm':
-            return 'video/webm';
-        case 'pdf':
-            return 'application/pdf';
-        case 'json':
-            return 'application/json';
-        case 'md':
-            return 'text/markdown';
-        case 'txt':
-            return 'text/plain';
-        case 'csv':
-            return 'text/csv';
-        default:
-            return DEFAULT_CONTENT_TYPE;
-    }
-}
-function buildObjectId(userId, category, filePath) {
-    const ext = getFileExtension(filePath);
-    const suffix = ext ? `.${ext}` : '';
-    return `assets/${userId}/${category}/${generateId()}${suffix}`;
-}
-function generateThumbnailKey(originalKey) {
-    const lastSlashIndex = originalKey.lastIndexOf('/');
-    if (lastSlashIndex === -1) {
-        const filenameWithoutExt = originalKey.replace(/\.[^.]+$/, '');
-        return `thumb/${filenameWithoutExt}_thumbnail.webp`;
-    }
-    const dirPath = originalKey.slice(0, lastSlashIndex);
-    const filename = originalKey.slice(lastSlashIndex + 1);
-    const filenameWithoutExt = filename.replace(/\.[^.]+$/, '');
-    return `${dirPath}/thumb/${filenameWithoutExt}_thumbnail.webp`;
-}
-function buildStorageTarget(config, key) {
-    assertStorageKeyUrlSafe(key);
-    const resolvedEndpoint = finishStorageHost(config.endpoint);
-    if (config.customDomain) {
-        const domain = finishStorageHost(config.customDomain);
-        return {
-            storageUrl: `${domain}/${encodeStorageKeyForUrl(key)}`,
-            domain,
-        };
-    }
-    const target = config.forcePathStyle
-        ? buildPathStyleUrl(config.bucket, resolvedEndpoint, key)
-        : buildVirtualHostedStyleUrl(config.bucket, resolvedEndpoint, key);
-    return {
-        storageUrl: target.finalUrl,
-        domain: target.domain,
-    };
-}
-function isOfficialStorageProvider(provider) {
-    return provider === OFFICIAL_STORAGE_PROVIDER;
-}
-function getStorageProviderName(provider) {
-    if (isOfficialStorageProvider(provider)) {
-        return OFFICIAL_STORAGE_PROVIDER_NAME;
-    }
-    switch (provider) {
-        case 'bitiful':
-            return '缤纷云';
-        case 'tencent':
-            return '腾讯云';
-        case 'aliyun':
-            return '阿里云';
-        case 'aws':
-            return 'AWS';
-        case 'qiniu':
-            return '七牛云';
-        case 'cloudflare':
-            return 'Cloudflare';
-        default:
-            return provider;
-    }
-}
-function toSanitizedStorage(config, isActive) {
-    return {
-        id: config.id,
-        aliasName: config.aliasName,
-        provider: config.provider,
-        endpoint: config.endpoint,
-        bucket: config.bucket,
-        region: config.region,
-        forcePathStyle: config.forcePathStyle,
-        pathPrefix: config.pathPrefix,
-        customDomain: config.customDomain,
-        legacyDomains: config.legacyDomains,
-        isPrivate: config.isPrivate,
-        hasAccessKeyId: config.accessKeyId.length > 0,
-        hasSecretAccessKey: config.secretAccessKey.length > 0,
-        isActive,
-    };
-}
-function buildStorageUsageLabel(args) {
-    const { provider, bucket, configsByKey, configsByProvider } = args;
-    if (isOfficialStorageProvider(provider)) {
-        return {
-            label: OFFICIAL_STORAGE_PROVIDER_NAME,
-            storageConfigId: null,
-            aliasName: OFFICIAL_STORAGE_PROVIDER_NAME,
-            isOfficial: true,
-        };
-    }
-    const exactConfig = configsByKey.get(`${provider}::${bucket}`);
-    if (exactConfig?.aliasName) {
-        return {
-            label: exactConfig.aliasName,
-            storageConfigId: exactConfig.id,
-            aliasName: exactConfig.aliasName,
-            isOfficial: false,
-        };
-    }
-    const sameProviderConfigs = configsByProvider.get(provider) ?? [];
-    if (sameProviderConfigs.length === 1 && sameProviderConfigs[0]?.aliasName) {
-        return {
-            label: sameProviderConfigs[0].aliasName,
-            storageConfigId: sameProviderConfigs[0].id,
-            aliasName: sameProviderConfigs[0].aliasName,
-            isOfficial: false,
-        };
-    }
-    return {
-        label: bucket ? `${getStorageProviderName(provider)} · ${bucket}` : getStorageProviderName(provider),
-        storageConfigId: exactConfig?.id ?? null,
-        aliasName: exactConfig?.aliasName ?? null,
-        isOfficial: false,
-    };
-}
-async function getTableColumns(db, tableName) {
-    const rows = await db.getAll(`PRAGMA table_info(${tableName})`, []);
-    return new Set(rows.map((row) => row.name).filter(Boolean));
-}
-async function listStoredCustomStorageConfigs(db, userId) {
-    const rows = await db.getAll(`
-    SELECT
-      TRIM(COALESCE(id, '')) AS id,
-      TRIM(COALESCE(alias_name, '')) AS alias_name,
-      TRIM(COALESCE(protocol, '')) AS protocol,
-      TRIM(COALESCE(provider, '')) AS provider,
-      TRIM(COALESCE(endpoint, '')) AS endpoint,
-      TRIM(COALESCE(bucket, '')) AS bucket,
-      TRIM(COALESCE(region, '')) AS region,
-      TRIM(COALESCE(access_key_id, '')) AS access_key_id,
-      TRIM(COALESCE(secret_access_key, '')) AS secret_access_key,
-      force_path_style,
-      TRIM(COALESCE(path_prefix, '')) AS path_prefix,
-      TRIM(COALESCE(custom_domain, '')) AS custom_domain,
-      legacy_domains,
-      is_private,
-      updated_at,
-      deleted_at
-    FROM c_storage
-    WHERE TRIM(COALESCE(user_id, '')) = ?
-      AND TRIM(COALESCE(protocol, '')) = ?
-      AND deleted_at IS NULL
-      AND TRIM(COALESCE(id, '')) <> ''
-    ORDER BY COALESCE(sort_rank, 2147483647) ASC, updated_at DESC, id ASC
-    `, [userId, DEFAULT_STORAGE_PROTOCOL]);
-    return rows
-        .map((row) => ({
-        id: normalizeText(row.id),
-        aliasName: normalizeText(row.alias_name),
-        provider: normalizeText(row.provider),
-        endpoint: normalizeText(row.endpoint),
-        bucket: normalizeText(row.bucket),
-        region: normalizeText(row.region),
-        accessKeyId: normalizeText(row.access_key_id),
-        secretAccessKey: normalizeText(row.secret_access_key),
-        forcePathStyle: normalizeBool(row.force_path_style),
-        pathPrefix: normalizeStoragePathPrefix(normalizeText(row.path_prefix)),
-        customDomain: normalizeText(row.custom_domain),
-        legacyDomains: normalizeTextArray(row.legacy_domains),
-        isPrivate: normalizeBool(row.is_private),
-    }))
-        .filter((row) => row.id.length > 0);
-}
-async function getActiveCustomStorageConfigId(db, userId) {
-    const rows = await db.getAll(`
-    SELECT c_value
-    FROM c_config_property
-    WHERE TRIM(COALESCE(c_key, '')) = ?
-      AND TRIM(COALESCE(user_id, '')) = ?
-      AND (is_del IS NULL OR is_del = 0)
-    ORDER BY updated_at DESC, created_at DESC, id DESC
-    LIMIT 1
-    `, [ACTIVE_CUSTOM_STORAGE_CONFIG_ID_KEY, userId]);
-    return normalizeText(rows[0]?.c_value ?? null) || null;
-}
-function resolveStorageSelection(args) {
-    const explicitId = normalizeText(args.storageId);
-    if (explicitId) {
-        const config = args.configs.find((item) => item.id === explicitId);
-        if (!config) {
-            throw new DinoxError(`Storage config not found: ${explicitId}`, {
-                suggestion: 'Run `dino storage list --format json` to inspect available storage ids.',
-            });
-        }
-        return { config, selectionSource: 'storage_id' };
-    }
-    const activeId = normalizeText(args.activeCustomStorageConfigId);
-    if (activeId) {
-        const config = args.configs.find((item) => item.id === activeId);
-        if (config) {
-            return { config, selectionSource: 'active' };
-        }
-    }
-    if (args.configs.length === 1) {
-        return { config: args.configs[0], selectionSource: 'single_available_config' };
-    }
-    throw new DinoxError('No active custom storage config is available for upload.', {
-        suggestion: 'Set an active custom storage config in the app, or pass `--storage-id <id>`.',
-    });
-}
-function buildStorageUploadPlan(args) {
-    const storageKey = normalizeText(args.key) || `${args.config.pathPrefix}${buildObjectId(args.userId, args.category, args.filePath)}`;
-    const target = buildStorageTarget(args.config, storageKey);
-    return {
-        storage: toSanitizedStorage({
-            ...args.config,
-            endpoint: finishStorageHost(args.config.endpoint),
-        }, args.selectionSource === 'active'),
-        selectionSource: args.selectionSource,
-        filePath: args.filePath,
-        fileName: path.basename(args.filePath),
-        sizeBytes: args.sizeBytes,
-        category: args.category,
-        contentType: guessContentType(args.filePath),
-        storageKey,
-        storageUrl: target.storageUrl,
-        domain: target.domain,
-    };
-}
-function buildStorageTestPlan(args) {
-    const storageKey = `${args.config.pathPrefix}dinox-cli-test/${args.userId}/${generateId()}.txt`;
-    const target = buildStorageTarget(args.config, storageKey);
-    const payload = Buffer.from(`dinox-cli storage test\nprovider=${args.config.provider}\nuser=${args.userId}\ncreated_at=${new Date().toISOString()}\n`, 'utf8');
-    return {
-        storage: toSanitizedStorage({
-            ...args.config,
-            endpoint: finishStorageHost(args.config.endpoint),
-        }, args.selectionSource === 'active'),
-        selectionSource: args.selectionSource,
-        contentType: 'text/plain',
-        sizeBytes: payload.byteLength,
-        storageKey,
-        storageUrl: target.storageUrl,
-        domain: target.domain,
-    };
-}
-async function defaultUploadObject(input) {
-    const { PutObjectCommand, S3Client } = await import('@aws-sdk/client-s3');
-    const client = new S3Client({
-        endpoint: finishStorageHost(input.storage.endpoint),
-        region: input.storage.region,
-        forcePathStyle: input.storage.forcePathStyle,
-        credentials: {
-            accessKeyId: input.storage.accessKeyId,
-            secretAccessKey: input.storage.secretAccessKey,
-        },
-    });
-    const response = await client.send(new PutObjectCommand({
-        Bucket: input.bucket,
-        Key: input.key,
-        Body: fs.createReadStream(input.localPath),
-        ContentType: input.contentType,
-        ContentLength: input.contentLength,
-        IfNoneMatch: input.overwrite ? undefined : '*',
-    }));
-    return {
-        etag: normalizeText(response.ETag) || null,
-    };
-}
-function isObjectCollisionError(error) {
-    if (!error || typeof error !== 'object') {
-        return false;
-    }
-    const record = error;
-    return record.$metadata?.httpStatusCode === 409
-        || record.$metadata?.httpStatusCode === 412
-        || record.name === 'ConditionalRequestConflict'
-        || record.name === 'PreconditionFailed'
-        || record.Code === 'PreconditionFailed'
-        || record.code === 'PreconditionFailed';
-}
-function createStorageCollisionError(bucket, keys, failureDetails = {}) {
-    return new DinoxError(`Storage object already exists: ${keys.join(', ')}`, {
-        code: 'STORAGE_OBJECT_ALREADY_EXISTS',
-        suggestion: 'Choose a different --key, or pass --overwrite to replace the existing object.',
-        recoverable: true,
-        details: {
-            bucket,
-            keys,
-            ...failureDetails,
-        },
-    });
-}
-function createStorageUploadOutcomeUnknownError(input) {
-    return new DinoxError(input.message, {
-        cause: input.cause,
-        code: 'STORAGE_UPLOAD_OUTCOME_UNKNOWN',
-        recoverable: true,
-        suggestion: 'Inspect the reported object key in remote storage before retrying; do not assume the failed request left the object unchanged.',
-        details: {
-            bucket: input.bucket,
-            storageKey: input.storageKey,
-            operation: input.operation,
-            overwrite: input.overwrite,
-            remoteOutcome: 'unknown',
-            remoteObjectChanged: null,
-            affectedKeys: [],
-            possiblyAffectedKeys: [...new Set(input.possiblyAffectedKeys)],
-        },
-    });
-}
-async function defaultDeleteObject(input) {
-    const { DeleteObjectCommand, S3Client } = await import('@aws-sdk/client-s3');
-    const client = new S3Client({
-        endpoint: finishStorageHost(input.storage.endpoint),
-        region: input.storage.region,
-        forcePathStyle: input.storage.forcePathStyle,
-        credentials: {
-            accessKeyId: input.storage.accessKeyId,
-            secretAccessKey: input.storage.secretAccessKey,
-        },
-    });
-    await client.send(new DeleteObjectCommand({
-        Bucket: input.bucket,
-        Key: input.key,
-        IfMatch: normalizeText(input.etag) || undefined,
-    }));
-}
-async function defaultUploadBytes(input) {
-    const { PutObjectCommand, S3Client } = await import('@aws-sdk/client-s3');
-    const client = new S3Client({
-        endpoint: finishStorageHost(input.storage.endpoint),
-        region: input.storage.region,
-        forcePathStyle: input.storage.forcePathStyle,
-        credentials: {
-            accessKeyId: input.storage.accessKeyId,
-            secretAccessKey: input.storage.secretAccessKey,
-        },
-    });
-    const response = await client.send(new PutObjectCommand({
-        Bucket: input.bucket,
-        Key: input.key,
-        Body: input.body,
-        ContentType: input.contentType,
-        ContentLength: input.body.byteLength,
-        IfNoneMatch: input.overwrite ? undefined : '*',
-    }));
-    return {
-        etag: normalizeText(response.ETag) || null,
-    };
-}
-async function generateThumbnailBuffer(localPath) {
-    const { default: sharp } = await import('sharp');
-    return sharp(localPath)
-        .resize({ width: 400, withoutEnlargement: true })
-        .webp({ quality: 50 })
-        .toBuffer();
-}
-function buildUploadedResourceEntries(columns, args, id, now) {
-    const entries = [];
-    const push = (column, value) => {
-        if (columns.has(column)) {
-            entries.push([column, value]);
-        }
-    };
-    push('id', id);
-    push('user_id', args.userId);
-    push('name', args.plan.fileName);
-    push('mime_type', args.plan.contentType);
-    push('size_bytes', args.plan.sizeBytes);
-    push('storage_config_id', args.storage.id);
-    push('storage_key', args.plan.storageKey);
-    push('storage_url', args.plan.storageUrl);
-    push('storage_provider', args.storage.provider);
-    push('bucket', args.storage.bucket);
-    push('is_public', args.storage.isPrivate ? 0 : 1);
-    push('created_at', now);
-    push('updated_at', now);
-    push('is_del', 0);
-    push('status', 'uploaded');
-    push('uploaded_at', now);
-    push('etag', args.etag);
-    push('checksum', null);
-    push('category', args.plan.category);
-    push('endpoint', args.storage.endpoint);
-    push('domain', args.plan.domain);
-    push('extra_data', '{}');
-    push('deleted_at', null);
-    push('content_sha256', null);
-    push('content', null);
-    push('content_md', null);
-    push('summary', null);
-    return entries;
-}
-async function insertResourceRow(db, entries) {
-    const insertColumns = entries.map(([column]) => column);
-    const placeholders = insertColumns.map(() => '?').join(', ');
-    await db.execute(`
-    INSERT INTO c_resource (${insertColumns.join(', ')})
-    VALUES (${placeholders})
-    `, entries.map(([, value]) => value));
-}
-async function persistUploadedResource(db, args) {
-    const columns = await getTableColumns(db, 'c_resource');
-    const requiredColumns = [
-        'id',
-        'user_id',
-        'name',
-        'mime_type',
-        'size_bytes',
-        'storage_key',
-        'storage_url',
-        'storage_provider',
-        'bucket',
-        'created_at',
-        'updated_at',
-        'is_del',
-    ];
-    const missingRequired = requiredColumns.filter((column) => !columns.has(column));
-    if (missingRequired.length > 0) {
-        throw new DinoxError(`c_resource table is missing required columns: ${missingRequired.join(', ')}`);
-    }
-    const id = generateId();
-    const now = new Date().toISOString();
-    const entries = buildUploadedResourceEntries(columns, args, id, now);
-    if (!args.overwrite) {
-        await insertResourceRow(db, entries);
-        return id;
-    }
-    return withPowerSyncWriteTransaction(db, async (tx) => {
-        const identityClauses = [
-            'user_id = ?',
-            'storage_key = ?',
-            'COALESCE(is_del, 0) = 0',
-        ];
-        const identityParams = [args.userId, args.plan.storageKey];
-        if (columns.has('storage_config_id')) {
-            identityClauses.push('storage_config_id = ?');
-            identityParams.push(args.storage.id);
-        }
-        else {
-            identityClauses.push('storage_provider = ?', 'bucket = ?');
-            identityParams.push(args.storage.provider, args.storage.bucket);
-            if (columns.has('endpoint')) {
-                identityClauses.push('endpoint = ?');
-                identityParams.push(args.storage.endpoint);
-            }
-        }
-        const existingRows = await tx.getAll(`
-      SELECT id
-      FROM c_resource
-      WHERE ${identityClauses.join('\n        AND ')}
-      ORDER BY created_at ASC, id ASC
-      `, identityParams);
-        const existingIds = [...new Set(existingRows.map((row) => normalizeText(row.id)).filter(Boolean))];
-        const existingId = existingIds[0];
-        if (!existingId) {
-            await insertResourceRow(tx, entries);
-            return id;
-        }
-        const updateEntries = entries.filter(([column]) => (column !== 'id' && column !== 'user_id' && column !== 'created_at'));
-        await tx.execute(`
-      UPDATE c_resource
-      SET ${updateEntries.map(([column]) => `${column} = ?`).join(', ')}
-      WHERE id = ?
-        AND user_id = ?
-        AND COALESCE(is_del, 0) = 0
-      `, [...updateEntries.map(([, value]) => value), existingId, args.userId]);
-        const duplicateIds = existingIds.slice(1);
-        if (duplicateIds.length > 0) {
-            const duplicateUpdates = [
-                ['updated_at', now],
-                ['is_del', 1],
-                ...(columns.has('deleted_at') ? [['deleted_at', now]] : []),
-            ];
-            await tx.execute(`
-        UPDATE c_resource
-        SET ${duplicateUpdates.map(([column]) => `${column} = ?`).join(', ')}
-        WHERE user_id = ?
-          AND COALESCE(is_del, 0) = 0
-          AND id IN (${duplicateIds.map(() => '?').join(', ')})
-        `, [...duplicateUpdates.map(([, value]) => value), args.userId, ...duplicateIds]);
-        }
-        return existingId;
-    });
-}
-export function parseStorageUploadCategory(value) {
-    const normalized = typeof value === 'string' ? value.trim().toLowerCase() : '';
-    if (UPLOAD_CATEGORY_VALUES.includes(normalized)) {
-        return normalized;
-    }
-    throw new DinoxError(`--category must be one of: ${UPLOAD_CATEGORY_VALUES.join(', ')}`);
-}
-export async function listStorageConfigs(db, userId) {
-    const activeCustomStorageConfigId = await getActiveCustomStorageConfigId(db, userId);
-    const configs = await listStoredCustomStorageConfigs(db, userId);
-    return {
-        activeCustomStorageConfigId,
-        usesOfficialStorage: !activeCustomStorageConfigId,
-        items: configs.map((config) => toSanitizedStorage(config, config.id === activeCustomStorageConfigId)),
-    };
-}
-export async function getStorageStats(db, userId) {
-    const rows = await db.getAll(`
-    SELECT
-      TRIM(COALESCE(storage_provider, '')) AS provider,
-      TRIM(COALESCE(bucket, '')) AS bucket,
-      COALESCE(SUM(COALESCE(size_bytes, 0)), 0) AS total_bytes,
-      COUNT(1) AS file_count
-    FROM c_resource
-    WHERE (is_del IS NULL OR is_del = 0)
-      AND TRIM(COALESCE(user_id, '')) = ?
-      AND TRIM(COALESCE(storage_provider, '')) <> ''
-      AND TRIM(COALESCE(storage_provider, '')) <> 'local'
-      AND TRIM(COALESCE(status, '')) = 'uploaded'
-    GROUP BY storage_provider, bucket
-    ORDER BY total_bytes DESC, provider ASC, bucket ASC
-    `, [userId]);
-    const configs = await listStoredCustomStorageConfigs(db, userId);
-    const configsByKey = new Map();
-    const configsByProvider = new Map();
-    for (const config of configs) {
-        configsByKey.set(`${config.provider}::${config.bucket}`, config);
-        const current = configsByProvider.get(config.provider);
-        if (current) {
-            current.push(config);
-        }
-        else {
-            configsByProvider.set(config.provider, [config]);
-        }
-    }
-    const entries = rows
-        .map((row) => {
-        const provider = normalizeText(row.provider);
-        const bucket = normalizeText(row.bucket);
-        const labelInfo = buildStorageUsageLabel({
-            provider,
-            bucket,
-            configsByKey,
-            configsByProvider,
-        });
-        return {
-            provider,
-            bucket,
-            label: labelInfo.label,
-            totalBytes: normalizeNumber(row.total_bytes),
-            fileCount: normalizeNumber(row.file_count),
-            storageConfigId: labelInfo.storageConfigId,
-            aliasName: labelInfo.aliasName,
-            isOfficial: labelInfo.isOfficial,
-        };
-    })
-        .filter((entry) => entry.provider.length > 0 && entry.fileCount > 0)
-        .sort((left, right) => {
-        if (left.isOfficial !== right.isOfficial) {
-            return left.isOfficial ? -1 : 1;
-        }
-        return right.totalBytes - left.totalBytes;
-    });
-    return {
-        totalBytes: entries.reduce((sum, entry) => sum + entry.totalBytes, 0),
-        totalFiles: entries.reduce((sum, entry) => sum + entry.fileCount, 0),
-        entries,
-    };
-}
-export async function inspectStorageUpload(db, input, deps) {
-    const statFile = deps?.statFile ?? fsp.stat;
-    const filePath = input.filePath.trim();
-    if (!filePath) {
-        throw new DinoxError('File path is required.');
-    }
-    const stats = await statFile(filePath).catch((error) => {
-        throw new DinoxError(`File not found: ${filePath}`, { cause: error });
-    });
-    if (!stats.isFile()) {
-        throw new DinoxError(`Not a regular file: ${filePath}`);
-    }
-    const configs = await listStoredCustomStorageConfigs(db, input.userId);
-    if (configs.length === 0) {
-        throw new DinoxError('No custom storage configs are available.', {
-            suggestion: 'Configure a custom storage target in the app first.',
-        });
-    }
-    const activeCustomStorageConfigId = await getActiveCustomStorageConfigId(db, input.userId);
-    const { config, selectionSource } = resolveStorageSelection({
-        configs,
-        storageId: input.storageId,
-        activeCustomStorageConfigId,
-    });
-    if (!config.endpoint || !config.bucket || !config.region || !config.accessKeyId || !config.secretAccessKey) {
-        throw new DinoxError(`Storage config "${config.aliasName || config.id}" is incomplete for upload.`, {
-            suggestion: 'Fill in endpoint, region, bucket, access key id, and secret access key in the app.',
-        });
-    }
-    return buildStorageUploadPlan({
-        config,
-        selectionSource,
-        userId: input.userId,
-        filePath,
-        category: input.category,
-        key: input.key,
-        sizeBytes: stats.size,
-    });
-}
-export async function inspectStorageTest(db, input) {
-    const configs = await listStoredCustomStorageConfigs(db, input.userId);
-    if (configs.length === 0) {
-        throw new DinoxError('No custom storage configs are available.', {
-            suggestion: 'Configure a custom storage target in the app first.',
-        });
-    }
-    const activeCustomStorageConfigId = await getActiveCustomStorageConfigId(db, input.userId);
-    const { config, selectionSource } = resolveStorageSelection({
-        configs,
-        storageId: input.storageId,
-        activeCustomStorageConfigId,
-    });
-    if (!config.endpoint || !config.bucket || !config.region || !config.accessKeyId || !config.secretAccessKey) {
-        throw new DinoxError(`Storage config "${config.aliasName || config.id}" is incomplete for upload.`, {
-            suggestion: 'Fill in endpoint, region, bucket, access key id, and secret access key in the app.',
-        });
-    }
-    return buildStorageTestPlan({
-        config,
-        selectionSource,
-        userId: input.userId,
-    });
-}
-export async function testStorageUpload(db, input, deps) {
-    const plan = await inspectStorageTest(db, input);
-    const configs = await listStoredCustomStorageConfigs(db, input.userId);
-    const storage = configs.find((item) => item.id === plan.storage.id);
-    if (!storage) {
-        throw new DinoxError(`Storage config not found: ${plan.storage.id}`);
-    }
-    const uploadBytes = deps?.uploadBytes ?? defaultUploadBytes;
-    const deleteObject = deps?.deleteObject ?? defaultDeleteObject;
-    const payload = Buffer.from(`dinox-cli storage test\nprovider=${storage.provider}\nuser=${input.userId}\ncreated_at=${new Date().toISOString()}\n`, 'utf8');
-    let uploaded;
-    try {
-        uploaded = await uploadBytes({
-            body: payload,
-            bucket: storage.bucket,
-            key: plan.storageKey,
-            contentType: plan.contentType,
-            storage,
-        });
-    }
-    catch (error) {
-        if (isObjectCollisionError(error)) {
-            throw error;
-        }
-        throw createStorageUploadOutcomeUnknownError({
-            message: 'Storage test upload outcome could not be confirmed.',
-            cause: error,
-            bucket: storage.bucket,
-            storageKey: plan.storageKey,
-            possiblyAffectedKeys: [plan.storageKey],
-            overwrite: false,
-            operation: 'storage_test',
-        });
-    }
-    const cleanupEtag = normalizeText(uploaded.etag);
-    if (!cleanupEtag) {
-        throw new DinoxError('Storage test uploaded the temporary object but could not clean it up safely.', {
-            code: 'STORAGE_TEST_CLEANUP_FAILED',
-            details: {
-                storageKey: plan.storageKey,
-                bucket: storage.bucket,
-                remoteObjectChanged: true,
-                affectedKeys: [plan.storageKey],
-                cleanupErrors: [
-                    `${plan.storageKey} cleanup skipped: upload response did not include an ETag required for safe conditional deletion`,
-                ],
-            },
-        });
-    }
-    try {
-        await deleteObject({
-            bucket: storage.bucket,
-            key: plan.storageKey,
-            etag: cleanupEtag,
-            storage,
-        });
-    }
-    catch (error) {
-        throw new DinoxError('Storage test uploaded the temporary object but failed to clean it up.', {
-            cause: error,
-            code: 'STORAGE_TEST_CLEANUP_FAILED',
-            details: {
-                storageKey: plan.storageKey,
-                bucket: storage.bucket,
-                remoteObjectChanged: true,
-                affectedKeys: [plan.storageKey],
-                cleanupErrors: [
-                    `${plan.storageKey} cleanup failed: ${error instanceof Error ? error.message : String(error)}`,
-                ],
-            },
-        });
-    }
-    return {
-        storageConfigId: storage.id,
-        aliasName: storage.aliasName,
-        provider: storage.provider,
-        bucket: storage.bucket,
-        endpoint: storage.endpoint,
-        domain: plan.domain,
-        storageKey: plan.storageKey,
-        storageUrl: plan.storageUrl,
-        contentType: plan.contentType,
-        sizeBytes: plan.sizeBytes,
-        selectionSource: plan.selectionSource,
-        isPrivate: storage.isPrivate,
-    };
-}
-export async function uploadFileToStorage(db, input, deps) {
-    if (input.overwrite && !normalizeText(input.key)) {
-        throw new DinoxError('--overwrite requires an explicit --key.', {
-            code: 'USAGE_ERROR',
-        });
-    }
-    const plan = await inspectStorageUpload(db, input, { statFile: deps?.statFile });
-    const configs = await listStoredCustomStorageConfigs(db, input.userId);
-    const storage = configs.find((item) => item.id === plan.storage.id);
-    if (!storage) {
-        throw new DinoxError(`Storage config not found: ${plan.storage.id}`);
-    }
-    const overwrite = input.overwrite === true;
-    const uploadObject = deps?.uploadObject ?? defaultUploadObject;
-    const uploadBytes = deps?.uploadBytes ?? defaultUploadBytes;
-    const deleteObject = deps?.deleteObject ?? defaultDeleteObject;
-    const thumbnailKey = plan.contentType.startsWith('image/')
-        ? generateThumbnailKey(plan.storageKey)
-        : null;
-    let uploaded;
-    try {
-        uploaded = await uploadObject({
-            localPath: plan.filePath,
-            bucket: storage.bucket,
-            key: plan.storageKey,
-            contentType: plan.contentType,
-            contentLength: plan.sizeBytes,
-            overwrite,
-            storage,
-        });
-    }
-    catch (error) {
-        if (!overwrite && isObjectCollisionError(error)) {
-            throw createStorageCollisionError(storage.bucket, [plan.storageKey]);
-        }
-        throw createStorageUploadOutcomeUnknownError({
-            message: 'Storage upload outcome could not be confirmed.',
-            cause: error,
-            bucket: storage.bucket,
-            storageKey: plan.storageKey,
-            possiblyAffectedKeys: [plan.storageKey],
-            overwrite,
-            operation: 'upload',
-        });
-    }
-    let thumbnailUrl = null;
-    const possiblyAffectedKeys = new Set();
-    const remoteWrites = [{
-            key: plan.storageKey,
-            etag: uploaded.etag,
-            cleanupAllowed: !overwrite,
-            cleaned: false,
-        }];
-    const cleanupUploadedObjects = async () => {
-        const cleanupErrors = [];
-        for (const remoteWrite of [...remoteWrites].reverse()) {
-            if (!remoteWrite.cleanupAllowed || remoteWrite.cleaned) {
-                continue;
-            }
-            const cleanupEtag = normalizeText(remoteWrite.etag);
-            if (!cleanupEtag) {
-                cleanupErrors.push(`${remoteWrite.key} cleanup skipped: upload response did not include an ETag required for safe conditional deletion`);
-                continue;
-            }
-            await deleteObject({
-                bucket: storage.bucket,
-                key: remoteWrite.key,
-                etag: cleanupEtag,
-                storage,
-            }).then(() => {
-                remoteWrite.cleaned = true;
-            }, (cleanupError) => {
-                cleanupErrors.push(`${remoteWrite.key} cleanup failed: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
-            });
-        }
-        return cleanupErrors;
-    };
-    const buildRemoteFailureDetails = (cleanupErrors) => {
-        const affectedKeys = remoteWrites
-            .filter((remoteWrite) => !remoteWrite.cleaned)
-            .map((remoteWrite) => remoteWrite.key);
-        const possibleKeys = [...possiblyAffectedKeys];
-        return {
-            bucket: storage.bucket,
-            storageKey: plan.storageKey,
-            remoteObjectChanged: possibleKeys.length > 0
-                ? (affectedKeys.length > 0 ? true : null)
-                : affectedKeys.length > 0,
-            affectedKeys,
-            ...(possibleKeys.length > 0
-                ? { remoteOutcome: 'unknown', possiblyAffectedKeys: possibleKeys }
-                : {}),
-            ...(cleanupErrors.length > 0 ? { cleanupErrors } : {}),
-        };
-    };
-    if (plan.contentType.startsWith('image/')) {
-        try {
-            if (!thumbnailKey) {
-                throw new Error('Thumbnail key could not be generated.');
-            }
-            const thumbnailBuffer = await generateThumbnailBuffer(plan.filePath);
-            const thumbnailTarget = buildStorageTarget(storage, thumbnailKey);
-            let uploadedThumbnail;
-            try {
-                uploadedThumbnail = await uploadBytes({
-                    body: thumbnailBuffer,
-                    bucket: storage.bucket,
-                    key: thumbnailKey,
-                    contentType: 'image/webp',
-                    overwrite,
-                    storage,
-                });
-            }
-            catch (error) {
-                if (!isObjectCollisionError(error)) {
-                    possiblyAffectedKeys.add(thumbnailKey);
-                }
-                throw error;
-            }
-            remoteWrites.push({
-                key: thumbnailKey,
-                etag: uploadedThumbnail.etag,
-                cleanupAllowed: !overwrite,
-                cleaned: false,
-            });
-            thumbnailUrl = thumbnailTarget.storageUrl;
-        }
-        catch (error) {
-            const cleanupErrors = await cleanupUploadedObjects();
-            if (!overwrite && isObjectCollisionError(error) && thumbnailKey) {
-                throw createStorageCollisionError(storage.bucket, [thumbnailKey], buildRemoteFailureDetails(cleanupErrors));
-            }
-            throw new DinoxError('Storage upload failed while generating the required thumbnail.', {
-                cause: error,
-                code: 'STORAGE_THUMBNAIL_UPLOAD_FAILED',
-                details: buildRemoteFailureDetails(cleanupErrors),
-            });
-        }
-    }
-    try {
-        const resourceId = await persistUploadedResource(db, {
-            userId: input.userId,
-            storage,
-            plan,
-            etag: uploaded.etag,
-            thumbnailUrl,
-            overwrite,
-        });
-        return {
-            resourceId,
-            storageConfigId: storage.id,
-            aliasName: storage.aliasName,
-            provider: storage.provider,
-            bucket: storage.bucket,
-            endpoint: storage.endpoint,
-            domain: plan.domain,
-            storageKey: plan.storageKey,
-            storageUrl: plan.storageUrl,
-            fileName: plan.fileName,
-            sizeBytes: plan.sizeBytes,
-            contentType: plan.contentType,
-            category: plan.category,
-            etag: uploaded.etag,
-            thumbnailUrl,
-            isPrivate: storage.isPrivate,
-            selectionSource: plan.selectionSource,
-        };
-    }
-    catch (error) {
-        const cleanupErrors = await cleanupUploadedObjects();
-        throw new DinoxError('Storage upload failed while recording resource metadata.', {
-            cause: error,
-            code: 'STORAGE_RESOURCE_INSERT_FAILED',
-            details: buildRemoteFailureDetails(cleanupErrors),
-        });
-    }
-}
+// Public repository API. Implementation lives in ./repo/*; this module re-exports
+// only the original public surface so callers do not depend on the internal split.
+export { getStorageStats, listStorageConfigs, parseStorageUploadCategory, } from './repo/configs.js';
+export { inspectStorageTest, inspectStorageUpload, testStorageUpload, uploadFileToStorage, } from './repo/operations.js';