@digitalforgestudios/openclaw-sulcus 3.3.0 → 3.5.0

package/bin/configure.mjs

@@ -12,6 +12,8 @@ import readline from 'readline';
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
+import https from 'https';
+import { execSync } from 'child_process';
 
 // ─── Colour support ───────────────────────────────────────────────────────────
 
@@ -153,6 +155,208 @@ function deepMerge(target, source) {
   return target;
 }
 
+// ─── Prebuilt binary download ─────────────────────────────────────────────────
+
+/**
+ * Detect the current platform slug used in GitHub release asset names.
+ * Returns { platform, ext } or throws if unsupported.
+ */
+function detectPlatform() {
+  const plat = process.platform;
+  const arch = process.arch;
+
+  const ext = plat === 'darwin' ? '.dylib' : '.so';
+
+  if (plat === 'darwin' && arch === 'arm64') return { platform: 'macos-arm64', ext };
+  if (plat === 'darwin' && arch === 'x64')   return { platform: 'macos-x64',   ext };
+  if (plat === 'linux'  && arch === 'x64')   return { platform: 'linux-x64',   ext };
+  if (plat === 'linux'  && arch === 'arm64') return { platform: 'linux-arm64', ext };
+
+  throw new Error(
+    `Prebuilt binaries are not available for your platform (${plat}/${arch}).\n` +
+    `  Supported: darwin/arm64, darwin/x64, linux/x64, linux/arm64`,
+  );
+}
+
+/**
+ * Follow redirects and download `url` into `destFile`.
+ * Shows a simple percentage progress bar (or dots when content-length is unknown).
+ * Follows up to maxRedirects hops.
+ */
+function downloadFile(url, destFile, maxRedirects = 5) {
+  return new Promise((resolve, reject) => {
+    let hops = 0;
+
+    function attempt(currentUrl) {
+      if (hops > maxRedirects) {
+        return reject(new Error('Too many redirects while downloading'));
+      }
+      hops++;
+
+      const parsed = new URL(currentUrl);
+      const opts = {
+        hostname: parsed.hostname,
+        path:     parsed.pathname + parsed.search,
+        method:   'GET',
+        headers:  { 'User-Agent': 'sulcus-configure/1.0' },
+      };
+
+      const req = https.request(opts, (res) => {
+        const { statusCode, headers: resHeaders } = res;
+
+        // Follow 301/302/307/308 redirects
+        if (
+          (statusCode === 301 || statusCode === 302 ||
+           statusCode === 307 || statusCode === 308) &&
+          resHeaders.location
+        ) {
+          res.resume(); // drain
+          return attempt(resHeaders.location);
+        }
+
+        if (statusCode !== 200) {
+          res.resume();
+          return reject(new Error(`HTTP ${statusCode} for ${currentUrl}`));
+        }
+
+        const total   = parseInt(resHeaders['content-length'] || '0', 10);
+        let received  = 0;
+        let lastPct   = -1;
+
+        const out = fs.createWriteStream(destFile);
+
+        res.on('data', (chunk) => {
+          received += chunk.length;
+          out.write(chunk);
+
+          if (total > 0) {
+            const pct = Math.floor((received / total) * 100);
+            if (pct !== lastPct && pct % 5 === 0) {
+              lastPct = pct;
+              process.stdout.write(`\r    Downloading... ${pct}%   `);
+            }
+          } else {
+            // No content-length — show dots
+            if (received % (64 * 1024) === 0) process.stdout.write('.');
+          }
+        });
+
+        res.on('end', () => {
+          out.end(() => {
+            process.stdout.write(`\r    Downloaded ${(received / 1024 / 1024).toFixed(1)} MB    \n`);
+            resolve();
+          });
+        });
+
+        res.on('error', (err) => {
+          out.destroy();
+          reject(err);
+        });
+      });
+
+      req.on('error', reject);
+      req.end();
+    }
+
+    attempt(url);
+  });
+}
+
+/**
+ * Download and install prebuilt dylibs for the current platform.
+ * Returns true on success, false if the user skips or something goes wrong.
+ *
+ * @param {string} resolvedLibDir  Absolute path where dylibs should be placed
+ * @param {string[]} dylibNames    Base names without extension, e.g. ['libsulcus_store', ...]
+ */
+async function downloadAndInstallBinaries(resolvedLibDir, dylibNames) {
+  let platformInfo;
+  try {
+    platformInfo = detectPlatform();
+  } catch (err) {
+    console.log(`  ${yellow('⚠')}  ${err.message}`);
+    return false;
+  }
+
+  const { platform, ext } = platformInfo;
+  const displayDir = resolvedLibDir.replace(os.homedir(), '~');
+  const tarUrl = `https://github.com/digitalforgeca/sulcus/releases/latest/download/sulcus-${platform}.tar.gz`;
+
+  console.log();
+  console.log(`  ${yellow('⚠')}  Native libraries not found at ${cyan(displayDir)}`);
+  console.log(`  ${dim(`Download prebuilt binaries for ${bold(platform)}?`)}`);
+
+  const doDownload = await askYN(`Download prebuilt binaries for ${platform}?`, true);
+  if (!doDownload) {
+    console.log(`  ${dim('Skipped. Install dylibs manually to use Sulcus.')}`);
+    return false;
+  }
+
+  // Create libDir if needed
+  try {
+    fs.mkdirSync(resolvedLibDir, { recursive: true });
+  } catch (err) {
+    console.log(`  ${red('✗')} Cannot create ${cyan(resolvedLibDir)}: ${err.message}`);
+    console.log(`  ${dim('Try running with appropriate permissions.')}`);
+    return false;
+  }
+
+  const tmpDir  = fs.mkdtempSync(path.join(os.tmpdir(), 'sulcus-'));
+  const tarPath = path.join(tmpDir, `sulcus-${platform}.tar.gz`);
+
+  console.log(`  ${dim(`→ ${tarUrl}`)}`);
+  process.stdout.write(`    Downloading...`);
+
+  try {
+    await downloadFile(tarUrl, tarPath);
+  } catch (err) {
+    console.log(`  ${red('✗')} Download failed: ${err.message}`);
+    console.log(`  ${dim('Check your internet connection or download manually:')}`);
+    console.log(`    ${cyan(tarUrl)}`);
+    try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch (_) {}
+    return false;
+  }
+
+  // Extract
+  console.log(`    Extracting...`);
+  try {
+    execSync(`tar xzf ${JSON.stringify(tarPath)} -C ${JSON.stringify(tmpDir)}`, { stdio: 'pipe' });
+  } catch (err) {
+    console.log(`  ${red('✗')} Extraction failed: ${err.message}`);
+    try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch (_) {}
+    return false;
+  }
+
+  // Move each dylib into libDir
+  let allInstalled = true;
+  for (const lib of dylibNames) {
+    const srcFile  = path.join(tmpDir, lib + ext);
+    const destFile = path.join(resolvedLibDir, lib + ext);
+
+    if (!fs.existsSync(srcFile)) {
+      console.log(`  ${yellow('⚠')}  ${lib + ext} not found in tarball`);
+      allInstalled = false;
+      continue;
+    }
+
+    try {
+      fs.copyFileSync(srcFile, destFile);
+      console.log(`  ${green('✓')} Installed: ${dim(destFile)}`);
+    } catch (err) {
+      console.log(`  ${red('✗')} Failed to install ${lib + ext}: ${err.message}`);
+      if (err.code === 'EACCES') {
+        console.log(`  ${dim('Try running with appropriate permissions (e.g. sudo).')}`);
+      }
+      allInstalled = false;
+    }
+  }
+
+  // Cleanup temp dir
+  try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch (_) {}
+
+  return allInstalled;
+}
+
 // ─── Main wizard ──────────────────────────────────────────────────────────────
 
 async function run() {
@@ -347,7 +551,7 @@ Press ${bold('Enter')} to accept defaults. ${bold('Ctrl+C')} to cancel at any ti
     console.log();
   }
 
-  // ── Step 4: Validate dylib path ───────────────────────────────────────────
+  // ── Step 4: Validate dylib path (+ auto-download if missing) ─────────────
 
   console.log(`${bold('Step 4 · Validate')}`);
 
@@ -357,30 +561,53 @@ Press ${bold('Enter')} to accept defaults. ${bold('Ctrl+C')} to cancel at any ti
             : process.platform === 'win32'  ? '.dll'
             :                                 '.so';
 
-  let dylibsOk = true;
+  /**
+   * Check which dylibs are present. Returns true when all are found.
+   */
+  function checkDylibs() {
+    if (!fs.existsSync(resolvedLibDir)) return false;
+    return dylibNames.every((lib) => fs.existsSync(path.join(resolvedLibDir, lib + ext)));
+  }
 
-  if (!fs.existsSync(resolvedLibDir)) {
-    dylibsOk = false;
-    console.log(`  ${yellow('⚠')}  Dylib directory not found: ${cyan(resolvedLibDir)}`);
-  } else {
+  let dylibsOk = checkDylibs();
+
+  if (dylibsOk) {
+    // All present — just print them
     for (const lib of dylibNames) {
-      const full = path.join(resolvedLibDir, lib + ext);
-      if (fs.existsSync(full)) {
-        console.log(`  ${green('✓')} Found: ${dim(full)}`);
-      } else {
-        dylibsOk = false;
-        console.log(`  ${yellow('⚠')}  Missing: ${dim(full)}`);
+      console.log(`  ${green('✓')} Found: ${dim(path.join(resolvedLibDir, lib + ext))}`);
+    }
+  } else {
+    // Some or all missing — try auto-download
+    const downloaded = await downloadAndInstallBinaries(resolvedLibDir, dylibNames);
+
+    if (downloaded) {
+      // Re-validate after successful download
+      dylibsOk = checkDylibs();
+      if (!dylibsOk) {
+        console.log(`  ${yellow('⚠')}  Some dylibs still missing after installation.`);
       }
+    } else if (!downloaded) {
+      // Download skipped or failed — show manual instructions
+      if (fs.existsSync(resolvedLibDir)) {
+        // Directory exists but files missing — list what we found / didn't find
+        for (const lib of dylibNames) {
+          const full = path.join(resolvedLibDir, lib + ext);
+          if (fs.existsSync(full)) {
+            console.log(`  ${green('✓')} Found: ${dim(full)}`);
+          } else {
+            console.log(`  ${yellow('⚠')}  Missing: ${dim(full)}`);
+          }
+        }
+      }
+      console.log();
+      console.log(`  ${yellow(bold('Native dylibs missing — Sulcus will not load.'))}`);
+      console.log(`  Download manually from:`);
+      console.log(`    ${cyan('https://github.com/digitalforgeca/sulcus/releases/latest')}`);
+      console.log(`  Or visit: ${cyan('https://sulcus.ca/docs/install')}`);
     }
   }
 
-  if (!dylibsOk) {
-    console.log();
-    console.log(`  ${yellow(bold('Native dylibs missing — Sulcus will not load.'))}`);;
-    console.log(`  Run the setup script to download and install them:`);
-    console.log(`    ${cyan('bash ~/.sulcus/setup-local.sh')}`);
-    console.log(`  Or visit: ${cyan('https://sulcus.ca/docs/install')}`);
-  } else {
+  if (dylibsOk) {
     console.log(`  ${green('✓')} All dylibs present — Sulcus is ready to go.`);
   }
 

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,6 +802,20 @@ 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 && 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}`);
+      }
+    }
+
     const isAvailable = sulcusMem !== null;
 
     // Update static awareness with runtime info

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digitalforgestudios/openclaw-sulcus",
-  "version": "3.3.0",
+  "version": "3.5.0",
   "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",