hereya-cli 0.83.2 → 0.84.1

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

@@ -0,0 +1,50 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { CloudBackend } from '../../../backend/cloud/cloud-backend.js';
+import { getBackend } from '../../../backend/index.js';
+export default class AppEnv extends Command {
+    static args = {
+        name: Args.string({ description: 'app name in org/name format', required: true }),
+        // eslint-disable-next-line perfectionist/sort-objects
+        key: Args.string({ description: 'optional env var key to print (omit to print all)', required: false }),
+    };
+    static description = 'Print environment variables exported by a hereya-app deployment.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my-org/my-app -w my-workspace',
+        '<%= config.bin %> <%= command.id %> my-org/my-app -w my-workspace DATABASE_URL',
+    ];
+    static flags = {
+        workspace: Flags.string({
+            char: 'w',
+            description: 'workspace to read env outputs from',
+            required: true,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(AppEnv);
+        const backend = await getBackend();
+        if (!(backend instanceof CloudBackend)) {
+            this.error('App env requires the cloud backend. Run `hereya login` first.');
+        }
+        const cloudBackend = backend;
+        const result = await cloudBackend.getAppDeployment({ name: args.name, workspace: flags.workspace });
+        if (!result.success) {
+            this.error(result.reason);
+        }
+        const env = result.deployment.env ?? {};
+        if (args.key) {
+            const value = env[args.key];
+            if (value === undefined) {
+                this.error(`Env var ${args.key} not found in deployment ${args.name}/${flags.workspace}`);
+            }
+            this.log(value);
+            return;
+        }
+        if (Object.keys(env).length === 0) {
+            this.log('(no env outputs)');
+            return;
+        }
+        for (const [key, value] of Object.entries(env)) {
+            this.log(`${key}=${value}`);
+        }
+    }
+}

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

@@ -0,0 +1,6 @@
+import { Command } from '@oclif/core';
+export default class AppList extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,30 @@
+import { Command } from '@oclif/core';
+import { CloudBackend } from '../../../backend/cloud/cloud-backend.js';
+import { getBackend } from '../../../backend/index.js';
+export default class AppList extends Command {
+    static description = 'List hereya-apps available to your account.';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    async run() {
+        const backend = await getBackend();
+        if (!(backend instanceof CloudBackend)) {
+            this.error('Listing apps requires the cloud backend. Run `hereya login` first.');
+        }
+        const cloudBackend = backend;
+        const result = await cloudBackend.listApps();
+        if (!result.success) {
+            this.error(`Failed to list apps: ${result.reason}`);
+        }
+        if (result.apps.length === 0) {
+            this.log('No apps found.');
+            return;
+        }
+        const nameWidth = Math.max(4, ...result.apps.map((a) => a.name.length));
+        const visibilityWidth = Math.max(10, ...result.apps.map((a) => (a.visibility ?? '').length));
+        this.log(`${'Name'.padEnd(nameWidth)}  ${'Visibility'.padEnd(visibilityWidth)}  Description`);
+        this.log('-'.repeat(nameWidth + visibilityWidth + 14));
+        for (const app of result.apps) {
+            const visibility = (app.visibility ?? '').padEnd(visibilityWidth);
+            this.log(`${app.name.padEnd(nameWidth)}  ${visibility}  ${app.description ?? ''}`);
+        }
+    }
+}

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

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

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

@@ -0,0 +1,69 @@
+import { Args, Command, Flags } from '@oclif/core';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export default class AppNew extends Command {
+    static args = {
+        dirname: Args.string({ description: 'directory to create the app skeleton in', required: true }),
+    };
+    static description = 'Scaffold a new hereya-app directory with starter hereyarc.yaml + hereya.yaml.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> ./my-app -n my-org/my-app',
+        '<%= config.bin %> <%= command.id %> ./my-app -n my-org/my-app --description "An ai-app-builder app"',
+    ];
+    static flags = {
+        description: Flags.string({
+            description: 'description of the app',
+            required: false,
+        }),
+        name: Flags.string({
+            char: 'n',
+            description: 'app name in org/name format (e.g. my-org/my-app)',
+            required: true,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(AppNew);
+        const targetDir = path.resolve(args.dirname);
+        // Validate name format: org/name
+        if (!/^[\w.-]+\/[\w.-]+$/.test(flags.name)) {
+            this.error(`Invalid app name '${flags.name}'. Use the format org/name (e.g. my-org/my-app).`);
+        }
+        // Refuse if target dir exists and is non-empty.
+        try {
+            const entries = await fs.readdir(targetDir);
+            if (entries.length > 0) {
+                this.error(`Directory ${targetDir} already exists and is not empty.`);
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                this.error(`Failed to inspect directory ${targetDir}: ${error.message}`);
+            }
+            // ENOENT is fine — we'll create it below.
+        }
+        await fs.mkdir(targetDir, { recursive: true });
+        const hereyarcLines = [
+            `name: ${flags.name}`,
+            'version: 0.1.0',
+            'kind: app',
+            'visibility: private',
+        ];
+        if (flags.description) {
+            hereyarcLines.splice(2, 0, `description: ${JSON.stringify(flags.description)}`);
+        }
+        const hereyarcContent = hereyarcLines.join('\n') + '\n';
+        const hereyaYamlContent = [
+            '# packages provisioned with this app deployment.',
+            'packages: []',
+            '',
+            '# packages run after `packages:` and have access to the merged workspace env.',
+            'deployPackages: []',
+            '',
+        ].join('\n');
+        await fs.writeFile(path.join(targetDir, 'hereyarc.yaml'), hereyarcContent, { encoding: 'utf8' });
+        await fs.writeFile(path.join(targetDir, 'hereya.yaml'), hereyaYamlContent, { encoding: 'utf8' });
+        this.log(`Created app skeleton at ${targetDir}`);
+        this.log(`  - hereyarc.yaml (${flags.name}@0.1.0, kind: app)`);
+        this.log('  - hereya.yaml (empty packages/deployPackages)');
+    }
+}

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

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/core';
+export default class AppStatus 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/status/index.js

@@ -0,0 +1,51 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { CloudBackend } from '../../../backend/cloud/cloud-backend.js';
+import { getBackend } from '../../../backend/index.js';
+export default class AppStatus extends Command {
+    static args = {
+        name: Args.string({ description: 'app name in org/name format', required: true }),
+    };
+    static description = 'Show the deployment status of a hereya-app on a workspace.';
+    static examples = ['<%= config.bin %> <%= command.id %> my-org/my-app -w my-workspace'];
+    static flags = {
+        workspace: Flags.string({
+            char: 'w',
+            description: 'workspace to read deployment status from',
+            required: true,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(AppStatus);
+        const backend = await getBackend();
+        if (!(backend instanceof CloudBackend)) {
+            this.error('App status requires the cloud backend. Run `hereya login` first.');
+        }
+        const cloudBackend = backend;
+        const result = await cloudBackend.getAppDeployment({ name: args.name, workspace: flags.workspace });
+        if (!result.success) {
+            this.error(result.reason);
+        }
+        const { deployment } = result;
+        this.log(`App:        ${args.name}`);
+        this.log(`Workspace:  ${deployment.workspace}`);
+        this.log(`Status:     ${deployment.status}`);
+        if (deployment.version) {
+            this.log(`Version:    ${deployment.version}`);
+        }
+        if (deployment.lastJobId) {
+            this.log(`Last Job:   ${deployment.lastJobId}`);
+        }
+        if (deployment.parameters && Object.keys(deployment.parameters).length > 0) {
+            this.log('\nParameters:');
+            for (const [key, value] of Object.entries(deployment.parameters)) {
+                this.log(`  ${key}=${typeof value === 'string' ? value : JSON.stringify(value)}`);
+            }
+        }
+        if (deployment.env && Object.keys(deployment.env).length > 0) {
+            this.log('\nEnv outputs:');
+            for (const [key, value] of Object.entries(deployment.env)) {
+                this.log(`  ${key}=${value}`);
+            }
+        }
+    }
+}

package/dist/commands/executor/start/index.d.ts

@@ -1,4 +1,14 @@
 import { Command } from '@oclif/core';
+import { destroyPackage, provisionPackage } from '../../../infrastructure/index.js';
+/**
+ * Indirection for testability: tests can stub `appPackageOps.provisionPackage`
+ * and `appPackageOps.destroyPackage` to assert call shape without going through
+ * the real infrastructure layer.
+ */
+export declare const appPackageOps: {
+    destroyPackage: typeof destroyPackage;
+    provisionPackage: typeof provisionPackage;
+};
 /**
  * Strip credentials from log strings before flushing them to the cloud.
  * Removes:
@@ -14,7 +24,10 @@ export default class ExecutorStart extends Command {
         workspace: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
+    private executeAppDeployJob;
+    private executeAppDestroyJob;
     private executeDeployJob;
     private executeInitJob;
     private executeJob;
+    private markAppDeploymentFailed;
 }

package/dist/commands/executor/start/index.js

@@ -3,14 +3,79 @@ import { randomUUID } from 'node:crypto';
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
+import * as yaml from 'yaml';
 import { CloudBackend } from '../../../backend/cloud/cloud-backend.js';
 import { loginWithToken } from '../../../backend/cloud/login.js';
 import { saveCloudCredentials } from '../../../backend/config.js';
 import { clearBackend, getBackend } from '../../../backend/index.js';
 import { LocalExecutor } from '../../../executor/local.js';
+import { destroyPackage, provisionPackage } from '../../../infrastructure/index.js';
+import * as appSourceLib from '../../../lib/app-source.js';
+import { applyHereyaVars } from '../../../lib/app-vars.js';
 import { SimpleConfigManager } from '../../../lib/config/simple.js';
 import { cloneWithCredentialHelper, gitUtils } from '../../../lib/git-utils.js';
 import { runShell, shellUtils } from '../../../lib/shell.js';
+/**
+ * Indirection for testability: tests can stub `appPackageOps.provisionPackage`
+ * and `appPackageOps.destroyPackage` to assert call shape without going through
+ * the real infrastructure layer.
+ */
+export const appPackageOps = {
+    destroyPackage,
+    provisionPackage,
+};
+async function getAnyExisting(...candidates) {
+    for (const candidate of candidates) {
+        try {
+            // eslint-disable-next-line no-await-in-loop
+            await fs.access(candidate);
+            return candidate;
+        }
+        catch {
+            // try next
+        }
+    }
+    return undefined;
+}
+function normalizePackageList(raw) {
+    if (!raw)
+        return [];
+    if (Array.isArray(raw)) {
+        return raw
+            .filter((entry) => typeof entry === 'string' && entry.length > 0)
+            .map((entry) => {
+            const [name, version] = entry.split('@');
+            return {
+                name,
+                spec: entry,
+                version,
+            };
+        });
+    }
+    if (typeof raw === 'object') {
+        return Object.entries(raw).map(([name, info]) => {
+            const version = info?.version;
+            return {
+                name,
+                spec: version ? `${name}@${version}` : name,
+                version,
+            };
+        });
+    }
+    return [];
+}
+async function runPreDeployCommand(input) {
+    if (!input.command)
+        return { success: true };
+    try {
+        input.logger.info('Running pre-deploy command...');
+        await runShell(input.command, [], { directory: input.directory, logger: input.logger });
+        return { success: true };
+    }
+    catch (error) {
+        return { reason: `pre-deploy command failed: ${error.message}`, success: false };
+    }
+}
 /**
  * Strip credentials from log strings before flushing them to the cloud.
  * Removes:
@@ -156,6 +221,228 @@ Set the HEREYA_CLOUD_URL environment variable to target a specific hereya cloud
         }
         this.log('Executor stopped.');
     }
+    async executeAppDeployJob(job, cloudBackend, logger) {
+        const payload = job.payload;
+        const { appName, commit, hereyaVarsYaml, parameters, repository, sha256, version, workspace } = payload;
+        if (!appName || !workspace || !repository) {
+            return {
+                reason: 'Missing appName, workspace, or repository in app-deploy job payload',
+                success: false,
+            };
+        }
+        let cleanup;
+        try {
+            logger.info(`Downloading app source ${repository}${commit ? `@${commit}` : ''}...`);
+            const downloadResult = await appSourceLib.appSource.download({ commit, logger, repository, sha256 });
+            cleanup = downloadResult.cleanup;
+            const { rootDir } = downloadResult;
+            // Apply hereyavars overrides
+            try {
+                const { filesWritten } = await applyHereyaVars(rootDir, hereyaVarsYaml);
+                if (filesWritten.length > 0) {
+                    logger.info(`Wrote ${filesWritten.length} hereyavars override file(s).`);
+                }
+            }
+            catch (error) {
+                await this.markAppDeploymentFailed({ appName, jobId: job.id, reason: error.message, workspace }, cloudBackend);
+                return { reason: `Failed to apply hereyavars overrides: ${error.message}`, success: false };
+            }
+            // Read hereya.yaml from app source
+            const hereyaYamlPath = await getAnyExisting(path.join(rootDir, 'hereya.yaml'), path.join(rootDir, 'hereya.yml'));
+            if (!hereyaYamlPath) {
+                await this.markAppDeploymentFailed({ appName, jobId: job.id, reason: 'Missing hereya.yaml', workspace }, cloudBackend);
+                return { reason: 'App source does not contain a hereya.yaml file', success: false };
+            }
+            const hereyaYamlContent = await fs.readFile(hereyaYamlPath, 'utf8');
+            const parsedHereyaYaml = (yaml.parse(hereyaYamlContent) ?? {});
+            // Build package lists
+            const packages = normalizePackageList(parsedHereyaYaml.packages);
+            const deployPackages = normalizePackageList(parsedHereyaYaml.deployPackages ?? parsedHereyaYaml.deploy);
+            // Resolve workspace env (used as projectEnv for deploy-marked packages)
+            const workspaceEnvResult = await cloudBackend.getWorkspaceEnv({ workspace });
+            const workspaceEnv = workspaceEnvResult.success ? workspaceEnvResult.env : {};
+            // Mark deployment as deploying
+            await cloudBackend.updateAppDeployment({
+                lastJobId: job.id,
+                name: appName,
+                status: 'deploying',
+                workspace,
+            });
+            const preDeployResult = await runPreDeployCommand({
+                command: parsedHereyaYaml.preDeployCommand,
+                directory: rootDir,
+                logger,
+            });
+            if (!preDeployResult.success) {
+                await this.markAppDeploymentFailed({ appName, jobId: job.id, reason: preDeployResult.reason, workspace }, cloudBackend);
+                return { reason: preDeployResult.reason, success: false };
+            }
+            const mergedEnv = {};
+            // 1) Provision regular packages
+            /* eslint-disable no-await-in-loop */
+            for (const pkg of packages) {
+                const result = await appPackageOps.provisionPackage({
+                    isDeploying: true,
+                    logger,
+                    package: pkg.spec,
+                    parameters,
+                    projectRootDir: rootDir,
+                    workspace,
+                });
+                if (!result.success) {
+                    await this.markAppDeploymentFailed({ appName, jobId: job.id, reason: result.reason, workspace }, cloudBackend);
+                    return { reason: `Failed to provision package ${pkg.name}: ${result.reason}`, success: false };
+                }
+                Object.assign(mergedEnv, result.env);
+            }
+            // 2) Provision deploy packages — these get workspace env merged in
+            for (const pkg of deployPackages) {
+                const result = await appPackageOps.provisionPackage({
+                    isDeploying: true,
+                    logger,
+                    package: pkg.spec,
+                    parameters,
+                    projectEnv: { ...workspaceEnv, ...mergedEnv },
+                    projectRootDir: rootDir,
+                    workspace,
+                });
+                if (!result.success) {
+                    await this.markAppDeploymentFailed({ appName, jobId: job.id, reason: result.reason, workspace }, cloudBackend);
+                    return { reason: `Failed to provision deploy package ${pkg.name}: ${result.reason}`, success: false };
+                }
+                Object.assign(mergedEnv, result.env);
+            }
+            /* eslint-enable no-await-in-loop */
+            // 3) PATCH AppDeployment with final state
+            const updateResult = await cloudBackend.updateAppDeployment({
+                env: mergedEnv,
+                lastJobId: job.id,
+                name: appName,
+                state: {
+                    deployPackages: deployPackages.map((p) => ({ name: p.name, version: p.version })),
+                    packages: packages.map((p) => ({ name: p.name, version: p.version })),
+                    version,
+                },
+                status: 'deployed',
+                workspace,
+            });
+            if (!updateResult.success) {
+                return { reason: `Provisioning succeeded but PATCH to deployment failed: ${updateResult.reason}`, success: false };
+            }
+            return { success: true };
+        }
+        catch (error) {
+            try {
+                await this.markAppDeploymentFailed({ appName, jobId: job.id, reason: error.message, workspace }, cloudBackend);
+            }
+            catch {
+                // best-effort
+            }
+            return { reason: `app-deploy failed: ${error.message}`, success: false };
+        }
+        finally {
+            if (cleanup) {
+                await cleanup();
+            }
+        }
+    }
+    async executeAppDestroyJob(job, cloudBackend, logger) {
+        const payload = job.payload;
+        const { appName, commit, hereyaVarsYaml, parameters, repository, sha256, workspace } = payload;
+        if (!appName || !workspace || !repository) {
+            return {
+                reason: 'Missing appName, workspace, or repository in app-destroy job payload',
+                success: false,
+            };
+        }
+        let cleanup;
+        try {
+            logger.info(`Downloading app source for destroy: ${repository}${commit ? `@${commit}` : ''}...`);
+            const downloadResult = await appSourceLib.appSource.download({ commit, logger, repository, sha256 });
+            cleanup = downloadResult.cleanup;
+            const { rootDir } = downloadResult;
+            // Apply hereyavars overrides — destroy needs the same vars to drive Terraform.
+            try {
+                await applyHereyaVars(rootDir, hereyaVarsYaml);
+            }
+            catch (error) {
+                return { reason: `Failed to apply hereyavars overrides: ${error.message}`, success: false };
+            }
+            const hereyaYamlPath = await getAnyExisting(path.join(rootDir, 'hereya.yaml'), path.join(rootDir, 'hereya.yml'));
+            if (!hereyaYamlPath) {
+                return { reason: 'App source does not contain a hereya.yaml file', success: false };
+            }
+            const parsedHereyaYaml = (yaml.parse(await fs.readFile(hereyaYamlPath, 'utf8')) ?? {});
+            const packages = normalizePackageList(parsedHereyaYaml.packages);
+            const deployPackages = normalizePackageList(parsedHereyaYaml.deployPackages ?? parsedHereyaYaml.deploy);
+            // Mark deployment as destroying
+            await cloudBackend.updateAppDeployment({
+                lastJobId: job.id,
+                name: appName,
+                status: 'destroying',
+                workspace,
+            });
+            const preDeployResult = await runPreDeployCommand({
+                command: parsedHereyaYaml.preDeployCommand,
+                directory: rootDir,
+                logger,
+            });
+            if (!preDeployResult.success) {
+                await cloudBackend.updateAppDeployment({
+                    lastJobId: job.id,
+                    name: appName,
+                    status: 'failed',
+                    workspace,
+                });
+                return { reason: preDeployResult.reason, success: false };
+            }
+            // Iterate in REVERSE: deploy packages first (depend on regular pkgs), then regular pkgs.
+            const reversed = [...deployPackages.reverse(), ...packages.reverse()];
+            const workspaceEnvResult = await cloudBackend.getWorkspaceEnv({ workspace });
+            const workspaceEnv = workspaceEnvResult.success ? workspaceEnvResult.env : {};
+            /* eslint-disable no-await-in-loop */
+            for (const pkg of reversed) {
+                const result = await appPackageOps.destroyPackage({
+                    isDeploying: true,
+                    logger,
+                    package: pkg.spec,
+                    parameters,
+                    projectEnv: workspaceEnv,
+                    projectRootDir: rootDir,
+                    workspace,
+                });
+                if (!result.success) {
+                    await cloudBackend.updateAppDeployment({
+                        lastJobId: job.id,
+                        name: appName,
+                        status: 'failed',
+                        workspace,
+                    });
+                    return { reason: `Failed to destroy package ${pkg.name}: ${result.reason}`, success: false };
+                }
+            }
+            /* eslint-enable no-await-in-loop */
+            const updateResult = await cloudBackend.updateAppDeployment({
+                env: {},
+                lastJobId: job.id,
+                name: appName,
+                status: 'destroyed',
+                workspace,
+            });
+            if (!updateResult.success) {
+                return { reason: `Destroy succeeded but PATCH to deployment failed: ${updateResult.reason}`, success: false };
+            }
+            return { success: true };
+        }
+        catch (error) {
+            return { reason: `app-destroy failed: ${error.message}`, success: false };
+        }
+        finally {
+            if (cleanup) {
+                await cleanup();
+            }
+        }
+    }
     async executeDeployJob(job, executor, cloudBackend, logger) {
         const { gitBranch, project, workspace } = job.payload;
         if (!project || !workspace) {
@@ -418,6 +705,32 @@ Set the HEREYA_CLOUD_URL environment variable to target a specific hereya cloud
                 this.log(`Job ${job.id} ${initResult.success ? 'completed' : 'failed'} (init)`);
                 return;
             }
+            if (job.type === 'app-deploy') {
+                const appDeployResult = await this.executeAppDeployJob(job, cloudBackend, logger);
+                clearInterval(logInterval);
+                clearInterval(heartbeatInterval);
+                await cloudBackend.updateExecutorJob({
+                    jobId: job.id,
+                    logs: logBuffer,
+                    result: appDeployResult,
+                    status: appDeployResult.success ? 'completed' : 'failed',
+                });
+                this.log(`Job ${job.id} ${appDeployResult.success ? 'completed' : 'failed'} (app-deploy)`);
+                return;
+            }
+            if (job.type === 'app-destroy') {
+                const appDestroyResult = await this.executeAppDestroyJob(job, cloudBackend, logger);
+                clearInterval(logInterval);
+                clearInterval(heartbeatInterval);
+                await cloudBackend.updateExecutorJob({
+                    jobId: job.id,
+                    logs: logBuffer,
+                    result: appDestroyResult,
+                    status: appDestroyResult.success ? 'completed' : 'failed',
+                });
+                this.log(`Job ${job.id} ${appDestroyResult.success ? 'completed' : 'failed'} (app-destroy)`);
+                return;
+            }
             const result = job.type === 'provision'
                 ? await executor.provision({
                     ...job.payload,
@@ -450,4 +763,17 @@ Set the HEREYA_CLOUD_URL environment variable to target a specific hereya cloud
             this.warn(`Job ${job.id} failed: ${error.message}`);
         }
     }
+    async markAppDeploymentFailed(input, cloudBackend) {
+        try {
+            await cloudBackend.updateAppDeployment({
+                lastJobId: input.jobId,
+                name: input.appName,
+                status: 'failed',
+                workspace: input.workspace,
+            });
+        }
+        catch {
+            // best-effort; failure of the PATCH must not bubble out
+        }
+    }
 }

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

@@ -1,8 +1,9 @@
 import { Command } from '@oclif/core';
 interface HereyarcConfig {
-    description: string;
-    iac: string;
-    infra: string;
+    description?: string;
+    iac?: string;
+    infra?: string;
+    kind?: 'app' | 'package';
     name: string;
     onDeploy?: {
         pkg: string;
@@ -28,5 +29,6 @@ export default class Publish extends Command {
     loadReadme(packageDir: string): string | undefined;
     run(): Promise<void>;
     validateConfig(config: HereyarcConfig): void;
+    private publishApp;
 }
 export {};