iriai-build 0.1.0

package/lib/agent-process.js

@@ -0,0 +1,170 @@
+// agent-process.js — Process wrapper for claude agent sessions.
+//
+// Two modes:
+//   spawn()       — bash script (legacy, used by index.js)
+//   spawnClaude() — claude CLI directly (v3 bridge)
+//
+// Uses child_process.spawn instead of node-pty to avoid blocking
+// the parent's event loop (node-pty interferes with WebSocket I/O).
+
+import { EventEmitter } from "node:events";
+import { spawn as cpSpawn } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { getClaudeBin } from "../cli/config.js";
+
+class AgentProcess extends EventEmitter {
+  /**
+   * @param {object} opts
+   * @param {string} opts.key        - Unique identifier (e.g. "fl-slug", "role-slug-0-backend")
+   * @param {string} [opts.script]   - Path to bash script (for spawn())
+   * @param {string[]} [opts.args]   - Script arguments (for spawn())
+   * @param {string} opts.cwd        - Working directory
+   * @param {object} [opts.extraEnv] - Extra env vars (merged with process.env)
+   * @param {string} opts.signalDir  - Signal directory (for log file)
+   */
+  constructor({ key, script, args, cwd, extraEnv, signalDir }) {
+    super();
+    this.key = key;
+    this.script = script;
+    this.args = args || [];
+    this.cwd = cwd;
+    this.extraEnv = extraEnv || {};
+    this.signalDir = signalDir;
+    this.logFile = path.join(signalDir, ".runner.log");
+
+    this._process = null;
+    this.pid = null;
+    this.startTime = null;
+    this.exitCode = null;
+    this.exited = false;
+    this._killed = false;
+    this._logStream = null;
+    this._killTimer = null;
+  }
+
+  /**
+   * Spawn claude CLI directly. No bash middleware.
+   * @param {string} prompt - The prompt to pass with -p flag
+   * @param {object} opts
+   * @param {string} [opts.model] - Model to use (default: "opus")
+   */
+  spawnClaude(prompt, { model = "opus", continue: cont = false } = {}) {
+    const claudeArgs = [
+      "--dangerously-skip-permissions",
+      "--verbose",
+      "--model", model,
+    ];
+    if (cont) claudeArgs.push("--continue");
+    claudeArgs.push("-p", prompt);
+    const bin = getClaudeBin();
+    return this._spawn(bin, claudeArgs, `${bin} ${claudeArgs.slice(0, 4).join(" ")} -p <prompt>`);
+  }
+
+  /**
+   * Spawn a bash script (legacy mode for index.js compatibility).
+   */
+  spawn() {
+    return this._spawn("bash", [this.script, ...this.args], `bash ${this.script} ${this.args.join(" ")}`);
+  }
+
+  _spawn(command, args, logLabel) {
+    const env = { ...process.env, ...this.extraEnv };
+    delete env.CLAUDECODE;
+
+    this._logStream = fs.createWriteStream(this.logFile, { flags: "a" });
+    this._logStream.write(
+      `\n[agent-process] Spawning: ${logLabel}\n` +
+        `[agent-process] cwd: ${this.cwd}  key: ${this.key}  time: ${new Date().toISOString()}\n`
+    );
+
+    this._process = cpSpawn(command, args, {
+      cwd: this.cwd,
+      env,
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: false,
+    });
+
+    this.pid = this._process.pid;
+    this.startTime = Date.now();
+
+    this._process.stdout.on("data", (data) => {
+      if (this._logStream && !this._logStream.destroyed) {
+        this._logStream.write(data);
+      }
+    });
+
+    this._process.stderr.on("data", (data) => {
+      if (this._logStream && !this._logStream.destroyed) {
+        this._logStream.write(data);
+      }
+    });
+
+    this._process.on("exit", (exitCode, signal) => {
+      this.exitCode = exitCode;
+      this.exited = true;
+      if (this._killTimer) {
+        clearTimeout(this._killTimer);
+        this._killTimer = null;
+      }
+      if (this._logStream && !this._logStream.destroyed) {
+        this._logStream.write(
+          `\n[agent-process] Exited: code=${exitCode} signal=${signal} elapsed=${this.getElapsedMs()}ms\n`
+        );
+        this._logStream.end();
+      }
+      this.emit("exit", {
+        exitCode: exitCode ?? 1,
+        signal,
+        key: this.key,
+        elapsed: this.getElapsedMs(),
+      });
+    });
+
+    this._process.on("error", (err) => {
+      if (this._logStream && !this._logStream.destroyed) {
+        this._logStream.write(`\n[agent-process] Spawn error: ${err.message}\n`);
+      }
+      if (!this.exited) {
+        this.exited = true;
+        this.exitCode = 1;
+        this.emit("exit", {
+          exitCode: 1,
+          signal: null,
+          key: this.key,
+          elapsed: this.getElapsedMs(),
+        });
+      }
+    });
+
+    return this;
+  }
+
+  kill(signal = "SIGTERM") {
+    if (!this._process || this._killed || this.exited) return;
+    this._killed = true;
+
+    try {
+      process.kill(this.pid, signal);
+    } catch {
+      /* already gone */
+    }
+
+    // Escalate to SIGKILL after 5s grace period
+    if (signal !== "SIGKILL") {
+      this._killTimer = setTimeout(() => {
+        try {
+          if (!this.exited) process.kill(this.pid, "SIGKILL");
+        } catch {
+          /* already gone */
+        }
+      }, 5000);
+    }
+  }
+
+  getElapsedMs() {
+    return this.startTime ? Date.now() - this.startTime : 0;
+  }
+}
+
+export default AgentProcess;

package/lib/bridge-state.js

@@ -0,0 +1,126 @@
+// bridge-state.js — State persistence and startup recovery.
+// Same JSON format as index.js for compatibility.
+
+import fs from "node:fs";
+import path from "node:path";
+import { STATE_FILE, IMPL_BASE } from "./constants.js";
+import { ensureDir } from "./slack-helpers.js";
+
+/**
+ * Save features state to disk.
+ * @param {object} features - thread_ts -> feature state
+ */
+export function save(features) {
+  ensureDir(path.dirname(STATE_FILE));
+  // Merge with on-disk state so concurrent bridge processes (e.g. during
+  // graceful shutdown of a replaced instance) don't overwrite entries they
+  // never knew about.
+  let diskState = {};
+  try {
+    if (fs.existsSync(STATE_FILE)) {
+      diskState = JSON.parse(fs.readFileSync(STATE_FILE, "utf-8"));
+    }
+  } catch { /* ok — start from empty */ }
+  const merged = { ...diskState, ...features };
+  fs.writeFileSync(STATE_FILE, JSON.stringify(merged, null, 2));
+}
+
+/**
+ * Load features state from disk.
+ * @returns {object} features
+ */
+export function load() {
+  try {
+    if (fs.existsSync(STATE_FILE)) {
+      const features = JSON.parse(fs.readFileSync(STATE_FILE, "utf-8"));
+      console.log(
+        `[state] Restored: ${Object.keys(features).length} active features`
+      );
+      return features;
+    }
+  } catch {
+    console.warn("[state] Could not load bridge state, starting fresh");
+  }
+  return {};
+}
+
+/**
+ * Discover the implementation signal tree for a feature.
+ * Same structure as index.js discoverImplSignalTree().
+ */
+export function discoverImplSignalTree(slug) {
+  const featureDir = path.join(IMPL_BASE, "features", slug);
+  const tree = {
+    featureDir,
+    featureLead: null,
+    operator: null,
+    featureReview: {},
+    teams: {},
+  };
+
+  const flDir = path.join(featureDir, "feature-lead");
+  if (fs.existsSync(flDir)) tree.featureLead = flDir;
+
+  const opDir = path.join(featureDir, "operator");
+  if (fs.existsSync(opDir)) tree.operator = opDir;
+
+  const reviewDir = path.join(featureDir, "feature-review");
+  try {
+    for (const entry of fs.readdirSync(reviewDir)) {
+      const roleDir = path.join(reviewDir, entry);
+      if (fs.statSync(roleDir).isDirectory()) {
+        tree.featureReview[entry] = roleDir;
+      }
+    }
+  } catch {
+    /* no review dir yet */
+  }
+
+  const teamsDir = path.join(featureDir, "teams");
+  try {
+    for (const team of fs.readdirSync(teamsDir).sort()) {
+      if (!team.startsWith("team-")) continue;
+      const teamDir = path.join(teamsDir, team);
+      if (!fs.statSync(teamDir).isDirectory()) continue;
+      const teamNum = team.replace("team-", "");
+      tree.teams[teamNum] = {
+        dir: teamDir,
+        orchestrator: null,
+        roles: {},
+      };
+
+      const orchDir = path.join(teamDir, "orchestrator");
+      if (fs.existsSync(orchDir)) tree.teams[teamNum].orchestrator = orchDir;
+
+      const rolesDir = path.join(teamDir, "roles");
+      try {
+        for (const role of fs.readdirSync(rolesDir)) {
+          const roleDir = path.join(rolesDir, role);
+          if (fs.statSync(roleDir).isDirectory()) {
+            tree.teams[teamNum].roles[role] = roleDir;
+          }
+        }
+      } catch {
+        /* no roles dir */
+      }
+    }
+  } catch {
+    /* no teams dir */
+  }
+
+  return tree;
+}
+
+/**
+ * Identify features that were in impl phase when bridge stopped.
+ * Returns array of { thread_ts, featureState, slug }.
+ */
+export function getActiveImplFeatures(features) {
+  return Object.entries(features)
+    .filter(([, f]) => f.active_role === "impl")
+    .map(([thread_ts, featureState]) => ({
+      thread_ts,
+      featureState,
+      slug: featureState.feature_slug,
+    }));
+}

package/lib/constants.js

@@ -0,0 +1,137 @@
+// constants.js — Centralized paths, timeouts, signal file names, role mappings.
+// Extracted from index.js config section and bash scripts.
+
+import path from "node:path";
+
+const HOME = process.env.HOME;
+
+// ─── Base Directories ────────────────────────────────────────────────────────
+
+export const PLANNING_BASE =
+  process.env.PLANNING_SIGNAL_BASE ||
+  path.join(HOME, "src/iriai/.planning");
+
+export const IMPL_BASE =
+  process.env.IMPL_SIGNAL_BASE ||
+  path.join(HOME, "src/iriai/.implementation");
+
+export const IRIAI_TEAM_DIR =
+  process.env.IRIAI_TEAM_DIR ||
+  path.join(HOME, "src/iriai/iriai-team");
+
+export const SCRIPTS_DIR = path.join(IRIAI_TEAM_DIR, "scripts");
+
+export const STATE_FILE = path.join(PLANNING_BASE, "lead", ".bridge-state.json");
+
+export const DASHBOARD_LOG = path.join(IRIAI_TEAM_DIR, ".dashboard-log");
+export const DASHBOARD_FILE = path.join(IRIAI_TEAM_DIR, "DASHBOARD.md");
+export const FEATURE_STATUS_FILE = path.join(IRIAI_TEAM_DIR, "FEATURE-STATUS.md");
+
+// ─── Planning Role Directories ───────────────────────────────────────────────
+
+export const ROLE_DIRS = {
+  pm: path.join(PLANNING_BASE, "pm"),
+  designer: path.join(PLANNING_BASE, "design"),
+  architect: path.join(PLANNING_BASE, "architect"),
+  "plan-compiler": path.join(PLANNING_BASE, "plan-compiler"),
+  lead: path.join(PLANNING_BASE, "lead"),
+};
+
+export const ROLE_LABELS = {
+  pm: "PM",
+  designer: "Designer",
+  architect: "Architect",
+  "plan-compiler": "Plan Compiler",
+  lead: "Feature Lead",
+};
+
+export const PIPELINE_ORDER = ["pm", "designer", "architect", "plan-compiler"];
+
+// ─── Timeouts (milliseconds unless noted) ────────────────────────────────────
+
+export const ROLE_HARD_TIMEOUT_MS = 75 * 60 * 1000;      // 75 min
+export const ROLE_SOFT_TIMEOUT_MS = 15 * 60 * 1000;      // 15 min
+export const ORCH_SOFT_TIMEOUT_MS = 45 * 60 * 1000;      // 45 min
+export const PLANNING_TIMEOUT_MS = 30 * 60 * 1000;       // 30 min
+export const OPERATOR_TIMEOUT_MS = 2 * 60 * 1000;        // 2 min
+export const FL_SOFT_TIMEOUT_MS = 45 * 60 * 1000;        // 45 min
+export const FL_CONTEXT_EXHAUST_MS = 5 * 60 * 1000;      // 5 min (auto-refresh threshold)
+
+export const RSS_CEILING_KB = 8_388_608;                   // 8 GB
+export const STUCK_THRESHOLD_MS = 10 * 60 * 1000;         // 10 min no PTY output
+export const HEALTH_CHECK_INTERVAL_MS = 30_000;            // 30s
+
+// ─── Retry Limits ────────────────────────────────────────────────────────────
+
+export const MAX_ROLE_RETRIES = 2;
+export const MAX_ORCH_RETRIES = 1;
+export const MAX_FL_RETRIES = 3;
+export const MAX_FL_INIT_RETRIES = 2;
+export const MAX_PLANNING_RETRIES = 2;
+
+// ─── Backoff (seconds) ──────────────────────────────────────────────────────
+
+export const FAST_EXIT_THRESHOLD_MS = 15_000;   // <15s = "fast exit" (possible usage limit)
+export const FAST_EXIT_BACKOFF_S = 30;           // multiplied by retry count
+export const NORMAL_BACKOFF_S = 5;               // multiplied by retry count
+export const FL_NORMAL_BACKOFF_S = 10;           // FL uses longer normal backoff
+
+// ─── Signal File Names ──────────────────────────────────────────────────────
+
+export const SIGNAL = {
+  TASK: ".task",
+  ACTIVE_TASK: ".active-task",
+  DONE: ".done",
+  OUTPUT: ".output",
+  AGENT_RESPONSE: ".agent-response",
+  USER_MESSAGE: ".user-message",
+  QUESTION: ".question",
+  ANSWER: ".answer",
+  NEEDS_RESTART: ".needs-restart",
+  HANDOVER: ".handover",
+  KILL: ".kill",
+  STUCK: ".stuck",
+  CRASHED: ".crashed",
+  STARTED: ".started",
+  RUNNING: ".running",
+  GATE_READY: ".gate-ready",
+  GATE_APPROVED: ".gate-approved",
+  PHASE_DONE: ".phase-done",
+  FEATURE_COMPLETE: ".feature-complete",
+  CONTEXT_REFRESH: ".context-refresh",
+  CONVERSATION_HISTORY: ".conversation-history",
+  CLAUDE_SESSION_LOG: ".claude-session.log",
+  RUNNER_LOG: ".runner.log",
+  DASHBOARD_LOG: ".dashboard-log",
+  BRIDGE_STATE: ".bridge-state.json",
+  TEAM_CONFIG: ".team-config",
+};
+
+// ─── Known Repos ─────────────────────────────────────────────────────────────
+
+export const KNOWN_REPOS = [
+  "first-party-apps/directory/directory-backend",
+  "first-party-apps/directory/directory-frontend",
+  "first-party-apps/events/events-backend",
+  "first-party-apps/events/events-frontend",
+  "first-party-apps/subdomain-home/subdomain-home-frontend",
+  "first-party-apps/subdomain-home/subdomain-home-server",
+  "frontend-apps/iriai-app/iriai-app-bff",
+  "frontend-apps/iriai-app/iriai-app-frontend",
+  "packages/auth-python",
+  "packages/auth-react",
+  "platform/auth/auth-frontend",
+  "platform/auth/auth-service",
+  "platform/deploy-console/deploy-console-frontend",
+  "platform/deploy-console/deploy-console-service",
+  "platform/integration-engine/integration-engine-service",
+];
+
+// ─── Feature Review Roles ────────────────────────────────────────────────────
+
+export const FEATURE_REVIEW_ROLES = [
+  "integration-tester",
+  "code-reviewer",
+  "security-auditor",
+  "health-monitor",
+];

package/lib/health-monitor.js

@@ -0,0 +1,113 @@
+// health-monitor.js — Periodic health checks for registered AgentProcesses.
+// Single setInterval(check, 30_000) replacing per-script timeout/RSS checks.
+
+import { EventEmitter } from "node:events";
+import { execSync } from "node:child_process";
+import {
+  HEALTH_CHECK_INTERVAL_MS,
+  RSS_CEILING_KB,
+  STUCK_THRESHOLD_MS,
+} from "./constants.js";
+
+export default class HealthMonitor extends EventEmitter {
+  constructor() {
+    super();
+    this._agents = new Map();  // key -> { agent, hardTimeoutMs, lastOutput }
+    this._timer = null;
+  }
+
+  /**
+   * Register an AgentProcess for monitoring.
+   * @param {AgentProcess} agent
+   * @param {object} opts
+   * @param {number} opts.hardTimeoutMs - Kill after this many ms
+   */
+  register(agent, { hardTimeoutMs } = {}) {
+    this._agents.set(agent.key, {
+      agent,
+      hardTimeoutMs: hardTimeoutMs || Infinity,
+      lastOutput: Date.now(),
+    });
+
+    // Track PTY output for stuck detection
+    if (agent.ptyProcess) {
+      agent.ptyProcess.onData(() => {
+        const entry = this._agents.get(agent.key);
+        if (entry) entry.lastOutput = Date.now();
+      });
+    }
+
+    // Auto-unregister on exit
+    agent.once("exit", () => this.unregister(agent.key));
+
+    if (!this._timer) this._start();
+  }
+
+  unregister(key) {
+    this._agents.delete(key);
+    if (this._agents.size === 0 && this._timer) {
+      clearInterval(this._timer);
+      this._timer = null;
+    }
+  }
+
+  _start() {
+    this._timer = setInterval(() => this._check(), HEALTH_CHECK_INTERVAL_MS);
+    // Don't prevent Node from exiting
+    this._timer.unref();
+  }
+
+  _check() {
+    const now = Date.now();
+
+    for (const [key, entry] of this._agents) {
+      const { agent, hardTimeoutMs, lastOutput } = entry;
+      if (agent.exited) continue;
+
+      const elapsed = agent.getElapsedMs();
+
+      // Hard timeout
+      if (elapsed > hardTimeoutMs) {
+        console.log(`[health] ${key}: hard timeout (${Math.round(elapsed / 1000)}s)`);
+        this.emit("timeout", { key, agent, elapsed });
+        continue;
+      }
+
+      // RSS check (only if we have a PID)
+      if (agent.pid) {
+        const rss = this._getRssKb(agent.pid);
+        if (rss > RSS_CEILING_KB) {
+          console.log(`[health] ${key}: OOM (${rss}KB > ${RSS_CEILING_KB}KB)`);
+          this.emit("oom", { key, agent, rssKb: rss });
+          continue;
+        }
+      }
+
+      // Stuck detection: no PTY output for >10 min
+      const silent = now - lastOutput;
+      if (silent > STUCK_THRESHOLD_MS) {
+        console.log(`[health] ${key}: stuck (no output for ${Math.round(silent / 1000)}s)`);
+        this.emit("stuck", { key, agent, silentMs: silent });
+        // Reset lastOutput so we don't re-fire every 30s
+        entry.lastOutput = now;
+      }
+    }
+  }
+
+  _getRssKb(pid) {
+    try {
+      const out = execSync(`ps -o rss= -p ${pid}`, { encoding: "utf-8", timeout: 3000 });
+      return parseInt(out.trim(), 10) || 0;
+    } catch {
+      return 0;
+    }
+  }
+
+  stop() {
+    if (this._timer) {
+      clearInterval(this._timer);
+      this._timer = null;
+    }
+    this._agents.clear();
+  }
+}