hereya-cli 0.69.3 → 0.71.0

package/dist/commands/devenv/install/index.js

@@ -0,0 +1,170 @@
+import { Command, Flags } from '@oclif/core';
+import { Listr, ListrLogger, ListrLogLevels } from 'listr2';
+import { getCloudCredentials, loadBackendConfig } from '../../../backend/config.js';
+import { getBackend } from '../../../backend/index.js';
+import { getExecutor } from '../../../executor/index.js';
+import { getLogger, getLogPath, isDebug, setDebug } from '../../../lib/log.js';
+import { arrayOfStringToObject } from '../../../lib/object-utils.js';
+import { delay } from '../../../lib/shell.js';
+import { load } from '../../../lib/yaml-utils.js';
+export default class DevenvInstall extends Command {
+    static description = 'Provision a remote dev environment on a workspace.';
+    static examples = ['<%= config.bin %> <%= command.id %> -w my-workspace -p instanceType=t3.large'];
+    static flags = {
+        debug: Flags.boolean({
+            default: false,
+            description: 'enable debug mode',
+        }),
+        parameter: Flags.string({
+            char: 'p',
+            default: [],
+            description: "parameter for the package, in the form of 'key=value'. Can be specified multiple times.",
+            multiple: true,
+        }),
+        'parameter-file': Flags.string({
+            char: 'f',
+            description: 'path to a file containing parameters for the package',
+        }),
+        version: Flags.string({
+            char: 'v',
+            description: 'version of the dev environment package',
+        }),
+        workspace: Flags.string({
+            char: 'w',
+            description: 'name of the workspace to provision the dev environment on',
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(DevenvInstall);
+        setDebug(flags.debug);
+        const pkg = flags.version ? `hereya/dev-env-aws@${flags.version}` : 'hereya/dev-env-aws';
+        const myLogger = new ListrLogger({ useIcons: false });
+        const task = new Listr([
+            {
+                async task(ctx, task) {
+                    return task.newListr([
+                        {
+                            async task(ctx) {
+                                const backend = await getBackend();
+                                const loadWorkspaceOutput = await backend.getWorkspace(flags.workspace);
+                                if (!loadWorkspaceOutput.found || loadWorkspaceOutput.hasError) {
+                                    throw new Error(`Workspace ${flags.workspace} not found`);
+                                }
+                                if (loadWorkspaceOutput.workspace.mirrorOf) {
+                                    throw new Error(`Workspace ${flags.workspace} is a mirror of ${loadWorkspaceOutput.workspace.mirrorOf}`);
+                                }
+                                ctx.workspace = loadWorkspaceOutput;
+                                await delay(500);
+                            },
+                            title: `Loading workspace ${flags.workspace}`,
+                        },
+                        {
+                            async task(ctx) {
+                                const parametersInCmdline = arrayOfStringToObject(flags.parameter);
+                                let parametersFromFile = {};
+                                if (flags['parameter-file']) {
+                                    const { data, found } = await load(flags['parameter-file']);
+                                    if (!found) {
+                                        throw new Error(`Parameter file ${flags['parameter-file']} not found`);
+                                    }
+                                    parametersFromFile = data;
+                                }
+                                const parameters = { ...parametersFromFile, ...parametersInCmdline };
+                                ctx.parameters = parameters;
+                                await delay(500);
+                            },
+                            title: 'Resolving parameters',
+                        },
+                        {
+                            async task(ctx) {
+                                const token = await generateHereyaToken(flags.workspace);
+                                if (token) {
+                                    ctx.parameters = { ...ctx.parameters, hereyaCloudUrl: token.cloudUrl, hereyaToken: token.token };
+                                }
+                            },
+                            title: 'Generating Hereya token for dev environment',
+                        },
+                        {
+                            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: pkg,
+                                    parameters: ctx.parameters,
+                                    workspace: flags.workspace,
+                                });
+                                if (!provisionOutput.success) {
+                                    throw new Error(provisionOutput.reason);
+                                }
+                                ctx.provisionOutput = provisionOutput;
+                            },
+                            title: 'Provisioning dev environment',
+                        },
+                        {
+                            async task(ctx) {
+                                const { env, metadata } = ctx.provisionOutput;
+                                const backend = await getBackend();
+                                const output = await backend.addPackageToWorkspace({
+                                    env,
+                                    infra: metadata.infra,
+                                    package: ctx.provisionOutput.pkgName,
+                                    parameters: ctx.parameters,
+                                    version: ctx.provisionOutput.version,
+                                    workspace: flags.workspace,
+                                });
+                                if (!output.success) {
+                                    throw new Error(output.reason);
+                                }
+                            },
+                            title: 'Saving exported environment variables to workspace',
+                        },
+                    ]);
+                },
+                title: `Installing ${pkg} into workspace ${flags.workspace}`,
+            },
+        ], { concurrent: false, rendererOptions: { collapseSubtasks: !isDebug() } });
+        try {
+            await task.run();
+            myLogger.log(ListrLogLevels.COMPLETED, `Dev environment provisioned successfully into workspace ${flags.workspace}`);
+        }
+        catch (error) {
+            this.error(`${error.message}
+
+See ${getLogPath()} for more details`);
+        }
+    }
+}
+async function generateHereyaToken(workspace) {
+    const backendConfig = await loadBackendConfig();
+    if (!backendConfig.cloud) {
+        return null;
+    }
+    const { clientId, url } = backendConfig.cloud;
+    const credentials = await getCloudCredentials(clientId);
+    if (!credentials) {
+        return null;
+    }
+    const formData = new FormData();
+    formData.append('description', `Dev environment: ${workspace}`);
+    formData.append('expiresInDays', '365');
+    const response = await fetch(`${url}/api/personal-tokens`, {
+        body: formData,
+        headers: {
+            Authorization: `Bearer ${credentials.accessToken}`,
+        },
+        method: 'POST',
+    });
+    if (!response.ok) {
+        return null;
+    }
+    const result = await response.json();
+    return { cloudUrl: url, token: result.data.token };
+}

package/dist/commands/devenv/project/init/index.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+export default class DevenvProjectInit extends Command {
+    static args: {
+        project: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        workspace: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    protected spawnSsh(args: string[]): Promise<void>;
+}

package/dist/commands/devenv/project/init/index.js

@@ -0,0 +1,94 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { getBackend } from '../../../../backend/index.js';
+import { getExecutorForWorkspace } from '../../../../executor/context.js';
+import { setKeyFilePermissions } from '../../../../lib/ssh-utils.js';
+export default class DevenvProjectInit extends Command {
+    static args = {
+        project: Args.string({
+            description: 'project name',
+            required: true,
+        }),
+    };
+    static description = 'Initialize a project on a remote dev environment.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my-app -w my-workspace',
+    ];
+    static flags = {
+        force: Flags.boolean({
+            char: 'f',
+            default: false,
+            description: 'continue even if folder already exists',
+        }),
+        workspace: Flags.string({
+            char: 'w',
+            description: 'name of the workspace',
+            required: true,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(DevenvProjectInit);
+        const { project } = args;
+        const { force, workspace } = flags;
+        const backend = await getBackend();
+        const getWorkspaceEnvOutput = await backend.getWorkspaceEnv({ workspace });
+        if (!getWorkspaceEnvOutput.success) {
+            this.error(getWorkspaceEnvOutput.reason);
+        }
+        let { env } = getWorkspaceEnvOutput;
+        const executor$ = await getExecutorForWorkspace(workspace);
+        if (!executor$.success) {
+            this.error(executor$.reason);
+        }
+        const { executor } = executor$;
+        env = await executor.resolveEnvValues({ env });
+        const sshHost = env.devEnvSshHost;
+        const sshPrivateKey = env.devEnvSshPrivateKey;
+        const sshUser = env.devEnvSshUser;
+        const sshHostDns = env.devEnvSshHostDns;
+        if (!sshHost || !sshPrivateKey || !sshUser) {
+            this.error('devEnvSshHost, devEnvSshPrivateKey, and devEnvSshUser must be set in the workspace environment');
+        }
+        const host = sshHostDns || sshHost;
+        const tempKeyPath = path.join(os.tmpdir(), `hereya-ssh-${randomUUID()}`);
+        try {
+            await fs.writeFile(tempKeyPath, sshPrivateKey);
+            await setKeyFilePermissions(tempKeyPath);
+            const remoteScript = force
+                ? `mkdir -p ~/${project} && cd ~/${project} && hereya init ${project} -w ${workspace}`
+                : `if [ -d ~/${project} ]; then echo "ERROR: Folder ~/${project} already exists. Use --force to continue." && exit 1; fi && mkdir -p ~/${project} && cd ~/${project} && hereya init ${project} -w ${workspace}`;
+            const sshArgs = ['-i', tempKeyPath, '-o', 'StrictHostKeyChecking=no', `${sshUser}@${host}`, remoteScript];
+            await this.spawnSsh(sshArgs);
+        }
+        finally {
+            try {
+                await fs.unlink(tempKeyPath);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+    }
+    spawnSsh(args) {
+        return new Promise((resolve, reject) => {
+            const child = spawn('ssh', args, {
+                stdio: 'inherit',
+            });
+            child.on('close', (code) => {
+                if (code === 0) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`SSH exited with code ${code}`));
+                }
+            });
+            child.on('error', (err) => {
+                reject(err);
+            });
+        });
+    }
+}

package/dist/commands/devenv/ssh/index.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class DevenvSsh extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        workspace: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    protected spawnSsh(args: string[]): Promise<void>;
+}

package/dist/commands/devenv/ssh/index.js

@@ -0,0 +1,79 @@
+import { Command, Flags } from '@oclif/core';
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { getBackend } from '../../../backend/index.js';
+import { getExecutorForWorkspace } from '../../../executor/context.js';
+import { setKeyFilePermissions } from '../../../lib/ssh-utils.js';
+export default class DevenvSsh extends Command {
+    static description = 'SSH into a dev environment instance.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> -w my-workspace',
+    ];
+    static flags = {
+        workspace: Flags.string({
+            char: 'w',
+            description: 'name of the workspace to SSH into',
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(DevenvSsh);
+        const { workspace } = flags;
+        const backend = await getBackend();
+        const getWorkspaceEnvOutput = await backend.getWorkspaceEnv({ workspace });
+        if (!getWorkspaceEnvOutput.success) {
+            this.error(getWorkspaceEnvOutput.reason);
+        }
+        let { env } = getWorkspaceEnvOutput;
+        const executor$ = await getExecutorForWorkspace(workspace);
+        if (!executor$.success) {
+            this.error(executor$.reason);
+        }
+        const { executor } = executor$;
+        env = await executor.resolveEnvValues({ env });
+        const sshHost = env.devEnvSshHost;
+        const sshPrivateKey = env.devEnvSshPrivateKey;
+        const sshUser = env.devEnvSshUser;
+        const sshHostDns = env.devEnvSshHostDns;
+        if (!sshHost || !sshPrivateKey || !sshUser) {
+            this.error('devEnvSshHost, devEnvSshPrivateKey, and devEnvSshUser must be set in the workspace environment');
+        }
+        const host = sshHostDns || sshHost;
+        const tempKeyPath = path.join(os.tmpdir(), `hereya-ssh-${randomUUID()}`);
+        try {
+            await fs.writeFile(tempKeyPath, sshPrivateKey);
+            await setKeyFilePermissions(tempKeyPath);
+            const sshArgs = ['-i', tempKeyPath, '-o', 'StrictHostKeyChecking=no', `${sshUser}@${host}`];
+            await this.spawnSsh(sshArgs);
+        }
+        finally {
+            try {
+                await fs.unlink(tempKeyPath);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+    }
+    spawnSsh(args) {
+        return new Promise((resolve, reject) => {
+            const child = spawn('ssh', args, {
+                stdio: 'inherit',
+            });
+            child.on('close', (code) => {
+                if (code === 0) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`SSH exited with code ${code}`));
+                }
+            });
+            child.on('error', (err) => {
+                reject(err);
+            });
+        });
+    }
+}

package/dist/commands/devenv/uninstall/index.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class DevenvUninstall extends Command {
+    static description: string;
+    static examples: 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/devenv/uninstall/index.js

@@ -0,0 +1,115 @@
+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 { getLogger, getLogPath, isDebug, setDebug } from '../../../lib/log.js';
+import { delay } from '../../../lib/shell.js';
+export default class DevenvUninstall extends Command {
+    static description = 'Destroy and remove the dev environment from a workspace.';
+    static examples = ['<%= config.bin %> <%= command.id %> -w my-workspace'];
+    static flags = {
+        debug: Flags.boolean({
+            default: false,
+            description: 'enable debug mode',
+        }),
+        workspace: Flags.string({
+            char: 'w',
+            description: 'name of the workspace to remove the dev environment from',
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(DevenvUninstall);
+        setDebug(flags.debug);
+        const pkg = 'hereya/dev-env-aws';
+        const myLogger = new ListrLogger({ useIcons: false });
+        const task = new Listr([
+            {
+                async task(ctx, task) {
+                    return task.newListr([
+                        {
+                            async task(ctx) {
+                                const backend = await getBackend();
+                                const loadWorkspaceOutput = await backend.getWorkspace(flags.workspace);
+                                if (!loadWorkspaceOutput.found || loadWorkspaceOutput.hasError) {
+                                    throw new Error(`Workspace ${flags.workspace} not found`);
+                                }
+                                if (loadWorkspaceOutput.workspace.mirrorOf) {
+                                    throw new Error(`Workspace ${flags.workspace} is a mirror of ${loadWorkspaceOutput.workspace.mirrorOf}`);
+                                }
+                                const packageInfo = loadWorkspaceOutput.workspace.packages?.[pkg];
+                                if (!packageInfo) {
+                                    throw new Error(`Package ${pkg} not found in workspace ${flags.workspace}`);
+                                }
+                                const installedVersion = packageInfo.version || '';
+                                ctx.packageWithInstalledVersion = installedVersion ? `${pkg}@${installedVersion}` : pkg;
+                                ctx.workspace = loadWorkspaceOutput;
+                                await delay(500);
+                            },
+                            title: `Loading workspace ${flags.workspace}`,
+                        },
+                        {
+                            async task(ctx) {
+                                const parameters = {
+                                    ...ctx.workspace.workspace.packages?.[pkg].parameters,
+                                };
+                                ctx.parameters = parameters;
+                                await delay(500);
+                            },
+                            title: 'Resolving parameters',
+                        },
+                        {
+                            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: ctx.packageWithInstalledVersion,
+                                    parameters: ctx.parameters,
+                                    workspace: flags.workspace,
+                                });
+                                if (!destroyOutput.success) {
+                                    throw new Error(destroyOutput.reason);
+                                }
+                                ctx.destroyOutput = destroyOutput;
+                            },
+                            title: 'Destroying dev environment',
+                        },
+                        {
+                            async task(ctx) {
+                                const { env, metadata } = ctx.destroyOutput;
+                                const backend = await getBackend();
+                                const output = await backend.removePackageFromWorkspace({
+                                    env,
+                                    infra: metadata.infra,
+                                    package: ctx.destroyOutput.pkgName,
+                                    workspace: flags.workspace,
+                                });
+                                if (!output.success) {
+                                    throw new Error(output.reason);
+                                }
+                            },
+                            title: 'Removing exported environment variables from workspace',
+                        },
+                    ]);
+                },
+                title: `Uninstalling dev environment from workspace ${flags.workspace}`,
+            },
+        ], { concurrent: false, rendererOptions: { collapseSubtasks: !isDebug() } });
+        try {
+            await task.run();
+            myLogger.log(ListrLogLevels.COMPLETED, `Dev environment uninstalled successfully from workspace ${flags.workspace}`);
+        }
+        catch (error) {
+            this.error(`${error.message}
+
+See ${getLogPath()} for more details`);
+        }
+    }
+}

package/dist/lib/package/cloud.js

@@ -192,7 +192,7 @@ export class CloudPackageManager {
         try {
             // Try to get package from registry
             // Registry API accepts both 'name' and 'org/name' formats
-            const result = version
+            const result = (version && version !== 'latest')
                 ? await this.backend.getPackageByVersion(packageName, version)
                 : await this.backend.getPackageLatest(packageName);
             if (result.success && result.package) {

package/dist/lib/ssh-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function setKeyFilePermissions(filePath: string): Promise<void>;
+export declare function setSshDirPermissions(dirPath: string): Promise<void>;

package/dist/lib/ssh-utils.js

@@ -0,0 +1,18 @@
+import { exec } from 'node:child_process';
+import { chmod } from 'node:fs/promises';
+import { promisify } from 'node:util';
+const execAsync = promisify(exec);
+export async function setKeyFilePermissions(filePath) {
+    // On Windows, use icacls to restrict the key file to the current user only.
+    // On Unix, chmod 600 restricts the file to owner read/write.
+    await (process.platform === 'win32'
+        ? execAsync(`icacls "${filePath}" /inheritance:r /grant:r "%USERNAME%:R"`)
+        : chmod(filePath, 0o600));
+}
+export async function setSshDirPermissions(dirPath) {
+    // chmod is a no-op on Windows; permissions are inherited from the parent directory
+    if (process.platform === 'win32') {
+        return;
+    }
+    await chmod(dirPath, 0o700);
+}