moflo 4.8.31 → 4.8.32

package/src/@claude-flow/cli/dist/src/services/container-worker-pool.d.ts

@@ -1,197 +0,0 @@
-/**
- * Container Worker Pool
- * Docker-based worker pool for high-throughput headless execution.
- *
- * ADR-020: Headless Worker Integration Architecture - Phase 3
- * - Manages pool of Docker containers for isolated worker execution
- * - Supports dynamic scaling based on workload
- * - Provides container lifecycle management
- * - Integrates with WorkerQueue for task distribution
- *
- * Key Features:
- * - Container pooling with configurable size
- * - Health checking and auto-recovery
- * - Resource limits (CPU, memory)
- * - Volume mounting for workspace access
- * - Network isolation per worker type
- */
-import { EventEmitter } from 'events';
-import type { HeadlessWorkerType, HeadlessExecutionResult, SandboxMode } from './headless-worker-executor.js';
-/**
- * Container state
- */
-export type ContainerState = 'creating' | 'ready' | 'busy' | 'unhealthy' | 'terminated';
-/**
- * Container info
- */
-export interface ContainerInfo {
-    id: string;
-    name: string;
-    state: ContainerState;
-    createdAt: Date;
-    lastUsedAt?: Date;
-    workerType?: HeadlessWorkerType;
-    executionCount: number;
-    healthCheckFailures: number;
-    pid?: number;
-}
-/**
- * Container pool configuration
- */
-export interface ContainerPoolConfig {
-    /** Maximum number of containers in the pool */
-    maxContainers: number;
-    /** Minimum number of containers to keep warm */
-    minContainers: number;
-    /** Docker image to use */
-    image: string;
-    /** Container resource limits */
-    resources: {
-        cpus: string;
-        memory: string;
-    };
-    /** Health check interval in ms */
-    healthCheckIntervalMs: number;
-    /** Container idle timeout in ms */
-    idleTimeoutMs: number;
-    /** Workspace volume mount path */
-    workspacePath: string;
-    /** State persistence path */
-    statePath: string;
-    /** Network name for container isolation */
-    network?: string;
-    /** Environment variables for containers */
-    env?: Record<string, string>;
-    /** Default sandbox mode */
-    defaultSandbox: SandboxMode;
-}
-/**
- * Container execution options
- */
-export interface ContainerExecutionOptions {
-    workerType: HeadlessWorkerType;
-    prompt: string;
-    contextPatterns?: string[];
-    sandbox?: SandboxMode;
-    model?: string;
-    timeoutMs?: number;
-}
-/**
- * Pool status
- */
-export interface ContainerPoolStatus {
-    totalContainers: number;
-    readyContainers: number;
-    busyContainers: number;
-    unhealthyContainers: number;
-    queuedTasks: number;
-    containers: ContainerInfo[];
-    dockerAvailable: boolean;
-    lastHealthCheck?: Date;
-}
-/**
- * ContainerWorkerPool - Manages Docker containers for headless worker execution
- */
-export declare class ContainerWorkerPool extends EventEmitter {
-    private config;
-    private projectRoot;
-    private containers;
-    private taskQueue;
-    private healthCheckTimer?;
-    private idleCheckTimer?;
-    private dockerAvailable;
-    private initialized;
-    private isShuttingDown;
-    private exitHandlersRegistered;
-    constructor(projectRoot: string, config?: Partial<ContainerPoolConfig>);
-    /**
-     * Initialize the container pool
-     */
-    initialize(): Promise<boolean>;
-    /**
-     * Register process exit handlers to clean up containers
-     */
-    private registerExitHandlers;
-    /**
-     * Execute a worker in a container
-     */
-    execute(options: ContainerExecutionOptions): Promise<HeadlessExecutionResult>;
-    /**
-     * Scale pool for batch execution
-     */
-    scaleForBatch(workerCount: number): Promise<void>;
-    /**
-     * Get pool status
-     */
-    getStatus(): ContainerPoolStatus;
-    /**
-     * Shutdown the pool
-     */
-    shutdown(): Promise<void>;
-    /**
-     * Check if Docker is available (async)
-     */
-    private checkDockerAvailable;
-    /**
-     * Ensure the container image exists (async)
-     */
-    private ensureImage;
-    /**
-     * Create a new container
-     */
-    private createContainer;
-    /**
-     * Terminate a container (async)
-     */
-    private terminateContainer;
-    /**
-     * Get a ready container
-     */
-    private getReadyContainer;
-    /**
-     * Scale to minimum containers
-     */
-    private scaleToMinimum;
-    /**
-     * Execute worker in a specific container
-     */
-    private executeInContainer;
-    /**
-     * Execute command in container
-     */
-    private execInContainer;
-    /**
-     * Build worker command for container execution
-     */
-    private buildWorkerCommand;
-    /**
-     * Process queued tasks
-     */
-    private processQueue;
-    /**
-     * Start health check timer
-     */
-    private startHealthChecks;
-    /**
-     * Run health checks on all containers
-     */
-    private runHealthChecks;
-    /**
-     * Start idle check timer
-     */
-    private startIdleChecks;
-    /**
-     * Terminate idle containers above minimum
-     */
-    private runIdleChecks;
-    /**
-     * Try to parse JSON from output
-     */
-    private tryParseJson;
-    /**
-     * Create an error result
-     */
-    private createErrorResult;
-}
-export default ContainerWorkerPool;
-//# sourceMappingURL=container-worker-pool.d.ts.map

package/src/@claude-flow/cli/dist/src/services/daemon-lock.d.ts

@@ -1,60 +0,0 @@
-/**
- * Atomic daemon lock — prevents duplicate daemon processes.
- *
- * Uses fs.writeFileSync with { flag: 'wx' } (O_CREAT | O_EXCL) which is
- * atomic on all platforms: the write fails immediately if the file exists,
- * eliminating the TOCTOU race in the old PID-file approach.
- *
- * Also solves Windows PID recycling by storing a label in the lock payload
- * and verifying the process command line before trusting a "live" PID.
- */
-export interface DaemonLockPayload {
-    pid: number;
-    startedAt: number;
-    label: string;
-}
-/** Resolve the lock file path for a project root. */
-export declare function lockPath(projectRoot: string): string;
-/**
- * Try to acquire the daemon lock atomically.
- *
- * @returns `{ acquired: true }` on success,
- *          `{ acquired: false, holder: pid }` if another daemon owns the lock.
- */
-export declare function acquireDaemonLock(projectRoot: string, pid?: number): {
-    acquired: true;
-} | {
-    acquired: false;
-    holder: number;
-};
-/**
- * Release the daemon lock. Only removes if we own it (or force = true).
- */
-export declare function releaseDaemonLock(projectRoot: string, pid?: number, force?: boolean): void;
-/**
- * Atomically transfer the daemon lock to a new PID (e.g. parent → child).
- *
- * Overwrites the lock file in-place so there is no window where the lock
- * is absent.  Only succeeds if the lock is currently held by `fromPid`.
- */
-export declare function transferDaemonLock(projectRoot: string, newPid: number, fromPid?: number): boolean;
-/**
- * Check if the daemon lock is currently held by a live daemon.
- * Returns the holder PID or null.
- */
-export declare function getDaemonLockHolder(projectRoot: string): number | null;
-/**
- * Cross-platform check: is this PID actually a moflo/claude-flow daemon?
- *
- * This prevents false positives from Windows PID recycling, where a dead
- * daemon's PID gets reused by an unrelated process (e.g. Chrome).
- *
- * - Windows: uses `tasklist /FI` to check the process image + command line
- * - Linux:   reads /proc/<pid>/cmdline
- * - macOS:   uses `ps -p <pid> -o command=`
- *
- * Falls back to `true` (trust process.kill) if the platform check fails,
- * to avoid accidentally allowing duplicates on exotic platforms.
- */
-export declare function isDaemonProcess(pid: number): boolean;
-//# sourceMappingURL=daemon-lock.d.ts.map

package/src/@claude-flow/cli/dist/src/services/headless-worker-executor.d.ts

@@ -1,304 +0,0 @@
-/**
- * Headless Worker Executor
- * Enables workers to invoke Claude Code in headless mode with configurable sandbox profiles.
- *
- * ADR-020: Headless Worker Integration Architecture
- * - Integrates with CLAUDE_CODE_HEADLESS and CLAUDE_CODE_SANDBOX_MODE environment variables
- * - Provides process pool for concurrent execution
- * - Builds context from file glob patterns
- * - Supports prompt templates and output parsing
- * - Implements timeout and graceful error handling
- *
- * Key Features:
- * - Process pool with configurable maxConcurrent
- * - Context building from file glob patterns with caching
- * - Prompt template system with context injection
- * - Output parsing (text, json, markdown)
- * - Timeout handling with graceful termination
- * - Execution logging for debugging
- * - Event emission for monitoring
- */
-import { EventEmitter } from 'events';
-import type { WorkerType } from './worker-daemon.js';
-/**
- * Headless worker types - workers that use Claude Code AI
- */
-export type HeadlessWorkerType = 'audit' | 'optimize' | 'testgaps' | 'document' | 'ultralearn' | 'refactor' | 'deepdive' | 'predict';
-/**
- * Local worker types - workers that run locally without AI
- */
-export type LocalWorkerType = 'map' | 'consolidate' | 'benchmark' | 'preload';
-/**
- * Sandbox mode for headless execution
- */
-export type SandboxMode = 'strict' | 'permissive' | 'disabled';
-/**
- * Model types for Claude Code
- */
-export type ModelType = 'sonnet' | 'opus' | 'haiku';
-/**
- * Output format for worker results
- */
-export type OutputFormat = 'text' | 'json' | 'markdown';
-/**
- * Execution mode for workers
- */
-export type ExecutionMode = 'local' | 'headless';
-/**
- * Worker priority levels
- */
-export type WorkerPriority = 'low' | 'normal' | 'high' | 'critical';
-/**
- * Base worker configuration (matching worker-daemon.ts)
- */
-export interface WorkerConfig {
-    type: WorkerType;
-    intervalMs: number;
-    priority: WorkerPriority;
-    description: string;
-    enabled: boolean;
-}
-/**
- * Headless-specific options
- */
-export interface HeadlessOptions {
-    /** Prompt template for Claude Code */
-    promptTemplate: string;
-    /** Sandbox profile: strict, permissive, or disabled */
-    sandbox: SandboxMode;
-    /** Model to use: sonnet, opus, or haiku */
-    model?: ModelType;
-    /** Maximum tokens for output */
-    maxOutputTokens?: number;
-    /** Timeout in milliseconds (overrides default) */
-    timeoutMs?: number;
-    /** File glob patterns to include as context */
-    contextPatterns?: string[];
-    /** Output parsing format */
-    outputFormat?: OutputFormat;
-}
-/**
- * Extended worker configuration with headless options
- */
-export interface HeadlessWorkerConfig extends WorkerConfig {
-    /** Execution mode: local or headless */
-    mode: ExecutionMode;
-    /** Headless-specific options (required when mode is 'headless') */
-    headless?: HeadlessOptions;
-}
-/**
- * Executor configuration options
- */
-export interface HeadlessExecutorConfig {
-    /** Maximum concurrent headless processes */
-    maxConcurrent?: number;
-    /** Default timeout in milliseconds */
-    defaultTimeoutMs?: number;
-    /** Maximum files to include in context */
-    maxContextFiles?: number;
-    /** Maximum characters per file in context */
-    maxCharsPerFile?: number;
-    /** Log directory for execution logs */
-    logDir?: string;
-    /** Whether to cache context between runs */
-    cacheContext?: boolean;
-    /** Context cache TTL in milliseconds */
-    cacheTtlMs?: number;
-}
-/**
- * Result from headless execution
- */
-export interface HeadlessExecutionResult {
-    /** Whether execution completed successfully */
-    success: boolean;
-    /** Raw output from Claude Code */
-    output: string;
-    /** Parsed output (if outputFormat is json or markdown) */
-    parsedOutput?: unknown;
-    /** Execution duration in milliseconds */
-    durationMs: number;
-    /** Estimated tokens used (if available) */
-    tokensUsed?: number;
-    /** Model used for execution */
-    model: string;
-    /** Sandbox mode used */
-    sandboxMode: SandboxMode;
-    /** Worker type that was executed */
-    workerType: HeadlessWorkerType;
-    /** Timestamp of execution */
-    timestamp: Date;
-    /** Error message if execution failed */
-    error?: string;
-    /** Execution ID for tracking */
-    executionId: string;
-}
-/**
- * Pool status information
- */
-export interface PoolStatus {
-    activeCount: number;
-    queueLength: number;
-    maxConcurrent: number;
-    activeWorkers: Array<{
-        executionId: string;
-        workerType: HeadlessWorkerType;
-        startTime: Date;
-        elapsedMs: number;
-    }>;
-    queuedWorkers: Array<{
-        workerType: HeadlessWorkerType;
-        queuedAt: Date;
-        waitingMs: number;
-    }>;
-}
-/**
- * Array of headless worker types for runtime checking
- */
-export declare const HEADLESS_WORKER_TYPES: HeadlessWorkerType[];
-/**
- * Array of local worker types
- */
-export declare const LOCAL_WORKER_TYPES: LocalWorkerType[];
-/**
- * Default headless worker configurations based on ADR-020
- */
-export declare const HEADLESS_WORKER_CONFIGS: Record<HeadlessWorkerType, HeadlessWorkerConfig>;
-/**
- * Local worker configurations
- */
-export declare const LOCAL_WORKER_CONFIGS: Record<LocalWorkerType, HeadlessWorkerConfig>;
-/**
- * Combined worker configurations
- */
-export declare const ALL_WORKER_CONFIGS: HeadlessWorkerConfig[];
-/**
- * Check if a worker type is a headless worker
- */
-export declare function isHeadlessWorker(type: WorkerType): type is HeadlessWorkerType;
-/**
- * Check if a worker type is a local worker
- */
-export declare function isLocalWorker(type: WorkerType): type is LocalWorkerType;
-/**
- * Get model ID from model type
- */
-export declare function getModelId(model: ModelType): string;
-/**
- * Get worker configuration by type
- */
-export declare function getWorkerConfig(type: WorkerType): HeadlessWorkerConfig | undefined;
-/**
- * HeadlessWorkerExecutor - Executes workers using Claude Code in headless mode
- *
- * Features:
- * - Process pool with configurable concurrency limit
- * - Pending queue for overflow requests
- * - Context caching with configurable TTL
- * - Execution logging for debugging
- * - Event emission for monitoring
- * - Graceful termination
- */
-export declare class HeadlessWorkerExecutor extends EventEmitter {
-    private projectRoot;
-    private config;
-    private processPool;
-    private pendingQueue;
-    private contextCache;
-    private claudeCodeAvailable;
-    private claudeCodeVersion;
-    constructor(projectRoot: string, options?: HeadlessExecutorConfig);
-    /**
-     * Check if Claude Code CLI is available
-     */
-    isAvailable(): Promise<boolean>;
-    /**
-     * Get Claude Code version
-     */
-    getVersion(): Promise<string | null>;
-    /**
-     * Execute a headless worker
-     */
-    execute(workerType: HeadlessWorkerType, configOverrides?: Partial<HeadlessOptions>): Promise<HeadlessExecutionResult>;
-    /**
-     * Get pool status
-     */
-    getPoolStatus(): PoolStatus;
-    /**
-     * Get number of active executions
-     */
-    getActiveCount(): number;
-    /**
-     * Cancel a running execution
-     */
-    cancel(executionId: string): boolean;
-    /**
-     * Cancel all running executions
-     */
-    cancelAll(): number;
-    /**
-     * Clear context cache
-     */
-    clearContextCache(): void;
-    /**
-     * Get worker configuration
-     */
-    getConfig(workerType: HeadlessWorkerType): HeadlessWorkerConfig | undefined;
-    /**
-     * Get all headless worker types
-     */
-    getHeadlessWorkerTypes(): HeadlessWorkerType[];
-    /**
-     * Get all local worker types
-     */
-    getLocalWorkerTypes(): LocalWorkerType[];
-    /**
-     * Ensure log directory exists
-     */
-    private ensureLogDir;
-    /**
-     * Internal execution logic
-     */
-    private executeInternal;
-    /**
-     * Process the pending queue
-     */
-    private processQueue;
-    /**
-     * Build context from file patterns
-     */
-    private buildContext;
-    /**
-     * Simple glob implementation for file matching
-     */
-    private simpleGlob;
-    /**
-     * Match filename against a simple pattern
-     */
-    private matchesPattern;
-    /**
-     * Build full prompt with context
-     */
-    private buildPrompt;
-    /**
-     * Execute Claude Code in headless mode
-     */
-    private executeClaudeCode;
-    /**
-     * Parse JSON output from Claude Code
-     */
-    private parseJsonOutput;
-    /**
-     * Parse markdown output into sections
-     */
-    private parseMarkdownOutput;
-    /**
-     * Create an error result
-     */
-    private createErrorResult;
-    /**
-     * Log execution details for debugging
-     */
-    private logExecution;
-}
-export default HeadlessWorkerExecutor;
-//# sourceMappingURL=headless-worker-executor.d.ts.map

package/src/@claude-flow/cli/dist/src/services/index.d.ts

@@ -1,13 +0,0 @@
-/**
- * V3 CLI Services Index
- * Central registry for all background services
- */
-export { WorkerDaemon, getDaemon, startDaemon, stopDaemon, type WorkerType, } from './worker-daemon.js';
-export { HeadlessWorkerExecutor, HEADLESS_WORKER_TYPES, HEADLESS_WORKER_CONFIGS, LOCAL_WORKER_TYPES, LOCAL_WORKER_CONFIGS, ALL_WORKER_CONFIGS, isHeadlessWorker, isLocalWorker, getModelId, getWorkerConfig, type HeadlessWorkerType, type LocalWorkerType, type HeadlessWorkerConfig, type HeadlessExecutionResult, type HeadlessExecutorConfig, type HeadlessOptions, type PoolStatus, type SandboxMode, type ModelType, type OutputFormat, type ExecutionMode, type WorkerPriority, type WorkerConfig, } from './headless-worker-executor.js';
-export { WorkerQueue, type QueueTask, type WorkerQueueConfig, type QueueStats, type WorkerRegistration, type TaskStatus, } from './worker-queue.js';
-export { LearningService, getLearningService, HNSWIndex, hashEmbed, cosineSimilarity, LEARNING_CONFIG, type PatternSearchResult, type StoreResult, type ConsolidateResult, type LearningStats, type PatternRow, } from './learning-service.js';
-export { AgentRouter, getAgentRouter, routeTask, AGENT_CAPABILITIES, type RouteResult, type AgentType, } from './agent-router.js';
-export type { default as WorkerDaemonType, DaemonConfig } from './worker-daemon.js';
-export type { default as HeadlessWorkerExecutorType } from './headless-worker-executor.js';
-export type { default as WorkerQueueType } from './worker-queue.js';
-//# sourceMappingURL=index.d.ts.map