hereya-cli 0.89.1 → 0.90.1

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

@@ -0,0 +1,13 @@
+import nock from 'nock';
+import { CloudBackend } from './cloud-backend.js';
+export declare const cloudConfig: {
+    accessToken: string;
+    clientId: string;
+    refreshToken: string;
+    url: string;
+};
+export interface CloudBackendTestContext {
+    backend: CloudBackend;
+    scope: nock.Scope;
+}
+export declare function setupCloudBackendTest(): CloudBackendTestContext;

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

@@ -0,0 +1,14 @@
+import nock from 'nock';
+import { CloudBackend } from './cloud-backend.js';
+export const cloudConfig = {
+    accessToken: 'test-token',
+    clientId: 'test-client-id',
+    refreshToken: 'test-refresh-token',
+    url: 'http://test.com',
+};
+export function setupCloudBackendTest() {
+    return {
+        backend: new CloudBackend(cloudConfig),
+        scope: nock(cloudConfig.url),
+    };
+}

package/dist/backend/local.setup.d.ts

@@ -0,0 +1,10 @@
+export interface LocalBackendTestContext {
+    homeDir: string;
+}
+/**
+ * Shared setup helpers for LocalFileBackend tests. Each split test file calls
+ * `setupLocalBackendTest()` from its `beforeEach` and uses the returned context
+ * to access the temp homeDir. Stubbing of `os.homedir` is restored by sinon.
+ */
+export declare function setupLocalBackendTest(): Promise<LocalBackendTestContext>;
+export declare function teardownLocalBackendTest(context: LocalBackendTestContext): Promise<void>;

package/dist/backend/local.setup.js

@@ -0,0 +1,20 @@
+import { randomUUID } from 'node:crypto';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import * as sinon from 'sinon';
+/**
+ * Shared setup helpers for LocalFileBackend tests. Each split test file calls
+ * `setupLocalBackendTest()` from its `beforeEach` and uses the returned context
+ * to access the temp homeDir. Stubbing of `os.homedir` is restored by sinon.
+ */
+export async function setupLocalBackendTest() {
+    const homeDir = path.join(os.tmpdir(), 'hereya-test', randomUUID());
+    sinon.stub(os, 'homedir').returns(homeDir);
+    await fs.mkdir(path.join(homeDir, '.hereya', 'state', 'workspaces'), { recursive: true });
+    return { homeDir };
+}
+export async function teardownLocalBackendTest(context) {
+    sinon.restore();
+    await fs.rm(context.homeDir, { force: true, recursive: true });
+}

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

@@ -1,11 +1,5 @@
 import { Command } from '@oclif/core';
-/**
- * Strip credentials from log strings before flushing them to the cloud.
- * Removes:
- *   - any occurrence of the actual hereyaGitPassword value
- *   - userinfo from URLs (https://user:pass@host -> https://host)
- */
-export declare function redactCredentials(str: string, password?: string): string;
+export { redactCredentials } from '../../../lib/executor-start/format.js';
 export default class ExecutorStart extends Command {
     static description: string;
     static examples: string[];
@@ -15,9 +9,5 @@ export default class ExecutorStart extends Command {
     };
     run(): Promise<void>;
     private executeAppJob;
-    private executeDeployJob;
     private executeInitJob;
-    private executeJob;
-    private markAppDeploymentFailed;
-    private patchAppFinalState;
 }

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

@@ -1,59 +1,14 @@
 import { Command, Flags } from '@oclif/core';
 import { randomUUID } from 'node:crypto';
-import fs from 'node:fs/promises';
 import os from 'node:os';
-import path from 'node:path';
 import { CloudBackend } from '../../../backend/cloud/cloud-backend.js';
-import { loginWithToken } from '../../../backend/cloud/login.js';
-import { saveCloudCredentials } from '../../../backend/config.js';
 import { clearBackend, getBackend } from '../../../backend/index.js';
 import { LocalExecutor } from '../../../executor/local.js';
-import * as appSourceLib from '../../../lib/app-source.js';
-import { SimpleConfigManager } from '../../../lib/config/simple.js';
-import { cloneWithCredentialHelper, gitUtils } from '../../../lib/git-utils.js';
-import { runShell, shellUtils } from '../../../lib/shell.js';
-/**
- * Workspaces look like `org/name`, which is not filesystem-safe. The
- * write-side in `app deploy --local` (commands/app/deploy/index.ts) MUST use
- * the same sanitization.
- */
-function sanitizeWorkspaceForFilename(workspace) {
-    return workspace.replaceAll('/', '-');
-}
-/**
- * Strip credentials from log strings before flushing them to the cloud.
- * Removes:
- *   - any occurrence of the actual hereyaGitPassword value
- *   - userinfo from URLs (https://user:pass@host -> https://host)
- */
-export function redactCredentials(str, password) {
-    let out = str;
-    if (password) {
-        // Replace every exact occurrence of the password with a placeholder.
-        out = out.split(password).join('[REDACTED]');
-    }
-    // Strip userinfo from URLs (http/https/git).
-    out = out.replaceAll(/(https?:\/\/|git:\/\/)([^/\s@]+@)/g, '$1');
-    return out;
-}
-async function createAuthenticatedBackend(hereyaToken, cloudUrl) {
-    const loginResult = await loginWithToken(cloudUrl, hereyaToken);
-    if (!loginResult.success) {
-        throw new Error(`Failed to authenticate: ${loginResult.error}`);
-    }
-    await saveCloudCredentials({
-        accessToken: loginResult.accessToken,
-        clientId: loginResult.clientId,
-        refreshToken: loginResult.refreshToken,
-        url: cloudUrl,
-    });
-    return new CloudBackend({
-        accessToken: loginResult.accessToken,
-        clientId: loginResult.clientId,
-        refreshToken: loginResult.refreshToken,
-        url: cloudUrl,
-    });
-}
+import { createAuthenticatedBackend } from '../../../lib/executor-start/auth.js';
+import { executeAppJob } from '../../../lib/executor-start/execute-app-job.js';
+import { executeInitJob } from '../../../lib/executor-start/execute-init-job.js';
+import { dispatchJob } from '../../../lib/executor-start/job-dispatch.js';
+export { redactCredentials } from '../../../lib/executor-start/format.js';
 export default class ExecutorStart extends Command {
     static description = `Start the remote executor process (polls for jobs from hereya cloud).
 
@@ -100,7 +55,6 @@ Set the HEREYA_CLOUD_URL environment variable to target a specific hereya cloud
         const executorId = `${os.hostname()}-${randomUUID().slice(0, 8)}`;
         this.log(`Starting executor ${executorId} 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...');
@@ -109,9 +63,9 @@ Set the HEREYA_CLOUD_URL environment variable to target a specific hereya cloud
         process.on('SIGINT', shutdown);
         process.on('SIGTERM', shutdown);
         const activeJobs = new Set();
+        const hooks = { log: (m) => this.log(m), warn: (m) => this.warn(m) };
         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);
@@ -138,474 +92,35 @@ Set the HEREYA_CLOUD_URL environment variable to target a specific hereya cloud
                     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(() => {
+                const jobPromise = dispatchJob(job, executor, cloudBackend, hooks).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 executeAppJob(job, cloudBackend, logger) {
-        const isDeploy = job.type === 'app-deploy';
-        const subcommand = isDeploy ? 'deploy' : 'destroy';
-        const payload = job.payload;
-        const { appName, commit, parameters: providedParameters, repository, sha256, version, workspace } = payload;
-        if (!appName || !workspace || !repository) {
-            return {
-                reason: `Missing appName, workspace, or repository in ${job.type} job payload`,
-                success: false,
-            };
-        }
-        let cleanup;
-        try {
-            logger.info(`Downloading app source ${repository}${commit ? `@${commit}` : ''}...`);
-            const downloadResult = await appSourceLib.appSource.download({ commit, logger, repository, sha256 });
-            cleanup = downloadResult.cleanup;
-            const { rootDir } = downloadResult;
-            // Mark deployment as deploying / destroying.
-            await cloudBackend.updateAppDeployment({
-                lastJobId: job.id,
-                name: appName,
-                status: isDeploy ? 'deploying' : 'destroying',
-                workspace,
-            });
-            // Build -p flag args from job payload parameters.
-            const parameters = providedParameters ?? {};
-            const paramFlags = [];
-            for (const [key, value] of Object.entries(parameters)) {
-                paramFlags.push('-p', `${key}=${value}`);
-            }
-            // For app-deploy, forward --version so the local command can serialize it into
-            // the deploy-env file's `state` block (which the cloud reads back via PATCH).
-            const versionFlags = isDeploy && version ? ['--version', version] : [];
-            // Shell out to `hereya app <subcommand> <appName> -w <workspace> [-p ...] [--version ...] --local`.
-            // The local command holds the provisioning logic (mirrors deploy/undeploy shell-out pattern).
-            logger.info(`Running hereya app ${subcommand} ${appName} -w ${workspace} --local...`);
-            let runResult;
-            try {
-                runResult = await shellUtils.runShell('hereya', ['app', subcommand, appName, '-w', workspace, ...paramFlags, ...versionFlags, '--local'], {
-                    directory: rootDir,
-                    env: { ...process.env, HEREYA_LOCAL_EXECUTION: 'true', HEREYA_PROJECT_ROOT_DIR: rootDir },
-                    logger,
-                });
-            }
-            catch (error) {
-                await this.markAppDeploymentFailed({ appName, jobId: job.id, reason: error.message, workspace }, cloudBackend);
-                return { reason: `hereya app ${subcommand} failed: ${error.message}`, success: false };
-            }
-            if (runResult && runResult.status !== 0) {
-                const reason = `hereya app ${subcommand} exited with code ${runResult.status}`;
-                await this.markAppDeploymentFailed({ appName, jobId: job.id, reason, workspace }, cloudBackend);
-                return { reason, success: false };
-            }
-            // PATCH final state to the cloud.
-            const patchResult = await this.patchAppFinalState({
-                appName,
-                cloudBackend,
-                isDeploy,
-                jobId: job.id,
-                rootDir,
-                workspace,
-            });
-            if (!patchResult.success) {
-                return patchResult;
-            }
-            return { success: true };
-        }
-        catch (error) {
-            try {
-                await this.markAppDeploymentFailed({ appName, jobId: job.id, reason: error.message, workspace }, cloudBackend);
-            }
-            catch {
-                // best-effort
-            }
-            return { reason: `app-${subcommand} failed: ${error.message}`, success: false };
-        }
-        finally {
-            if (cleanup) {
-                await cleanup();
-            }
-        }
-    }
-    async executeDeployJob(job, executor, cloudBackend, logger) {
-        const { gitBranch, project, workspace } = job.payload;
-        if (!project || !workspace) {
-            return { reason: 'Missing project or workspace in job payload', success: false };
-        }
-        // 1. Get project metadata to find git credentials
-        const metadata$ = await cloudBackend.getProjectMetadata({ project });
-        if (!metadata$.found) {
-            return { reason: `No metadata found for project ${project}`, success: false };
-        }
-        const { metadata } = metadata$;
-        if (!metadata.env?.hereyaGitRemoteUrl) {
-            return { reason: 'Project metadata missing hereyaGitRemoteUrl', success: false };
-        }
-        // 2. Resolve git credentials using the local executor
-        const gitEnvToResolve = {};
-        for (const [key, value] of Object.entries(metadata.env)) {
-            if (key.startsWith('hereyaGit'))
-                gitEnvToResolve[key] = value;
-        }
-        const resolvedGitEnv = await executor.resolveEnvValues({ env: gitEnvToResolve, project, workspace });
-        // 3. Clone repo at specified branch into temp dir
-        const tempDir = path.join(os.tmpdir(), `hereya-deploy-${randomUUID()}`);
-        try {
-            const branch = gitBranch || 'main';
-            logger.info(`Cloning ${resolvedGitEnv.hereyaGitRemoteUrl} (branch: ${branch})...`);
-            const cloneResult = await cloneWithCredentialHelper({
-                gitUrl: resolvedGitEnv.hereyaGitRemoteUrl,
-                hereyaBinPath: process.argv[1],
-                password: resolvedGitEnv.hereyaGitPassword,
-                targetDir: tempDir,
-                username: resolvedGitEnv.hereyaGitUsername,
-            });
-            if (!cloneResult.success) {
-                return { reason: `Git clone failed: ${cloneResult.reason}`, success: false };
-            }
-            // Checkout the correct branch if not main/master
-            if (branch !== 'main' && branch !== 'master') {
-                await runShell('git', ['checkout', branch], { directory: tempDir, logger });
-            }
-            // 4. Run hereya deploy/undeploy --local inside the cloned repo
-            const command = job.type === 'deploy' ? 'deploy' : 'undeploy';
-            logger.info(`Running hereya ${command} -w ${workspace} --local...`);
-            const result = await runShell('hereya', [command, '-w', workspace, '--local'], {
-                directory: tempDir,
-                env: { ...process.env, HEREYA_LOCAL_EXECUTION: 'true', HEREYA_PROJECT_ROOT_DIR: tempDir },
-                logger,
-            });
-            logger.info(`hereya ${command} exited with code ${result.status}`);
-            if (result.status !== 0) {
-                return { reason: `hereya ${command} failed (exit code ${result.status})`, success: false };
-            }
-            return { success: true };
-        }
-        finally {
-            // 5. Clean up temp dir
-            try {
-                await fs.rm(tempDir, { force: true, recursive: true });
-            }
-            catch {
-                // Ignore cleanup errors
-            }
-        }
-    }
-    async executeInitJob(job, executor, logger) {
-        const payload = job.payload;
-        const { deployWorkspace, parameters, projectName, template, workspace } = payload;
-        if (!projectName || !workspace || !template || !deployWorkspace) {
-            return {
-                reason: 'Missing projectName, workspace, template, or deployWorkspace in job payload',
-                success: false,
-            };
-        }
-        // Track the password here (captured after provision) so the redacting logger knows what
-        // to strip. Until we have it, redaction still runs for URL userinfo.
-        let password;
-        const redactingLogger = {
-            debug(msg) {
-                logger.debug(redactCredentials(msg, password));
-            },
-            error(msg) {
-                logger.error(redactCredentials(msg, password));
-            },
-            info(msg) {
-                logger.info(redactCredentials(msg, password));
-            },
-        };
-        const scratchDir = await fs.mkdtemp(path.join(os.tmpdir(), 'hereya-init-'));
-        try {
-            // 1. Provision template
-            redactingLogger.info(`Provisioning template ${template}...`);
-            const provisionResult = await executor.provision({
-                logger: redactingLogger,
-                package: template,
-                parameters: {
-                    ...parameters,
-                    deployWorkspace,
-                    projectName,
-                    workspace,
-                },
-                project: projectName,
-                workspace,
-            });
-            if (!provisionResult.success) {
-                return { reason: `Template provisioning failed: ${provisionResult.reason}`, success: false };
-            }
-            const { env } = provisionResult;
-            const { hereyaGitPassword, hereyaGitRemoteUrl, hereyaGitUsername } = env;
-            password = hereyaGitPassword;
-            if (!hereyaGitRemoteUrl) {
-                return { reason: 'Template did not export hereyaGitRemoteUrl', success: false };
-            }
-            // 2. Clone repo into scratch dir.
-            redactingLogger.info(`Cloning ${hereyaGitRemoteUrl}...`);
-            // Clone into a subdirectory so we control the target exactly.
-            const repoDir = path.join(scratchDir, 'repo');
-            const cloneResult = await gitUtils.cloneWithCredentialHelper({
-                gitUrl: hereyaGitRemoteUrl,
-                hereyaBinPath: process.argv[1],
-                password: hereyaGitPassword,
-                targetDir: repoDir,
-                username: hereyaGitUsername,
-            });
-            if (!cloneResult.success) {
-                return { reason: `Git clone failed: ${cloneResult.reason}`, success: false };
-            }
-            // 3. Write hereya.yaml
-            redactingLogger.info('Writing hereya.yaml...');
-            const config = {
-                project: projectName,
-                workspace,
-            };
-            await new SimpleConfigManager().saveConfig({ config, projectRootDir: repoDir });
-            // 4. Commit + push
-            redactingLogger.info('Committing and pushing initial project config...');
-            const gitEnv = {
-                ...process.env,
-                GIT_AUTHOR_EMAIL: 'executor@hereya.dev',
-                GIT_AUTHOR_NAME: 'hereya-executor',
-                GIT_COMMITTER_EMAIL: 'executor@hereya.dev',
-                GIT_COMMITTER_NAME: 'hereya-executor',
-            };
-            if (hereyaGitUsername)
-                gitEnv.hereyaGitUsername = hereyaGitUsername;
-            if (hereyaGitPassword)
-                gitEnv.hereyaGitPassword = hereyaGitPassword;
-            try {
-                await shellUtils.runShell('git', ['add', '.'], { directory: repoDir, env: gitEnv, logger: redactingLogger });
-                await shellUtils.runShell('git', ['commit', '-m', '"chore: hereya init"'], {
-                    directory: repoDir,
-                    env: gitEnv,
-                    logger: redactingLogger,
-                });
-                await shellUtils.runShell('git', ['push', 'origin', 'HEAD'], {
-                    directory: repoDir,
-                    env: gitEnv,
-                    logger: redactingLogger,
-                });
-            }
-            catch (error) {
-                return {
-                    reason: `Git commit/push failed: ${redactCredentials(error.message ?? String(error), password)}`,
-                    success: false,
-                };
-            }
-            return { hereyaGitRemoteUrl, success: true };
-        }
-        catch (error) {
-            return {
-                reason: `Init failed: ${redactCredentials(error.message ?? String(error), password)}`,
-                success: false,
-            };
-        }
-        finally {
-            try {
-                await fs.rm(scratchDir, { force: true, recursive: true });
-            }
-            catch {
-                // Ignore cleanup errors
-            }
-        }
-    }
-    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);
-        // Heartbeat every 30 seconds (independent of log flushing)
-        const heartbeatInterval = setInterval(async () => {
-            try {
-                await cloudBackend.updateExecutorJob({ jobId: job.id });
-            }
-            catch {
-                // Heartbeat errors are non-fatal
-            }
-        }, 30_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);
-                clearInterval(heartbeatInterval);
-                await cloudBackend.updateExecutorJob({
-                    jobId: job.id,
-                    logs: logBuffer,
-                    result: { env: resolved, success: true },
-                    status: 'completed',
-                });
-                this.log(`Job ${job.id} completed (resolve-env)`);
-                return;
-            }
-            if (job.type === 'deploy' || job.type === 'undeploy') {
-                const deployResult = await this.executeDeployJob(job, executor, cloudBackend, logger);
-                clearInterval(logInterval);
-                clearInterval(heartbeatInterval);
-                await cloudBackend.updateExecutorJob({
-                    jobId: job.id,
-                    logs: logBuffer,
-                    result: deployResult,
-                    status: deployResult.success ? 'completed' : 'failed',
-                });
-                this.log(`Job ${job.id} ${deployResult.success ? 'completed' : 'failed'} (${job.type})`);
-                return;
-            }
-            if (job.type === 'init') {
-                const initResult = await this.executeInitJob(job, executor, logger);
-                clearInterval(logInterval);
-                clearInterval(heartbeatInterval);
-                await cloudBackend.updateExecutorJob({
-                    jobId: job.id,
-                    logs: logBuffer,
-                    result: initResult,
-                    status: initResult.success ? 'completed' : 'failed',
-                });
-                this.log(`Job ${job.id} ${initResult.success ? 'completed' : 'failed'} (init)`);
-                return;
-            }
-            if (job.type === 'app-deploy' || job.type === 'app-destroy') {
-                const appJobResult = await this.executeAppJob(job, cloudBackend, logger);
-                clearInterval(logInterval);
-                clearInterval(heartbeatInterval);
-                await cloudBackend.updateExecutorJob({
-                    jobId: job.id,
-                    logs: logBuffer,
-                    result: appJobResult,
-                    status: appJobResult.success ? 'completed' : 'failed',
-                });
-                this.log(`Job ${job.id} ${appJobResult.success ? 'completed' : 'failed'} (${job.type})`);
-                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);
-            clearInterval(heartbeatInterval);
-            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);
-            clearInterval(heartbeatInterval);
-            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}`);
-        }
-    }
-    async markAppDeploymentFailed(input, cloudBackend) {
-        try {
-            await cloudBackend.updateAppDeployment({
-                lastJobId: input.jobId,
-                name: input.appName,
-                status: 'failed',
-                workspace: input.workspace,
-            });
-        }
-        catch {
-            // best-effort; failure of the PATCH must not bubble out
-        }
+    // Test-friendly delegators kept on the class for backwards compatibility with
+    // tests that call `(cmd as any).executeInitJob(...)` / `executeAppJob(...)`.
+    executeAppJob(job, cloudBackend, logger) {
+        return executeAppJob(job, cloudBackend, logger);
     }
-    async patchAppFinalState(input) {
-        const { appName, cloudBackend, isDeploy, jobId, rootDir, workspace } = input;
-        if (!isDeploy) {
-            const updateResult = await cloudBackend.updateAppDeployment({
-                env: {},
-                lastJobId: jobId,
-                name: appName,
-                status: 'destroyed',
-                workspace,
-            });
-            if (!updateResult.success) {
-                return { reason: `Destroy succeeded but PATCH to deployment failed: ${updateResult.reason}`, success: false };
-            }
-            return { success: true };
-        }
-        // Read .hereya/deploy-env.<workspace>.json that was written by `app deploy --local`.
-        // Filename sanitization MUST match the write side (see `sanitizeWorkspaceForFilename`).
-        const deployEnvFile = path.join(rootDir, '.hereya', `deploy-env.${sanitizeWorkspaceForFilename(workspace)}.json`);
-        let parsed;
-        try {
-            const content = await fs.readFile(deployEnvFile, 'utf8');
-            parsed = JSON.parse(content);
-        }
-        catch (error) {
-            const reason = `Failed to read deploy env file at ${deployEnvFile}: ${error.message}`;
-            await this.markAppDeploymentFailed({ appName, jobId, reason, workspace }, cloudBackend);
-            return { reason, success: false };
-        }
-        const updateResult = await cloudBackend.updateAppDeployment({
-            env: parsed.env ?? {},
-            lastJobId: jobId,
-            name: appName,
-            state: parsed.state,
-            status: 'deployed',
-            workspace,
-        });
-        if (!updateResult.success) {
-            return { reason: `Provisioning succeeded but PATCH to deployment failed: ${updateResult.reason}`, success: false };
-        }
-        return { success: true };
+    executeInitJob(job, executor, logger) {
+        return executeInitJob(job, executor, logger);
     }
 }

package/dist/lib/env/test.setup.d.ts

@@ -0,0 +1,7 @@
+import { EnvManager } from './index.js';
+export interface EnvManagerTestContext {
+    envManager: EnvManager;
+    tempDir: string;
+}
+export declare function setupEnvManagerTest(): Promise<EnvManagerTestContext>;
+export declare function teardownEnvManagerTest(context: EnvManagerTestContext): Promise<void>;

package/dist/lib/env/test.setup.js

@@ -0,0 +1,18 @@
+import { randomUUID } from 'node:crypto';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import * as sinon from 'sinon';
+import { EnvManager } from './index.js';
+export async function setupEnvManagerTest() {
+    const tempDir = path.join(os.tmpdir(), 'hereya-test-env', randomUUID());
+    await fs.mkdir(path.join(tempDir, '.hereya'), { recursive: true });
+    process.env.HEREYA_PROJECT_ROOT_DIR = tempDir;
+    const envManager = new EnvManager();
+    return { envManager, tempDir };
+}
+export async function teardownEnvManagerTest(context) {
+    sinon.restore();
+    await fs.rm(context.tempDir, { force: true, recursive: true });
+    delete process.env.HEREYA_PROJECT_ROOT_DIR;
+}