herdr-plugin-amq 0.1.7 → 0.1.9

package/src/fleet.mjs

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
-import { execFileSync, execSync } from "node:child_process";
+import { execFileSync } from "node:child_process";
 import { scanAgentBriefs } from "./briefs.mjs";
 import { ensureAgentWorktree } from "./worktrees.mjs";
 import { registerAgent, formatAgentTitle } from "./store.mjs";
@@ -173,145 +173,316 @@ export function buildFleetEnvPath() {
     process.env.PATH || "",
   ];
 
-  return Array.from(new Set(paths.filter(Boolean))).join(":");
+  return Array.from(new Set(paths.filter(Boolean))).join(path.delimiter);
 }
 
-/**
- * Launch or recover the agent fleet inside Herdr
- */
-export async function launchFleet(amqRoot, repoRoot, options = {}) {
-  const kind = options.kind || "agy";
-  const dryRun = Boolean(options.dryRun);
-  const timeoutMs = options.timeout || 25000;
-  const customArgs = options.args || (kind === "agy" ? ["--dangerously-skip-permissions"] : []);
-  const filterList = options.agents
-    ? (Array.isArray(options.agents) ? options.agents : options.agents.split(",")).map((s) => s.trim().toLowerCase())
-    : null;
+function filterPersonas(fleet, filter) {
+  if (!filter) return fleet;
+  const selected = new Set(
+    (Array.isArray(filter) ? filter : filter.split(","))
+      .map((value) => value.trim().toLowerCase())
+      .filter(Boolean),
+  );
+  return fleet.filter((agent) => selected.has(agent.handle.toLowerCase()));
+}
 
-  // 1. Prepopulate maildirs and worktrees
-  const fleet = prepopulateFleet(amqRoot, repoRoot);
-  const targetFleet = filterList ? fleet.filter((f) => filterList.includes(f.handle)) : fleet;
+function pathsMatch(left, right) {
+  if (!left || !right) return false;
+  try {
+    return fs.realpathSync(left) === fs.realpathSync(right);
+  } catch {
+    return path.resolve(left) === path.resolve(right);
+  }
+}
 
-  const result = {
-    total: targetFleet.length,
-    prepopulated: targetFleet.map((t) => t.handle),
-    alreadyRunning: [],
-    wouldLaunch: [],
-    launched: [],
-    failed: [],
-    dryRun,
-  };
+function matchingFleetPanes(agent, liveAgents) {
+  return liveAgents.filter((live) => (
+    live.name === agent.handle && pathsMatch(live.cwd, agent.worktree)
+  ));
+}
 
-  // 2. Check Herdr connectivity and live agents
-  let activeHandles = new Set();
-  try {
-    const liveAgents = await getHerdrAgents();
-    activeHandles = new Set(liveAgents.map((a) => a.name).filter(Boolean));
-  } catch {}
+function runHerdr(args, execHerdr) {
+  if (execHerdr) return execHerdr(args);
+  return execFileSync("herdr", args, { encoding: "utf8" });
+}
 
-  for (const agent of targetFleet) {
-    if (activeHandles.has(agent.handle)) {
-      result.alreadyRunning.push(agent.handle);
-    } else {
-      result.wouldLaunch.push(agent.handle);
-    }
-  }
+function waitFor(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 
-  if (dryRun) {
-    return result;
+export function defaultLaunchArgs(kind, handle) {
+  if (kind === "agy") return ["--dangerously-skip-permissions"];
+  if (kind === "opencode") return ["--agent", handle, "--auto"];
+  return [];
+}
+
+export function resolveExecutable(name, envPath = buildFleetEnvPath()) {
+  for (const dir of envPath.split(path.delimiter)) {
+    if (!dir) continue;
+    const candidate = path.join(dir, name);
+    try {
+      fs.accessSync(candidate, fs.constants.X_OK);
+      if (fs.statSync(candidate).isFile()) return fs.realpathSync(candidate);
+    } catch {}
   }
+  return null;
+}
 
-  // Determine Herdr workspace
-  let workspaceId = process.env.HERDR_WORKSPACE_ID || null;
-  if (!workspaceId) {
+function validModel(model) {
+  return typeof model === "string" && /^[^\s/]+\/[^\s/]+/.test(model) ? model : null;
+}
+
+export function readOpencodeModel(worktree) {
+  for (const relativePath of ["opencode.json", path.join(".opencode", "opencode.json")]) {
+    const configPath = path.join(worktree, relativePath);
     try {
-      const wsRaw = execFileSync("herdr", ["workspace", "list"], { encoding: "utf8" });
-      const wsJson = JSON.parse(wsRaw);
-      const workspaces = wsJson?.result?.workspaces || [];
-      const matched = workspaces.find((w) => w.cwd === repoRoot || w.label === path.basename(repoRoot));
-      workspaceId = matched ? matched.workspace_id : (workspaces[0]?.workspace_id || null);
+      const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+      const model = validModel(config.model);
+      if (model) return model;
     } catch {}
   }
+  return null;
+}
 
-  const safePath = buildFleetEnvPath();
+function shellQuote(value) {
+  return `'${String(value).replaceAll("'", "'\"'\"'")}'`;
+}
+
+export function createOpencodeLauncher(handle, model, executable) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "herdr-amq-opencode-"));
+  const binDir = path.join(root, handle.replace(/[^a-zA-Z0-9._-]/g, "_"));
+  fs.mkdirSync(binDir, { recursive: true });
+  const agentConfig = { mode: "all" };
+  const selectedModel = validModel(model);
+  if (selectedModel) agentConfig.model = selectedModel;
+  const config = JSON.stringify({ agent: { [handle]: agentConfig } });
+  const launcher = path.join(binDir, "opencode");
+  fs.writeFileSync(
+    launcher,
+    `#!/bin/sh\nexport OPENCODE_CONFIG_CONTENT=${shellQuote(config)}\nexec ${shellQuote(executable)} "$@"\n`,
+    { mode: 0o700 },
+  );
+  return { root, binDir, launcher, config };
+}
+
+export async function stopFleet(amqRoot, repoRoot, options = {}) {
+  const personas = discoverFleetPersonas(repoRoot);
+  const fleet = [...personas.values()].map((agent) => ({
+    ...agent,
+    worktree: path.join(repoRoot, ".worktrees", agent.handle),
+  }));
+  const targetFleet = filterPersonas(fleet, options.agents);
+  const kind = options.kind || null;
+  const dryRun = Boolean(options.dryRun);
+  const getLiveAgents = options.getLiveAgents || getHerdrAgents;
+  const execHerdr = options.execHerdr || null;
+  const liveAgents = await getLiveAgents();
+  const result = {
+    total: targetFleet.length,
+    stopped: [],
+    wouldStop: [],
+    skipped: [],
+    failed: [],
+    dryRun,
+  };
 
-  // 4. Launch each non-active agent into a tab
   for (const agent of targetFleet) {
-    const handle = agent.handle;
-    if (activeHandles.has(handle)) {
-      result.alreadyRunning.push(handle);
+    const panes = matchingFleetPanes(agent, liveAgents);
+    const selected = kind ? panes.filter((pane) => pane.agent === kind) : panes;
+    if (selected.length === 0) {
+      if (panes.length > 0) {
+        result.skipped.push({ handle: agent.handle, reason: `kind is ${panes.map((pane) => pane.agent).join(", ")}` });
+      }
       continue;
     }
-
-    try {
-      // Create tab in Herdr targeting worktree
-      const tabArgs = [
-        "tab",
-        "create",
-        "--cwd",
-        agent.worktree,
-        "--label",
-        handle,
-        "--env",
-        `PATH=${safePath}`,
-        "--no-focus",
-      ];
-      if (workspaceId) {
-        tabArgs.push("--workspace", workspaceId);
+    if (dryRun) {
+      result.wouldStop.push(...selected.map((pane) => ({ handle: agent.handle, paneId: pane.pane_id, kind: pane.agent })));
+      continue;
+    }
+    for (const pane of selected) {
+      try {
+        runHerdr(["pane", "close", pane.pane_id], execHerdr);
+        result.stopped.push({ handle: agent.handle, paneId: pane.pane_id, kind: pane.agent });
+      } catch (error) {
+        result.failed.push({ handle: agent.handle, paneId: pane.pane_id, error: error.message });
       }
+    }
+  }
 
-      const tabOut = execFileSync("herdr", tabArgs, { encoding: "utf8" });
-      const tabJson = JSON.parse(tabOut);
-      const paneId = tabJson?.result?.root_pane?.pane_id;
+  return result;
+}
 
-      if (!paneId) {
-        throw new Error(`Failed to acquire pane_id from herdr tab create: ${tabOut}`);
-      }
+/**
+ * Launch or recover the agent fleet inside Herdr
+ */
+export async function launchFleet(amqRoot, repoRoot, options = {}) {
+  const kind = options.kind || "agy";
+  const dryRun = Boolean(options.dryRun);
+  const timeoutMs = options.timeout || 25000;
+  const replace = options.replace !== false;
+  const prepopulate = options.prepopulate || prepopulateFleet;
+  const getLiveAgents = options.getLiveAgents || getHerdrAgents;
+  const execHerdr = options.execHerdr || null;
+  const sleep = options.sleep || waitFor;
+  const safePath = options.envPath || buildFleetEnvPath();
+  const configuredArgs = options.args == null
+    ? defaultLaunchArgs(kind, "")
+    : Array.isArray(options.args) ? options.args : [String(options.args)];
+  const fleet = prepopulate(amqRoot, repoRoot);
+  const targetFleet = filterPersonas(fleet, options.agents);
+  const result = {
+    total: targetFleet.length,
+    prepopulated: targetFleet.map((agent) => agent.handle),
+    alreadyRunning: [],
+    replaced: [],
+    wouldReplace: [],
+    wouldLaunch: [],
+    blocked: [],
+    launched: [],
+    failed: [],
+    dryRun,
+  };
+  const liveAgents = await getLiveAgents();
+  const launcherRoots = new Set();
+  let workspaceId = process.env.HERDR_WORKSPACE_ID || null;
+  let workspaceLookupAttempted = Boolean(workspaceId);
 
-      // Start the agent in the new pane with retry if the shell is still booting
-      const startArgs = [
-        "agent",
-        "start",
-        handle,
-        "--kind",
-        kind,
-        "--pane",
-        paneId,
-        "--timeout",
-        String(timeoutMs),
-      ];
-
-      if (customArgs.length > 0) {
-        startArgs.push("--", ...customArgs);
+  try {
+    for (const agent of targetFleet) {
+      const handle = agent.handle;
+      const panes = matchingFleetPanes(agent, liveAgents);
+      const matchingKind = panes.filter((pane) => pane.agent === kind);
+
+      if (matchingKind.length > 0) {
+        result.alreadyRunning.push(handle);
+        for (const duplicate of matchingKind.slice(1)) {
+          try {
+            runHerdr(["pane", "close", duplicate.pane_id], execHerdr);
+          } catch (error) {
+            result.failed.push({ handle, error: error.message });
+          }
+        }
+        continue;
       }
 
-      let started = false;
-      let lastErr = null;
-      for (let attempt = 0; attempt < 5; attempt++) {
+      if (panes.length > 0) {
+        if (dryRun) {
+          result.wouldReplace.push(handle);
+          continue;
+        }
+        if (!replace) {
+          result.blocked.push({ handle, reason: `already running as ${panes.map((pane) => pane.agent).join(", ")}` });
+          continue;
+        }
         try {
-          if (attempt === 0) {
-            await new Promise((r) => setTimeout(r, 800));
-          } else {
-            await new Promise((r) => setTimeout(r, 1200));
-          }
-          execFileSync("herdr", startArgs, { encoding: "utf8" });
-          started = true;
-          result.launched.push({ handle, paneId, kind });
-          break;
-        } catch (err) {
-          lastErr = err;
-          if (err.message && err.message.includes("agent_pane_busy")) {
-            continue;
+          for (const pane of panes) {
+            runHerdr(["pane", "close", pane.pane_id], execHerdr);
           }
-          break;
+          await sleep(300);
+          result.replaced.push({
+            handle,
+            fromKinds: panes.map((pane) => pane.agent),
+            paneIds: panes.map((pane) => pane.pane_id),
+          });
+        } catch (error) {
+          result.failed.push({ handle, error: error.message });
+          continue;
         }
       }
 
-      if (!started) {
-        result.failed.push({ handle, error: lastErr?.message || "Failed to start agent" });
+      if (dryRun) {
+        result.wouldLaunch.push(handle);
+        continue;
       }
-    } catch (err) {
-      result.failed.push({ handle, error: err.message });
+
+      if (!workspaceLookupAttempted) {
+        workspaceLookupAttempted = true;
+        try {
+          const workspaceOutput = runHerdr(["workspace", "list"], execHerdr);
+          const workspaceJson = JSON.parse(workspaceOutput);
+          const workspaces = workspaceJson?.result?.workspaces || [];
+          const matched = workspaces.find((workspace) => workspace.cwd === repoRoot || workspace.label === path.basename(repoRoot));
+          workspaceId = matched ? matched.workspace_id : (workspaces[0]?.workspace_id || null);
+        } catch {}
+      }
+
+      let paneId;
+      try {
+        let launchPath = safePath;
+        if (kind === "opencode") {
+          const executable = options.opencodeExecutable || resolveExecutable("opencode", safePath);
+          if (!executable) throw new Error("OpenCode executable not found in fleet PATH");
+          const createLauncher = options.createOpencodeLauncher || createOpencodeLauncher;
+          const launcher = createLauncher(handle, readOpencodeModel(agent.worktree), executable);
+          launcherRoots.add(launcher.root);
+          launchPath = `${launcher.binDir}${path.delimiter}${safePath}`;
+        }
+
+        const tabArgs = [
+          "tab",
+          "create",
+          "--cwd",
+          agent.worktree,
+          "--label",
+          handle,
+          "--env",
+          `PATH=${launchPath}`,
+          "--no-focus",
+        ];
+        if (workspaceId) tabArgs.push("--workspace", workspaceId);
+        const tabOutput = runHerdr(tabArgs, execHerdr);
+        const tabJson = JSON.parse(tabOutput);
+        paneId = tabJson?.result?.root_pane?.pane_id;
+        if (!paneId) throw new Error(`Failed to acquire pane_id from herdr tab create: ${tabOutput}`);
+
+        const startArgs = [
+          "agent",
+          "start",
+          handle,
+          "--kind",
+          kind,
+          "--pane",
+          paneId,
+          "--timeout",
+          String(timeoutMs),
+        ];
+        const launchArgs = kind === "opencode" && options.args == null
+          ? defaultLaunchArgs(kind, handle)
+          : configuredArgs;
+        if (launchArgs.length > 0) startArgs.push("--", ...launchArgs);
+
+        let started = false;
+        let lastError = null;
+        for (let attempt = 0; attempt < 5; attempt++) {
+          try {
+            await sleep(attempt === 0 ? 800 : 1200);
+            runHerdr(startArgs, execHerdr);
+            started = true;
+            result.launched.push({ handle, paneId, kind });
+            break;
+          } catch (error) {
+            lastError = error;
+            if (error.message && error.message.includes("agent_pane_busy")) continue;
+            break;
+          }
+        }
+        if (!started) {
+          throw lastError || new Error("Failed to start agent");
+        }
+      } catch (error) {
+        result.failed.push({ handle, error: error.message || String(error) });
+        if (paneId) {
+          try {
+            runHerdr(["pane", "close", paneId], execHerdr);
+          } catch {}
+        }
+      }
+    }
+  } finally {
+    for (const root of launcherRoots) {
+      try {
+        fs.rmSync(root, { recursive: true, force: true });
+      } catch {}
     }
   }
 

package/src/herdr.mjs

@@ -11,9 +11,9 @@
  */
 
 import net from "node:net";
-import { execSync } from "node:child_process";
 import os from "node:os";
 import path from "node:path";
+import { getOpenCodeSessionModels, resolveRuntimeModel } from "./runtime-models.mjs";
 
 // ─── Socket Path Resolution ──────────────────────────────────────────────────
 
@@ -108,24 +108,78 @@ export async function getHerdrAgents() {
  */
 export async function getHerdrStatusMap() {
   const agents = await getHerdrAgents();
+  const observedAt = new Date().toISOString();
+  const sessionModels = getOpenCodeSessionModels(agents);
   const map = new Map();
-  for (const a of agents) {
-    const handle = a.name; // e.g. "ballistics", "testkit"
-    if (handle) {
-      map.set(handle, {
-        herdrStatus: a.agent_status || "unknown",
-        herdrPaneId: a.pane_id,
-        herdrWorkspaceId: a.workspace_id,
-        herdrTabId: a.tab_id,
-        herdrTitle: a.terminal_title_stripped || a.terminal_title,
-        interactiveReady: a.interactive_ready || false,
-        agentType: a.agent,
-      });
-    }
+  for (const agent of agents) {
+    const activity = mapHerdrAgentActivity(agent, observedAt, resolveRuntimeModel(agent, sessionModels));
+    if (activity) map.set(activity.herdrHandle, activity);
   }
   return map;
 }
 
+export function normalizeHerdrStatus(value) {
+  const status = String(value || "").trim().toLowerCase();
+  if (status === "online" || status === "active") return "idle";
+  if (["idle", "working", "blocked", "done", "error", "unknown"].includes(status)) return status;
+  return "unknown";
+}
+
+function herdrText(value) {
+  if (typeof value === "string") return value.trim();
+  if (!value || typeof value !== "object") return "";
+  for (const key of ["text", "label", "title", "value"]) {
+    if (typeof value[key] === "string" && value[key].trim()) return value[key].trim();
+  }
+  return "";
+}
+
+function herdrStateLabels(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const result = {};
+  for (const [status, label] of Object.entries(value)) {
+    const text = herdrText(label);
+    if (text) result[status] = text;
+  }
+  return result;
+}
+
+function herdrTokens(value) {
+  const values = Array.isArray(value) ? value : value ? [value] : [];
+  return values.map(herdrText).filter(Boolean);
+}
+
+export function mapHerdrAgentActivity(agent, observedAt = new Date().toISOString(), runtime = null) {
+  const handle = herdrText(agent?.name);
+  if (!handle) return null;
+  const status = normalizeHerdrStatus(agent?.agent_status);
+  const terminalTitle = herdrText(agent?.terminal_title_stripped) || herdrText(agent?.terminal_title);
+  const metadataTitle = herdrText(agent?.title);
+  const model = runtime || resolveRuntimeModel(agent);
+  return {
+    herdrHandle: handle,
+    herdrStatus: status,
+    herdrPaneId: herdrText(agent?.pane_id),
+    herdrWorkspaceId: herdrText(agent?.workspace_id),
+    herdrTabId: herdrText(agent?.tab_id),
+    herdrTerminalId: herdrText(agent?.terminal_id),
+    herdrTitle: terminalTitle || metadataTitle,
+    herdrTerminalTitle: terminalTitle,
+    herdrMetadataTitle: metadataTitle,
+    herdrStateLabels: herdrStateLabels(agent?.state_labels),
+    herdrTokens: herdrTokens(agent?.tokens),
+    herdrStateChangeSeq: Number.isFinite(agent?.state_change_seq) ? agent.state_change_seq : null,
+    interactiveReady: Boolean(agent?.interactive_ready),
+    herdrFocused: Boolean(agent?.focused),
+    herdrLaunchPending: Boolean(agent?.launch_pending),
+    agentType: herdrText(agent?.agent),
+    herdrSessionId: model.sessionId || null,
+    herdrModel: model.model || null,
+    herdrModelSource: model.source || null,
+    herdrObservedAt: observedAt,
+  };
+}
+
 // ─── Long-lived event subscription ──────────────────────────────────────────
 
 /**

package/src/index.mjs

@@ -7,3 +7,4 @@ export * from "./migration.mjs";
 export * from "./briefs.mjs";
 export * from "./worktrees.mjs";
 export * from "./fleet.mjs";
+export * from "./templates.mjs";