@docker-harpoon/core 0.1.3 → 0.1.5

package/dist/services/HarpoonConfig.d.ts

@@ -0,0 +1,60 @@
+/**
+ * HarpoonConfig Service
+ *
+ * Provides typed configuration for all Harpoon services using Effect's Config module.
+ * Configuration is loaded from environment variables with sensible defaults.
+ */
+import { Context, Layer, Duration } from 'effect';
+/**
+ * Configuration interface for Harpoon services.
+ */
+export interface HarpoonConfigService {
+    readonly _tag: 'HarpoonConfig';
+    /** Docker socket path (auto-detected if not specified) */
+    readonly dockerSocket: string | undefined;
+    /** Default timeout for operations */
+    readonly defaultTimeout: Duration.Duration;
+    /** Timeout for cleanup operations */
+    readonly cleanupTimeout: Duration.Duration;
+    /** Log level for Harpoon operations */
+    readonly logLevel: 'debug' | 'info' | 'warn' | 'error';
+    /** Maximum parallel operations (for Effect.all concurrency) */
+    readonly parallelLimit: number;
+    /** Number of retry attempts for failed operations */
+    readonly retryAttempts: number;
+    /** Delay between retry attempts */
+    readonly retryDelay: Duration.Duration;
+    /** Docker startup timeout (for auto-start on macOS/Windows) */
+    readonly dockerStartupTimeout: Duration.Duration;
+}
+declare const HarpoonConfig_base: Context.TagClass<HarpoonConfig, "@harpoon/HarpoonConfig", HarpoonConfigService>;
+/**
+ * HarpoonConfig service tag for dependency injection.
+ */
+export declare class HarpoonConfig extends HarpoonConfig_base {
+}
+/**
+ * Live implementation that loads configuration from environment variables.
+ *
+ * Environment variables:
+ * - DOCKER_SOCKET: Docker socket path
+ * - HARPOON_TIMEOUT: Default timeout in milliseconds (default: 30000)
+ * - HARPOON_CLEANUP_TIMEOUT: Cleanup timeout in milliseconds (default: 5000)
+ * - HARPOON_LOG_LEVEL: Log level (default: 'info')
+ * - HARPOON_PARALLEL_LIMIT: Max parallel operations (default: 4)
+ * - HARPOON_RETRY_ATTEMPTS: Retry attempts (default: 3)
+ * - HARPOON_RETRY_DELAY: Retry delay in milliseconds (default: 1000)
+ * - HARPOON_DOCKER_STARTUP_TIMEOUT: Docker startup timeout in milliseconds (default: 60000)
+ */
+export declare const HarpoonConfigLive: Layer.Layer<HarpoonConfig, import("effect/ConfigError").ConfigError, never>;
+/**
+ * Create a test configuration layer with custom overrides.
+ * Uses fast timeouts suitable for testing.
+ */
+export declare const makeHarpoonConfigTest: (overrides?: Partial<Omit<HarpoonConfigService, "_tag">>) => Layer.Layer<HarpoonConfig, never, never>;
+/**
+ * Default test configuration layer.
+ */
+export declare const HarpoonConfigTest: Layer.Layer<HarpoonConfig, never, never>;
+export {};
+//# sourceMappingURL=HarpoonConfig.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"HarpoonConfig.d.ts","sourceRoot":"","sources":["../../src/services/HarpoonConfig.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAkB,KAAK,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAElE;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAE/B,0DAA0D;IAC1D,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IAE1C,qCAAqC;IACrC,QAAQ,CAAC,cAAc,EAAE,QAAQ,CAAC,QAAQ,CAAC;IAE3C,qCAAqC;IACrC,QAAQ,CAAC,cAAc,EAAE,QAAQ,CAAC,QAAQ,CAAC;IAE3C,uCAAuC;IACvC,QAAQ,CAAC,QAAQ,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;IAEvD,+DAA+D;IAC/D,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAE/B,qDAAqD;IACrD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAE/B,mCAAmC;IACnC,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,QAAQ,CAAC;IAEvC,+DAA+D;IAC/D,QAAQ,CAAC,oBAAoB,EAAE,QAAQ,CAAC,QAAQ,CAAC;CAClD;;AAED;;GAEG;AACH,qBAAa,aAAc,SAAQ,kBAGhC;CAAG;AAEN;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,iBAAiB,6EA6C7B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,qBAAqB,uGAc9B,CAAC;AAEL;;GAEG;AACH,eAAO,MAAM,iBAAiB,0CAA0B,CAAC"}

package/dist/services/HarpoonConfig.js

@@ -0,0 +1,67 @@
+/**
+ * HarpoonConfig Service
+ *
+ * Provides typed configuration for all Harpoon services using Effect's Config module.
+ * Configuration is loaded from environment variables with sensible defaults.
+ */
+import { Context, Config, Effect, Layer, Duration } from 'effect';
+/**
+ * HarpoonConfig service tag for dependency injection.
+ */
+export class HarpoonConfig extends Context.Tag('@harpoon/HarpoonConfig')() {
+}
+/**
+ * Live implementation that loads configuration from environment variables.
+ *
+ * Environment variables:
+ * - DOCKER_SOCKET: Docker socket path
+ * - HARPOON_TIMEOUT: Default timeout in milliseconds (default: 30000)
+ * - HARPOON_CLEANUP_TIMEOUT: Cleanup timeout in milliseconds (default: 5000)
+ * - HARPOON_LOG_LEVEL: Log level (default: 'info')
+ * - HARPOON_PARALLEL_LIMIT: Max parallel operations (default: 4)
+ * - HARPOON_RETRY_ATTEMPTS: Retry attempts (default: 3)
+ * - HARPOON_RETRY_DELAY: Retry delay in milliseconds (default: 1000)
+ * - HARPOON_DOCKER_STARTUP_TIMEOUT: Docker startup timeout in milliseconds (default: 60000)
+ */
+export const HarpoonConfigLive = Layer.effect(HarpoonConfig, Effect.gen(function* () {
+    // Load all configuration with defaults
+    const dockerSocket = yield* Config.string('DOCKER_SOCKET').pipe(Config.option);
+    const defaultTimeout = yield* Config.integer('HARPOON_TIMEOUT').pipe(Config.withDefault(30000));
+    const cleanupTimeout = yield* Config.integer('HARPOON_CLEANUP_TIMEOUT').pipe(Config.withDefault(5000));
+    const logLevel = yield* Config.literal('debug', 'info', 'warn', 'error')('HARPOON_LOG_LEVEL').pipe(Config.withDefault('info'));
+    const parallelLimit = yield* Config.integer('HARPOON_PARALLEL_LIMIT').pipe(Config.withDefault(4));
+    const retryAttempts = yield* Config.integer('HARPOON_RETRY_ATTEMPTS').pipe(Config.withDefault(3));
+    const retryDelay = yield* Config.integer('HARPOON_RETRY_DELAY').pipe(Config.withDefault(1000));
+    const dockerStartupTimeout = yield* Config.integer('HARPOON_DOCKER_STARTUP_TIMEOUT').pipe(Config.withDefault(60000));
+    return {
+        _tag: 'HarpoonConfig',
+        dockerSocket: dockerSocket._tag === 'Some' ? dockerSocket.value : undefined,
+        defaultTimeout: Duration.millis(defaultTimeout),
+        cleanupTimeout: Duration.millis(cleanupTimeout),
+        logLevel,
+        parallelLimit,
+        retryAttempts,
+        retryDelay: Duration.millis(retryDelay),
+        dockerStartupTimeout: Duration.millis(dockerStartupTimeout),
+    };
+}));
+/**
+ * Create a test configuration layer with custom overrides.
+ * Uses fast timeouts suitable for testing.
+ */
+export const makeHarpoonConfigTest = (overrides = {}) => Layer.succeed(HarpoonConfig, {
+    _tag: 'HarpoonConfig',
+    dockerSocket: undefined,
+    defaultTimeout: Duration.millis(5000),
+    cleanupTimeout: Duration.millis(1000),
+    logLevel: 'debug',
+    parallelLimit: 2,
+    retryAttempts: 1,
+    retryDelay: Duration.millis(100),
+    dockerStartupTimeout: Duration.millis(5000),
+    ...overrides,
+});
+/**
+ * Default test configuration layer.
+ */
+export const HarpoonConfigTest = makeHarpoonConfigTest();

package/dist/services/HarpoonLogger.d.ts

@@ -0,0 +1,36 @@
+/**
+ * HarpoonLogger Service
+ *
+ * Provides structured logging for all Harpoon operations using Effect's Logger.
+ * Logs include timestamps, log levels, and structured annotations.
+ */
+import { Effect, Layer } from 'effect';
+/**
+ * Live logger layer with pretty-printed format.
+ */
+export declare const HarpoonLoggerLive: Layer.Layer<never, never, never>;
+/**
+ * JSON logger layer for structured logging.
+ */
+export declare const HarpoonLoggerJson: Layer.Layer<never, never, never>;
+/**
+ * Test logger layer that suppresses all output.
+ */
+export declare const HarpoonLoggerTest: Layer.Layer<never, never, never>;
+/**
+ * Minimum log level layer - only show warnings and above.
+ */
+export declare const HarpoonLoggerMinWarn: Layer.Layer<never, never, never>;
+/**
+ * Debug log level layer - show all logs including debug.
+ */
+export declare const HarpoonLoggerDebug: Layer.Layer<never, never, never>;
+/**
+ * Helper to create a span for tracing operations.
+ */
+export declare const withSpan: <A, E, R>(name: string, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+/**
+ * Helper to add annotations to logs within a scope.
+ */
+export declare const withLogAnnotations: <A, E, R>(annotations: Record<string, unknown>, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+//# sourceMappingURL=HarpoonLogger.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"HarpoonLogger.d.ts","sourceRoot":"","sources":["../../src/services/HarpoonLogger.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAoB,MAAM,EAAE,KAAK,EAAQ,MAAM,QAAQ,CAAC;AAqE/D;;GAEG;AACH,eAAO,MAAM,iBAAiB,kCAAyD,CAAC;AAExF;;GAEG;AACH,eAAO,MAAM,iBAAiB,kCAA6D,CAAC;AAE5F;;GAEG;AACH,eAAO,MAAM,iBAAiB,kCAAoD,CAAC;AAEnF;;GAEG;AACH,eAAO,MAAM,oBAAoB,kCAGhC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB,kCAG9B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,yEAG0B,CAAC;AAE3D;;GAEG;AACH,eAAO,MAAM,kBAAkB,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,iGAG2B,CAAC"}

package/dist/services/HarpoonLogger.js

@@ -0,0 +1,94 @@
+/**
+ * HarpoonLogger Service
+ *
+ * Provides structured logging for all Harpoon operations using Effect's Logger.
+ * Logs include timestamps, log levels, and structured annotations.
+ */
+import { Logger, LogLevel, Effect, Layer, List } from 'effect';
+/**
+ * Custom log format for Harpoon.
+ *
+ * Format: [ISO_TIMESTAMP] LEVEL [Harpoon] message | key=value key=value
+ *
+ * Example:
+ * [2024-01-15T10:30:00.000Z] INFO  [Harpoon] Container created | containerId="abc123" name="my-app"
+ */
+const harpoonLogFormat = Logger.make(({ logLevel, message, annotations, date, spans, cause }) => {
+    const timestamp = date.toISOString();
+    const level = logLevel.label.toUpperCase().padEnd(5);
+    // Format annotations as key=value pairs
+    const annotationEntries = Object.entries(annotations);
+    const annotationStr = annotationEntries.length > 0
+        ? ' | ' + annotationEntries.map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(' ')
+        : '';
+    // Format spans if present (spans is a List<LogSpan>)
+    const spansArray = List.toArray(spans);
+    const spanStr = spansArray.length > 0 ? ` [${spansArray.map((s) => s.label).join(' > ')}]` : '';
+    // Build the log message
+    const formatted = `[${timestamp}] ${level} [Harpoon]${spanStr} ${message}${annotationStr}`;
+    // Route to appropriate console method based on level
+    if (logLevel._tag === 'Error' || logLevel._tag === 'Fatal') {
+        console.error(formatted);
+        if (cause) {
+            console.error('Cause:', cause);
+        }
+    }
+    else if (logLevel._tag === 'Warning') {
+        console.warn(formatted);
+    }
+    else if (logLevel._tag === 'Debug' || logLevel._tag === 'Trace') {
+        console.debug(formatted);
+    }
+    else {
+        console.log(formatted);
+    }
+});
+/**
+ * JSON log format for structured logging (useful for log aggregation systems).
+ */
+const harpoonJsonLogFormat = Logger.make(({ logLevel, message, annotations, date, spans, cause }) => {
+    const spansArray = List.toArray(spans);
+    const logEntry = {
+        timestamp: date.toISOString(),
+        level: logLevel.label,
+        service: 'harpoon',
+        message: String(message),
+        ...(Object.keys(annotations).length > 0 && { annotations }),
+        ...(spansArray.length > 0 && { spans: spansArray.map((s) => s.label) }),
+        ...(cause && { cause: String(cause) }),
+    };
+    if (logLevel._tag === 'Error' || logLevel._tag === 'Fatal') {
+        console.error(JSON.stringify(logEntry));
+    }
+    else {
+        console.log(JSON.stringify(logEntry));
+    }
+});
+/**
+ * Live logger layer with pretty-printed format.
+ */
+export const HarpoonLoggerLive = Logger.replace(Logger.defaultLogger, harpoonLogFormat);
+/**
+ * JSON logger layer for structured logging.
+ */
+export const HarpoonLoggerJson = Logger.replace(Logger.defaultLogger, harpoonJsonLogFormat);
+/**
+ * Test logger layer that suppresses all output.
+ */
+export const HarpoonLoggerTest = Logger.replace(Logger.defaultLogger, Logger.none);
+/**
+ * Minimum log level layer - only show warnings and above.
+ */
+export const HarpoonLoggerMinWarn = Layer.merge(HarpoonLoggerLive, Logger.minimumLogLevel(LogLevel.Warning));
+/**
+ * Debug log level layer - show all logs including debug.
+ */
+export const HarpoonLoggerDebug = Layer.merge(HarpoonLoggerLive, Logger.minimumLogLevel(LogLevel.Debug));
+/**
+ * Helper to create a span for tracing operations.
+ */
+export const withSpan = (name, effect) => Effect.withSpan(name)(effect);
+/**
+ * Helper to add annotations to logs within a scope.
+ */
+export const withLogAnnotations = (annotations, effect) => Effect.annotateLogs(annotations)(effect);

package/dist/services/ReadinessCoordinator.d.ts

@@ -0,0 +1,128 @@
+/**
+ * ReadinessCoordinator Service
+ *
+ * Coordinates container readiness checks with support for multiple health check types.
+ * Uses Effect's Deferred for efficient waiting and Ref for state management.
+ */
+import { Context, Effect, Layer, Duration } from 'effect';
+/**
+ * Log-based health check - waits for a pattern in container logs.
+ */
+export interface LogHealthCheck {
+    readonly type: 'log';
+    /** Regex pattern or string to match in logs */
+    readonly pattern: string | RegExp;
+}
+/**
+ * HTTP health check - polls an HTTP endpoint.
+ */
+export interface HttpHealthCheck {
+    readonly type: 'http';
+    /** URL to check (e.g., 'http://localhost:3000/health') */
+    readonly url: string;
+    /** Expected status code (default: 200) */
+    readonly expectedStatus?: number;
+    /** HTTP method (default: GET) */
+    readonly method?: 'GET' | 'HEAD';
+}
+/**
+ * TCP health check - checks if a port is accepting connections.
+ */
+export interface TcpHealthCheck {
+    readonly type: 'tcp';
+    /** Host to connect to */
+    readonly host: string;
+    /** Port to check */
+    readonly port: number;
+}
+/**
+ * Exec health check - runs a command inside the container.
+ */
+export interface ExecHealthCheck {
+    readonly type: 'exec';
+    /** Command to execute */
+    readonly cmd: string[];
+    /** Expected exit code (default: 0) */
+    readonly expectedExitCode?: number;
+}
+/**
+ * Custom health check - user-provided check function.
+ */
+export interface CustomHealthCheck {
+    readonly type: 'custom';
+    /** Custom check function that returns true when ready */
+    readonly check: () => Effect.Effect<boolean, Error>;
+}
+/**
+ * Union type of all health check types.
+ */
+export type HealthCheck = LogHealthCheck | HttpHealthCheck | TcpHealthCheck | ExecHealthCheck | CustomHealthCheck;
+/**
+ * Options for waiting for container readiness.
+ */
+export interface WaitOptions {
+    /** Maximum time to wait (default: 60 seconds) */
+    readonly timeout?: Duration.Duration;
+    /** Interval between checks (default: 1 second) */
+    readonly interval?: Duration.Duration;
+}
+/**
+ * Error thrown when container readiness check fails.
+ */
+export declare class ReadinessError extends Error {
+    readonly _tag = "ReadinessError";
+    readonly containerId: string;
+    readonly healthCheckType: string;
+    constructor(containerId: string, healthCheckType: string, message: string, cause?: Error);
+}
+/**
+ * ReadinessCoordinator service interface.
+ */
+export interface ReadinessCoordinatorService {
+    readonly _tag: 'ReadinessCoordinator';
+    /**
+     * Wait for a container to become ready.
+     * Uses the specified health check to determine readiness.
+     */
+    readonly waitForReady: (containerId: string, healthCheck: HealthCheck, checkFn: () => Effect.Effect<boolean, Error>, options?: WaitOptions) => Effect.Effect<void, ReadinessError>;
+    /**
+     * Check if a container is currently marked as ready.
+     */
+    readonly isReady: (containerId: string) => Effect.Effect<boolean>;
+    /**
+     * Mark a container as ready (for external updates).
+     */
+    readonly markReady: (containerId: string) => Effect.Effect<void>;
+    /**
+     * Mark a container as not ready.
+     */
+    readonly markNotReady: (containerId: string) => Effect.Effect<void>;
+    /**
+     * Remove tracking for a container.
+     */
+    readonly untrack: (containerId: string) => Effect.Effect<void>;
+    /**
+     * Get all tracked containers and their readiness status.
+     */
+    readonly getAll: () => Effect.Effect<ReadonlyArray<{
+        containerId: string;
+        ready: boolean;
+        timestamp: Date;
+    }>>;
+}
+declare const ReadinessCoordinator_base: Context.TagClass<ReadinessCoordinator, "@harpoon/ReadinessCoordinator", ReadinessCoordinatorService>;
+/**
+ * ReadinessCoordinator service tag for dependency injection.
+ */
+export declare class ReadinessCoordinator extends ReadinessCoordinator_base {
+}
+/**
+ * Live implementation using Effect Ref and Deferred.
+ */
+export declare const ReadinessCoordinatorLive: Layer.Layer<ReadinessCoordinator, never, never>;
+/**
+ * Test implementation that can be pre-configured with ready containers.
+ */
+export declare const ReadinessCoordinatorTest: Layer.Layer<ReadinessCoordinator, never, never>;
+export {};
+//# sourceMappingURL=ReadinessCoordinator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ReadinessCoordinator.d.ts","sourceRoot":"","sources":["../../src/services/ReadinessCoordinator.ts"],"names":[],"mappings":"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"}

package/dist/services/ReadinessCoordinator.js

@@ -0,0 +1,170 @@
+/**
+ * ReadinessCoordinator Service
+ *
+ * Coordinates container readiness checks with support for multiple health check types.
+ * Uses Effect's Deferred for efficient waiting and Ref for state management.
+ */
+import { Context, Effect, Layer, Ref, Duration, Schedule } from 'effect';
+/**
+ * Error thrown when container readiness check fails.
+ */
+export class ReadinessError extends Error {
+    _tag = 'ReadinessError';
+    containerId;
+    healthCheckType;
+    constructor(containerId, healthCheckType, message, cause) {
+        super(message);
+        this.containerId = containerId;
+        this.healthCheckType = healthCheckType;
+        this.cause = cause;
+        this.name = 'ReadinessError';
+    }
+}
+/**
+ * ReadinessCoordinator service tag for dependency injection.
+ */
+export class ReadinessCoordinator extends Context.Tag('@harpoon/ReadinessCoordinator')() {
+}
+/**
+ * Default wait options.
+ */
+const defaultWaitOptions = {
+    timeout: Duration.seconds(60),
+    interval: Duration.seconds(1),
+};
+/**
+ * Live implementation using Effect Ref and Deferred.
+ */
+export const ReadinessCoordinatorLive = Layer.scoped(ReadinessCoordinator, Effect.gen(function* () {
+    // State: Map of containerId -> readiness state
+    const stateRef = yield* Ref.make(new Map());
+    // Pending waiters: Map of containerId -> Deferred for coordination
+    const waitersRef = yield* Ref.make(new Map());
+    yield* Effect.logDebug('ReadinessCoordinator initialized');
+    const service = {
+        _tag: 'ReadinessCoordinator',
+        waitForReady: (containerId, healthCheck, checkFn, options) => Effect.gen(function* () {
+            const opts = { ...defaultWaitOptions, ...options };
+            yield* Effect.logDebug('Waiting for container readiness').pipe(Effect.annotateLogs({
+                containerId,
+                healthCheckType: healthCheck.type,
+                timeoutMs: Duration.toMillis(opts.timeout),
+            }));
+            // Check if already ready
+            const currentState = yield* Ref.get(stateRef);
+            const existing = currentState.get(containerId);
+            if (existing?.ready) {
+                yield* Effect.logDebug('Container already ready').pipe(Effect.annotateLogs({ containerId }));
+                return;
+            }
+            // Create a schedule that runs at the specified interval up to the timeout
+            const schedule = Schedule.spaced(opts.interval).pipe(Schedule.upTo(opts.timeout));
+            // Perform the health check with retry
+            const check = Effect.gen(function* () {
+                const result = yield* checkFn().pipe(Effect.catchAll((e) => Effect.succeed(false).pipe(Effect.tap(() => Effect.logDebug('Health check error').pipe(Effect.annotateLogs({ error: String(e) }))))));
+                if (!result) {
+                    return yield* Effect.fail(new ReadinessError(containerId, healthCheck.type, 'Health check not yet passing'));
+                }
+                return result;
+            });
+            yield* check.pipe(Effect.retry({
+                schedule,
+            }), Effect.catchAll(() => Effect.fail(new ReadinessError(containerId, healthCheck.type, `Container ${containerId} did not become ready within ${Duration.toMillis(opts.timeout)}ms`))));
+            // Mark as ready
+            yield* Ref.update(stateRef, (map) => {
+                const newMap = new Map(map);
+                newMap.set(containerId, {
+                    ready: true,
+                    timestamp: new Date(),
+                    healthCheckType: healthCheck.type,
+                });
+                return newMap;
+            });
+            yield* Effect.logInfo('Container is ready').pipe(Effect.annotateLogs({ containerId, healthCheckType: healthCheck.type }));
+        }),
+        isReady: (containerId) => Ref.get(stateRef).pipe(Effect.map((map) => map.get(containerId)?.ready ?? false)),
+        markReady: (containerId) => Ref.update(stateRef, (map) => {
+            const newMap = new Map(map);
+            newMap.set(containerId, {
+                ready: true,
+                timestamp: new Date(),
+                healthCheckType: 'manual',
+            });
+            return newMap;
+        }).pipe(Effect.tap(() => Effect.logDebug('Container marked as ready').pipe(Effect.annotateLogs({ containerId })))),
+        markNotReady: (containerId) => Ref.update(stateRef, (map) => {
+            const newMap = new Map(map);
+            const existing = map.get(containerId);
+            if (existing) {
+                newMap.set(containerId, { ...existing, ready: false });
+            }
+            return newMap;
+        }).pipe(Effect.tap(() => Effect.logDebug('Container marked as not ready').pipe(Effect.annotateLogs({ containerId })))),
+        untrack: (containerId) => Effect.all([
+            Ref.update(stateRef, (map) => {
+                const newMap = new Map(map);
+                newMap.delete(containerId);
+                return newMap;
+            }),
+            Ref.update(waitersRef, (map) => {
+                const newMap = new Map(map);
+                newMap.delete(containerId);
+                return newMap;
+            }),
+        ]).pipe(Effect.asVoid),
+        getAll: () => Ref.get(stateRef).pipe(Effect.map((map) => [...map.entries()].map(([containerId, state]) => ({
+            containerId,
+            ready: state.ready,
+            timestamp: state.timestamp,
+        })))),
+    };
+    return service;
+}));
+/**
+ * Test implementation that can be pre-configured with ready containers.
+ */
+export const ReadinessCoordinatorTest = Layer.scoped(ReadinessCoordinator, Effect.gen(function* () {
+    const stateRef = yield* Ref.make(new Map());
+    return {
+        _tag: 'ReadinessCoordinator',
+        waitForReady: (containerId, healthCheck, checkFn, _options) => checkFn().pipe(Effect.catchAll((e) => Effect.fail(new ReadinessError(containerId, healthCheck.type, String(e), e))), Effect.flatMap((ready) => ready
+            ? Ref.update(stateRef, (map) => {
+                const newMap = new Map(map);
+                newMap.set(containerId, {
+                    ready: true,
+                    timestamp: new Date(),
+                    healthCheckType: healthCheck.type,
+                });
+                return newMap;
+            })
+            : Effect.fail(new ReadinessError(containerId, healthCheck.type, 'Not ready in test')))),
+        isReady: (containerId) => Ref.get(stateRef).pipe(Effect.map((map) => map.get(containerId)?.ready ?? false)),
+        markReady: (containerId) => Ref.update(stateRef, (map) => {
+            const newMap = new Map(map);
+            newMap.set(containerId, {
+                ready: true,
+                timestamp: new Date(),
+                healthCheckType: 'manual',
+            });
+            return newMap;
+        }),
+        markNotReady: (containerId) => Ref.update(stateRef, (map) => {
+            const newMap = new Map(map);
+            const existing = map.get(containerId);
+            if (existing) {
+                newMap.set(containerId, { ...existing, ready: false });
+            }
+            return newMap;
+        }),
+        untrack: (containerId) => Ref.update(stateRef, (map) => {
+            const newMap = new Map(map);
+            newMap.delete(containerId);
+            return newMap;
+        }),
+        getAll: () => Ref.get(stateRef).pipe(Effect.map((map) => [...map.entries()].map(([containerId, state]) => ({
+            containerId,
+            ready: state.ready,
+            timestamp: state.timestamp,
+        })))),
+    };
+}));

package/dist/services/ResourceTracker.d.ts

@@ -0,0 +1,74 @@
+/**
+ * ResourceTracker Service
+ *
+ * Tracks all created resources (containers, networks, etc.) for lifecycle management.
+ * Uses Effect's Ref for thread-safe state management.
+ */
+import { Context, Effect, Layer, Option } from 'effect';
+import { HarpoonConfig } from './HarpoonConfig';
+/**
+ * Types of resources that can be tracked.
+ */
+export type ResourceType = 'container' | 'network' | 'database' | 'image';
+/**
+ * A tracked resource with cleanup function.
+ */
+export interface TrackedResource {
+    /** Unique identifier for this resource */
+    readonly id: string;
+    /** Type of resource */
+    readonly type: ResourceType;
+    /** Human-readable name */
+    readonly name: string;
+    /** When the resource was created */
+    readonly createdAt: Date;
+    /** Cleanup function to destroy the resource */
+    readonly cleanup: () => Effect.Effect<void, Error>;
+    /** Priority for cleanup ordering (higher = cleanup first) */
+    readonly priority: number;
+}
+/**
+ * ResourceTracker service interface.
+ */
+export interface ResourceTrackerService {
+    readonly _tag: 'ResourceTracker';
+    /** Register a new resource for tracking */
+    readonly register: (resource: TrackedResource) => Effect.Effect<void>;
+    /** Unregister a resource by ID */
+    readonly unregister: (id: string) => Effect.Effect<void>;
+    /** Get a tracked resource by ID */
+    readonly get: (id: string) => Effect.Effect<Option.Option<TrackedResource>>;
+    /** Get all tracked resources */
+    readonly getAll: () => Effect.Effect<readonly TrackedResource[]>;
+    /** Get resources by type */
+    readonly getByType: (type: ResourceType) => Effect.Effect<readonly TrackedResource[]>;
+    /** Get the count of tracked resources */
+    readonly count: () => Effect.Effect<number>;
+    /** Destroy all tracked resources in priority order */
+    readonly destroyAll: (options?: {
+        concurrency?: number;
+    }) => Effect.Effect<void, Error>;
+    /** Destroy resources by type */
+    readonly destroyByType: (type: ResourceType, options?: {
+        concurrency?: number;
+    }) => Effect.Effect<void, Error>;
+    /** Clear all tracking without cleanup (use with caution) */
+    readonly clear: () => Effect.Effect<void>;
+}
+declare const ResourceTracker_base: Context.TagClass<ResourceTracker, "@harpoon/ResourceTracker", ResourceTrackerService>;
+/**
+ * ResourceTracker service tag for dependency injection.
+ */
+export declare class ResourceTracker extends ResourceTracker_base {
+}
+/**
+ * Live implementation using Effect Ref for state management.
+ * Enhanced with retry schedules and per-resource timeouts.
+ */
+export declare const ResourceTrackerLive: Layer.Layer<ResourceTracker, never, HarpoonConfig>;
+/**
+ * Test implementation that tracks resources in memory but doesn't actually clean up.
+ */
+export declare const ResourceTrackerTest: Layer.Layer<ResourceTracker, never, never>;
+export {};
+//# sourceMappingURL=ResourceTracker.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ResourceTracker.d.ts","sourceRoot":"","sources":["../../src/services/ResourceTracker.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAO,MAAM,EAAY,MAAM,QAAQ,CAAC;AACvE,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,WAAW,GAAG,SAAS,GAAG,UAAU,GAAG,OAAO,CAAC;AAE1E;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,0CAA0C;IAC1C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAEpB,uBAAuB;IACvB,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAE5B,0BAA0B;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,oCAAoC;IACpC,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC;IAEzB,+CAA+C;IAC/C,QAAQ,CAAC,OAAO,EAAE,MAAM,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IAEnD,6DAA6D;IAC7D,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;IAEjC,2CAA2C;IAC3C,QAAQ,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,eAAe,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAEtE,kCAAkC;IAClC,QAAQ,CAAC,UAAU,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAEzD,mCAAmC;IACnC,QAAQ,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC,CAAC;IAE5E,gCAAgC;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,MAAM,CAAC,MAAM,CAAC,SAAS,eAAe,EAAE,CAAC,CAAC;IAEjE,4BAA4B;IAC5B,QAAQ,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,MAAM,CAAC,MAAM,CAAC,SAAS,eAAe,EAAE,CAAC,CAAC;IAEtF,yCAAyC;IACzC,QAAQ,CAAC,KAAK,EAAE,MAAM,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAE5C,sDAAsD;IACtD,QAAQ,CAAC,UAAU,EAAE,CAAC,OAAO,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IAExF,gCAAgC;IAChC,QAAQ,CAAC,aAAa,EAAE,CACtB,IAAI,EAAE,YAAY,EAClB,OAAO,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,KAC/B,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IAEhC,4DAA4D;IAC5D,QAAQ,CAAC,KAAK,EAAE,MAAM,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;CAC3C;;AAED;;GAEG;AACH,qBAAa,eAAgB,SAAQ,oBAGlC;CAAG;AAqCN;;;GAGG;AACH,eAAO,MAAM,mBAAmB,oDAoI/B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB,4CAkD/B,CAAC"}