@virtengine/openfleet 0.25.0

package/presence.mjs

@@ -0,0 +1,328 @@
+import { execSync } from "node:child_process";
+import crypto from "node:crypto";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import os from "node:os";
+import { resolve } from "node:path";
+
+const PRESENCE_PREFIX = "[ve-presence]";
+const PRESENCE_VERSION = 1;
+const INSTANCE_ID_FILENAME = "instance-id.json";
+const PRESENCE_FILENAME = "presence.json";
+
+const state = {
+  initialized: false,
+  repoRoot: null,
+  presencePath: null,
+  instanceId: null,
+  startedAt: new Date().toISOString(),
+  localWorkspace: null,
+  localMeta: null,
+  instances: new Map(),
+};
+
+function safeParseNumber(value, fallback) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+async function ensurePresenceDir(repoRoot) {
+  const dir = resolve(repoRoot, ".cache", "openfleet");
+  await mkdir(dir, { recursive: true });
+  return dir;
+}
+
+async function loadOrCreateInstanceId(repoRoot, explicitId) {
+  if (explicitId) {
+    return String(explicitId).trim();
+  }
+  const dir = await ensurePresenceDir(repoRoot);
+  const idPath = resolve(dir, INSTANCE_ID_FILENAME);
+  if (existsSync(idPath)) {
+    try {
+      const raw = await readFile(idPath, "utf8");
+      const parsed = JSON.parse(raw);
+      if (parsed?.instance_id) {
+        return String(parsed.instance_id).trim();
+      }
+    } catch {
+      // best effort
+    }
+  }
+  const host = os.hostname() || "host";
+  const suffix = crypto.randomUUID().slice(0, 8);
+  const newId = `${host}-${suffix}`;
+  await writeFile(
+    idPath,
+    JSON.stringify({ instance_id: newId, created_at: new Date().toISOString() }, null, 2),
+    "utf8",
+  );
+  return newId;
+}
+
+function readGitInfo(repoRoot) {
+  const info = { git_branch: null, git_sha: null };
+  try {
+    const branch = execSync("git rev-parse --abbrev-ref HEAD", {
+      cwd: repoRoot,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    });
+    info.git_branch = branch.trim();
+  } catch {
+    // ignore
+  }
+  try {
+    const sha = execSync("git rev-parse --short HEAD", {
+      cwd: repoRoot,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    });
+    info.git_sha = sha.trim();
+  } catch {
+    // ignore
+  }
+  return info;
+}
+
+function buildLocalMeta() {
+  const envLabel = process.env.VE_INSTANCE_LABEL || "";
+  const priority = safeParseNumber(
+    process.env.VE_COORDINATOR_PRIORITY,
+    null,
+  );
+  const eligibleRaw = process.env.VE_COORDINATOR_ELIGIBLE;
+  const eligible =
+    eligibleRaw === undefined
+      ? true
+      : !["0", "false", "no"].includes(String(eligibleRaw).toLowerCase());
+
+  const workspace = state.localWorkspace || {};
+  const role = workspace.role || "workspace";
+  const basePriority = role === "coordinator" ? 10 : 100;
+
+  return {
+    v: PRESENCE_VERSION,
+    instance_id: state.instanceId,
+    instance_label: envLabel || workspace.name || null,
+    workspace_id: workspace.id || null,
+    workspace_role: role,
+    coordinator_priority: Number.isFinite(priority) ? priority : basePriority,
+    coordinator_eligible: eligible,
+    capabilities: Array.isArray(workspace.capabilities)
+      ? workspace.capabilities
+      : [],
+    host: os.hostname(),
+    platform: os.platform(),
+    arch: os.arch(),
+    node: process.version,
+    pid: process.pid,
+    started_at: state.startedAt,
+  };
+}
+
+async function loadPresenceRegistry() {
+  if (!state.presencePath || !existsSync(state.presencePath)) {
+    return;
+  }
+  try {
+    const raw = await readFile(state.presencePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed?.instances)) {
+      for (const entry of parsed.instances) {
+        if (entry?.instance_id) {
+          state.instances.set(String(entry.instance_id), entry);
+        }
+      }
+    }
+  } catch {
+    // ignore
+  }
+}
+
+async function persistPresenceRegistry() {
+  if (!state.presencePath) return;
+  const instances = [...state.instances.values()];
+  const payload = {
+    updated_at: new Date().toISOString(),
+    instances,
+  };
+  await writeFile(state.presencePath, JSON.stringify(payload, null, 2), "utf8");
+}
+
+function normalizePresencePayload(payload) {
+  if (!payload || !payload.instance_id) return null;
+  return {
+    ...payload,
+    instance_id: String(payload.instance_id),
+    workspace_id: payload.workspace_id ? String(payload.workspace_id) : null,
+    workspace_role: payload.workspace_role || payload.role || null,
+    coordinator_priority: safeParseNumber(payload.coordinator_priority, 100),
+    coordinator_eligible:
+      payload.coordinator_eligible === undefined ? true : !!payload.coordinator_eligible,
+  };
+}
+
+export async function initPresence(options = {}) {
+  const forceReset = options.force || process.env.VITEST;
+  if (state.initialized && !forceReset) return state;
+  if (forceReset) {
+    state.initialized = false;
+    state.repoRoot = null;
+    state.presencePath = null;
+    state.instanceId = null;
+    state.startedAt = new Date().toISOString();
+    state.localWorkspace = null;
+    state.localMeta = null;
+    state.instances = new Map();
+  }
+  state.repoRoot = options.repoRoot || process.cwd();
+  state.presencePath =
+    options.presencePath ||
+    resolve(state.repoRoot, ".cache", "openfleet", PRESENCE_FILENAME);
+  state.localWorkspace = options.localWorkspace || null;
+  state.instanceId = await loadOrCreateInstanceId(
+    state.repoRoot,
+    options.instanceId || process.env.VE_INSTANCE_ID,
+  );
+  state.localMeta = buildLocalMeta();
+  await ensurePresenceDir(state.repoRoot);
+  const shouldLoadRegistry =
+    options.loadRegistry ?? (!options.skipLoad && !process.env.VITEST);
+  if (shouldLoadRegistry) {
+    await loadPresenceRegistry();
+  }
+  state.initialized = true;
+  return state;
+}
+
+export function getPresencePrefix() {
+  return PRESENCE_PREFIX;
+}
+
+export function formatPresenceMessage(payload) {
+  return `${PRESENCE_PREFIX} ${JSON.stringify(payload)}`;
+}
+
+export function parsePresenceMessage(text) {
+  const raw = String(text || "");
+  const idx = raw.indexOf(PRESENCE_PREFIX);
+  if (idx === -1) return null;
+  const jsonPart = raw.slice(idx + PRESENCE_PREFIX.length).trim();
+  if (!jsonPart.startsWith("{")) return null;
+  try {
+    const parsed = JSON.parse(jsonPart);
+    return normalizePresencePayload(parsed);
+  } catch {
+    return null;
+  }
+}
+
+export function buildLocalPresence(extra = {}) {
+  const meta = state.localMeta || {};
+  const gitInfo = state.repoRoot ? readGitInfo(state.repoRoot) : {};
+  return normalizePresencePayload({
+    ...meta,
+    ...gitInfo,
+    ...extra,
+    updated_at: new Date().toISOString(),
+  });
+}
+
+export async function notePresence(payload, options = {}) {
+  const normalized = normalizePresencePayload(payload);
+  if (!normalized) return null;
+  const now = options.receivedAt || new Date().toISOString();
+  const entry = {
+    ...normalized,
+    last_seen_at: now,
+    source: options.source || normalized.source || "telegram",
+  };
+  state.instances.set(normalized.instance_id, entry);
+  await persistPresenceRegistry();
+  return entry;
+}
+
+export function listActiveInstances({ nowMs, ttlMs } = {}) {
+  const now = Number.isFinite(nowMs) ? nowMs : Date.now();
+  const ttl = Number.isFinite(ttlMs) ? ttlMs : 0;
+  const instances = [];
+  for (const entry of state.instances.values()) {
+    const last = Date.parse(entry.last_seen_at || entry.updated_at || "");
+    if (ttl > 0 && (!Number.isFinite(last) || now - last >= ttl)) {
+      continue;
+    }
+    instances.push(entry);
+  }
+  return instances;
+}
+
+export function selectCoordinator({ nowMs, ttlMs } = {}) {
+  const active = listActiveInstances({ nowMs, ttlMs });
+  if (!active.length) return null;
+  const eligible = active.filter((entry) => entry.coordinator_eligible !== false);
+  const pool = eligible.length ? eligible : active;
+  const preferred = pool.filter(
+    (entry) => String(entry.workspace_role || "").toLowerCase() === "coordinator",
+  );
+  const candidates = preferred.length ? preferred : pool;
+  const sorted = [...candidates].sort((a, b) => {
+    const pa = safeParseNumber(a.coordinator_priority, 100);
+    const pb = safeParseNumber(b.coordinator_priority, 100);
+    if (pa !== pb) return pa - pb;
+    const sa = Date.parse(a.started_at || "");
+    const sb = Date.parse(b.started_at || "");
+    if (Number.isFinite(sa) && Number.isFinite(sb) && sa !== sb) {
+      return sa - sb;
+    }
+    return String(a.instance_id).localeCompare(String(b.instance_id));
+  });
+  return sorted[0] || null;
+}
+
+export function formatPresenceSummary({ nowMs, ttlMs } = {}) {
+  const active = listActiveInstances({ nowMs, ttlMs });
+  if (!active.length) {
+    return "No active instances reported.";
+  }
+  const coordinator = selectCoordinator({ nowMs, ttlMs });
+  const lines = ["🛰️ Codex Monitor Presence"];
+  for (const entry of active) {
+    const name = entry.instance_label || entry.instance_id;
+    const role = entry.workspace_role || "workspace";
+    const host = entry.host || "unknown";
+    const lastSeen = entry.last_seen_at
+      ? entry.last_seen_at.slice(11, 19)
+      : "--:--:--";
+    const coordTag =
+      coordinator && coordinator.instance_id === entry.instance_id ? " (coordinator)" : "";
+    lines.push(`- ${name}${coordTag} — ${role} @ ${host} (last ${lastSeen})`);
+  }
+  return lines.join("\n");
+}
+
+export function formatCoordinatorSummary({ nowMs, ttlMs } = {}) {
+  const coordinator = selectCoordinator({ nowMs, ttlMs });
+  if (!coordinator) {
+    return "No coordinator selected (no active instances).";
+  }
+  const name = coordinator.instance_label || coordinator.instance_id;
+  const role = coordinator.workspace_role || "workspace";
+  const host = coordinator.host || "unknown";
+  const lastSeen = coordinator.last_seen_at || coordinator.updated_at || "unknown";
+  return [
+    "⭐ Coordinator",
+    `Instance: ${name}`,
+    `Role: ${role}`,
+    `Host: ${host}`,
+    `Last seen: ${lastSeen}`,
+  ].join("\n");
+}
+
+export function getPresenceState() {
+  return {
+    instance_id: state.instanceId,
+    started_at: state.startedAt,
+    instances: [...state.instances.values()],
+  };
+}

package/primary-agent.mjs

@@ -0,0 +1,282 @@
+/**
+ * primary-agent.mjs — Adapter that selects the primary agent implementation.
+ *
+ * Supports Codex SDK, Copilot SDK, and Claude SDK.
+ */
+
+import { loadConfig } from "./config.mjs";
+import { getSessionTracker } from "./session-tracker.mjs";
+import {
+  execCodexPrompt,
+  steerCodexPrompt,
+  isCodexBusy,
+  getThreadInfo,
+  resetThread,
+  initCodexShell,
+  getActiveSessionId as getCodexSessionId,
+  listSessions as listCodexSessions,
+  switchSession as switchCodexSession,
+  createSession as createCodexSession,
+} from "./codex-shell.mjs";
+import {
+  execCopilotPrompt,
+  steerCopilotPrompt,
+  isCopilotBusy,
+  getSessionInfo as getCopilotSessionInfo,
+  resetSession as resetCopilotSession,
+  initCopilotShell,
+} from "./copilot-shell.mjs";
+import {
+  execClaudePrompt,
+  steerClaudePrompt,
+  isClaudeBusy,
+  getSessionInfo as getClaudeSessionInfo,
+  resetClaudeSession,
+  initClaudeShell,
+} from "./claude-shell.mjs";
+
+const ADAPTERS = {
+  "codex-sdk": {
+    name: "codex-sdk",
+    provider: "CODEX",
+    exec: (msg, opts) => execCodexPrompt(msg, { persistent: true, ...opts }),
+    steer: steerCodexPrompt,
+    isBusy: isCodexBusy,
+    getInfo: () => {
+      const info = getThreadInfo();
+      return { ...info, sessionId: info.sessionId || info.threadId };
+    },
+    reset: resetThread,
+    init: async () => {
+      await initCodexShell();
+      return true;
+    },
+    getSessionId: getCodexSessionId,
+    listSessions: listCodexSessions,
+    switchSession: switchCodexSession,
+    createSession: createCodexSession,
+  },
+  "copilot-sdk": {
+    name: "copilot-sdk",
+    provider: "COPILOT",
+    exec: (msg, opts) => execCopilotPrompt(msg, { persistent: true, ...opts }),
+    steer: steerCopilotPrompt,
+    isBusy: isCopilotBusy,
+    getInfo: () => getCopilotSessionInfo(),
+    reset: resetCopilotSession,
+    init: async () => initCopilotShell(),
+  },
+  "claude-sdk": {
+    name: "claude-sdk",
+    provider: "CLAUDE",
+    exec: execClaudePrompt,
+    steer: steerClaudePrompt,
+    isBusy: isClaudeBusy,
+    getInfo: () => getClaudeSessionInfo(),
+    reset: resetClaudeSession,
+    init: async () => {
+      await initClaudeShell();
+      return true;
+    },
+  },
+};
+
+function envFlagEnabled(value) {
+  const raw = String(value ?? "")
+    .trim()
+    .toLowerCase();
+  return ["1", "true", "yes", "on", "y"].includes(raw);
+}
+
+let activeAdapter = ADAPTERS["codex-sdk"];
+let primaryProfile = null;
+let primaryFallbackReason = null;
+let initialized = false;
+
+function normalizePrimaryAgent(value) {
+  const raw = String(value || "")
+    .trim()
+    .toLowerCase();
+  if (!raw) return "codex-sdk";
+  if (["codex", "codex-sdk"].includes(raw)) return "codex-sdk";
+  if (["copilot", "copilot-sdk", "github-copilot"].includes(raw))
+    return "copilot-sdk";
+  if (["claude", "claude-sdk", "claude_code", "claude-code"].includes(raw))
+    return "claude-sdk";
+  return raw;
+}
+
+function selectPrimaryExecutor(config) {
+  const executors = config?.executorConfig?.executors || [];
+  if (!executors.length) return null;
+  const primary = executors.find(
+    (e) => (e.role || "").toLowerCase() === "primary",
+  );
+  return primary || executors[0];
+}
+
+function executorToAdapter(executor) {
+  if (!executor) return null;
+  const normalized = String(executor).toUpperCase();
+  if (normalized === "COPILOT") return "copilot-sdk";
+  if (normalized === "CLAUDE") return "claude-sdk";
+  return "codex-sdk";
+}
+
+function resolvePrimaryAgent(nameOrConfig) {
+  if (typeof nameOrConfig === "string" && nameOrConfig.trim()) {
+    return normalizePrimaryAgent(nameOrConfig);
+  }
+  if (nameOrConfig && typeof nameOrConfig === "object") {
+    const direct = normalizePrimaryAgent(nameOrConfig.primaryAgent);
+    if (direct) return direct;
+  }
+  if (process.env.PRIMARY_AGENT || process.env.PRIMARY_AGENT_SDK) {
+    return normalizePrimaryAgent(
+      process.env.PRIMARY_AGENT || process.env.PRIMARY_AGENT_SDK,
+    );
+  }
+  const cfg = loadConfig();
+  const direct = normalizePrimaryAgent(cfg?.primaryAgent || "");
+  if (direct) return direct;
+  primaryProfile = selectPrimaryExecutor(cfg);
+  const mapped = executorToAdapter(primaryProfile?.executor);
+  return mapped || "codex-sdk";
+}
+
+export function setPrimaryAgent(name) {
+  const normalized = normalizePrimaryAgent(name);
+  activeAdapter = ADAPTERS[normalized] || ADAPTERS["codex-sdk"];
+  return activeAdapter.name;
+}
+
+export function getPrimaryAgentName() {
+  return activeAdapter?.name || "codex-sdk";
+}
+
+export async function switchPrimaryAgent(name) {
+  const normalized = normalizePrimaryAgent(name);
+  if (!ADAPTERS[normalized]) {
+    return { ok: false, reason: "unknown_agent" };
+  }
+  activeAdapter = ADAPTERS[normalized];
+  primaryFallbackReason = null;
+  initialized = false;
+  try {
+    await initPrimaryAgent(normalized);
+    return { ok: true, name: getPrimaryAgentName() };
+  } catch (err) {
+    return { ok: false, reason: err?.message || "init_failed" };
+  }
+}
+
+export async function initPrimaryAgent(nameOrConfig = null) {
+  if (initialized) return getPrimaryAgentName();
+  const desired = resolvePrimaryAgent(nameOrConfig);
+  setPrimaryAgent(desired);
+
+  if (
+    activeAdapter.name === "codex-sdk" &&
+    envFlagEnabled(process.env.CODEX_SDK_DISABLED)
+  ) {
+    primaryFallbackReason = "Codex SDK disabled — attempting fallback";
+    if (!envFlagEnabled(process.env.COPILOT_SDK_DISABLED)) {
+      setPrimaryAgent("copilot-sdk");
+    } else if (!envFlagEnabled(process.env.CLAUDE_SDK_DISABLED)) {
+      setPrimaryAgent("claude-sdk");
+    }
+  }
+
+  if (
+    activeAdapter.name === "claude-sdk" &&
+    envFlagEnabled(process.env.CLAUDE_SDK_DISABLED)
+  ) {
+    primaryFallbackReason = "Claude SDK disabled — falling back to Codex";
+    setPrimaryAgent("codex-sdk");
+  }
+
+  const ok = await activeAdapter.init();
+  if (activeAdapter.name === "copilot-sdk" && ok === false) {
+    primaryFallbackReason = "Copilot SDK unavailable — falling back to Codex";
+    setPrimaryAgent("codex-sdk");
+    await activeAdapter.init();
+  }
+
+  initialized = true;
+  return getPrimaryAgentName();
+}
+
+export async function execPrimaryPrompt(userMessage, options = {}) {
+  if (!initialized) {
+    await initPrimaryAgent();
+  }
+  const sessionId = `primary-${activeAdapter.name}`;
+  const tracker = getSessionTracker();
+  tracker.recordEvent(sessionId, {
+    role: "user",
+    content: userMessage,
+    timestamp: new Date().toISOString(),
+    _sessionType: "primary",
+  });
+  const result = await activeAdapter.exec(userMessage, options);
+  if (result) {
+    tracker.recordEvent(sessionId, {
+      role: "assistant",
+      content: typeof result === "string" ? result : JSON.stringify(result),
+      timestamp: new Date().toISOString(),
+      _sessionType: "primary",
+    });
+  }
+  return result;
+}
+
+export async function steerPrimaryPrompt(message) {
+  if (!initialized) {
+    await initPrimaryAgent();
+  }
+  return activeAdapter.steer(message);
+}
+
+export function isPrimaryBusy() {
+  return activeAdapter.isBusy();
+}
+
+export function getPrimaryAgentInfo() {
+  const info = activeAdapter.getInfo ? activeAdapter.getInfo() : {};
+  return {
+    adapter: activeAdapter.name,
+    provider: activeAdapter.provider,
+    profile: primaryProfile,
+    fallbackReason: primaryFallbackReason,
+    sessionId: info.sessionId || info.threadId || null,
+    threadId: info.threadId || null,
+    turnCount: info.turnCount || 0,
+    isActive: !!info.isActive,
+    isBusy: !!info.isBusy,
+  };
+}
+
+export async function resetPrimaryAgent() {
+  if (!initialized) {
+    await initPrimaryAgent();
+  }
+  if (activeAdapter.reset) {
+    await activeAdapter.reset();
+  }
+}
+
+export function getPrimarySessionId() {
+  return activeAdapter.getSessionId ? activeAdapter.getSessionId() : null;
+}
+
+export async function listPrimarySessions() {
+  return activeAdapter.listSessions ? activeAdapter.listSessions() : [];
+}
+
+export async function switchPrimarySession(id) {
+  return activeAdapter.switchSession ? activeAdapter.switchSession(id) : undefined;
+}
+
+export async function createPrimarySession(id) {
+  return activeAdapter.createSession ? activeAdapter.createSession(id) : undefined;
+}