hereya-cli 0.64.1 → 0.64.3

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

@@ -126,6 +126,37 @@ export class CloudBackend {
             success: true,
         };
     }
+    async generateExecutorToken(input) {
+        const response = await fetch(`${this.config.url}/api/workspaces/${encodeURIComponent(input.workspace)}/executor-token`, {
+            headers: { 'Authorization': `Bearer ${this.config.accessToken}` },
+            method: 'POST',
+        });
+        if (!response.ok) {
+            const error = await response.json();
+            return { reason: error.error || 'Failed to generate executor token', success: false };
+        }
+        const result = await response.json();
+        return { success: true, token: result.token };
+    }
+    async getExecutorJobStatus(input) {
+        const url = new URL(`${this.config.url}/api/workspaces/${encodeURIComponent(input.workspace)}/jobs/${encodeURIComponent(input.jobId)}`);
+        if (input.poll) {
+            url.searchParams.set('poll', 'true');
+        }
+        if (input.lastStatus) {
+            url.searchParams.set('lastStatus', input.lastStatus);
+        }
+        const response = await fetch(url.toString(), {
+            headers: { 'Authorization': `Bearer ${this.config.accessToken}` },
+            method: 'GET',
+        });
+        if (!response.ok) {
+            const error = await response.json();
+            return { reason: error.error || 'Failed to get job status', success: false };
+        }
+        const result = await response.json();
+        return { job: result.job, success: true };
+    }
     async getPackageByVersion(name, version) {
         const response = await fetch(`${this.config.url}/api/registry/packages/${encodeURIComponent(name)}/${encodeURIComponent(version)}`, {
             headers: {
@@ -411,6 +442,18 @@ export class CloudBackend {
         const result = await response.json();
         return result.workspaces.map((workspace) => workspace.name);
     }
+    async pollExecutorJobs(input) {
+        const response = await fetch(`${this.config.url}/api/executor/jobs?workspace=${encodeURIComponent(input.workspace)}`, {
+            headers: { 'Authorization': `Bearer ${this.config.accessToken}` },
+            method: 'GET',
+        });
+        if (!response.ok) {
+            const error = await response.json();
+            return { reason: error.error || 'Failed to poll for jobs', success: false };
+        }
+        const result = await response.json();
+        return { job: result.job, success: true };
+    }
     async publishPackage(input) {
         const formData = new FormData();
         formData.append('name', input.name);
@@ -533,6 +576,17 @@ export class CloudBackend {
             workspace: this.convertWorkspace(result.workspace),
         };
     }
+    async revokeExecutorToken(input) {
+        const response = await fetch(`${this.config.url}/api/workspaces/${encodeURIComponent(input.workspace)}/executor-token`, {
+            headers: { 'Authorization': `Bearer ${this.config.accessToken}` },
+            method: 'DELETE',
+        });
+        if (!response.ok) {
+            const error = await response.json();
+            return { reason: error.error || 'Failed to revoke executor token', success: false };
+        }
+        return { success: true };
+    }
     async saveState(config, workspace) {
         const formData = new FormData();
         if (workspace) {
@@ -622,6 +676,22 @@ export class CloudBackend {
             success: true,
         };
     }
+    async submitExecutorJob(input) {
+        const formData = new FormData();
+        formData.append('type', input.type);
+        formData.append('payload', JSON.stringify(input.payload));
+        const response = await fetch(`${this.config.url}/api/workspaces/${encodeURIComponent(input.workspace)}/jobs`, {
+            body: formData,
+            headers: { 'Authorization': `Bearer ${this.config.accessToken}` },
+            method: 'POST',
+        });
+        if (!response.ok) {
+            const error = await response.json();
+            return { reason: error.error || 'Failed to submit executor job', success: false };
+        }
+        const result = await response.json();
+        return { jobId: result.jobId, success: true };
+    }
     async unsetEnvVar(input) {
         const response = await fetch(`${this.config.url}/api/workspaces/${encodeURIComponent(input.workspace)}/env/${encodeURIComponent(input.name)}`, {
             headers: {
@@ -639,11 +709,36 @@ export class CloudBackend {
             success: true,
         };
     }
+    async updateExecutorJob(input) {
+        const formData = new FormData();
+        if (input.logs) {
+            formData.append('logs', input.logs);
+        }
+        if (input.status) {
+            formData.append('status', input.status);
+        }
+        if (input.result) {
+            formData.append('result', JSON.stringify(input.result));
+        }
+        const response = await fetch(`${this.config.url}/api/executor/jobs/${encodeURIComponent(input.jobId)}`, {
+            body: formData,
+            headers: { 'Authorization': `Bearer ${this.config.accessToken}` },
+            method: 'PATCH',
+        });
+        if (!response.ok) {
+            const error = await response.json();
+            return { reason: error.error || 'Failed to update job', success: false };
+        }
+        return { success: true };
+    }
     async updateWorkspace(input) {
         const formData = new FormData();
         if (input.profile !== undefined) {
             formData.append('profile', input.profile === null ? '' : input.profile);
         }
+        if (input.hasExecutor !== undefined) {
+            formData.append('hasExecutor', input.hasExecutor === null ? '' : String(input.hasExecutor));
+        }
         if (input.isDeploy !== undefined) {
             formData.append('isDeploy', input.isDeploy === null ? '' : String(input.isDeploy));
         }
@@ -693,6 +788,7 @@ export class CloudBackend {
         }
         return {
             env,
+            hasExecutor: workspace.hasExecutor ?? undefined,
             id: workspace.id,
             isDeploy: workspace.isDeploy,
             mirrorOf: workspace.mirrorOf?.name,

package/dist/backend/common.d.ts

@@ -27,6 +27,7 @@ export interface Backend {
 }
 export declare const WorkspaceSchema: z.ZodObject<{
     env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    hasExecutor: z.ZodOptional<z.ZodBoolean>;
     id: z.ZodString;
     isDeploy: z.ZodOptional<z.ZodBoolean>;
     mirrorOf: z.ZodOptional<z.ZodString>;
@@ -51,6 +52,7 @@ export declare const WorkspaceSchema: z.ZodObject<{
         parameters?: Record<string, any> | undefined;
     }> | undefined;
     profile?: string | undefined;
+    hasExecutor?: boolean | undefined;
     isDeploy?: boolean | undefined;
     mirrorOf?: string | undefined;
 }, {
@@ -62,6 +64,7 @@ export declare const WorkspaceSchema: z.ZodObject<{
         parameters?: Record<string, any> | undefined;
     }> | undefined;
     profile?: string | undefined;
+    hasExecutor?: boolean | undefined;
     isDeploy?: boolean | undefined;
     mirrorOf?: string | undefined;
 }>;
@@ -222,6 +225,7 @@ export type UnsetEnvVarInput = {
 };
 export type UnsetEnvVarOutput = SetEnvVarOutput;
 export type UpdateWorkspaceInput = {
+    hasExecutor?: boolean | null;
     isDeploy?: boolean | null;
     name: string;
     profile?: null | string;

package/dist/backend/common.js

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 export const WorkspaceSchema = z.object({
     env: z.record(z.string()).optional(),
+    hasExecutor: z.boolean().optional(),
     id: z.string().min(2),
     isDeploy: z.boolean().optional(),
     mirrorOf: z.string().optional(),

package/dist/backend/index.d.ts

@@ -1,5 +1,9 @@
 import { Backend } from './common.js';
-export declare function getBackend(type?: BackendType): Promise<Backend>;
+export interface GetBackendOptions {
+    token?: string;
+    url?: string;
+}
+export declare function getBackend(typeOrOptions?: BackendType | GetBackendOptions): Promise<Backend>;
 export declare function clearBackend(): void;
 export declare function setBackendType(type: BackendType): void;
 export declare enum BackendType {

package/dist/backend/index.js

@@ -1,11 +1,54 @@
 import { getAwsConfig } from '../infrastructure/aws-config.js';
 import { CloudBackend } from './cloud/cloud-backend.js';
-import { refreshToken } from './cloud/login.js';
+import { loginWithToken, refreshToken } from './cloud/login.js';
 import { getCloudCredentials, loadBackendConfig, saveCloudCredentials } from './config.js';
 import { LocalFileBackend } from './local.js';
 import { S3FileBackend } from './s3.js';
 let backend;
 let currentBackendType;
+function sleep(ms) {
+    return new Promise(resolve => {
+        setTimeout(resolve, ms);
+    });
+}
+async function refreshCloudCredentials(cloudConfig) {
+    const maxAttempts = 3;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        // Re-read credentials from disk on each attempt, as another process may have refreshed them
+        // eslint-disable-next-line no-await-in-loop
+        const credentials = await getCloudCredentials(cloudConfig.clientId);
+        if (!credentials) {
+            throw new Error('Cloud credentials not found. Please run `hereya login` first.');
+        }
+        let { accessToken, refreshToken: refreshTokenValue } = credentials;
+        // If token is still valid (possibly refreshed by another process), we're done
+        if (!isTokenExpired(accessToken)) {
+            return { accessToken, refreshToken: refreshTokenValue };
+        }
+        // Token is expired, attempt to refresh
+        // eslint-disable-next-line no-await-in-loop
+        const refreshResult = await refreshToken(cloudConfig.url, refreshTokenValue);
+        if (refreshResult.success) {
+            accessToken = refreshResult.accessToken;
+            refreshTokenValue = refreshResult.refreshToken;
+            // eslint-disable-next-line no-await-in-loop
+            await saveCloudCredentials({
+                accessToken,
+                clientId: cloudConfig.clientId,
+                refreshToken: refreshTokenValue,
+                url: cloudConfig.url,
+            });
+            return { accessToken, refreshToken: refreshTokenValue };
+        }
+        // Refresh failed — another process may have consumed the refresh token.
+        // Wait with backoff before retrying so the other process can finish saving new credentials.
+        if (attempt < maxAttempts) {
+            // eslint-disable-next-line no-await-in-loop
+            await sleep(attempt * 500);
+        }
+    }
+    throw new Error('Failed to refresh token. Please run `hereya login` again.');
+}
 function isTokenExpired(token) {
     try {
         const payload = JSON.parse(Buffer.from(token.split('.')[1], 'base64').toString());
@@ -19,10 +62,26 @@ function isTokenExpired(token) {
         return true;
     }
 }
-export async function getBackend(type) {
+export async function getBackend(typeOrOptions) {
     if (backend) {
         return backend;
     }
+    // Handle token-based auth
+    if (typeOrOptions && typeof typeOrOptions === 'object' && typeOrOptions.token) {
+        const url = typeOrOptions.url || 'https://cloud.hereya.dev';
+        const result = await loginWithToken(url, typeOrOptions.token);
+        if (!result.success) {
+            throw new Error(`Failed to authenticate with token: ${result.error}`);
+        }
+        backend = new CloudBackend({
+            accessToken: result.accessToken,
+            clientId: result.clientId,
+            refreshToken: result.refreshToken,
+            url,
+        });
+        return backend;
+    }
+    const type = typeof typeOrOptions === 'string' ? typeOrOptions : undefined;
     const backendConfig = await loadBackendConfig();
     const backendType = type ?? currentBackendType ?? backendConfig.current;
     switch (backendType) {
@@ -30,26 +89,7 @@ export async function getBackend(type) {
             if (!backendConfig.cloud) {
                 throw new Error('Cloud credentials not found. Please run `hereya login` first.');
             }
-            const credentials = await getCloudCredentials(backendConfig.cloud.clientId);
-            if (!credentials) {
-                throw new Error('Cloud credentials not found. Please run `hereya login` first.');
-            }
-            let { accessToken, refreshToken: refreshTokenValue } = credentials;
-            // Check if token is expired and refresh if necessary
-            if (isTokenExpired(accessToken)) {
-                const refreshResult = await refreshToken(backendConfig.cloud.url, refreshTokenValue);
-                if (!refreshResult.success) {
-                    throw new Error('Failed to refresh token. Please run `hereya login` again.');
-                }
-                accessToken = refreshResult.accessToken;
-                refreshTokenValue = refreshResult.refreshToken;
-                await saveCloudCredentials({
-                    accessToken,
-                    clientId: backendConfig.cloud.clientId,
-                    refreshToken: refreshTokenValue,
-                    url: backendConfig.cloud.url,
-                });
-            }
+            const { accessToken, refreshToken: refreshTokenValue } = await refreshCloudCredentials(backendConfig.cloud);
             backend = new CloudBackend({
                 accessToken,
                 clientId: backendConfig.cloud.clientId,

package/dist/commands/add/index.js

@@ -1,7 +1,7 @@
 import { Args, Command, Flags } from '@oclif/core';
 import { Listr, ListrLogger, ListrLogLevels } from 'listr2';
 import { getBackend } from '../../backend/index.js';
-import { getExecutor } from '../../executor/index.js';
+import { getExecutorForWorkspace } from '../../executor/context.js';
 import { getConfigManager } from '../../lib/config/index.js';
 import { logEnv } from '../../lib/env-utils.js';
 import { getEnvManager } from '../../lib/env/index.js';
@@ -107,7 +107,7 @@ export default class Add extends Command {
                                 persistentOutput: isDebug(),
                             },
                             async task(ctx, task) {
-                                const executor$ = getExecutor();
+                                const executor$ = await getExecutorForWorkspace(ctx.workspace, ctx.configOutput.config.project);
                                 if (!executor$.success) {
                                     throw new Error(executor$.reason);
                                 }
@@ -135,7 +135,9 @@ export default class Add extends Command {
                                 await envManager.addProjectEnv({
                                     env,
                                     infra: metadata.originalInfra ?? metadata.infra,
+                                    pkg: ctx.provisionOutput.pkgName,
                                     projectRootDir,
+                                    snakeCase: metadata.snakeCase,
                                     workspace: ctx.workspace,
                                 });
                                 await delay(500);
@@ -176,6 +178,111 @@ export default class Add extends Command {
                             },
                             title: 'Saving state',
                         },
+                        {
+                            async task(ctx) {
+                                const configManager = getConfigManager();
+                                const { config } = await configManager.loadConfig({ projectRootDir });
+                                const devDeploy = config.devDeploy ?? {};
+                                if (Object.keys(devDeploy).length === 0) {
+                                    return;
+                                }
+                                const backend = await getBackend();
+                                const profile = await getProfileFromWorkspace(backend, ctx.workspace, ctx.configOutput.config.project);
+                                const envManager = getEnvManager();
+                                const getProjectEnvOutput = await envManager.getProjectEnv({
+                                    excludeDevDeploy: true,
+                                    markSecret: false,
+                                    profile,
+                                    project: ctx.configOutput.config.project,
+                                    projectRootDir,
+                                    workspace: ctx.workspace,
+                                });
+                                if (!getProjectEnvOutput.success) {
+                                    throw new Error(getProjectEnvOutput.reason);
+                                }
+                                ctx.projectEnv = getProjectEnvOutput.env;
+                                // Update configOutput with fresh config
+                                ctx.configOutput = { config, found: true };
+                                await delay(500);
+                            },
+                            title: 'Loading project environment',
+                        },
+                        {
+                            skip(ctx) {
+                                const devDeploy = ctx.configOutput.config.devDeploy ?? {};
+                                return Object.keys(devDeploy).length === 0;
+                            },
+                            async task(ctx, task) {
+                                const configManager = getConfigManager();
+                                const { config } = await configManager.loadConfig({ projectRootDir });
+                                const devDeployPackages = config.devDeploy ?? {};
+                                const devDeployEntries = Object.entries(devDeployPackages).map(([name, info]) => ({
+                                    name,
+                                    packageSpec: info.version ? `${name}@${info.version}` : name,
+                                    version: info.version || '',
+                                }));
+                                return task.newListr(devDeployEntries.map((pkg) => ({
+                                    rendererOptions: {
+                                        persistentOutput: isDebug(),
+                                    },
+                                    async task(_, task) {
+                                        const parameterManager = getParameterManager();
+                                        const backend = await getBackend();
+                                        const profile = await getProfileFromWorkspace(backend, ctx.workspace, ctx.configOutput.config.project);
+                                        const { parameters } = await parameterManager.getPackageParameters({
+                                            package: pkg.name,
+                                            profile,
+                                            projectRootDir,
+                                        });
+                                        const executor$ = await getExecutorForWorkspace(ctx.workspace, ctx.configOutput.config.project);
+                                        if (!executor$.success) {
+                                            throw new Error(executor$.reason);
+                                        }
+                                        const { executor } = executor$;
+                                        const provisionOutput = await executor.provision({
+                                            logger: getLogger(task),
+                                            package: pkg.packageSpec,
+                                            parameters,
+                                            project: ctx.configOutput.config.project,
+                                            projectEnv: ctx.projectEnv ?? {},
+                                            workspace: ctx.workspace,
+                                        });
+                                        if (!provisionOutput.success) {
+                                            throw new Error(provisionOutput.reason);
+                                        }
+                                        const { env, metadata } = provisionOutput;
+                                        const output = ctx.devDeployAdded || [];
+                                        output.push({ env, metadata, packageName: pkg.name });
+                                        ctx.devDeployAdded = output;
+                                    },
+                                    title: `Provisioning ${pkg.name}`,
+                                })), { concurrent: true, rendererOptions: { collapseSubtasks: !isDebug() } });
+                            },
+                            title: 'Provisioning devDeploy packages',
+                        },
+                        {
+                            skip: (ctx) => !ctx.devDeployAdded || ctx.devDeployAdded.length === 0,
+                            async task(ctx) {
+                                if (!ctx.devDeployAdded || ctx.devDeployAdded.length === 0) {
+                                    return;
+                                }
+                                const envManager = getEnvManager();
+                                for (const { env, metadata, packageName } of ctx.devDeployAdded) {
+                                    // eslint-disable-next-line no-await-in-loop
+                                    await envManager.addProjectEnv({
+                                        env,
+                                        infra: metadata.originalInfra ?? metadata.infra,
+                                        isDevDeploy: true,
+                                        pkg: packageName,
+                                        projectRootDir,
+                                        snakeCase: metadata.snakeCase,
+                                        workspace: ctx.workspace,
+                                    });
+                                }
+                                await delay(500);
+                            },
+                            title: 'Adding env vars from devDeploy packages',
+                        },
                     ], { concurrent: false, rendererOptions: { collapseSubtasks: !isDebug() } });
                 },
                 title: `Adding ${args.package}`,

package/dist/commands/deploy/index.js

@@ -81,6 +81,7 @@ export default class Deploy extends Command {
                     const getProjectEnvOutput = await envManager.getProjectEnv({
                         markSecret: true,
                         profile,
+                        project: ctx.configOutput.config.project,
                         projectRootDir,
                         workspace: ctx.workspace,
                     });
@@ -267,12 +268,14 @@ export default class Deploy extends Command {
                         return;
                     }
                     const envManager = getEnvManager();
-                    for (const { env, metadata } of ctx.removed) {
+                    for (const { env, metadata, packageName } of ctx.removed) {
                         // eslint-disable-next-line no-await-in-loop
                         await envManager.removeProjectEnv({
                             env,
                             infra: metadata.originalInfra ?? metadata.infra,
+                            pkg: packageName,
                             projectRootDir,
+                            snakeCase: metadata.snakeCase,
                             workspace: ctx.workspace,
                         });
                     }
@@ -287,12 +290,14 @@ export default class Deploy extends Command {
                         return;
                     }
                     const envManager = getEnvManager();
-                    for (const { env, metadata } of ctx.added) {
+                    for (const { env, metadata, packageName } of ctx.added) {
                         // eslint-disable-next-line no-await-in-loop
                         await envManager.addProjectEnv({
                             env,
                             infra: metadata.originalInfra ?? metadata.infra,
+                            pkg: packageName,
                             projectRootDir,
+                            snakeCase: metadata.snakeCase,
                             workspace: ctx.workspace,
                         });
                     }
@@ -319,6 +324,7 @@ export default class Deploy extends Command {
                     const getProjectEnvOutput = await envManager.getProjectEnv({
                         markSecret: true,
                         profile,
+                        project: ctx.configOutput.config.project,
                         projectRootDir,
                         workspace: ctx.workspace,
                     });

package/dist/commands/docker/run/index.js

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

package/dist/commands/down/index.js

@@ -1,7 +1,7 @@
 import { Command, Flags } from '@oclif/core';
 import { Listr, ListrLogger, ListrLogLevels } from 'listr2';
 import { getBackend } from '../../backend/index.js';
-import { getExecutor } from '../../executor/index.js';
+import { getExecutorForWorkspace } from '../../executor/context.js';
 import { getConfigManager } from '../../lib/config/index.js';
 import { getEnvManager } from '../../lib/env/index.js';
 import { getLogger, getLogPath, isDebug, setDebug } from '../../lib/log.js';
@@ -115,10 +115,116 @@ export default class Down extends Command {
                                     packagesWithVersions = selectedPackages;
                                 }
                                 ctx.packages = [...packagesWithVersions, ...removedPackagesWithVersions];
+                                // Collect devDeploy packages from config and saved state
+                                const configDevDeploy = ctx.configOutput.config.devDeploy ?? {};
+                                const devDeployFromConfig = Object.entries(configDevDeploy).map(([name, info]) => ({
+                                    name,
+                                    packageSpec: info.version ? `${name}@${info.version}` : name,
+                                    version: info.version || '',
+                                }));
+                                let devDeployFromState = [];
+                                if (savedStateOutput.found) {
+                                    const savedDevDeploy = savedStateOutput.config.devDeploy ?? {};
+                                    devDeployFromState = Object.entries(savedDevDeploy)
+                                        .filter(([name]) => !configDevDeploy[name])
+                                        .map(([name, info]) => ({
+                                        name,
+                                        packageSpec: info.version ? `${name}@${info.version}` : name,
+                                        version: info.version || '',
+                                    }));
+                                }
+                                ctx.devDeployPackages = [...devDeployFromConfig, ...devDeployFromState];
                                 await delay(500);
                             },
                             title: 'Identifying packages to destroy',
                         },
+                        {
+                            skip: (ctx) => !ctx.devDeployPackages || ctx.devDeployPackages.length === 0,
+                            async task(ctx) {
+                                // Load project env for devDeploy destroy
+                                const backend = await getBackend();
+                                const profile = await getProfileFromWorkspace(backend, ctx.workspace, ctx.configOutput.config.project);
+                                const envManager = getEnvManager();
+                                const getProjectEnvOutput = await envManager.getProjectEnv({
+                                    excludeDevDeploy: true,
+                                    markSecret: false,
+                                    profile,
+                                    project: ctx.configOutput.config.project,
+                                    projectRootDir,
+                                    workspace: ctx.workspace,
+                                });
+                                if (!getProjectEnvOutput.success) {
+                                    throw new Error(getProjectEnvOutput.reason);
+                                }
+                                ctx.projectEnv = getProjectEnvOutput.env;
+                                await delay(500);
+                            },
+                            title: 'Loading project environment for devDeploy',
+                        },
+                        {
+                            skip: (ctx) => !ctx.devDeployPackages || ctx.devDeployPackages.length === 0,
+                            async task(ctx) {
+                                return task.newListr(ctx.devDeployPackages.map((pkg) => ({
+                                    rendererOptions: {
+                                        persistentOutput: isDebug(),
+                                    },
+                                    async task(_, task) {
+                                        const parameterManager = getParameterManager();
+                                        const backend = await getBackend();
+                                        const profile = await getProfileFromWorkspace(backend, ctx.workspace, ctx.configOutput.config.project);
+                                        const { parameters } = await parameterManager.getPackageParameters({
+                                            package: pkg.name,
+                                            profile,
+                                            projectRootDir,
+                                        });
+                                        const executor$ = await getExecutorForWorkspace(ctx.workspace, ctx.configOutput.config.project);
+                                        if (!executor$.success) {
+                                            throw new Error(executor$.reason);
+                                        }
+                                        const { executor } = executor$;
+                                        const destroyOutput = await executor.destroy({
+                                            logger: getLogger(task),
+                                            package: pkg.packageSpec,
+                                            parameters,
+                                            project: ctx.configOutput.config.project,
+                                            projectEnv: ctx.projectEnv,
+                                            workspace: ctx.workspace,
+                                        });
+                                        if (!destroyOutput.success) {
+                                            throw new Error(destroyOutput.reason);
+                                        }
+                                        const { env, metadata } = destroyOutput;
+                                        const output = ctx.devDeployDestroyed || [];
+                                        output.push({ env, metadata, packageName: pkg.name });
+                                        ctx.devDeployDestroyed = output;
+                                    },
+                                    title: `Destroying ${pkg.name}`,
+                                })), { concurrent: true, rendererOptions: { collapseSubtasks: !isDebug() } });
+                            },
+                            title: 'Destroying devDeploy packages',
+                        },
+                        {
+                            skip: (ctx) => !ctx.devDeployDestroyed || ctx.devDeployDestroyed.length === 0,
+                            async task(ctx) {
+                                if (!ctx.devDeployDestroyed || ctx.devDeployDestroyed.length === 0) {
+                                    return;
+                                }
+                                const envManager = getEnvManager();
+                                for (const { env, metadata, packageName } of ctx.devDeployDestroyed) {
+                                    // eslint-disable-next-line no-await-in-loop
+                                    await envManager.removeProjectEnv({
+                                        env,
+                                        infra: metadata.originalInfra ?? metadata.infra,
+                                        pkg: packageName,
+                                        projectRootDir,
+                                        snakeCase: metadata.snakeCase,
+                                        workspace: ctx.workspace,
+                                    });
+                                }
+                                await delay(500);
+                            },
+                            title: 'Removing env vars from devDeploy packages',
+                        },
                         {
                             skip: (ctx) => !ctx.packages || ctx.packages.length === 0,
                             async task(ctx) {
@@ -138,7 +244,7 @@ export default class Down extends Command {
                                             profile,
                                             projectRootDir,
                                         });
-                                        const executor$ = getExecutor();
+                                        const executor$ = await getExecutorForWorkspace(ctx.workspace, ctx.configOutput.config.project);
                                         if (!executor$.success) {
                                             throw new Error(executor$.reason);
                                         }
@@ -173,12 +279,14 @@ export default class Down extends Command {
                                     return;
                                 }
                                 const envManager = getEnvManager();
-                                for (const { env, metadata } of destroyed) {
+                                for (const { env, metadata, packageName } of destroyed) {
                                     // eslint-disable-next-line no-await-in-loop
                                     await envManager.removeProjectEnv({
                                         env,
                                         infra: metadata.originalInfra ?? metadata.infra,
+                                        pkg: packageName,
                                         projectRootDir,
+                                        snakeCase: metadata.snakeCase,
                                         workspace,
                                     });
                                 }

package/dist/commands/env/index.js

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