hereya-cli 0.83.2 → 0.84.1

package/dist/backend/cloud/cloud-backend.d.ts

@@ -6,6 +6,72 @@ interface CloudBackendConfig {
     refreshToken: string;
     url: string;
 }
+export interface AppSummary {
+    description?: null | string;
+    name: string;
+    visibility?: string;
+}
+export interface AppVersionSummary {
+    commit?: string;
+    publishedAt?: string;
+    repository?: string;
+    sha256?: string;
+    version: string;
+}
+export interface AppDeploymentSummary {
+    appName?: string;
+    env?: Record<string, string>;
+    lastJobId?: null | string;
+    parameters?: Record<string, unknown>;
+    state?: unknown;
+    status: string;
+    version?: string;
+    workspace: string;
+}
+export type DeployAppInput = {
+    hereyaVarsYaml?: string;
+    name: string;
+    parameters?: Record<string, string>;
+    version?: string;
+    workspace: string;
+};
+export type DestroyAppInput = {
+    name: string;
+    workspace: string;
+};
+export type GetAppDeploymentInput = {
+    name: string;
+    workspace: string;
+};
+export type PublishAppVersionInput = {
+    commit: string;
+    description?: string;
+    hereyaYaml: string;
+    name: string;
+    repository: string;
+    sha256: string;
+    version: string;
+    visibility?: 'private' | 'public';
+};
+export type PublishAppVersionOutput = {
+    app: {
+        id?: string;
+        name: string;
+        version: string;
+    };
+    success: true;
+} | {
+    reason: string;
+    success: false;
+};
+export type UpdateAppDeploymentInput = {
+    env?: Record<string, string>;
+    lastJobId?: string;
+    name: string;
+    state?: unknown;
+    status: string;
+    workspace: string;
+};
 export declare class CloudBackend implements Backend {
     private readonly config;
     constructor(config: CloudBackendConfig);
@@ -13,6 +79,21 @@ export declare class CloudBackend implements Backend {
     createWorkspace(input: CreateWorkspaceInput): Promise<CreateWorkspaceOutput>;
     deleteState(input: DeleteStateInput): Promise<DeleteStateOutput>;
     deleteWorkspace(input: DeleteWorkspaceInput): Promise<DeleteWorkspaceOutput>;
+    deployApp(input: DeployAppInput): Promise<{
+        deploymentId: string;
+        jobId: string;
+        success: true;
+    } | {
+        reason: string;
+        success: false;
+    }>;
+    destroyApp(input: DestroyAppInput): Promise<{
+        jobId: string;
+        success: true;
+    } | {
+        reason: string;
+        success: false;
+    }>;
     exportBackend(): Promise<ExportBackendOutput>;
     generateExecutorToken(input: {
         workspace: string;
@@ -24,6 +105,20 @@ export declare class CloudBackend implements Backend {
         reason: string;
         success: false;
     }>;
+    getApp(name: string): Promise<{
+        app: AppSummary;
+        success: true;
+    } | {
+        reason: string;
+        success: false;
+    }>;
+    getAppDeployment(input: GetAppDeploymentInput): Promise<{
+        deployment: AppDeploymentSummary;
+        success: true;
+    } | {
+        reason: string;
+        success: false;
+    }>;
     getExecutorJobStatus(input: {
         jobId: string;
         lastStatus?: string;
@@ -51,6 +146,27 @@ export declare class CloudBackend implements Backend {
     getWorkspaceEnv(input: GetWorkspaceEnvInput): Promise<GetWorkspaceEnvOutput>;
     importBackend(input: ImportBackendInput): Promise<ImportBackendOutput>;
     init(input: InitProjectInput): Promise<InitProjectOutput>;
+    listAppDeployments(name: string): Promise<{
+        deployments: AppDeploymentSummary[];
+        success: true;
+    } | {
+        reason: string;
+        success: false;
+    }>;
+    listApps(): Promise<{
+        apps: AppSummary[];
+        success: true;
+    } | {
+        reason: string;
+        success: false;
+    }>;
+    listAppVersions(name: string): Promise<{
+        reason: string;
+        success: false;
+    } | {
+        success: true;
+        versions: AppVersionSummary[];
+    }>;
     listPackageVersions(name: string): Promise<ListPackageVersionsOutput>;
     listProjects(): Promise<ListProjectsOutput>;
     listWorkspaces(input?: ListWorkspacesInput): Promise<string[]>;
@@ -69,6 +185,7 @@ export declare class CloudBackend implements Backend {
         success: false;
         unauthorized?: true;
     }>;
+    publishAppVersion(input: PublishAppVersionInput): Promise<PublishAppVersionOutput>;
     publishPackage(input: PublishPackageInput): Promise<PublishPackageOutput>;
     removePackageFromWorkspace(input: RemovePackageFromWorkspaceInput): Promise<RemovePackageFromWorkspaceOutput>;
     revokeExecutorToken(input: {
@@ -85,7 +202,7 @@ export declare class CloudBackend implements Backend {
     setEnvVar(input: SetEnvVarInput): Promise<SetEnvVarOutput>;
     submitExecutorJob(input: {
         payload: object;
-        type: 'deploy' | 'destroy' | 'provision' | 'resolve-env' | 'undeploy';
+        type: 'app-deploy' | 'app-destroy' | 'deploy' | 'destroy' | 'provision' | 'resolve-env' | 'undeploy';
         workspace: string;
     }): Promise<{
         jobId: string;
@@ -95,6 +212,12 @@ export declare class CloudBackend implements Backend {
         success: false;
     }>;
     unsetEnvVar(input: UnsetEnvVarInput): Promise<UnsetEnvVarOutput>;
+    updateAppDeployment(input: UpdateAppDeploymentInput): Promise<{
+        reason: string;
+        success: false;
+    } | {
+        success: true;
+    }>;
     updateExecutorJob(input: {
         jobId: string;
         logs?: string;

package/dist/backend/cloud/cloud-backend.js

@@ -101,6 +101,43 @@ export class CloudBackend {
             success: true,
         };
     }
+    async deployApp(input) {
+        const body = {
+            workspace: input.workspace,
+        };
+        if (input.version)
+            body.version = input.version;
+        if (input.parameters)
+            body.parameters = input.parameters;
+        if (input.hereyaVarsYaml !== undefined)
+            body.hereyaVarsYaml = input.hereyaVarsYaml;
+        const response = await fetch(`${this.config.url}/api/apps/${encodeURIComponent(input.name)}/deployments`, {
+            body: JSON.stringify(body),
+            headers: {
+                'Authorization': `Bearer ${this.config.accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            method: 'POST',
+        });
+        if (!response.ok) {
+            const error = await this.safeResponseJson(response);
+            return { reason: error.error || `Failed to deploy app (status ${response.status})`, success: false };
+        }
+        const result = await response.json();
+        return { deploymentId: result.deploymentId, jobId: result.jobId, success: true };
+    }
+    async destroyApp(input) {
+        const response = await fetch(`${this.config.url}/api/apps/${encodeURIComponent(input.name)}/deployments/${encodeURIComponent(input.workspace)}`, {
+            headers: { 'Authorization': `Bearer ${this.config.accessToken}` },
+            method: 'DELETE',
+        });
+        if (!response.ok) {
+            const error = await this.safeResponseJson(response);
+            return { reason: error.error || `Failed to destroy app (status ${response.status})`, success: false };
+        }
+        const result = await response.json();
+        return { jobId: result.jobId, success: true };
+    }
     async exportBackend() {
         const response = await fetch(`${this.config.url}/api/export`, {
             headers: {
@@ -138,6 +175,38 @@ export class CloudBackend {
         const result = await response.json();
         return { expiresAt: result.expiresAt, success: true, token: result.token };
     }
+    async getApp(name) {
+        const response = await fetch(`${this.config.url}/api/apps/${encodeURIComponent(name)}`, {
+            headers: { 'Authorization': `Bearer ${this.config.accessToken}` },
+            method: 'GET',
+        });
+        if (!response.ok) {
+            const error = await this.safeResponseJson(response);
+            let errorMessage = error.error || `Failed to get app (status ${response.status})`;
+            if (response.status === 404) {
+                errorMessage = `App '${name}' not found`;
+            }
+            return { reason: errorMessage, success: false };
+        }
+        const result = await response.json();
+        return { app: result.app, success: true };
+    }
+    async getAppDeployment(input) {
+        const response = await fetch(`${this.config.url}/api/apps/${encodeURIComponent(input.name)}/deployments/${encodeURIComponent(input.workspace)}`, {
+            headers: { 'Authorization': `Bearer ${this.config.accessToken}` },
+            method: 'GET',
+        });
+        if (!response.ok) {
+            const error = await this.safeResponseJson(response);
+            let errorMessage = error.error || `Failed to get app deployment (status ${response.status})`;
+            if (response.status === 404) {
+                errorMessage = `Deployment for app '${input.name}' on workspace '${input.workspace}' not found`;
+            }
+            return { reason: errorMessage, success: false };
+        }
+        const result = await response.json();
+        return { deployment: result.deployment, success: true };
+    }
     async getExecutorJobStatus(input) {
         const url = new URL(`${this.config.url}/api/workspaces/${encodeURIComponent(input.workspace)}/jobs/${encodeURIComponent(input.jobId)}`);
         if (input.poll) {
@@ -418,6 +487,42 @@ export class CloudBackend {
             },
         };
     }
+    async listAppDeployments(name) {
+        const response = await fetch(`${this.config.url}/api/apps/${encodeURIComponent(name)}/deployments`, {
+            headers: { 'Authorization': `Bearer ${this.config.accessToken}` },
+            method: 'GET',
+        });
+        if (!response.ok) {
+            const error = await this.safeResponseJson(response);
+            return { reason: error.error || `Failed to list app deployments (status ${response.status})`, success: false };
+        }
+        const result = await response.json();
+        return { deployments: result.deployments || [], success: true };
+    }
+    async listApps() {
+        const response = await fetch(`${this.config.url}/api/apps`, {
+            headers: { 'Authorization': `Bearer ${this.config.accessToken}` },
+            method: 'GET',
+        });
+        if (!response.ok) {
+            const error = await this.safeResponseJson(response);
+            return { reason: error.error || `Failed to list apps (status ${response.status})`, success: false };
+        }
+        const result = await response.json();
+        return { apps: result.apps || [], success: true };
+    }
+    async listAppVersions(name) {
+        const response = await fetch(`${this.config.url}/api/apps/${encodeURIComponent(name)}/versions`, {
+            headers: { 'Authorization': `Bearer ${this.config.accessToken}` },
+            method: 'GET',
+        });
+        if (!response.ok) {
+            const error = await this.safeResponseJson(response);
+            return { reason: error.error || `Failed to list app versions (status ${response.status})`, success: false };
+        }
+        const result = await response.json();
+        return { success: true, versions: result.versions || [] };
+    }
     async listPackageVersions(name) {
         const response = await fetch(`${this.config.url}/api/registry/packages/${encodeURIComponent(name)}?versions=all`, {
             headers: {
@@ -504,6 +609,55 @@ export class CloudBackend {
         const result = await response.json();
         return { job: result.job, success: true };
     }
+    async publishAppVersion(input) {
+        const requestBody = {
+            commit: input.commit,
+            hereyaYaml: input.hereyaYaml,
+            repository: input.repository,
+            sha256: input.sha256,
+            version: input.version,
+        };
+        if (input.description !== undefined)
+            requestBody.description = input.description;
+        if (input.visibility !== undefined)
+            requestBody.visibility = input.visibility;
+        const response = await fetch(`${this.config.url}/api/apps/${encodeURIComponent(input.name)}/versions`, {
+            body: JSON.stringify(requestBody),
+            headers: {
+                'Authorization': `Bearer ${this.config.accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            method: 'POST',
+        });
+        const result = await this.safeResponseJson(response);
+        if (!response.ok) {
+            let errorMessage = result.error || 'Failed to publish app version';
+            switch (response.status) {
+                case 401: {
+                    errorMessage = 'Authentication failed. Please run `hereya login` to refresh your credentials.';
+                    break;
+                }
+                case 403: {
+                    errorMessage = `Permission denied: ${errorMessage}`;
+                    break;
+                }
+                case 409: {
+                    errorMessage = `Conflict: ${errorMessage}`;
+                    break;
+                }
+            }
+            return { reason: errorMessage, success: false };
+        }
+        const app = result.appVersion ?? result.app ?? { name: input.name, version: input.version };
+        return {
+            app: {
+                id: app.id,
+                name: app.name ?? input.name,
+                version: app.version ?? input.version,
+            },
+            success: true,
+        };
+    }
     async publishPackage(input) {
         const formData = new FormData();
         formData.append('name', input.name);
@@ -782,6 +936,28 @@ export class CloudBackend {
             success: true,
         };
     }
+    async updateAppDeployment(input) {
+        const body = { status: input.status };
+        if (input.state !== undefined)
+            body.state = input.state;
+        if (input.env !== undefined)
+            body.env = input.env;
+        if (input.lastJobId !== undefined)
+            body.lastJobId = input.lastJobId;
+        const response = await fetch(`${this.config.url}/api/apps/${encodeURIComponent(input.name)}/deployments/${encodeURIComponent(input.workspace)}`, {
+            body: JSON.stringify(body),
+            headers: {
+                'Authorization': `Bearer ${this.config.accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            method: 'PATCH',
+        });
+        if (!response.ok) {
+            const error = await this.safeResponseJson(response);
+            return { reason: error.error || `Failed to update app deployment (status ${response.status})`, success: false };
+        }
+        return { success: true };
+    }
     async updateExecutorJob(input) {
         const formData = new FormData();
         if (input.logs) {

package/dist/commands/app/deploy/index.d.ts

@@ -0,0 +1,16 @@
+import { Command } from '@oclif/core';
+export default class AppDeploy extends Command {
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        parameter: import("@oclif/core/interfaces").OptionFlag<string[], import("@oclif/core/interfaces").CustomOptions>;
+        vars: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'vars-file': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        version: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        workspace: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/app/deploy/index.js

@@ -0,0 +1,113 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { ListrLogger, ListrLogLevels } from 'listr2';
+import fs from 'node:fs/promises';
+import { CloudBackend } from '../../../backend/cloud/cloud-backend.js';
+import { getBackend } from '../../../backend/index.js';
+import { arrayOfStringToObject } from '../../../lib/object-utils.js';
+import { pollExecutorJob } from '../../../lib/remote-job-utils.js';
+export default class AppDeploy extends Command {
+    static args = {
+        name: Args.string({ description: 'app name in org/name format', required: true }),
+    };
+    static description = 'Deploy a hereya-app to a workspace.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my-org/my-app -w my-workspace',
+        '<%= config.bin %> <%= command.id %> my-org/my-app -w prod --version 1.2.0',
+        '<%= config.bin %> <%= command.id %> my-org/my-app -w prod -V \'app.yaml: "key: value"\'',
+        '<%= config.bin %> <%= command.id %> my-org/my-app -w prod --vars-file ./hereyavars.yaml',
+    ];
+    static flags = {
+        parameter: Flags.string({
+            char: 'p',
+            default: [],
+            description: 'parameter for the app deployment, in the form of key=value (repeatable)',
+            multiple: true,
+        }),
+        vars: Flags.string({
+            char: 'V',
+            description: 'YAML string mapping hereyavars filename -> YAML body (mutually exclusive with --vars-file)',
+            exclusive: ['vars-file'],
+        }),
+        'vars-file': Flags.string({
+            description: 'path to a YAML file mapping hereyavars filename -> YAML body (mutually exclusive with --vars)',
+            exclusive: ['vars'],
+        }),
+        version: Flags.string({
+            description: 'specific app version to deploy (defaults to latest)',
+        }),
+        workspace: Flags.string({
+            char: 'w',
+            description: 'name of the workspace to deploy the app to',
+            required: true,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(AppDeploy);
+        const backend = await getBackend();
+        if (!(backend instanceof CloudBackend)) {
+            this.error('App deployment requires the cloud backend. Run `hereya login` first.');
+        }
+        const cloudBackend = backend;
+        const myLogger = new ListrLogger({ useIcons: false });
+        // Parse parameters
+        const parameters = arrayOfStringToObject(flags.parameter);
+        // Resolve hereyaVarsYaml
+        let hereyaVarsYaml;
+        if (flags.vars && flags['vars-file']) {
+            this.error('Cannot use both --vars and --vars-file at the same time.');
+        }
+        else if (flags.vars) {
+            hereyaVarsYaml = flags.vars;
+        }
+        else if (flags['vars-file']) {
+            try {
+                hereyaVarsYaml = await fs.readFile(flags['vars-file'], 'utf8');
+            }
+            catch (error) {
+                this.error(`Failed to read vars file ${flags['vars-file']}: ${error.message}`);
+            }
+        }
+        myLogger.log(ListrLogLevels.STARTED, `Deploying ${args.name}${flags.version ? `@${flags.version}` : ''} to workspace ${flags.workspace}...`);
+        const deployResult = await cloudBackend.deployApp({
+            hereyaVarsYaml,
+            name: args.name,
+            parameters: Object.keys(parameters).length > 0 ? parameters : undefined,
+            version: flags.version,
+            workspace: flags.workspace,
+        });
+        if (!deployResult.success) {
+            this.error(`Failed to deploy app: ${deployResult.reason}`);
+        }
+        myLogger.log(ListrLogLevels.COMPLETED, `Deployment ${deployResult.deploymentId} created. Job: ${deployResult.jobId}`);
+        // Poll for results
+        const logger = {
+            debug: (msg) => myLogger.log(ListrLogLevels.OUTPUT, msg),
+            error: (msg) => myLogger.log(ListrLogLevels.OUTPUT, msg),
+            info: (msg) => myLogger.log(ListrLogLevels.OUTPUT, msg),
+        };
+        const pollResult = await pollExecutorJob({
+            cloudBackend,
+            jobId: deployResult.jobId,
+            logger,
+            workspace: flags.workspace,
+        });
+        if (!pollResult.success) {
+            this.error(pollResult.reason);
+        }
+        myLogger.log(ListrLogLevels.COMPLETED, `App ${args.name} deployed to ${flags.workspace}`);
+        // Print final state
+        const status = await cloudBackend.getAppDeployment({ name: args.name, workspace: flags.workspace });
+        if (status.success) {
+            this.log(`\nStatus: ${status.deployment.status}`);
+            if (status.deployment.version) {
+                this.log(`Version: ${status.deployment.version}`);
+            }
+            if (status.deployment.env && Object.keys(status.deployment.env).length > 0) {
+                this.log('\nEnv outputs:');
+                for (const [key, value] of Object.entries(status.deployment.env)) {
+                    this.log(`  ${key}=${value}`);
+                }
+            }
+        }
+    }
+}

package/dist/commands/app/deployments/index.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class AppDeployments extends Command {
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/app/deployments/index.js

@@ -0,0 +1,34 @@
+import { Args, Command } from '@oclif/core';
+import { CloudBackend } from '../../../backend/cloud/cloud-backend.js';
+import { getBackend } from '../../../backend/index.js';
+export default class AppDeployments extends Command {
+    static args = {
+        name: Args.string({ description: 'app name in org/name format', required: true }),
+    };
+    static description = 'List workspaces a hereya-app has been deployed to.';
+    static examples = ['<%= config.bin %> <%= command.id %> my-org/my-app'];
+    async run() {
+        const { args } = await this.parse(AppDeployments);
+        const backend = await getBackend();
+        if (!(backend instanceof CloudBackend)) {
+            this.error('Listing app deployments requires the cloud backend. Run `hereya login` first.');
+        }
+        const cloudBackend = backend;
+        const result = await cloudBackend.listAppDeployments(args.name);
+        if (!result.success) {
+            this.error(`Failed to list deployments: ${result.reason}`);
+        }
+        if (result.deployments.length === 0) {
+            this.log(`No deployments found for app ${args.name}.`);
+            return;
+        }
+        const wsWidth = Math.max(9, ...result.deployments.map((d) => d.workspace.length));
+        const versionWidth = Math.max(7, ...result.deployments.map((d) => (d.version ?? '').length));
+        const statusWidth = Math.max(6, ...result.deployments.map((d) => d.status.length));
+        this.log(`${'Workspace'.padEnd(wsWidth)}  ${'Version'.padEnd(versionWidth)}  ${'Status'.padEnd(statusWidth)}`);
+        this.log('-'.repeat(wsWidth + versionWidth + statusWidth + 4));
+        for (const deployment of result.deployments) {
+            this.log(`${deployment.workspace.padEnd(wsWidth)}  ${(deployment.version ?? '').padEnd(versionWidth)}  ${deployment.status.padEnd(statusWidth)}`);
+        }
+    }
+}

package/dist/commands/app/destroy/index.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/core';
+export default class AppDestroy extends Command {
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        workspace: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/app/destroy/index.js

@@ -0,0 +1,52 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { ListrLogger, ListrLogLevels } from 'listr2';
+import { CloudBackend } from '../../../backend/cloud/cloud-backend.js';
+import { getBackend } from '../../../backend/index.js';
+import { pollExecutorJob } from '../../../lib/remote-job-utils.js';
+export default class AppDestroy extends Command {
+    static args = {
+        name: Args.string({ description: 'app name in org/name format', required: true }),
+    };
+    static description = 'Destroy a hereya-app deployment from a workspace.';
+    static examples = ['<%= config.bin %> <%= command.id %> my-org/my-app -w my-workspace'];
+    static flags = {
+        workspace: Flags.string({
+            char: 'w',
+            description: 'workspace where the app is currently deployed',
+            required: true,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(AppDestroy);
+        const backend = await getBackend();
+        if (!(backend instanceof CloudBackend)) {
+            this.error('App destroy requires the cloud backend. Run `hereya login` first.');
+        }
+        const cloudBackend = backend;
+        const myLogger = new ListrLogger({ useIcons: false });
+        myLogger.log(ListrLogLevels.STARTED, `Destroying ${args.name} on workspace ${flags.workspace}...`);
+        const destroyResult = await cloudBackend.destroyApp({
+            name: args.name,
+            workspace: flags.workspace,
+        });
+        if (!destroyResult.success) {
+            this.error(`Failed to destroy app: ${destroyResult.reason}`);
+        }
+        myLogger.log(ListrLogLevels.COMPLETED, `Destroy job submitted: ${destroyResult.jobId}`);
+        const logger = {
+            debug: (msg) => myLogger.log(ListrLogLevels.OUTPUT, msg),
+            error: (msg) => myLogger.log(ListrLogLevels.OUTPUT, msg),
+            info: (msg) => myLogger.log(ListrLogLevels.OUTPUT, msg),
+        };
+        const pollResult = await pollExecutorJob({
+            cloudBackend,
+            jobId: destroyResult.jobId,
+            logger,
+            workspace: flags.workspace,
+        });
+        if (!pollResult.success) {
+            this.error(pollResult.reason);
+        }
+        myLogger.log(ListrLogLevels.COMPLETED, `App ${args.name} destroyed from ${flags.workspace}`);
+    }
+}

package/dist/commands/app/env/index.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+export default class AppEnv extends Command {
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        key: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        workspace: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}