hereya-cli 0.85.4 → 0.85.5

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

@@ -1,10 +1,66 @@
 import { Args, Command, Flags } from '@oclif/core';
 import { ListrLogger, ListrLogLevels } from 'listr2';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import * as yaml from 'yaml';
 import { CloudBackend } from '../../../backend/cloud/cloud-backend.js';
 import { getBackend } from '../../../backend/index.js';
-import { resolveAppParameters } from '../../../lib/app-parameters.js';
+import { LocalExecutor } from '../../../executor/local.js';
+import { resolveAndSubstituteAppParams, resolveAppParameters } from '../../../lib/app-parameters.js';
+import { getEnvManager } from '../../../lib/env/index.js';
 import { arrayOfStringToObject } from '../../../lib/object-utils.js';
+import { stripOrgPrefix } from '../../../lib/org-utils.js';
+import { getProfileFromWorkspace } from '../../../lib/profile-utils.js';
 import { pollExecutorJob } from '../../../lib/remote-job-utils.js';
+import { shellUtils } from '../../../lib/shell.js';
+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 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;
+}
+/**
+ * Workspaces look like `org/name`, which is not filesystem-safe. The
+ * corresponding read-side in the executor wrapper MUST use the same
+ * sanitization — see `executeAppJob` in `commands/executor/start/index.ts`.
+ */
+function sanitizeWorkspaceForFilename(workspace) {
+    return workspace.replaceAll('/', '-');
+}
 export default class AppDeploy extends Command {
     static args = {
         name: Args.string({ description: 'app name in org/name format', required: true }),
@@ -16,6 +72,16 @@ export default class AppDeploy extends Command {
         '<%= config.bin %> <%= command.id %> my-org/my-app -w prod -p organizationId=org-123',
     ];
     static flags = {
+        chdir: Flags.string({
+            description: `Directory where the command will be executed.
+        If not specified, it defaults to the current working directory.
+        Alternatively, you can define the project root by setting the HEREYA_PROJECT_ROOT_DIR environment variable.`,
+            required: false,
+        }),
+        local: Flags.boolean({
+            default: false,
+            description: 'force local execution (skip remote executor)',
+        }),
         parameter: Flags.string({
             char: 'p',
             default: [],
@@ -33,6 +99,145 @@ export default class AppDeploy extends Command {
     };
     async run() {
         const { args, flags } = await this.parse(AppDeploy);
+        const forceLocal = flags.local || process.env.HEREYA_LOCAL_EXECUTION === 'true';
+        if (forceLocal) {
+            await this.runLocal({ appName: args.name, flags });
+            return;
+        }
+        await this.runRemote({ appName: args.name, flags });
+    }
+    async runLocal(input) {
+        const { appName, flags } = input;
+        const rootDir = path.resolve(flags.chdir || process.env.HEREYA_PROJECT_ROOT_DIR || process.cwd());
+        const myLogger = new ListrLogger({ useIcons: false });
+        const logger = {
+            debug: (msg) => myLogger.log(ListrLogLevels.OUTPUT, msg),
+            error: (msg) => myLogger.log(ListrLogLevels.OUTPUT, msg),
+            info: (msg) => myLogger.log(ListrLogLevels.OUTPUT, msg),
+        };
+        // Read hereya.yaml
+        const hereyaYamlPath = await getAnyExisting(path.join(rootDir, 'hereya.yaml'), path.join(rootDir, 'hereya.yml'));
+        if (!hereyaYamlPath) {
+            this.error(`No hereya.yaml found in ${rootDir}`);
+        }
+        const parsedHereyaYaml = (yaml.parse(await fs.readFile(hereyaYamlPath, 'utf8')) ?? {});
+        const packages = normalizePackageList(parsedHereyaYaml.packages);
+        const deployPackages = normalizePackageList(parsedHereyaYaml.deployPackages ?? parsedHereyaYaml.deploy);
+        // Parse user-provided parameters
+        const provided = arrayOfStringToObject(flags.parameter);
+        // Resolve params + substitute hereyavars files
+        const paramsResult = await resolveAndSubstituteAppParams({
+            logger,
+            provided,
+            rootDir,
+        });
+        if (!paramsResult.success) {
+            this.error(paramsResult.reason);
+        }
+        const { parameters: resolvedParameters } = paramsResult;
+        // Run preDeployCommand if any
+        if (parsedHereyaYaml.preDeployCommand) {
+            logger.info('Running pre-deploy command...');
+            try {
+                await shellUtils.runShell(parsedHereyaYaml.preDeployCommand, [], { directory: rootDir, logger });
+            }
+            catch (error) {
+                this.error(`pre-deploy command failed: ${error.message}`);
+            }
+        }
+        const backend = await getBackend();
+        const { profile } = await getProfileFromWorkspace(backend, flags.workspace, appName);
+        const executor = new LocalExecutor();
+        const envMgr = getEnvManager();
+        const deployEnv = {};
+        // Mirror project-deploy env machinery exactly:
+        //   1. Each regular pkg is provisioned in isolation. LocalExecutor.provision
+        //      auto-loads workspace env; pkg outputs are persisted via
+        //      envManager.addProjectEnv to .hereya/env.<workspace>.yaml.
+        //   2. projectEnv for deploy pkgs is built from envManager.getProjectEnv
+        //      (.hereya/env.<workspace>.yaml + .env + hereyaconfig/hereyastaticenv)
+        //      — explicitly NOT including workspace env. That keeps the deploy
+        //      Lambda env block under AWS's 4 KB limit.
+        //   3. deployEnv accumulates only deploy-package outputs and is the
+        //      AppDeployment's public env surface (cloud UI + `hereya app env`).
+        /* eslint-disable no-await-in-loop */
+        for (const pkg of packages) {
+            myLogger.log(ListrLogLevels.STARTED, `Provisioning ${pkg.name}...`);
+            const result = await executor.provision({
+                app: appName,
+                isDeploying: true,
+                logger,
+                package: pkg.spec,
+                parameters: resolvedParameters,
+                projectRootDir: rootDir,
+                workspace: flags.workspace,
+            });
+            if (!result.success) {
+                this.error(`Failed to provision package ${pkg.name}: ${result.reason}`);
+            }
+            await envMgr.addProjectEnv({
+                env: result.env,
+                infra: result.metadata.originalInfra ?? result.metadata.infra,
+                pkg: result.pkgName,
+                projectRootDir: rootDir,
+                snakeCase: result.metadata.snakeCase,
+                workspace: flags.workspace,
+            });
+        }
+        // Build projectEnv for deploy packages from saved per-package outputs.
+        const projectEnvResult = await envMgr.getProjectEnv({
+            markSecret: true,
+            profile: profile ?? stripOrgPrefix(flags.workspace),
+            project: appName,
+            projectRootDir: rootDir,
+            workspace: flags.workspace,
+        });
+        if (!projectEnvResult.success) {
+            this.error(`Failed to build projectEnv: ${projectEnvResult.reason}`);
+        }
+        const projectEnv = projectEnvResult.env;
+        for (const pkg of deployPackages) {
+            myLogger.log(ListrLogLevels.STARTED, `Provisioning deploy package ${pkg.name}...`);
+            const result = await executor.provision({
+                app: appName,
+                isDeploying: true,
+                logger,
+                package: pkg.spec,
+                parameters: resolvedParameters,
+                projectEnv,
+                projectRootDir: rootDir,
+                workspace: flags.workspace,
+            });
+            if (!result.success) {
+                this.error(`Failed to provision deploy package ${pkg.name}: ${result.reason}`);
+            }
+            Object.assign(deployEnv, result.env);
+        }
+        /* eslint-enable no-await-in-loop */
+        // Write deploy env file for executor wrapper to PATCH back to the cloud.
+        const hereyaDir = path.join(rootDir, '.hereya');
+        await fs.mkdir(hereyaDir, { recursive: true });
+        const deployEnvFile = path.join(hereyaDir, `deploy-env.${sanitizeWorkspaceForFilename(flags.workspace)}.json`);
+        const state = {
+            deployPackages: deployPackages.map((p) => ({ name: p.name, version: p.version })),
+            packages: packages.map((p) => ({ name: p.name, version: p.version })),
+            version: flags.version,
+        };
+        await fs.writeFile(deployEnvFile, JSON.stringify({ env: deployEnv, state }, null, 2), 'utf8');
+        myLogger.log(ListrLogLevels.COMPLETED, `App ${appName} deployed to ${flags.workspace}`);
+        this.log(`\nStatus: deployed`);
+        if (flags.version) {
+            this.log(`Version: ${flags.version}`);
+        }
+        if (Object.keys(deployEnv).length > 0) {
+            this.log('\nEnv outputs:');
+            for (const [key, value] of Object.entries(deployEnv)) {
+                this.log(`  ${key}=${value}`);
+            }
+        }
+    }
+    async runRemote(input) {
+        const { appName, flags } = input;
         const backend = await getBackend();
         if (!(backend instanceof CloudBackend)) {
             this.error('App deployment requires the cloud backend. Run `hereya login` first.');
@@ -43,7 +248,7 @@ export default class AppDeploy extends Command {
         const provided = arrayOfStringToObject(flags.parameter);
         // Fetch the target version's declared parameters before submitting any cloud job.
         const versionResult = await cloudBackend.getAppVersion({
-            name: args.name,
+            name: appName,
             version: flags.version,
         });
         if (!versionResult.success) {
@@ -54,9 +259,9 @@ export default class AppDeploy extends Command {
         if (errors.length > 0) {
             this.error(['Cannot deploy app due to parameter errors:', ...errors.map((e) => `  - ${e}`)].join('\n'));
         }
-        myLogger.log(ListrLogLevels.STARTED, `Deploying ${args.name}${flags.version ? `@${flags.version}` : ''} to workspace ${flags.workspace}...`);
+        myLogger.log(ListrLogLevels.STARTED, `Deploying ${appName}${flags.version ? `@${flags.version}` : ''} to workspace ${flags.workspace}...`);
         const deployResult = await cloudBackend.deployApp({
-            name: args.name,
+            name: appName,
             parameters: Object.keys(parameters).length > 0 ? parameters : undefined,
             version: flags.version,
             workspace: flags.workspace,
@@ -80,9 +285,9 @@ export default class AppDeploy extends Command {
         if (!pollResult.success) {
             this.error(pollResult.reason);
         }
-        myLogger.log(ListrLogLevels.COMPLETED, `App ${args.name} deployed to ${flags.workspace}`);
+        myLogger.log(ListrLogLevels.COMPLETED, `App ${appName} deployed to ${flags.workspace}`);
         // Print final state
-        const status = await cloudBackend.getAppDeployment({ name: args.name, workspace: flags.workspace });
+        const status = await cloudBackend.getAppDeployment({ name: appName, workspace: flags.workspace });
         if (status.success) {
             this.log(`\nStatus: ${status.deployment.status}`);
             if (status.deployment.version) {

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

@@ -6,7 +6,12 @@ export default class AppDestroy extends Command {
     static description: string;
     static examples: string[];
     static flags: {
+        chdir: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        local: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        parameter: import("@oclif/core/interfaces").OptionFlag<string[], import("@oclif/core/interfaces").CustomOptions>;
         workspace: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
+    private runLocal;
+    private runRemote;
 }

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

@@ -1,8 +1,58 @@
 import { Args, Command, Flags } from '@oclif/core';
 import { ListrLogger, ListrLogLevels } from 'listr2';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import * as yaml from 'yaml';
 import { CloudBackend } from '../../../backend/cloud/cloud-backend.js';
 import { getBackend } from '../../../backend/index.js';
+import { LocalExecutor } from '../../../executor/local.js';
+import { resolveAndSubstituteAppParams } from '../../../lib/app-parameters.js';
+import { getEnvManager } from '../../../lib/env/index.js';
+import { arrayOfStringToObject } from '../../../lib/object-utils.js';
+import { stripOrgPrefix } from '../../../lib/org-utils.js';
+import { getProfileFromWorkspace } from '../../../lib/profile-utils.js';
 import { pollExecutorJob } from '../../../lib/remote-job-utils.js';
+import { shellUtils } from '../../../lib/shell.js';
+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 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;
+}
 export default class AppDestroy extends Command {
     static args = {
         name: Args.string({ description: 'app name in org/name format', required: true }),
@@ -10,6 +60,22 @@ export default class AppDestroy extends Command {
     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 = {
+        chdir: Flags.string({
+            description: `Directory where the command will be executed.
+        If not specified, it defaults to the current working directory.
+        Alternatively, you can define the project root by setting the HEREYA_PROJECT_ROOT_DIR environment variable.`,
+            required: false,
+        }),
+        local: Flags.boolean({
+            default: false,
+            description: 'force local execution (skip remote executor)',
+        }),
+        parameter: Flags.string({
+            char: 'p',
+            default: [],
+            description: 'parameter for the app deployment, in the form of key=value (repeatable)',
+            multiple: true,
+        }),
         workspace: Flags.string({
             char: 'w',
             description: 'workspace where the app is currently deployed',
@@ -18,15 +84,98 @@ export default class AppDestroy extends Command {
     };
     async run() {
         const { args, flags } = await this.parse(AppDestroy);
+        const forceLocal = flags.local || process.env.HEREYA_LOCAL_EXECUTION === 'true';
+        if (forceLocal) {
+            await this.runLocal({ appName: args.name, flags });
+            return;
+        }
+        await this.runRemote({ appName: args.name, flags });
+    }
+    async runLocal(input) {
+        const { appName, flags } = input;
+        const rootDir = path.resolve(flags.chdir || process.env.HEREYA_PROJECT_ROOT_DIR || process.cwd());
+        const myLogger = new ListrLogger({ useIcons: false });
+        const logger = {
+            debug: (msg) => myLogger.log(ListrLogLevels.OUTPUT, msg),
+            error: (msg) => myLogger.log(ListrLogLevels.OUTPUT, msg),
+            info: (msg) => myLogger.log(ListrLogLevels.OUTPUT, msg),
+        };
+        // Read hereya.yaml
+        const hereyaYamlPath = await getAnyExisting(path.join(rootDir, 'hereya.yaml'), path.join(rootDir, 'hereya.yml'));
+        if (!hereyaYamlPath) {
+            this.error(`No hereya.yaml found in ${rootDir}`);
+        }
+        const parsedHereyaYaml = (yaml.parse(await fs.readFile(hereyaYamlPath, 'utf8')) ?? {});
+        const packages = normalizePackageList(parsedHereyaYaml.packages);
+        const deployPackages = normalizePackageList(parsedHereyaYaml.deployPackages ?? parsedHereyaYaml.deploy);
+        // Parse user-provided parameters
+        const provided = arrayOfStringToObject(flags.parameter);
+        // Resolve params + substitute hereyavars files
+        const paramsResult = await resolveAndSubstituteAppParams({
+            logger,
+            provided,
+            rootDir,
+        });
+        if (!paramsResult.success) {
+            this.error(paramsResult.reason);
+        }
+        const { parameters: resolvedParameters } = paramsResult;
+        // Run preDeployCommand if any (matches project undeploy + current executor behavior)
+        if (parsedHereyaYaml.preDeployCommand) {
+            logger.info('Running pre-deploy command...');
+            try {
+                await shellUtils.runShell(parsedHereyaYaml.preDeployCommand, [], { directory: rootDir, logger });
+            }
+            catch (error) {
+                this.error(`pre-deploy command failed: ${error.message}`);
+            }
+        }
+        const backend = await getBackend();
+        const { profile } = await getProfileFromWorkspace(backend, flags.workspace, appName);
+        const executor = new LocalExecutor();
+        const envMgr = getEnvManager();
+        // Build projectEnv from saved per-package outputs.
+        const projectEnvResult = await envMgr.getProjectEnv({
+            markSecret: true,
+            profile: profile ?? stripOrgPrefix(flags.workspace),
+            project: appName,
+            projectRootDir: rootDir,
+            workspace: flags.workspace,
+        });
+        const projectEnv = projectEnvResult.success ? projectEnvResult.env : {};
+        // Iterate in declaration order: deploy packages first, then regular packages.
+        const allPackages = [...deployPackages, ...packages];
+        /* eslint-disable no-await-in-loop */
+        for (const pkg of allPackages) {
+            myLogger.log(ListrLogLevels.STARTED, `Destroying ${pkg.name}...`);
+            const result = await executor.destroy({
+                app: appName,
+                isDeploying: true,
+                logger,
+                package: pkg.spec,
+                parameters: resolvedParameters,
+                projectEnv,
+                projectRootDir: rootDir,
+                workspace: flags.workspace,
+            });
+            if (!result.success) {
+                this.error(`Failed to destroy package ${pkg.name}: ${result.reason}`);
+            }
+        }
+        /* eslint-enable no-await-in-loop */
+        myLogger.log(ListrLogLevels.COMPLETED, `App ${appName} destroyed from ${flags.workspace}`);
+    }
+    async runRemote(input) {
+        const { appName, flags } = input;
         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}...`);
+        myLogger.log(ListrLogLevels.STARTED, `Destroying ${appName} on workspace ${flags.workspace}...`);
         const destroyResult = await cloudBackend.destroyApp({
-            name: args.name,
+            name: appName,
             workspace: flags.workspace,
         });
         if (!destroyResult.success) {
@@ -47,6 +196,6 @@ export default class AppDestroy extends Command {
         if (!pollResult.success) {
             this.error(pollResult.reason);
         }
-        myLogger.log(ListrLogLevels.COMPLETED, `App ${args.name} destroyed from ${flags.workspace}`);
+        myLogger.log(ListrLogLevels.COMPLETED, `App ${appName} destroyed from ${flags.workspace}`);
     }
 }

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

@@ -14,12 +14,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 executeAppJob;
     private executeDeployJob;
     private executeInitJob;
     private executeJob;
     private markAppDeploymentFailed;
-    private readDeclaredParameters;
-    private resolveAndSubstituteParams;
+    private patchAppFinalState;
 }