@revealui/harnesses 0.1.0 → 0.1.1

package/dist/{chunk-BDA7D725.js → chunk-MO2EXBUG.js}

@@ -2,7 +2,12 @@ import {
   WorkboardManager,
   deriveSessionId,
   detectSessionType
-} from "./chunk-PG4RAOWS.js";
+} from "./chunk-6WO7SSCX.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";
@@ -49,7 +54,22 @@ var ClaudeCodeAdapter = class {
       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();
@@ -117,6 +137,14 @@ var ClaudeCodeAdapter = class {
   async dispose() {
     this.eventHandlers.clear();
   }
+  emit(event) {
+    for (const handler of this.eventHandlers) {
+      try {
+        handler(event);
+      } catch {
+      }
+    }
+  }
 };
 
 // src/adapters/copilot-adapter.ts
@@ -141,6 +169,12 @@ var CopilotAdapter = class {
   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,
@@ -155,83 +189,147 @@ var CopilotAdapter = class {
   async dispose() {
     this.eventHandlers.clear();
   }
-};
-
-// src/detection/auto-detector.ts
-async function autoDetectHarnesses(registry) {
-  const candidates = [new ClaudeCodeAdapter(), new CopilotAdapter()];
-  const registered = [];
-  await Promise.all(
-    candidates.map(async (adapter) => {
+  emit(event) {
+    for (const handler of this.eventHandlers) {
       try {
-        if (await adapter.isAvailable()) {
-          registry.register(adapter);
-          registered.push(adapter.id);
-        } else {
-          await adapter.dispose();
-        }
+        handler(event);
       } 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}`);
+// 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 {
     }
-    this.adapters.set(adapter.id, adapter);
+    return { id: this.id, name: this.name, version, capabilities: this.getCapabilities() };
   }
-  /** Unregister an adapter, disposing it in the process. */
-  async unregister(id) {
-    const adapter = this.adapters.get(id);
-    if (adapter) {
-      await adapter.dispose();
-      this.adapters.delete(id);
+  async isAvailable() {
+    try {
+      await execFileAsync2("cursor", ["--version"], { timeout: 3e3 });
+      return true;
+    } catch {
+      return false;
     }
   }
-  /** Retrieve an adapter by id. */
-  get(id) {
-    return this.adapters.get(id);
+  notifyRegistered() {
+    this.emit({ type: "harness-connected", harnessId: this.id });
   }
-  /** List all registered adapter ids. */
-  listAll() {
-    return Array.from(this.adapters.keys());
+  notifyUnregistering() {
+    this.emit({ type: "harness-disconnected", harnessId: this.id });
   }
-  /** 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);
+  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 };
+    }
   }
-  /** Dispose all adapters and clear the registry. */
-  async disposeAll() {
-    await Promise.all(Array.from(this.adapters.values()).map((a) => a.dispose()));
-    this.adapters.clear();
+  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 SSD_BASE = process.env.REVEALUI_SSD_PATH ?? "/mnt/e/.revealui";
+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 SSD_CONFIG_FILES = {
+var ROOT_CONFIG_FILES = {
   "claude-code": "settings.json",
   cursor: "settings.json",
   copilot: "hosts.json"
@@ -239,22 +337,20 @@ var SSD_CONFIG_FILES = {
 function getLocalConfigPath(harnessId) {
   return LOCAL_CONFIG_PATHS[harnessId];
 }
-function getSsdConfigPath(harnessId, ssdBase = SSD_BASE) {
-  const file = SSD_CONFIG_FILES[harnessId];
+function getRootConfigPath(harnessId, root = REVEALUI_ROOT) {
+  const file = ROOT_CONFIG_FILES[harnessId];
   if (!file) return void 0;
-  return join(ssdBase, "harness-configs", harnessId, file);
+  return join(root, "harness-configs", harnessId, file);
 }
 function getConfigurableHarnesses() {
   return Object.keys(LOCAL_CONFIG_PATHS);
 }
 
 // src/config/config-sync.ts
-import { copyFileSync, existsSync, mkdirSync, readFileSync } from "fs";
-import { dirname } from "path";
-function syncConfig(harnessId, direction, ssdBase) {
+function syncConfig(harnessId, direction, root) {
   const localPath = getLocalConfigPath(harnessId);
-  const ssdPath = getSsdConfigPath(harnessId, ssdBase);
-  if (!(localPath && ssdPath)) {
+  const rootPath = getRootConfigPath(harnessId, root);
+  if (!(localPath && rootPath)) {
     return {
       success: false,
       harnessId,
@@ -264,12 +360,13 @@ function syncConfig(harnessId, direction, ssdBase) {
   }
   try {
     if (direction === "pull") {
-      if (!existsSync(ssdPath)) {
-        return { success: false, harnessId, direction, message: `SSD config not found: ${ssdPath}` };
+      if (!existsSync(rootPath)) {
+        return { success: false, harnessId, direction, message: `Root config not found: ${rootPath}` };
       }
       mkdirSync(dirname(localPath), { recursive: true });
-      copyFileSync(ssdPath, localPath);
-      return { success: true, harnessId, direction, message: `Pulled ${ssdPath} \u2192 ${localPath}` };
+      backupIfExists(localPath);
+      copyFileSync(rootPath, localPath);
+      return { success: true, harnessId, direction, message: `Pulled ${rootPath} \u2192 ${localPath}` };
     } else {
       if (!existsSync(localPath)) {
         return {
@@ -279,9 +376,10 @@ function syncConfig(harnessId, direction, ssdBase) {
           message: `Local config not found: ${localPath}`
         };
       }
-      mkdirSync(dirname(ssdPath), { recursive: true });
-      copyFileSync(localPath, ssdPath);
-      return { success: true, harnessId, direction, message: `Pushed ${localPath} \u2192 ${ssdPath}` };
+      mkdirSync(dirname(rootPath), { recursive: true });
+      backupIfExists(rootPath);
+      copyFileSync(localPath, rootPath);
+      return { success: true, harnessId, direction, message: `Pushed ${localPath} \u2192 ${rootPath}` };
     }
   } catch (err) {
     return {
@@ -292,32 +390,130 @@ function syncConfig(harnessId, direction, ssdBase) {
     };
   }
 }
-function diffConfig(harnessId, ssdBase) {
+function diffConfig(harnessId, root) {
   const localPath = getLocalConfigPath(harnessId);
-  const ssdPath = getSsdConfigPath(harnessId, ssdBase);
+  const rootPath = getRootConfigPath(harnessId, root);
   const localExists = !!localPath && existsSync(localPath);
-  const ssdExists = !!ssdPath && existsSync(ssdPath);
+  const ssdExists = !!rootPath && existsSync(rootPath);
   if (!(localExists && ssdExists)) {
     return { harnessId, localExists, ssdExists, identical: false };
   }
   try {
     const localContent = readFileSync(localPath, "utf8");
-    const ssdContent = readFileSync(ssdPath, "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/detection/auto-detector.ts
+async function autoDetectHarnesses(registry) {
+  const candidates = [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 execFile2 } from "child_process";
+import { execFile as execFile3 } from "child_process";
 import { readdir } from "fs/promises";
 import { join as join2 } from "path";
-import { promisify as promisify2 } from "util";
-var execFileAsync2 = promisify2(execFile2);
+import { promisify as promisify3 } from "util";
+var execFileAsync3 = promisify3(execFile3);
 async function findProcesses(pattern) {
   try {
-    const { stdout } = await execFileAsync2("pgrep", ["-a", pattern], { timeout: 3e3 });
+    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);
@@ -367,7 +563,6 @@ async function findClaudeCodeSockets() {
 }
 
 // src/server/rpc-server.ts
-import { createServer } from "net";
 var ERR_PARSE = -32700;
 var ERR_INVALID_PARAMS = -32602;
 var ERR_METHOD_NOT_FOUND = -32601;
@@ -392,6 +587,7 @@ var RpcServer = class {
     });
   }
   server = createServer();
+  healthCheckFn = null;
   handleLine(line, reply) {
     let req;
     try {
@@ -492,6 +688,17 @@ var RpcServer = class {
         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",
@@ -500,6 +707,10 @@ var RpcServer = class {
         };
     }
   }
+  /** 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());
@@ -512,7 +723,6 @@ var RpcServer = class {
 };
 
 // src/coordinator.ts
-import { join as join3 } from "path";
 var HarnessCoordinator = class {
   constructor(options) {
     this.options = options;
@@ -544,6 +754,7 @@ var HarnessCoordinator = class {
     });
     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() {
@@ -573,23 +784,92 @@ var HarnessCoordinator = class {
   registerAdapter(adapter) {
     this.registry.register(adapter);
   }
+  /** Run a health check across all registered harnesses and the workboard. */
+  async healthCheck() {
+    const diagnostics = [];
+    const STALE_MS = 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 > STALE_MS) {
+          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,
   CopilotAdapter,
+  CursorAdapter,
   autoDetectHarnesses,
   HarnessRegistry,
   getLocalConfigPath,
-  getSsdConfigPath,
+  getRootConfigPath,
   getConfigurableHarnesses,
   syncConfig,
   diffConfig,
+  syncAllConfigs,
+  diffAllConfigs,
+  validateConfigJson,
   findProcesses,
   findHarnessProcesses,
   findAllHarnessProcesses,
   findClaudeCodeSockets,
   RpcServer,
-  HarnessCoordinator
+  HarnessCoordinator,
+  checkHarnessesLicense
 };
-//# sourceMappingURL=chunk-BDA7D725.js.map
+//# sourceMappingURL=chunk-MO2EXBUG.js.map