@docker-harpoon/core 0.1.3 → 0.1.5

package/dist/resources/network.js

@@ -8,24 +8,35 @@ import { Effect, Exit } from 'effect';
 import { toHarpoonError, NetworkError } from '../errors';
 // Constants
 const CLEANUP_TIMEOUT_MS = 5_000; // 5 seconds max for network cleanup
+const makeNetworkLogger = (networkName) => ({
+    debug: (message) => {
+        if (process.env.HARPOON_LOG_LEVEL === 'debug') {
+            console.log(`[Network:${networkName}] ${message}`);
+        }
+    },
+    info: (message) => console.log(`[Network:${networkName}] ${message}`),
+    warn: (message) => console.warn(`[Network:${networkName}] ${message}`),
+    error: (message) => console.error(`[Network:${networkName}] ${message}`),
+});
 /**
  * Safely removes a network, handling all possible states.
  */
 const safeRemoveNetwork = async (docker, networkId, networkName) => {
+    const log = makeNetworkLogger(networkName);
     try {
         const network = docker.getNetwork(networkId);
         await network.remove();
-        console.log(`[Cleanup] Network removed: ${networkName}`);
+        log.info('Network removed');
     }
     catch (e) {
         if (e.statusCode === 404) {
-            console.log(`[Cleanup] Network ${networkName} already removed`);
+            log.debug('Network already removed');
         }
         else if (e.message?.includes('has active endpoints')) {
-            console.warn(`[Cleanup] Network ${networkName} has active endpoints, skipping removal`);
+            log.warn('Network has active endpoints, skipping removal');
         }
         else {
-            console.error(`[Cleanup] Error removing network ${networkName}:`, e.message);
+            log.error(`Error removing network: ${e.message}`);
         }
     }
 };
@@ -41,21 +52,22 @@ Effect.tryPromise({
             filters: { name: [config.name] },
         });
         const existing = networks.find((n) => n.Name === config.name);
+        const log = makeNetworkLogger(config.name);
         if (existing) {
             // Try to remove existing network for clean state
             try {
                 const net = docker.getNetwork(existing.Id);
                 await net.remove();
-                console.log(`[Network] Removed existing network: ${config.name}`);
+                log.info('Removed existing network');
             }
             catch (e) {
                 if (e.message?.includes('has active endpoints')) {
                     // Network in use - try to reuse it
-                    console.warn(`[Network] ${config.name} in use, reusing existing network`);
+                    log.warn('Network in use, reusing existing network');
                     return { id: existing.Id, name: config.name };
                 }
                 // Other errors - try to proceed with creation anyway
-                console.warn(`[Network] Could not remove ${config.name}: ${e.message}`);
+                log.warn(`Could not remove: ${e.message}`);
             }
         }
         // Create new network
@@ -71,7 +83,7 @@ Effect.tryPromise({
 (resource, exit) => Effect.gen(function* () {
     const isInterrupted = Exit.isInterrupted(exit);
     if (isInterrupted) {
-        console.log(`[Cleanup] Interrupted - cleaning up network: ${resource.name}`);
+        yield* Effect.logDebug('Interrupted - cleaning up network').pipe(Effect.annotateLogs({ service: 'Network', networkId: resource.id }));
     }
     yield* Effect.tryPromise({
         try: () => Promise.race([
@@ -79,7 +91,9 @@ Effect.tryPromise({
             new Promise((_, reject) => setTimeout(() => reject(new Error('Network cleanup timeout')), CLEANUP_TIMEOUT_MS)),
         ]),
         catch: (e) => {
-            console.error(`[Cleanup] Failed to clean up network ${resource.name}:`, e);
+            // Log error but don't fail - cleanup should be best effort
+            const log = makeNetworkLogger(resource.name);
+            log.error(`Failed to clean up network: ${e}`);
             return null;
         },
     });

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>;
 /**
@@ -95,18 +227,40 @@ export declare const logOptionsSchema: z.ZodObject<{
     until: z.ZodOptional<z.ZodNumber>;
     tail: z.ZodOptional<z.ZodNumber>;
     timestamps: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
+    follow: z.ZodOptional<z.ZodBoolean>;
+}, "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>;
 /**
@@ -115,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;;;;;;;iBAO3B,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 ============
@@ -76,6 +76,7 @@ export const logOptionsSchema = z.object({
     until: z.number().optional().describe('Unix timestamp to end at'),
     tail: z.number().int().min(0).optional().describe('Number of lines to tail'),
     timestamps: z.boolean().optional().describe('Include timestamps (default: false)'),
+    follow: z.boolean().optional().describe('Follow log output (default: false)'),
 });
 /**
  * A single log line from a container

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));