@virtengine/openfleet 0.25.0

package/workspace-reaper.mjs

@@ -0,0 +1,405 @@
+import { execSync } from "node:child_process";
+import { existsSync, statSync, readFileSync } from "node:fs";
+import { readdir, rm, stat } from "node:fs/promises";
+import { resolve } from "node:path";
+import {
+  loadSharedWorkspaceRegistry,
+  saveSharedWorkspaceRegistry,
+  sweepExpiredLeases,
+} from "./shared-workspace-registry.mjs";
+
+/**
+ * workspace-reaper.mjs
+ *
+ * Cleans up expired workspace leases and orphaned git worktrees after crashes.
+ * Implements safety checks to avoid deleting active workspaces.
+ */
+
+const DEFAULT_ORPHAN_THRESHOLD_HOURS = 24;
+const DEFAULT_AGGRESSIVE_THRESHOLD_HOURS = 1; // For completed task cleanup
+const DEFAULT_PROCESS_CHECK_RETRIES = 3;
+const IS_WINDOWS = process.platform === "win32";
+
+function buildGitEnv() {
+  const env = { ...process.env };
+  delete env.GIT_DIR;
+  delete env.GIT_WORK_TREE;
+  delete env.GIT_INDEX_FILE;
+  return env;
+}
+
+function ensureIso(date) {
+  return new Date(date).toISOString();
+}
+
+/**
+ * Check if a process is running by PID
+ */
+function isProcessRunning(pid) {
+  if (!Number.isFinite(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Extract PIDs from common lock files or process indicators
+ */
+function extractPidsFromPath(worktreePath) {
+  const pids = new Set();
+  const lockPaths = [
+    resolve(worktreePath, ".git", "index.lock"),
+    resolve(worktreePath, ".openfleet.pid"),
+    resolve(worktreePath, ".vk-executor.pid"),
+  ];
+  for (const lockPath of lockPaths) {
+    if (!existsSync(lockPath)) continue;
+    try {
+      const content = readFileSync(lockPath, "utf8").trim();
+      const pidMatch = /^\d+$/.test(content) ? Number(content) : null;
+      if (pidMatch && pidMatch > 0) {
+        pids.add(pidMatch);
+      }
+    } catch {
+      // Ignore errors reading lock files
+    }
+  }
+  return Array.from(pids);
+}
+
+/**
+ * Cross-platform sleep
+ */
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Check if a worktree path has any active processes
+ */
+async function hasActiveProcesses(worktreePath, options = {}) {
+  const retries = options.retries || DEFAULT_PROCESS_CHECK_RETRIES;
+  const pids = extractPidsFromPath(worktreePath);
+  if (pids.length === 0) return false;
+  
+  for (let i = 0; i < retries; i++) {
+    for (const pid of pids) {
+      if (isProcessRunning(pid)) {
+        return true;
+      }
+    }
+    if (i < retries - 1) {
+      // Wait a bit before retry
+      await sleep(1000);
+    }
+  }
+  return false;
+}
+
+/**
+ * Get last modified time of most recently modified file in directory
+ */
+async function getLastModifiedTime(dirPath) {
+  try {
+    if (!existsSync(dirPath)) return null;
+    let latestMtime = null;
+    const entries = await readdir(dirPath, { withFileTypes: true, recursive: false });
+    for (const entry of entries) {
+      if (entry.name === ".git") {
+        continue;
+      }
+      const fullPath = resolve(dirPath, entry.name);
+      try {
+        const stats = await stat(fullPath);
+        if (!latestMtime || stats.mtime > latestMtime) {
+          latestMtime = stats.mtime;
+        }
+      } catch {
+        // Ignore errors on individual files
+      }
+    }
+    return latestMtime;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if a worktree is truly orphaned (safe to delete)
+ */
+async function isWorktreeOrphaned(worktreePath, options = {}) {
+  const now = options.now ? new Date(options.now) : new Date();
+  const thresholdHours = options.orphanThresholdHours || DEFAULT_ORPHAN_THRESHOLD_HOURS;
+  
+  // Safety check 1: Path must exist
+  if (!existsSync(worktreePath)) {
+    return { orphaned: false, reason: "path_not_found" };
+  }
+  
+  // Safety check 2: No active processes
+  if (await hasActiveProcesses(worktreePath, options)) {
+    return { orphaned: false, reason: "active_process" };
+  }
+  
+  // Safety check 3: Check last modified time
+  const lastModified = await getLastModifiedTime(worktreePath);
+  if (lastModified) {
+    const ageHours = (now.getTime() - lastModified.getTime()) / (1000 * 60 * 60);
+    if (ageHours < thresholdHours) {
+      return { orphaned: false, reason: "recently_modified", ageHours };
+    }
+  }
+  
+  // Safety check 4: Check git status for uncommitted work
+  // Only check git status if .git is a FILE (proper worktree), not a directory
+  const gitPath = resolve(worktreePath, ".git");
+  const isProperWorktree = existsSync(gitPath) && !statSync(gitPath).isDirectory();
+
+  if (isProperWorktree) {
+    try {
+      const cmd = IS_WINDOWS
+        ? `cd /d "${worktreePath}" && git status --porcelain`
+        : `cd "${worktreePath}" && git status --porcelain`;
+      const gitStatus = execSync(cmd, {
+        encoding: "utf8",
+        env: buildGitEnv(),
+        stdio: ["pipe", "pipe", "ignore"],
+      }).trim();
+      if (gitStatus.length > 0) {
+        return { orphaned: false, reason: "uncommitted_changes" };
+      }
+    } catch {
+      // If git command fails, worktree might be corrupted - consider orphaned
+    }
+  }
+
+  return { orphaned: true, lastModified, ageHours: lastModified ? (now.getTime() - lastModified.getTime()) / (1000 * 60 * 60) : null };
+}
+
+/**
+ * Find git worktrees in a given directory
+ */
+async function findGitWorktrees(searchPath) {
+  const worktrees = [];
+  try {
+    if (!existsSync(searchPath)) return worktrees;
+    const entries = await readdir(searchPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const fullPath = resolve(searchPath, entry.name);
+      const gitPath = resolve(fullPath, ".git");
+      if (existsSync(gitPath)) {
+        worktrees.push({
+          path: fullPath,
+          name: entry.name,
+        });
+      }
+    }
+  } catch (err) {
+    console.warn(`[workspace-reaper] failed to scan ${searchPath}: ${err.message || err}`);
+  }
+  return worktrees;
+}
+
+/**
+ * Clean orphaned worktrees with safety checks
+ */
+export async function cleanOrphanedWorktrees(options = {}) {
+  const now = options.now ? new Date(options.now) : new Date();
+  const searchPaths = Array.isArray(options.searchPaths)
+    ? options.searchPaths
+    : [process.env.VK_WORKTREE_BASE || "/tmp/vibe-kanban/worktrees"];
+  
+  const results = {
+    scanned: 0,
+    cleaned: 0,
+    skipped: 0,
+    errors: [],
+    cleaned_paths: [],
+    skipped_reasons: {},
+  };
+  
+  for (const searchPath of searchPaths) {
+    const worktrees = await findGitWorktrees(searchPath);
+    for (const worktree of worktrees) {
+      results.scanned++;
+      const orphanCheck = await isWorktreeOrphaned(worktree.path, options);
+      
+      if (!orphanCheck.orphaned) {
+        results.skipped++;
+        const reason = orphanCheck.reason || "unknown";
+        results.skipped_reasons[reason] = (results.skipped_reasons[reason] || 0) + 1;
+        continue;
+      }
+      
+      // Safe to delete
+      if (options.dryRun) {
+        results.cleaned_paths.push({
+          path: worktree.path,
+          dryRun: true,
+          ageHours: orphanCheck.ageHours,
+        });
+        results.cleaned++;
+        continue;
+      }
+      
+      try {
+        await rm(worktree.path, { recursive: true, force: true });
+        results.cleaned++;
+        results.cleaned_paths.push({
+          path: worktree.path,
+          ageHours: orphanCheck.ageHours,
+          cleanedAt: ensureIso(now),
+        });
+      } catch (err) {
+        results.errors.push({
+          path: worktree.path,
+          error: err.message || String(err),
+        });
+      }
+    }
+  }
+  
+  return results;
+}
+
+/**
+ * Prune git worktree metadata
+ * Removes stale entries from .git/worktrees/
+ */
+export async function pruneWorktreeMetadata(repoPath, options = {}) {
+  const results = {
+    pruned: 0,
+    errors: [],
+  };
+
+  try {
+    const gitEnv = buildGitEnv();
+    execSync('git worktree prune', {
+      cwd: repoPath,
+      stdio: options.verbose ? 'inherit' : 'pipe',
+      env: { ...gitEnv, GIT_EDITOR: ':', GIT_MERGE_AUTOEDIT: 'no' },
+    });
+    results.pruned++;
+  } catch (err) {
+    results.errors.push(err.message || String(err));
+  }
+
+  return results;
+}
+
+/**
+ * Get worktree count for monitoring
+ */
+export async function getWorktreeCount(repoPath) {
+  try {
+    const gitEnv = buildGitEnv();
+    const output = execSync('git worktree list --porcelain', {
+      cwd: repoPath,
+      encoding: 'utf8',
+      env: gitEnv,
+    });
+    // Count "worktree" lines (one per worktree including main)
+    const count = (output.match(/^worktree /gm) || []).length;
+    return count - 1; // Subtract 1 for main worktree
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Run full reaper sweep: expired leases + orphaned worktrees
+ */
+export async function runReaperSweep(options = {}) {
+  const now = options.now ? new Date(options.now) : new Date();
+  const results = {
+    timestamp: ensureIso(now),
+    leases: {
+      expired: 0,
+      cleaned: 0,
+      errors: [],
+    },
+    worktrees: {
+      scanned: 0,
+      cleaned: 0,
+      skipped: 0,
+      errors: [],
+    },
+  };
+  
+  // Step 1: Sweep expired leases
+  try {
+    const leaseResult = await sweepExpiredLeases({ ...options, now });
+    results.leases.expired = leaseResult.expired?.length || 0;
+    results.leases.cleaned = leaseResult.expired?.length || 0;
+  } catch (err) {
+    results.leases.errors.push(err.message || String(err));
+  }
+  
+  // Step 2: Clean orphaned worktrees
+  try {
+    const worktreeResult = await cleanOrphanedWorktrees({ ...options, now });
+    results.worktrees.scanned = worktreeResult.scanned;
+    results.worktrees.cleaned = worktreeResult.cleaned;
+    results.worktrees.skipped = worktreeResult.skipped;
+    results.worktrees.errors = worktreeResult.errors || [];
+    results.worktrees.skipped_reasons = worktreeResult.skipped_reasons || {};
+    results.worktrees.cleaned_paths = worktreeResult.cleaned_paths || [];
+  } catch (err) {
+    results.worktrees.errors.push({ error: err.message || String(err) });
+  }
+  
+  return results;
+}
+
+/**
+ * Format reaper results for logging
+ */
+export function formatReaperResults(results) {
+  const lines = [];
+  lines.push(`[workspace-reaper] Sweep completed at ${results.timestamp}`);
+  
+  if (results.leases) {
+    lines.push(`  Leases: ${results.leases.expired} expired, ${results.leases.cleaned} cleaned`);
+    if (results.leases.errors.length > 0) {
+      lines.push(`  Lease errors: ${results.leases.errors.length}`);
+    }
+  }
+  
+  if (results.worktrees) {
+    lines.push(
+      `  Worktrees: ${results.worktrees.scanned} scanned, ${results.worktrees.cleaned} cleaned, ${results.worktrees.skipped} skipped`,
+    );
+    if (results.worktrees.skipped_reasons) {
+      for (const [reason, count] of Object.entries(results.worktrees.skipped_reasons)) {
+        lines.push(`    - ${reason}: ${count}`);
+      }
+    }
+    if (results.worktrees.errors.length > 0) {
+      lines.push(`  Worktree errors: ${results.worktrees.errors.length}`);
+    }
+  }
+  
+  return lines.join("\n");
+}
+
+/**
+ * Calculate reaper metrics for monitoring
+ */
+export function calculateReaperMetrics(results) {
+  return {
+    timestamp: results.timestamp,
+    leases_expired: results.leases?.expired || 0,
+    leases_cleaned: results.leases?.cleaned || 0,
+    lease_errors: results.leases?.errors?.length || 0,
+    worktrees_scanned: results.worktrees?.scanned || 0,
+    worktrees_cleaned: results.worktrees?.cleaned || 0,
+    worktrees_skipped: results.worktrees?.skipped || 0,
+    worktree_errors: results.worktrees?.errors?.length || 0,
+    total_cleaned: (results.leases?.cleaned || 0) + (results.worktrees?.cleaned || 0),
+    total_errors: (results.leases?.errors?.length || 0) + (results.worktrees?.errors?.length || 0),
+  };
+}

package/workspace-registry.mjs

@@ -0,0 +1,238 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = resolve(fileURLToPath(new URL(".", import.meta.url)));
+
+const DEFAULT_REGISTRY = {
+  version: 1,
+  default_workspace: "primary",
+  workspaces: [
+    {
+      id: "primary",
+      name: "Primary Coordinator",
+      host: "localhost",
+      role: "coordinator",
+      capabilities: ["planning", "triage", "routing"],
+      model_priorities: ["CODEX:DEFAULT"],
+      vk_workspace_id: "primary",
+      mentions: ["primary", "coord", "coordinator"],
+    },
+  ],
+};
+
+function normalizeId(value) {
+  return String(value || "")
+    .trim()
+    .toLowerCase();
+}
+
+function normalizeExecutorProfile(profile) {
+  if (!profile) return null;
+  if (typeof profile === "string") {
+    const [executor, variant] = profile.split(":");
+    if (!executor) return null;
+    return {
+      executor: executor.trim().toUpperCase(),
+      variant: (variant || "DEFAULT").trim().toUpperCase(),
+    };
+  }
+  if (profile.executor && profile.variant) {
+    return {
+      executor: String(profile.executor).toUpperCase(),
+      variant: String(profile.variant).toUpperCase(),
+    };
+  }
+  if (profile.executor_profile_id) {
+    return normalizeExecutorProfile(profile.executor_profile_id);
+  }
+  return null;
+}
+
+function normalizeWorkspace(workspace) {
+  if (!workspace) return null;
+  const id = normalizeId(workspace.id);
+  if (!id) return null;
+  const mentions = Array.isArray(workspace.mentions)
+    ? workspace.mentions.map(normalizeId).filter(Boolean)
+    : [];
+  const aliases = Array.isArray(workspace.aliases)
+    ? workspace.aliases.map(normalizeId).filter(Boolean)
+    : [];
+  return {
+    ...workspace,
+    id,
+    mentions,
+    aliases,
+    role: workspace.role || "workspace",
+    model_priorities: Array.isArray(workspace.model_priorities)
+      ? workspace.model_priorities
+      : [],
+  };
+}
+
+export async function loadWorkspaceRegistry(options = {}) {
+  const registryPath = options.registryPath
+    ? resolve(options.registryPath)
+    : resolve(__dirname, "workspaces.json");
+  let registry = null;
+  const errors = [];
+  const warnings = [];
+  if (existsSync(registryPath)) {
+    try {
+      const raw = await readFile(registryPath, "utf8");
+      registry = JSON.parse(raw);
+    } catch (err) {
+      errors.push(`Failed to read ${registryPath}: ${err.message || err}`);
+      console.warn(
+        `[workspace-registry] failed to read ${registryPath}: ${err.message || err}`,
+      );
+    }
+  } else {
+    warnings.push(`Registry file not found: ${registryPath} — using defaults`);
+  }
+  if (!registry) {
+    registry = { ...DEFAULT_REGISTRY };
+  }
+
+  const workspaces = Array.isArray(registry.workspaces)
+    ? registry.workspaces.map(normalizeWorkspace).filter(Boolean)
+    : [];
+  const defaultWorkspace =
+    normalizeId(registry.default_workspace) ||
+    DEFAULT_REGISTRY.default_workspace;
+
+  if (workspaces.length === 0) {
+    warnings.push("No workspaces configured — using built-in defaults");
+  }
+
+  return {
+    registry: {
+      version: registry.version || DEFAULT_REGISTRY.version,
+      default_workspace: defaultWorkspace,
+      workspaces,
+      registry_path: registryPath,
+    },
+    // Also spread top-level for backward compat
+    version: registry.version || DEFAULT_REGISTRY.version,
+    default_workspace: defaultWorkspace,
+    workspaces,
+    registry_path: registryPath,
+    errors,
+    warnings,
+  };
+}
+
+export function resolveWorkspace(registry, candidateId) {
+  if (!registry || !Array.isArray(registry.workspaces)) return null;
+  const target = normalizeId(candidateId);
+  if (!target) return null;
+  return (
+    registry.workspaces.find((w) => w.id === target) ||
+    registry.workspaces.find((w) => w.aliases?.includes(target)) ||
+    registry.workspaces.find((w) => w.mentions?.includes(target)) ||
+    null
+  );
+}
+
+export function getLocalWorkspace(registry, envWorkspaceId) {
+  if (!registry || !Array.isArray(registry.workspaces)) return null;
+  const explicit = normalizeId(envWorkspaceId);
+  const defaultId = registry.default_workspace;
+  const id = explicit || defaultId || "primary";
+  return (
+    resolveWorkspace(registry, id) ||
+    registry.workspaces[0] ||
+    normalizeWorkspace({ id })
+  );
+}
+
+export function listWorkspaceIds(registry) {
+  if (!registry || !Array.isArray(registry.workspaces)) return [];
+  return registry.workspaces.map((w) => w.id);
+}
+
+export function selectExecutorProfile(workspace, override) {
+  const overrideProfile = normalizeExecutorProfile(override);
+  if (overrideProfile) {
+    return overrideProfile;
+  }
+  if (!workspace) {
+    return { executor: "CODEX", variant: "DEFAULT" };
+  }
+  for (const entry of workspace.model_priorities || []) {
+    const profile = normalizeExecutorProfile(entry);
+    if (profile) return profile;
+  }
+  return { executor: "CODEX", variant: "DEFAULT" };
+}
+
+export function parseWorkspaceMentions(text, registry) {
+  const targets = new Set();
+  const normalizedText = String(text || "");
+  const mentionMatches = normalizedText.matchAll(/@([A-Za-z0-9_-]+)/g);
+  for (const match of mentionMatches) {
+    const id = match[1];
+    if (id && id.toLowerCase() === "all") {
+      return { targets, broadcast: true };
+    }
+    const workspace = resolveWorkspace(registry, id);
+    if (workspace) {
+      targets.add(workspace.id);
+    }
+  }
+  const prefixMatches = normalizedText.matchAll(/\[ws:([A-Za-z0-9_-]+)\]/gi);
+  for (const match of prefixMatches) {
+    const id = match[1];
+    if (id && id.toLowerCase() === "all") {
+      return { targets, broadcast: true };
+    }
+    const workspace = resolveWorkspace(registry, id);
+    if (workspace) {
+      targets.add(workspace.id);
+    }
+  }
+  return { targets, broadcast: false };
+}
+
+export function stripWorkspaceMentions(text, registry) {
+  const ids = listWorkspaceIds(registry);
+  if (!ids.length) return String(text || "").trim();
+  let result = String(text || "");
+  for (const id of ids) {
+    const mention = new RegExp(`@${id}\\b`, "gi");
+    const prefix = new RegExp(`\\[ws:${id}\\]`, "gi");
+    result = result.replace(mention, "").replace(prefix, "");
+  }
+  return result.replace(/\s{2,}/g, " ").trim();
+}
+
+export function formatBusMessage({ workspaceId, type, text }) {
+  const prefixId = workspaceId || "unknown";
+  const typeTag = type ? `[${type}]` : "";
+  const prefix = `[ws:${prefixId}]${typeTag}`;
+  const lines = String(text || "").split(/\r?\n/);
+  if (lines.length === 0) {
+    return `${prefix}`;
+  }
+  lines[0] = `${prefix} ${lines[0]}`.trim();
+  return lines.join("\n");
+}
+
+export function formatRegistryDiagnostics(errors, warnings) {
+  const parts = [];
+  if (errors && errors.length > 0) {
+    parts.push(
+      `❌ Registry errors:\n${errors.map((e) => `  • ${e}`).join("\n")}`,
+    );
+  }
+  if (warnings && warnings.length > 0) {
+    parts.push(`⚠️ ${warnings.map((w) => w).join("\n⚠️ ")}`);
+  }
+  return parts.length > 0 ? parts.join("\n") : null;
+}
+
+export function getDefaultModelPriority() {
+  return ["CODEX:DEFAULT", "COPILOT:CLAUDE_OPUS_4_6"];
+}