@docker-harpoon/core 0.1.3 → 0.1.5

package/dist/resources/container.js

@@ -6,17 +6,28 @@
  *
  * Supports bindings for environment variable injection and lifecycle hooks.
  */
-import { Effect, Schedule, Exit } from 'effect';
+import { Effect, Schedule, Exit, Stream } from 'effect';
 import { toHarpoonError, ContainerError } from '../errors';
 import { mergeBindingsEnv } from '../bindings/types';
 import { containerStatsSchema, execOptionsSchema, execResultSchema, logOptionsSchema, } from './schemas';
 const CLEANUP_TIMEOUT_MS = 30_000; // 30 seconds for database graceful shutdown
+const makeContainerLogger = (containerName) => ({
+    debug: (message, meta) => {
+        if (process.env.HARPOON_LOG_LEVEL === 'debug') {
+            console.log(`[Container:${containerName}] ${message}`, meta ?? '');
+        }
+    },
+    info: (message, _meta) => console.log(`[Container:${containerName}] ${message}`),
+    warn: (message, _meta) => console.warn(`[Container:${containerName}] ${message}`),
+    error: (message, meta) => console.error(`[Container:${containerName}] ${message}`, meta ?? ''),
+});
 const safeRemoveContainer = async (docker, containerId, containerName) => {
     const container = docker.getContainer(containerId);
+    const log = makeContainerLogger(containerName);
     try {
         const data = await container.inspect();
         if (data.State.Running) {
-            console.log(`[Cleanup] Stopping container: ${containerName}`);
+            log.info('Stopping container');
             try {
                 await container.kill({ signal: 'SIGTERM' });
                 await new Promise((resolve) => {
@@ -46,7 +57,7 @@ const safeRemoveContainer = async (docker, containerId, containerName) => {
                         setTimeout(checkStopped, 100);
                     };
                     const timeout = setTimeout(() => {
-                        console.warn(`[Cleanup] Container ${containerName} did not stop gracefully, forcing`);
+                        log.warn('Container did not stop gracefully, forcing');
                         container.kill({ signal: 'SIGKILL' }).catch(() => { });
                         safeResolve();
                     }, 5000);
@@ -55,33 +66,34 @@ const safeRemoveContainer = async (docker, containerId, containerName) => {
             }
             catch (e) {
                 if (!e.message?.includes('is not running')) {
-                    console.warn(`[Cleanup] Error stopping ${containerName}: ${e.message}`);
+                    log.warn(`Error stopping: ${e.message}`);
                 }
             }
         }
         await container.remove({ force: true });
-        console.log(`[Cleanup] Container removed: ${containerName}`);
+        log.info('Container removed');
     }
     catch (e) {
         if (e.statusCode === 404) {
-            console.log(`[Cleanup] Container ${containerName} already removed`);
+            log.debug('Container already removed');
         }
         else {
-            console.error(`[Cleanup] Error removing container ${containerName}:`, e.message);
+            log.error(`Error removing container: ${e.message}`);
         }
     }
 };
 export const Container = (resourceId, config, docker) => Effect.acquireRelease(Effect.tryPromise({
     try: async () => {
+        const log = makeContainerLogger(resourceId);
         try {
             const existingContainer = docker.getContainer(resourceId);
             await existingContainer.inspect();
-            console.log(`[Container] Found existing container ${resourceId}, removing...`);
+            log.info('Found existing container, removing...');
             await safeRemoveContainer(docker, resourceId, resourceId);
         }
         catch (e) {
             if (e.statusCode !== 404) {
-                console.warn(`[Container] Warning checking for existing container: ${e.message}`);
+                log.warn(`Warning checking for existing container: ${e.message}`);
             }
         }
         if (config.ports?.length) {
@@ -95,12 +107,12 @@ export const Container = (resourceId, config, docker) => Effect.acquireRelease(E
                     if (!usesConflictingPort)
                         continue;
                     const name = c.Names?.[0]?.replace(/^\//, '') ?? c.Id.substring(0, 12);
-                    console.log(`[Container] Found container "${name}" using port(s) ${externalPorts.join(', ')}, removing...`);
+                    log.info(`Found container "${name}" using port(s) ${externalPorts.join(', ')}, removing...`);
                     await safeRemoveContainer(docker, c.Id, name);
                 }
             }
             catch (e) {
-                console.warn(`[Container] Warning checking for port conflicts: ${e.message}`);
+                log.warn(`Warning checking for port conflicts: ${e.message}`);
             }
         }
         const PortBindings = {};
@@ -113,7 +125,7 @@ export const Container = (resourceId, config, docker) => Effect.acquireRelease(E
         try {
             const image = docker.getImage(config.image);
             await image.inspect();
-            console.log(`[Container] Verified image exists: ${config.image}`);
+            log.debug(`Verified image exists: ${config.image}`);
         }
         catch (e) {
             if (e.statusCode === 404) {
@@ -127,9 +139,7 @@ export const Container = (resourceId, config, docker) => Effect.acquireRelease(E
             throw new Error(`Failed to verify image "${config.image}": ${e.message}`);
         }
         // Merge env vars from bindings
-        const bindingsEnv = config.bindings
-            ? mergeBindingsEnv(config.bindings)
-            : {};
+        const bindingsEnv = config.bindings ? mergeBindingsEnv(config.bindings) : {};
         const finalEnv = {
             ...bindingsEnv,
             ...config.env, // User env takes precedence
@@ -142,9 +152,14 @@ export const Container = (resourceId, config, docker) => Effect.acquireRelease(E
                 NetworkMode: config.networks?.[0]?.name,
                 AutoRemove: false,
                 PortBindings,
+                Binds: config.volumes?.map((v) => `${v.hostPath}:${v.containerPath}${v.readonly ? ':ro' : ''}`),
+                CapAdd: config.capAdd,
+                CapDrop: config.capDrop,
+                Privileged: config.privileged,
             },
             ExposedPorts,
             Cmd: config.cmd,
+            User: config.user,
             StopSignal: 'SIGTERM',
             StopTimeout: 10,
         });
@@ -229,8 +244,7 @@ export const Container = (resourceId, config, docker) => Effect.acquireRelease(E
             getIp: (networkName) => Effect.tryPromise({
                 try: async () => {
                     const data = await container.inspect();
-                    return (data.NetworkSettings.Networks[networkName]?.IPAddress ??
-                        'localhost');
+                    return data.NetworkSettings.Networks[networkName]?.IPAddress ?? 'localhost';
                 },
                 catch: (e) => new Error(`getIp failed: ${e}`),
             }),
@@ -244,12 +258,9 @@ export const Container = (resourceId, config, docker) => Effect.acquireRelease(E
                     // Calculate CPU percentage
                     const cpuDelta = statsData.cpu_stats.cpu_usage.total_usage -
                         statsData.precpu_stats.cpu_usage.total_usage;
-                    const systemDelta = statsData.cpu_stats.system_cpu_usage -
-                        statsData.precpu_stats.system_cpu_usage;
+                    const systemDelta = statsData.cpu_stats.system_cpu_usage - statsData.precpu_stats.system_cpu_usage;
                     const cpuCores = statsData.cpu_stats.online_cpus || 1;
-                    const cpuPercent = systemDelta > 0
-                        ? (cpuDelta / systemDelta) * cpuCores * 100
-                        : 0;
+                    const cpuPercent = systemDelta > 0 ? (cpuDelta / systemDelta) * cpuCores * 100 : 0;
                     // Calculate memory stats
                     const memUsage = statsData.memory_stats?.usage ?? 0;
                     const memLimit = statsData.memory_stats?.limit ?? 0;
@@ -294,6 +305,67 @@ export const Container = (resourceId, config, docker) => Effect.acquireRelease(E
                 },
                 catch: (e) => new Error(`stats failed: ${e}`),
             }),
+            /**
+             * Stream container stats as an Effect Stream.
+             * Polls every 1 second using Stream.repeatEffectWithSchedule.
+             */
+            statsStream: () => {
+                const getStats = Effect.tryPromise({
+                    try: async () => {
+                        const statsData = await container.stats({ stream: false });
+                        // Calculate CPU percentage
+                        const cpuDelta = statsData.cpu_stats.cpu_usage.total_usage -
+                            statsData.precpu_stats.cpu_usage.total_usage;
+                        const systemDelta = statsData.cpu_stats.system_cpu_usage - statsData.precpu_stats.system_cpu_usage;
+                        const cpuCores = statsData.cpu_stats.online_cpus || 1;
+                        const cpuPercent = systemDelta > 0 ? (cpuDelta / systemDelta) * cpuCores * 100 : 0;
+                        // Calculate memory stats
+                        const memUsage = statsData.memory_stats?.usage ?? 0;
+                        const memLimit = statsData.memory_stats?.limit ?? 0;
+                        const memPercent = memLimit > 0 ? (memUsage / memLimit) * 100 : 0;
+                        // Calculate network stats (sum all interfaces)
+                        const networks = statsData.networks ?? {};
+                        let rxBytes = 0;
+                        let txBytes = 0;
+                        let rxPackets = 0;
+                        let txPackets = 0;
+                        for (const iface of Object.values(networks)) {
+                            rxBytes += iface.rx_bytes ?? 0;
+                            txBytes += iface.tx_bytes ?? 0;
+                            rxPackets += iface.rx_packets ?? 0;
+                            txPackets += iface.tx_packets ?? 0;
+                        }
+                        const result = {
+                            cpu: {
+                                usage: statsData.cpu_stats.cpu_usage.total_usage,
+                                system: statsData.cpu_stats.system_cpu_usage,
+                                percent: Math.round(cpuPercent * 100) / 100,
+                                cores: cpuCores,
+                            },
+                            memory: {
+                                usage: memUsage,
+                                limit: memLimit,
+                                percent: Math.round(memPercent * 100) / 100,
+                                usageMB: Math.round((memUsage / 1024 / 1024) * 100) / 100,
+                                limitMB: Math.round((memLimit / 1024 / 1024) * 100) / 100,
+                            },
+                            network: {
+                                rxBytes,
+                                txBytes,
+                                rxPackets,
+                                txPackets,
+                            },
+                            timestamp: new Date().toISOString(),
+                            containerId: container.id,
+                        };
+                        return containerStatsSchema.parse(result);
+                    },
+                    catch: (e) => toHarpoonError(new Error(`statsStream failed: ${e}`), resourceId, ContainerError),
+                });
+                // Poll every 1 second
+                const schedule = Schedule.spaced('1 seconds');
+                return Stream.repeatEffectWithSchedule(getStats, schedule);
+            },
             /**
              * Execute a command inside the container.
              * Returns stdout, stderr, and exit code.
@@ -376,69 +448,218 @@ export const Container = (resourceId, config, docker) => Effect.acquireRelease(E
                     const stdout = opts.stdout ?? true;
                     const stderr = opts.stderr ?? true;
                     const timestamps = opts.timestamps ?? false;
-                    const stream = await container.logs({
-                        follow: true,
-                        stdout,
-                        stderr,
-                        since: opts.since,
-                        until: opts.until,
-                        tail: opts.tail,
-                        timestamps,
-                    });
-                    // Create a wrapper to make the stream async iterable
-                    const readable = stream;
-                    // Convert NodeJS.ReadableStream to AsyncIterable<LogLine>
-                    async function* logIterator() {
-                        const chunks = [];
-                        // Use Promise-based iteration for ReadableStream
-                        for await (const chunk of readable) {
-                            // Parse Docker log format (8-byte header + payload)
-                            let offset = 0;
-                            const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-                            while (offset < buffer.length) {
-                                if (offset + 8 > buffer.length) {
-                                    // Incomplete header, yield rest as stdout
+                    const follow = opts.follow ?? false;
+                    // Helper to parse Docker log format from a buffer
+                    function* parseLogBuffer(buffer) {
+                        let offset = 0;
+                        while (offset < buffer.length) {
+                            if (offset + 8 > buffer.length) {
+                                // Incomplete header, yield rest as stdout
+                                const remaining = buffer.slice(offset).toString('utf-8').trim();
+                                if (remaining) {
                                     yield {
                                         stream: 'stdout',
-                                        message: buffer.slice(offset).toString('utf-8').trim(),
+                                        message: remaining,
                                     };
-                                    break;
                                 }
-                                const streamType = buffer.readUInt8(offset);
-                                const size = buffer.readUInt32BE(offset + 4);
-                                if (offset + 8 + size > buffer.length) {
-                                    // Incomplete payload
+                                break;
+                            }
+                            const streamType = buffer.readUInt8(offset);
+                            const size = buffer.readUInt32BE(offset + 4);
+                            if (offset + 8 + size > buffer.length) {
+                                // Incomplete payload
+                                const remaining = buffer
+                                    .slice(offset + 8)
+                                    .toString('utf-8')
+                                    .trim();
+                                if (remaining) {
                                     yield {
                                         stream: streamType === 2 ? 'stderr' : 'stdout',
-                                        message: buffer.slice(offset + 8).toString('utf-8').trim(),
+                                        message: remaining,
                                     };
-                                    break;
                                 }
-                                const payload = buffer.slice(offset + 8, offset + 8 + size);
-                                const message = payload.toString('utf-8');
-                                // Parse timestamp if present (format: "2024-01-14T21:00:00.000000000Z message")
-                                let timestamp;
-                                let content = message;
-                                if (timestamps) {
-                                    const match = message.match(/^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d+Z)\s+(.*)$/s);
-                                    if (match) {
-                                        timestamp = match[1];
-                                        content = match[2] ?? '';
-                                    }
+                                break;
+                            }
+                            const payload = buffer.slice(offset + 8, offset + 8 + size);
+                            const message = payload.toString('utf-8');
+                            // Parse timestamp if present (format: "2024-01-14T21:00:00.000000000Z message")
+                            let timestamp;
+                            let content = message;
+                            if (timestamps) {
+                                const match = message.match(/^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d+Z)\s+(.*)$/s);
+                                if (match) {
+                                    timestamp = match[1];
+                                    content = match[2] ?? '';
                                 }
-                                yield {
-                                    stream: streamType === 2 ? 'stderr' : 'stdout',
-                                    timestamp,
-                                    message: content.trim(),
-                                };
-                                offset += 8 + size;
                             }
+                            yield {
+                                stream: streamType === 2 ? 'stderr' : 'stdout',
+                                timestamp,
+                                message: content.trim(),
+                            };
+                            offset += 8 + size;
                         }
                     }
-                    return logIterator();
+                    // Dockerode has different return types based on follow option:
+                    // - follow: false (or undefined) returns Buffer
+                    // - follow: true returns NodeJS.ReadableStream
+                    // We branch explicitly so TypeScript can infer correct types
+                    if (follow) {
+                        const readable = await container.logs({
+                            follow: true,
+                            stdout,
+                            stderr,
+                            since: opts.since,
+                            until: opts.until,
+                            tail: opts.tail,
+                            timestamps,
+                        });
+                        async function* streamIterator() {
+                            for await (const chunk of readable) {
+                                if (!Buffer.isBuffer(chunk) && typeof chunk !== 'string') {
+                                    continue;
+                                }
+                                const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+                                yield* parseLogBuffer(buffer);
+                            }
+                        }
+                        return streamIterator();
+                    }
+                    // Non-follow mode: Docker returns Buffer directly
+                    const buffer = await container.logs({
+                        follow: false,
+                        stdout,
+                        stderr,
+                        since: opts.since,
+                        until: opts.until,
+                        tail: opts.tail,
+                        timestamps,
+                    });
+                    async function* bufferIterator() {
+                        yield* parseLogBuffer(buffer);
+                    }
+                    return bufferIterator();
                 },
                 catch: (e) => new Error(`streamLogs failed: ${e}`),
             }),
+            /**
+             * Stream container logs as an Effect Stream.
+             * Internal API for Effect-based consumers.
+             * Uses Stream.asyncScoped for follow mode to ensure proper cleanup.
+             */
+            logsStream: (options) => {
+                const opts = logOptionsSchema.parse(options ?? {});
+                const stdout = opts.stdout ?? true;
+                const stderr = opts.stderr ?? true;
+                const timestamps = opts.timestamps ?? false;
+                const follow = opts.follow ?? false;
+                // Helper to parse Docker log format from a buffer
+                const parseLogBuffer = (buffer) => {
+                    const lines = [];
+                    let bufferOffset = 0;
+                    while (bufferOffset < buffer.length) {
+                        if (bufferOffset + 8 > buffer.length) {
+                            const remaining = buffer.slice(bufferOffset).toString('utf-8').trim();
+                            if (remaining) {
+                                lines.push({ stream: 'stdout', message: remaining });
+                            }
+                            break;
+                        }
+                        const streamType = buffer.readUInt8(bufferOffset);
+                        const size = buffer.readUInt32BE(bufferOffset + 4);
+                        if (bufferOffset + 8 + size > buffer.length) {
+                            const remaining = buffer
+                                .slice(bufferOffset + 8)
+                                .toString('utf-8')
+                                .trim();
+                            if (remaining) {
+                                lines.push({
+                                    stream: streamType === 2 ? 'stderr' : 'stdout',
+                                    message: remaining,
+                                });
+                            }
+                            break;
+                        }
+                        const payload = buffer.slice(bufferOffset + 8, bufferOffset + 8 + size);
+                        const message = payload.toString('utf-8');
+                        let timestamp;
+                        let content = message;
+                        if (timestamps) {
+                            const match = message.match(/^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d+Z)\s+(.*)$/s);
+                            if (match) {
+                                timestamp = match[1];
+                                content = match[2] ?? '';
+                            }
+                        }
+                        lines.push({
+                            stream: streamType === 2 ? 'stderr' : 'stdout',
+                            timestamp,
+                            message: content.trim(),
+                        });
+                        bufferOffset += 8 + size;
+                    }
+                    return lines;
+                };
+                if (follow) {
+                    // Follow mode: use Stream.asyncScoped for proper resource cleanup
+                    return Stream.asyncScoped((emit) => Effect.gen(function* () {
+                        const readable = yield* Effect.tryPromise({
+                            try: () => container.logs({
+                                follow: true,
+                                stdout,
+                                stderr,
+                                since: opts.since,
+                                until: opts.until,
+                                tail: opts.tail,
+                                timestamps,
+                            }),
+                            catch: (e) => toHarpoonError(new Error(`logsStream failed: ${e}`), resourceId, ContainerError),
+                        });
+                        // Set up event handlers
+                        const onData = (chunk) => {
+                            const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+                            const lines = parseLogBuffer(buffer);
+                            for (const line of lines) {
+                                emit.single(line);
+                            }
+                        };
+                        const onError = (err) => {
+                            emit.fail(toHarpoonError(err, resourceId, ContainerError));
+                        };
+                        const onEnd = () => {
+                            emit.end();
+                        };
+                        readable.on('data', onData);
+                        readable.on('error', onError);
+                        readable.on('end', onEnd);
+                        // Register cleanup on scope close
+                        yield* Effect.addFinalizer(() => Effect.sync(() => {
+                            readable.removeListener('data', onData);
+                            readable.removeListener('error', onError);
+                            readable.removeListener('end', onEnd);
+                            if (readable.destroy) {
+                                readable.destroy();
+                            }
+                        }));
+                    }));
+                }
+                // Non-follow mode: emit all lines from buffer
+                return Stream.fromEffect(Effect.tryPromise({
+                    try: async () => {
+                        const buffer = await container.logs({
+                            follow: false,
+                            stdout,
+                            stderr,
+                            since: opts.since,
+                            until: opts.until,
+                            tail: opts.tail,
+                            timestamps,
+                        });
+                        return parseLogBuffer(buffer);
+                    },
+                    catch: (e) => toHarpoonError(new Error(`logsStream failed: ${e}`), resourceId, ContainerError),
+                })).pipe(Stream.flatMap((lines) => Stream.fromIterable(lines)));
+            },
         };
         // Call onStart hooks for bindings
         // This is done in Effect context for proper error handling
@@ -446,19 +667,20 @@ export const Container = (resourceId, config, docker) => Effect.acquireRelease(E
     },
     catch: (e) => new Error(`Container "${resourceId}" creation failed: ${e}`),
 }).pipe(Effect.mapError((e) => toHarpoonError(e, resourceId, ContainerError)), 
-// Run onStart hooks after container creation
+// Run onStart hooks after container creation (in parallel for performance)
 Effect.tap((resource) => Effect.gen(function* () {
     if (config.bindings) {
-        for (const binding of Object.values(config.bindings)) {
-            if (binding.onStart) {
-                yield* binding.onStart(resource);
-            }
+        const onStartHooks = Object.values(config.bindings)
+            .filter((binding) => binding.onStart !== undefined)
+            .map((binding) => binding.onStart(resource));
+        if (onStartHooks.length > 0) {
+            yield* Effect.all(onStartHooks, { concurrency: 4 });
         }
     }
 }))), (resource, exit) => Effect.gen(function* () {
     const isInterrupted = Exit.isInterrupted(exit);
     if (isInterrupted) {
-        console.log(`[Cleanup] Interrupted - force cleaning container: ${resource.name}`);
+        yield* Effect.logDebug('Interrupted - force cleaning container').pipe(Effect.annotateLogs({ service: 'Container', containerId: resource.id }));
     }
     yield* Effect.tryPromise({
         try: () => Promise.race([
@@ -466,7 +688,9 @@ Effect.tap((resource) => Effect.gen(function* () {
             new Promise((_, reject) => setTimeout(() => reject(new Error('Cleanup timeout')), CLEANUP_TIMEOUT_MS)),
         ]),
         catch: (e) => {
-            console.error(`[Cleanup] Failed to clean up container ${resource.name}:`, e);
+            // Log error but don't fail - cleanup should be best effort
+            const log = makeContainerLogger(resource.name);
+            log.error(`Failed to clean up container`, { error: e });
             return null;
         },
     });

package/dist/resources/image.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"image.d.ts","sourceRoot":"","sources":["../../src/resources/image.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAKhC,MAAM,WAAW,WAAW;IAC1B,0CAA0C;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,6CAA6C;IAC7C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,6BAA6B;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,kDAAkD;IAClD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,uCAAuC;IACvC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,mDAAmD;IACnD,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;GAMG;AACH,eAAO,MAAM,KAAK,kFA4HmD,CAAC"}
+{"version":3,"file":"image.d.ts","sourceRoot":"","sources":["../../src/resources/image.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAMhC,MAAM,WAAW,WAAW;IAC1B,0CAA0C;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,6CAA6C;IAC7C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,6BAA6B;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,kDAAkD;IAClD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,uCAAuC;IACvC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,mDAAmD;IACnD,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;GAMG;AACH,eAAO,MAAM,KAAK,kFAgGmD,CAAC"}

package/dist/resources/image.js

@@ -8,6 +8,7 @@ import { Effect } from 'effect';
 import * as fs from 'fs/promises';
 import { toHarpoonError, ImageError } from '../errors';
 import { getBuildStrategy } from '../build-strategies';
+import { execCommand } from '../utils/process';
 /**
  * Build a Docker image using the configured strategy.
  *
@@ -45,34 +46,18 @@ export const Image = (tag, config) => Effect.gen(function* () {
                 }
             }
             args.push(buildContext.contextPath);
-            const proc = Bun.spawn(args, {
-                stdout: 'ignore',
-                stderr: 'pipe',
-            });
-            const stderrOutput = [];
-            const errorReader = async () => {
-                if (!proc.stderr)
-                    return;
-                const reader = proc.stderr.getReader();
-                const decoder = new TextDecoder();
-                try {
-                    while (true) {
-                        const { done, value } = await reader.read();
-                        if (done)
-                            break;
-                        const output = decoder.decode(value);
-                        stderrOutput.push(output);
-                        if (output.toLowerCase().includes('error')) {
-                            console.error(`[${tag}] ${output.trim()}`);
-                        }
+            // Execute docker build using cross-runtime utility
+            const buildResult = await execCommand('docker', args.slice(1), { captureStderr: true });
+            // Log errors from stderr if present
+            if (buildResult.stderr) {
+                for (const line of buildResult.stderr.split('\n')) {
+                    if (line.toLowerCase().includes('error')) {
+                        console.error(`[${tag}] ${line.trim()}`);
                     }
                 }
-                catch (e) {
-                    console.error(`[${tag}] Error reading stderr:`, e);
-                }
-            };
-            await errorReader();
-            const exitCode = await proc.exited;
+            }
+            const exitCode = buildResult.exitCode;
+            const stderrOutput = buildResult.stderr ? [buildResult.stderr] : [];
             // Cleanup temp directory if needed
             if (buildContext.requiresCleanup && buildContext.tempDir) {
                 await fs.rm(buildContext.tempDir, { recursive: true, force: true });
@@ -84,16 +69,10 @@ export const Image = (tag, config) => Effect.gen(function* () {
             // Verify image was created
             let verified = false;
             for (let attempt = 0; attempt < 5; attempt++) {
-                const verifyProc = Bun.spawn(['docker', 'images', '-q', tag], {
-                    stdout: 'pipe',
-                    stderr: 'pipe',
+                const verifyResult = await execCommand('docker', ['images', '-q', tag], {
+                    captureStdout: true,
                 });
-                let verifyOutput = '';
-                if (verifyProc.stdout) {
-                    verifyOutput = await Bun.readableStreamToText(verifyProc.stdout);
-                }
-                const verifyExitCode = await verifyProc.exited;
-                if (verifyExitCode === 0 && verifyOutput.trim()) {
+                if (verifyResult.exitCode === 0 && verifyResult.stdout.trim()) {
                     verified = true;
                     break;
                 }

package/dist/resources/index.d.ts

@@ -6,7 +6,7 @@
 export { Network } from './network';
 export type { NetworkConfig, NetworkResource } from './network';
 export { Container } from './container';
-export type { ContainerConfig, ContainerResource, PortMapping, ShutdownMetadata, } from './container';
+export type { ContainerConfig, ContainerResource, PortMapping, ShutdownMetadata, VolumeMapping, } from './container';
 export { containerStatsSchema, execOptionsSchema, execResultSchema, logOptionsSchema, logLineSchema, cpuStatsSchema, memoryStatsSchema, networkStatsSchema, statsOptionsSchema, } from './schemas';
 export type { ContainerStats, CpuStats, MemoryStats, NetworkStats, ExecOptions, ExecResult, LogOptions, LogLine, StatsOptions, } from './schemas';
 export { Image } from './image';

package/dist/resources/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/resources/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,YAAY,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAEhE,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,YAAY,EACV,eAAe,EACf,iBAAiB,EACjB,WAAW,EACX,gBAAgB,GACjB,MAAM,aAAa,CAAC;AAGrB,OAAO,EACL,oBAAoB,EACpB,iBAAiB,EACjB,gBAAgB,EAChB,gBAAgB,EAChB,aAAa,EACb,cAAc,EACd,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,GACnB,MAAM,WAAW,CAAC;AACnB,YAAY,EACV,cAAc,EACd,QAAQ,EACR,WAAW,EACX,YAAY,EACZ,WAAW,EACX,UAAU,EACV,UAAU,EACV,OAAO,EACP,YAAY,GACb,MAAM,WAAW,CAAC;AAEnB,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,YAAY,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/resources/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,YAAY,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAEhE,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,YAAY,EACV,eAAe,EACf,iBAAiB,EACjB,WAAW,EACX,gBAAgB,EAChB,aAAa,GACd,MAAM,aAAa,CAAC;AAGrB,OAAO,EACL,oBAAoB,EACpB,iBAAiB,EACjB,gBAAgB,EAChB,gBAAgB,EAChB,aAAa,EACb,cAAc,EACd,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,GACnB,MAAM,WAAW,CAAC;AACnB,YAAY,EACV,cAAc,EACd,QAAQ,EACR,WAAW,EACX,YAAY,EACZ,WAAW,EACX,UAAU,EACV,UAAU,EACV,OAAO,EACP,YAAY,GACb,MAAM,WAAW,CAAC;AAEnB,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,YAAY,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC"}

package/dist/resources/network.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"network.d.ts","sourceRoot":"","sources":["../../src/resources/network.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,MAAM,EAAE,KAAK,EAAQ,MAAM,QAAQ,CAAC;AAC7C,OAAO,MAAM,MAAM,WAAW,CAAC;AAG/B,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAiCD;;GAEG;AACH,eAAO,MAAM,OAAO,mHAmFjB,CAAC"}
+{"version":3,"file":"network.d.ts","sourceRoot":"","sources":["../../src/resources/network.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,MAAM,EAAE,KAAK,EAAQ,MAAM,QAAQ,CAAC;AAC7C,OAAO,MAAM,MAAM,WAAW,CAAC;AAG/B,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAmDD;;GAEG;AACH,eAAO,MAAM,OAAO,mHA2EjB,CAAC"}