@docker-harpoon/core 0.1.4 → 0.1.5

package/dist/resources/schemas.d.ts

@@ -2,7 +2,7 @@
  * Zod Schemas for Container Resources
  *
  * Defines validation schemas for container stats, exec, and log streaming.
- * Following Alchemy.run patterns for declarative resource definitions.
+ * Following Harpoon patterns for declarative resource definitions.
  */
 import { z } from 'zod';
 /**
@@ -13,7 +13,17 @@ export declare const cpuStatsSchema: z.ZodObject<{
     system: z.ZodNumber;
     percent: z.ZodNumber;
     cores: z.ZodNumber;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    usage: number;
+    system: number;
+    percent: number;
+    cores: number;
+}, {
+    usage: number;
+    system: number;
+    percent: number;
+    cores: number;
+}>;
 /**
  * Memory statistics from Docker container
  */
@@ -23,7 +33,19 @@ export declare const memoryStatsSchema: z.ZodObject<{
     percent: z.ZodNumber;
     usageMB: z.ZodNumber;
     limitMB: z.ZodNumber;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    usage: number;
+    limit: number;
+    percent: number;
+    usageMB: number;
+    limitMB: number;
+}, {
+    usage: number;
+    limit: number;
+    percent: number;
+    usageMB: number;
+    limitMB: number;
+}>;
 /**
  * Network I/O statistics from Docker container
  */
@@ -32,7 +54,17 @@ export declare const networkStatsSchema: z.ZodObject<{
     txBytes: z.ZodNumber;
     rxPackets: z.ZodNumber;
     txPackets: z.ZodNumber;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    rxBytes: number;
+    txBytes: number;
+    rxPackets: number;
+    txPackets: number;
+}, {
+    rxBytes: number;
+    txBytes: number;
+    rxPackets: number;
+    txPackets: number;
+}>;
 /**
  * Complete container statistics
  */
@@ -42,23 +74,99 @@ export declare const containerStatsSchema: z.ZodObject<{
         system: z.ZodNumber;
         percent: z.ZodNumber;
         cores: z.ZodNumber;
-    }, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        usage: number;
+        system: number;
+        percent: number;
+        cores: number;
+    }, {
+        usage: number;
+        system: number;
+        percent: number;
+        cores: number;
+    }>;
     memory: z.ZodObject<{
         usage: z.ZodNumber;
         limit: z.ZodNumber;
         percent: z.ZodNumber;
         usageMB: z.ZodNumber;
         limitMB: z.ZodNumber;
-    }, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        usage: number;
+        limit: number;
+        percent: number;
+        usageMB: number;
+        limitMB: number;
+    }, {
+        usage: number;
+        limit: number;
+        percent: number;
+        usageMB: number;
+        limitMB: number;
+    }>;
     network: z.ZodObject<{
         rxBytes: z.ZodNumber;
         txBytes: z.ZodNumber;
         rxPackets: z.ZodNumber;
         txPackets: z.ZodNumber;
-    }, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        rxBytes: number;
+        txBytes: number;
+        rxPackets: number;
+        txPackets: number;
+    }, {
+        rxBytes: number;
+        txBytes: number;
+        rxPackets: number;
+        txPackets: number;
+    }>;
     timestamp: z.ZodString;
     containerId: z.ZodString;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    cpu: {
+        usage: number;
+        system: number;
+        percent: number;
+        cores: number;
+    };
+    memory: {
+        usage: number;
+        limit: number;
+        percent: number;
+        usageMB: number;
+        limitMB: number;
+    };
+    network: {
+        rxBytes: number;
+        txBytes: number;
+        rxPackets: number;
+        txPackets: number;
+    };
+    timestamp: string;
+    containerId: string;
+}, {
+    cpu: {
+        usage: number;
+        system: number;
+        percent: number;
+        cores: number;
+    };
+    memory: {
+        usage: number;
+        limit: number;
+        percent: number;
+        usageMB: number;
+        limitMB: number;
+    };
+    network: {
+        rxBytes: number;
+        txBytes: number;
+        rxPackets: number;
+        txPackets: number;
+    };
+    timestamp: string;
+    containerId: string;
+}>;
 export type ContainerStats = z.infer<typeof containerStatsSchema>;
 export type CpuStats = z.infer<typeof cpuStatsSchema>;
 export type MemoryStats = z.infer<typeof memoryStatsSchema>;
@@ -67,13 +175,27 @@ export type NetworkStats = z.infer<typeof networkStatsSchema>;
  * Options for executing a command in a container
  */
 export declare const execOptionsSchema: z.ZodObject<{
-    cmd: z.ZodArray<z.ZodString>;
+    cmd: z.ZodArray<z.ZodString, "many">;
     env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     workingDir: z.ZodOptional<z.ZodString>;
     user: z.ZodOptional<z.ZodString>;
     privileged: z.ZodOptional<z.ZodBoolean>;
     tty: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    cmd: string[];
+    env?: Record<string, string> | undefined;
+    workingDir?: string | undefined;
+    user?: string | undefined;
+    privileged?: boolean | undefined;
+    tty?: boolean | undefined;
+}, {
+    cmd: string[];
+    env?: Record<string, string> | undefined;
+    workingDir?: string | undefined;
+    user?: string | undefined;
+    privileged?: boolean | undefined;
+    tty?: boolean | undefined;
+}>;
 /**
  * Result of executing a command in a container
  */
@@ -82,7 +204,17 @@ export declare const execResultSchema: z.ZodObject<{
     stdout: z.ZodString;
     stderr: z.ZodString;
     durationMs: z.ZodNumber;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    durationMs: number;
+}, {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    durationMs: number;
+}>;
 export type ExecOptions = z.infer<typeof execOptionsSchema>;
 export type ExecResult = z.infer<typeof execResultSchema>;
 /**
@@ -96,18 +228,39 @@ export declare const logOptionsSchema: z.ZodObject<{
     tail: z.ZodOptional<z.ZodNumber>;
     timestamps: z.ZodOptional<z.ZodBoolean>;
     follow: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    stdout?: boolean | undefined;
+    stderr?: boolean | undefined;
+    since?: number | undefined;
+    until?: number | undefined;
+    tail?: number | undefined;
+    timestamps?: boolean | undefined;
+    follow?: boolean | undefined;
+}, {
+    stdout?: boolean | undefined;
+    stderr?: boolean | undefined;
+    since?: number | undefined;
+    until?: number | undefined;
+    tail?: number | undefined;
+    timestamps?: boolean | undefined;
+    follow?: boolean | undefined;
+}>;
 /**
  * A single log line from a container
  */
 export declare const logLineSchema: z.ZodObject<{
-    stream: z.ZodEnum<{
-        stderr: "stderr";
-        stdout: "stdout";
-    }>;
+    stream: z.ZodEnum<["stdout", "stderr"]>;
     timestamp: z.ZodOptional<z.ZodString>;
     message: z.ZodString;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    stream: "stderr" | "stdout";
+    timestamp?: string | undefined;
+    message: string;
+}, {
+    stream: "stderr" | "stdout";
+    timestamp?: string | undefined;
+    message: string;
+}>;
 export type LogOptions = z.infer<typeof logOptionsSchema>;
 export type LogLine = z.infer<typeof logLineSchema>;
 /**
@@ -116,6 +269,12 @@ export type LogLine = z.infer<typeof logLineSchema>;
 export declare const statsOptionsSchema: z.ZodObject<{
     stream: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     oneShot: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    stream: boolean;
+    oneShot: boolean;
+}, {
+    stream?: boolean | undefined;
+    oneShot?: boolean | undefined;
+}>;
 export type StatsOptions = z.infer<typeof statsOptionsSchema>;
 //# sourceMappingURL=schemas.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/resources/schemas.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;iBAKzB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;iBAM5B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;iBAK7B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;iBAM/B,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAI9D;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;iBAO5B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;iBAK3B,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAI1D;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;iBAQ3B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;;iBAIxB,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAIpD;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;iBAG7B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/resources/schemas.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;EAKzB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;EAM5B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;EAK7B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM/B,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAI9D;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;EAO5B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;EAK3B,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAI1D;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;EAQ3B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;EAIxB,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAIpD;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;EAG7B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/resources/schemas.js

@@ -2,7 +2,7 @@
  * Zod Schemas for Container Resources
  *
  * Defines validation schemas for container stats, exec, and log streaming.
- * Following Alchemy.run patterns for declarative resource definitions.
+ * Following Harpoon patterns for declarative resource definitions.
  */
 import { z } from 'zod';
 // ============ Container Stats Schema ============

package/dist/services/CircuitBreaker.d.ts

@@ -0,0 +1,83 @@
+/**
+ * CircuitBreaker Service
+ *
+ * Implements the circuit breaker pattern to prevent cascading failures
+ * when the Docker daemon becomes unresponsive or overloaded.
+ *
+ * States:
+ * - Closed: Normal operation, requests pass through
+ * - Open: Circuit tripped, requests fail fast
+ * - HalfOpen: Testing if the service has recovered
+ */
+import { Context, Effect, Layer, Duration } from 'effect';
+/**
+ * Circuit breaker states.
+ */
+export type CircuitState = 'Closed' | 'Open' | 'HalfOpen';
+/**
+ * Circuit breaker configuration.
+ */
+export interface CircuitBreakerConfig {
+    /** Number of failures before opening the circuit */
+    readonly maxFailures: number;
+    /** Time to wait before attempting to close the circuit */
+    readonly resetTimeout: Duration.Duration;
+    /** Optional name for logging */
+    readonly name?: string;
+}
+/**
+ * Error thrown when the circuit is open.
+ */
+export declare class CircuitOpenError extends Error {
+    readonly _tag = "CircuitOpenError";
+    readonly circuitName: string;
+    readonly resetTimeout: Duration.Duration;
+    constructor(circuitName: string, resetTimeout: Duration.Duration);
+}
+/**
+ * CircuitBreaker service interface.
+ */
+export interface CircuitBreakerService {
+    readonly _tag: 'CircuitBreaker';
+    /**
+     * Execute an effect protected by the circuit breaker.
+     * If the circuit is open, fails fast with CircuitOpenError.
+     */
+    readonly protect: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | CircuitOpenError, R>;
+    /**
+     * Get the current circuit state.
+     */
+    readonly getState: () => Effect.Effect<CircuitState>;
+    /**
+     * Manually reset the circuit to closed state.
+     */
+    readonly reset: () => Effect.Effect<void>;
+    /**
+     * Get current failure count.
+     */
+    readonly getFailures: () => Effect.Effect<number>;
+}
+declare const CircuitBreaker_base: Context.TagClass<CircuitBreaker, "@harpoon/CircuitBreaker", CircuitBreakerService>;
+/**
+ * CircuitBreaker service tag for dependency injection.
+ */
+export declare class CircuitBreaker extends CircuitBreaker_base {
+}
+/**
+ * Factory function to create a circuit breaker with specific configuration.
+ */
+export declare const makeCircuitBreaker: (config: CircuitBreakerConfig) => Effect.Effect<CircuitBreakerService, never, never>;
+/**
+ * Live implementation with default configuration.
+ */
+export declare const CircuitBreakerLive: Layer.Layer<CircuitBreaker, never, never>;
+/**
+ * Test implementation that never opens (all requests pass through).
+ */
+export declare const CircuitBreakerTest: Layer.Layer<CircuitBreaker, never, never>;
+/**
+ * Create a custom circuit breaker layer with specific configuration.
+ */
+export declare const makeCircuitBreakerLayer: (config: CircuitBreakerConfig) => Layer.Layer<CircuitBreaker, never, never>;
+export {};
+//# sourceMappingURL=CircuitBreaker.d.ts.map

package/dist/services/CircuitBreaker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CircuitBreaker.d.ts","sourceRoot":"","sources":["../../src/services/CircuitBreaker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAO,QAAQ,EAAS,MAAM,QAAQ,CAAC;AAEtE;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,CAAC;AAE1D;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,oDAAoD;IACpD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAE7B,0DAA0D;IAC1D,QAAQ,CAAC,YAAY,EAAE,QAAQ,CAAC,QAAQ,CAAC;IAEzC,gCAAgC;IAChC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAYD;;GAEG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;IACzC,QAAQ,CAAC,IAAI,sBAAsB;IACnC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,YAAY,EAAE,QAAQ,CAAC,QAAQ,CAAC;IAEzC,YAAY,WAAW,EAAE,MAAM,EAAE,YAAY,EAAE,QAAQ,CAAC,QAAQ,EAQ/D;CACF;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAEhC;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EACxB,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAC3B,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,GAAG,gBAAgB,EAAE,CAAC,CAAC,CAAC;IAE/C;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;IAErD;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAE1C;;OAEG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;CACnD;;AAED;;GAEG;AACH,qBAAa,cAAe,SAAQ,mBAGjC;CAAG;AAEN;;GAEG;AACH,eAAO,MAAM,kBAAkB,sFA+I3B,CAAC;AAWL;;GAEG;AACH,eAAO,MAAM,kBAAkB,2CAAkE,CAAC;AAElG;;GAEG;AACH,eAAO,MAAM,kBAAkB,2CAO7B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,uBAAuB,6EAEsD,CAAC"}

package/dist/services/CircuitBreaker.js

@@ -0,0 +1,164 @@
+/**
+ * CircuitBreaker Service
+ *
+ * Implements the circuit breaker pattern to prevent cascading failures
+ * when the Docker daemon becomes unresponsive or overloaded.
+ *
+ * States:
+ * - Closed: Normal operation, requests pass through
+ * - Open: Circuit tripped, requests fail fast
+ * - HalfOpen: Testing if the service has recovered
+ */
+import { Context, Effect, Layer, Ref, Duration, Clock } from 'effect';
+/**
+ * Error thrown when the circuit is open.
+ */
+export class CircuitOpenError extends Error {
+    _tag = 'CircuitOpenError';
+    circuitName;
+    resetTimeout;
+    constructor(circuitName, resetTimeout) {
+        super(`Circuit breaker "${circuitName}" is open. ` +
+            `Retry after ${Duration.toMillis(resetTimeout)}ms`);
+        this.circuitName = circuitName;
+        this.resetTimeout = resetTimeout;
+        this.name = 'CircuitOpenError';
+    }
+}
+/**
+ * CircuitBreaker service tag for dependency injection.
+ */
+export class CircuitBreaker extends Context.Tag('@harpoon/CircuitBreaker')() {
+}
+/**
+ * Factory function to create a circuit breaker with specific configuration.
+ */
+export const makeCircuitBreaker = (config) => Effect.gen(function* () {
+    const name = config.name ?? 'default';
+    const resetTimeoutMs = Duration.toMillis(config.resetTimeout);
+    // Initialize state
+    const stateRef = yield* Ref.make({
+        state: 'Closed',
+        failures: 0,
+        lastFailure: null,
+        successesSinceHalfOpen: 0,
+    });
+    // Helper to check if we should transition from Open to HalfOpen
+    const checkReset = Effect.gen(function* () {
+        const current = yield* Ref.get(stateRef);
+        if (current.state !== 'Open')
+            return;
+        const now = yield* Clock.currentTimeMillis;
+        const timeSinceFailure = current.lastFailure ? now - current.lastFailure : Infinity;
+        if (timeSinceFailure >= resetTimeoutMs) {
+            yield* Ref.update(stateRef, (s) => ({
+                ...s,
+                state: 'HalfOpen',
+                successesSinceHalfOpen: 0,
+            }));
+            yield* Effect.logDebug('Circuit breaker transitioning to HalfOpen').pipe(Effect.annotateLogs({ circuit: name }));
+        }
+    });
+    // Record a failure
+    const recordFailure = Effect.gen(function* () {
+        const now = yield* Clock.currentTimeMillis;
+        const current = yield* Ref.get(stateRef);
+        if (current.state === 'HalfOpen') {
+            // Any failure in HalfOpen reopens the circuit
+            yield* Ref.set(stateRef, {
+                state: 'Open',
+                failures: current.failures + 1,
+                lastFailure: now,
+                successesSinceHalfOpen: 0,
+            });
+            yield* Effect.logWarning('Circuit breaker reopened from HalfOpen').pipe(Effect.annotateLogs({ circuit: name }));
+        }
+        else {
+            const newFailures = current.failures + 1;
+            const shouldOpen = newFailures >= config.maxFailures;
+            yield* Ref.set(stateRef, {
+                state: shouldOpen ? 'Open' : 'Closed',
+                failures: newFailures,
+                lastFailure: now,
+                successesSinceHalfOpen: 0,
+            });
+            if (shouldOpen) {
+                yield* Effect.logWarning('Circuit breaker opened').pipe(Effect.annotateLogs({
+                    circuit: name,
+                    failures: newFailures,
+                    maxFailures: config.maxFailures,
+                }));
+            }
+        }
+    });
+    // Record a success
+    const recordSuccess = Effect.gen(function* () {
+        const current = yield* Ref.get(stateRef);
+        if (current.state === 'HalfOpen') {
+            // Success in HalfOpen mode - close the circuit
+            yield* Ref.set(stateRef, {
+                state: 'Closed',
+                failures: 0,
+                lastFailure: null,
+                successesSinceHalfOpen: 0,
+            });
+            yield* Effect.logInfo('Circuit breaker closed after successful probe').pipe(Effect.annotateLogs({ circuit: name }));
+        }
+        else if (current.state === 'Closed' && current.failures > 0) {
+            // Reset failure count on success in closed state
+            yield* Ref.update(stateRef, (s) => ({
+                ...s,
+                failures: 0,
+            }));
+        }
+    });
+    const service = {
+        _tag: 'CircuitBreaker',
+        protect: (effect) => Effect.gen(function* () {
+            // Check if we should transition from Open to HalfOpen
+            yield* checkReset;
+            const current = yield* Ref.get(stateRef);
+            if (current.state === 'Open') {
+                return yield* Effect.fail(new CircuitOpenError(name, config.resetTimeout));
+            }
+            // Execute the effect
+            const result = yield* effect.pipe(Effect.tap(() => recordSuccess), Effect.tapError(() => recordFailure));
+            return result;
+        }),
+        getState: () => Ref.get(stateRef).pipe(Effect.map((s) => s.state)),
+        reset: () => Ref.set(stateRef, {
+            state: 'Closed',
+            failures: 0,
+            lastFailure: null,
+            successesSinceHalfOpen: 0,
+        }).pipe(Effect.tap(() => Effect.logInfo('Circuit breaker manually reset').pipe(Effect.annotateLogs({ circuit: name })))),
+        getFailures: () => Ref.get(stateRef).pipe(Effect.map((s) => s.failures)),
+    };
+    return service;
+});
+/**
+ * Default circuit breaker configuration.
+ */
+const defaultConfig = {
+    maxFailures: 5,
+    resetTimeout: Duration.seconds(30),
+    name: 'docker',
+};
+/**
+ * Live implementation with default configuration.
+ */
+export const CircuitBreakerLive = Layer.effect(CircuitBreaker, makeCircuitBreaker(defaultConfig));
+/**
+ * Test implementation that never opens (all requests pass through).
+ */
+export const CircuitBreakerTest = Layer.succeed(CircuitBreaker, {
+    _tag: 'CircuitBreaker',
+    protect: (effect) => effect,
+    getState: () => Effect.succeed('Closed'),
+    reset: () => Effect.void,
+    getFailures: () => Effect.succeed(0),
+});
+/**
+ * Create a custom circuit breaker layer with specific configuration.
+ */
+export const makeCircuitBreakerLayer = (config) => Layer.effect(CircuitBreaker, makeCircuitBreaker(config));

package/dist/services/ContainerPool.d.ts

@@ -0,0 +1,82 @@
+/**
+ * ContainerPool Service
+ *
+ * Provides a pool of pre-warmed containers for faster test execution.
+ * Uses Effect's Pool for efficient resource management.
+ */
+import { Context, Effect, Layer, Scope, Duration } from 'effect';
+import { DockerClient } from './DockerClient';
+import { HarpoonConfig } from './HarpoonConfig';
+import { type ContainerConfig, type ContainerResource } from '../resources/container';
+/**
+ * Configuration for the container pool.
+ */
+export interface ContainerPoolConfig {
+    /** Base configuration for pooled containers */
+    readonly containerConfig: ContainerConfig;
+    /** Minimum number of containers to keep in the pool */
+    readonly minSize: number;
+    /** Maximum number of containers in the pool */
+    readonly maxSize: number;
+    /** Time to wait for a container before timing out */
+    readonly acquireTimeout: Duration.Duration;
+    /** How long an idle container stays in the pool */
+    readonly idleTimeout: Duration.Duration;
+    /** Prefix for container names */
+    readonly namePrefix: string;
+}
+/**
+ * Pooled container with additional metadata.
+ */
+export interface PooledContainer {
+    readonly resource: ContainerResource;
+    readonly acquiredAt: Date;
+    readonly poolId: string;
+}
+/**
+ * ContainerPool service interface.
+ */
+export interface ContainerPoolService {
+    readonly _tag: 'ContainerPool';
+    /**
+     * Acquire a container from the pool.
+     * Returns a scoped effect that releases the container when done.
+     */
+    readonly acquire: () => Effect.Effect<PooledContainer, Error, Scope.Scope>;
+    /**
+     * Get the current size of the pool (available + in-use).
+     */
+    readonly size: () => Effect.Effect<number>;
+    /**
+     * Get the number of available containers in the pool.
+     */
+    readonly available: () => Effect.Effect<number>;
+    /**
+     * Get the number of containers currently in use.
+     */
+    readonly inUse: () => Effect.Effect<number>;
+    /**
+     * Pre-warm the pool by creating containers up to minSize.
+     */
+    readonly warmup: () => Effect.Effect<void, Error>;
+}
+declare const ContainerPool_base: Context.TagClass<ContainerPool, "@harpoon/ContainerPool", ContainerPoolService>;
+/**
+ * ContainerPool service tag for dependency injection.
+ */
+export declare class ContainerPool extends ContainerPool_base {
+}
+/**
+ * Create a ContainerPool with specific configuration.
+ */
+export declare const makeContainerPool: (config?: Partial<ContainerPoolConfig>) => Effect.Effect<ContainerPoolService, Error, DockerClient | HarpoonConfig | Scope.Scope>;
+/**
+ * Live implementation layer.
+ */
+export declare const ContainerPoolLive: (config?: Partial<ContainerPoolConfig>) => Layer.Layer<ContainerPool, Error, DockerClient | HarpoonConfig>;
+/**
+ * Test implementation that creates containers on-demand.
+ */
+export declare const ContainerPoolTest: Layer.Layer<ContainerPool, never, never>;
+export {};
+//# sourceMappingURL=ContainerPool.d.ts.map

package/dist/services/ContainerPool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContainerPool.d.ts","sourceRoot":"","sources":["../../src/services/ContainerPool.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAQ,KAAK,EAAE,QAAQ,EAAO,MAAM,QAAQ,CAAC;AAG5E,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAa,KAAK,eAAe,EAAE,KAAK,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAIjG;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,+CAA+C;IAC/C,QAAQ,CAAC,eAAe,EAAE,eAAe,CAAC;IAE1C,uDAAuD;IACvD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAEzB,+CAA+C;IAC/C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAEzB,qDAAqD;IACrD,QAAQ,CAAC,cAAc,EAAE,QAAQ,CAAC,QAAQ,CAAC;IAE3C,mDAAmD;IACnD,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC,QAAQ,CAAC;IAExC,iCAAiC;IACjC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAC;IACrC,QAAQ,CAAC,UAAU,EAAE,IAAI,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAID;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAE/B;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,MAAM,CAAC,MAAM,CAAC,eAAe,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;IAE3E;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAE3C;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAEhD;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAE5C;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;CACnD;;AAED;;GAEG;AACH,qBAAa,aAAc,SAAQ,kBAGhC;CAAG;AAiBN;;GAEG;AACH,eAAO,MAAM,iBAAiB,mIAyI1B,CAAC;AAEL;;GAEG;AACH,eAAO,MAAM,iBAAiB,4GAG0B,CAAC;AAEzD;;GAEG;AACH,eAAO,MAAM,iBAAiB,0CA2E7B,CAAC"}