@renseiai/agentfactory-cli 0.8.0

package/dist/src/lib/version.js

@@ -0,0 +1,168 @@
+/**
+ * Shared version utilities for AgentFactory CLI commands.
+ *
+ * Provides current version detection and npm update checking with
+ * file-based caching to avoid excessive network requests.
+ */
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import os from 'os';
+// ---------------------------------------------------------------------------
+// Current version
+// ---------------------------------------------------------------------------
+const PACKAGE_NAME = '@renseiai/agentfactory-cli';
+/**
+ * Read the current package version from the CLI's package.json.
+ */
+export function getVersion() {
+    try {
+        let dir = path.dirname(fileURLToPath(import.meta.url));
+        // Walk up from the current file until we find the CLI package.json
+        for (let i = 0; i < 5; i++) {
+            const candidate = path.join(dir, 'package.json');
+            if (existsSync(candidate)) {
+                const pkg = JSON.parse(readFileSync(candidate, 'utf-8'));
+                if (pkg.name === PACKAGE_NAME) {
+                    return pkg.version ?? 'unknown';
+                }
+            }
+            dir = path.dirname(dir);
+        }
+        return 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+// ---------------------------------------------------------------------------
+// Cache management
+// ---------------------------------------------------------------------------
+const CACHE_DIR = path.join(os.tmpdir(), 'agentfactory');
+const CACHE_FILE = path.join(CACHE_DIR, 'update-check.json');
+const CHECK_INTERVAL_MS = 4 * 60 * 60 * 1000; // 4 hours
+function readCache() {
+    try {
+        if (!existsSync(CACHE_FILE))
+            return null;
+        const data = JSON.parse(readFileSync(CACHE_FILE, 'utf-8'));
+        if (typeof data.latestVersion !== 'string' || typeof data.checkedAt !== 'number')
+            return null;
+        return data;
+    }
+    catch {
+        return null;
+    }
+}
+function writeCache(entry) {
+    try {
+        if (!existsSync(CACHE_DIR)) {
+            mkdirSync(CACHE_DIR, { recursive: true });
+        }
+        writeFileSync(CACHE_FILE, JSON.stringify(entry), 'utf-8');
+    }
+    catch {
+        // Non-critical — silently ignore cache write failures
+    }
+}
+// ---------------------------------------------------------------------------
+// npm registry fetch
+// ---------------------------------------------------------------------------
+async function fetchLatestVersion() {
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 5000);
+        const response = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, { signal: controller.signal });
+        clearTimeout(timeout);
+        if (!response.ok)
+            return null;
+        const data = (await response.json());
+        return data.version ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+// ---------------------------------------------------------------------------
+// Semver comparison (major.minor.patch only)
+// ---------------------------------------------------------------------------
+function parseVersion(v) {
+    const match = v.match(/^(\d+)\.(\d+)\.(\d+)/);
+    if (!match)
+        return null;
+    return [parseInt(match[1], 10), parseInt(match[2], 10), parseInt(match[3], 10)];
+}
+function isNewer(latest, current) {
+    const l = parseVersion(latest);
+    const c = parseVersion(current);
+    if (!l || !c)
+        return false;
+    if (l[0] !== c[0])
+        return l[0] > c[0];
+    if (l[1] !== c[1])
+        return l[1] > c[1];
+    return l[2] > c[2];
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Check whether a newer version is available on npm.
+ *
+ * Uses a file-based cache (4-hour TTL) to avoid hitting the registry
+ * on every CLI invocation. Returns null if the check is skipped or fails.
+ *
+ * Disabled when:
+ *   - `AF_NO_UPDATE_CHECK=1` env var is set
+ *   - `--no-update-check` was passed
+ *   - Current version is 'unknown'
+ */
+export async function checkForUpdate(opts) {
+    if (opts?.noUpdateCheck)
+        return null;
+    if (process.env.AF_NO_UPDATE_CHECK === '1' || process.env.AF_NO_UPDATE_CHECK === 'true')
+        return null;
+    const currentVersion = getVersion();
+    if (currentVersion === 'unknown')
+        return null;
+    // Check cache first
+    const cached = readCache();
+    if (cached && Date.now() - cached.checkedAt < CHECK_INTERVAL_MS) {
+        return {
+            currentVersion,
+            latestVersion: cached.latestVersion,
+            updateAvailable: isNewer(cached.latestVersion, currentVersion),
+        };
+    }
+    // Fetch from npm (non-blocking — don't slow down startup)
+    const latestVersion = await fetchLatestVersion();
+    if (!latestVersion)
+        return null;
+    writeCache({ latestVersion, checkedAt: Date.now() });
+    return {
+        currentVersion,
+        latestVersion,
+        updateAvailable: isNewer(latestVersion, currentVersion),
+    };
+}
+// ---------------------------------------------------------------------------
+// Display helpers
+// ---------------------------------------------------------------------------
+const c = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    yellow: '\x1b[33m',
+    cyan: '\x1b[36m',
+    green: '\x1b[32m',
+};
+/**
+ * Print an update notification to stderr if a newer version is available.
+ * Designed to be non-intrusive — just a single line after the startup banner.
+ */
+export function printUpdateNotification(result) {
+    if (!result?.updateAvailable)
+        return;
+    console.log(`\n${c.yellow}${c.bold}Update available:${c.reset} ${c.dim}v${result.currentVersion}${c.reset} → ${c.green}v${result.latestVersion}${c.reset}` +
+        `  ${c.dim}Run${c.reset} ${c.cyan}npm i -g @renseiai/agentfactory-cli@latest${c.reset} ${c.dim}to update${c.reset}\n`);
+}

package/dist/src/lib/worker-fleet-runner.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Worker Fleet Runner — Programmatic API for the worker fleet manager CLI.
+ *
+ * Spawns and manages multiple worker processes for parallel agent execution.
+ * Each worker runs as a separate OS process with its own resources.
+ */
+export interface FleetRunnerConfig {
+    /** Number of worker processes (default: CPU cores / 2) */
+    workers?: number;
+    /** Agents per worker (default: 3) */
+    capacity?: number;
+    /** Show configuration without starting workers (default: false) */
+    dryRun?: boolean;
+    /** Coordinator API URL (required) */
+    apiUrl: string;
+    /** API key for authentication (required) */
+    apiKey: string;
+    /** Path to the worker script/binary (default: auto-detect from this package) */
+    workerScript?: string;
+    /** Linear project names for workers to accept (undefined = all) */
+    projects?: string[];
+    /** Enable auto-update (CLI flag override) */
+    autoUpdate?: boolean;
+}
+/**
+ * Run a fleet of worker processes.
+ *
+ * The caller can cancel via the optional {@link AbortSignal}. The function
+ * returns once all workers have been stopped.
+ */
+export declare function runWorkerFleet(config: FleetRunnerConfig, signal?: AbortSignal): Promise<void>;
+//# sourceMappingURL=worker-fleet-runner.d.ts.map

package/dist/src/lib/worker-fleet-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-fleet-runner.d.ts","sourceRoot":"","sources":["../../../src/lib/worker-fleet-runner.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAcH,MAAM,WAAW,iBAAiB;IAChC,0DAA0D;IAC1D,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,qCAAqC;IACrC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,mEAAmE;IACnE,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,qCAAqC;IACrC,MAAM,EAAE,MAAM,CAAA;IACd,4CAA4C;IAC5C,MAAM,EAAE,MAAM,CAAA;IACd,gFAAgF;IAChF,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,mEAAmE;IACnE,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;IACnB,6CAA6C;IAC7C,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB;AA6UD;;;;;GAKG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,iBAAiB,EACzB,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,IAAI,CAAC,CAqBf"}

package/dist/src/lib/worker-fleet-runner.js

@@ -0,0 +1,256 @@
+/**
+ * Worker Fleet Runner — Programmatic API for the worker fleet manager CLI.
+ *
+ * Spawns and manages multiple worker processes for parallel agent execution.
+ * Each worker runs as a separate OS process with its own resources.
+ */
+import { spawn } from 'child_process';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { getVersion, checkForUpdate, printUpdateNotification } from './version.js';
+import { maybeAutoUpdate, isAutoUpdateEnabled } from './auto-updater.js';
+// ---------------------------------------------------------------------------
+// ANSI colors
+// ---------------------------------------------------------------------------
+const colors = {
+    reset: '\x1b[0m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    gray: '\x1b[90m',
+};
+const workerColors = [
+    colors.cyan,
+    colors.magenta,
+    colors.yellow,
+    colors.green,
+    colors.blue,
+];
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function timestamp() {
+    return new Date().toLocaleTimeString('en-US', { hour12: false });
+}
+function fleetLog(workerId, color, level, message) {
+    const prefix = workerId !== null
+        ? `[W${workerId.toString().padStart(2, '0')}]`
+        : '[FLEET]';
+    const levelColor = level === 'ERR' ? colors.red : level === 'WRN' ? colors.yellow : colors.gray;
+    console.log(`${colors.gray}${timestamp()}${colors.reset} ${color}${prefix}${colors.reset} ${levelColor}${level}${colors.reset} ${message}`);
+}
+function getDefaultWorkerScript() {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    // Runner lives in lib/, worker entry is one level up.
+    // When running from compiled dist/ the .js file exists; when running from
+    // source via tsx only the .ts file exists.
+    const jsPath = path.resolve(__dirname, '..', 'worker.js');
+    if (fs.existsSync(jsPath))
+        return jsPath;
+    return path.resolve(__dirname, '..', 'worker.ts');
+}
+// ---------------------------------------------------------------------------
+// WorkerFleet class (internal)
+// ---------------------------------------------------------------------------
+class WorkerFleet {
+    workers = new Map();
+    fleetConfig;
+    shuttingDown = false;
+    workerScript;
+    autoUpdateFlag;
+    resolveRunning = null;
+    updateInterval = null;
+    constructor(fleetConfig, workerScript, autoUpdateFlag) {
+        this.fleetConfig = fleetConfig;
+        this.workerScript = workerScript;
+        this.autoUpdateFlag = autoUpdateFlag;
+    }
+    async start(signal) {
+        const { workers, capacity, dryRun } = this.fleetConfig;
+        const totalCapacity = workers * capacity;
+        const version = getVersion();
+        console.log(`
+${colors.cyan}================================================================${colors.reset}
+${colors.cyan}  AgentFactory Worker Fleet Manager${colors.reset} ${colors.gray}v${version}${colors.reset}
+${colors.cyan}================================================================${colors.reset}
+  Workers:         ${colors.green}${workers}${colors.reset}
+  Capacity/Worker: ${colors.green}${capacity}${colors.reset}
+  Total Capacity:  ${colors.green}${totalCapacity}${colors.reset} concurrent agents
+  Projects:        ${colors.green}${this.fleetConfig.projects?.length ? this.fleetConfig.projects.join(', ') : 'all'}${colors.reset}
+  Auto-update:     ${isAutoUpdateEnabled(this.autoUpdateFlag) ? `${colors.green}enabled${colors.reset}` : `${colors.gray}disabled${colors.reset}`}
+
+  System:
+    CPU Cores:    ${os.cpus().length}
+    Total RAM:    ${Math.round(os.totalmem() / 1024 / 1024 / 1024)} GB
+    Free RAM:     ${Math.round(os.freemem() / 1024 / 1024 / 1024)} GB
+${colors.cyan}================================================================${colors.reset}
+`);
+        // Update check
+        const updateCheck = await checkForUpdate();
+        printUpdateNotification(updateCheck);
+        if (dryRun) {
+            console.log(`${colors.yellow}Dry run mode - not starting workers${colors.reset}`);
+            return;
+        }
+        // Wire up AbortSignal for graceful shutdown
+        const onAbort = () => this.shutdown('AbortSignal');
+        signal?.addEventListener('abort', onAbort, { once: true });
+        try {
+            // Spawn workers with staggered start to avoid thundering herd
+            for (let i = 0; i < workers; i++) {
+                if (signal?.aborted)
+                    break;
+                await this.spawnWorker(i);
+                if (i < workers - 1) {
+                    await new Promise((resolve) => setTimeout(resolve, 1000));
+                }
+            }
+            if (signal?.aborted)
+                return;
+            fleetLog(null, colors.green, 'INF', `All ${workers} workers started`);
+            // Periodic auto-update check (every 4 hours)
+            if (isAutoUpdateEnabled(this.autoUpdateFlag)) {
+                this.updateInterval = setInterval(async () => {
+                    const check = await checkForUpdate();
+                    await maybeAutoUpdate(check, {
+                        cliFlag: this.autoUpdateFlag,
+                        hasActiveWorkers: async () => this.workers.size > 0 && !this.shuttingDown,
+                        onBeforeRestart: async () => this.shutdown('auto-update'),
+                    });
+                }, 4 * 60 * 60 * 1000); // 4 hours
+            }
+            // Keep the fleet manager running until shutdown
+            await new Promise((resolve) => {
+                this.resolveRunning = resolve;
+            });
+        }
+        finally {
+            if (this.updateInterval)
+                clearInterval(this.updateInterval);
+            signal?.removeEventListener('abort', onAbort);
+        }
+    }
+    async spawnWorker(id) {
+        const color = workerColors[id % workerColors.length];
+        const existingWorker = this.workers.get(id);
+        const restartCount = existingWorker?.restartCount ?? 0;
+        fleetLog(id, color, 'INF', `Starting worker (capacity: ${this.fleetConfig.capacity})${restartCount > 0 ? ` [restart #${restartCount}]` : ''}`);
+        const nodeArgs = [];
+        // When running a .ts worker script, register tsx so Node can load it
+        if (this.workerScript.endsWith('.ts')) {
+            nodeArgs.push('--import', 'tsx');
+        }
+        nodeArgs.push(this.workerScript, '--capacity', String(this.fleetConfig.capacity), '--api-url', this.fleetConfig.apiUrl, '--api-key', this.fleetConfig.apiKey);
+        if (this.fleetConfig.projects?.length) {
+            nodeArgs.push('--projects', this.fleetConfig.projects.join(','));
+        }
+        const workerProcess = spawn('node', nodeArgs, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: {
+                ...process.env,
+                WORKER_FLEET_ID: String(id),
+            },
+            cwd: process.cwd(),
+        });
+        const workerInfo = {
+            id,
+            process: workerProcess,
+            color,
+            startedAt: new Date(),
+            restartCount,
+        };
+        this.workers.set(id, workerInfo);
+        // Handle stdout — prefix with worker ID
+        workerProcess.stdout?.on('data', (data) => {
+            const lines = data.toString().trim().split('\n');
+            for (const line of lines) {
+                if (line.trim()) {
+                    console.log(`${color}[W${id.toString().padStart(2, '0')}]${colors.reset} ${line}`);
+                }
+            }
+        });
+        // Handle stderr
+        workerProcess.stderr?.on('data', (data) => {
+            const lines = data.toString().trim().split('\n');
+            for (const line of lines) {
+                if (line.trim()) {
+                    console.log(`${color}[W${id.toString().padStart(2, '0')}]${colors.reset} ${colors.red}${line}${colors.reset}`);
+                }
+            }
+        });
+        // Handle worker exit
+        workerProcess.on('exit', (code, sig) => {
+            if (this.shuttingDown) {
+                fleetLog(id, color, 'INF', `Worker stopped (code: ${code}, signal: ${sig})`);
+                return;
+            }
+            fleetLog(id, color, 'WRN', `Worker exited unexpectedly (code: ${code}, signal: ${sig}) - restarting in 5s`);
+            const worker = this.workers.get(id);
+            if (worker) {
+                worker.restartCount++;
+            }
+            setTimeout(() => {
+                if (!this.shuttingDown) {
+                    this.spawnWorker(id);
+                }
+            }, 5000);
+        });
+        workerProcess.on('error', (err) => {
+            fleetLog(id, color, 'ERR', `Worker error: ${err.message}`);
+        });
+    }
+    async shutdown(reason) {
+        if (this.shuttingDown)
+            return;
+        this.shuttingDown = true;
+        console.log(`\n${colors.yellow}Received ${reason} - shutting down fleet...${colors.reset}`);
+        for (const [id, worker] of this.workers) {
+            fleetLog(id, worker.color, 'INF', 'Stopping worker...');
+            worker.process.kill('SIGTERM');
+        }
+        // Wait for workers to exit (max 30 seconds)
+        const forceKillTimeout = setTimeout(() => {
+            console.log(`${colors.red}Timeout waiting for workers - force killing${colors.reset}`);
+            for (const worker of this.workers.values()) {
+                worker.process.kill('SIGKILL');
+            }
+        }, 30000);
+        await Promise.all(Array.from(this.workers.values()).map((worker) => new Promise((resolve) => {
+            worker.process.on('exit', () => resolve());
+        })));
+        clearTimeout(forceKillTimeout);
+        console.log(`${colors.green}All workers stopped${colors.reset}`);
+        // Resolve the running promise so start() returns
+        this.resolveRunning?.();
+    }
+}
+// ---------------------------------------------------------------------------
+// Runner
+// ---------------------------------------------------------------------------
+/**
+ * Run a fleet of worker processes.
+ *
+ * The caller can cancel via the optional {@link AbortSignal}. The function
+ * returns once all workers have been stopped.
+ */
+export async function runWorkerFleet(config, signal) {
+    const workers = config.workers ?? Math.max(1, Math.floor(os.cpus().length / 2));
+    const capacity = config.capacity ?? 3;
+    const dryRun = config.dryRun ?? false;
+    const workerScript = config.workerScript ?? getDefaultWorkerScript();
+    const fleet = new WorkerFleet({
+        workers,
+        capacity,
+        dryRun,
+        apiUrl: config.apiUrl,
+        apiKey: config.apiKey,
+        projects: config.projects?.length ? config.projects : undefined,
+    }, workerScript, config.autoUpdate);
+    await fleet.start(signal);
+}

package/dist/src/lib/worker-runner.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Worker Runner — Programmatic API for the remote worker CLI.
+ *
+ * Encapsulates all global state into the runner function's closure so that
+ * multiple workers can be started from the same process (e.g. tests) without
+ * leaking state between invocations.
+ */
+export interface WorkerRunnerConfig {
+    /** Coordinator API URL */
+    apiUrl: string;
+    /** API key for authentication */
+    apiKey: string;
+    /** Worker hostname (default: os.hostname()) */
+    hostname?: string;
+    /** Maximum concurrent agents (default: 3) */
+    capacity?: number;
+    /** Poll but don't execute work (default: false) */
+    dryRun?: boolean;
+    /** Linear API key for agent operations (default: process.env.LINEAR_API_KEY) */
+    linearApiKey?: string;
+    /** Git repository root (default: auto-detect) */
+    gitRoot?: string;
+    /** Linear project names to accept (undefined = all) */
+    projects?: string[];
+}
+/**
+ * Run a worker that polls the coordinator for work and executes agents.
+ *
+ * All state is encapsulated in the function closure. The caller can cancel
+ * via the optional {@link AbortSignal}.
+ */
+export declare function runWorker(config: WorkerRunnerConfig, signal?: AbortSignal): Promise<void>;
+//# sourceMappingURL=worker-runner.d.ts.map

package/dist/src/lib/worker-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-runner.d.ts","sourceRoot":"","sources":["../../../src/lib/worker-runner.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAmBH,MAAM,WAAW,kBAAkB;IACjC,0BAA0B;IAC1B,MAAM,EAAE,MAAM,CAAA;IACd,iCAAiC;IACjC,MAAM,EAAE,MAAM,CAAA;IACd,+CAA+C;IAC/C,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,6CAA6C;IAC7C,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,mDAAmD;IACnD,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,gFAAgF;IAChF,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,iDAAiD;IACjD,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,uDAAuD;IACvD,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;CACpB;AAwED;;;;;GAKG;AACH,wBAAsB,SAAS,CAC7B,MAAM,EAAE,kBAAkB,EAC1B,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,IAAI,CAAC,CAm7Bf"}