hereya-cli 0.64.2 → 0.64.3

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

@@ -0,0 +1,110 @@
+import { Command, Flags } from '@oclif/core';
+import { Listr, ListrLogger, ListrLogLevels } from 'listr2';
+import { CloudBackend } from '../../../../backend/cloud/cloud-backend.js';
+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';
+export default class WorkspaceExecutorInstall extends Command {
+    static description = 'Install a remote executor into a workspace';
+    static flags = {
+        debug: Flags.boolean({ default: false, description: 'enable debug mode' }),
+        workspace: Flags.string({
+            char: 'w',
+            description: 'name of the workspace',
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(WorkspaceExecutorInstall);
+        setDebug(flags.debug);
+        const myLogger = new ListrLogger({ useIcons: false });
+        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) {
+                                    throw new Error(`Workspace ${flags.workspace} already has an executor installed`);
+                                }
+                                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,
+                                });
+                                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() } });
+                },
+                title: `Installing executor on workspace ${flags.workspace}`,
+            },
+        ], { concurrent: false });
+        try {
+            await task.run();
+            myLogger.log(ListrLogLevels.COMPLETED, 'Executor installed successfully');
+        }
+        catch (error) {
+            this.error(`${error.message}\n\nSee ${getLogPath()} for more details`);
+        }
+    }
+}

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

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

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

@@ -0,0 +1,40 @@
+import { Command, Flags } from '@oclif/core';
+import { CloudBackend } from '../../../../backend/cloud/cloud-backend.js';
+import { getBackend } from '../../../../backend/index.js';
+export default class WorkspaceExecutorToken extends Command {
+    static description = 'Generate a workspace-scoped executor token for testing the remote executor locally';
+    static flags = {
+        workspace: Flags.string({
+            char: 'w',
+            description: 'name of the workspace',
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(WorkspaceExecutorToken);
+        const backend = await getBackend();
+        if (!(backend instanceof CloudBackend)) {
+            this.error('Remote executor requires cloud backend. Run `hereya login` first.');
+        }
+        const workspace$ = await backend.getWorkspace(flags.workspace);
+        if (!workspace$.found) {
+            this.error(`Workspace ${flags.workspace} not found`);
+        }
+        if (workspace$.hasError) {
+            this.error(workspace$.error);
+        }
+        const tokenResult = await backend.generateExecutorToken({
+            workspace: flags.workspace,
+        });
+        if (!tokenResult.success) {
+            this.error(`Failed to generate executor token: ${tokenResult.reason}`);
+        }
+        await backend.updateWorkspace({
+            hasExecutor: true,
+            name: flags.workspace,
+        });
+        this.log(tokenResult.token);
+        this.log('');
+        this.log(`Use this token with: hereya login --token ${tokenResult.token}`);
+    }
+}

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

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class WorkspaceExecutorUninstall 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>;
+}

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

@@ -0,0 +1,102 @@
+import { Command, Flags } from '@oclif/core';
+import { Listr, ListrLogger, ListrLogLevels } from 'listr2';
+import { CloudBackend } from '../../../../backend/cloud/cloud-backend.js';
+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';
+export default class WorkspaceExecutorUninstall extends Command {
+    static description = 'Uninstall the remote executor from a workspace';
+    static flags = {
+        debug: Flags.boolean({ default: false, description: 'enable debug mode' }),
+        workspace: Flags.string({
+            char: 'w',
+            description: 'name of the workspace',
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(WorkspaceExecutorUninstall);
+        setDebug(flags.debug);
+        const myLogger = new ListrLogger({ useIcons: false });
+        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.');
+                                }
+                                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) {
+                                    throw new Error(`Workspace ${flags.workspace} does not have an executor installed`);
+                                }
+                                await delay(500);
+                            },
+                            title: 'Validating workspace',
+                        },
+                        {
+                            rendererOptions: {
+                                persistentOutput: isDebug(),
+                            },
+                            async task(_ctx, task) {
+                                const executor$ = getExecutor();
+                                if (!executor$.success) {
+                                    throw new Error(executor$.reason);
+                                }
+                                const { executor } = executor$;
+                                const destroyOutput = await executor.destroy({
+                                    logger: getLogger(task),
+                                    package: DEFAULT_EXECUTOR_PACKAGE,
+                                    skipDeploy: true,
+                                });
+                                if (!destroyOutput.success) {
+                                    throw new Error(destroyOutput.reason);
+                                }
+                            },
+                            title: 'Destroying remote executor infrastructure',
+                        },
+                        {
+                            async task() {
+                                const backend = await getBackend();
+                                await backend.revokeExecutorToken({
+                                    workspace: flags.workspace,
+                                });
+                                await delay(500);
+                            },
+                            title: 'Revoking executor token',
+                        },
+                        {
+                            async task() {
+                                const backend = await getBackend();
+                                await backend.updateWorkspace({
+                                    hasExecutor: false,
+                                    name: flags.workspace,
+                                });
+                                await delay(500);
+                            },
+                            title: 'Removing executor from workspace',
+                        },
+                    ], { concurrent: false, rendererOptions: { collapseSubtasks: !isDebug() } });
+                },
+                title: `Uninstalling executor from workspace ${flags.workspace}`,
+            },
+        ], { concurrent: false });
+        try {
+            await task.run();
+            myLogger.log(ListrLogLevels.COMPLETED, 'Executor uninstalled successfully');
+        }
+        catch (error) {
+            this.error(`${error.message}\n\nSee ${getLogPath()} for more details`);
+        }
+    }
+}

package/dist/executor/context.d.ts

@@ -0,0 +1,2 @@
+import { GetExecutorOutput } from './index.js';
+export declare function getExecutorForWorkspace(workspaceName?: string, project?: string): Promise<GetExecutorOutput>;

package/dist/executor/context.js

@@ -0,0 +1,39 @@
+import { getCloudCredentials, loadBackendConfig } from '../backend/config.js';
+import { BackendType, getBackend } from '../backend/index.js';
+import { resolveWorkspaceName } from '../lib/workspace-utils.js';
+import { getExecutor } from './index.js';
+export async function getExecutorForWorkspace(workspaceName, project) {
+    if (!workspaceName) {
+        return getExecutor();
+    }
+    const backendConfig = await loadBackendConfig();
+    if (backendConfig.current !== BackendType.Cloud) {
+        return getExecutor();
+    }
+    if (!backendConfig.cloud) {
+        return getExecutor();
+    }
+    const resolvedName = resolveWorkspaceName(workspaceName, project);
+    const backend = await getBackend();
+    const workspace$ = await backend.getWorkspace(resolvedName);
+    if (!workspace$.found || workspace$.hasError) {
+        return getExecutor();
+    }
+    const { workspace } = workspace$;
+    if (!workspace.hasExecutor) {
+        return getExecutor();
+    }
+    const credentials = await getCloudCredentials(backendConfig.cloud.clientId);
+    if (!credentials) {
+        return getExecutor();
+    }
+    return getExecutor({
+        cloudConfig: {
+            accessToken: credentials.accessToken,
+            clientId: backendConfig.cloud.clientId,
+            refreshToken: credentials.refreshToken,
+            url: backendConfig.cloud.url,
+        },
+        workspace: resolvedName,
+    });
+}

package/dist/executor/delegating.d.ts

@@ -0,0 +1,15 @@
+import { Executor, ExecutorDestroyInput, ExecutorDestroyOutput, ExecutorImportInput, ExecutorImportOutput, ExecutorProvisionInput, ExecutorProvisionOutput, ExecutorResolveEnvValuesInput, ExecutorResolveEnvValuesOutput, ExecutorSetEnvVarInput, ExecutorSetEnvVarOutput, ExecutorUnsetEnvVarInput, ExecutorUnsetEnvVarOutput } from './interface.js';
+import { LocalExecutor } from './local.js';
+import { RemoteExecutor } from './remote.js';
+export declare class DelegatingExecutor implements Executor {
+    private readonly localExecutor;
+    private readonly remoteExecutor;
+    constructor(localExecutor: LocalExecutor, remoteExecutor: RemoteExecutor);
+    destroy(input: ExecutorDestroyInput): Promise<ExecutorDestroyOutput>;
+    import(input: ExecutorImportInput): Promise<ExecutorImportOutput>;
+    provision(input: ExecutorProvisionInput): Promise<ExecutorProvisionOutput>;
+    resolveEnvValues(input: ExecutorResolveEnvValuesInput): Promise<ExecutorResolveEnvValuesOutput>;
+    setEnvVar(input: ExecutorSetEnvVarInput): Promise<ExecutorSetEnvVarOutput>;
+    unsetEnvVar(input: ExecutorUnsetEnvVarInput): Promise<ExecutorUnsetEnvVarOutput>;
+    private selectExecutor;
+}

package/dist/executor/delegating.js

@@ -0,0 +1,50 @@
+import { InfrastructureType } from '../infrastructure/common.js';
+import { resolvePackage } from '../lib/package/index.js';
+export class DelegatingExecutor {
+    localExecutor;
+    remoteExecutor;
+    constructor(localExecutor, remoteExecutor) {
+        this.localExecutor = localExecutor;
+        this.remoteExecutor = remoteExecutor;
+    }
+    async destroy(input) {
+        const executor = await this.selectExecutor(input.package, input.projectRootDir, input.isDeploying);
+        return executor.destroy(input);
+    }
+    async import(input) {
+        return this.localExecutor.import(input);
+    }
+    async provision(input) {
+        const executor = await this.selectExecutor(input.package, input.projectRootDir, input.isDeploying);
+        return executor.provision(input);
+    }
+    async resolveEnvValues(input) {
+        return this.remoteExecutor.resolveEnvValues(input);
+    }
+    async setEnvVar(input) {
+        return this.localExecutor.setEnvVar(input);
+    }
+    async unsetEnvVar(input) {
+        return this.localExecutor.unsetEnvVar(input);
+    }
+    async selectExecutor(pkg, projectRootDir, isDeploying) {
+        // Deploy operations always run locally
+        if (isDeploying) {
+            return this.localExecutor;
+        }
+        // Resolve package to check infra type
+        try {
+            const resolved = await resolvePackage({
+                package: pkg,
+                projectRootDir,
+            });
+            if (resolved.found && resolved.metadata.infra !== InfrastructureType.local) {
+                return this.remoteExecutor;
+            }
+        }
+        catch {
+            // If we can't resolve, fall back to local
+        }
+        return this.localExecutor;
+    }
+}

package/dist/executor/index.d.ts

@@ -1,7 +1,16 @@
-import { Executor } from "./interface.js";
-import { LocalExecutor } from "./local.js";
+import { Executor } from './interface.js';
+import { LocalExecutor } from './local.js';
 export declare const localExecutor: LocalExecutor;
-export declare function getExecutor(): GetExecutorOutput;
+export type GetExecutorInput = {
+    cloudConfig?: {
+        accessToken: string;
+        clientId: string;
+        refreshToken: string;
+        url: string;
+    };
+    workspace?: string;
+};
+export declare function getExecutor(input?: GetExecutorInput): GetExecutorOutput;
 export type GetExecutorOutput = {
     executor: Executor;
     success: true;

package/dist/executor/index.js

@@ -1,6 +1,17 @@
-import { LocalExecutor } from "./local.js";
+import { CloudBackend } from '../backend/cloud/cloud-backend.js';
+import { DelegatingExecutor } from './delegating.js';
+import { LocalExecutor } from './local.js';
+import { RemoteExecutor } from './remote.js';
 export const localExecutor = new LocalExecutor();
-export function getExecutor() {
+export function getExecutor(input) {
+    if (input?.cloudConfig && input?.workspace) {
+        const cloudBackend = new CloudBackend(input.cloudConfig);
+        const remoteExecutor = new RemoteExecutor(cloudBackend, input.workspace);
+        return {
+            executor: new DelegatingExecutor(localExecutor, remoteExecutor),
+            success: true,
+        };
+    }
     return {
         executor: localExecutor,
         success: true,

package/dist/executor/remote.d.ts

@@ -0,0 +1,16 @@
+import { CloudBackend } from '../backend/cloud/cloud-backend.js';
+import { Executor, ExecutorDestroyInput, ExecutorDestroyOutput, ExecutorImportInput, ExecutorImportOutput, ExecutorProvisionInput, ExecutorProvisionOutput, ExecutorResolveEnvValuesInput, ExecutorResolveEnvValuesOutput, ExecutorSetEnvVarInput, ExecutorSetEnvVarOutput, ExecutorUnsetEnvVarInput, ExecutorUnsetEnvVarOutput } from './interface.js';
+export declare class RemoteExecutor implements Executor {
+    private readonly cloudBackend;
+    private readonly workspace;
+    private localExecutor;
+    constructor(cloudBackend: CloudBackend, workspace: string);
+    destroy(input: ExecutorDestroyInput): Promise<ExecutorDestroyOutput>;
+    import(input: ExecutorImportInput): Promise<ExecutorImportOutput>;
+    provision(input: ExecutorProvisionInput): Promise<ExecutorProvisionOutput>;
+    resolveEnvValues(input: ExecutorResolveEnvValuesInput): Promise<ExecutorResolveEnvValuesOutput>;
+    setEnvVar(input: ExecutorSetEnvVarInput): Promise<ExecutorSetEnvVarOutput>;
+    unsetEnvVar(input: ExecutorUnsetEnvVarInput): Promise<ExecutorUnsetEnvVarOutput>;
+    private executeRemote;
+    private resolveEnvRemotely;
+}

package/dist/executor/remote.js

@@ -0,0 +1,168 @@
+import { LocalExecutor } from './local.js';
+export class RemoteExecutor {
+    cloudBackend;
+    workspace;
+    localExecutor = new LocalExecutor();
+    constructor(cloudBackend, workspace) {
+        this.cloudBackend = cloudBackend;
+        this.workspace = workspace;
+    }
+    async destroy(input) {
+        return this.executeRemote('destroy', input);
+    }
+    async import(input) {
+        return this.localExecutor.import(input);
+    }
+    async provision(input) {
+        return this.executeRemote('provision', input);
+    }
+    async resolveEnvValues(input) {
+        const localEntries = {};
+        const remoteEntries = {};
+        for (const [key, value] of Object.entries(input.env)) {
+            const colonIndex = value.indexOf(':');
+            if (colonIndex === -1) {
+                // No colon - plain value, resolve locally
+                localEntries[key] = value;
+            }
+            else {
+                const prefix = value.slice(0, colonIndex);
+                if (prefix === 'local') {
+                    localEntries[key] = value;
+                }
+                else {
+                    remoteEntries[key] = value;
+                }
+            }
+        }
+        // Resolve local entries via local executor
+        const localResolved = Object.keys(localEntries).length > 0
+            ? await this.localExecutor.resolveEnvValues({ env: localEntries, markSecret: input.markSecret })
+            : {};
+        // Resolve remote entries via cloud backend
+        const remoteResolved = Object.keys(remoteEntries).length > 0
+            ? await this.resolveEnvRemotely(remoteEntries, input.markSecret)
+            : {};
+        return { ...localResolved, ...remoteResolved };
+    }
+    async setEnvVar(input) {
+        return this.localExecutor.setEnvVar(input);
+    }
+    async unsetEnvVar(input) {
+        return this.localExecutor.unsetEnvVar(input);
+    }
+    async executeRemote(type, input) {
+        // Submit job to cloud
+        const submitResult = await this.cloudBackend.submitExecutorJob({
+            payload: {
+                isDeploying: input.isDeploying,
+                package: input.package,
+                parameters: input.parameters,
+                project: input.project,
+                projectEnv: input.projectEnv,
+                skipDeploy: input.skipDeploy,
+                workspace: input.workspace,
+            },
+            type,
+            workspace: this.workspace,
+        });
+        if (!submitResult.success) {
+            return { reason: `Failed to submit remote executor job: ${submitResult.reason}`, success: false };
+        }
+        const { jobId } = submitResult;
+        input.logger?.info?.(`Remote executor job submitted (${jobId}). Waiting for result...`);
+        // Poll for result
+        const timeout = 10 * 60 * 1000; // 10 minutes
+        const startTime = Date.now();
+        let lastLogLength = 0;
+        let lastStatus = 'pending';
+        while (Date.now() - startTime < timeout) {
+            // eslint-disable-next-line no-await-in-loop
+            const statusResult = await this.cloudBackend.getExecutorJobStatus({
+                jobId,
+                lastStatus,
+                poll: true,
+                workspace: this.workspace,
+            });
+            if (!statusResult.success) {
+                return { reason: `Failed to get job status: ${statusResult.reason}`, success: false };
+            }
+            const { job } = statusResult;
+            lastStatus = job.status;
+            // Forward new logs
+            if (job.logs && job.logs.length > lastLogLength) {
+                const newLogs = job.logs.slice(lastLogLength);
+                if (newLogs.trim()) {
+                    input.logger?.info?.(newLogs);
+                }
+                lastLogLength = job.logs.length;
+            }
+            // Check if job is done
+            if (job.status === 'completed') {
+                if (job.result) {
+                    return job.result;
+                }
+                return { reason: 'Job completed but no result returned', success: false };
+            }
+            if (job.status === 'failed') {
+                const reason = job.result?.reason || 'Remote executor job failed';
+                return { reason, success: false };
+            }
+            // Small delay between polls (server-side long polling handles most of the wait)
+            // eslint-disable-next-line no-await-in-loop
+            await new Promise(resolve => {
+                setTimeout(resolve, 1000);
+            });
+        }
+        return { reason: 'Remote executor job timed out after 10 minutes', success: false };
+    }
+    async resolveEnvRemotely(env, markSecret) {
+        const submitResult = await this.cloudBackend.submitExecutorJob({
+            payload: { env, markSecret },
+            type: 'resolve-env',
+            workspace: this.workspace,
+        });
+        if (!submitResult.success) {
+            console.warn(`Failed to submit resolve-env job: ${submitResult.reason}. Returning unresolved values.`);
+            return env;
+        }
+        const { jobId } = submitResult;
+        // Poll for result with 2-minute timeout
+        const timeout = 2 * 60 * 1000;
+        const startTime = Date.now();
+        let lastStatus = 'pending';
+        while (Date.now() - startTime < timeout) {
+            // eslint-disable-next-line no-await-in-loop
+            const statusResult = await this.cloudBackend.getExecutorJobStatus({
+                jobId,
+                lastStatus,
+                poll: true,
+                workspace: this.workspace,
+            });
+            if (!statusResult.success) {
+                console.warn(`Failed to get resolve-env job status: ${statusResult.reason}. Returning unresolved values.`);
+                return env;
+            }
+            const { job } = statusResult;
+            lastStatus = job.status;
+            if (job.status === 'completed') {
+                if (job.result?.env) {
+                    return job.result.env;
+                }
+                console.warn('resolve-env job completed but no env in result. Returning unresolved values.');
+                return env;
+            }
+            if (job.status === 'failed') {
+                const reason = job.result?.reason || 'resolve-env job failed';
+                console.warn(`resolve-env job failed: ${reason}. Returning unresolved values.`);
+                return env;
+            }
+            // eslint-disable-next-line no-await-in-loop
+            await new Promise(resolve => {
+                setTimeout(resolve, 1000);
+            });
+        }
+        console.warn('resolve-env job timed out after 2 minutes. Returning unresolved values.');
+        return env;
+    }
+}