@livingdata/pipex 0.0.9 → 0.0.10

package/dist/kits/builtin/__tests__/node.js

@@ -0,0 +1,74 @@
+import test from 'ava';
+import { KitError, MissingParameterError } from '../../../errors.js';
+import { nodeKit } from '../node.js';
+test('resolve with minimal params (script only)', t => {
+    const result = nodeKit.resolve({ script: 'index.js' });
+    t.is(result.image, 'node:24-alpine');
+    t.truthy(result.cmd[2].includes('node /app/index.js'));
+    t.is(result.sources, undefined);
+});
+test('resolve uses default version and variant', t => {
+    const result = nodeKit.resolve({ script: 'app.js' });
+    t.is(result.image, 'node:24-alpine');
+});
+test('resolve with npm package manager', t => {
+    const result = nodeKit.resolve({ script: 'app.js', packageManager: 'npm' });
+    t.truthy(result.cmd[2].includes('cd /app && npm install'));
+    t.deepEqual(result.caches, [{ name: 'npm-cache', path: '/root/.npm' }]);
+});
+test('resolve with pnpm package manager', t => {
+    const result = nodeKit.resolve({ script: 'app.js', packageManager: 'pnpm' });
+    t.truthy(result.cmd[2].includes('pnpm install'));
+    t.deepEqual(result.caches, [{ name: 'pnpm-store', path: '/root/.local/share/pnpm/store' }]);
+});
+test('resolve with yarn package manager', t => {
+    const result = nodeKit.resolve({ script: 'app.js', packageManager: 'yarn' });
+    t.truthy(result.cmd[2].includes('yarn install'));
+    t.deepEqual(result.caches, [{ name: 'yarn-cache', path: '/usr/local/share/.cache/yarn' }]);
+});
+test('resolve with install=false skips install command', t => {
+    const result = nodeKit.resolve({ script: 'app.js', install: false });
+    t.falsy(result.cmd[2].includes('npm install'));
+    t.truthy(result.cmd[2].includes('node /app/app.js'));
+});
+test('resolve with src adds source', t => {
+    const result = nodeKit.resolve({ script: 'app.js', src: 'myapp' });
+    t.deepEqual(result.sources, [{ host: 'myapp', container: '/app' }]);
+    t.is(result.mounts, undefined);
+});
+test('resolve sets allowNetwork to true', t => {
+    const result = nodeKit.resolve({ script: 'app.js' });
+    t.true(result.allowNetwork);
+});
+test('resolve throws KitError on unsupported packageManager', t => {
+    const error = t.throws(() => nodeKit.resolve({ script: 'app.js', packageManager: 'bun' }), {
+        message: /unsupported packageManager/
+    });
+    t.true(error instanceof KitError);
+});
+test('resolve throws MissingParameterError without script or run', t => {
+    const error = t.throws(() => nodeKit.resolve({}), { message: /required/i });
+    t.true(error instanceof MissingParameterError);
+});
+test('resolve throws KitError when both script and run are provided', t => {
+    const error = t.throws(() => nodeKit.resolve({ script: 'app.js', run: 'npm run build' }), {
+        message: /mutually exclusive/
+    });
+    t.true(error instanceof KitError);
+});
+// -- run parameter ------------------------------------------------------------
+test('resolve with run uses the command directly', t => {
+    const result = nodeKit.resolve({ run: 'npm run build --prefix /app' });
+    t.truthy(result.cmd[2].includes('npm run build --prefix /app'));
+    t.falsy(result.cmd[2].includes('node /app/'));
+});
+test('resolve with run still runs install by default', t => {
+    const result = nodeKit.resolve({ run: 'npx eslint /app/src' });
+    t.truthy(result.cmd[2].includes('npm install'));
+    t.truthy(result.cmd[2].includes('npx eslint /app/src'));
+});
+test('resolve with run and install=false skips install', t => {
+    const result = nodeKit.resolve({ run: 'node --version', install: false });
+    t.falsy(result.cmd[2].includes('npm install'));
+    t.is(result.cmd[2], 'node --version');
+});

package/dist/kits/builtin/__tests__/python.js

@@ -0,0 +1,67 @@
+import test from 'ava';
+import { KitError, MissingParameterError } from '../../../errors.js';
+import { pythonKit } from '../python.js';
+test('resolve with minimal params (script only)', t => {
+    const result = pythonKit.resolve({ script: 'main.py' });
+    t.is(result.image, 'python:3.12-slim');
+    t.truthy(result.cmd[2].includes('python /app/main.py'));
+});
+test('resolve uses default version and variant', t => {
+    const result = pythonKit.resolve({ script: 'app.py' });
+    t.is(result.image, 'python:3.12-slim');
+});
+test('resolve with pip package manager', t => {
+    const result = pythonKit.resolve({ script: 'app.py', packageManager: 'pip' });
+    t.truthy(result.cmd[2].includes('pip install'));
+    t.deepEqual(result.caches, [{ name: 'pip-cache', path: '/root/.cache/pip' }]);
+});
+test('resolve with uv package manager', t => {
+    const result = pythonKit.resolve({ script: 'app.py', packageManager: 'uv' });
+    t.truthy(result.cmd[2].includes('uv pip install'));
+    t.deepEqual(result.caches, [{ name: 'uv-cache', path: '/root/.cache/uv' }]);
+});
+test('resolve with install=false skips install command', t => {
+    const result = pythonKit.resolve({ script: 'app.py', install: false });
+    t.falsy(result.cmd[2].includes('pip install'));
+    t.truthy(result.cmd[2].includes('python /app/app.py'));
+});
+test('resolve with src adds mount', t => {
+    const result = pythonKit.resolve({ script: 'app.py', src: 'myproject' });
+    t.deepEqual(result.mounts, [{ host: 'myproject', container: '/app' }]);
+});
+test('resolve sets allowNetwork to true', t => {
+    const result = pythonKit.resolve({ script: 'app.py' });
+    t.true(result.allowNetwork);
+});
+test('resolve throws KitError on unsupported packageManager', t => {
+    const error = t.throws(() => pythonKit.resolve({ script: 'app.py', packageManager: 'conda' }), {
+        message: /unsupported packageManager/
+    });
+    t.true(error instanceof KitError);
+});
+test('resolve throws MissingParameterError without script or run', t => {
+    const error = t.throws(() => pythonKit.resolve({}), { message: /required/i });
+    t.true(error instanceof MissingParameterError);
+});
+test('resolve throws KitError when both script and run are provided', t => {
+    const error = t.throws(() => pythonKit.resolve({ script: 'app.py', run: 'pytest /app/tests' }), {
+        message: /mutually exclusive/
+    });
+    t.true(error instanceof KitError);
+});
+// -- run parameter ------------------------------------------------------------
+test('resolve with run uses the command directly', t => {
+    const result = pythonKit.resolve({ run: 'pytest /app/tests -v' });
+    t.truthy(result.cmd[2].includes('pytest /app/tests -v'));
+    t.falsy(result.cmd[2].includes('python /app/'));
+});
+test('resolve with run still runs install by default', t => {
+    const result = pythonKit.resolve({ run: 'pytest /app/tests' });
+    t.truthy(result.cmd[2].includes('pip install'));
+    t.truthy(result.cmd[2].includes('pytest /app/tests'));
+});
+test('resolve with run and install=false skips install', t => {
+    const result = pythonKit.resolve({ run: 'python --version', install: false });
+    t.falsy(result.cmd[2].includes('pip install'));
+    t.is(result.cmd[2], 'python --version');
+});

package/dist/kits/builtin/__tests__/shell.js

@@ -0,0 +1,74 @@
+import test from 'ava';
+import { MissingParameterError } from '../../../errors.js';
+import { shellKit } from '../shell.js';
+// -- Defaults (no packages) --------------------------------------------------
+test('resolve with run parameter uses alpine by default', t => {
+    const result = shellKit.resolve({ run: 'echo hello' });
+    t.is(result.image, 'alpine:3.20');
+    t.deepEqual(result.cmd, ['sh', '-c', 'echo hello']);
+});
+test('resolve without packages has no caches', t => {
+    const result = shellKit.resolve({ run: 'ls' });
+    t.is(result.caches, undefined);
+});
+test('resolve without packages has no network', t => {
+    const result = shellKit.resolve({ run: 'ls' });
+    t.is(result.allowNetwork, undefined);
+});
+// -- With packages ------------------------------------------------------------
+test('resolve with packages defaults to debian', t => {
+    const result = shellKit.resolve({ run: 'ls', packages: ['curl'] });
+    t.is(result.image, 'debian:bookworm-slim');
+});
+test('resolve with packages prepends apt-get install', t => {
+    const result = shellKit.resolve({ run: 'unzip archive.zip', packages: ['unzip', 'jq'] });
+    t.truthy(result.cmd[2].includes('apt-get update'));
+    t.truthy(result.cmd[2].includes('apt-get install -y --no-install-recommends unzip jq'));
+    t.truthy(result.cmd[2].includes('unzip archive.zip'));
+});
+test('resolve with packages cleans apt lists', t => {
+    const result = shellKit.resolve({ run: 'ls', packages: ['curl'] });
+    t.truthy(result.cmd[2].includes('rm -rf /var/lib/apt/lists/*'));
+});
+test('resolve with packages includes apt-cache', t => {
+    const result = shellKit.resolve({ run: 'ls', packages: ['curl'] });
+    t.deepEqual(result.caches, [{ name: 'apt-cache', path: '/var/cache/apt' }]);
+});
+test('resolve with packages enables network', t => {
+    const result = shellKit.resolve({ run: 'ls', packages: ['curl'] });
+    t.true(result.allowNetwork);
+});
+test('resolve with empty packages array behaves like no packages', t => {
+    const result = shellKit.resolve({ run: 'ls', packages: [] });
+    t.is(result.image, 'alpine:3.20');
+    t.is(result.caches, undefined);
+    t.is(result.allowNetwork, undefined);
+    t.falsy(result.cmd[2].includes('apt-get'));
+});
+// -- Custom image -------------------------------------------------------------
+test('resolve uses custom image', t => {
+    const result = shellKit.resolve({ run: 'ls', image: 'ubuntu:24.04' });
+    t.is(result.image, 'ubuntu:24.04');
+});
+test('resolve custom image overrides debian default when packages set', t => {
+    const result = shellKit.resolve({ run: 'ls', packages: ['curl'], image: 'ubuntu:24.04' });
+    t.is(result.image, 'ubuntu:24.04');
+});
+// -- Src mount ----------------------------------------------------------------
+test('resolve with src adds mount', t => {
+    const result = shellKit.resolve({ run: 'ls', src: 'mydir' });
+    t.deepEqual(result.mounts, [{ host: 'mydir', container: '/app' }]);
+});
+test('resolve without src has no mounts', t => {
+    const result = shellKit.resolve({ run: 'ls' });
+    t.is(result.mounts, undefined);
+});
+// -- Validation ---------------------------------------------------------------
+test('resolve throws MissingParameterError without run', t => {
+    const error = t.throws(() => shellKit.resolve({}), { message: /run.*required/i });
+    t.true(error instanceof MissingParameterError);
+});
+test('resolve throws MissingParameterError without run even with packages', t => {
+    const error = t.throws(() => shellKit.resolve({ packages: ['curl'] }), { message: /run.*required/i });
+    t.true(error instanceof MissingParameterError);
+});

package/dist/kits/builtin/node.js

@@ -1,3 +1,4 @@
+import { KitError, MissingParameterError } from '../../errors.js';
 const cacheMap = {
     npm: { name: 'npm-cache', path: '/root/.npm' },
     pnpm: { name: 'pnpm-store', path: '/root/.local/share/pnpm/store' },
@@ -15,7 +16,7 @@ function buildInstallCommand(packageManager) {
             return 'cd /app && yarn install 2>&1';
         }
         default: {
-            throw new Error(`Kit "node": unsupported packageManager "${packageManager}"`);
+            throw new KitError('UNSUPPORTED_PACKAGE_MANAGER', `Kit "node": unsupported packageManager "${packageManager}"`);
         }
     }
 }
@@ -25,21 +26,25 @@ export const nodeKit = {
         const version = params.version ?? '24';
         const packageManager = params.packageManager ?? 'npm';
         const script = params.script;
+        const run = params.run;
         const install = params.install ?? true;
         const variant = params.variant ?? 'alpine';
         const src = params.src;
-        if (!script || typeof script !== 'string') {
-            throw new Error('Kit "node": "script" parameter is required');
+        if (script && run) {
+            throw new KitError('CONFLICTING_PARAMETERS', 'Kit "node": "script" and "run" are mutually exclusive');
+        }
+        if (!script && !run) {
+            throw new MissingParameterError('node', 'script" or "run');
         }
         const image = `node:${version}-${variant}`;
         const parts = [];
         if (install) {
             parts.push(buildInstallCommand(packageManager));
         }
-        parts.push(`node /app/${script}`);
+        parts.push(run ?? `node /app/${script}`);
         const cache = cacheMap[packageManager];
         if (!cache) {
-            throw new Error(`Kit "node": unsupported packageManager "${packageManager}"`);
+            throw new KitError('UNSUPPORTED_PACKAGE_MANAGER', `Kit "node": unsupported packageManager "${packageManager}"`);
         }
         const output = {
             image,

package/dist/kits/builtin/python.js

@@ -1,3 +1,4 @@
+import { KitError, MissingParameterError } from '../../errors.js';
 const cacheMap = {
     pip: { name: 'pip-cache', path: '/root/.cache/pip' },
     uv: { name: 'uv-cache', path: '/root/.cache/uv' }
@@ -11,7 +12,7 @@ function buildInstallCommand(packageManager) {
             return 'uv pip install --quiet -r /app/requirements.txt 2>&1';
         }
         default: {
-            throw new Error(`Kit "python": unsupported packageManager "${packageManager}"`);
+            throw new KitError('UNSUPPORTED_PACKAGE_MANAGER', `Kit "python": unsupported packageManager "${packageManager}"`);
         }
     }
 }
@@ -21,22 +22,26 @@ export const pythonKit = {
         const version = params.version ?? '3.12';
         const packageManager = params.packageManager ?? 'pip';
         const script = params.script;
+        const run = params.run;
         const install = params.install ?? true;
         const variant = params.variant ?? 'slim';
         const src = params.src;
-        if (!script || typeof script !== 'string') {
-            throw new Error('Kit "python": "script" parameter is required');
+        if (script && run) {
+            throw new KitError('CONFLICTING_PARAMETERS', 'Kit "python": "script" and "run" are mutually exclusive');
+        }
+        if (!script && !run) {
+            throw new MissingParameterError('python', 'script" or "run');
         }
         const image = `python:${version}-${variant}`;
         const cache = cacheMap[packageManager];
         if (!cache) {
-            throw new Error(`Kit "python": unsupported packageManager "${packageManager}"`);
+            throw new KitError('UNSUPPORTED_PACKAGE_MANAGER', `Kit "python": unsupported packageManager "${packageManager}"`);
         }
         const parts = [];
         if (install) {
             parts.push(buildInstallCommand(packageManager));
         }
-        parts.push(`python /app/${script}`);
+        parts.push(run ?? `python /app/${script}`);
         const output = {
             image,
             cmd: ['sh', '-c', parts.join(' && ')],

package/dist/kits/builtin/shell.js

@@ -1,9 +1,10 @@
+import { MissingParameterError } from '../../errors.js';
 export const shellKit = {
     name: 'shell',
     resolve(params) {
         const run = params.run;
         if (!run || typeof run !== 'string') {
-            throw new Error('Kit "shell": "run" parameter is required');
+            throw new MissingParameterError('shell', 'run');
         }
         const packages = params.packages;
         const hasPackages = packages && packages.length > 0;

package/dist/kits/index.js

@@ -1,3 +1,4 @@
+import { KitError } from '../errors.js';
 import { nodeKit } from './builtin/node.js';
 import { pythonKit } from './builtin/python.js';
 import { shellKit } from './builtin/shell.js';
@@ -9,7 +10,7 @@ const kits = new Map([
 export function getKit(name) {
     const kit = kits.get(name);
     if (!kit) {
-        throw new Error(`Unknown kit: "${name}". Available kits: ${[...kits.keys()].join(', ')}`);
+        throw new KitError('UNKNOWN_KIT', `Unknown kit: "${name}". Available kits: ${[...kits.keys()].join(', ')}`);
     }
     return kit;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livingdata/pipex",
-  "version": "0.0.9",
+  "version": "0.0.10",
   "description": "Execution engine for containerized pipeline steps",
   "author": "Jérôme Desboeufs <jerome@livingdata.co>",
   "type": "module",
@@ -24,16 +24,19 @@
     "test": "ava",
     "lint": "xo",
     "lint:fix": "xo --fix",
-    "build": "tsc"
+    "build": "tsc -p tsconfig.build.json"
   },
   "dependencies": {
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
     "dotenv": "^17.2.3",
     "execa": "^9.6.1",
+    "ignore": "^7.0.5",
+    "jexl": "^2.3.0",
     "lodash-es": "^4.17.23",
-    "ora": "^9.3.0",
+    "log-update": "^7.1.0",
     "pino": "^10.3.0",
+    "tar": "^7.5.7",
     "yaml": "^2.8.2"
   },
   "devDependencies": {

package/dist/cli/types.js

@@ -1,3 +0,0 @@
-export function isKitStep(step) {
-    return 'uses' in step && typeof step.uses === 'string';
-}

package/dist/engine/docker-runtime.js

@@ -1,65 +0,0 @@
-import { execa } from 'execa';
-import { createInterface } from 'node:readline';
-import { ContainerRuntime } from './runtime.js';
-export class DockerCliRuntime extends ContainerRuntime {
-    async check() {
-        try {
-            await execa('docker', ['--version']);
-        }
-        catch {
-            throw new Error('Docker CLI not found. Please install Docker.');
-        }
-    }
-    async run(workspace, request, onLogLine) {
-        const startedAt = new Date();
-        const args = ['run', '--name', request.name, '--network', request.network];
-        if (request.env) {
-            for (const [key, value] of Object.entries(request.env)) {
-                args.push('-e', `${key}=${value}`);
-            }
-        }
-        // Mount inputs (committed artifacts, read-only)
-        for (const input of request.inputs) {
-            const hostPath = workspace.artifactPath(input.artifactId);
-            args.push('-v', `${hostPath}:${input.containerPath}:ro`);
-        }
-        // Mount output (staging artifact, read-write)
-        const outputHostPath = workspace.stagingPath(request.output.stagingArtifactId);
-        args.push('-v', `${outputHostPath}:${request.output.containerPath}:rw`, request.image, ...request.cmd);
-        let exitCode = 0;
-        let error;
-        try {
-            const proc = execa('docker', args, {
-                reject: false,
-                timeout: request.timeoutSec ? request.timeoutSec * 1000 : undefined
-            });
-            if (proc.stdout) {
-                const rl = createInterface({ input: proc.stdout });
-                rl.on('line', line => {
-                    onLogLine({ stream: 'stdout', line });
-                });
-            }
-            if (proc.stderr) {
-                const rl = createInterface({ input: proc.stderr });
-                rl.on('line', line => {
-                    onLogLine({ stream: 'stderr', line });
-                });
-            }
-            const result = await proc;
-            exitCode = result.exitCode ?? 0;
-        }
-        catch (error_) {
-            exitCode = 1;
-            error = error_ instanceof Error ? error_.message : String(error_);
-        }
-        finally {
-            try {
-                await execa('docker', ['rm', '-f', request.name], { reject: false });
-            }
-            catch {
-                // Best effort cleanup
-            }
-        }
-        return { exitCode, startedAt, finishedAt: new Date(), error };
-    }
-}

package/dist/engine/runtime.js

@@ -1,2 +0,0 @@
-export class ContainerRuntime {
-}

package/dist/kits/bash.js

@@ -1,19 +0,0 @@
-export const bashKit = {
-    name: 'bash',
-    resolve(params) {
-        const run = params.run;
-        if (!run || typeof run !== 'string') {
-            throw new Error('Kit "bash": "run" parameter is required');
-        }
-        const image = params.image ?? 'alpine:3.20';
-        const src = params.src;
-        const output = {
-            image,
-            cmd: ['sh', '-c', run]
-        };
-        if (src) {
-            output.mounts = [{ host: src, container: '/app' }];
-        }
-        return output;
-    }
-};

package/dist/kits/builtin/bash.js

@@ -1,19 +0,0 @@
-export const bashKit = {
-    name: 'bash',
-    resolve(params) {
-        const run = params.run;
-        if (!run || typeof run !== 'string') {
-            throw new Error('Kit "bash": "run" parameter is required');
-        }
-        const image = params.image ?? 'alpine:3.20';
-        const src = params.src;
-        const output = {
-            image,
-            cmd: ['sh', '-c', run]
-        };
-        if (src) {
-            output.mounts = [{ host: src, container: '/app' }];
-        }
-        return output;
-    }
-};

package/dist/kits/node.js

@@ -1,56 +0,0 @@
-const cacheMap = {
-    npm: { name: 'npm-cache', path: '/root/.npm' },
-    pnpm: { name: 'pnpm-store', path: '/root/.local/share/pnpm/store' },
-    yarn: { name: 'yarn-cache', path: '/usr/local/share/.cache/yarn' }
-};
-function buildInstallCommand(packageManager) {
-    switch (packageManager) {
-        case 'npm': {
-            return 'cd /tmp && cp /app/package*.json . && npm install --no-audit --no-fund 2>&1';
-        }
-        case 'pnpm': {
-            return 'cd /tmp && cp /app/package.json . && cp /app/pnpm-lock.yaml . 2>/dev/null; pnpm install --no-frozen-lockfile 2>&1';
-        }
-        case 'yarn': {
-            return 'cd /tmp && cp /app/package.json . && cp /app/yarn.lock . 2>/dev/null; yarn install 2>&1';
-        }
-        default: {
-            throw new Error(`Kit "node": unsupported packageManager "${packageManager}"`);
-        }
-    }
-}
-export const nodeKit = {
-    name: 'node',
-    resolve(params) {
-        const version = params.version ?? '22';
-        const packageManager = params.packageManager ?? 'npm';
-        const script = params.script;
-        const install = params.install ?? true;
-        const variant = params.variant ?? 'alpine';
-        const src = params.src;
-        if (!script || typeof script !== 'string') {
-            throw new Error('Kit "node": "script" parameter is required');
-        }
-        const image = `node:${version}-${variant}`;
-        const parts = [];
-        if (install) {
-            parts.push(buildInstallCommand(packageManager));
-        }
-        const nodePathPrefix = install ? 'NODE_PATH=/tmp/node_modules ' : '';
-        parts.push(`${nodePathPrefix}node /app/${script}`);
-        const cache = cacheMap[packageManager];
-        if (!cache) {
-            throw new Error(`Kit "node": unsupported packageManager "${packageManager}"`);
-        }
-        const output = {
-            image,
-            cmd: ['sh', '-c', parts.join(' && ')],
-            caches: [cache],
-            allowNetwork: true
-        };
-        if (src) {
-            output.mounts = [{ host: src, container: '/app' }];
-        }
-        return output;
-    }
-};

package/dist/kits/python.js

@@ -1,51 +0,0 @@
-const cacheMap = {
-    pip: { name: 'pip-cache', path: '/root/.cache/pip' },
-    uv: { name: 'uv-cache', path: '/root/.cache/uv' }
-};
-function buildInstallCommand(packageManager) {
-    switch (packageManager) {
-        case 'pip': {
-            return 'pip install --quiet /app/ 2>&1';
-        }
-        case 'uv': {
-            return 'uv pip install --quiet /app/ 2>&1';
-        }
-        default: {
-            throw new Error(`Kit "python": unsupported packageManager "${packageManager}"`);
-        }
-    }
-}
-export const pythonKit = {
-    name: 'python',
-    resolve(params) {
-        const version = params.version ?? '3.12';
-        const packageManager = params.packageManager ?? 'pip';
-        const script = params.script;
-        const install = params.install ?? true;
-        const variant = params.variant ?? 'slim';
-        const src = params.src;
-        if (!script || typeof script !== 'string') {
-            throw new Error('Kit "python": "script" parameter is required');
-        }
-        const image = `python:${version}-${variant}`;
-        const cache = cacheMap[packageManager];
-        if (!cache) {
-            throw new Error(`Kit "python": unsupported packageManager "${packageManager}"`);
-        }
-        const parts = [];
-        if (install) {
-            parts.push(buildInstallCommand(packageManager));
-        }
-        parts.push(`python /app/${script}`);
-        const output = {
-            image,
-            cmd: ['sh', '-c', parts.join(' && ')],
-            caches: [cache],
-            allowNetwork: true
-        };
-        if (src) {
-            output.mounts = [{ host: src, container: '/app' }];
-        }
-        return output;
-    }
-};

package/dist/kits/types.js

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

package/dist/reporter.js

@@ -1,13 +0,0 @@
-import pino from 'pino';
-export class ConsoleReporter {
-    logger = pino({ level: 'info' });
-    state(workspaceId, event, stepId, meta) {
-        this.logger.info({ workspaceId, event, stepId, ...meta });
-    }
-    log(workspaceId, stepId, stream, line) {
-        this.logger.info({ workspaceId, stepId, stream, line });
-    }
-    result(workspaceId, stepId, result) {
-        this.logger.info({ workspaceId, stepId, result });
-    }
-}