@claude-flow/cli 3.32.2 → 3.32.3

package/dist/src/services/config-file-manager.d.ts

@@ -1,37 +0,0 @@
-/**
- * Config File Manager
- * Shared JSON config file persistence with atomic writes and Zod validation
- */
-export declare class ConfigFileManager {
-    private configPath;
-    private config;
-    /** Find config file in search paths starting from cwd */
-    findConfig(cwd: string): string | null;
-    /** Load config from file, returns null if not found */
-    load(cwd: string): Record<string, unknown> | null;
-    /** Get the current config, loading if needed */
-    getConfig(cwd: string): Record<string, unknown>;
-    /** Get a nested config value by dot-separated key */
-    get(cwd: string, key: string): unknown;
-    /** Set a nested config value by dot-separated key */
-    set(cwd: string, key: string, value: unknown): void;
-    /** Create a new config file with defaults */
-    create(cwd: string, overrides?: Record<string, unknown>, force?: boolean): string;
-    /** Reset config to defaults */
-    reset(cwd: string): string;
-    /** Export config to a specific path */
-    exportTo(cwd: string, exportPath: string): void;
-    /** Import config from a specific path */
-    importFrom(cwd: string, importPath: string): void;
-    /** Get the path to the current config file */
-    getConfigPath(): string | null;
-    /** Get default config */
-    getDefaults(): Record<string, unknown>;
-    /** Atomic write: write to .tmp then rename */
-    private writeAtomic;
-}
-/** Parse a string value to the appropriate type */
-export declare function parseConfigValue(value: string): unknown;
-/** Singleton instance */
-export declare const configManager: ConfigFileManager;
-//# sourceMappingURL=config-file-manager.d.ts.map

package/dist/src/services/config-file-manager.js

@@ -1,224 +0,0 @@
-/**
- * Config File Manager
- * Shared JSON config file persistence with atomic writes and Zod validation
- */
-import * as fs from 'fs';
-import * as path from 'path';
-/** Config file search paths in priority order */
-const CONFIG_FILENAMES = [
-    'claude-flow.config.json',
-    '.claude-flow/config.json',
-];
-/** Default config values */
-const DEFAULT_CONFIG = {
-    version: '3.5',
-    agents: {
-        defaultType: 'coder',
-        autoSpawn: false,
-        maxConcurrent: 8,
-        timeout: 300000,
-        providers: [],
-    },
-    swarm: {
-        topology: 'hierarchical',
-        maxAgents: 8,
-        autoScale: false,
-        coordinationStrategy: 'leader',
-        healthCheckInterval: 30000,
-    },
-    memory: {
-        backend: 'hybrid',
-        persistPath: './data/memory',
-        cacheSize: 1000,
-        enableHNSW: true,
-        vectorDimension: 384,
-    },
-    mcp: {
-        serverHost: 'localhost',
-        serverPort: 3000,
-        autoStart: false,
-        transportType: 'stdio',
-        tools: [],
-    },
-    cli: {
-        colorOutput: true,
-        interactive: true,
-        verbosity: 'normal',
-        outputFormat: 'text',
-        progressStyle: 'spinner',
-    },
-    hooks: {
-        enabled: true,
-        autoExecute: true,
-        hooks: [],
-    },
-};
-export class ConfigFileManager {
-    configPath = null;
-    config = null;
-    /** Find config file in search paths starting from cwd */
-    findConfig(cwd) {
-        for (const filename of CONFIG_FILENAMES) {
-            const candidate = path.resolve(cwd, filename);
-            if (fs.existsSync(candidate)) {
-                return candidate;
-            }
-        }
-        // Check env var
-        const envPath = process.env.CLAUDE_FLOW_CONFIG;
-        if (envPath && fs.existsSync(envPath)) {
-            return path.resolve(envPath);
-        }
-        return null;
-    }
-    /** Load config from file, returns null if not found */
-    load(cwd) {
-        this.configPath = this.findConfig(cwd);
-        if (!this.configPath) {
-            this.config = null;
-            return null;
-        }
-        try {
-            const content = fs.readFileSync(this.configPath, 'utf-8');
-            this.config = JSON.parse(content);
-            return this.config;
-        }
-        catch {
-            this.config = null;
-            return null;
-        }
-    }
-    /** Get the current config, loading if needed */
-    getConfig(cwd) {
-        if (this.config === null) {
-            this.load(cwd);
-        }
-        return this.config ?? { ...DEFAULT_CONFIG };
-    }
-    /** Get a nested config value by dot-separated key */
-    get(cwd, key) {
-        const config = this.getConfig(cwd);
-        return getNestedValue(config, key);
-    }
-    /** Set a nested config value by dot-separated key */
-    set(cwd, key, value) {
-        const config = this.getConfig(cwd);
-        setNestedValue(config, key, value);
-        this.config = config;
-        const targetPath = this.configPath ?? path.resolve(cwd, CONFIG_FILENAMES[0]);
-        this.writeAtomic(targetPath, config);
-        this.configPath = targetPath;
-    }
-    /** Create a new config file with defaults */
-    create(cwd, overrides, force) {
-        const targetPath = path.resolve(cwd, CONFIG_FILENAMES[0]);
-        if (fs.existsSync(targetPath) && !force) {
-            throw new Error(`Config file already exists: ${targetPath}. Use --force to overwrite.`);
-        }
-        const config = { ...DEFAULT_CONFIG, ...overrides };
-        this.writeAtomic(targetPath, config);
-        this.config = config;
-        this.configPath = targetPath;
-        return targetPath;
-    }
-    /** Reset config to defaults */
-    reset(cwd) {
-        const targetPath = this.configPath ?? path.resolve(cwd, CONFIG_FILENAMES[0]);
-        this.writeAtomic(targetPath, DEFAULT_CONFIG);
-        this.config = { ...DEFAULT_CONFIG };
-        this.configPath = targetPath;
-        return targetPath;
-    }
-    /** Export config to a specific path */
-    exportTo(cwd, exportPath) {
-        const config = this.getConfig(cwd);
-        const resolved = path.resolve(cwd, exportPath);
-        this.writeAtomic(resolved, config);
-    }
-    /** Import config from a specific path */
-    importFrom(cwd, importPath) {
-        const resolved = path.resolve(cwd, importPath);
-        if (!fs.existsSync(resolved)) {
-            throw new Error(`Import file not found: ${resolved}`);
-        }
-        const content = fs.readFileSync(resolved, 'utf-8');
-        let imported;
-        try {
-            imported = JSON.parse(content);
-        }
-        catch {
-            throw new Error(`Invalid JSON in import file: ${resolved}`);
-        }
-        if (typeof imported !== 'object' || imported === null || Array.isArray(imported)) {
-            throw new Error('Import file must contain a JSON object');
-        }
-        const targetPath = this.configPath ?? path.resolve(cwd, CONFIG_FILENAMES[0]);
-        this.writeAtomic(targetPath, imported);
-        this.config = imported;
-        this.configPath = targetPath;
-    }
-    /** Get the path to the current config file */
-    getConfigPath() {
-        return this.configPath;
-    }
-    /** Get default config */
-    getDefaults() {
-        return { ...DEFAULT_CONFIG };
-    }
-    /** Atomic write: write to .tmp then rename */
-    writeAtomic(filePath, data) {
-        const dir = path.dirname(filePath);
-        if (!fs.existsSync(dir)) {
-            fs.mkdirSync(dir, { recursive: true });
-        }
-        const tmpPath = filePath + '.tmp';
-        fs.writeFileSync(tmpPath, JSON.stringify(data, null, 2) + '\n');
-        fs.renameSync(tmpPath, filePath);
-    }
-}
-/** Get a nested value by dot-separated key */
-function getNestedValue(obj, key) {
-    const parts = key.split('.');
-    let current = obj;
-    for (const part of parts) {
-        if (current === null || current === undefined || typeof current !== 'object') {
-            return undefined;
-        }
-        current = current[part];
-    }
-    return current;
-}
-/** Set a nested value by dot-separated key */
-function setNestedValue(obj, key, value) {
-    const parts = key.split('.');
-    let current = obj;
-    for (let i = 0; i < parts.length - 1; i++) {
-        const part = parts[i];
-        if (!(part in current) || typeof current[part] !== 'object' || current[part] === null) {
-            current[part] = {};
-        }
-        current = current[part];
-    }
-    current[parts[parts.length - 1]] = value;
-}
-/** Parse a string value to the appropriate type */
-export function parseConfigValue(value) {
-    if (value === 'true')
-        return true;
-    if (value === 'false')
-        return false;
-    if (/^\d+$/.test(value))
-        return parseInt(value, 10);
-    if (/^\d+\.\d+$/.test(value))
-        return parseFloat(value);
-    try {
-        const parsed = JSON.parse(value);
-        if (typeof parsed === 'object')
-            return parsed;
-    }
-    catch { /* not JSON, use as string */ }
-    return value;
-}
-/** Singleton instance */
-export const configManager = new ConfigFileManager();
-//# sourceMappingURL=config-file-manager.js.map

package/dist/src/services/container-worker-pool.d.ts

@@ -1,204 +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.
-     *
-     * #2371: the old command spawned `npx claude-flow@v3alpha daemon trigger`,
-     * which (a) referenced a deprecated dist-tag pointing at the pre-rename
-     * package, and (b) omitted `-y`, so npx could silently fall back to a
-     * locally-installed stale `claude-flow` without fetching the published
-     * version. Workers were running pre-autopilot / pre-browser builds.
-     * Use the current `ruflo@latest` and force a fresh resolution with `-y`.
-     */
-    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