@revealui/harnesses 0.1.0 → 0.1.3

package/dist/chunk-HH2PJYQN.js

@@ -0,0 +1,1158 @@
+import {
+  WorkboardManager,
+  deriveSessionId,
+  detectSessionType
+} from "./chunk-FJGN6DTH.js";
+import {
+  __require
+} from "./chunk-DGUM43GV.js";
+
+// src/index.ts
+import { isFeatureEnabled } from "@revealui/core/features";
+import { initializeLicense } from "@revealui/core/license";
+import { logger } from "@revealui/core/observability/logger";
+
+// src/adapters/claude-code-adapter.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var ClaudeCodeAdapter = class {
+  id = "claude-code";
+  name = "Claude Code";
+  eventHandlers = /* @__PURE__ */ new Set();
+  workboardPath;
+  constructor(workboardPath) {
+    this.workboardPath = workboardPath ?? process.env.REVEALUI_WORKBOARD_PATH;
+  }
+  getCapabilities() {
+    return {
+      generateCode: false,
+      // interactive only — no headless CLI interface
+      analyzeCode: false,
+      // interactive only — no headless CLI interface
+      applyEdit: false,
+      // interactive only — edits are applied inside Claude Code sessions
+      applyConfig: false,
+      // config managed interactively via ~/.claude/settings.json
+      readWorkboard: this.workboardPath !== void 0,
+      writeWorkboard: this.workboardPath !== void 0
+    };
+  }
+  async getInfo() {
+    let version;
+    try {
+      const { stdout } = await execFileAsync("claude", ["--version"], {
+        timeout: 5e3
+      });
+      version = stdout.trim().split("\n")[0];
+    } catch {
+    }
+    return { id: this.id, name: this.name, version, capabilities: this.getCapabilities() };
+  }
+  async isAvailable() {
+    try {
+      await execFileAsync("claude", ["--version"], { timeout: 3e3 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  notifyRegistered() {
+    this.emit({ type: "harness-connected", harnessId: this.id });
+  }
+  notifyUnregistering() {
+    this.emit({ type: "harness-disconnected", harnessId: this.id });
+  }
+  async execute(command) {
+    try {
+      return await this.executeInner(command);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.emit({ type: "error", harnessId: this.id, message });
+      return { success: false, command: command.type, message };
+    }
+  }
+  async executeInner(command) {
+    switch (command.type) {
+      case "get-status": {
+        const available = await this.isAvailable();
+        return { success: true, command: command.type, data: { available } };
+      }
+      case "get-running-instances": {
+        return { success: true, command: command.type, data: [] };
+      }
+      case "generate-code":
+      case "analyze-code": {
+        return {
+          success: false,
+          command: command.type,
+          message: `${command.type} is not supported \u2014 Claude Code operates interactively`
+        };
+      }
+      case "apply-config": {
+        return {
+          success: false,
+          command: command.type,
+          message: "Config is managed interactively via ~/.claude/settings.json"
+        };
+      }
+      case "read-workboard": {
+        if (!this.workboardPath) {
+          return {
+            success: false,
+            command: command.type,
+            message: "REVEALUI_WORKBOARD_PATH is not set"
+          };
+        }
+        const manager = new WorkboardManager(this.workboardPath);
+        const state = await manager.readAsync();
+        return { success: true, command: command.type, data: state };
+      }
+      case "update-workboard": {
+        if (!this.workboardPath) {
+          return {
+            success: false,
+            command: command.type,
+            message: "REVEALUI_WORKBOARD_PATH is not set"
+          };
+        }
+        const manager = new WorkboardManager(this.workboardPath);
+        manager.updateSession(command.sessionId, {
+          ...command.task !== void 0 && { task: command.task },
+          ...command.files !== void 0 && { files: command.files.join(", ") },
+          updated: `${(/* @__PURE__ */ new Date()).toISOString().slice(0, 16)}Z`
+        });
+        return { success: true, command: command.type };
+      }
+      default: {
+        return {
+          success: false,
+          command: command.type,
+          message: `Command not supported by ${this.name}`
+        };
+      }
+    }
+  }
+  onEvent(handler) {
+    this.eventHandlers.add(handler);
+    return () => this.eventHandlers.delete(handler);
+  }
+  async dispose() {
+    this.eventHandlers.clear();
+  }
+  emit(event) {
+    for (const handler of this.eventHandlers) {
+      try {
+        handler(event);
+      } catch {
+      }
+    }
+  }
+};
+
+// src/adapters/cursor-adapter.ts
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execFileAsync2 = promisify2(execFile2);
+var CursorAdapter = class {
+  id = "cursor";
+  name = "Cursor";
+  eventHandlers = /* @__PURE__ */ new Set();
+  workboardPath;
+  constructor(workboardPath) {
+    this.workboardPath = workboardPath ?? process.env.REVEALUI_WORKBOARD_PATH;
+  }
+  getCapabilities() {
+    return {
+      generateCode: false,
+      analyzeCode: false,
+      applyEdit: false,
+      applyConfig: false,
+      readWorkboard: this.workboardPath !== void 0,
+      writeWorkboard: this.workboardPath !== void 0
+    };
+  }
+  async getInfo() {
+    let version;
+    try {
+      const { stdout } = await execFileAsync2("cursor", ["--version"], {
+        timeout: 5e3
+      });
+      version = stdout.trim().split("\n")[0];
+    } catch {
+    }
+    return { id: this.id, name: this.name, version, capabilities: this.getCapabilities() };
+  }
+  async isAvailable() {
+    try {
+      await execFileAsync2("cursor", ["--version"], { timeout: 3e3 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  notifyRegistered() {
+    this.emit({ type: "harness-connected", harnessId: this.id });
+  }
+  notifyUnregistering() {
+    this.emit({ type: "harness-disconnected", harnessId: this.id });
+  }
+  async execute(command) {
+    try {
+      return await this.executeInner(command);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.emit({ type: "error", harnessId: this.id, message });
+      return { success: false, command: command.type, message };
+    }
+  }
+  async executeInner(command) {
+    switch (command.type) {
+      case "get-status": {
+        const available = await this.isAvailable();
+        return { success: true, command: command.type, data: { available } };
+      }
+      case "read-workboard": {
+        if (!this.workboardPath) {
+          return {
+            success: false,
+            command: command.type,
+            message: "REVEALUI_WORKBOARD_PATH is not set"
+          };
+        }
+        const manager = new WorkboardManager(this.workboardPath);
+        const state = await manager.readAsync();
+        return { success: true, command: command.type, data: state };
+      }
+      case "update-workboard": {
+        if (!this.workboardPath) {
+          return {
+            success: false,
+            command: command.type,
+            message: "REVEALUI_WORKBOARD_PATH is not set"
+          };
+        }
+        const manager = new WorkboardManager(this.workboardPath);
+        manager.updateSession(command.sessionId, {
+          ...command.task !== void 0 && { task: command.task },
+          ...command.files !== void 0 && { files: command.files.join(", ") },
+          updated: `${(/* @__PURE__ */ new Date()).toISOString().slice(0, 16)}Z`
+        });
+        return { success: true, command: command.type };
+      }
+      default: {
+        return {
+          success: false,
+          command: command.type,
+          message: `Command not supported by ${this.name}`
+        };
+      }
+    }
+  }
+  onEvent(handler) {
+    this.eventHandlers.add(handler);
+    return () => this.eventHandlers.delete(handler);
+  }
+  async dispose() {
+    this.eventHandlers.clear();
+  }
+  emit(event) {
+    for (const handler of this.eventHandlers) {
+      try {
+        handler(event);
+      } catch {
+      }
+    }
+  }
+};
+
+// src/config/config-sync.ts
+import { copyFileSync, existsSync, mkdirSync, readFileSync } from "fs";
+import { dirname } from "path";
+
+// src/config/harness-config-paths.ts
+import { homedir } from "os";
+import { join } from "path";
+var HOME = homedir();
+var REVEALUI_ROOT = process.env.REVEALUI_ROOT ?? join(HOME, ".revealui");
+var LOCAL_CONFIG_PATHS = {
+  "claude-code": join(HOME, ".claude", "settings.json"),
+  cursor: join(HOME, ".cursor", "settings.json"),
+  copilot: join(HOME, ".config", "github-copilot", "hosts.json")
+};
+var ROOT_CONFIG_FILES = {
+  "claude-code": "settings.json",
+  cursor: "settings.json",
+  copilot: "hosts.json"
+};
+function getLocalConfigPath(harnessId) {
+  return LOCAL_CONFIG_PATHS[harnessId];
+}
+function getRootConfigPath(harnessId, root = REVEALUI_ROOT) {
+  const file = ROOT_CONFIG_FILES[harnessId];
+  if (!file) return void 0;
+  return join(root, "harness-configs", harnessId, file);
+}
+function getConfigurableHarnesses() {
+  return Object.keys(LOCAL_CONFIG_PATHS);
+}
+
+// src/config/config-sync.ts
+function syncConfig(harnessId, direction, root) {
+  const localPath = getLocalConfigPath(harnessId);
+  const rootPath = getRootConfigPath(harnessId, root);
+  if (!(localPath && rootPath)) {
+    return {
+      success: false,
+      harnessId,
+      direction,
+      message: `No config path known for harness: ${harnessId}`
+    };
+  }
+  try {
+    if (direction === "pull") {
+      if (!existsSync(rootPath)) {
+        return {
+          success: false,
+          harnessId,
+          direction,
+          message: `Root config not found: ${rootPath}`
+        };
+      }
+      mkdirSync(dirname(localPath), { recursive: true });
+      backupIfExists(localPath);
+      copyFileSync(rootPath, localPath);
+      return { success: true, harnessId, direction, message: `Pulled ${rootPath} \u2192 ${localPath}` };
+    } else {
+      if (!existsSync(localPath)) {
+        return {
+          success: false,
+          harnessId,
+          direction,
+          message: `Local config not found: ${localPath}`
+        };
+      }
+      mkdirSync(dirname(rootPath), { recursive: true });
+      backupIfExists(rootPath);
+      copyFileSync(localPath, rootPath);
+      return { success: true, harnessId, direction, message: `Pushed ${localPath} \u2192 ${rootPath}` };
+    }
+  } catch (err) {
+    return {
+      success: false,
+      harnessId,
+      direction,
+      message: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function diffConfig(harnessId, root) {
+  const localPath = getLocalConfigPath(harnessId);
+  const rootPath = getRootConfigPath(harnessId, root);
+  const localExists = !!localPath && existsSync(localPath);
+  const ssdExists = !!rootPath && existsSync(rootPath);
+  if (!(localExists && ssdExists)) {
+    return { harnessId, localExists, ssdExists, identical: false };
+  }
+  try {
+    const localContent = readFileSync(localPath, "utf8");
+    const ssdContent = readFileSync(rootPath, "utf8");
+    return { harnessId, localExists, ssdExists, identical: localContent === ssdContent };
+  } catch {
+    return { harnessId, localExists, ssdExists, identical: false };
+  }
+}
+function syncAllConfigs(direction, root) {
+  return getConfigurableHarnesses().map((id) => syncConfig(id, direction, root));
+}
+function diffAllConfigs(root) {
+  return getConfigurableHarnesses().map((id) => diffConfig(id, root));
+}
+function validateConfigJson(harnessId) {
+  const localPath = getLocalConfigPath(harnessId);
+  if (!localPath) return `No config path known for harness: ${harnessId}`;
+  if (!existsSync(localPath)) return `Config file not found: ${localPath}`;
+  try {
+    const content = readFileSync(localPath, "utf8");
+    JSON.parse(content);
+    return null;
+  } catch (err) {
+    return err instanceof Error ? err.message : String(err);
+  }
+}
+function backupIfExists(filePath) {
+  try {
+    if (existsSync(filePath)) {
+      copyFileSync(filePath, `${filePath}.bak`);
+    }
+  } catch {
+  }
+}
+
+// src/coordinator.ts
+import { join as join3 } from "path";
+
+// src/adapters/copilot-adapter.ts
+var CopilotAdapter = class {
+  id = "copilot";
+  name = "GitHub Copilot";
+  eventHandlers = /* @__PURE__ */ new Set();
+  getCapabilities() {
+    return {
+      generateCode: false,
+      // stub — no CLI available
+      analyzeCode: false,
+      applyEdit: false,
+      applyConfig: false,
+      readWorkboard: false,
+      writeWorkboard: false
+    };
+  }
+  async getInfo() {
+    return { id: this.id, name: this.name, capabilities: this.getCapabilities() };
+  }
+  async isAvailable() {
+    return false;
+  }
+  notifyRegistered() {
+    this.emit({ type: "harness-connected", harnessId: this.id });
+  }
+  notifyUnregistering() {
+    this.emit({ type: "harness-disconnected", harnessId: this.id });
+  }
+  async execute(command) {
+    return {
+      success: false,
+      command: command.type,
+      message: "Copilot adapter is a stub \u2014 no standalone CLI available"
+    };
+  }
+  onEvent(handler) {
+    this.eventHandlers.add(handler);
+    return () => this.eventHandlers.delete(handler);
+  }
+  async dispose() {
+    this.eventHandlers.clear();
+  }
+  emit(event) {
+    for (const handler of this.eventHandlers) {
+      try {
+        handler(event);
+      } catch {
+      }
+    }
+  }
+};
+
+// src/adapters/revealui-agent-adapter.ts
+var DEFAULT_CONFIG = {
+  projectRoot: process.cwd(),
+  maxIterations: 10,
+  timeoutMs: 12e4
+};
+var RevealUIAgentAdapter = class {
+  id = "revealui-agent";
+  name = "RevealUI Agent";
+  config;
+  eventHandlers = /* @__PURE__ */ new Set();
+  constructor(config) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  getCapabilities() {
+    return {
+      generateCode: true,
+      analyzeCode: true,
+      applyEdit: true,
+      applyConfig: false,
+      readWorkboard: (this.config.workboardPath ?? process.env.REVEALUI_WORKBOARD_PATH) !== void 0,
+      writeWorkboard: (this.config.workboardPath ?? process.env.REVEALUI_WORKBOARD_PATH) !== void 0
+    };
+  }
+  async getInfo() {
+    return {
+      id: this.id,
+      name: this.name,
+      version: "0.1.0",
+      capabilities: this.getCapabilities()
+    };
+  }
+  /**
+   * The RevealUI agent is available if at least one LLM provider is reachable.
+   * Checks in order: BitNet (localhost), Ollama (localhost), Groq (API key).
+   */
+  async isAvailable() {
+    if (process.env.BITNET_BASE_URL) {
+      try {
+        const url = `${process.env.BITNET_BASE_URL}/v1/models`;
+        const res = await fetch(url, { signal: AbortSignal.timeout(2e3) });
+        if (res.ok) return true;
+      } catch {
+      }
+    }
+    const ollamaUrl = process.env.OLLAMA_BASE_URL ?? "http://localhost:11434";
+    try {
+      const res = await fetch(`${ollamaUrl}/api/tags`, {
+        signal: AbortSignal.timeout(2e3)
+      });
+      if (res.ok) return true;
+    } catch {
+    }
+    if (process.env.GROQ_API_KEY) return true;
+    return false;
+  }
+  notifyRegistered() {
+    this.emit({ type: "harness-connected", harnessId: this.id });
+  }
+  notifyUnregistering() {
+    this.emit({ type: "harness-disconnected", harnessId: this.id });
+  }
+  async execute(command) {
+    try {
+      return await this.executeInner(command);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.emit({ type: "error", harnessId: this.id, message });
+      return { success: false, command: command.type, message };
+    }
+  }
+  async executeInner(command) {
+    switch (command.type) {
+      case "get-status": {
+        const available = await this.isAvailable();
+        return {
+          success: true,
+          command: command.type,
+          data: {
+            available,
+            provider: this.config.provider ?? "auto",
+            model: this.config.model ?? "auto",
+            projectRoot: this.config.projectRoot
+          }
+        };
+      }
+      case "headless-prompt": {
+        return this.runHeadlessPrompt(command.prompt, command.maxTurns, command.timeoutMs);
+      }
+      case "generate-code": {
+        return this.runHeadlessPrompt(
+          `Generate code: ${command.prompt}${command.language ? ` (language: ${command.language})` : ""}${command.context ? `
+
+Context:
+${command.context}` : ""}`
+        );
+      }
+      case "analyze-code": {
+        const question = command.question ?? "Analyze this file and explain what it does.";
+        return this.runHeadlessPrompt(
+          `Read the file at ${command.filePath} and answer: ${question}`
+        );
+      }
+      case "apply-edit": {
+        return this.runHeadlessPrompt(
+          `Apply the following diff to ${command.filePath}:
+
+${command.diff}`
+        );
+      }
+      case "apply-config":
+      case "sync-config":
+      case "diff-config": {
+        return {
+          success: false,
+          command: command.type,
+          message: "Config sync is not applicable \u2014 RevealUI agent uses the content layer directly"
+        };
+      }
+      case "read-workboard":
+      case "update-workboard": {
+        return {
+          success: false,
+          command: command.type,
+          message: "Workboard support not yet wired \u2014 use WorkboardManager directly"
+        };
+      }
+      default: {
+        return {
+          success: false,
+          command: command.type,
+          message: `Command not supported by ${this.name}`
+        };
+      }
+    }
+  }
+  /**
+   * Run a headless prompt through the coding agent.
+   * Lazy-imports @revealui/ai to avoid hard dependency at module load time.
+   * Types are inferred from the dynamic imports — no compile-time @revealui/ai dependency.
+   */
+  async runHeadlessPrompt(prompt, maxTurns, timeoutMs) {
+    const aiRuntimePath = "@revealui/ai/orchestration/streaming-runtime";
+    const aiClientPath = "@revealui/ai/llm/client";
+    const aiToolsPath = "@revealui/ai/tools/coding";
+    let runtimeMod;
+    let clientMod;
+    let toolsMod;
+    try {
+      [runtimeMod, clientMod, toolsMod] = await Promise.all([
+        import(aiRuntimePath),
+        import(aiClientPath),
+        import(aiToolsPath)
+      ]);
+    } catch {
+      return {
+        success: false,
+        command: "headless-prompt",
+        message: "@revealui/ai is not installed. Install it to use the RevealUI agent: npm install @revealui/ai"
+      };
+    }
+    const StreamingAgentRuntime = runtimeMod.StreamingAgentRuntime;
+    const createCodingTools = toolsMod.createCodingTools;
+    const projectRoot = this.config.projectRoot ?? process.cwd();
+    const tools = createCodingTools({ projectRoot });
+    let llmClient;
+    if (this.config.provider) {
+      const LLMClient = clientMod.LLMClient;
+      llmClient = new LLMClient({
+        provider: this.config.provider,
+        model: this.config.model,
+        baseURL: process.env.BITNET_BASE_URL ?? process.env.OLLAMA_BASE_URL,
+        apiKey: process.env.GROQ_API_KEY ?? "not-needed"
+      });
+    } else {
+      const createLLMClientFromEnv = clientMod.createLLMClientFromEnv;
+      llmClient = createLLMClientFromEnv();
+    }
+    const agent = {
+      id: "revealui-coding-agent",
+      name: "RevealUI Coding Agent",
+      instructions: this.buildInstructions(),
+      tools,
+      config: {},
+      getContext: () => ({ projectRoot, workingDirectory: projectRoot })
+    };
+    const task = {
+      id: `task-${Date.now()}`,
+      type: "headless-prompt",
+      description: prompt
+    };
+    const runtime = new StreamingAgentRuntime({
+      maxIterations: maxTurns ?? this.config.maxIterations ?? DEFAULT_CONFIG.maxIterations,
+      timeout: timeoutMs ?? this.config.timeoutMs ?? DEFAULT_CONFIG.timeoutMs
+    });
+    const taskId = task.id;
+    this.emit({ type: "generation-started", taskId });
+    const outputParts = [];
+    try {
+      for await (const chunk of runtime.streamTask(agent, task, llmClient)) {
+        switch (chunk.type) {
+          case "text":
+            if (chunk.content) outputParts.push(chunk.content);
+            break;
+          case "tool_call_result":
+            if (chunk.toolResult?.content) {
+              outputParts.push(`[tool: ${chunk.toolCall?.name}] ${chunk.toolResult.content}`);
+            }
+            break;
+          case "error":
+            if (chunk.error) outputParts.push(`[error] ${chunk.error}`);
+            break;
+          case "done":
+            break;
+        }
+      }
+    } finally {
+      await runtime.cleanup();
+    }
+    const output = outputParts.join("\n");
+    this.emit({ type: "generation-completed", taskId, output });
+    return {
+      success: true,
+      command: "headless-prompt",
+      message: output,
+      data: { taskId, output }
+    };
+  }
+  /**
+   * Build system instructions from the content layer.
+   * Loads rules from .claude/rules/ as a baseline (they are the canonical content).
+   */
+  buildInstructions() {
+    const lines = [
+      "You are the RevealUI coding agent. You help with software development tasks in this project.",
+      "Use the available tools to read, write, edit, search, and execute commands.",
+      "Always read files before modifying them. Prefer surgical edits over full rewrites.",
+      "Follow project conventions discovered via the project_context tool.",
+      ""
+    ];
+    try {
+      const { readdirSync, readFileSync: readFileSync2 } = __require("fs");
+      const { join: join4 } = __require("path");
+      const projectRoot = this.config.projectRoot ?? process.cwd();
+      const rulesDir = join4(projectRoot, ".claude", "rules");
+      const ruleFiles = readdirSync(rulesDir);
+      for (const file of ruleFiles) {
+        if (file.endsWith(".md")) {
+          const content = readFileSync2(join4(rulesDir, file), "utf8");
+          lines.push(`## ${file.replace(".md", "")}`, content, "");
+        }
+      }
+    } catch {
+    }
+    return lines.join("\n");
+  }
+  onEvent(handler) {
+    this.eventHandlers.add(handler);
+    return () => this.eventHandlers.delete(handler);
+  }
+  async dispose() {
+    this.eventHandlers.clear();
+  }
+  emit(event) {
+    for (const handler of this.eventHandlers) {
+      try {
+        handler(event);
+      } catch {
+      }
+    }
+  }
+};
+
+// src/detection/auto-detector.ts
+async function autoDetectHarnesses(registry) {
+  const candidates = [
+    new RevealUIAgentAdapter(),
+    new ClaudeCodeAdapter(),
+    new CursorAdapter(),
+    new CopilotAdapter()
+  ];
+  const registered = [];
+  await Promise.all(
+    candidates.map(async (adapter) => {
+      try {
+        if (await adapter.isAvailable()) {
+          registry.register(adapter);
+          registered.push(adapter.id);
+        } else {
+          await adapter.dispose();
+        }
+      } catch {
+        await adapter.dispose();
+      }
+    })
+  );
+  return registered;
+}
+
+// src/registry/harness-registry.ts
+var HarnessRegistry = class {
+  adapters = /* @__PURE__ */ new Map();
+  /** Register an adapter. Throws if an adapter with the same id already exists. */
+  register(adapter) {
+    if (this.adapters.has(adapter.id)) {
+      throw new Error(`Harness adapter already registered: ${adapter.id}`);
+    }
+    this.adapters.set(adapter.id, adapter);
+    adapter.notifyRegistered?.();
+  }
+  /** Unregister an adapter, disposing it in the process. */
+  async unregister(id) {
+    const adapter = this.adapters.get(id);
+    if (adapter) {
+      adapter.notifyUnregistering?.();
+      await adapter.dispose();
+      this.adapters.delete(id);
+    }
+  }
+  /** Retrieve an adapter by id. */
+  get(id) {
+    return this.adapters.get(id);
+  }
+  /** List all registered adapter ids. */
+  listAll() {
+    return Array.from(this.adapters.keys());
+  }
+  /** List ids of adapters that report isAvailable() === true. */
+  async listAvailable() {
+    const results = await Promise.all(
+      Array.from(this.adapters.entries()).map(async ([id, adapter]) => ({
+        id,
+        available: await adapter.isAvailable()
+      }))
+    );
+    return results.filter((r) => r.available).map((r) => r.id);
+  }
+  /** Dispose all adapters and clear the registry. */
+  async disposeAll() {
+    await Promise.all(Array.from(this.adapters.values()).map((a) => a.dispose()));
+    this.adapters.clear();
+  }
+};
+
+// src/server/rpc-server.ts
+import { createServer } from "net";
+
+// src/detection/process-detector.ts
+import { execFile as execFile3 } from "child_process";
+import { readdir } from "fs/promises";
+import { join as join2 } from "path";
+import { promisify as promisify3 } from "util";
+var execFileAsync3 = promisify3(execFile3);
+async function findProcesses(pattern) {
+  try {
+    const { stdout } = await execFileAsync3("pgrep", ["-a", pattern], { timeout: 3e3 });
+    return stdout.trim().split("\n").filter(Boolean).map((line) => {
+      const spaceIdx = line.indexOf(" ");
+      const pid = parseInt(line.slice(0, spaceIdx), 10);
+      const command = line.slice(spaceIdx + 1);
+      return { pid, command };
+    });
+  } catch {
+    return [];
+  }
+}
+var HARNESS_PROCESS_PATTERNS = {
+  "claude-code": ["claude"],
+  cursor: ["cursor", "Cursor"],
+  copilot: ["copilot"]
+};
+async function findHarnessProcesses(harnessId) {
+  const patterns = HARNESS_PROCESS_PATTERNS[harnessId];
+  if (!patterns) return [];
+  const results = await Promise.all(patterns.map((p) => findProcesses(p)));
+  return results.flat().map((p) => ({ ...p, harnessId }));
+}
+async function findAllHarnessProcesses() {
+  const results = await Promise.all(
+    Object.keys(HARNESS_PROCESS_PATTERNS).map((id) => findHarnessProcesses(id))
+  );
+  return results.flat();
+}
+async function findClaudeCodeSockets() {
+  const dirs = [
+    "/tmp",
+    process.env.XDG_RUNTIME_DIR,
+    join2(process.env.HOME ?? "/tmp", ".claude")
+  ].filter(Boolean);
+  const sockets = [];
+  for (const dir of dirs) {
+    try {
+      const entries = await readdir(dir);
+      for (const entry of entries) {
+        if (/^claude.*\.sock$/.test(entry)) {
+          sockets.push(join2(dir, entry));
+        }
+      }
+    } catch {
+    }
+  }
+  return sockets;
+}
+
+// src/server/rpc-server.ts
+var ERR_PARSE = -32700;
+var ERR_INVALID_PARAMS = -32602;
+var ERR_METHOD_NOT_FOUND = -32601;
+var ERR_INTERNAL = -32603;
+var RpcServer = class {
+  constructor(registry, socketPath) {
+    this.registry = registry;
+    this.socketPath = socketPath;
+    this.server.on("connection", (socket) => {
+      let buffer = "";
+      socket.on("data", (chunk) => {
+        buffer += chunk.toString();
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          this.handleLine(line.trim(), (response) => {
+            socket.write(`${JSON.stringify(response)}
+`);
+          });
+        }
+      });
+    });
+  }
+  server = createServer();
+  healthCheckFn = null;
+  handleLine(line, reply) {
+    let req;
+    try {
+      req = JSON.parse(line);
+    } catch {
+      reply({ jsonrpc: "2.0", id: null, error: { code: ERR_PARSE, message: "Parse error" } });
+      return;
+    }
+    this.dispatch(req).then(reply).catch((err) => {
+      reply({
+        jsonrpc: "2.0",
+        id: req.id,
+        error: { code: ERR_INTERNAL, message: err instanceof Error ? err.message : String(err) }
+      });
+    });
+  }
+  async dispatch(req) {
+    const { id, method, params } = req;
+    const p = params ?? {};
+    switch (method) {
+      case "harness.list": {
+        const ids = await this.registry.listAvailable();
+        const infos = await Promise.all(ids.map((id2) => this.registry.get(id2)?.getInfo()));
+        return { jsonrpc: "2.0", id, result: infos };
+      }
+      case "harness.info": {
+        const harnessId = p.harnessId;
+        if (!harnessId) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: ERR_INVALID_PARAMS, message: "harnessId required" }
+          };
+        }
+        const adapter = this.registry.get(harnessId);
+        if (!adapter) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: ERR_INVALID_PARAMS, message: `Harness not found: ${harnessId}` }
+          };
+        }
+        return { jsonrpc: "2.0", id, result: await adapter.getInfo() };
+      }
+      case "harness.execute": {
+        const harnessId = p.harnessId;
+        const command = p.command;
+        if (!(harnessId && command)) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: ERR_INVALID_PARAMS, message: "harnessId and command required" }
+          };
+        }
+        const adapter = this.registry.get(harnessId);
+        if (!adapter) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: ERR_INVALID_PARAMS, message: `Harness not found: ${harnessId}` }
+          };
+        }
+        const result = await adapter.execute(command);
+        return { jsonrpc: "2.0", id, result };
+      }
+      case "harness.syncConfig": {
+        const harnessId = p.harnessId;
+        const direction = p.direction;
+        if (!(harnessId && direction)) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: ERR_INVALID_PARAMS, message: "harnessId and direction required" }
+          };
+        }
+        return { jsonrpc: "2.0", id, result: syncConfig(harnessId, direction) };
+      }
+      case "harness.diffConfig": {
+        const harnessId = p.harnessId;
+        if (!harnessId) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: ERR_INVALID_PARAMS, message: "harnessId required" }
+          };
+        }
+        return { jsonrpc: "2.0", id, result: diffConfig(harnessId) };
+      }
+      case "harness.listRunning": {
+        const harnessId = p.harnessId;
+        if (!harnessId) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: ERR_INVALID_PARAMS, message: "harnessId required" }
+          };
+        }
+        const processes = await findHarnessProcesses(harnessId);
+        return { jsonrpc: "2.0", id, result: processes };
+      }
+      case "harness.health": {
+        if (!this.healthCheckFn) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: ERR_INTERNAL, message: "Health check not configured" }
+          };
+        }
+        const health = await this.healthCheckFn();
+        return { jsonrpc: "2.0", id, result: health };
+      }
+      default:
+        return {
+          jsonrpc: "2.0",
+          id,
+          error: { code: ERR_METHOD_NOT_FOUND, message: `Method not found: ${method}` }
+        };
+    }
+  }
+  /** Set the health check function (called by coordinator after construction). */
+  setHealthCheck(fn) {
+    this.healthCheckFn = fn;
+  }
+  start() {
+    return new Promise((resolve, reject) => {
+      this.server.listen(this.socketPath, () => resolve());
+      this.server.once("error", reject);
+    });
+  }
+  stop() {
+    return new Promise((resolve) => this.server.close(() => resolve()));
+  }
+};
+
+// src/coordinator.ts
+var HarnessCoordinator = class {
+  constructor(options) {
+    this.options = options;
+    const workboardPath = join3(options.projectRoot, ".claude", "workboard.md");
+    this.workboard = new WorkboardManager(workboardPath);
+  }
+  registry = new HarnessRegistry();
+  rpcServer = null;
+  sessionId = null;
+  workboard;
+  async start() {
+    await autoDetectHarnesses(this.registry);
+    const type = detectSessionType();
+    const state = this.workboard.read();
+    const existingIds = state.sessions.map((s) => s.id);
+    this.sessionId = deriveSessionId(type, existingIds);
+    const envLabels = {
+      zed: "Zed/ACP",
+      cursor: "Cursor",
+      terminal: "WSL/bash"
+    };
+    this.workboard.registerSession({
+      id: this.sessionId,
+      env: envLabels[type] ?? type,
+      started: `${(/* @__PURE__ */ new Date()).toISOString().slice(0, 16)}Z`,
+      task: this.options.task ?? "Harness coordination active",
+      files: "",
+      updated: `${(/* @__PURE__ */ new Date()).toISOString().slice(0, 16)}Z`
+    });
+    const socketPath = this.options.socketPath ?? join3(process.env.HOME ?? "/tmp", ".local", "share", "revealui", "harness.sock");
+    this.rpcServer = new RpcServer(this.registry, socketPath);
+    this.rpcServer.setHealthCheck(() => this.healthCheck());
+    await this.rpcServer.start();
+  }
+  async stop() {
+    if (this.sessionId) {
+      this.workboard.unregisterSession(this.sessionId);
+      this.workboard.addRecentEntry({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString().slice(0, 16).replace("T", " "),
+        sessionId: this.sessionId,
+        description: `Session ended \u2014 ${this.options.task ?? "harness coordination"}`
+      });
+    }
+    if (this.rpcServer) {
+      await this.rpcServer.stop();
+      this.rpcServer = null;
+    }
+    await this.registry.disposeAll();
+  }
+  /** The registry of detected harnesses. Available after start(). */
+  getRegistry() {
+    return this.registry;
+  }
+  /** The workboard manager. */
+  getWorkboard() {
+    return this.workboard;
+  }
+  /** Register a custom adapter (must be called before start()). */
+  registerAdapter(adapter) {
+    this.registry.register(adapter);
+  }
+  /** Run a health check across all registered harnesses and the workboard. */
+  async healthCheck() {
+    const diagnostics = [];
+    const StaleMs = 4 * 60 * 60 * 1e3;
+    const allIds = this.registry.listAll();
+    const registeredHarnesses = await Promise.all(
+      allIds.map(async (harnessId) => {
+        const adapter = this.registry.get(harnessId);
+        let available = false;
+        try {
+          available = adapter ? await adapter.isAvailable() : false;
+        } catch (err) {
+          diagnostics.push(
+            `${harnessId}: availability check failed \u2014 ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+        if (!available) diagnostics.push(`${harnessId}: not available`);
+        return { harnessId, available };
+      })
+    );
+    let readable = false;
+    let sessionCount = 0;
+    const staleSessionIds = [];
+    try {
+      const state = this.workboard.read();
+      readable = true;
+      sessionCount = state.sessions.length;
+      const now = Date.now();
+      for (const s of state.sessions) {
+        const ts = Date.parse(s.updated);
+        if (!Number.isNaN(ts) && now - ts > StaleMs) {
+          staleSessionIds.push(s.id);
+        }
+      }
+      if (staleSessionIds.length > 0) {
+        diagnostics.push(`Stale sessions: ${staleSessionIds.join(", ")}`);
+      }
+    } catch (err) {
+      diagnostics.push(`Workboard unreadable: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const healthy = registeredHarnesses.some((h) => h.available) && readable && staleSessionIds.length === 0;
+    return {
+      healthy,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      registeredHarnesses,
+      workboard: { readable, sessionCount, staleSessionIds },
+      diagnostics
+    };
+  }
+};
+
+// src/index.ts
+async function checkHarnessesLicense() {
+  await initializeLicense();
+  if (!isFeatureEnabled("ai")) {
+    logger.warn(
+      "[@revealui/harnesses] AI harness integration requires a Pro or Enterprise license. Visit https://revealui.com/pricing for details.",
+      { feature: "ai" }
+    );
+    return false;
+  }
+  return true;
+}
+
+export {
+  ClaudeCodeAdapter,
+  CursorAdapter,
+  autoDetectHarnesses,
+  HarnessRegistry,
+  getLocalConfigPath,
+  getRootConfigPath,
+  getConfigurableHarnesses,
+  syncConfig,
+  diffConfig,
+  syncAllConfigs,
+  diffAllConfigs,
+  validateConfigJson,
+  findProcesses,
+  findHarnessProcesses,
+  findAllHarnessProcesses,
+  findClaudeCodeSockets,
+  RpcServer,
+  HarnessCoordinator,
+  checkHarnessesLicense
+};
+//# sourceMappingURL=chunk-HH2PJYQN.js.map