hereya-cli 0.90.1 → 0.91.0

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

@@ -0,0 +1,38 @@
+import { safeResponseJson } from './utils.js';
+export async function registerExecutorBroker(config, input) {
+    const response = await fetch(`${config.url}/api/workspaces/${encodeURIComponent(input.workspace)}/executor-broker`, {
+        body: JSON.stringify({
+            brokerVersion: input.brokerVersion,
+            brokerWebhookUrl: input.brokerWebhookUrl,
+            metadata: input.metadata,
+            provider: input.provider,
+        }),
+        headers: {
+            'Authorization': `Bearer ${config.accessToken}`,
+            'Content-Type': 'application/json',
+        },
+        method: 'POST',
+    });
+    if (!response.ok) {
+        const error = await safeResponseJson(response);
+        return { reason: error.error || 'Failed to register executor broker', success: false };
+    }
+    return { success: true };
+}
+export async function unregisterExecutorBroker(config, input) {
+    const response = await fetch(`${config.url}/api/workspaces/${encodeURIComponent(input.workspace)}/executor-broker`, {
+        headers: { 'Authorization': `Bearer ${config.accessToken}` },
+        method: 'DELETE',
+    });
+    if (!response.ok) {
+        if (response.status === 404) {
+            // No broker registered — treat as a successful no-op so callers can
+            // unconditionally invoke this during `executor uninstall` for both
+            // ephemeral and legacy always-on installs.
+            return { success: true };
+        }
+        const error = await safeResponseJson(response);
+        return { reason: error.error || 'Failed to unregister executor broker', success: false };
+    }
+    return { success: true };
+}

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

@@ -2,6 +2,7 @@ import { Config } from '../../lib/config/common.js';
 import { Backend } from '../common.js';
 import * as appsDeploy from './cloud-backend/apps-deploy.js';
 import * as appsVersions from './cloud-backend/apps-versions.js';
+import * as executorBroker from './cloud-backend/executor-broker.js';
 import * as executorJobs from './cloud-backend/executor-jobs.js';
 import * as misc from './cloud-backend/misc.js';
 import * as packagesPublish from './cloud-backend/packages-publish.js';
@@ -143,6 +144,7 @@ export declare class CloudBackend implements Backend {
     }>;
     publishAppVersion(input: appsVersions.PublishAppVersionInput): Promise<appsVersions.PublishAppVersionOutput>;
     publishPackage(input: Parameters<typeof packagesPublish.publishPackage>[1]): Promise<import("../common.js").PublishPackageOutput>;
+    registerExecutorBroker(input: executorBroker.RegisterExecutorBrokerInput): Promise<executorBroker.RegisterExecutorBrokerOutput>;
     removePackageFromWorkspace(input: Parameters<typeof packagesWorkspace.removePackageFromWorkspace>[1]): Promise<import("../common.js").AddPackageToWorkspaceOutput>;
     revokeExecutorToken(input: {
         workspace: string;
@@ -163,6 +165,7 @@ export declare class CloudBackend implements Backend {
         reason: string;
         success: false;
     }>;
+    unregisterExecutorBroker(input: executorBroker.UnregisterExecutorBrokerInput): Promise<executorBroker.UnregisterExecutorBrokerOutput>;
     unsetEnvVar(input: Parameters<typeof workspaceEnv.unsetEnvVar>[1]): Promise<import("../common.js").SetEnvVarOutput>;
     updateAppDeployment(input: appsDeploy.UpdateAppDeploymentInput): Promise<{
         reason: string;

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

@@ -1,5 +1,6 @@
 import * as appsDeploy from './cloud-backend/apps-deploy.js';
 import * as appsVersions from './cloud-backend/apps-versions.js';
+import * as executorBroker from './cloud-backend/executor-broker.js';
 import * as executorJobs from './cloud-backend/executor-jobs.js';
 import * as misc from './cloud-backend/misc.js';
 import * as packagesPublish from './cloud-backend/packages-publish.js';
@@ -107,6 +108,9 @@ export class CloudBackend {
     publishPackage(input) {
         return packagesPublish.publishPackage(this.config, input);
     }
+    registerExecutorBroker(input) {
+        return executorBroker.registerExecutorBroker(this.config, input);
+    }
     removePackageFromWorkspace(input) {
         return packagesWorkspace.removePackageFromWorkspace(this.config, input);
     }
@@ -128,6 +132,9 @@ export class CloudBackend {
     submitExecutorJob(input) {
         return executorJobs.submitExecutorJob(this.config, input);
     }
+    unregisterExecutorBroker(input) {
+        return executorBroker.unregisterExecutorBroker(this.config, input);
+    }
     unsetEnvVar(input) {
         return workspaceEnv.unsetEnvVar(this.config, input);
     }

package/dist/backend/common.d.ts

@@ -61,11 +61,11 @@ export declare const WorkspaceSchema: z.ZodObject<{
     name: string;
     id: string;
     env?: Record<string, string> | undefined;
+    profile?: string | undefined;
     packages?: Record<string, {
         version: string;
         parameters?: Record<string, any> | undefined;
     }> | undefined;
-    profile?: string | undefined;
     hasExecutor?: boolean | undefined;
     isDeploy?: boolean | undefined;
     mirrorOf?: string | undefined;
@@ -77,11 +77,11 @@ export declare const WorkspaceSchema: z.ZodObject<{
     name: string;
     id: string;
     env?: Record<string, string> | undefined;
+    profile?: string | undefined;
     packages?: Record<string, {
         version: string;
         parameters?: Record<string, any> | undefined;
     }> | undefined;
-    profile?: string | undefined;
     hasExecutor?: boolean | undefined;
     isDeploy?: boolean | undefined;
     mirrorOf?: string | undefined;

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

@@ -5,9 +5,12 @@ export default class ExecutorStart extends Command {
     static examples: string[];
     static flags: {
         concurrency: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        idleTimeout: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
         workspace: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
     private executeAppJob;
     private executeInitJob;
+    private handleUnauthorizedPoll;
+    private runPollIteration;
 }

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

@@ -29,6 +29,11 @@ Set the HEREYA_CLOUD_URL environment variable to target a specific hereya cloud
             description: 'maximum number of parallel jobs',
             min: 1,
         }),
+        idleTimeout: Flags.integer({
+            char: 'i',
+            description: 'seconds idle before exit; omit to keep running indefinitely',
+            min: 1,
+        }),
         workspace: Flags.string({
             char: 'w',
             description: 'name of the workspace to poll jobs for',
@@ -37,7 +42,7 @@ Set the HEREYA_CLOUD_URL environment variable to target a specific hereya cloud
     };
     async run() {
         const { flags } = await this.parse(ExecutorStart);
-        const { concurrency } = flags;
+        const { concurrency, idleTimeout } = flags;
         const executor = new LocalExecutor();
         const hereyaToken = process.env.HEREYA_TOKEN;
         const cloudUrl = process.env.HEREYA_CLOUD_URL || 'https://cloud.hereya.dev';
@@ -53,7 +58,8 @@ Set the HEREYA_CLOUD_URL environment variable to target a specific hereya cloud
             cloudBackend = backend;
         }
         const executorId = `${os.hostname()}-${randomUUID().slice(0, 8)}`;
-        this.log(`Starting executor ${executorId} for workspace: ${flags.workspace} (concurrency: ${concurrency})`);
+        const idleSuffix = idleTimeout ? `, idle-timeout: ${idleTimeout}s` : '';
+        this.log(`Starting executor ${executorId} for workspace: ${flags.workspace} (concurrency: ${concurrency}${idleSuffix})`);
         this.log('Polling for jobs...');
         const state = { shuttingDown: false };
         const shutdown = () => {
@@ -64,42 +70,46 @@ Set the HEREYA_CLOUD_URL environment variable to target a specific hereya cloud
         process.on('SIGTERM', shutdown);
         const activeJobs = new Set();
         const hooks = { log: (m) => this.log(m), warn: (m) => this.warn(m) };
-        while (!state.shuttingDown) {
+        // Idle clock advances on every successful poll OR while jobs are running.
+        // Generic transient errors (5xx, network) deliberately do NOT advance it
+        // — a flaky cloud must not keep the EC2 alive forever. Persistent 401s
+        // are handled separately by `consecutive401s` below.
+        const startedAt = Date.now();
+        let lastJobAt = startedAt;
+        let lastSuccessfulPollAt = startedAt;
+        const MAX_CONSECUTIVE_401S = 3;
+        let consecutive401s = 0;
+        let authFailureExit = false;
+        while (!state.shuttingDown && !authFailureExit) {
             try {
-                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({
+                const step = await this.runPollIteration({
+                    activeJobs,
+                    cloudBackend,
+                    cloudUrl,
+                    concurrency,
+                    consecutive401s,
+                    executor,
                     executorId,
+                    hereyaToken,
+                    hooks,
+                    idleTimeout,
+                    lastJobAt,
+                    lastSuccessfulPollAt,
+                    maxConsecutive401s: MAX_CONSECUTIVE_401S,
                     workspace: flags.workspace,
                 });
-                if (!pollResult.success) {
-                    if ('unauthorized' in pollResult && pollResult.unauthorized && hereyaToken) {
-                        this.log('Access token expired. Re-authenticating...');
-                        clearBackend();
-                        // eslint-disable-next-line no-await-in-loop
-                        cloudBackend = await createAuthenticatedBackend(hereyaToken, cloudUrl);
-                        continue;
-                    }
-                    this.warn(`Poll error: ${pollResult.reason}`);
-                    // eslint-disable-next-line no-await-in-loop
-                    await new Promise(resolve => {
-                        setTimeout(resolve, 5000);
-                    });
-                    continue;
+                consecutive401s = step.consecutive401s;
+                lastJobAt = step.lastJobAt;
+                lastSuccessfulPollAt = step.lastSuccessfulPollAt;
+                if (step.cloudBackend)
+                    cloudBackend = step.cloudBackend;
+                if (step.exit) {
+                    authFailureExit = true;
+                    break;
                 }
-                if (!pollResult.job) {
-                    continue;
-                }
-                const { job } = pollResult;
-                this.log(`Received job ${job.id} (${job.type}) [${activeJobs.size + 1}/${concurrency} slots used]`);
-                const jobPromise = dispatchJob(job, executor, cloudBackend, hooks).finally(() => {
-                    activeJobs.delete(jobPromise);
-                });
-                activeJobs.add(jobPromise);
+                if (step.idleShutdown)
+                    break;
             }
             catch (error) {
                 this.warn(`Executor error: ${error.message}`);
@@ -114,6 +124,12 @@ Set the HEREYA_CLOUD_URL environment variable to target a specific hereya cloud
             await Promise.allSettled(activeJobs);
         }
         this.log('Executor stopped.');
+        if (authFailureExit) {
+            // Hard exit so systemd's `OnFailure=shutdown.target` triggers an EC2
+            // halt on persistent authentication failure (e.g. token revoked).
+            // eslint-disable-next-line n/no-process-exit, unicorn/no-process-exit
+            process.exit(1);
+        }
     }
     // Test-friendly delegators kept on the class for backwards compatibility with
     // tests that call `(cmd as any).executeInitJob(...)` / `executeAppJob(...)`.
@@ -123,4 +139,71 @@ Set the HEREYA_CLOUD_URL environment variable to target a specific hereya cloud
     executeInitJob(job, executor, logger) {
         return executeInitJob(job, executor, logger);
     }
+    async handleUnauthorizedPoll(args) {
+        const { cloudUrl, consecutive401s, hereyaToken, max } = args;
+        if (consecutive401s >= max) {
+            this.warn(`Persistent authentication failure: ${consecutive401s} consecutive 401 responses from hereya cloud. Token likely revoked or expired. Exiting.`);
+            return { exit: true };
+        }
+        if (hereyaToken) {
+            this.log(`Access token expired (attempt ${consecutive401s}/${max}). Re-authenticating...`);
+            clearBackend();
+            const cloudBackend = await createAuthenticatedBackend(hereyaToken, cloudUrl);
+            return { cloudBackend, exit: false };
+        }
+        this.warn(`Unauthorized poll (attempt ${consecutive401s}/${max}); no HEREYA_TOKEN available to re-authenticate.`);
+        return { exit: false };
+    }
+    async runPollIteration(args) {
+        const { activeJobs, cloudBackend, cloudUrl, concurrency, executor, executorId, hereyaToken, hooks, idleTimeout, maxConsecutive401s, workspace, } = args;
+        let { consecutive401s, lastJobAt, lastSuccessfulPollAt } = args;
+        if (activeJobs.size > 0) {
+            lastJobAt = Date.now();
+        }
+        if (activeJobs.size >= concurrency) {
+            await Promise.race(activeJobs);
+            return { consecutive401s, lastJobAt, lastSuccessfulPollAt };
+        }
+        const pollResult = await cloudBackend.pollExecutorJobs({ executorId, workspace });
+        if (!pollResult.success && 'unauthorized' in pollResult && pollResult.unauthorized) {
+            consecutive401s += 1;
+            const action = await this.handleUnauthorizedPoll({
+                cloudUrl,
+                consecutive401s,
+                hereyaToken,
+                max: maxConsecutive401s,
+            });
+            if (action.exit)
+                return { consecutive401s, exit: true, lastJobAt, lastSuccessfulPollAt };
+            return { cloudBackend: action.cloudBackend, consecutive401s, lastJobAt, lastSuccessfulPollAt };
+        }
+        if (!pollResult.success) {
+            this.warn(`Poll error: ${pollResult.reason}`);
+            await new Promise((resolve) => {
+                setTimeout(resolve, 5000);
+            });
+            return { consecutive401s, lastJobAt, lastSuccessfulPollAt };
+        }
+        // Successful poll: clear the 401 counter and advance the idle clock.
+        consecutive401s = 0;
+        lastSuccessfulPollAt = Date.now();
+        if (pollResult.job) {
+            const { job } = pollResult;
+            this.log(`Received job ${job.id} (${job.type}) [${activeJobs.size + 1}/${concurrency} slots used]`);
+            lastJobAt = Date.now();
+            const jobPromise = dispatchJob(job, executor, cloudBackend, hooks).finally(() => {
+                activeJobs.delete(jobPromise);
+            });
+            activeJobs.add(jobPromise);
+            return { consecutive401s, lastJobAt, lastSuccessfulPollAt };
+        }
+        if (idleTimeout !== undefined &&
+            activeJobs.size === 0 &&
+            Date.now() - lastJobAt > idleTimeout * 1000) {
+            const afterMs = Date.now() - lastJobAt;
+            this.log(JSON.stringify({ afterMs, event: 'executor.idle.shutdown', lastSuccessfulPollAt }));
+            return { consecutive401s, idleShutdown: true, lastJobAt, lastSuccessfulPollAt };
+        }
+        return { consecutive401s, lastJobAt, lastSuccessfulPollAt };
+    }
 }

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

@@ -4,7 +4,10 @@ export default class WorkspaceExecutorInstall extends Command {
     static flags: {
         debug: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        mode: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        parameter: 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>;
+    private parseParameterFlag;
 }

package/dist/commands/workspace/executor/install/index.js

@@ -5,12 +5,27 @@ import { getBackend } from '../../../../backend/index.js';
 import { getExecutor } from '../../../../executor/index.js';
 import { getLogger, getLogPath, isDebug, setDebug } from '../../../../lib/log.js';
 import { delay } from '../../../../lib/shell.js';
-const DEFAULT_EXECUTOR_PACKAGE = 'hereya/remote-executor-aws';
+const ALWAYS_ON_PACKAGE = 'hereya/remote-executor-aws';
+const EPHEMERAL_PACKAGE = 'hereya/aws-executor-broker';
 export default class WorkspaceExecutorInstall extends Command {
-    static description = 'Install a remote executor into a workspace';
+    static description = `Install a remote executor into a workspace.
+
+Two modes are supported:
+  - ephemeral (default): provisions hereya/aws-executor-broker (Lambda + on-demand EC2).
+  - always-on: provisions hereya/remote-executor-aws (legacy always-on EC2).`;
     static flags = {
         debug: Flags.boolean({ default: false, description: 'enable debug mode' }),
         force: Flags.boolean({ char: 'f', default: false, description: 'force reinstall even if executor is already installed' }),
+        mode: Flags.string({
+            default: 'ephemeral',
+            description: 'executor mode: ephemeral (Lambda + on-demand EC2) or always-on (legacy)',
+            options: ['ephemeral', 'always-on'],
+        }),
+        parameter: Flags.string({
+            char: 'p',
+            description: "parameter for the package, in the form of 'key=value'. Can be specified multiple times.",
+            multiple: true,
+        }),
         workspace: Flags.string({
             char: 'w',
             description: 'name of the workspace',
@@ -21,84 +36,184 @@ export default class WorkspaceExecutorInstall extends Command {
         const { flags } = await this.parse(WorkspaceExecutorInstall);
         setDebug(flags.debug);
         const myLogger = new ListrLogger({ useIcons: false });
+        const isEphemeral = flags.mode === 'ephemeral';
+        const executorPackage = isEphemeral ? EPHEMERAL_PACKAGE : ALWAYS_ON_PACKAGE;
+        const userParameters = this.parseParameterFlag(flags.parameter);
+        const reservedKeys = ['workspaceId', 'workspaceName'];
+        for (const reserved of reservedKeys) {
+            if (Object.hasOwn(userParameters, reserved)) {
+                this.error(`--parameter ${reserved}=... is not allowed: this value is auto-inferred from the workspace and overriding it would corrupt the broker registration`);
+            }
+        }
+        const validateTask = {
+            async task(ctx) {
+                const backend = await getBackend();
+                if (!(backend instanceof CloudBackend)) {
+                    throw new TypeError('Remote executor requires cloud backend. Run `hereya login` first.');
+                }
+                const workspace$ = await backend.getWorkspace(flags.workspace);
+                if (!workspace$.found) {
+                    throw new Error(`Workspace ${flags.workspace} not found`);
+                }
+                if (workspace$.hasError) {
+                    throw new Error(workspace$.error);
+                }
+                if (workspace$.workspace.hasExecutor && !flags.force) {
+                    throw new Error(`Workspace ${flags.workspace} already has an executor installed. Use --force to reinstall.`);
+                }
+                ctx.workspaceId = workspace$.workspace.id;
+                await delay(500);
+            },
+            title: 'Validating workspace',
+        };
+        const provisionAlwaysOnTasks = [
+            {
+                async task(ctx) {
+                    const backend = await getBackend();
+                    const tokenResult = await backend.generateExecutorToken({
+                        workspace: flags.workspace,
+                    });
+                    if (!tokenResult.success) {
+                        throw new Error(`Failed to generate executor token: ${tokenResult.reason}`);
+                    }
+                    ctx.executorToken = tokenResult.token;
+                    await delay(500);
+                },
+                title: 'Generating executor token',
+            },
+            {
+                rendererOptions: {
+                    persistentOutput: isDebug(),
+                },
+                async task(ctx, task) {
+                    const executor$ = getExecutor();
+                    if (!executor$.success) {
+                        throw new Error(executor$.reason);
+                    }
+                    const { executor } = executor$;
+                    // Merge precedence (lowest -> highest):
+                    //   1. --parameter key=value (catch-all for any remote-executor-aws inputs)
+                    //   2. auto-inferred (EXECUTOR_TOKEN, WORKSPACE) — cloud-derived, must not be overridden
+                    const parameters = {
+                        ...userParameters,
+                        EXECUTOR_TOKEN: ctx.executorToken,
+                        WORKSPACE: flags.workspace,
+                    };
+                    const provisionOutput = await executor.provision({
+                        logger: getLogger(task),
+                        package: executorPackage,
+                        parameters,
+                        skipDeploy: true,
+                        workspace: flags.workspace,
+                    });
+                    if (!provisionOutput.success) {
+                        throw new Error(provisionOutput.reason);
+                    }
+                },
+                title: 'Provisioning remote executor infrastructure',
+            },
+            {
+                async task() {
+                    const backend = await getBackend();
+                    await backend.updateWorkspace({
+                        hasExecutor: true,
+                        name: flags.workspace,
+                    });
+                    await delay(500);
+                },
+                title: 'Registering executor on workspace',
+            },
+        ];
+        const provisionEphemeralTasks = [
+            {
+                rendererOptions: {
+                    persistentOutput: isDebug(),
+                },
+                async task(ctx, task) {
+                    const executor$ = getExecutor();
+                    if (!executor$.success) {
+                        throw new Error(executor$.reason);
+                    }
+                    const { executor } = executor$;
+                    const hereyaCloudUrl = process.env.HEREYA_CLOUD_URL || 'https://cloud.hereya.dev';
+                    // Merge precedence (lowest -> highest):
+                    //   1. auto-inferred (hereyaCloudUrl, workspaceId, workspaceName)
+                    //   2. --parameter key=value (can override hereyaCloudUrl; workspaceId/workspaceName are
+                    //      rejected up-front, so we re-pin them here defensively)
+                    const parameters = {
+                        hereyaCloudUrl,
+                        ...userParameters,
+                        workspaceId: ctx.workspaceId,
+                        workspaceName: flags.workspace,
+                    };
+                    const provisionOutput = await executor.provision({
+                        logger: getLogger(task),
+                        package: executorPackage,
+                        parameters,
+                        skipDeploy: true,
+                        workspace: flags.workspace,
+                    });
+                    if (!provisionOutput.success) {
+                        throw new Error(provisionOutput.reason);
+                    }
+                    ctx.brokerOutputs = provisionOutput.env;
+                },
+                title: 'Provisioning ephemeral executor broker infrastructure',
+            },
+            {
+                async task(ctx) {
+                    const outputs = ctx.brokerOutputs ?? {};
+                    const { brokerVersion, brokerWebhookUrl } = outputs;
+                    if (!brokerWebhookUrl) {
+                        throw new Error('Executor broker package did not return brokerWebhookUrl output');
+                    }
+                    if (!brokerVersion) {
+                        throw new Error('Executor broker package did not return brokerVersion output');
+                    }
+                    const metadata = {
+                        awsAccountId: outputs.awsAccountId,
+                        brokerLambdaArn: outputs.brokerLambdaArn,
+                        ec2InstanceId: outputs.ec2InstanceId,
+                        ec2LaunchTemplateId: outputs.ec2LaunchTemplateId,
+                        invokerRoleArn: outputs.invokerRoleArn,
+                        region: outputs.region,
+                    };
+                    const backend = await getBackend();
+                    const result = await backend.registerExecutorBroker({
+                        brokerVersion,
+                        brokerWebhookUrl,
+                        metadata,
+                        provider: 'aws',
+                        workspace: flags.workspace,
+                    });
+                    if (!result.success) {
+                        throw new Error(`Failed to register executor broker: ${result.reason}`);
+                    }
+                    await delay(500);
+                },
+                title: 'Registering executor broker with hereya cloud',
+            },
+            {
+                async task() {
+                    const backend = await getBackend();
+                    await backend.updateWorkspace({
+                        hasExecutor: true,
+                        name: flags.workspace,
+                    });
+                    await delay(500);
+                },
+                title: 'Marking workspace executor-enabled',
+            },
+        ];
+        const subTasks = isEphemeral
+            ? [validateTask, ...provisionEphemeralTasks]
+            : [validateTask, ...provisionAlwaysOnTasks];
         const task = new Listr([
             {
                 async task(_ctx, task) {
-                    return task.newListr([
-                        {
-                            async task() {
-                                const backend = await getBackend();
-                                if (!(backend instanceof CloudBackend)) {
-                                    throw new TypeError('Remote executor requires cloud backend. Run `hereya login` first.');
-                                }
-                                const workspace$ = await backend.getWorkspace(flags.workspace);
-                                if (!workspace$.found) {
-                                    throw new Error(`Workspace ${flags.workspace} not found`);
-                                }
-                                if (workspace$.hasError) {
-                                    throw new Error(workspace$.error);
-                                }
-                                if (workspace$.workspace.hasExecutor && !flags.force) {
-                                    throw new Error(`Workspace ${flags.workspace} already has an executor installed. Use --force to reinstall.`);
-                                }
-                                await delay(500);
-                            },
-                            title: 'Validating workspace',
-                        },
-                        {
-                            async task(ctx) {
-                                const backend = await getBackend();
-                                const tokenResult = await backend.generateExecutorToken({
-                                    workspace: flags.workspace,
-                                });
-                                if (!tokenResult.success) {
-                                    throw new Error(`Failed to generate executor token: ${tokenResult.reason}`);
-                                }
-                                ctx.executorToken = tokenResult.token;
-                                await delay(500);
-                            },
-                            title: 'Generating executor token',
-                        },
-                        {
-                            rendererOptions: {
-                                persistentOutput: isDebug(),
-                            },
-                            async task(ctx, task) {
-                                const executor$ = getExecutor();
-                                if (!executor$.success) {
-                                    throw new Error(executor$.reason);
-                                }
-                                const { executor } = executor$;
-                                const provisionOutput = await executor.provision({
-                                    logger: getLogger(task),
-                                    package: DEFAULT_EXECUTOR_PACKAGE,
-                                    parameters: {
-                                        EXECUTOR_TOKEN: ctx.executorToken,
-                                        WORKSPACE: flags.workspace,
-                                    },
-                                    skipDeploy: true,
-                                    workspace: flags.workspace,
-                                });
-                                if (!provisionOutput.success) {
-                                    throw new Error(provisionOutput.reason);
-                                }
-                            },
-                            title: 'Provisioning remote executor infrastructure',
-                        },
-                        {
-                            async task() {
-                                const backend = await getBackend();
-                                await backend.updateWorkspace({
-                                    hasExecutor: true,
-                                    name: flags.workspace,
-                                });
-                                await delay(500);
-                            },
-                            title: 'Registering executor on workspace',
-                        },
-                    ], { concurrent: false, rendererOptions: { collapseSubtasks: !isDebug() } });
+                    return task.newListr(subTasks, { concurrent: false, rendererOptions: { collapseSubtasks: !isDebug() } });
                 },
-                title: `Installing executor on workspace ${flags.workspace}`,
+                title: `Installing executor on workspace ${flags.workspace} (mode: ${flags.mode})`,
             },
         ], { concurrent: false });
         try {
@@ -109,4 +224,23 @@ export default class WorkspaceExecutorInstall extends Command {
             this.error(`${error.message}\n\nSee ${getLogPath()} for more details`);
         }
     }
+    parseParameterFlag(values) {
+        const result = {};
+        if (!values || values.length === 0) {
+            return result;
+        }
+        for (const raw of values) {
+            const eqIdx = raw.indexOf('=');
+            if (eqIdx === -1) {
+                this.error(`Invalid --parameter value '${raw}': expected format 'key=value'`);
+            }
+            const key = raw.slice(0, eqIdx);
+            const value = raw.slice(eqIdx + 1);
+            if (key.length === 0) {
+                this.error(`Invalid --parameter value '${raw}': key must not be empty`);
+            }
+            result[key] = value;
+        }
+        return result;
+    }
 }

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

@@ -3,6 +3,7 @@ export default class WorkspaceExecutorUninstall extends Command {
     static description: string;
     static flags: {
         debug: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        mode: 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>;