hereya-cli 0.90.1 → 0.91.0

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

@@ -5,11 +5,19 @@ import { getBackend } from '../../../../backend/index.js';
 import { getExecutor } from '../../../../executor/index.js';
 import { getLogger, getLogPath, isDebug, setDebug } from '../../../../lib/log.js';
 import { delay } from '../../../../lib/shell.js';
-const DEFAULT_EXECUTOR_PACKAGE = 'hereya/remote-executor-aws';
+const ALWAYS_ON_PACKAGE = 'hereya/remote-executor-aws';
+const EPHEMERAL_PACKAGE = 'hereya/aws-executor-broker';
 export default class WorkspaceExecutorUninstall extends Command {
-    static description = 'Uninstall the remote executor from a workspace';
+    static description = `Uninstall the remote executor from a workspace.
+
+The --mode flag must match the mode used at install time (default: ephemeral).`;
     static flags = {
         debug: Flags.boolean({ default: false, description: 'enable debug mode' }),
+        mode: Flags.string({
+            default: 'ephemeral',
+            description: 'executor mode used at install time',
+            options: ['ephemeral', 'always-on'],
+        }),
         workspace: Flags.string({
             char: 'w',
             description: 'name of the workspace',
@@ -20,6 +28,8 @@ export default class WorkspaceExecutorUninstall extends Command {
         const { flags } = await this.parse(WorkspaceExecutorUninstall);
         setDebug(flags.debug);
         const myLogger = new ListrLogger({ useIcons: false });
+        const isEphemeral = flags.mode === 'ephemeral';
+        const executorPackage = isEphemeral ? EPHEMERAL_PACKAGE : ALWAYS_ON_PACKAGE;
         const task = new Listr([
             {
                 async task(_ctx, task) {
@@ -56,7 +66,7 @@ export default class WorkspaceExecutorUninstall extends Command {
                                 const { executor } = executor$;
                                 const destroyOutput = await executor.destroy({
                                     logger: getLogger(task),
-                                    package: DEFAULT_EXECUTOR_PACKAGE,
+                                    package: executorPackage,
                                     skipDeploy: true,
                                     workspace: flags.workspace,
                                 });
@@ -76,6 +86,22 @@ export default class WorkspaceExecutorUninstall extends Command {
                             },
                             title: 'Revoking executor token',
                         },
+                        {
+                            async task() {
+                                const backend = await getBackend();
+                                // Always attempt to unregister the broker. The endpoint
+                                // gracefully no-ops on 404 so this is safe for legacy
+                                // always-on installs that never registered a broker.
+                                const result = await backend.unregisterExecutorBroker({
+                                    workspace: flags.workspace,
+                                });
+                                if (!result.success) {
+                                    throw new Error(`Failed to unregister executor broker: ${result.reason}`);
+                                }
+                                await delay(500);
+                            },
+                            title: 'Unregistering executor broker',
+                        },
                         {
                             async task() {
                                 const backend = await getBackend();
@@ -89,7 +115,7 @@ export default class WorkspaceExecutorUninstall extends Command {
                         },
                     ], { concurrent: false, rendererOptions: { collapseSubtasks: !isDebug() } });
                 },
-                title: `Uninstalling executor from workspace ${flags.workspace}`,
+                title: `Uninstalling executor from workspace ${flags.workspace} (mode: ${flags.mode})`,
             },
         ], { concurrent: false });
         try {

package/dist/executor/local.d.ts

@@ -7,5 +7,4 @@ export declare class LocalExecutor implements Executor {
     setEnvVar(input: ExecutorSetEnvVarInput): Promise<ExecutorSetEnvVarOutput>;
     unsetEnvVar(input: ExecutorUnsetEnvVarInput): Promise<ExecutorUnsetEnvVarOutput>;
     private getWorkspaceEnv;
-    private resolveGithubAppMarkers;
 }

package/dist/executor/local.js

@@ -2,6 +2,7 @@ import { getBackend } from '../backend/index.js';
 import { destroyPackage, getInfrastructure, getProvisioningLogicalId, provisionPackage, resolveEnvValues as resolveEnvValuesSimple } from '../infrastructure/index.js';
 import { mintInstallationToken } from '../lib/github-app.js';
 import { resolvePackage } from '../lib/package/index.js';
+import { resolveEnvValues as resolveEnvValuesPure } from './resolve-env.js';
 export class LocalExecutor {
     async destroy(input) {
         // For apps, we use `app` as the project-name source for workspace env resolution
@@ -70,28 +71,15 @@ export class LocalExecutor {
         });
     }
     async resolveEnvValues(input) {
-        const resolved = Object.fromEntries(await Promise.all(Object.entries(input.env).map(async ([key, value]) => {
-            // Check if value has infra prefix (contains ':' and first part is valid infra)
-            const colonIndex = value.indexOf(':');
-            if (colonIndex === -1) {
-                // No colon - plain value, return as-is
-                return [key, value];
-            }
-            const infraType = value.slice(0, colonIndex);
-            const infra$ = getInfrastructure({ type: infraType });
-            if (!infra$.supported) {
-                // Unknown infra type - treat as plain value, return as-is
-                return [key, value];
-            }
-            const { infrastructure } = infra$;
-            const valueWithoutInfra = value.slice(colonIndex + 1);
-            const { isSecret, value: resolvedValue } = await infrastructure.resolveEnv({
-                value: valueWithoutInfra,
-            });
-            const finalValue = input.markSecret && isSecret ? `secret://${resolvedValue}` : resolvedValue;
-            return [key, finalValue];
-        })));
-        return this.resolveGithubAppMarkers(resolved, input);
+        return resolveEnvValuesPure(input, {
+            getInfrastructure,
+            async getWorkspaceEnv(args) {
+                const backend = await getBackend();
+                return backend.getWorkspaceEnv(args);
+            },
+            mintInstallationToken,
+            resolveSimpleEnv: resolveEnvValuesSimple,
+        });
     }
     async setEnvVar(input) {
         const backend = await getBackend();
@@ -187,44 +175,4 @@ export class LocalExecutor {
             success: true,
         };
     }
-    async resolveGithubAppMarkers(resolved, input) {
-        const needsToken = Object.values(resolved).some((v) => typeof v === 'string' && v.startsWith('github-app:'));
-        if (!needsToken)
-            return resolved;
-        if (!input.workspace || !input.project)
-            return resolved;
-        const backend = await getBackend();
-        const wsEnv$ = await backend.getWorkspaceEnv({
-            project: input.project,
-            workspace: input.workspace,
-        });
-        if (!wsEnv$.success)
-            return resolved;
-        // Use the simple infrastructure resolver - resolves aws: prefixes only and
-        // does NOT recurse into github-app: markers, so no circularity.
-        const wsResolved = await resolveEnvValuesSimple(wsEnv$.env);
-        const appId = wsResolved.hereyaGithubAppId;
-        const installationIdFromEnv = wsResolved.hereyaGithubAppInstallationId;
-        const privateKey = wsResolved.hereyaGithubAppPrivateKey;
-        if (!appId || !privateKey) {
-            console.warn('hereya: github-app marker present but workspace env missing hereyaGithubAppId / hereyaGithubAppPrivateKey; leaving marker unresolved');
-            return resolved;
-        }
-        const out = { ...resolved };
-        for (const [k, v] of Object.entries(resolved)) {
-            if (typeof v !== 'string' || !v.startsWith('github-app:'))
-                continue;
-            const installationId = v.slice('github-app:'.length) || installationIdFromEnv;
-            if (!installationId)
-                continue;
-            try {
-                // eslint-disable-next-line no-await-in-loop
-                out[k] = await mintInstallationToken({ appId, installationId, privateKey });
-            }
-            catch (error) {
-                console.warn(`hereya: failed to mint github-app installation token: ${error.message}`);
-            }
-        }
-        return out;
-    }
 }

package/dist/executor/resolve-env.d.ts

@@ -0,0 +1,88 @@
+import type { GetInfrastructureOutput } from '../infrastructure/registry.js';
+/**
+ * Pure-function env-value resolver, factored out of `LocalExecutor.resolveEnvValues`.
+ *
+ * The functions in this module are deliberately free of any class state
+ * (`this`) or hard-coded global lookups so they can be invoked from contexts
+ * that do not include the full CLI runtime — e.g. the broker Lambda that
+ * imports `hereya-cli` as a published npm dependency.
+ *
+ * Dependencies that the resolver needs (the infrastructure-provider lookup,
+ * the workspace-env lookup, and the GitHub-app installation-token minter) are
+ * all injected via the `providers` argument so callers can supply only the
+ * pieces they have available.
+ */
+import { InfrastructureType } from '../infrastructure/common.js';
+export type ResolveEnvValuesInput = {
+    env: {
+        [key: string]: string;
+    };
+    markSecret?: boolean;
+    project?: string;
+    workspace?: string;
+};
+export type ResolveEnvValuesOutput = {
+    [key: string]: string;
+};
+/**
+ * Look up an infrastructure provider by type. The Lambda passes a thin wrapper
+ * over its registered `aws` provider; the CLI passes the full registry.
+ */
+export type GetInfrastructureFn = (input: {
+    type: InfrastructureType;
+}) => GetInfrastructureOutput;
+/**
+ * Fetch a workspace's stored env values (used to find the GitHub-app
+ * configuration when resolving `github-app:` markers).
+ */
+export type GetWorkspaceEnvFn = (input: {
+    project: string;
+    workspace: string;
+}) => Promise<{
+    env: {
+        [key: string]: string;
+    };
+    success: true;
+} | {
+    reason: string;
+    success: false;
+}>;
+/**
+ * Resolve a workspace env map without recursing into github-app markers.
+ * Used to dereference the `aws:` (or other infra) values for the GitHub-app
+ * config keys.
+ */
+export type ResolveSimpleEnvFn = (env: Record<string, string>) => Promise<Record<string, string>>;
+/**
+ * Mint a GitHub-app installation token.
+ */
+export type MintInstallationTokenFn = (input: {
+    appId: string;
+    installationId: string;
+    privateKey: string;
+}) => Promise<string>;
+export interface ResolveEnvProviders {
+    /** Infrastructure-provider lookup — required. */
+    getInfrastructure: GetInfrastructureFn;
+    /**
+     * Optional GitHub-app dependencies. If any of them is missing, `github-app:`
+     * markers are left unresolved (the Lambda path can choose not to wire
+     * GitHub-app support at all).
+     */
+    getWorkspaceEnv?: GetWorkspaceEnvFn;
+    mintInstallationToken?: MintInstallationTokenFn;
+    resolveSimpleEnv?: ResolveSimpleEnvFn;
+}
+/**
+ * Resolve `infra:` prefixes and `github-app:` markers in an env map. Pure
+ * function — no module-level state, no `this`, side effects are limited to
+ * what the injected providers do.
+ */
+export declare function resolveEnvValues(input: ResolveEnvValuesInput, providers: ResolveEnvProviders): Promise<ResolveEnvValuesOutput>;
+/**
+ * Walk the resolved env, replace any `github-app:<installationId?>` marker
+ * with a freshly-minted installation token. Reads the GitHub-app config from
+ * the workspace env (`hereyaGithubAppId`, `hereyaGithubAppPrivateKey`,
+ * optional `hereyaGithubAppInstallationId`).
+ */
+export declare function resolveGithubAppMarkers(resolved: Record<string, string>, input: ResolveEnvValuesInput, providers: ResolveEnvProviders): Promise<Record<string, string>>;

package/dist/executor/resolve-env.js

@@ -0,0 +1,77 @@
+/**
+ * Resolve `infra:` prefixes and `github-app:` markers in an env map. Pure
+ * function — no module-level state, no `this`, side effects are limited to
+ * what the injected providers do.
+ */
+export async function resolveEnvValues(input, providers) {
+    const resolved = Object.fromEntries(await Promise.all(Object.entries(input.env).map(async ([key, value]) => {
+        // Check if value has infra prefix (contains ':' and first part is valid infra)
+        const colonIndex = value.indexOf(':');
+        if (colonIndex === -1) {
+            // No colon - plain value, return as-is
+            return [key, value];
+        }
+        const infraType = value.slice(0, colonIndex);
+        const infra$ = providers.getInfrastructure({ type: infraType });
+        if (!infra$.supported) {
+            // Unknown infra type - treat as plain value, return as-is
+            return [key, value];
+        }
+        const { infrastructure } = infra$;
+        const valueWithoutInfra = value.slice(colonIndex + 1);
+        const { isSecret, value: resolvedValue } = await infrastructure.resolveEnv({
+            value: valueWithoutInfra,
+        });
+        const finalValue = input.markSecret && isSecret ? `secret://${resolvedValue}` : resolvedValue;
+        return [key, finalValue];
+    })));
+    return resolveGithubAppMarkers(resolved, input, providers);
+}
+/**
+ * Walk the resolved env, replace any `github-app:<installationId?>` marker
+ * with a freshly-minted installation token. Reads the GitHub-app config from
+ * the workspace env (`hereyaGithubAppId`, `hereyaGithubAppPrivateKey`,
+ * optional `hereyaGithubAppInstallationId`).
+ */
+export async function resolveGithubAppMarkers(resolved, input, providers) {
+    const needsToken = Object.values(resolved).some((v) => typeof v === 'string' && v.startsWith('github-app:'));
+    if (!needsToken)
+        return resolved;
+    if (!input.workspace || !input.project)
+        return resolved;
+    const { getWorkspaceEnv, mintInstallationToken, resolveSimpleEnv } = providers;
+    if (!getWorkspaceEnv || !mintInstallationToken || !resolveSimpleEnv)
+        return resolved;
+    const wsEnv$ = await getWorkspaceEnv({
+        project: input.project,
+        workspace: input.workspace,
+    });
+    if (!wsEnv$.success)
+        return resolved;
+    // Use the simple infrastructure resolver - resolves aws: prefixes only and
+    // does NOT recurse into github-app: markers, so no circularity.
+    const wsResolved = await resolveSimpleEnv(wsEnv$.env);
+    const appId = wsResolved.hereyaGithubAppId;
+    const installationIdFromEnv = wsResolved.hereyaGithubAppInstallationId;
+    const privateKey = wsResolved.hereyaGithubAppPrivateKey;
+    if (!appId || !privateKey) {
+        console.warn('hereya: github-app marker present but workspace env missing hereyaGithubAppId / hereyaGithubAppPrivateKey; leaving marker unresolved');
+        return resolved;
+    }
+    const out = { ...resolved };
+    for (const [k, v] of Object.entries(resolved)) {
+        if (typeof v !== 'string' || !v.startsWith('github-app:'))
+            continue;
+        const installationId = v.slice('github-app:'.length) || installationIdFromEnv;
+        if (!installationId)
+            continue;
+        try {
+            // eslint-disable-next-line no-await-in-loop
+            out[k] = await mintInstallationToken({ appId, installationId, privateKey });
+        }
+        catch (error) {
+            console.warn(`hereya: failed to mint github-app installation token: ${error.message}`);
+        }
+    }
+    return out;
+}

package/dist/index.d.ts

@@ -1 +1,4 @@
+export { type GetInfrastructureFn, type GetWorkspaceEnvFn, type MintInstallationTokenFn, type ResolveEnvProviders, resolveEnvValues, type ResolveEnvValuesInput, type ResolveEnvValuesOutput, resolveGithubAppMarkers, type ResolveSimpleEnvFn, } from './executor/resolve-env.js';
+export { InfrastructureType } from './infrastructure/common.js';
+export { awsProviderFactory, getInfrastructure, type GetInfrastructureInput, type GetInfrastructureOutput, type InfrastructureProviderFactory, registerInfrastructureProvider, resetInfrastructureProviders, } from './infrastructure/registry.js';
 export { run } from '@oclif/core';

package/dist/index.js

@@ -1 +1,8 @@
+// Public API for external consumers (e.g. the broker Lambda) that import
+// `hereya-cli` as a published npm dependency. None of these re-exports pull
+// in the `local` infrastructure provider or the rest of the CLI runtime — the
+// Lambda bundle stays slim.
+export { resolveEnvValues, resolveGithubAppMarkers, } from './executor/resolve-env.js';
+export { InfrastructureType } from './infrastructure/common.js';
+export { awsProviderFactory, getInfrastructure, registerInfrastructureProvider, resetInfrastructureProviders, } from './infrastructure/registry.js';
 export { run } from '@oclif/core';

package/dist/infrastructure/index.d.ts

@@ -1,13 +1,19 @@
 import { z } from 'zod';
 import { Logger } from '../lib/log.js';
 import { PackageMetadata } from '../lib/package/index.js';
-import { AwsInfrastructure } from './aws.js';
-import { Infrastructure, InfrastructureType } from './common.js';
-import { LocalInfrastructure } from './local.js';
-export declare const localInfrastructure: LocalInfrastructure;
-export declare const awsInfrastructure: AwsInfrastructure;
+import { Infrastructure } from './common.js';
+import { type InfrastructureProviderFactory } from './registry.js';
+export { awsProviderFactory, getInfrastructure, type GetInfrastructureInput, type GetInfrastructureOutput, type InfrastructureProviderFactory, registerInfrastructureProvider, resetInfrastructureProviders, } from './registry.js';
+/**
+ * Default factory for the local-filesystem provider. Registered eagerly when
+ * this module is imported (the CLI's standard entry point). The broker
+ * Lambda never imports this module, so `LocalInfrastructure` and its
+ * filesystem deps are tree-shaken out of the Lambda bundle.
+ */
+export declare const localProviderFactory: InfrastructureProviderFactory;
+export declare const awsInfrastructure: Infrastructure;
+export declare const localInfrastructure: Infrastructure;
 export declare function resolveEnvValues(env: Record<string, string>): Promise<Record<string, string>>;
-export declare function getInfrastructure(input: GetInfrastructureInput): GetInfrastructureOutput;
 export declare function destroyPackage(input: DestroyPackageInput): Promise<DestroyPackageOutput>;
 export declare function provisionPackage(input: ProvisionPackageInput): Promise<ProvisionPackageOutput>;
 export declare function getProvisioningLogicalId({ app, pkg, project, workspace }: {
@@ -49,14 +55,4 @@ export type ProvisionPackageOutput = {
     reason: string;
     success: false;
 };
-export type GetInfrastructureInput = {
-    type: InfrastructureType;
-};
-export type GetInfrastructureOutput = {
-    infrastructure: Infrastructure;
-    supported: true;
-} | {
-    reason: string;
-    supported: false;
-};
 export type PackageMetadata = z.infer<typeof PackageMetadata>;

package/dist/infrastructure/index.js

@@ -1,11 +1,26 @@
 import { getBackend } from '../backend/index.js';
 import { stripOrgPrefix } from '../lib/org-utils.js';
 import { resolvePackage } from '../lib/package/index.js';
-import { AwsInfrastructure } from './aws.js';
 import { InfrastructureType } from './common.js';
 import { LocalInfrastructure } from './local.js';
-export const localInfrastructure = new LocalInfrastructure();
-export const awsInfrastructure = new AwsInfrastructure();
+import { getInfrastructure, getOrCreateProvider, registerInfrastructureProvider, } from './registry.js';
+// Re-export the registry surface so existing imports
+// (`from '../infrastructure/index.js'`) keep working.
+export { awsProviderFactory, getInfrastructure, registerInfrastructureProvider, resetInfrastructureProviders, } from './registry.js';
+/**
+ * Default factory for the local-filesystem provider. Registered eagerly when
+ * this module is imported (the CLI's standard entry point). The broker
+ * Lambda never imports this module, so `LocalInfrastructure` and its
+ * filesystem deps are tree-shaken out of the Lambda bundle.
+ */
+export const localProviderFactory = () => new LocalInfrastructure();
+registerInfrastructureProvider(InfrastructureType.local, localProviderFactory);
+// Backwards-compatible singleton exports. These remain stable references
+// (`sinon.stub(awsInfrastructure, 'foo')` continues to work) because the
+// default registrations above run at import time and the cached instances
+// never change identity for the lifetime of the CLI process.
+export const awsInfrastructure = getOrCreateProvider(InfrastructureType.aws);
+export const localInfrastructure = getOrCreateProvider(InfrastructureType.local);
 export async function resolveEnvValues(env) {
     return Object.fromEntries(await Promise.all(Object.entries(env).map(async ([key, value]) => {
         const colonIndex = value.indexOf(':');
@@ -21,28 +36,6 @@ export async function resolveEnvValues(env) {
         return [key, resolvedValue];
     })));
 }
-export function getInfrastructure(input) {
-    switch (input.type) {
-        case InfrastructureType.aws: {
-            return {
-                infrastructure: awsInfrastructure,
-                supported: true,
-            };
-        }
-        case InfrastructureType.local: {
-            return {
-                infrastructure: localInfrastructure,
-                supported: true,
-            };
-        }
-        default: {
-            return {
-                reason: `Invalid infrastructure type: ${input.type}. Valid options are: aws, local`,
-                supported: false,
-            };
-        }
-    }
-}
 /**
  * When `input.app` is set, scope the provisioning row by `app` (workspace-scoped).
  * Otherwise, scope by `project`. Apps and projects are mutually exclusive scopes

package/dist/infrastructure/registry.d.ts

@@ -0,0 +1,38 @@
+import { Infrastructure, InfrastructureType } from './common.js';
+/**
+ * A factory that lazily constructs an `Infrastructure` provider singleton.
+ * Registered factories are invoked at most once per type — the resulting
+ * instance is cached so external consumers (and tests that stub methods on
+ * `awsInfrastructure` / `localInfrastructure`) see the same reference every
+ * time.
+ */
+export type InfrastructureProviderFactory = () => Infrastructure;
+/**
+ * Default factory for the AWS provider. Both the CLI and the broker Lambda
+ * register this; it is the only factory the Lambda bundle pulls in.
+ */
+export declare const awsProviderFactory: InfrastructureProviderFactory;
+/**
+ * Register (or replace) the factory for a given infrastructure type. Resets
+ * any cached instance for that type so the next `getInfrastructure` call
+ * rebuilds it from the new factory.
+ */
+export declare function registerInfrastructureProvider(type: InfrastructureType, factory: InfrastructureProviderFactory): void;
+/**
+ * Clear all registered providers and cached instances. Primarily useful for
+ * tests and for the Lambda bundle that wants to start with a clean slate
+ * before registering only `aws`.
+ */
+export declare function resetInfrastructureProviders(): void;
+export declare function getOrCreateProvider(type: InfrastructureType): Infrastructure;
+export declare function getInfrastructure(input: GetInfrastructureInput): GetInfrastructureOutput;
+export type GetInfrastructureInput = {
+    type: InfrastructureType;
+};
+export type GetInfrastructureOutput = {
+    infrastructure: Infrastructure;
+    supported: true;
+} | {
+    reason: string;
+    supported: false;
+};

package/dist/infrastructure/registry.js

@@ -0,0 +1,61 @@
+/**
+ * Infrastructure provider registry. This module is the slim, Lambda-friendly
+ * entry point: it never imports the local-filesystem provider. The CLI's
+ * `./index.ts` extends this registry with `LocalInfrastructure`; the broker
+ * Lambda imports only this registry (via the `hereya-cli` package root) and
+ * registers `aws` only.
+ */
+import { AwsInfrastructure } from './aws.js';
+import { InfrastructureType } from './common.js';
+/**
+ * Default factory for the AWS provider. Both the CLI and the broker Lambda
+ * register this; it is the only factory the Lambda bundle pulls in.
+ */
+export const awsProviderFactory = () => new AwsInfrastructure();
+const factories = new Map();
+const instances = new Map();
+/**
+ * Register (or replace) the factory for a given infrastructure type. Resets
+ * any cached instance for that type so the next `getInfrastructure` call
+ * rebuilds it from the new factory.
+ */
+export function registerInfrastructureProvider(type, factory) {
+    factories.set(type, factory);
+    instances.delete(type);
+}
+/**
+ * Clear all registered providers and cached instances. Primarily useful for
+ * tests and for the Lambda bundle that wants to start with a clean slate
+ * before registering only `aws`.
+ */
+export function resetInfrastructureProviders() {
+    factories.clear();
+    instances.clear();
+}
+export function getOrCreateProvider(type) {
+    const cached = instances.get(type);
+    if (cached)
+        return cached;
+    const factory = factories.get(type);
+    if (!factory) {
+        throw new Error(`Infrastructure provider not registered: ${type}. Call registerInfrastructureProvider(${type}, factory) first.`);
+    }
+    const instance = factory();
+    instances.set(type, instance);
+    return instance;
+}
+export function getInfrastructure(input) {
+    if (!factories.has(input.type)) {
+        return {
+            reason: `Invalid infrastructure type: ${input.type}. Valid options are: ${[...factories.keys()].join(', ') || '<none registered>'}`,
+            supported: false,
+        };
+    }
+    return {
+        infrastructure: getOrCreateProvider(input.type),
+        supported: true,
+    };
+}
+// Register the AWS provider eagerly. The CLI's `infrastructure/index.ts`
+// additionally registers the `local` provider; the broker Lambda does not.
+registerInfrastructureProvider(InfrastructureType.aws, awsProviderFactory);

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

@@ -37,20 +37,20 @@ export declare const ParameterSpec: z.ZodEffects<z.ZodObject<{
     description: z.ZodOptional<z.ZodString>;
     mandatory: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
 }, "strip", z.ZodTypeAny, {
-    description?: string | undefined;
     default?: string | undefined;
+    description?: string | undefined;
     mandatory?: boolean | undefined;
 }, {
-    description?: string | undefined;
     default?: string | undefined;
+    description?: string | undefined;
     mandatory?: boolean | undefined;
 }>, {
-    description?: string | undefined;
     default?: string | undefined;
+    description?: string | undefined;
     mandatory?: boolean | undefined;
 }, {
-    description?: string | undefined;
     default?: string | undefined;
+    description?: string | undefined;
     mandatory?: boolean | undefined;
 }>;
 export type IParameterSpec = z.infer<typeof ParameterSpec>;
@@ -79,42 +79,37 @@ export declare const PackageMetadata: z.ZodObject<{
         description: z.ZodOptional<z.ZodString>;
         mandatory: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
     }, "strip", z.ZodTypeAny, {
-        description?: string | undefined;
         default?: string | undefined;
+        description?: string | undefined;
         mandatory?: boolean | undefined;
     }, {
-        description?: string | undefined;
         default?: string | undefined;
+        description?: string | undefined;
         mandatory?: boolean | undefined;
     }>, {
-        description?: string | undefined;
         default?: string | undefined;
+        description?: string | undefined;
         mandatory?: boolean | undefined;
     }, {
-        description?: string | undefined;
         default?: string | undefined;
+        description?: string | undefined;
         mandatory?: boolean | undefined;
     }>>>, Record<string, {
-        description?: string | undefined;
         default?: string | undefined;
+        description?: string | undefined;
         mandatory?: boolean | undefined;
     }> | undefined, Record<string, {
-        description?: string | undefined;
         default?: string | undefined;
+        description?: string | undefined;
         mandatory?: boolean | undefined;
     }> | undefined>;
     snakeCase: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     iac: IacType;
     infra: InfrastructureType;
-    dependencies?: Record<string, string> | undefined;
     kind?: "app" | "package" | undefined;
-    parameters?: Record<string, {
-        description?: string | undefined;
-        default?: string | undefined;
-        mandatory?: boolean | undefined;
-    }> | undefined;
     deploy?: boolean | undefined;
+    dependencies?: Record<string, string> | undefined;
     devDeploy?: boolean | undefined;
     inputs?: Record<string, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">> | undefined;
     onDeploy?: {
@@ -123,18 +118,18 @@ export declare const PackageMetadata: z.ZodObject<{
     } | undefined;
     originalInfra?: InfrastructureType | undefined;
     outputs?: Record<string, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">> | undefined;
+    parameters?: Record<string, {
+        default?: string | undefined;
+        description?: string | undefined;
+        mandatory?: boolean | undefined;
+    }> | undefined;
     snakeCase?: boolean | undefined;
 }, {
     iac: IacType;
     infra: InfrastructureType;
-    dependencies?: Record<string, string> | undefined;
     kind?: "app" | "package" | undefined;
-    parameters?: Record<string, {
-        description?: string | undefined;
-        default?: string | undefined;
-        mandatory?: boolean | undefined;
-    }> | undefined;
     deploy?: boolean | undefined;
+    dependencies?: Record<string, string> | undefined;
     devDeploy?: boolean | undefined;
     inputs?: Record<string, z.objectInputType<{}, z.ZodTypeAny, "passthrough">> | undefined;
     onDeploy?: {
@@ -143,6 +138,11 @@ export declare const PackageMetadata: z.ZodObject<{
     } | undefined;
     originalInfra?: InfrastructureType | undefined;
     outputs?: Record<string, z.objectInputType<{}, z.ZodTypeAny, "passthrough">> | undefined;
+    parameters?: Record<string, {
+        default?: string | undefined;
+        description?: string | undefined;
+        mandatory?: boolean | undefined;
+    }> | undefined;
     snakeCase?: boolean | undefined;
 }>;
 export type IPackageMetadata = z.infer<typeof PackageMetadata>;