@memtensor/memos-local-openclaw-plugin 0.3.10 → 0.3.12

package/scripts/postinstall.cjs

@@ -18,6 +18,64 @@ function warn(msg) { console.log(`${YELLOW}[memos-local]${RESET} ${msg}`); }
 function ok(msg) { console.log(`${GREEN}[memos-local]${RESET} ${msg}`); }
 function fail(msg) { console.log(`${RED}[memos-local]${RESET} ${msg}`); }
 
+const pluginDir = path.resolve(__dirname, "..");
+
+console.log(`
+${CYAN}${BOLD}┌──────────────────────────────────────────────────┐
+│  MemOS Local Memory — postinstall               │
+└──────────────────────────────────────────────────┘${RESET}
+`);
+
+log(`Plugin dir: ${DIM}${pluginDir}${RESET}`);
+log(`Node: ${process.version}  Platform: ${process.platform}-${process.arch}`);
+
+/* ═══════════════════════════════════════════════════════════
+ *  Phase 0: Ensure all dependencies are installed
+ * ═══════════════════════════════════════════════════════════ */
+
+function ensureDependencies() {
+  const coreDeps = ["@sinclair/typebox", "uuid", "posthog-node", "@huggingface/transformers"];
+  const missing = [];
+  for (const dep of coreDeps) {
+    try {
+      require.resolve(dep, { paths: [pluginDir] });
+    } catch {
+      missing.push(dep);
+    }
+  }
+
+  if (missing.length === 0) {
+    ok("All dependencies present.");
+    return;
+  }
+
+  warn(`Missing dependencies: ${missing.join(", ")}`);
+  log("Running: npm install --omit=dev (this may take a moment)...");
+
+  const startMs = Date.now();
+  const result = spawnSync("npm", ["install", "--omit=dev"], {
+    cwd: pluginDir,
+    stdio: "inherit",
+    shell: true,
+    timeout: 120_000,
+  });
+  const elapsed = ((Date.now() - startMs) / 1000).toFixed(1);
+
+  if (result.status === 0) {
+    ok(`Dependencies installed (${elapsed}s).`);
+  } else {
+    fail(`npm install exited with code ${result.status} (${elapsed}s).`);
+    warn("Some features may not work. Try running manually:");
+    warn(`  cd ${pluginDir} && npm install --omit=dev`);
+  }
+}
+
+try {
+  ensureDependencies();
+} catch (e) {
+  warn(`Dependency check skipped: ${e.message}`);
+}
+
 /* ═══════════════════════════════════════════════════════════
  *  Phase 1: Clean up legacy plugin versions
  * ═══════════════════════════════════════════════════════════ */
@@ -52,7 +110,6 @@ function cleanupLegacy() {
     }
   }
 
-  // Clean up openclaw.json config — migrate old plugin entries
   const cfgPath = path.join(ocHome, "openclaw.json");
   if (fs.existsSync(cfgPath)) {
     try {
@@ -67,9 +124,8 @@ function cleanupLegacy() {
           if (entries[oldKey]) {
             const oldEntry = entries[oldKey];
             if (!entries["memos-local-openclaw-plugin"]) {
-              // Migrate: copy old config to new key
               entries["memos-local-openclaw-plugin"] = oldEntry;
-              log(`Migrated config: ${DIM}${oldKey}${RESET} → ${GREEN}memos-local-openclaw-plugin${RESET}`);
+              log(`Migrated config: ${DIM}${oldKey}${RESET} -> ${GREEN}memos-local-openclaw-plugin${RESET}`);
             }
             delete entries[oldKey];
             cfgChanged = true;
@@ -77,7 +133,6 @@ function cleanupLegacy() {
           }
         }
 
-        // Fix source path if it points to old directory names
         const newEntry = entries["memos-local-openclaw-plugin"];
         if (newEntry && typeof newEntry.source === "string") {
           const oldSource = newEntry.source;
@@ -86,14 +141,13 @@ function cleanupLegacy() {
               .replace(/memos-lite-openclaw-plugin/g, "memos-local-openclaw-plugin")
               .replace(/memos-lite/g, "memos-local");
             if (newEntry.source !== oldSource) {
-              log(`Updated source path: ${DIM}${oldSource}${RESET} → ${GREEN}${newEntry.source}${RESET}`);
+              log(`Updated source path: ${DIM}${oldSource}${RESET} -> ${GREEN}${newEntry.source}${RESET}`);
               cfgChanged = true;
             }
           }
         }
 
         if (cfgChanged) {
-          // Write back with backup
           const backup = cfgPath + ".bak-" + Date.now();
           fs.copyFileSync(cfgPath, backup);
           fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2) + "\n", "utf-8");
@@ -127,18 +181,18 @@ log("Checking better-sqlite3 native module...");
 try {
   require("better-sqlite3");
   ok("better-sqlite3 is ready.");
+  console.log(`\n${GREEN}${BOLD}[memos-local] Setup complete!${RESET} Restart the gateway: ${CYAN}openclaw gateway stop && openclaw gateway start${RESET}\n`);
   process.exit(0);
 } catch (_) {
   warn("better-sqlite3 native bindings not found, attempting rebuild...");
 }
 
-log(`Node: ${process.version}  Platform: ${process.platform}-${process.arch}`);
 log("Running: npm rebuild better-sqlite3 (this may take 30-60 seconds)...");
 
 const startMs = Date.now();
 
 const result = spawnSync("npm", ["rebuild", "better-sqlite3"], {
-  cwd: path.resolve(__dirname, ".."),
+  cwd: pluginDir,
   stdio: "inherit",
   shell: true,
   timeout: 180_000,
@@ -151,6 +205,7 @@ if (result.status === 0) {
     delete require.cache[require.resolve("better-sqlite3")];
     require("better-sqlite3");
     ok(`better-sqlite3 rebuilt successfully (${elapsed}s).`);
+    console.log(`\n${GREEN}${BOLD}[memos-local] Setup complete!${RESET} Restart the gateway: ${CYAN}openclaw gateway stop && openclaw gateway start${RESET}\n`);
     process.exit(0);
   } catch (_) {
     fail(`Rebuild completed but module still cannot load (${elapsed}s).`);
@@ -159,7 +214,6 @@ if (result.status === 0) {
   fail(`Rebuild failed with exit code ${result.status} (${elapsed}s).`);
 }
 
-const pluginDir = path.resolve(__dirname, "..");
 console.log(`
 ${YELLOW}${BOLD}╔══════════════════════════════════════════════════════════════╗
 ║  better-sqlite3 native module build failed                   ║
@@ -176,6 +230,7 @@ ${YELLOW}║${RESET}
 ${YELLOW}║${RESET}  Then retry:                                                ${YELLOW}║${RESET}
 ${YELLOW}║${RESET}  ${GREEN}cd ${pluginDir}${RESET}
 ${YELLOW}║${RESET}  ${GREEN}npm rebuild better-sqlite3${RESET}                                ${YELLOW}║${RESET}
+${YELLOW}║${RESET}  ${GREEN}openclaw gateway stop && openclaw gateway start${RESET}           ${YELLOW}║${RESET}
 ${YELLOW}${BOLD}╚══════════════════════════════════════════════════════════════╝${RESET}
 `);
 

package/src/viewer/html.ts

@@ -2868,17 +2868,22 @@ async function loadAll(){
 }
 
 async function loadStats(){
-  const r=await fetch('/api/stats');
-  const d=await r.json();
+  let d;
+  try{
+    const r=await fetch('/api/stats');
+    d=await r.json();
+  }catch(e){ d={}; }
+  if(!d||typeof d!=='object') d={};
+  const tm=d.totalMemories||0;
   const dedupB=d.dedupBreakdown||{};
-  const activeCount=dedupB.active||d.totalMemories;
+  const activeCount=dedupB.active||tm;
   const inactiveCount=(dedupB.duplicate||0)+(dedupB.merged||0);
-  document.getElementById('statTotal').textContent=d.totalMemories;
+  document.getElementById('statTotal').textContent=tm;
   if(inactiveCount>0){
     document.getElementById('statTotal').title=activeCount+' '+t('stat.active')+', '+inactiveCount+' '+t('stat.deduped');
   }
-  document.getElementById('statSessions').textContent=d.totalSessions;
-  document.getElementById('statEmbeddings').textContent=d.totalEmbeddings;
+  document.getElementById('statSessions').textContent=d.totalSessions||0;
+  document.getElementById('statEmbeddings').textContent=d.totalEmbeddings||0;
   let days=0;
   if(d.timeRange&&d.timeRange.earliest!=null&&d.timeRange.latest!=null){
     let e=Number(d.timeRange.earliest), l=Number(d.timeRange.latest);
@@ -2900,7 +2905,7 @@ async function loadStats(){
   }
 
   const sl=document.getElementById('sessionList');
-  sl.innerHTML='<div class="session-item'+(activeSession===null?' active':'')+'" onclick="filterSession(null)"><span>'+t('sidebar.allsessions')+'</span><span class="count">'+d.totalMemories+'</span></div>';
+  sl.innerHTML='<div class="session-item'+(activeSession===null?' active':'')+'" onclick="filterSession(null)"><span>'+t('sidebar.allsessions')+'</span><span class="count">'+tm+'</span></div>';
   (d.sessions||[]).forEach(s=>{
     const isActive=activeSession===s.session_key;
     const name=s.session_key.length>20?s.session_key.slice(0,8)+'...'+s.session_key.slice(-8):s.session_key;
@@ -2927,16 +2932,23 @@ async function loadMemories(page){
   if(page) currentPage=page;
   const list=document.getElementById('memoryList');
   list.innerHTML='<div class="spinner"></div>';
-  const p=getFilterParams();
-  p.set('limit',PAGE_SIZE);
-  p.set('page',currentPage);
-  const r=await fetch('/api/memories?'+p.toString());
-  const d=await r.json();
-  totalPages=d.totalPages||1;
-  totalCount=d.total||0;
-  document.getElementById('searchMeta').textContent=totalCount+t('search.meta.total');
-  renderMemories(d.memories||[]);
-  renderPagination();
+  try{
+    const p=getFilterParams();
+    p.set('limit',PAGE_SIZE);
+    p.set('page',currentPage);
+    const r=await fetch('/api/memories?'+p.toString());
+    const d=await r.json();
+    totalPages=d.totalPages||1;
+    totalCount=d.total||0;
+    document.getElementById('searchMeta').textContent=totalCount+t('search.meta.total');
+    renderMemories(d.memories||[]);
+    renderPagination();
+  }catch(e){
+    list.innerHTML='';
+    totalPages=1;totalCount=0;
+    renderMemories([]);
+    renderPagination();
+  }
 }
 
 async function doSearch(q){
@@ -3261,11 +3273,11 @@ async function migrateScan(){
 
   try{
     const r=await fetch('/api/migrate/scan');
-    if(!r.ok){ const err=await r.text(); throw new Error(err); }
-    const d=await r.json();
+    const d=await r.json().catch(()=>({}));
+    if(d.error && !d.sqliteFiles) throw new Error(d.error);
     migrateScanData=d;
 
-    const files=d.sqliteFiles||[];
+    const files=Array.isArray(d.sqliteFiles)?d.sqliteFiles:[];
     const sess=d.sessions||{count:0,messages:0};
     const sqliteTotal=files.reduce((s,f)=>s+f.chunks,0);
     document.getElementById('migrateSqliteCount').textContent=sqliteTotal;

package/src/viewer/server.ts

@@ -447,36 +447,55 @@ export class ViewerServer {
   }
 
   private serveStats(res: http.ServerResponse): void {
-    const db = (this.store as any).db;
-    const total = db.prepare("SELECT COUNT(*) as count FROM chunks").get() as any;
-    const sessions = db.prepare("SELECT COUNT(DISTINCT session_key) as count FROM chunks").get() as any;
-    const roles = db.prepare("SELECT role, COUNT(*) as count FROM chunks GROUP BY role").all() as any[];
-    const timeRange = db.prepare("SELECT MIN(created_at) as earliest, MAX(created_at) as latest FROM chunks").get() as any;
-    const embeddings = db.prepare("SELECT COUNT(*) as count FROM embeddings").get() as any;
-    const kinds = db.prepare("SELECT kind, COUNT(*) as count FROM chunks GROUP BY kind").all() as any[];
-    const sessionList = db.prepare(
-      "SELECT session_key, COUNT(*) as count, MIN(created_at) as earliest, MAX(created_at) as latest FROM chunks GROUP BY session_key ORDER BY latest DESC",
-    ).all() as any[];
-
-    let skillCount = 0;
-    try { skillCount = (db.prepare("SELECT COUNT(*) as count FROM skills").get() as any).count; } catch { /* table may not exist yet */ }
-
-    let dedupBreakdown: Record<string, number> = {};
+    const emptyStats = {
+      totalMemories: 0, totalSessions: 0, totalEmbeddings: 0, totalSkills: 0,
+      embeddingProvider: this.embedder?.provider ?? "none",
+      roleBreakdown: {}, kindBreakdown: {}, dedupBreakdown: {},
+      timeRange: { earliest: null, latest: null },
+      sessions: [],
+    };
+
+    if (!this.store || !(this.store as any).db) {
+      this.jsonResponse(res, emptyStats);
+      return;
+    }
+
     try {
-      const dedupRows = db.prepare("SELECT dedup_status, COUNT(*) as count FROM chunks GROUP BY dedup_status").all() as any[];
-      dedupBreakdown = Object.fromEntries(dedupRows.map((d: any) => [d.dedup_status ?? "active", d.count]));
-    } catch { /* column may not exist yet */ }
+      const db = (this.store as any).db;
+      const total = db.prepare("SELECT COUNT(*) as count FROM chunks").get() as any;
+      const sessions = db.prepare("SELECT COUNT(DISTINCT session_key) as count FROM chunks").get() as any;
+      const roles = db.prepare("SELECT role, COUNT(*) as count FROM chunks GROUP BY role").all() as any[];
+      const timeRange = db.prepare("SELECT MIN(created_at) as earliest, MAX(created_at) as latest FROM chunks").get() as any;
+      let embCount = 0;
+      try { embCount = (db.prepare("SELECT COUNT(*) as count FROM embeddings").get() as any).count; } catch { /* table may not exist */ }
+      const kinds = db.prepare("SELECT kind, COUNT(*) as count FROM chunks GROUP BY kind").all() as any[];
+      const sessionList = db.prepare(
+        "SELECT session_key, COUNT(*) as count, MIN(created_at) as earliest, MAX(created_at) as latest FROM chunks GROUP BY session_key ORDER BY latest DESC",
+      ).all() as any[];
+
+      let skillCount = 0;
+      try { skillCount = (db.prepare("SELECT COUNT(*) as count FROM skills").get() as any).count; } catch { /* table may not exist yet */ }
+
+      let dedupBreakdown: Record<string, number> = {};
+      try {
+        const dedupRows = db.prepare("SELECT dedup_status, COUNT(*) as count FROM chunks GROUP BY dedup_status").all() as any[];
+        dedupBreakdown = Object.fromEntries(dedupRows.map((d: any) => [d.dedup_status ?? "active", d.count]));
+      } catch { /* column may not exist yet */ }
 
-    this.jsonResponse(res, {
-      totalMemories: total.count, totalSessions: sessions.count, totalEmbeddings: embeddings.count,
-      totalSkills: skillCount,
-      embeddingProvider: this.embedder.provider,
-      roleBreakdown: Object.fromEntries(roles.map((r: any) => [r.role, r.count])),
-      kindBreakdown: Object.fromEntries(kinds.map((k: any) => [k.kind, k.count])),
-      dedupBreakdown,
-      timeRange: { earliest: timeRange.earliest, latest: timeRange.latest },
-      sessions: sessionList,
-    });
+      this.jsonResponse(res, {
+        totalMemories: total.count, totalSessions: sessions.count, totalEmbeddings: embCount,
+        totalSkills: skillCount,
+        embeddingProvider: this.embedder.provider,
+        roleBreakdown: Object.fromEntries(roles.map((r: any) => [r.role, r.count])),
+        kindBreakdown: Object.fromEntries(kinds.map((k: any) => [k.kind, k.count])),
+        dedupBreakdown,
+        timeRange: { earliest: timeRange.earliest, latest: timeRange.latest },
+        sessions: sessionList,
+      });
+    } catch (e) {
+      this.log.warn(`stats error: ${e}`);
+      this.jsonResponse(res, emptyStats);
+    }
   }
 
   private async serveSearch(_req: http.IncomingMessage, res: http.ServerResponse, url: URL): Promise<void> {
@@ -943,8 +962,17 @@ export class ViewerServer {
       });
     } catch (e) {
       this.log.warn(`migrate/scan error: ${e}`);
-      res.writeHead(500, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ error: String(e) }));
+      this.jsonResponse(res, {
+        sqliteFiles: [],
+        sessions: { count: 0, messages: 0 },
+        totalItems: 0,
+        configReady: false,
+        hasEmbedding: false,
+        hasSummarizer: false,
+        hasImportedData: false,
+        importedSessionCount: 0,
+        error: String(e),
+      });
     }
   }