hereya-cli 0.18.0 → 0.20.0

package/dist/executor/interface.d.ts

@@ -0,0 +1,41 @@
+import { IPackageMetadata } from '../lib/package/index.js';
+export type ExecutorProvisionInput = {
+    isDeploying?: boolean;
+    package: string;
+    parameters?: {
+        [key: string]: string;
+    };
+    project?: string;
+    projectEnv?: {
+        [key: string]: string;
+    };
+    projectRootDir?: string;
+    skipDeploy?: boolean;
+    workspace?: string;
+};
+export type ExecutorProvisionOutput = {
+    env: {
+        [key: string]: string;
+    };
+    metadata: IPackageMetadata;
+    success: true;
+} | {
+    reason: string;
+    success: false;
+};
+export type ExecutorDestroyInput = ExecutorProvisionInput;
+export type ExecutorDestroyOutput = ExecutorProvisionOutput;
+export type ExecutorResolveEnvValuesInput = {
+    env: {
+        [key: string]: string;
+    };
+    markSecret?: boolean;
+};
+export type ExecutorResolveEnvValuesOutput = {
+    [key: string]: string;
+};
+export interface Executor {
+    destroy(input: ExecutorDestroyInput): Promise<ExecutorDestroyOutput>;
+    provision(input: ExecutorProvisionInput): Promise<ExecutorProvisionOutput>;
+    resolveEnvValues(input: ExecutorResolveEnvValuesInput): Promise<ExecutorResolveEnvValuesOutput>;
+}

package/dist/executor/interface.js

@@ -0,0 +1 @@
+export {};

package/dist/executor/local.d.ts

@@ -0,0 +1,7 @@
+import { Executor, ExecutorDestroyInput, ExecutorDestroyOutput, ExecutorProvisionInput, ExecutorProvisionOutput, ExecutorResolveEnvValuesInput, ExecutorResolveEnvValuesOutput } from './interface.js';
+export declare class LocalExecutor implements Executor {
+    destroy(input: ExecutorDestroyInput): Promise<ExecutorDestroyOutput>;
+    provision(input: ExecutorProvisionInput): Promise<ExecutorProvisionOutput>;
+    resolveEnvValues(input: ExecutorResolveEnvValuesInput): Promise<ExecutorResolveEnvValuesOutput>;
+    private getWorkspaceEnv;
+}

package/dist/executor/local.js

@@ -0,0 +1,56 @@
+import { getBackend } from '../backend/index.js';
+import { destroyPackage, getInfrastructure, provisionPackage } from '../infrastructure/index.js';
+export class LocalExecutor {
+    async destroy(input) {
+        const getWorkspaceEnvOutput = await this.getWorkspaceEnv({
+            project: input.project,
+            workspace: input.workspace,
+        });
+        if (!getWorkspaceEnvOutput.success) {
+            return { reason: getWorkspaceEnvOutput.reason, success: false };
+        }
+        return destroyPackage({
+            ...input,
+            env: getWorkspaceEnvOutput.env,
+        });
+    }
+    async provision(input) {
+        const getWorkspaceEnvOutput = await this.getWorkspaceEnv({
+            project: input.project,
+            workspace: input.workspace,
+        });
+        if (!getWorkspaceEnvOutput.success) {
+            return { reason: getWorkspaceEnvOutput.reason, success: false };
+        }
+        return provisionPackage({
+            ...input,
+            env: getWorkspaceEnvOutput.env,
+        });
+    }
+    async resolveEnvValues(input) {
+        return Object.fromEntries(await Promise.all(Object.entries(input.env).map(async ([key, value]) => {
+            const infraType = value.split(':')[0];
+            const infra$ = getInfrastructure({ type: infraType });
+            if (!infra$.supported) {
+                throw new Error(infra$.reason);
+            }
+            const { infrastructure } = infra$;
+            const valueWithoutInfra = value.split(':').slice(1).join(':');
+            const { isSecret, value: resolvedValue } = await infrastructure.resolveEnv({
+                value: valueWithoutInfra,
+            });
+            const finalValue = input.markSecret && isSecret ? `secret://${resolvedValue}` : resolvedValue;
+            return [key, finalValue];
+        })));
+    }
+    async getWorkspaceEnv({ project, workspace, }) {
+        if (!workspace || !project) {
+            return { env: {}, success: true };
+        }
+        const backend = await getBackend();
+        return backend.getWorkspaceEnv({
+            project,
+            workspace,
+        });
+    }
+}

package/dist/iac/cdk.js

@@ -7,7 +7,7 @@ export class Cdk {
     async apply(input) {
         try {
             const { remainingEnv, serializedParameters, serializedWorkspaceEnv } = await this.serializedParametersAndContext(input);
-            runShell('npx', [
+            await runShell('npx', [
                 'aws-cdk', 'deploy', '--require-approval', 'never', ...serializedWorkspaceEnv, ...serializedParameters,
             ], {
                 directory: input.pkgPath,
@@ -27,7 +27,7 @@ export class Cdk {
         try {
             const env = await this.getEnv(input.id);
             const { remainingEnv, serializedParameters, serializedWorkspaceEnv } = await this.serializedParametersAndContext(input);
-            runShell('npx', [
+            await runShell('npx', [
                 'aws-cdk', 'destroy', '--force', ...serializedWorkspaceEnv, ...serializedParameters
             ], {
                 directory: input.pkgPath,
@@ -52,14 +52,14 @@ export class Cdk {
     }
     async getParameterNames(input) {
         const workDir = input.pkgPath;
-        runShell('npm', ['install'], { directory: workDir });
-        runShell('npx', [
+        await runShell('npm', ['install'], { directory: workDir });
+        await runShell('npx', [
             'aws-cdk', 'synth',
         ], {
             directory: workDir,
             env: { ...input.env, ...input.parameters },
         });
-        const result = runShell('npx', [
+        const result = await runShell('npx', [
             'aws-cdk', 'synth',
         ], {
             directory: workDir,

package/dist/iac/index.js

@@ -5,21 +5,21 @@ export const terraform = new Terraform();
 export const cdk = new Cdk();
 export function getIac({ type }) {
     switch (type) {
-        case IacType.terraform: {
+        case IacType.cdk: {
+            return { iac: cdk, supported: true };
+        }
+        case IacType.opentf: {
             return { iac: terraform, supported: true };
         }
         case IacType.opentofu: {
             return { iac: terraform, supported: true };
         }
-        case IacType.opentf: {
+        case IacType.terraform: {
             return { iac: terraform, supported: true };
         }
         case IacType.tofu: {
             return { iac: terraform, supported: true };
         }
-        case IacType.cdk: {
-            return { iac: cdk, supported: true };
-        }
         default: {
             return { reason: `Iac type ${type} is not supported yet!`, supported: false };
         }

package/dist/iac/terraform.js

@@ -27,7 +27,7 @@ export class Terraform {
         }
         try {
             const terraform = await this.getTerraformBinary();
-            runShell(terraform, ['init'], {
+            await runShell(terraform, ['init'], {
                 directory: input.pkgPath,
                 env: {
                     ...mapObject(input.env ?? {}, (key, value) => [
@@ -41,7 +41,7 @@ export class Terraform {
                     ]),
                 },
             });
-            runShell(terraform, ['apply', '-auto-approve'], {
+            await runShell(terraform, ['apply', '-auto-approve'], {
                 directory: input.pkgPath,
                 env: {
                     ...mapObject(input.env ?? {}, (key, value) => [
@@ -71,7 +71,7 @@ export class Terraform {
     async destroy(input) {
         const terraform = await this.getTerraformBinary();
         try {
-            runShell(terraform, ['init'], {
+            await runShell(terraform, ['init'], {
                 directory: input.pkgPath,
                 env: {
                     ...mapObject(input.env ?? {}, (key, value) => [
@@ -86,7 +86,7 @@ export class Terraform {
                 },
             });
             const env = await this.getEnv(input.pkgPath);
-            runShell(terraform, ['destroy', '-auto-approve'], {
+            await runShell(terraform, ['destroy', '-auto-approve'], {
                 directory: input.pkgPath,
                 env: {
                     ...mapObject(input.env ?? {}, (key, value) => [
@@ -119,8 +119,8 @@ export class Terraform {
             ['freebsd_arm', 'https://github.com/opentofu/opentofu/releases/download/v1.9.0/tofu_1.9.0_freebsd_arm.zip'],
             ['freebsd_ia32', 'https://github.com/opentofu/opentofu/releases/download/v1.9.0/tofu_1.9.0_freebsd_386.zip'],
             ['freebsd_x64', 'https://github.com/opentofu/opentofu/releases/download/v1.9.0/tofu_1.9.0_freebsd_amd64.zip'],
-            ['linux_arm', 'https://github.com/opentofu/opentofu/releases/download/v1.9.0/tofu_1.9.0_linux_arm.zip'],
             ['linux_arm64', 'https://github.com/opentofu/opentofu/releases/download/v1.9.0/tofu_1.9.0_linux_arm64.zip'],
+            ['linux_arm', 'https://github.com/opentofu/opentofu/releases/download/v1.9.0/tofu_1.9.0_linux_arm.zip'],
             ['linux_ia32', 'https://github.com/opentofu/opentofu/releases/download/v1.9.0/tofu_1.9.0_linux_386.zip'],
             ['linux_x64', 'https://github.com/opentofu/opentofu/releases/download/v1.9.0/tofu_1.9.0_linux_amd64.zip'],
             ['openbsd_ia32', 'https://github.com/opentofu/opentofu/releases/download/v1.9.0/tofu_1.9.0_openbsd_386.zip'],
@@ -170,11 +170,11 @@ export class Terraform {
     }
     async getEnv(pkgPath) {
         const terraform = await this.getTerraformBinary();
-        const resourceOut = runShell(terraform, ['output', '--json'], {
+        const resourceOut = await runShell(terraform, ['output', '--json'], {
             directory: pkgPath,
             stdio: 'pipe',
         });
-        let outStr = resourceOut.output.toString().trim();
+        let outStr = resourceOut.stdout.toString().trim();
         const start = outStr.indexOf('{');
         const end = outStr.lastIndexOf('}');
         outStr = outStr.slice(start, end + 1);

package/dist/infrastructure/aws.js

@@ -15,7 +15,7 @@ export class AwsInfrastructure {
         const stsClient = new STSClient({});
         const { Account: accountId } = await stsClient.send(new GetCallerIdentityCommand({}));
         const region = process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION;
-        runShell('npx', ['cdk', 'bootstrap', `aws://${accountId}/${region}`]);
+        await runShell('npx', ['cdk', 'bootstrap', `aws://${accountId}/${region}`]);
         const bootstrapPackage = 'hereya/bootstrap-aws-stack';
         const output = await provisionPackage({ package: bootstrapPackage });
         if (!output.success) {

package/dist/infrastructure/common.d.ts

@@ -44,12 +44,12 @@ export type ProvisionOutput = {
 };
 export type DestroyInput = ProvisionInput;
 export type DestroyOutput = ProvisionOutput;
-export type DeployInput = {
+export type DeployInput = ProvisionInput & {
     projectEnv: {
         [key: string]: string;
     };
     projectRootDir: string;
-} & ProvisionInput;
+};
 export type DeployOutput = ProvisionOutput;
 export type UndeployInput = DeployInput;
 export type UndeployOutput = DeployOutput;

package/dist/infrastructure/index.d.ts

@@ -41,10 +41,10 @@ export type GetInfrastructureInput = {
     type: InfrastructureType;
 };
 export type GetInfrastructureOutput = {
-    reason: string;
-    supported: false;
-} | {
     infrastructure: Infrastructure;
     supported: true;
+} | {
+    reason: string;
+    supported: false;
 };
 export type PackageMetadata = z.infer<typeof PackageMetadata>;

package/dist/infrastructure/index.js

@@ -7,15 +7,15 @@ export const localInfrastructure = new LocalInfrastructure();
 export const awsInfrastructure = new AwsInfrastructure();
 export function getInfrastructure(input) {
     switch (input.type) {
-        case InfrastructureType.local: {
+        case InfrastructureType.aws: {
             return {
-                infrastructure: localInfrastructure,
+                infrastructure: awsInfrastructure,
                 supported: true,
             };
         }
-        case InfrastructureType.aws: {
+        case InfrastructureType.local: {
             return {
-                infrastructure: awsInfrastructure,
+                infrastructure: localInfrastructure,
                 supported: true,
             };
         }
@@ -28,7 +28,7 @@ export function getInfrastructure(input) {
     }
 }
 export async function destroyPackage(input) {
-    const resolvePackageOutput = await resolvePackage({ isDeploying: input.isDeploying, package: input.package });
+    const resolvePackageOutput = await resolvePackage({ isDeploying: input.isDeploying, package: input.package, projectRootDir: input.projectRootDir });
     if (!resolvePackageOutput.found) {
         return { reason: resolvePackageOutput.reason, success: false };
     }
@@ -91,7 +91,7 @@ export async function destroyPackage(input) {
     return { env: destroyOutput.env, metadata, success: true };
 }
 export async function provisionPackage(input) {
-    const resolvePackageOutput = await resolvePackage({ isDeploying: input.isDeploying, package: input.package });
+    const resolvePackageOutput = await resolvePackage({ isDeploying: input.isDeploying, package: input.package, projectRootDir: input.projectRootDir });
     if (!resolvePackageOutput.found) {
         return { reason: resolvePackageOutput.reason, success: false };
     }

package/dist/infrastructure/local.js

@@ -1,6 +1,6 @@
 import * as fs from 'node:fs/promises';
 import * as os from 'node:os';
-import * as path from 'node:path';
+import path from 'node:path';
 import { getIac } from '../iac/index.js';
 import { downloadPackage } from '../lib/package/index.js';
 export class LocalInfrastructure {

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

@@ -26,4 +26,8 @@ export type GetProjectEnvOutput = {
     env: {
         [key: string]: string;
     };
+    success: true;
+} | {
+    reason: string;
+    success: false;
 };

package/dist/lib/env/index.js

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { resolveEnvValues } from '../env-utils.js';
+import { getExecutor } from '../../executor/index.js';
 import { getAnyPath } from '../filesystem.js';
 import { load, save } from '../yaml-utils.js';
 export class EnvManager {
@@ -14,8 +14,16 @@ export class EnvManager {
         const envPath = await this.getEnvPath(input);
         const { data: env, found } = await load(envPath);
         let resolvedEnv = {};
+        const executor$ = getExecutor();
+        if (!executor$.success) {
+            return {
+                reason: executor$.reason,
+                success: false,
+            };
+        }
+        const { executor } = executor$;
         if (found) {
-            resolvedEnv = await resolveEnvValues(env, { markSecret: input.markSecret });
+            resolvedEnv = await executor.resolveEnvValues({ env, markSecret: input.markSecret });
         }
         const userEnvs = await this.getUserEnvPaths(input).then((paths) => Promise.all(paths.map((path) => load(path))));
         let userMergedEnv = {};
@@ -23,7 +31,7 @@ export class EnvManager {
             userMergedEnv = { ...userMergedEnv, ...data };
         }
         const finalEnv = { ...resolvedEnv, ...userMergedEnv };
-        return { env: finalEnv };
+        return { env: finalEnv, success: true };
     }
     async removeProjectEnv(input) {
         const envPath = await this.getEnvPath(input);

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

@@ -1,10 +1,3 @@
 export declare function logEnv(env: {
     [key: string]: string;
 }, logFn?: (_: string) => void): void;
-export declare function resolveEnvValues(env: {
-    [key: string]: string;
-}, options?: {
-    markSecret?: boolean;
-}): Promise<{
-    [key: string]: string;
-}>;

package/dist/lib/env-utils.js

@@ -1,23 +1,5 @@
-import { getInfrastructure } from '../infrastructure/index.js';
 export function logEnv(env, logFn = console.log) {
     for (const [key, value] of Object.entries(env)) {
         logFn(`${key}=${value}`);
     }
 }
-export async function resolveEnvValues(env, options = {}) {
-    return Object.fromEntries(await Promise.all(Object.entries(env)
-        .map(async ([key, value]) => {
-        const infraType = value.split(':')[0];
-        const infra$ = getInfrastructure({ type: infraType });
-        if (!infra$.supported) {
-            throw new Error(infra$.reason);
-        }
-        const { infrastructure } = infra$;
-        const valueWithoutInfra = value.split(':').slice(1).join(':');
-        const { isSecret, value: resolvedValue } = await infrastructure.resolveEnv({
-            value: valueWithoutInfra
-        });
-        const finalValue = options.markSecret && isSecret ? `secret://${resolvedValue}` : resolvedValue;
-        return [key, finalValue];
-    })));
-}

package/dist/lib/log.js

@@ -1,4 +1,4 @@
-import { ListrLogLevels, ListrLogger } from 'listr2';
+import { ListrLogger, ListrLogLevels } from 'listr2';
 const myLogger = new ListrLogger({ useIcons: false });
 const logger = {
     done(message) {

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

@@ -5,6 +5,7 @@ export interface PackageManager {
 export type GetRepoContentInput = {
     owner: string;
     path: string;
+    projectRootDir?: string;
     repo: string;
 };
 export type GetRepoContentOutput = {

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

@@ -12,6 +12,7 @@ export declare function downloadPackage(pkgUrl: string, destPath: string): Promi
 export type ResolvePackageInput = {
     isDeploying?: boolean;
     package: string;
+    projectRootDir?: string;
 };
 export type ResolvePackageOutput = {
     canonicalName: string;

package/dist/lib/package/index.js

@@ -29,8 +29,8 @@ export async function resolvePackage(input) {
     }
     const packageManager = getPackageManager(isLocal ? 'local' : '');
     const metadataContentCandidates = (await Promise.all([
-        packageManager.getRepoContent({ owner, path: 'hereyarc.yaml', repo }),
-        packageManager.getRepoContent({ owner, path: 'hereyarc.yml', repo }),
+        packageManager.getRepoContent({ owner, path: 'hereyarc.yaml', projectRootDir: input.projectRootDir, repo }),
+        packageManager.getRepoContent({ owner, path: 'hereyarc.yml', projectRootDir: input.projectRootDir, repo }),
     ])).filter((content$) => content$.found);
     if (metadataContentCandidates.length === 0) {
         return { found: false, reason: `No hereya metadata file found in ${input.package}` };
@@ -42,7 +42,7 @@ export async function resolvePackage(input) {
             return { found: false, reason: 'Package has dependencies but is not a deploy package' };
         }
         if (input.isDeploying && metadata.onDeploy) {
-            return resolvePackage({ package: metadata.onDeploy.pkg });
+            return resolvePackage({ package: metadata.onDeploy.pkg, projectRootDir: input.projectRootDir });
         }
         return {
             canonicalName: getPackageCanonicalName(input.package),

package/dist/lib/package/local.d.ts

@@ -1,5 +1,5 @@
 import { GetRepoContentInput, GetRepoContentOutput, PackageManager } from './common.js';
 export declare class LocalPackageManager implements PackageManager {
     downloadPackage(pkgUrl: string, destPath: string): Promise<string>;
-    getRepoContent({ path: filePath, repo }: GetRepoContentInput): Promise<GetRepoContentOutput>;
+    getRepoContent({ path: filePath, projectRootDir, repo }: GetRepoContentInput): Promise<GetRepoContentOutput>;
 }

package/dist/lib/package/local.js

@@ -3,18 +3,19 @@ import path from 'node:path';
 export class LocalPackageManager {
     async downloadPackage(pkgUrl, destPath) {
         const [, source] = pkgUrl.split('://');
-        await fs.cp(source, destPath, { recursive: true });
+        await copyRecursive(source, destPath);
         return destPath;
     }
-    async getRepoContent({ path: filePath, repo }) {
+    async getRepoContent({ path: filePath, projectRootDir, repo }) {
         try {
-            const resolvedPath = path.join(repo, filePath);
+            const pkgRootDir = path.join(projectRootDir ?? process.cwd(), repo);
+            const resolvedPath = path.join(pkgRootDir, filePath);
             if (await fs.stat(resolvedPath)) {
                 const content = await fs.readFile(resolvedPath, 'utf8');
                 return {
                     content,
                     found: true,
-                    pkgUrl: `local://${repo}`,
+                    pkgUrl: `local://${pkgRootDir}`,
                 };
             }
             return {
@@ -30,3 +31,15 @@ export class LocalPackageManager {
         }
     }
 }
+async function copyRecursive(src, dest) {
+    // Ensure the destination directory exists.
+    await fs.mkdir(dest, { recursive: true });
+    // Read the contents of the source directory.
+    const entries = await fs.readdir(src, { withFileTypes: true });
+    // Loop through each entry in the directory.
+    await Promise.all(entries.map(async (entry) => {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        return entry.isDirectory() ? copyRecursive(srcPath, destPath) : fs.copyFile(srcPath, destPath);
+    }));
+}

package/dist/lib/shell.d.ts

@@ -1,12 +1,22 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-import { StdioOptions, spawnSync } from 'node:child_process';
+import { SpawnOptions } from 'node:child_process';
 export declare function setDebug(value: boolean): void;
 export declare function isDebug(): boolean;
-export type RunShellOptions = {
+export interface RunShellOptions {
     directory?: string;
     env?: NodeJS.ProcessEnv;
-    stdio?: StdioOptions;
-};
-export declare function runShell(cmd: string, args: string[], options?: RunShellOptions): ReturnType<typeof spawnSync>;
+    logger?: typeof defaultLogger;
+    stdio?: SpawnOptions['stdio'];
+}
+export declare function runShell(cmd: string, args: string[], options?: RunShellOptions): Promise<{
+    pid: number;
+    signal: NodeJS.Signals | null;
+    status: null | number;
+    stderr: string;
+    stdout: string;
+}>;
 export declare function delay(ms: number): Promise<unknown> | undefined;
+export declare const defaultLogger: {
+    debug(message: string): void;
+    error(message: string): void;
+    info(message: string): void;
+};

package/dist/lib/shell.js

@@ -1,4 +1,4 @@
-import { spawnSync } from 'node:child_process';
+import { spawn } from 'node:child_process';
 let debug = false;
 export function setDebug(value) {
     debug = value;
@@ -6,20 +6,62 @@ export function setDebug(value) {
 export function isDebug() {
     return debug;
 }
-export function runShell(cmd, args, options = {}) {
-    // Run the command
-    const result = spawnSync(cmd, args, {
-        cwd: options.directory ?? process.cwd(),
-        encoding: 'utf8',
-        env: { ...process.env, ...options.env },
-        shell: true,
-        stdio: options.stdio ?? (isDebug() ? 'inherit' : 'ignore'),
+// Asynchronous runShell that logs output using the provided logger.
+export async function runShell(cmd, args, options = {}) {
+    return new Promise((resolve, reject) => {
+        // Use the provided logger or default to console.log
+        const logger = options.logger ?? defaultLogger;
+        const spawnOptions = {
+            cwd: options.directory ?? process.cwd(),
+            env: { ...process.env, ...options.env },
+            shell: true,
+            // If not explicitly set, use 'inherit' when debugging, or 'pipe' otherwise
+            stdio: options.stdio ?? (isDebug() ? 'inherit' : 'pipe'),
+        };
+        logger.debug(`Executing: ${cmd} ${args.join(' ')}`);
+        const child = spawn(cmd, args, spawnOptions);
+        // Buffers to accumulate output from the process.
+        let stdout = '';
+        let stderr = '';
+        if (child.stdout) {
+            child.stdout.on('data', (data) => {
+                const chunk = data.toString();
+                stdout += chunk;
+                logger.info(chunk);
+            });
+        }
+        if (child.stderr) {
+            child.stderr.on('data', (data) => {
+                const chunk = data.toString();
+                stderr += chunk;
+                logger.info(chunk);
+            });
+        }
+        child.on('error', (err) => {
+            logger.error(`Error: ${err.message}`);
+            reject(err);
+        });
+        let exitCode = null;
+        let exitSignal = null;
+        child.on('exit', (code, signal) => {
+            exitCode = code;
+            exitSignal = signal;
+        });
+        child.on('close', () => {
+            if (exitCode !== 0) {
+                const errorMsg = `Command "${cmd} ${args.join(' ')}" failed with exit code "${exitCode}"`;
+                logger.error(errorMsg);
+                return reject(new Error(errorMsg));
+            }
+            resolve({
+                pid: child.pid,
+                signal: exitSignal,
+                status: exitCode,
+                stderr,
+                stdout,
+            });
+        });
     });
-    // Throw an error if the command failed
-    if (result.status !== 0) {
-        throw new Error(`Command "${cmd} ${args.join(' ')}" failed with exit code "${result.status}"`);
-    }
-    return result;
 }
 export function delay(ms) {
     if (process.env.NODE_ENV === 'test') {
@@ -29,3 +71,20 @@ export function delay(ms) {
         setTimeout(resolve, ms);
     });
 }
+export const defaultLogger = {
+    debug(message) {
+        if (isDebug()) {
+            console.debug(message);
+        }
+    },
+    error(message) {
+        if (isDebug()) {
+            console.error(message);
+        }
+    },
+    info(message) {
+        if (isDebug()) {
+            console.info(message);
+        }
+    },
+};

package/dist/lib/yaml-utils.js

@@ -1,5 +1,5 @@
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import * as path from 'node:path';
+import path from 'node:path';
 import { parse, stringify } from 'yaml';
 export async function save(content, file) {
     try {