memory-braid 0.3.4 → 0.3.7

package/README.md

@@ -20,7 +20,7 @@ On the target machine:
 1. Install from npm:
 
 ```bash
-openclaw plugins install memory-braid@0.3.4
+openclaw plugins install memory-braid@0.3.5
 ```
 
 2. Rebuild native dependencies inside the installed extension:
@@ -71,6 +71,7 @@ openclaw gateway restart
 If you install from npm and see native module errors like:
 
 - `Could not locate the bindings file` (sqlite3)
+- `.../node_modules/jiti/.../node_sqlite3.node` in the stack/error text
 - `Cannot find module ... sharp-*.node`
 
 run:
@@ -81,6 +82,14 @@ npm rebuild sqlite3 sharp
 openclaw gateway restart
 ```
 
+Note:
+- The `jiti/.../node_sqlite3.node` error is still a sqlite native artifact/runtime loading issue.
+- `memory-braid` now preloads sqlite via native `require` to avoid that path, but you still need `npm rebuild sqlite3 sharp` after `--ignore-scripts` installs.
+- When this happens, startup logs now include `memory_braid.mem0.error` with:
+  - `sqliteBindingsError: true`
+  - `fixCommand` (copy/paste command for that machine)
+  - `pluginDir` (resolved extension directory when available)
+
 ## Quick start: hybrid capture + multilingual NER
 
 Add this under `plugins.entries["memory-braid"].config` in your OpenClaw config:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memory-braid",
-  "version": "0.3.4",
+  "version": "0.3.7",
   "description": "OpenClaw memory plugin that augments local memory with Mem0, bootstrap import, reconcile, and capture.",
   "type": "module",
   "main": "./src/index.ts",

package/src/index.ts

@@ -439,6 +439,34 @@ const memoryBraidPlugin = {
         return;
       }
 
+      if (!statePaths) {
+        const resolvedStateDir = api.runtime.state.resolveStateDir();
+        if (resolvedStateDir) {
+          const lazyStatePaths = createStatePaths(resolvedStateDir);
+          try {
+            await ensureStateDir(lazyStatePaths);
+            statePaths = lazyStatePaths;
+            mem0.setStateDir(resolvedStateDir);
+            entityExtraction.setStateDir(resolvedStateDir);
+            log.info("memory_braid.state.ready", {
+              runId,
+              reason: "lazy_capture",
+              stateDir: resolvedStateDir,
+            });
+          } catch (err) {
+            log.warn("memory_braid.capture.skip", {
+              runId,
+              reason: "state_init_failed",
+              workspaceHash: scope.workspaceHash,
+              agentId: scope.agentId,
+              sessionKey: scope.sessionKey,
+              error: err instanceof Error ? err.message : String(err),
+            });
+            return;
+          }
+        }
+      }
+
       if (!statePaths) {
         log.warn("memory_braid.capture.skip", {
           runId,

package/src/mem0-client.ts

@@ -1,4 +1,5 @@
 import fs from "node:fs/promises";
+import { createRequire } from "node:module";
 import os from "node:os";
 import path from "node:path";
 import { normalizeForHash } from "./chunking.js";
@@ -46,6 +47,13 @@ type OssClientLike = {
 
 type OssMemoryCtor = new (config?: Record<string, unknown>) => OssClientLike;
 
+type LoadedOssModule = {
+  moduleValue: unknown;
+  loader: "require" | "import";
+  mem0Path?: string;
+  sqlite3Path?: string;
+};
+
 function extractCloudText(memory: CloudRecord): string {
   const byData = memory.data?.memory;
   if (typeof byData === "string" && byData.trim()) {
@@ -137,6 +145,48 @@ function resolveCtorFromCandidate(candidate: unknown, depth = 0): OssMemoryCtor
   );
 }
 
+function asErrorMessage(error: unknown): string {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+
+function isSqliteBindingsError(error: unknown): boolean {
+  const message = asErrorMessage(error);
+  return /Could not locate the bindings file/i.test(message) || /node_sqlite3\.node/i.test(message);
+}
+
+export function isMem0DeleteNotFoundError(error: unknown): boolean {
+  const message = asErrorMessage(error).toLowerCase();
+  if (!message) {
+    return false;
+  }
+
+  return (
+    /\bmemory\b.*\bnot found\b/.test(message) ||
+    /\bnot found\b.*\bmemory\b/.test(message) ||
+    /\bmemory\b.*\bdoes not exist\b/.test(message) ||
+    /\bno such memory\b/.test(message)
+  );
+}
+
+function createLocalRequire(): NodeJS.Require {
+  return createRequire(import.meta.url);
+}
+
+function tryResolve(requireFn: NodeJS.Require, id: string): string | undefined {
+  try {
+    return requireFn.resolve(id);
+  } catch {
+    return undefined;
+  }
+}
+
+function tryRequire(requireFn: NodeJS.Require, id: string): unknown {
+  return requireFn(id);
+}
+
 export function resolveOssMemoryCtor(moduleValue: unknown): OssMemoryCtor | undefined {
   return (
     resolveCtorFromCandidate(moduleValue) ??
@@ -300,11 +350,13 @@ export class Mem0Adapter {
   private ossClient: OssClientLike | null = null;
   private readonly cfg: MemoryBraidConfig;
   private readonly log: MemoryBraidLogger;
+  private readonly pluginDir?: string;
   private stateDir?: string;
 
   constructor(cfg: MemoryBraidConfig, log: MemoryBraidLogger, options?: Mem0AdapterOptions) {
     this.cfg = cfg;
     this.log = log;
+    this.pluginDir = this.resolvePluginDir();
     this.stateDir = options?.stateDir;
   }
 
@@ -362,7 +414,7 @@ export class Mem0Adapter {
     }
 
     try {
-      const mod = await import("mem0ai/oss");
+      const { moduleValue: mod, loader, mem0Path, sqlite3Path } = await this.loadOssModule();
       const Memory = resolveOssMemoryCtor(mod);
       if (!Memory) {
         const exportKeys = Object.keys(asRecord(mod));
@@ -384,20 +436,104 @@ export class Mem0Adapter {
       this.log.debug("memory_braid.mem0.response", {
         action: "init",
         mode: "oss",
+        loader,
+        mem0Path,
+        sqlite3Path,
         hasCustomConfig,
         sqliteDbPaths: collectSqliteDbPaths(configToUse),
       }, true);
       return this.ossClient;
     } catch (err) {
+      const sqliteBindingsError = isSqliteBindingsError(err);
       this.log.error("memory_braid.mem0.error", {
         reason: "init_failed",
         mode: "oss",
+        sqliteBindingsError,
+        ...(sqliteBindingsError ? this.nativeRebuildHint() : {}),
         error: err instanceof Error ? err.message : String(err),
       });
       return null;
     }
   }
 
+  private async loadOssModule(): Promise<LoadedOssModule> {
+    const requireFromHere = createLocalRequire();
+    const sqlite3Path = tryResolve(requireFromHere, "sqlite3");
+    if (sqlite3Path) {
+      try {
+        tryRequire(requireFromHere, sqlite3Path);
+      } catch (error) {
+        this.log.warn("memory_braid.mem0.error", {
+          reason: "sqlite3_preload_failed",
+          mode: "oss",
+          ...this.nativeRebuildHint(),
+          sqlite3Path,
+          error: asErrorMessage(error),
+        });
+      }
+    }
+
+    const mem0Path = tryResolve(requireFromHere, "mem0ai/oss");
+    if (mem0Path) {
+      try {
+        const required = tryRequire(requireFromHere, mem0Path);
+        return {
+          moduleValue: required,
+          loader: "require",
+          mem0Path,
+          sqlite3Path,
+        };
+      } catch (error) {
+        const sqliteBindingsError = isSqliteBindingsError(error);
+        this.log.warn("memory_braid.mem0.error", {
+          reason: "oss_require_failed",
+          mode: "oss",
+          mem0Path,
+          sqlite3Path,
+          sqliteBindingsError,
+          ...(sqliteBindingsError ? this.nativeRebuildHint() : {}),
+          error: asErrorMessage(error),
+        });
+      }
+    }
+
+    const imported = await import("mem0ai/oss");
+    return {
+      moduleValue: imported,
+      loader: "import",
+      mem0Path,
+      sqlite3Path,
+    };
+  }
+
+  private resolvePluginDir(): string | undefined {
+    const requireFromHere = createLocalRequire();
+    const packageJsonPath = tryResolve(requireFromHere, "../package.json");
+    if (!packageJsonPath) {
+      return undefined;
+    }
+    return path.dirname(packageJsonPath);
+  }
+
+  private nativeRebuildHint(): {
+    pluginDir?: string;
+    fixCommand: string;
+    why: string;
+  } {
+    if (this.pluginDir) {
+      return {
+        pluginDir: this.pluginDir,
+        fixCommand: `cd "${this.pluginDir}" && npm rebuild sqlite3 sharp && openclaw gateway restart`,
+        why: "OpenClaw plugin installs use --ignore-scripts, so sqlite3/sharp native artifacts may be missing after install/update.",
+      };
+    }
+
+    return {
+      fixCommand: "cd ~/.openclaw/extensions/memory-braid && npm rebuild sqlite3 sharp && openclaw gateway restart",
+      why: "OpenClaw plugin installs use --ignore-scripts, so sqlite3/sharp native artifacts may be missing after install/update.",
+    };
+  }
+
   async ensureClient(): Promise<{ mode: "cloud" | "oss"; client: CloudClientLike | OssClientLike } | null> {
     if (this.cfg.mem0.mode === "oss") {
       const client = await this.ensureOssClient();
@@ -616,6 +752,21 @@ export class Mem0Adapter {
       });
       return true;
     } catch (err) {
+      const missingRemote = isMem0DeleteNotFoundError(err);
+      if (missingRemote) {
+        this.log.debug("memory_braid.mem0.response", {
+          runId: params.runId,
+          action: "delete",
+          mode: prepared.mode,
+          workspaceHash: params.scope.workspaceHash,
+          agentId: params.scope.agentId,
+          memoryId: params.memoryId,
+          durMs: Date.now() - startedAt,
+          alreadyMissing: true,
+        });
+        return true;
+      }
+
       this.log.warn("memory_braid.mem0.error", {
         runId: params.runId,
         action: "delete",