@digitalforgestudios/openclaw-sulcus 3.4.0 → 3.5.1

package/index.ts

@@ -1,5 +1,8 @@
 import { resolve } from "node:path";
 import { existsSync } from "node:fs";
+import * as https from "node:https";
+import * as http from "node:http";
+import { URL } from "node:url";
 import { Type } from "@sinclair/typebox";
 
 // ─── STATIC AWARENESS ───────────────────────────────────────────────────────
@@ -128,6 +131,157 @@ const hookHandlers: Record<string, HookHandler> = {
   },
 };
 
+// ─── CLOUD HTTP CLIENT ───────────────────────────────────────────────────────
+// Lightweight fallback client for users without local dylibs/WASM.
+// Uses Node.js built-in https/http — ZERO external dependencies.
+// Activates only when serverUrl + apiKey are configured and local libs are absent.
+
+class SulcusCloudClient {
+  private serverUrl: string;
+  private apiKey: string;
+
+  constructor(serverUrl: string, apiKey: string) {
+    // Strip trailing slash for clean path concatenation
+    this.serverUrl = serverUrl.replace(/\/+$/, "");
+    this.apiKey = apiKey;
+  }
+
+  /** Low-level HTTP helper. Returns parsed JSON response body. */
+  private request(method: string, path: string, body?: any): Promise<any> {
+    return new Promise((resolve, reject) => {
+      let parsedUrl: URL;
+      try {
+        parsedUrl = new URL(this.serverUrl + path);
+      } catch (e: any) {
+        return reject(new Error(`SulcusCloudClient: invalid URL ${this.serverUrl}${path}: ${e.message}`));
+      }
+
+      const isHttps = parsedUrl.protocol === "https:";
+      const transport = isHttps ? https : http;
+
+      const bodyStr = body !== undefined ? JSON.stringify(body) : undefined;
+      const headers: Record<string, string> = {
+        "Authorization": `Bearer ${this.apiKey}`,
+        "Accept": "application/json",
+      };
+      if (bodyStr !== undefined) {
+        headers["Content-Type"] = "application/json";
+        headers["Content-Length"] = String(Buffer.byteLength(bodyStr));
+      }
+
+      const options = {
+        hostname: parsedUrl.hostname,
+        port: parsedUrl.port ? parseInt(parsedUrl.port, 10) : (isHttps ? 443 : 80),
+        path: parsedUrl.pathname + parsedUrl.search,
+        method,
+        headers,
+      };
+
+      const req = transport.request(options, (res) => {
+        const chunks: Buffer[] = [];
+        res.on("data", (chunk: Buffer) => chunks.push(chunk));
+        res.on("end", () => {
+          const raw = Buffer.concat(chunks).toString("utf-8");
+          if (!res.statusCode || res.statusCode >= 400) {
+            return reject(new Error(`SulcusCloudClient: HTTP ${res.statusCode} for ${method} ${path}: ${raw.substring(0, 200)}`));
+          }
+          if (!raw || raw.trim() === "") {
+            return resolve(null);
+          }
+          try {
+            resolve(JSON.parse(raw));
+          } catch (_e) {
+            // Some endpoints return plain text (e.g. markdown export)
+            resolve(raw);
+          }
+        });
+      });
+
+      req.on("error", (e: Error) => reject(new Error(`SulcusCloudClient: network error for ${method} ${path}: ${e.message}`)));
+
+      if (bodyStr !== undefined) {
+        req.write(bodyStr);
+      }
+      req.end();
+    });
+  }
+
+  /**
+   * search_memory — maps to POST /agent/search
+   * Server returns { results: [...] }; we normalise to the results array.
+   */
+  async search_memory(query: string, limit?: number): Promise<{ results: any[] }> {
+    const body: any = { query };
+    if (limit !== undefined) body.limit = limit;
+    const res = await this.request("POST", "/agent/search", body);
+    const results = res?.results ?? res?.items ?? res?.nodes ?? (Array.isArray(res) ? res : []);
+    return { results };
+  }
+
+  /**
+   * add_memory — maps to POST /agent/nodes
+   * Server returns { id, ... }; pass through.
+   */
+  async add_memory(content: string, memoryType?: string | null): Promise<{ id: string; [key: string]: any }> {
+    const body: any = { text: content };
+    if (memoryType) body.memory_type = memoryType;
+    const res = await this.request("POST", "/agent/nodes", body);
+    return res ?? { id: "unknown" };
+  }
+
+  /**
+   * list_hot_nodes — maps to GET /agent/memory/status
+   * Returns hot_nodes list; normalised for memory_status tool.
+   */
+  async list_hot_nodes(_limit?: number): Promise<{ nodes: any[] }> {
+    const res = await this.request("GET", "/agent/memory/status");
+    const nodes = res?.hot_nodes ?? res?.nodes ?? [];
+    return { nodes };
+  }
+
+  /**
+   * consolidate — maps to POST /agent/consolidate
+   */
+  async consolidate(minHeat?: number): Promise<any> {
+    const body: any = {};
+    if (minHeat !== undefined) body.min_heat = minHeat;
+    return this.request("POST", "/agent/consolidate", body);
+  }
+
+  /**
+   * export_markdown — maps to GET /agent/export?format=markdown
+   * Returns raw markdown string.
+   */
+  async export_markdown(): Promise<string> {
+    const res = await this.request("GET", "/agent/export?format=markdown");
+    // Server may return { content: "..." } or raw string
+    if (typeof res === "string") return res;
+    return res?.content ?? res?.markdown ?? JSON.stringify(res, null, 2);
+  }
+
+  /**
+   * import_markdown — maps to POST /agent/import
+   */
+  async import_markdown(text: string): Promise<any> {
+    return this.request("POST", "/agent/import", { format: "markdown", content: text });
+  }
+
+  /**
+   * evaluate_triggers — maps to POST /agent/triggers/evaluate
+   */
+  async evaluate_triggers(event: any, contextJson?: string): Promise<any> {
+    const body: any = { event };
+    if (contextJson) {
+      try {
+        body.context = JSON.parse(contextJson);
+      } catch (_e) {
+        body.context = contextJson;
+      }
+    }
+    return this.request("POST", "/agent/triggers/evaluate", body);
+  }
+}
+
 // ─── NATIVE LIB LOADER ──────────────────────────────────────────────────────
 // Loads libsulcus_store.dylib (embedded PG) and libsulcus_vectors.dylib (embeddings)
 // via koffi FFI. Provides queryFn and embedFn callbacks for SulcusMem.create().
@@ -603,6 +757,10 @@ const sulcusPlugin = {
       ? resolve(api.config.wasmDir)
       : resolve(__dirname, "wasm");
 
+    // Cloud fallback credentials (used when local libs unavailable)
+    const serverUrl: string | undefined = api.config?.serverUrl;
+    const apiKey: string | undefined = api.config?.apiKey;
+
     // Default namespace = agent name (prevents everything landing in "default")
     const agentId = api.config?.agentId || api.pluginConfig?.agentId;
     const namespace = api.config?.namespace === "default" && agentId
@@ -644,12 +802,40 @@ const sulcusPlugin = {
       api.logger.warn(`sulcus: native libs unavailable — ${nativeLoader.error}`);
     }
 
+    // ── Cloud HTTP fallback ──
+    // Activates only when local WASM/native libs are unavailable AND
+    // serverUrl + apiKey are configured. Zero external dependencies.
+    if (sulcusMem === null) {
+      if (serverUrl && apiKey) {
+        try {
+          const cloudClient = new SulcusCloudClient(serverUrl, apiKey);
+          sulcusMem = cloudClient;
+          backendMode = "cloud";
+          api.logger.info(`sulcus: using cloud backend (server: ${serverUrl})`);
+        } catch (e: any) {
+          api.logger.warn(`sulcus: cloud client init failed: ${e.message}`);
+        }
+      } else {
+        api.logger.info(`sulcus: no cloud fallback — serverUrl: ${serverUrl ? "set" : "missing"}, apiKey: ${apiKey ? "set" : "missing"}`);
+      }
+    }
+
     const isAvailable = sulcusMem !== null;
 
     // Update static awareness with runtime info
     STATIC_AWARENESS = buildStaticAwareness(backendMode, namespace);
 
-    api.logger.info(`sulcus: registered (backend: ${backendMode}, namespace: ${namespace}, available: ${isAvailable})`);
+    // ── Startup summary ──
+    if (isAvailable) {
+      api.logger.info(`sulcus: ✓ registered (backend: ${backendMode}, namespace: ${namespace})`);
+    } else {
+      const hints: string[] = [];
+      if (!serverUrl && !apiKey) hints.push("no serverUrl/apiKey for cloud mode");
+      if (serverUrl && !apiKey) hints.push("serverUrl set but apiKey missing");
+      if (!serverUrl && apiKey) hints.push("apiKey set but serverUrl missing");
+      if (nativeLoader.error) hints.push(`local: ${nativeLoader.error}`);
+      api.logger.warn(`sulcus: ✗ unavailable — ${hints.join("; ") || "unknown reason"}. Configure serverUrl+apiKey for cloud, or install native dylibs for local.`);
+    }
 
     // ── Shared deps for tool executors ──
     const toolDeps: ToolDeps = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digitalforgestudios/openclaw-sulcus",
-  "version": "3.4.0",
+  "version": "3.5.1",
   "description": "Sulcus — reactive, thermodynamic memory plugin for OpenClaw. Opt-in persistent memory with heat-based decay, semantic search, and cross-agent sync. Auto-recall and auto-capture disabled by default.",
   "keywords": [
     "openclaw",