@super-protocol/sp-cli 0.0.8 → 0.0.10-beta

package/dist/commands/assets/base.js

@@ -0,0 +1,217 @@
+import { password, text } from '@clack/prompts';
+import { AssetService, AssetType, SourceType, } from '../../services/asset.service.js';
+import { BaseCommand } from '../base.js';
+const isRecord = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+export class BaseAssetCommand extends BaseCommand {
+    static summary = 'Asset management';
+    assetService;
+    currentDir = process.cwd();
+    async init() {
+        await super.init();
+        await this.container.initSwarmClient().build();
+        this.assetService = new AssetService(this.container.swarmClient, this.logger);
+    }
+    parseCredentialsInput(raw, fieldName) {
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch (error) {
+            this.error(`${fieldName} must be valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (!isRecord(parsed)) {
+            this.error(`${fieldName} must be a JSON object`);
+        }
+        return parsed;
+    }
+    async promptCredentials(sourceType) {
+        switch (sourceType) {
+            case SourceType.STORJ: {
+                const bucket = await this.promptRequiredText('Bucket');
+                const path = await this.promptRequiredText('Path');
+                const token = await this.promptRequiredText('Access token');
+                return { bucket, path, token };
+            }
+            case SourceType.S3: {
+                const bucket = await this.promptRequiredText('Bucket');
+                const path = await this.promptRequiredText('Path');
+                const accessKey = await this.promptRequiredText('Access key');
+                const secretKey = await this.promptRequiredText('Secret key');
+                const region = await this.promptRequiredText('Region');
+                const endpoint = await this.promptOptionalText('Endpoint (optional)');
+                return {
+                    bucket,
+                    path,
+                    accessKey,
+                    secretKey,
+                    region,
+                    endpoint,
+                };
+            }
+            case SourceType.DOCKERHUB: {
+                const image = await this.promptRequiredText('Image');
+                const registry = await this.promptOptionalText('Registry (optional)');
+                const username = await this.promptOptionalText('Username (optional)');
+                const passwordValue = await this.promptOptionalText('Password (optional)', true);
+                return {
+                    image,
+                    registry,
+                    username,
+                    password: passwordValue,
+                };
+            }
+            case SourceType.GITHUB: {
+                const repo = await this.promptRequiredText('Repository (org/repo)');
+                const token = await this.promptOptionalText('Token (optional)', true);
+                const branch = await this.promptOptionalText('Branch (optional)');
+                return {
+                    repo,
+                    token,
+                    branch,
+                };
+            }
+            case SourceType.GOOGLE_DOCS: {
+                const documentId = await this.promptRequiredText('Document ID');
+                const apiKey = await this.promptOptionalText('API key (optional)');
+                const serviceAccountJson = await this.promptOptionalText('Service account JSON (optional)');
+                return {
+                    documentId,
+                    apiKey,
+                    serviceAccountJson,
+                };
+            }
+            default: {
+                const exhaustive = sourceType;
+                throw new Error(`Unsupported source type: ${exhaustive}`);
+            }
+        }
+    }
+    async promptOptionalText(message, secret = false) {
+        const prompt = secret ? password : text;
+        const value = this.ensurePromptValue(await prompt({ message }));
+        const trimmed = value.trim();
+        return trimmed ? trimmed : undefined;
+    }
+    async promptRequiredText(message) {
+        const value = this.ensurePromptValue(await text({
+            message,
+            validate(input) {
+                return input?.trim() ? undefined : 'Value is required';
+            },
+        })).trim();
+        return value;
+    }
+    parseSizeInput(raw) {
+        const trimmed = raw.trim();
+        if (!trimmed) {
+            return undefined;
+        }
+        const size = Number(trimmed);
+        if (!Number.isFinite(size) || size < 0) {
+            this.error('Size must be a positive number');
+        }
+        return size;
+    }
+    getAllowedSourceTypes(type) {
+        if (type === AssetType.OUTPUT) {
+            return [SourceType.S3, SourceType.STORJ];
+        }
+        return Object.values(SourceType);
+    }
+    assertSourceTypeAllowed(type, sourceType) {
+        const allowed = this.getAllowedSourceTypes(type);
+        if (!allowed.includes(sourceType)) {
+            this.error('For output assets, sourceType must be "s3" or "storj".');
+        }
+    }
+    hasCredentialsFlags(flags) {
+        return Boolean(flags.storjBucket ||
+            flags.storjPath ||
+            flags.storjToken ||
+            flags.s3Bucket ||
+            flags.s3Path ||
+            flags.s3AccessKey ||
+            flags.s3SecretKey ||
+            flags.s3Region ||
+            flags.s3Endpoint ||
+            flags.dockerImage ||
+            flags.dockerRegistry ||
+            flags.dockerUsername ||
+            flags.dockerPassword ||
+            flags.githubRepo ||
+            flags.githubToken ||
+            flags.githubBranch ||
+            flags.gdocsDocumentId ||
+            flags.gdocsApiKey ||
+            flags.gdocsServiceAccountJson);
+    }
+    buildCredentialsFromFlags(sourceType, flags) {
+        const missing = [];
+        const requireField = (value, flag) => {
+            const trimmed = value?.trim();
+            if (!trimmed) {
+                missing.push(flag);
+            }
+            return trimmed ?? '';
+        };
+        const optionalField = (value) => {
+            const trimmed = value?.trim();
+            return trimmed ? trimmed : undefined;
+        };
+        switch (sourceType) {
+            case SourceType.STORJ: {
+                const bucket = requireField(flags.storjBucket, '--storj-bucket');
+                const path = requireField(flags.storjPath, '--storj-path');
+                const token = requireField(flags.storjToken, '--storj-token');
+                if (missing.length > 0) {
+                    this.error(`Missing required Storj credentials flags: ${missing.join(', ')}`);
+                }
+                return { bucket, path, token };
+            }
+            case SourceType.S3: {
+                const bucket = requireField(flags.s3Bucket, '--s3-bucket');
+                const path = requireField(flags.s3Path, '--s3-path');
+                const accessKey = requireField(flags.s3AccessKey, '--s3-access-key');
+                const secretKey = requireField(flags.s3SecretKey, '--s3-secret-key');
+                const region = requireField(flags.s3Region, '--s3-region');
+                const endpoint = optionalField(flags.s3Endpoint);
+                if (missing.length > 0) {
+                    this.error(`Missing required S3 credentials flags: ${missing.join(', ')}`);
+                }
+                return { bucket, path, accessKey, secretKey, region, endpoint };
+            }
+            case SourceType.DOCKERHUB: {
+                const image = requireField(flags.dockerImage, '--docker-image');
+                const registry = optionalField(flags.dockerRegistry);
+                const username = optionalField(flags.dockerUsername);
+                const password = optionalField(flags.dockerPassword);
+                if (missing.length > 0) {
+                    this.error(`Missing required DockerHub credentials flags: ${missing.join(', ')}`);
+                }
+                return { image, registry, username, password };
+            }
+            case SourceType.GITHUB: {
+                const repo = requireField(flags.githubRepo, '--github-repo');
+                const token = optionalField(flags.githubToken);
+                const branch = optionalField(flags.githubBranch);
+                if (missing.length > 0) {
+                    this.error(`Missing required GitHub credentials flags: ${missing.join(', ')}`);
+                }
+                return { repo, token, branch };
+            }
+            case SourceType.GOOGLE_DOCS: {
+                const documentId = requireField(flags.gdocsDocumentId, '--gdocs-document-id');
+                const apiKey = optionalField(flags.gdocsApiKey);
+                const serviceAccountJson = optionalField(flags.gdocsServiceAccountJson);
+                if (missing.length > 0) {
+                    this.error(`Missing required Google Docs credentials flags: ${missing.join(', ')}`);
+                }
+                return { documentId, apiKey, serviceAccountJson };
+            }
+            default: {
+                const exhaustive = sourceType;
+                throw new Error(`Unsupported source type: ${exhaustive}`);
+            }
+        }
+    }
+}

package/dist/commands/assets/create.d.ts

@@ -0,0 +1,41 @@
+import { type Asset, AssetType, SourceType } from '../../services/asset.service.js';
+import { BaseAssetCommand } from './base.js';
+export default class AssetCreate extends BaseAssetCommand<typeof AssetCreate> {
+    static authenticate: boolean;
+    static description: string;
+    static examples: string[];
+    static flags: {
+        fromFile: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        type: import("@oclif/core/interfaces").OptionFlag<AssetType | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        sourceType: import("@oclif/core/interfaces").OptionFlag<SourceType | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        tag: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        hash: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        size: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        storjBucket: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        storjPath: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        storjToken: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        s3Bucket: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        s3Path: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        s3AccessKey: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        s3SecretKey: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        s3Region: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        s3Endpoint: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        dockerImage: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        dockerRegistry: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        dockerUsername: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        dockerPassword: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        githubRepo: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        githubToken: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        githubBranch: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        gdocsDocumentId: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        gdocsApiKey: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        gdocsServiceAccountJson: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<Asset>;
+    private loadAssetFromFile;
+    private promptAssetPayload;
+    private hasFlagPayload;
+    private buildPayloadFromFlags;
+    private parseEnumValue;
+}

package/dist/commands/assets/create.js

@@ -0,0 +1,277 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { select, text } from '@clack/prompts';
+import { Flags } from '@oclif/core';
+import { AssetType, SourceType, } from '../../services/asset.service.js';
+import { promptService } from '../../utils/prompt.service.js';
+import { BaseAssetCommand } from './base.js';
+const assetTypeOptions = Object.values(AssetType);
+const sourceTypeOptions = Object.values(SourceType);
+export default class AssetCreate extends BaseAssetCommand {
+    static authenticate = false;
+    static description = 'Create a new asset.';
+    static examples = [
+        '<%= config.bin %> assets create',
+        '<%= config.bin %> assets create --fromFile ./asset.json',
+        '<%= config.bin %> assets create --name "dataset-v1" --type data --sourceType s3 --s3Bucket b --s3Path p --s3AccessKey a --s3SecretKey s --s3Region us-east-1',
+    ];
+    static flags = {
+        fromFile: Flags.string({
+            char: 'f',
+            description: 'Path to a JSON file that contains asset definition.',
+        }),
+        name: Flags.string({
+            char: 'n',
+            description: 'Asset name',
+        }),
+        type: Flags.option({
+            char: 't',
+            description: 'Asset type',
+            options: assetTypeOptions,
+        })(),
+        sourceType: Flags.option({
+            char: 's',
+            description: 'Source type',
+            options: sourceTypeOptions,
+        })(),
+        tag: Flags.string({
+            description: 'Asset tag',
+        }),
+        hash: Flags.string({
+            description: 'Asset hash',
+        }),
+        size: Flags.string({
+            description: 'Asset size in bytes',
+        }),
+        storjBucket: Flags.string({
+            description: 'Storj bucket',
+        }),
+        storjPath: Flags.string({
+            description: 'Storj path',
+        }),
+        storjToken: Flags.string({
+            description: 'Storj access token',
+        }),
+        s3Bucket: Flags.string({
+            description: 'S3 bucket',
+        }),
+        s3Path: Flags.string({
+            description: 'S3 path',
+        }),
+        s3AccessKey: Flags.string({
+            description: 'S3 access key',
+        }),
+        s3SecretKey: Flags.string({
+            description: 'S3 secret key',
+        }),
+        s3Region: Flags.string({
+            description: 'S3 region',
+        }),
+        s3Endpoint: Flags.string({
+            description: 'S3 endpoint',
+        }),
+        dockerImage: Flags.string({
+            description: 'Docker image',
+        }),
+        dockerRegistry: Flags.string({
+            description: 'Docker registry',
+        }),
+        dockerUsername: Flags.string({
+            description: 'Docker username',
+        }),
+        dockerPassword: Flags.string({
+            description: 'Docker password',
+        }),
+        githubRepo: Flags.string({
+            description: 'GitHub repo (org/repo)',
+        }),
+        githubToken: Flags.string({
+            description: 'GitHub token',
+        }),
+        githubBranch: Flags.string({
+            description: 'GitHub branch',
+        }),
+        gdocsDocumentId: Flags.string({
+            description: 'Google Docs document ID',
+        }),
+        gdocsApiKey: Flags.string({
+            description: 'Google Docs API key',
+        }),
+        gdocsServiceAccountJson: Flags.string({
+            description: 'Google Docs service account JSON',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(AssetCreate);
+        const hasFlagPayload = this.hasFlagPayload(flags);
+        if (!flags.fromFile && !hasFlagPayload && !promptService.isInteractive) {
+            this.error('Provide --fromFile or required flags when running with --no-tty.');
+        }
+        let payload = flags.fromFile ? await this.loadAssetFromFile(flags.fromFile) : undefined;
+        if (hasFlagPayload) {
+            if (payload) {
+                const flagPayload = this.buildPayloadFromFlags(flags, {
+                    allowPartial: true,
+                    basePayload: payload,
+                });
+                payload = this.assetService.validateCreatePayload({ ...payload, ...flagPayload });
+            }
+            else {
+                payload = this.buildPayloadFromFlags(flags);
+            }
+        }
+        if (!payload) {
+            payload = await this.promptAssetPayload();
+        }
+        this.assertSourceTypeAllowed(payload.type, payload.sourceType);
+        try {
+            const asset = await this.assetService.createAsset(payload);
+            this.log(`Asset created: ${asset.id}`);
+            return asset;
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : String(error));
+        }
+    }
+    async loadAssetFromFile(filePath) {
+        const absolutePath = path.isAbsolute(filePath)
+            ? filePath
+            : path.join(this.currentDir, filePath);
+        try {
+            const fileContent = await fs.readFile(absolutePath, 'utf8');
+            const parsed = JSON.parse(fileContent);
+            return this.assetService.validateCreatePayload(parsed);
+        }
+        catch (error) {
+            this.error(`Failed to load asset definition: ${error instanceof Error ? error.message : String(error)}`);
+            throw error; // This will never execute, but helps TypeScript
+        }
+    }
+    async promptAssetPayload() {
+        const name = this.ensurePromptValue(await text({
+            message: 'Asset name',
+            validate(value) {
+                return value?.trim() ? undefined : 'Name is required';
+            },
+        })).trim();
+        const type = this.ensurePromptValue(await select({
+            message: 'Select asset type',
+            options: [
+                { label: 'Data', value: AssetType.DATA },
+                { label: 'Image', value: AssetType.IMAGE },
+                { label: 'Output', value: AssetType.OUTPUT },
+            ],
+        }));
+        const allowedSourceTypes = this.getAllowedSourceTypes(type);
+        const sourceTypeOptions = [
+            { label: 'StorJ', value: SourceType.STORJ },
+            { label: 'S3', value: SourceType.S3 },
+            { label: 'DockerHub', value: SourceType.DOCKERHUB },
+            { label: 'GitHub', value: SourceType.GITHUB },
+            { label: 'Google Docs', value: SourceType.GOOGLE_DOCS },
+        ].filter((option) => allowedSourceTypes.includes(option.value));
+        const sourceType = this.ensurePromptValue(await select({
+            message: 'Select source type',
+            options: sourceTypeOptions,
+        }));
+        const credentials = await this.promptCredentials(sourceType);
+        const tag = await this.promptOptionalText('Tag (optional)');
+        const hash = this.ensurePromptValue(await text({
+            message: 'Hash (optional)',
+        })).trim();
+        const sizeRaw = this.ensurePromptValue(await text({
+            message: 'Size in bytes (optional)',
+            validate(value) {
+                if (!value?.trim()) {
+                    return undefined;
+                }
+                const size = Number(value);
+                if (!Number.isFinite(size) || size < 0) {
+                    return 'Size must be a non-negative number';
+                }
+                return undefined;
+            },
+        }));
+        const size = this.parseSizeInput(sizeRaw);
+        const payload = {
+            credentials,
+            name,
+            sourceType,
+            type,
+            ...(tag ? { tag } : {}),
+            ...(hash ? { hash } : {}),
+            ...(size !== undefined ? { size } : {}),
+        };
+        return this.assetService.validateCreatePayload(payload);
+    }
+    hasFlagPayload(flags) {
+        return Boolean(flags.name ||
+            flags.type ||
+            flags.sourceType ||
+            flags.tag ||
+            flags.hash ||
+            flags.size ||
+            this.hasCredentialsFlags(flags));
+    }
+    buildPayloadFromFlags(flags, options) {
+        const allowPartial = options?.allowPartial ?? false;
+        const basePayload = options?.basePayload;
+        const missing = [];
+        const name = flags.name?.trim();
+        const rawType = flags.type?.trim();
+        const rawSourceType = flags.sourceType?.trim();
+        if (!allowPartial) {
+            if (!name) {
+                missing.push('--name');
+            }
+            if (!rawType) {
+                missing.push('--type');
+            }
+            if (!rawSourceType) {
+                missing.push('--sourceType');
+            }
+        }
+        if (missing.length > 0) {
+            this.error(`Missing required flags for asset creation: ${missing.join(', ')}`);
+        }
+        const payload = {};
+        if (name) {
+            payload.name = name;
+        }
+        if (rawType) {
+            payload.type = this.parseEnumValue(rawType, assetTypeOptions, 'type');
+        }
+        if (rawSourceType) {
+            payload.sourceType = this.parseEnumValue(rawSourceType, sourceTypeOptions, 'sourceType');
+        }
+        const hasCredentialFlags = this.hasCredentialsFlags(flags);
+        if (hasCredentialFlags) {
+            const effectiveSourceType = payload.sourceType ?? basePayload?.sourceType;
+            this.assertDefined(effectiveSourceType, 'Missing --sourceType for credentials overrides.');
+            payload.credentials = this.buildCredentialsFromFlags(effectiveSourceType, flags);
+        }
+        else if (!allowPartial) {
+            this.assertDefined(payload.sourceType, 'Missing --sourceType');
+            payload.credentials = this.buildCredentialsFromFlags(payload.sourceType, flags);
+        }
+        const tag = flags.tag?.trim();
+        const hash = flags.hash?.trim();
+        const size = flags.size !== undefined ? this.parseSizeInput(flags.size) : undefined;
+        if (tag) {
+            payload.tag = tag;
+        }
+        if (hash) {
+            payload.hash = hash;
+        }
+        if (size !== undefined) {
+            payload.size = size;
+        }
+        return allowPartial ? payload : this.assetService.validateCreatePayload(payload);
+    }
+    parseEnumValue(value, allowed, field) {
+        const normalized = value.trim().toLowerCase();
+        const match = allowed.find((candidate) => candidate.toLowerCase() === normalized);
+        this.assertDefined(match, `Invalid ${field}: ${value}. Allowed: ${allowed.join(', ')}`);
+        return match;
+    }
+}

package/dist/commands/assets/delete.d.ts

@@ -0,0 +1,14 @@
+import type { Asset } from '../../services/asset.service.js';
+import { BaseAssetCommand } from './base.js';
+export default class AssetDelete extends BaseAssetCommand<typeof AssetDelete> {
+    static authenticate: boolean;
+    static description: string;
+    static examples: string[];
+    static flags: {
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        id: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<Asset | undefined>;
+    private resolveAsset;
+}

package/dist/commands/assets/delete.js

@@ -0,0 +1,69 @@
+import { confirm, select } from '@clack/prompts';
+import { Flags } from '@oclif/core';
+import { BaseAssetCommand } from './base.js';
+export default class AssetDelete extends BaseAssetCommand {
+    static authenticate = false;
+    static description = 'Delete an asset.';
+    static examples = [
+        '<%= config.bin %> assets delete --id 11111111-1111-1111-1111-111111111111',
+        '<%= config.bin %> assets delete --name "dataset-v1" --force',
+    ];
+    static flags = {
+        force: Flags.boolean({
+            char: 'f',
+            default: false,
+            description: 'Delete without confirmation',
+        }),
+        id: Flags.string({
+            char: 'i',
+            description: 'Asset ID to delete',
+        }),
+        name: Flags.string({
+            char: 'n',
+            description: 'Asset name to delete',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(AssetDelete);
+        const asset = await this.resolveAsset(flags.id, flags.name);
+        this.assertDefined(asset, 'Asset not found');
+        if (!flags.force) {
+            const confirmed = this.ensurePromptValue(await confirm({
+                initialValue: false,
+                message: `Delete asset "${asset.name}" (${asset.id})?`,
+            }));
+            if (!confirmed) {
+                this.log('Deletion cancelled');
+                return;
+            }
+        }
+        try {
+            await this.assetService.deleteAsset(asset.id);
+            this.log(`Asset deleted: ${asset.id}`);
+            return asset;
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : String(error));
+        }
+    }
+    async resolveAsset(id, name) {
+        if (id) {
+            return this.assetService.findAssetById(id);
+        }
+        if (name) {
+            return this.assetService.findAssetByName(name);
+        }
+        const assets = await this.assetService.listAssets();
+        if (assets.length === 0) {
+            this.error('No assets available');
+        }
+        const selection = this.ensurePromptValue(await select({
+            message: 'Select asset to delete',
+            options: assets.map((asset) => ({
+                label: `${asset.name} (${asset.id})`,
+                value: asset.id,
+            })),
+        }));
+        return assets.find((asset) => asset.id === selection);
+    }
+}

package/dist/commands/assets/get.d.ts

@@ -0,0 +1,14 @@
+import type { Asset } from '../../services/asset.service.js';
+import { BaseAssetCommand } from './base.js';
+export default class AssetGet extends BaseAssetCommand<typeof AssetGet> {
+    static authenticate: boolean;
+    static description: string;
+    static examples: string[];
+    static flags: {
+        id: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<Asset>;
+    private resolveAsset;
+    private printAssetInfo;
+}