@grantx/fleet-core 0.1.0

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@grantx/fleet-core",
+  "version": "0.1.0",
+  "type": "module",
+  "files": ["src/"],
+  "exports": {
+    ".": "./src/index.js",
+    "./agent-runner": "./src/agent-runner.js",
+    "./conductor-runner": "./src/conductor-runner.js",
+    "./conductor-loop": "./src/conductor-loop.js",
+    "./smart-dispatcher": "./src/smart-dispatcher.js",
+    "./dispatch-prompts": "./src/dispatch-prompts.js",
+    "./supabase-client": "./src/supabase-client.js",
+    "./fleet-utils": "./src/fleet-utils.js",
+    "./config": "./src/config.js",
+    "./platform": "./src/platform.js",
+    "./logger": "./src/logger.js"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  }
+}

package/src/agent-runner.js

@@ -0,0 +1,291 @@
+// agent-runner.js — Spawn claude -p processes with pooling and lockfiles.
+// Cross-platform port of the Grantx fleet agent-runner.
+// Persistent sessions via --resume. Max-turns and timeouts restore bounded execution.
+//
+// Session lifecycle:
+//   First invocation  -> --session-id <uuid>  (creates the session)
+//   All subsequent    -> --resume <uuid>       (resumes the session)
+// Tracked via "initialized" flag in sessions.json. Self-heals on errors.
+
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import path from 'node:path';
+import { log } from './logger.js';
+import { lockDir, ensureLockDir, buildAgentEnv, agentHome as resolveAgentHome } from './platform.js';
+import { getWorkerAgents } from './config.js';
+
+// ── Session Management ────────────────────────────────────────────
+
+function sessionsPath(projectRoot) {
+  return path.join(projectRoot, '.fleet', 'sessions.json');
+}
+
+function loadSessions(projectRoot, agentNames) {
+  const sessFile = sessionsPath(projectRoot);
+  try {
+    const raw = JSON.parse(readFileSync(sessFile, 'utf8'));
+    const sessions = {};
+    for (const [agent, val] of Object.entries(raw)) {
+      if (typeof val === 'string') {
+        sessions[agent] = { id: val, initialized: false };
+      } else {
+        sessions[agent] = val;
+      }
+    }
+    return sessions;
+  } catch {
+    // First run — generate sessions for all configured agents
+    const sessions = {};
+    for (const name of agentNames) {
+      sessions[name] = { id: randomUUID(), initialized: false };
+    }
+    saveSessions(projectRoot, sessions);
+    return sessions;
+  }
+}
+
+function saveSessions(projectRoot, sessions) {
+  const sessFile = sessionsPath(projectRoot);
+  try {
+    mkdirSync(path.dirname(sessFile), { recursive: true });
+    writeFileSync(sessFile, JSON.stringify(sessions, null, 2));
+  } catch (err) {
+    log.error('sessions', `Failed to write sessions file: ${err.message}`);
+  }
+}
+
+// ── AgentPool ─────────────────────────────────────────────────────
+
+export class AgentPool {
+  /**
+   * @param {object} config - Loaded fleet config
+   */
+  constructor(config) {
+    this.maxConcurrent = config.execution?.maxConcurrent || 5;
+    this.projectRoot = config._projectRoot || config.projectRoot || process.cwd();
+    this.teamId = config.teamId;
+    this.config = config;
+
+    const allAgents = config.agents.map(a => a.name);
+    this.sessions = loadSessions(this.projectRoot, allAgents);
+    this.running = new Map(); // agent -> { process, startTime, mode }
+    this.queue = [];
+    this.children = new Set();
+
+    ensureLockDir();
+  }
+
+  async invoke(agent, prompt, options = {}) {
+    const isBroadcast = options.broadcast || false;
+    const isDispatch = options.dispatch || false;
+
+    // Check if agent is already running
+    if (this.running.has(agent)) {
+      const entry = this.running.get(agent);
+      const elapsed = Math.round((Date.now() - entry.startTime) / 1000);
+      return {
+        ok: false,
+        busy: true,
+        message: `*${agent}* is already processing a request (${elapsed}s elapsed, mode: ${entry.mode}). Wait for it to finish.`,
+      };
+    }
+
+    // Check pool capacity
+    if (this.running.size >= this.maxConcurrent) {
+      if (this.queue.length >= 10) {
+        return {
+          ok: false,
+          busy: true,
+          message: `Fleet is at capacity (${this.running.size}/${this.maxConcurrent} active, ${this.queue.length} queued). Try again later.`,
+        };
+      }
+      return new Promise((resolve) => {
+        const mode = isDispatch ? 'dispatch' : isBroadcast ? 'broadcast' : 'on-demand';
+        this.queue.push({ agent, prompt, mode, resolve });
+        log.info('agent-pool', `Queued ${agent} (queue depth: ${this.queue.length})`);
+      });
+    }
+
+    const mode = isDispatch ? 'dispatch' : isBroadcast ? 'broadcast' : 'on-demand';
+    return this._spawn(agent, prompt, mode);
+  }
+
+  async _spawn(agent, prompt, mode) {
+    const lockFile = path.join(lockDir, `fleet-${agent}.lock`);
+    const agentHomeDir = resolveAgentHome(this.projectRoot, agent);
+    const workDir = this.projectRoot;
+    const sess = this.sessions[agent] || { id: randomUUID(), initialized: false };
+    const sessionId = sess.id;
+
+    return this._spawnWithSession(agent, prompt, mode, lockFile, agentHomeDir, workDir, sessionId, sess.initialized);
+  }
+
+  async _spawnWithSession(agent, prompt, mode, lockFile, agentHomeDir, workDir, sessionId, isInitialized, retryCount = 0) {
+    return new Promise((resolve) => {
+      // Write lockfile
+      try {
+        writeFileSync(lockFile, String(process.pid));
+      } catch (err) {
+        log.warn('agent-runner', `Could not write lockfile: ${err.message}`);
+      }
+
+      const env = buildAgentEnv(agent, agentHomeDir, this.teamId);
+      let stdout = '';
+      let stderr = '';
+
+      const sessionFlag = isInitialized ? '--resume' : '--session-id';
+      const child = spawn('claude', [
+        '-p', prompt,
+        '--dangerously-skip-permissions',
+        sessionFlag, sessionId,
+      ], {
+        cwd: workDir,
+        env,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+
+      this.children.add(child);
+      this.running.set(agent, { process: child, startTime: Date.now(), mode });
+
+      const timeouts = this.config.execution?.timeouts || {};
+      const timeoutMs = mode === 'broadcast' ? 120000
+        : mode === 'on-demand' ? (timeouts.review || 300000)
+        : (timeouts.task || 1800000);
+
+      const timeoutTimer = setTimeout(() => {
+        if (this.running.has(agent)) {
+          log.warn('agent-runner', `${agent} timed out after ${timeoutMs / 1000}s (mode: ${mode})`);
+          try { child.kill('SIGTERM'); } catch { /* ignore */ }
+        }
+      }, timeoutMs);
+
+      log.info('agent-runner', `Spawned ${agent} (PID ${child.pid}, mode: ${mode}, timeout: ${timeoutMs / 1000}s, ${sessionFlag} ${sessionId.slice(0, 8)}...)`);
+
+      child.stdout.on('data', (data) => { stdout += data.toString(); });
+      child.stderr.on('data', (data) => { stderr += data.toString(); });
+
+      child.on('close', (code) => {
+        clearTimeout(timeoutTimer);
+        this.running.delete(agent);
+        this.children.delete(child);
+        try { unlinkSync(lockFile); } catch { /* ignore */ }
+
+        let output = stdout.trim();
+        const errText = stderr.trim();
+
+        // Self-healing: wrong session flag -> retry once. On second failure, fresh session.
+        if (code === 1 && retryCount < 2) {
+          if (errText.includes('already in use') && !isInitialized) {
+            log.info('agent-runner', `${agent}: session exists, retrying with --resume`);
+            this._markInitialized(agent);
+            this._spawnWithSession(agent, prompt, mode, lockFile, agentHomeDir, workDir, sessionId, true, retryCount + 1).then(resolve);
+            return;
+          }
+          if (errText.includes('No conversation found') && isInitialized) {
+            const newId = randomUUID();
+            log.info('agent-runner', `${agent}: session not found, creating fresh session ${newId.slice(0, 8)}`);
+            this.sessions[agent] = { id: newId, initialized: false };
+            saveSessions(this.projectRoot, this.sessions);
+            this._spawnWithSession(agent, prompt, mode, lockFile, agentHomeDir, workDir, newId, false, retryCount + 1).then(resolve);
+            return;
+          }
+        }
+
+        if (code === 0 || (code === null && output.length > 0)) {
+          if (!isInitialized) this._markInitialized(agent);
+          log.info('agent-runner', `${agent} completed (${output.length} chars, mode: ${mode})`);
+          resolve({ ok: true, output });
+        } else {
+          const errMsg = errText.slice(0, 500) || 'No output';
+          log.warn('agent-runner', `${agent} exited with code ${code} (mode: ${mode}): ${errMsg.slice(0, 200)}`);
+          resolve({
+            ok: false,
+            message: `*${agent}* exited with code ${code}: ${errMsg}`,
+          });
+        }
+
+        this._drainQueue();
+      });
+
+      child.on('error', (err) => {
+        clearTimeout(timeoutTimer);
+        this.running.delete(agent);
+        this.children.delete(child);
+        try { unlinkSync(lockFile); } catch { /* ignore */ }
+        resolve({
+          ok: false,
+          message: `Failed to spawn *${agent}*: ${err.message}`,
+        });
+        this._drainQueue();
+      });
+    });
+  }
+
+  _markInitialized(agent) {
+    if (this.sessions[agent]) {
+      this.sessions[agent].initialized = true;
+      saveSessions(this.projectRoot, this.sessions);
+    }
+  }
+
+  _drainQueue() {
+    while (this.queue.length > 0 && this.running.size < this.maxConcurrent) {
+      const next = this.queue.shift();
+      log.info('agent-pool', `Dequeuing ${next.agent} (remaining: ${this.queue.length})`);
+      this._spawn(next.agent, next.prompt, next.mode).then(next.resolve);
+    }
+  }
+
+  /**
+   * Get status of all running agents.
+   */
+  getRunningStatus() {
+    const status = [];
+    for (const [agent, entry] of this.running) {
+      status.push({
+        agent,
+        mode: entry.mode,
+        elapsed: Math.round((Date.now() - entry.startTime) / 1000),
+        pid: entry.process.pid,
+      });
+    }
+    return status;
+  }
+
+  /**
+   * Kill a specific agent process.
+   */
+  killAgent(agent) {
+    const entry = this.running.get(agent);
+    if (!entry) {
+      log.warn('agent-pool', `killAgent: ${agent} not in running map`);
+      return false;
+    }
+    log.info('agent-pool', `Killing ${agent} (PID ${entry.process.pid})`);
+    try { entry.process.kill('SIGTERM'); } catch { /* ignore */ }
+    setTimeout(() => {
+      if (this.running.has(agent)) {
+        log.warn('agent-pool', `Force-killing ${agent} (SIGKILL)`);
+        try { entry.process.kill('SIGKILL'); } catch { /* ignore */ }
+      }
+    }, 5000);
+    return true;
+  }
+
+  /**
+   * Kill all running child processes. Called on SIGTERM for graceful shutdown.
+   */
+  killAll() {
+    log.info('agent-pool', `Killing ${this.children.size} child processes`);
+    for (const child of this.children) {
+      try { child.kill('SIGTERM'); } catch { /* ignore */ }
+    }
+    for (const agent of this.running.keys()) {
+      try { unlinkSync(path.join(lockDir, `fleet-${agent}.lock`)); } catch { /* ignore */ }
+    }
+    this.running.clear();
+    this.children.clear();
+    this.queue = [];
+  }
+}

package/src/conductor-loop.js

@@ -0,0 +1,336 @@
+// conductor-loop.js — Event-driven orchestration loop.
+// Polls Supabase for state changes, routes to SmartDispatcher for fast-path,
+// falls through to conductor AI for complex decisions.
+// All queries team-scoped. No Grantx-specific events.
+
+import { log } from './logger.js';
+import { SmartDispatcher } from './smart-dispatcher.js';
+import { ConductorRunner, parseDispatchBlock } from './conductor-runner.js';
+import { fetchFleetState, executeDecisions } from './fleet-utils.js';
+import { buildConductorEventPrompt } from './dispatch-prompts.js';
+
+export class ConductorLoop {
+  /**
+   * @param {AgentPool} agentPool
+   * @param {SupabaseClient} supabase
+   * @param {object} config - Loaded fleet config
+   */
+  constructor(agentPool, supabase, config) {
+    this.agentPool = agentPool;
+    this.supabase = supabase;
+    this.config = config;
+
+    this.dispatcher = new SmartDispatcher(agentPool, supabase, config);
+    this.conductor = new ConductorRunner(config);
+
+    this.loopIntervalMs = config.daemon?.loopIntervalMs || 5000;
+    this.cronConfig = config.daemon?.cron || {};
+
+    this._events = [];
+    this._running = false;
+    this._tickTimer = null;
+    this._tickInProgress = false;
+    this._lastState = {};
+
+    // Cron trackers
+    this._lastHealthCheck = Date.now();
+    this._lastSynthesis = Date.now();
+
+    // Stats
+    this.stats = {
+      ticks: 0,
+      conductorCalls: 0,
+      dispatches: 0,
+      errors: 0,
+      startTime: null,
+    };
+  }
+
+  /**
+   * Start the orchestration loop.
+   */
+  start() {
+    if (this._running) {
+      log.warn('conductor-loop', 'Already running');
+      return;
+    }
+    this._running = true;
+    this.stats.startTime = Date.now();
+    log.info('conductor-loop', `Starting loop (interval: ${this.loopIntervalMs}ms)`);
+
+    this._tickTimer = setInterval(() => this._tick(), this.loopIntervalMs);
+
+    // Push initial dispatch tick to get things moving
+    this.pushEvent({ type: 'dispatch_tick', timestamp: new Date().toISOString() });
+  }
+
+  /**
+   * Stop the orchestration loop gracefully.
+   */
+  stop() {
+    if (!this._running) return;
+    this._running = false;
+    if (this._tickTimer) {
+      clearInterval(this._tickTimer);
+      this._tickTimer = null;
+    }
+    log.info('conductor-loop', `Stopped (${this.stats.ticks} ticks, ${this.stats.conductorCalls} conductor calls)`);
+  }
+
+  /**
+   * Push an event into the queue (processed on next tick).
+   */
+  pushEvent(event) {
+    this._events.push(event);
+  }
+
+  /**
+   * Get loop stats.
+   */
+  getStats() {
+    return {
+      ...this.stats,
+      running: this._running,
+      eventQueueDepth: this._events.length,
+      uptime: this.stats.startTime ? Math.round((Date.now() - this.stats.startTime) / 1000) : 0,
+      dispatcher: this.dispatcher.getStats(),
+    };
+  }
+
+  // ── Internal ──────────────────────────────────────────────────────
+
+  async _tick() {
+    // Guard: no overlapping ticks
+    if (this._tickInProgress) return;
+    this._tickInProgress = true;
+
+    try {
+      this.stats.ticks++;
+
+      // Inject cron events
+      this._checkCrons();
+
+      // Detect state changes from Supabase
+      await this._detectStateChanges();
+
+      // Collect events for this cycle
+      const events = this._events.splice(0);
+      if (events.length === 0) {
+        // Nothing happened — push a dispatch tick to check for pending work
+        events.push({ type: 'dispatch_tick', timestamp: new Date().toISOString() });
+      }
+
+      // Fetch fleet state
+      const state = await fetchFleetState(this.supabase);
+      this._lastState = state;
+
+      // Try smart-dispatcher first (fast path)
+      const handled = await this.dispatcher.tryFastPath(events, state);
+      if (handled) {
+        return;
+      }
+
+      // Fall through to conductor AI for complex decisions
+      await this._invokeConductor(events, state);
+
+    } catch (err) {
+      this.stats.errors++;
+      log.error('conductor-loop', `Tick error: ${err.message}`);
+    } finally {
+      this._tickInProgress = false;
+    }
+  }
+
+  /**
+   * Detect state changes by comparing Supabase snapshots.
+   * Generates events for: completions, failures, flags.
+   */
+  async _detectStateChanges() {
+    try {
+      // Check for recently completed tasks
+      const completed = await this.supabase.get(
+        'task_queue?status=eq.completed&order=completed_at.desc&limit=5'
+      );
+      for (const t of completed) {
+        const key = `completed:${t.id}`;
+        if (!this._seenEvent(key)) {
+          this._markSeen(key);
+          this.pushEvent({
+            type: 'task_completed',
+            task_id: t.id,
+            agent: t.to_agent,
+            title: t.title,
+            timestamp: t.completed_at,
+          });
+
+          // Try chain dispatch for the completing agent
+          const state = this._lastState;
+          if (t.to_agent && state.pendingTasks) {
+            await this.dispatcher.tryChainDispatch(t.to_agent, state);
+          }
+        }
+      }
+
+      // Check for recently failed tasks
+      const failed = await this.supabase.get(
+        'task_queue?status=eq.failed&order=last_failure_at.desc&limit=5'
+      );
+      for (const t of failed) {
+        const key = `failed:${t.id}:${t.failure_count}`;
+        if (!this._seenEvent(key)) {
+          this._markSeen(key);
+          this.pushEvent({
+            type: 'task_failed',
+            task_id: t.id,
+            agent: t.to_agent,
+            title: t.title,
+            failure_count: t.failure_count,
+            failure_reason: t.last_failure_reason,
+          });
+        }
+      }
+
+      // Check for blocked tasks
+      const blocked = await this.supabase.get(
+        'task_queue?status=eq.blocked&order=flagged_at.desc&limit=5'
+      );
+      for (const t of blocked) {
+        const key = `blocked:${t.id}`;
+        if (!this._seenEvent(key)) {
+          this._markSeen(key);
+          this.pushEvent({
+            type: 'task_flagged',
+            task_id: t.id,
+            agent: t.to_agent,
+            title: t.title,
+            flag_type: 'blocked',
+            flag_reason: t.blocked_reason,
+          });
+        }
+      }
+
+      // Check for unblocked tasks (pending tasks whose deps are now all completed)
+      await this._checkUnblocked();
+
+    } catch (err) {
+      log.warn('conductor-loop', `State change detection error: ${err.message}`);
+    }
+  }
+
+  /**
+   * Check for tasks that just became unblocked (all deps completed).
+   */
+  async _checkUnblocked() {
+    try {
+      const pending = await this.supabase.get(
+        'task_queue?status=eq.pending&depends_on=not.is.null&select=id,title,depends_on'
+      );
+
+      for (const task of pending) {
+        if (!task.depends_on?.length) continue;
+
+        const depTasks = await this.supabase.getUnscoped(
+          `task_queue?id=in.(${task.depends_on.join(',')})&select=id,status`
+        );
+
+        const allDone = depTasks.every(d => d.status === 'completed');
+        if (allDone) {
+          const key = `unblocked:${task.id}`;
+          if (!this._seenEvent(key)) {
+            this._markSeen(key);
+            this.pushEvent({
+              type: 'task_unblocked',
+              task_id: task.id,
+              title: task.title,
+            });
+          }
+        }
+      }
+    } catch (err) {
+      log.warn('conductor-loop', `Unblocked check error: ${err.message}`);
+    }
+  }
+
+  /**
+   * Invoke conductor AI for complex decisions.
+   */
+  async _invokeConductor(events, state) {
+    if (this.conductor.running) {
+      log.info('conductor-loop', 'Conductor already running, skipping');
+      return;
+    }
+
+    this.stats.conductorCalls++;
+    const prompt = buildConductorEventPrompt(events, state, this.config);
+
+    log.info('conductor-loop', `Invoking conductor (${events.length} events)`);
+    const result = await this.conductor.invoke(prompt);
+
+    if (!result.ok) {
+      log.warn('conductor-loop', `Conductor failed: ${result.message?.slice(0, 200)}`);
+      return;
+    }
+
+    // Parse dispatch block
+    const block = parseDispatchBlock(result.output);
+    if (!block) {
+      log.info('conductor-loop', 'Conductor returned no dispatch block');
+      return;
+    }
+
+    // Execute decisions
+    const dispatchCount = block.dispatches?.length || 0;
+    this.stats.dispatches += dispatchCount;
+    if (dispatchCount > 0 || block.kills?.length > 0 || block.reviews?.length > 0) {
+      log.info('conductor-loop', `Executing: ${dispatchCount} dispatches, ${block.kills?.length || 0} kills, ${block.reviews?.length || 0} reviews`);
+      await executeDecisions(block, this.agentPool, this.supabase, this.config);
+    }
+  }
+
+  // ── Cron events ───────────────────────────────────────────────────
+
+  _checkCrons() {
+    const now = Date.now();
+
+    // Health check
+    const healthIntervalMs = (this.cronConfig.healthCheckMinutes || 10) * 60 * 1000;
+    if (now - this._lastHealthCheck >= healthIntervalMs) {
+      this._lastHealthCheck = now;
+      this.pushEvent({ type: 'health_check', timestamp: new Date().toISOString() });
+      log.info('conductor-loop', 'Cron: health check');
+    }
+
+    // Synthesis
+    const synthesisIntervalMs = (this.cronConfig.synthesisHours || 2) * 60 * 60 * 1000;
+    if (now - this._lastSynthesis >= synthesisIntervalMs) {
+      this._lastSynthesis = now;
+      this.pushEvent({ type: 'synthesis', timestamp: new Date().toISOString() });
+      log.info('conductor-loop', 'Cron: synthesis');
+    }
+  }
+
+  // ── Dedup helpers ─────────────────────────────────────────────────
+
+  _seenEvents = new Set();
+  _seenTimestamps = new Map();
+
+  _seenEvent(key) {
+    return this._seenEvents.has(key);
+  }
+
+  _markSeen(key) {
+    this._seenEvents.add(key);
+    this._seenTimestamps.set(key, Date.now());
+
+    // Cleanup old entries every 100 additions to prevent memory growth
+    if (this._seenEvents.size % 100 === 0) {
+      const cutoff = Date.now() - 30 * 60 * 1000; // 30 min
+      for (const [k, ts] of this._seenTimestamps) {
+        if (ts < cutoff) {
+          this._seenEvents.delete(k);
+          this._seenTimestamps.delete(k);
+        }
+      }
+    }
+  }
+}