hereya-cli 0.64.1 → 0.64.3

package/dist/infrastructure/index.js

@@ -41,6 +41,10 @@ export async function destroyPackage(input) {
     if (metadata.deploy && input.skipDeploy) {
         return { env: {}, metadata, pkgName, success: true, version: version || '' };
     }
+    // devDeploy packages are NOT skipped during remove (unlike deploy packages)
+    if (metadata.devDeploy && input.isDeploying) {
+        return { env: {}, metadata, pkgName, success: true, version: version || '' };
+    }
     const { infrastructure } = infrastructure$;
     const backend = await getBackend();
     const id$ = await backend.getProvisioningId({
@@ -67,17 +71,29 @@ export async function destroyPackage(input) {
             projectRootDir: input.projectRootDir,
             version,
         })
-        : await infrastructure.destroy({
-            canonicalName,
-            env: input.env,
-            iacType: metadata.iac,
-            id,
-            logger: input.logger,
-            parameters: input.parameters,
-            pkgName,
-            pkgUrl: packageUri,
-            version,
-        });
+        : metadata.devDeploy
+            ? await infrastructure.destroy({
+                canonicalName,
+                env: { ...input.env, ...input.projectEnv },
+                iacType: metadata.iac,
+                id,
+                logger: input.logger,
+                parameters: input.parameters,
+                pkgName,
+                pkgUrl: packageUri,
+                version,
+            })
+            : await infrastructure.destroy({
+                canonicalName,
+                env: input.env,
+                iacType: metadata.iac,
+                id,
+                logger: input.logger,
+                parameters: input.parameters,
+                pkgName,
+                pkgUrl: packageUri,
+                version,
+            });
     if (!destroyOutput.success) {
         return { reason: destroyOutput.reason, success: false };
     }
@@ -109,6 +125,11 @@ export async function provisionPackage(input) {
     if (metadata.deploy && input.skipDeploy) {
         return { env: {}, metadata, pkgName, success: true, version: version || '' };
     }
+    // devDeploy packages are skipped during the regular provision step (skipDeploy=true)
+    // and ignored during deploy/undeploy (deploy workspaces)
+    if (metadata.devDeploy && (input.skipDeploy || input.isDeploying)) {
+        return { env: {}, metadata, pkgName, success: true, version: version || '' };
+    }
     const dependencies = metadata.dependencies ?? {};
     const depsOutput = await Promise.all(Object.entries(dependencies).map(async ([depName]) => provisionPackage({
         ...input,
@@ -157,17 +178,29 @@ export async function provisionPackage(input) {
             projectRootDir: input.projectRootDir,
             version,
         })
-        : await infrastructure.provision({
-            canonicalName,
-            env: input.env,
-            iacType: metadata.iac,
-            id,
-            logger: input.logger,
-            parameters: input.parameters,
-            pkgName,
-            pkgUrl: packageUri,
-            version,
-        });
+        : metadata.devDeploy
+            ? await infrastructure.provision({
+                canonicalName,
+                env: { ...input.env, ...depsEnv, ...input.projectEnv },
+                iacType: metadata.iac,
+                id,
+                logger: input.logger,
+                parameters: input.parameters,
+                pkgName,
+                pkgUrl: packageUri,
+                version,
+            })
+            : await infrastructure.provision({
+                canonicalName,
+                env: input.env,
+                iacType: metadata.iac,
+                id,
+                logger: input.logger,
+                parameters: input.parameters,
+                pkgName,
+                pkgUrl: packageUri,
+                version,
+            });
     if (!provisionOutput.success) {
         return { reason: provisionOutput.reason, success: false };
     }

package/dist/lib/config/common.d.ts

@@ -21,6 +21,11 @@ export interface Config {
             version: string;
         };
     };
+    devDeploy?: {
+        [key: string]: {
+            version: string;
+        };
+    };
     packages?: {
         [key: string]: {
             version: string;

package/dist/lib/config/simple.js

@@ -4,32 +4,46 @@ import * as yaml from '../yaml-utils.js';
 export class SimpleConfigManager {
     async addPackage(input) {
         const { config } = await this.loadConfig({ projectRootDir: input.projectRootDir });
+        const packageEntry = {
+            version: input.version || '',
+        };
+        let sectionUpdate;
+        if (input.metadata.deploy) {
+            sectionUpdate = {
+                deploy: {
+                    ...config.deploy,
+                    [input.package]: packageEntry,
+                },
+            };
+        }
+        else if (input.metadata.devDeploy) {
+            sectionUpdate = {
+                devDeploy: {
+                    ...config.devDeploy,
+                    [input.package]: packageEntry,
+                },
+            };
+        }
+        else {
+            sectionUpdate = {
+                packages: {
+                    ...config.packages,
+                    [input.package]: {
+                        ...packageEntry,
+                        ...(input.metadata.onDeploy
+                            ? {
+                                onDeploy: {
+                                    ...input.metadata.onDeploy,
+                                },
+                            }
+                            : {}),
+                    },
+                },
+            };
+        }
         await yaml.save({
             ...config,
-            ...(input.metadata.deploy
-                ? {
-                    deploy: {
-                        ...config.deploy,
-                        [input.package]: {
-                            version: input.version || '',
-                        },
-                    },
-                }
-                : {
-                    packages: {
-                        ...config.packages,
-                        [input.package]: {
-                            version: input.version || '',
-                            ...(input.metadata.onDeploy
-                                ? {
-                                    onDeploy: {
-                                        ...input.metadata.onDeploy,
-                                    },
-                                }
-                                : {}),
-                        },
-                    },
-                }),
+            ...sectionUpdate,
         }, await this.getConfigPath(input.projectRootDir));
     }
     async loadConfig(input) {
@@ -44,15 +58,20 @@ export class SimpleConfigManager {
         const { config } = await this.loadConfig({ projectRootDir: input.projectRootDir });
         const newPackages = { ...config.packages };
         const newDeploy = { ...config.deploy };
+        const newDevDeploy = { ...config.devDeploy };
         if (input.metadata.deploy) {
             delete newDeploy[input.package];
         }
+        else if (input.metadata.devDeploy) {
+            delete newDevDeploy[input.package];
+        }
         else {
             delete newPackages[input.package];
         }
         await yaml.save({
             ...config,
             deploy: newDeploy,
+            devDeploy: newDevDeploy,
             packages: newPackages,
         }, await this.getConfigPath(input.projectRootDir));
     }

package/dist/lib/env/index.d.ts

@@ -7,9 +7,11 @@ export declare class EnvManager {
     private extractProfileSections;
     private getEnvPath;
     private getUserEnvPaths;
+    private loadAllDocuments;
     private loadDotEnvFiles;
     private loadFirstDocument;
     private parseDotEnv;
+    private saveAllDocuments;
 }
 export declare const envManager: EnvManager;
 export declare function getEnvManager(): EnvManager;
@@ -18,13 +20,19 @@ export type AddEnvInput = {
         [key: string]: string;
     };
     infra: InfrastructureType;
+    isDevDeploy?: boolean;
+    pkg?: string;
     projectRootDir?: string;
+    snakeCase?: boolean;
     workspace: string;
 };
 export type RemoveEnvInput = AddEnvInput;
 export type GetProjectEnvInput = {
+    excludeDevDeploy?: boolean;
+    excludePkg?: string;
     markSecret?: boolean;
     profile: string;
+    project?: string;
     projectRootDir?: string;
     workspace: string;
 };
@@ -37,3 +45,4 @@ export type GetProjectEnvOutput = {
     reason: string;
     success: false;
 };
+export declare function camelToUpperSnake(str: string): string;

package/dist/lib/env/index.js

@@ -1,22 +1,64 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { getExecutor } from '../../executor/index.js';
+import { stringify } from 'yaml';
+import { getExecutorForWorkspace } from '../../executor/context.js';
 import { getAnyPath } from '../filesystem.js';
 import { stripOrgPrefix } from '../org-utils.js';
-import { load, parseYaml, save } from '../yaml-utils.js';
+import { load, parseYaml } from '../yaml-utils.js';
 export class EnvManager {
     async addProjectEnv(input) {
         const envPath = await this.getEnvPath(input);
-        const { data: existingEnv } = await load(envPath);
+        const documents = await this.loadAllDocuments(envPath);
+        const newDoc = {};
+        if (input.pkg) {
+            newDoc.pkg = input.pkg;
+        }
+        if (input.isDevDeploy) {
+            newDoc.devDeploy = 'true';
+        }
         const newEnv = Object.fromEntries(Object.entries(input.env).map(([key, value]) => [key, `${input.infra}:${value}`]));
-        const finalEnv = { ...existingEnv, ...newEnv };
-        await save(finalEnv, envPath);
+        Object.assign(newDoc, newEnv);
+        if (input.snakeCase) {
+            for (const [key, value] of Object.entries(newEnv)) {
+                const snakeKey = camelToUpperSnake(key);
+                if (snakeKey !== key) {
+                    newDoc[snakeKey] = value;
+                }
+            }
+        }
+        if (input.pkg) {
+            const idx = documents.findIndex(d => d.pkg === input.pkg);
+            if (idx === -1) {
+                documents.push(newDoc);
+            }
+            else {
+                documents[idx] = newDoc;
+            }
+        }
+        else {
+            documents[0] = { ...documents[0], ...newDoc };
+        }
+        await this.saveAllDocuments(documents, envPath);
     }
     async getProjectEnv(input) {
         const envPath = await this.getEnvPath(input);
-        const { data: env, found } = await load(envPath);
+        const documents = await this.loadAllDocuments(envPath);
+        const mergedEnv = {};
+        for (const doc of documents) {
+            if (doc.pkg) {
+                if (input.excludeDevDeploy && doc.devDeploy === 'true')
+                    continue;
+                if (input.excludePkg && doc.pkg === input.excludePkg)
+                    continue;
+            }
+            for (const [key, value] of Object.entries(doc)) {
+                if (key === 'pkg' || key === 'devDeploy')
+                    continue;
+                mergedEnv[key] = value;
+            }
+        }
         let resolvedEnv = {};
-        const executor$ = getExecutor();
+        const executor$ = await getExecutorForWorkspace(input.workspace, input.project);
         if (!executor$.success) {
             return {
                 reason: executor$.reason,
@@ -30,8 +72,8 @@ export class EnvManager {
         if (input.markSecret && Object.keys(dotEnv).length > 0) {
             dotEnv = Object.fromEntries(Object.entries(dotEnv).map(([key, value]) => [key, `secret://${value}`]));
         }
-        if (found) {
-            resolvedEnv = await executor.resolveEnvValues({ env, markSecret: input.markSecret });
+        if (Object.keys(mergedEnv).length > 0) {
+            resolvedEnv = await executor.resolveEnvValues({ env: mergedEnv, markSecret: input.markSecret });
         }
         const userEnvPaths = await this.getUserEnvPaths(input.profile, input.projectRootDir);
         let userMergedEnv = {};
@@ -64,13 +106,29 @@ export class EnvManager {
     }
     async removeProjectEnv(input) {
         const envPath = await this.getEnvPath(input);
-        const { data: existingEnv, found } = await load(envPath);
-        if (!found) {
-            return;
+        const documents = await this.loadAllDocuments(envPath);
+        if (input.pkg) {
+            // Remove tagged document
+            const filtered = documents.filter(d => d.pkg !== input.pkg);
+            // Also remove matching keys from untagged (legacy) document for backward compat
+            if (filtered.length > 0 && !filtered[0].pkg) {
+                const envKeysToRemove = Object.keys(input.env);
+                const allKeysToRemove = input.snakeCase
+                    ? new Set([...envKeysToRemove, ...envKeysToRemove.map(k => camelToUpperSnake(k))])
+                    : new Set(envKeysToRemove);
+                filtered[0] = Object.fromEntries(Object.entries(filtered[0]).filter(([key]) => !allKeysToRemove.has(key)));
+            }
+            await this.saveAllDocuments(filtered, envPath);
+        }
+        else {
+            // Legacy: filter individual keys from first document
+            const envKeysToRemove = Object.keys(input.env);
+            const allKeysToRemove = input.snakeCase
+                ? new Set([...envKeysToRemove, ...envKeysToRemove.map(k => camelToUpperSnake(k))])
+                : new Set(envKeysToRemove);
+            documents[0] = Object.fromEntries(Object.entries(documents[0]).filter(([key]) => !allKeysToRemove.has(key)));
+            await this.saveAllDocuments(documents, envPath);
         }
-        const envKeysToRemove = Object.keys(input.env);
-        const finalEnv = Object.fromEntries(Object.entries(existingEnv).filter(([key]) => !envKeysToRemove.includes(key)));
-        await save(finalEnv, envPath);
     }
     async extractProfileSections(filePath, targetProfile) {
         if (!filePath)
@@ -113,6 +171,23 @@ export class EnvManager {
         ]);
         return paths;
     }
+    async loadAllDocuments(envPath) {
+        try {
+            const content = await fs.readFile(envPath, 'utf8');
+            const rawDocs = content.split(/^---$/m);
+            const parsedDocs = await Promise.all(rawDocs
+                .filter(raw => raw.trim())
+                .map(async (raw) => {
+                const { data } = await parseYaml(raw);
+                return data && Object.keys(data).length > 0 ? data : null;
+            }));
+            const documents = parsedDocs.filter((d) => d !== null);
+            return documents.length > 0 ? documents : [{}];
+        }
+        catch {
+            return [{}];
+        }
+    }
     // Load .env files from project root
     async loadDotEnvFiles(profile, projectRootDir) {
         const rootDir = projectRootDir ?? process.cwd();
@@ -175,8 +250,19 @@ export class EnvManager {
         }
         return result;
     }
+    async saveAllDocuments(documents, envPath) {
+        await fs.mkdir(path.dirname(envPath), { recursive: true });
+        const yamlDocs = documents
+            .filter(d => Object.keys(d).length > 0)
+            .map(d => stringify(d));
+        const content = yamlDocs.length > 0 ? yamlDocs.join('---\n') : stringify({});
+        await fs.writeFile(envPath, content, 'utf8');
+    }
 }
 export const envManager = new EnvManager();
 export function getEnvManager() {
     return envManager;
 }
+export function camelToUpperSnake(str) {
+    return str.replaceAll(/([a-z0-9])([A-Z])/g, '$1_$2').toUpperCase();
+}

package/dist/lib/package/index.d.ts

@@ -32,8 +32,10 @@ export type ResolvePackageOutput = {
 export declare const PackageMetadata: z.ZodObject<{
     dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     deploy: z.ZodOptional<z.ZodBoolean>;
+    devDeploy: z.ZodOptional<z.ZodBoolean>;
     iac: z.ZodNativeEnum<typeof IacType>;
     infra: z.ZodNativeEnum<typeof InfrastructureType>;
+    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>>;
     onDeploy: z.ZodOptional<z.ZodObject<{
         pkg: z.ZodString;
         version: z.ZodString;
@@ -45,25 +47,35 @@ export declare const PackageMetadata: z.ZodObject<{
         pkg: string;
     }>>;
     originalInfra: z.ZodOptional<z.ZodNativeEnum<typeof InfrastructureType>>;
+    outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>>;
+    snakeCase: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     infra: InfrastructureType;
     iac: IacType;
     dependencies?: Record<string, string> | undefined;
     deploy?: boolean | undefined;
+    devDeploy?: boolean | undefined;
+    inputs?: Record<string, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">> | undefined;
     onDeploy?: {
         version: string;
         pkg: string;
     } | undefined;
     originalInfra?: InfrastructureType | undefined;
+    outputs?: Record<string, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">> | undefined;
+    snakeCase?: boolean | undefined;
 }, {
     infra: InfrastructureType;
     iac: IacType;
     dependencies?: Record<string, string> | undefined;
     deploy?: boolean | undefined;
+    devDeploy?: boolean | undefined;
+    inputs?: Record<string, z.objectInputType<{}, z.ZodTypeAny, "passthrough">> | undefined;
     onDeploy?: {
         version: string;
         pkg: string;
     } | undefined;
     originalInfra?: InfrastructureType | undefined;
+    outputs?: Record<string, z.objectInputType<{}, z.ZodTypeAny, "passthrough">> | undefined;
+    snakeCase?: boolean | undefined;
 }>;
 export type IPackageMetadata = z.infer<typeof PackageMetadata>;

package/dist/lib/package/index.js

@@ -77,8 +77,10 @@ export async function downloadPackage(pkgUrl, destPath) {
 export const PackageMetadata = z.object({
     dependencies: z.record(z.string()).optional(),
     deploy: z.boolean().optional(),
+    devDeploy: z.boolean().optional(),
     iac: z.nativeEnum(IacType),
     infra: z.nativeEnum(InfrastructureType),
+    inputs: z.record(z.object({}).passthrough()).optional(),
     onDeploy: z
         .object({
         pkg: z.string(),
@@ -86,6 +88,8 @@ export const PackageMetadata = z.object({
     })
         .optional(),
     originalInfra: z.nativeEnum(InfrastructureType).optional(),
+    outputs: z.record(z.object({}).passthrough()).optional(),
+    snakeCase: z.boolean().optional(),
 });
 // Helper function to parse package spec into name and version
 function parsePackageSpec(spec) {