hereya-cli 0.64.2 → 0.65.0

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

@@ -0,0 +1,176 @@
+import { Command, Flags } from '@oclif/core';
+import { CloudBackend } from '../../../backend/cloud/cloud-backend.js';
+import { getBackend } from '../../../backend/index.js';
+import { LocalExecutor } from '../../../executor/local.js';
+export default class ExecutorStart extends Command {
+    static description = `Start the remote executor process (polls for jobs from hereya cloud).
+
+Jobs are executed in parallel up to the concurrency limit (default: 10). Use --concurrency to adjust.
+
+Set the HEREYA_TOKEN environment variable to authenticate without running \`hereya login\`.
+Set the HEREYA_CLOUD_URL environment variable to target a specific hereya cloud instance (defaults to https://cloud.hereya.dev).`;
+    static examples = [
+        '<%= config.bin %> <%= command.id %> -w my-workspace',
+        '<%= config.bin %> <%= command.id %> -w my-workspace --concurrency 5',
+        'HEREYA_TOKEN=<token> <%= config.bin %> <%= command.id %> -w my-workspace',
+        'HEREYA_TOKEN=<token> HEREYA_CLOUD_URL=https://my-cloud.example.com <%= config.bin %> <%= command.id %> -w my-workspace',
+    ];
+    static flags = {
+        concurrency: Flags.integer({
+            char: 'c',
+            default: 10,
+            description: 'maximum number of parallel jobs',
+            min: 1,
+        }),
+        workspace: Flags.string({
+            char: 'w',
+            description: 'name of the workspace to poll jobs for',
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ExecutorStart);
+        const { concurrency } = flags;
+        const executor = new LocalExecutor();
+        const backend = await getBackend({
+            token: process.env.HEREYA_TOKEN,
+            url: process.env.HEREYA_CLOUD_URL,
+        });
+        if (!(backend instanceof CloudBackend)) {
+            this.error('Remote executor requires cloud backend. Set HEREYA_TOKEN or run `hereya login` first.');
+        }
+        const cloudBackend = backend;
+        this.log(`Starting executor for workspace: ${flags.workspace} (concurrency: ${concurrency})`);
+        this.log('Polling for jobs...');
+        // Handle graceful shutdown
+        const state = { shuttingDown: false };
+        const shutdown = () => {
+            this.log('Shutting down executor...');
+            state.shuttingDown = true;
+        };
+        process.on('SIGINT', shutdown);
+        process.on('SIGTERM', shutdown);
+        const activeJobs = new Set();
+        while (!state.shuttingDown) {
+            try {
+                // Wait for a slot to open up if at concurrency limit
+                if (activeJobs.size >= concurrency) {
+                    // eslint-disable-next-line no-await-in-loop
+                    await Promise.race(activeJobs);
+                    continue;
+                }
+                // eslint-disable-next-line no-await-in-loop
+                const pollResult = await cloudBackend.pollExecutorJobs({
+                    workspace: flags.workspace,
+                });
+                if (!pollResult.success) {
+                    this.warn(`Poll error: ${pollResult.reason}`);
+                    // eslint-disable-next-line no-await-in-loop
+                    await new Promise(resolve => {
+                        setTimeout(resolve, 5000);
+                    });
+                    continue;
+                }
+                if (!pollResult.job) {
+                    // No job available, continue polling
+                    continue;
+                }
+                const { job } = pollResult;
+                this.log(`Received job ${job.id} (${job.type}) [${activeJobs.size + 1}/${concurrency} slots used]`);
+                // Fire off the job without awaiting it
+                const jobPromise = this.executeJob(job, executor, cloudBackend).finally(() => {
+                    activeJobs.delete(jobPromise);
+                });
+                activeJobs.add(jobPromise);
+            }
+            catch (error) {
+                this.warn(`Executor error: ${error.message}`);
+                // Wait before retrying
+                // eslint-disable-next-line no-await-in-loop
+                await new Promise(resolve => {
+                    setTimeout(resolve, 5000);
+                });
+            }
+        }
+        // Wait for all active jobs to complete before exiting
+        if (activeJobs.size > 0) {
+            this.log(`Waiting for ${activeJobs.size} active job(s) to complete...`);
+            await Promise.allSettled(activeJobs);
+        }
+        this.log('Executor stopped.');
+    }
+    async executeJob(job, executor, cloudBackend) {
+        // Set up buffered logging
+        let logBuffer = '';
+        const logInterval = setInterval(async () => {
+            if (logBuffer) {
+                const logs = logBuffer;
+                logBuffer = '';
+                try {
+                    await cloudBackend.updateExecutorJob({
+                        jobId: job.id,
+                        logs,
+                    });
+                }
+                catch {
+                    // Log flush errors are non-fatal
+                }
+            }
+        }, 10_000);
+        const logger = {
+            debug(msg) {
+                logBuffer += msg + '\n';
+            },
+            error(msg) {
+                logBuffer += msg + '\n';
+            },
+            info(msg) {
+                logBuffer += msg + '\n';
+            },
+        };
+        try {
+            if (job.type === 'resolve-env') {
+                // resolve-env job: resolve env values using local executor
+                const resolved = await executor.resolveEnvValues(job.payload);
+                // Send resolved env as result
+                clearInterval(logInterval);
+                await cloudBackend.updateExecutorJob({
+                    jobId: job.id,
+                    logs: logBuffer,
+                    result: { env: resolved, success: true },
+                    status: 'completed',
+                });
+                this.log(`Job ${job.id} completed (resolve-env)`);
+                return;
+            }
+            const result = job.type === 'provision'
+                ? await executor.provision({
+                    ...job.payload,
+                    logger,
+                })
+                : await executor.destroy({
+                    ...job.payload,
+                    logger,
+                });
+            // Flush remaining logs and send result
+            clearInterval(logInterval);
+            await cloudBackend.updateExecutorJob({
+                jobId: job.id,
+                logs: logBuffer,
+                result,
+                status: result.success ? 'completed' : 'failed',
+            });
+            this.log(`Job ${job.id} ${result.success ? 'completed' : 'failed'}`);
+        }
+        catch (error) {
+            clearInterval(logInterval);
+            await cloudBackend.updateExecutorJob({
+                jobId: job.id,
+                logs: logBuffer + `\nError: ${error.message}\n`,
+                result: { reason: error.message, success: false },
+                status: 'failed',
+            });
+            this.warn(`Job ${job.id} failed: ${error.message}`);
+        }
+    }
+}

package/dist/commands/remove/index.js

@@ -1,7 +1,7 @@
 import { Args, Command, Flags } from '@oclif/core';
 import { Listr, ListrLogger, ListrLogLevels } from 'listr2';
 import { getBackend } from '../../backend/index.js';
-import { getExecutor } from '../../executor/index.js';
+import { getExecutorForWorkspace } from '../../executor/context.js';
 import { getConfigManager } from '../../lib/config/index.js';
 import { getEnvManager } from '../../lib/env/index.js';
 import { getLogger, getLogPath, isDebug, setDebug } from '../../lib/log.js';
@@ -71,7 +71,8 @@ export default class Remove extends Command {
                                 // Parse package name to extract name and version
                                 const [packageNameWithoutVersion, userSpecifiedVersion] = ctx.package.split('@');
                                 // Check if package exists in config (using clean name without version)
-                                const packageInfo = config.packages?.[packageNameWithoutVersion] || config.deploy?.[packageNameWithoutVersion];
+                                ctx.isDevDeploy = Boolean(config.devDeploy?.[packageNameWithoutVersion]);
+                                const packageInfo = config.packages?.[packageNameWithoutVersion] || config.deploy?.[packageNameWithoutVersion] || config.devDeploy?.[packageNameWithoutVersion];
                                 if (!packageInfo) {
                                     throw new Error(`Package ${packageNameWithoutVersion} not found in the project.`);
                                 }
@@ -102,12 +103,34 @@ export default class Remove extends Command {
                             },
                             title: 'Resolving package parameters',
                         },
+                        {
+                            skip: (ctx) => !ctx.isDevDeploy,
+                            async task(ctx) {
+                                const backend = await getBackend();
+                                const profile = await getProfileFromWorkspace(backend, ctx.workspace, ctx.configOutput.config.project);
+                                const envManager = getEnvManager();
+                                const getProjectEnvOutput = await envManager.getProjectEnv({
+                                    excludeDevDeploy: true,
+                                    markSecret: false,
+                                    profile,
+                                    project: ctx.configOutput.config.project,
+                                    projectRootDir,
+                                    workspace: ctx.workspace,
+                                });
+                                if (!getProjectEnvOutput.success) {
+                                    throw new Error(getProjectEnvOutput.reason);
+                                }
+                                ctx.projectEnv = getProjectEnvOutput.env;
+                                await delay(500);
+                            },
+                            title: 'Loading project environment for devDeploy',
+                        },
                         {
                             rendererOptions: {
                                 persistentOutput: isDebug(),
                             },
                             async task(ctx, task) {
-                                const executor$ = getExecutor();
+                                const executor$ = await getExecutorForWorkspace(ctx.workspace, ctx.configOutput.config.project);
                                 if (!executor$.success) {
                                     throw new Error(executor$.reason);
                                 }
@@ -117,8 +140,9 @@ export default class Remove extends Command {
                                     package: ctx.packageWithInstalledVersion,
                                     parameters: ctx.parametersOutput.parameters,
                                     project: ctx.configOutput.config.project,
+                                    projectEnv: ctx.projectEnv,
                                     projectRootDir,
-                                    skipDeploy: true,
+                                    skipDeploy: !ctx.isDevDeploy,
                                     workspace: ctx.workspace,
                                 });
                                 if (!destroyOutput.success) {
@@ -134,7 +158,9 @@ export default class Remove extends Command {
                                 await envManager.removeProjectEnv({
                                     env: ctx.destroyOutput.env,
                                     infra: ctx.destroyOutput.metadata.infra,
+                                    pkg: ctx.destroyOutput.pkgName,
                                     projectRootDir,
+                                    snakeCase: ctx.destroyOutput.metadata.snakeCase,
                                     workspace: ctx.workspace,
                                 });
                                 await delay(500);
@@ -163,6 +189,114 @@ export default class Remove extends Command {
                             },
                             title: 'Saving state',
                         },
+                        {
+                            skip(ctx) {
+                                const devDeploy = ctx.configOutput.config.devDeploy ?? {};
+                                return Object.keys(devDeploy).length === 0;
+                            },
+                            async task(ctx) {
+                                const configManager = getConfigManager();
+                                const { config } = await configManager.loadConfig({ projectRootDir });
+                                const devDeploy = config.devDeploy ?? {};
+                                if (Object.keys(devDeploy).length === 0) {
+                                    return;
+                                }
+                                const backend = await getBackend();
+                                const profile = await getProfileFromWorkspace(backend, ctx.workspace, ctx.configOutput.config.project);
+                                const envManager = getEnvManager();
+                                const getProjectEnvOutput = await envManager.getProjectEnv({
+                                    excludeDevDeploy: true,
+                                    markSecret: false,
+                                    profile,
+                                    project: ctx.configOutput.config.project,
+                                    projectRootDir,
+                                    workspace: ctx.workspace,
+                                });
+                                if (!getProjectEnvOutput.success) {
+                                    throw new Error(getProjectEnvOutput.reason);
+                                }
+                                ctx.projectEnv = getProjectEnvOutput.env;
+                                ctx.configOutput = { config, found: true };
+                                await delay(500);
+                            },
+                            title: 'Loading project environment',
+                        },
+                        {
+                            skip(ctx) {
+                                const devDeploy = ctx.configOutput.config.devDeploy ?? {};
+                                return Object.keys(devDeploy).length === 0;
+                            },
+                            async task(ctx, task) {
+                                const configManager = getConfigManager();
+                                const { config } = await configManager.loadConfig({ projectRootDir });
+                                const devDeployPackages = config.devDeploy ?? {};
+                                const devDeployEntries = Object.entries(devDeployPackages).map(([name, info]) => ({
+                                    name,
+                                    packageSpec: info.version ? `${name}@${info.version}` : name,
+                                    version: info.version || '',
+                                }));
+                                return task.newListr(devDeployEntries.map((pkg) => ({
+                                    rendererOptions: {
+                                        persistentOutput: isDebug(),
+                                    },
+                                    async task(_, task) {
+                                        const parameterManager = getParameterManager();
+                                        const backend = await getBackend();
+                                        const profile = await getProfileFromWorkspace(backend, ctx.workspace, ctx.configOutput.config.project);
+                                        const { parameters } = await parameterManager.getPackageParameters({
+                                            package: pkg.name,
+                                            profile,
+                                            projectRootDir,
+                                        });
+                                        const executor$ = await getExecutorForWorkspace(ctx.workspace, ctx.configOutput.config.project);
+                                        if (!executor$.success) {
+                                            throw new Error(executor$.reason);
+                                        }
+                                        const { executor } = executor$;
+                                        const provisionOutput = await executor.provision({
+                                            logger: getLogger(task),
+                                            package: pkg.packageSpec,
+                                            parameters,
+                                            project: ctx.configOutput.config.project,
+                                            projectEnv: ctx.projectEnv ?? {},
+                                            workspace: ctx.workspace,
+                                        });
+                                        if (!provisionOutput.success) {
+                                            throw new Error(provisionOutput.reason);
+                                        }
+                                        const { env, metadata } = provisionOutput;
+                                        const output = ctx.devDeployAdded || [];
+                                        output.push({ env, metadata, packageName: pkg.name });
+                                        ctx.devDeployAdded = output;
+                                    },
+                                    title: `Provisioning ${pkg.name}`,
+                                })), { concurrent: true, rendererOptions: { collapseSubtasks: !isDebug() } });
+                            },
+                            title: 'Provisioning devDeploy packages',
+                        },
+                        {
+                            skip: (ctx) => !ctx.devDeployAdded || ctx.devDeployAdded.length === 0,
+                            async task(ctx) {
+                                if (!ctx.devDeployAdded || ctx.devDeployAdded.length === 0) {
+                                    return;
+                                }
+                                const envManager = getEnvManager();
+                                for (const { env, metadata, packageName } of ctx.devDeployAdded) {
+                                    // eslint-disable-next-line no-await-in-loop
+                                    await envManager.addProjectEnv({
+                                        env,
+                                        infra: metadata.originalInfra ?? metadata.infra,
+                                        isDevDeploy: true,
+                                        pkg: packageName,
+                                        projectRootDir,
+                                        snakeCase: metadata.snakeCase,
+                                        workspace: ctx.workspace,
+                                    });
+                                }
+                                await delay(500);
+                            },
+                            title: 'Adding env vars from devDeploy packages',
+                        },
                     ]);
                 },
                 title: `Removing ${args.package}`,

package/dist/commands/run/index.js

@@ -53,6 +53,7 @@ export default class Run extends Command {
         const envManager = getEnvManager();
         const getProjectEnvOutput = await envManager.getProjectEnv({
             profile,
+            project: config.project,
             projectRootDir,
             workspace,
         });

package/dist/commands/undeploy/index.js

@@ -70,6 +70,7 @@ export default class Undeploy extends Command {
                                 const getProjectEnvOutput = await envManager.getProjectEnv({
                                     markSecret: true,
                                     profile,
+                                    project: ctx.configOutput.config.project,
                                     projectRootDir,
                                     workspace: ctx.workspace,
                                 });
@@ -229,12 +230,14 @@ export default class Undeploy extends Command {
                                     return;
                                 }
                                 const envManager = getEnvManager();
-                                for (const { env, metadata } of destroyed) {
+                                for (const { env, metadata, packageName } of destroyed) {
                                     // eslint-disable-next-line no-await-in-loop
                                     await envManager.removeProjectEnv({
                                         env,
                                         infra: metadata.originalInfra ?? metadata.infra,
+                                        pkg: packageName,
                                         projectRootDir,
+                                        snakeCase: metadata.snakeCase,
                                         workspace,
                                     });
                                 }

package/dist/commands/up/index.js

@@ -1,7 +1,7 @@
 import { Command, Flags } from '@oclif/core';
 import { Listr, ListrLogger, ListrLogLevels } from 'listr2';
 import { getBackend } from '../../backend/index.js';
-import { getExecutor } from '../../executor/index.js';
+import { getExecutorForWorkspace } from '../../executor/context.js';
 import { getConfigManager } from '../../lib/config/index.js';
 import { getEnvManager } from '../../lib/env/index.js';
 import { getLogger, getLogPath, isDebug, setDebug } from '../../lib/log.js';
@@ -142,7 +142,7 @@ export default class Up extends Command {
                                             profile,
                                             projectRootDir,
                                         });
-                                        const executor$ = getExecutor();
+                                        const executor$ = await getExecutorForWorkspace(ctx.workspace, ctx.configOutput.config.project);
                                         if (!executor$.success) {
                                             throw new Error(executor$.reason);
                                         }
@@ -188,7 +188,7 @@ export default class Up extends Command {
                                             profile,
                                             projectRootDir,
                                         });
-                                        const executor$ = getExecutor();
+                                        const executor$ = await getExecutorForWorkspace(ctx.workspace, ctx.configOutput.config.project);
                                         if (!executor$.success) {
                                             throw new Error(executor$.reason);
                                         }
@@ -223,12 +223,14 @@ export default class Up extends Command {
                                     return;
                                 }
                                 const envManager = getEnvManager();
-                                for (const { env, metadata } of removed) {
+                                for (const { env, metadata, packageName } of removed) {
                                     // eslint-disable-next-line no-await-in-loop
                                     await envManager.removeProjectEnv({
                                         env,
                                         infra: metadata.originalInfra ?? metadata.infra,
+                                        pkg: packageName,
                                         projectRootDir,
+                                        snakeCase: metadata.snakeCase,
                                         workspace,
                                     });
                                 }
@@ -243,12 +245,14 @@ export default class Up extends Command {
                                     return;
                                 }
                                 const envManager = getEnvManager();
-                                for (const { env, metadata } of ctx.added) {
+                                for (const { env, metadata, packageName } of ctx.added) {
                                     // eslint-disable-next-line no-await-in-loop
                                     await envManager.addProjectEnv({
                                         env,
                                         infra: metadata.originalInfra ?? metadata.infra,
+                                        pkg: packageName,
                                         projectRootDir,
+                                        snakeCase: metadata.snakeCase,
                                         workspace: ctx.workspace,
                                     });
                                 }
@@ -256,6 +260,99 @@ export default class Up extends Command {
                             },
                             title: 'Adding env vars from added packages',
                         },
+                        {
+                            skip: (ctx) => !ctx.configOutput.config.devDeploy || Object.keys(ctx.configOutput.config.devDeploy).length === 0,
+                            async task(ctx) {
+                                const backend = await getBackend();
+                                const profile = await getProfileFromWorkspace(backend, ctx.workspace, ctx.configOutput.config.project);
+                                const envManager = getEnvManager();
+                                const getProjectEnvOutput = await envManager.getProjectEnv({
+                                    excludeDevDeploy: true,
+                                    markSecret: false,
+                                    profile,
+                                    project: ctx.configOutput.config.project,
+                                    projectRootDir,
+                                    workspace: ctx.workspace,
+                                });
+                                if (!getProjectEnvOutput.success) {
+                                    throw new Error(getProjectEnvOutput.reason);
+                                }
+                                ctx.projectEnv = getProjectEnvOutput.env;
+                                await delay(500);
+                            },
+                            title: 'Loading project environment',
+                        },
+                        {
+                            skip: (ctx) => !ctx.configOutput.config.devDeploy || Object.keys(ctx.configOutput.config.devDeploy).length === 0,
+                            async task(ctx) {
+                                const devDeployPackages = ctx.configOutput.config.devDeploy ?? {};
+                                const devDeployEntries = Object.entries(devDeployPackages).map(([name, info]) => ({
+                                    name,
+                                    packageSpec: info.version ? `${name}@${info.version}` : name,
+                                    version: info.version || '',
+                                }));
+                                return task.newListr(devDeployEntries.map((pkg) => ({
+                                    rendererOptions: {
+                                        persistentOutput: isDebug(),
+                                    },
+                                    async task(_, task) {
+                                        const parameterManager = getParameterManager();
+                                        const backend = await getBackend();
+                                        const profile = await getProfileFromWorkspace(backend, ctx.workspace, ctx.configOutput.config.project);
+                                        const { parameters } = await parameterManager.getPackageParameters({
+                                            package: pkg.name,
+                                            profile,
+                                            projectRootDir,
+                                        });
+                                        const executor$ = await getExecutorForWorkspace(ctx.workspace, ctx.configOutput.config.project);
+                                        if (!executor$.success) {
+                                            throw new Error(executor$.reason);
+                                        }
+                                        const { executor } = executor$;
+                                        const provisionOutput = await executor.provision({
+                                            logger: getLogger(task),
+                                            package: pkg.packageSpec,
+                                            parameters,
+                                            project: ctx.configOutput.config.project,
+                                            projectEnv: ctx.projectEnv ?? {},
+                                            workspace: ctx.workspace,
+                                        });
+                                        if (!provisionOutput.success) {
+                                            throw new Error(provisionOutput.reason);
+                                        }
+                                        const { env, metadata } = provisionOutput;
+                                        const output = ctx.devDeployAdded || [];
+                                        output.push({ env, metadata, packageName: pkg.name });
+                                        ctx.devDeployAdded = output;
+                                    },
+                                    title: `Provisioning ${pkg.name}`,
+                                })), { concurrent: true, rendererOptions: { collapseSubtasks: !isDebug() } });
+                            },
+                            title: 'Provisioning devDeploy packages',
+                        },
+                        {
+                            skip: (ctx) => !ctx.devDeployAdded || ctx.devDeployAdded.length === 0,
+                            async task(ctx) {
+                                if (!ctx.devDeployAdded || ctx.devDeployAdded.length === 0) {
+                                    return;
+                                }
+                                const envManager = getEnvManager();
+                                for (const { env, metadata, packageName } of ctx.devDeployAdded) {
+                                    // eslint-disable-next-line no-await-in-loop
+                                    await envManager.addProjectEnv({
+                                        env,
+                                        infra: metadata.originalInfra ?? metadata.infra,
+                                        isDevDeploy: true,
+                                        pkg: packageName,
+                                        projectRootDir,
+                                        snakeCase: metadata.snakeCase,
+                                        workspace: ctx.workspace,
+                                    });
+                                }
+                                await delay(500);
+                            },
+                            title: 'Adding env vars from devDeploy packages',
+                        },
                         {
                             async task(ctx) {
                                 const backend = await getBackend();

package/dist/commands/workspace/executor/install/index.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class WorkspaceExecutorInstall extends Command {
+    static description: string;
+    static flags: {
+        debug: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        workspace: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}