memorylake-openclaw 1.1.6 → 1.1.7

package/dist/index.js

@@ -238,6 +238,98 @@ function registerMemoryPromptSection(pctx, cfg) {
 // lib/tools/memory-tools.ts
 import { Type } from "@sinclair/typebox";
 
+// lib/telemetry.ts
+import { createHash } from "crypto";
+var PLUGIN_VERSION = true ? "1.1.7" : "dev";
+var DEFAULT_POSTHOG_HOST = "https://us.i.posthog.com/i/v0/e/";
+var POSTHOG_API_KEY = process.env.MEMORYLAKE_POSTHOG_API_KEY?.trim() ?? "";
+var POSTHOG_HOST = normalizePosthogHost(
+  process.env.MEMORYLAKE_POSTHOG_HOST?.trim() || DEFAULT_POSTHOG_HOST
+);
+var FLUSH_INTERVAL_MS = 5e3;
+var FLUSH_THRESHOLD = 10;
+var eventQueue = [];
+var flushTimer;
+var telemetryEnabled;
+var exitHandlerInstalled = false;
+function normalizePosthogHost(value) {
+  const trimmed = value.replace(/\/+$/, "");
+  return trimmed.endsWith("/i/v0/e") ? `${trimmed}/` : `${trimmed}/i/v0/e/`;
+}
+function isTelemetryEnabled() {
+  if (telemetryEnabled !== void 0) return telemetryEnabled;
+  telemetryEnabled = !!POSTHOG_API_KEY;
+  return telemetryEnabled;
+}
+function getDistinctId(apiKey = "") {
+  return createHash("sha256").update(apiKey).digest("hex");
+}
+function ensureFlushTimer() {
+  if (flushTimer) return;
+  flushTimer = setInterval(flushEvents, FLUSH_INTERVAL_MS);
+  if (typeof flushTimer === "object" && "unref" in flushTimer) {
+    flushTimer.unref();
+  }
+}
+function ensureExitHandler() {
+  if (exitHandlerInstalled) return;
+  exitHandlerInstalled = true;
+  process.on("beforeExit", async () => {
+    if (eventQueue.length === 0) return;
+    const batch = eventQueue;
+    eventQueue = [];
+    const body = JSON.stringify({ api_key: POSTHOG_API_KEY, batch });
+    try {
+      await fetch(POSTHOG_HOST, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body,
+        signal: AbortSignal.timeout(3e3)
+      });
+    } catch {
+    }
+  });
+}
+function flushEvents() {
+  if (eventQueue.length === 0) return;
+  const batch = eventQueue;
+  eventQueue = [];
+  const body = JSON.stringify({ api_key: POSTHOG_API_KEY, batch });
+  fetch(POSTHOG_HOST, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body,
+    signal: AbortSignal.timeout(3e3)
+  }).catch(() => {
+  });
+}
+function captureEvent(eventName, properties = {}, ctx) {
+  if (!isTelemetryEnabled()) return;
+  try {
+    const distinctId = getDistinctId(ctx.apiKey ?? "");
+    eventQueue.push({
+      event: eventName,
+      distinct_id: distinctId,
+      properties: {
+        source: "OPENCLAW",
+        language: "node",
+        plugin_version: PLUGIN_VERSION,
+        node_version: process.version,
+        os: process.platform,
+        $process_person_profile: false,
+        $lib: "posthog-node",
+        ...properties
+      }
+    });
+    ensureFlushTimer();
+    ensureExitHandler();
+    if (eventQueue.length >= FLUSH_THRESHOLD) {
+      flushEvents();
+    }
+  } catch {
+  }
+}
+
 // lib/provider.ts
 import got from "got";
 
@@ -473,7 +565,7 @@ function getProvider(effectiveCfg) {
 }
 
 // lib/utils/builders.ts
-var PLUGIN_VERSION = true ? "1.1.6" : "dev";
+var PLUGIN_VERSION2 = true ? "1.1.7" : "dev";
 function buildDocumentContext(results, maxChunkLength = 1e4) {
   const parts = [];
   for (const result of results) {
@@ -552,7 +644,7 @@ function buildAddOptions(effectiveCfg, userIdOverride, sessionId) {
   const opts = {
     user_id: userIdOverride || effectiveCfg.userId,
     infer: true,
-    metadata: { source: "OPENCLAW", plugin_version: PLUGIN_VERSION }
+    metadata: { source: "OPENCLAW", plugin_version: PLUGIN_VERSION2 }
   };
   if (sessionId) opts.chat_session_id = sessionId;
   return opts;
@@ -588,6 +680,7 @@ function registerMemoryTools(pctx, cfg) {
         )
       }),
       async execute(_toolCallId, params) {
+        const start = Date.now();
         const effectiveCfg = resolveConfig(ctx);
         const effectiveProvider = getProvider(effectiveCfg);
         const { query, limit, userId } = params;
@@ -601,6 +694,8 @@ function registerMemoryTools(pctx, cfg) {
         const sections = [];
         let memoryCount = 0;
         let docCount = 0;
+        let conflictCount = 0;
+        let conflictFetchFailed = false;
         let sanitizedMemories = [];
         if (memoryResult.status === "fulfilled" && memoryResult.value.length > 0) {
           const results = memoryResult.value;
@@ -621,6 +716,7 @@ ${text}`);
               const effectiveUserId = userId ?? effectiveCfg.userId;
               const conflicts = await effectiveProvider.listConflicts(conflictMemoryIds, effectiveUserId);
               if (conflicts.length > 0) {
+                conflictCount = conflicts.length;
                 const conflictText = buildConflictContext(conflicts);
                 sections.push(`## Memory Conflicts
 The following memories have unresolved conflicts. Review and help the user resolve them if relevant:
@@ -628,6 +724,7 @@ The following memories have unresolved conflicts. Review and help the user resol
 ${conflictText}`);
               }
             } catch (err) {
+              conflictFetchFailed = true;
               sections.push(`## Memory Conflicts
 Failed to fetch conflicts: ${String(err)}`);
             }
@@ -647,6 +744,20 @@ ${context}`);
           sections.push(`## Documents
 Document search failed: ${String(docResult.reason)}`);
         }
+        const allFailed = memoryResult.status === "rejected" && docResult.status === "rejected";
+        const partialSuccess = !allFailed && (memoryResult.status === "rejected" || docResult.status === "rejected" || conflictFetchFailed);
+        captureEvent(
+          "memorylake.tool.retrieve_context",
+          {
+            success: !allFailed,
+            partial_success: partialSuccess,
+            latency_ms: Date.now() - start,
+            memory_count: memoryCount,
+            document_count: docCount,
+            conflict_count: conflictCount
+          },
+          effectiveCfg
+        );
         if (memoryCount === 0 && docCount === 0) {
           return {
             content: [
@@ -691,6 +802,7 @@ Document search failed: ${String(docResult.reason)}`);
         )
       }),
       async execute(_toolCallId, params) {
+        const start = Date.now();
         const effectiveCfg = resolveConfig(ctx);
         const effectiveProvider = getProvider(effectiveCfg);
         const { text, userId } = params;
@@ -700,6 +812,15 @@ Document search failed: ${String(docResult.reason)}`);
             buildAddOptions(effectiveCfg, userId, ctx?.sessionId)
           );
           const count = result.results?.length ?? 0;
+          captureEvent(
+            "memorylake.tool.memory_store",
+            {
+              success: true,
+              latency_ms: Date.now() - start,
+              result_count: count
+            },
+            effectiveCfg
+          );
           return {
             content: [
               {
@@ -713,6 +834,15 @@ Document search failed: ${String(docResult.reason)}`);
             }
           };
         } catch (err) {
+          captureEvent(
+            "memorylake.tool.memory_store",
+            {
+              success: false,
+              latency_ms: Date.now() - start,
+              error: String(err)
+            },
+            effectiveCfg
+          );
           return {
             content: [
               {
@@ -740,12 +870,22 @@ Document search failed: ${String(docResult.reason)}`);
         )
       }),
       async execute(_toolCallId, params) {
+        const start = Date.now();
         const effectiveCfg = resolveConfig(ctx);
         const effectiveProvider = getProvider(effectiveCfg);
         const { userId } = params;
         try {
           const uid = userId || effectiveCfg.userId;
           const memories = await effectiveProvider.getAll({ user_id: uid });
+          captureEvent(
+            "memorylake.tool.memory_list",
+            {
+              success: true,
+              latency_ms: Date.now() - start,
+              result_count: memories.length
+            },
+            effectiveCfg
+          );
           if (!memories || memories.length === 0) {
             return {
               content: [
@@ -774,6 +914,15 @@ ${text}`
             details: { count: memories.length, memories: sanitized }
           };
         } catch (err) {
+          captureEvent(
+            "memorylake.tool.memory_list",
+            {
+              success: false,
+              latency_ms: Date.now() - start,
+              error: String(err)
+            },
+            effectiveCfg
+          );
           return {
             content: [
               {
@@ -797,11 +946,20 @@ ${text}`
         memoryId: Type.String({ description: "Memory ID to delete" })
       }),
       async execute(_toolCallId, params) {
+        const start = Date.now();
         const effectiveCfg = resolveConfig(ctx);
         const effectiveProvider = getProvider(effectiveCfg);
         const { memoryId } = params;
         try {
           await effectiveProvider.delete(memoryId);
+          captureEvent(
+            "memorylake.tool.memory_forget",
+            {
+              success: true,
+              latency_ms: Date.now() - start
+            },
+            effectiveCfg
+          );
           return {
             content: [
               { type: "text", text: `Memory ${memoryId} forgotten.` }
@@ -809,6 +967,15 @@ ${text}`
             details: { action: "deleted", id: memoryId }
           };
         } catch (err) {
+          captureEvent(
+            "memorylake.tool.memory_forget",
+            {
+              success: false,
+              latency_ms: Date.now() - start,
+              error: String(err)
+            },
+            effectiveCfg
+          );
           return {
             content: [
               {
@@ -863,6 +1030,7 @@ function registerDocumentTools(pctx) {
         })
       }),
       async execute(_toolCallId, params) {
+        const start = Date.now();
         const effectiveCfg = resolveConfig(ctx);
         const effectiveProvider = getProvider(effectiveCfg);
         const { documentId } = params;
@@ -892,6 +1060,14 @@ function registerDocumentTools(pctx) {
             }
           }
           fs3.renameSync(tempPath, localPath);
+          captureEvent(
+            "memorylake.tool.document_download",
+            {
+              success: true,
+              latency_ms: Date.now() - start
+            },
+            effectiveCfg
+          );
           return {
             content: [
               {
@@ -905,6 +1081,15 @@ You MUST now call the message tool with action="send" and media set to this loca
             details: { documentId, localPath }
           };
         } catch (err) {
+          captureEvent(
+            "memorylake.tool.document_download",
+            {
+              success: false,
+              latency_ms: Date.now() - start,
+              error: String(err)
+            },
+            effectiveCfg
+          );
           return {
             content: [
               {
@@ -973,6 +1158,7 @@ function registerSearchTools(pctx, cfg) {
         )
       }),
       async execute(_toolCallId, params) {
+        const start = Date.now();
         const effectiveCfg = resolveConfig(ctx);
         const effectiveProvider = getProvider(effectiveCfg);
         const {
@@ -997,6 +1183,15 @@ function registerSearchTools(pctx, cfg) {
             } : void 0
           });
           if (!response.results || response.results.length === 0) {
+            captureEvent(
+              "memorylake.tool.advanced_web_search",
+              {
+                success: true,
+                latency_ms: Date.now() - start,
+                result_count: 0
+              },
+              effectiveCfg
+            );
             return {
               content: [
                 { type: "text", text: "No relevant web results found." }
@@ -1005,6 +1200,15 @@ function registerSearchTools(pctx, cfg) {
             };
           }
           const context = buildWebSearchContext(response.results);
+          captureEvent(
+            "memorylake.tool.advanced_web_search",
+            {
+              success: true,
+              latency_ms: Date.now() - start,
+              result_count: response.results.length
+            },
+            effectiveCfg
+          );
           return {
             content: [
               {
@@ -1021,6 +1225,15 @@ ${context}`
             }
           };
         } catch (err) {
+          captureEvent(
+            "memorylake.tool.advanced_web_search",
+            {
+              success: false,
+              latency_ms: Date.now() - start,
+              error: String(err)
+            },
+            effectiveCfg
+          );
           return {
             content: [
               {
@@ -1076,6 +1289,7 @@ ${context}`
         )
       }),
       async execute(_toolCallId, params) {
+        const start = Date.now();
         const effectiveCfg = resolveConfig(ctx);
         const effectiveProvider = getProvider(effectiveCfg);
         const {
@@ -1087,6 +1301,15 @@ ${context}`
         } = params;
         const dataset = normalizeOpenDataCategory(rawDataset);
         if (!dataset) {
+          captureEvent(
+            "memorylake.tool.open_data_search",
+            {
+              success: false,
+              latency_ms: Date.now() - start,
+              error: "unsupported_dataset"
+            },
+            effectiveCfg
+          );
           return {
             content: [
               {
@@ -1102,6 +1325,15 @@ ${context}`
           if (projectInfo.industries.length > 0) {
             const allowedIds = projectInfo.industries.map((ind) => ind.id);
             if (!allowedIds.includes(dataset)) {
+              captureEvent(
+                "memorylake.tool.open_data_search",
+                {
+                  success: false,
+                  latency_ms: Date.now() - start,
+                  error: "dataset_not_allowed"
+                },
+                effectiveCfg
+              );
               const allowed = projectInfo.industries.map((ind) => `${ind.id} (${ind.name})`).join(", ");
               return {
                 content: [
@@ -1125,6 +1357,15 @@ ${context}`
             end_date: endDate
           });
           if (!response.results || response.results.length === 0) {
+            captureEvent(
+              "memorylake.tool.open_data_search",
+              {
+                success: true,
+                latency_ms: Date.now() - start,
+                result_count: 0
+              },
+              effectiveCfg
+            );
             return {
               content: [
                 { type: "text", text: "No relevant open data results found." }
@@ -1133,6 +1374,15 @@ ${context}`
             };
           }
           const context = buildOpenDataContext(response.results);
+          captureEvent(
+            "memorylake.tool.open_data_search",
+            {
+              success: true,
+              latency_ms: Date.now() - start,
+              result_count: response.results.length
+            },
+            effectiveCfg
+          );
           return {
             content: [
               {
@@ -1149,6 +1399,15 @@ ${context}`
             }
           };
         } catch (err) {
+          captureEvent(
+            "memorylake.tool.open_data_search",
+            {
+              success: false,
+              latency_ms: Date.now() - start,
+              error: String(err)
+            },
+            effectiveCfg
+          );
           return {
             content: [
               {
@@ -1176,6 +1435,7 @@ function registerCli(pctx, cfg) {
     ({ program }) => {
       const memorylake = program.command("memorylake").description("MemoryLake memory plugin commands");
       memorylake.command("search").description("Search memories in MemoryLake").argument("<query>", "Search query").option("--limit <n>", "Max results", String(cfg.topK)).action(async (query, opts) => {
+        const start = Date.now();
         try {
           const limit = parseInt(opts.limit, 10);
           const results = await provider.search(
@@ -1183,6 +1443,11 @@ function registerCli(pctx, cfg) {
             buildSearchOptions(cfg, void 0, limit)
           );
           if (!results.length) {
+            captureEvent("memorylake.cli.search", {
+              success: true,
+              latency_ms: Date.now() - start,
+              result_count: 0
+            }, cfg);
             console.log("No memories found.");
             return;
           }
@@ -1192,12 +1457,23 @@ function registerCli(pctx, cfg) {
             user_id: r.user_id,
             created_at: r.created_at
           }));
+          captureEvent("memorylake.cli.search", {
+            success: true,
+            latency_ms: Date.now() - start,
+            result_count: results.length
+          }, cfg);
           console.log(JSON.stringify(output, null, 2));
         } catch (err) {
+          captureEvent("memorylake.cli.search", {
+            success: false,
+            latency_ms: Date.now() - start,
+            error: String(err)
+          }, cfg);
           console.error(`Search failed: ${String(err)}`);
         }
       });
       memorylake.command("upload").description("Upload files or directories to MemoryLake").argument("<path>", "File or directory path to upload").option("--agent <id>", "Agent ID (resolves workspace and per-agent projectId)").option("--project-id <id>", "Override project ID (takes precedence over --agent)").action(async (targetPath, opts) => {
+        const start = Date.now();
         let effectiveCfg = cfg;
         if (opts.agent) {
           try {
@@ -1217,10 +1493,20 @@ function registerCli(pctx, cfg) {
         }
         const effectiveProjectId = opts.projectId || effectiveCfg.projectId;
         if (!effectiveProjectId) {
+          captureEvent("memorylake.cli.upload", {
+            success: false,
+            latency_ms: Date.now() - start,
+            error: "missing_project_id"
+          }, effectiveCfg);
           console.error("No project ID configured. Use --project-id or set up agent/workspace config.");
           return;
         }
         if (!effectiveCfg.host || !effectiveCfg.apiKey) {
+          captureEvent("memorylake.cli.upload", {
+            success: false,
+            latency_ms: Date.now() - start,
+            error: "missing_host_or_api_key"
+          }, effectiveCfg);
           console.error("Missing host or apiKey in config. Check your MemoryLake configuration.");
           return;
         }
@@ -1232,6 +1518,11 @@ function registerCli(pctx, cfg) {
           );
           uploadFn = uploadModule.uploadAuto;
         } catch (err) {
+          captureEvent("memorylake.cli.upload", {
+            success: false,
+            latency_ms: Date.now() - start,
+            error: String(err)
+          }, effectiveCfg);
           console.error(`Failed to load upload module: ${String(err)}`);
           return;
         }
@@ -1244,15 +1535,34 @@ function registerCli(pctx, cfg) {
             filePath: absPath,
             fileName: path3.basename(absPath)
           });
+          captureEvent("memorylake.cli.upload", {
+            success: true,
+            latency_ms: Date.now() - start,
+            agent_override: !!opts.agent,
+            project_override: !!opts.projectId
+          }, effectiveCfg);
         } catch (err) {
+          captureEvent("memorylake.cli.upload", {
+            success: false,
+            latency_ms: Date.now() - start,
+            error: String(err),
+            agent_override: !!opts.agent,
+            project_override: !!opts.projectId
+          }, effectiveCfg);
           console.error(`Upload failed: ${String(err)}`);
         }
       });
       memorylake.command("stats").description("Show memory statistics from MemoryLake").action(async () => {
+        const start = Date.now();
         try {
           const memories = await provider.getAll({
             user_id: cfg.userId
           });
+          captureEvent("memorylake.cli.stats", {
+            success: true,
+            latency_ms: Date.now() - start,
+            result_count: Array.isArray(memories) ? memories.length : 0
+          }, cfg);
           console.log(`User: ${cfg.userId}`);
           console.log(
             `Total memories: ${Array.isArray(memories) ? memories.length : "unknown"}`
@@ -1261,6 +1571,11 @@ function registerCli(pctx, cfg) {
             `Auto-recall: ${cfg.autoRecall}, Auto-capture: ${cfg.autoCapture}`
           );
         } catch (err) {
+          captureEvent("memorylake.cli.stats", {
+            success: false,
+            latency_ms: Date.now() - start,
+            error: String(err)
+          }, cfg);
           console.error(`Stats failed: ${String(err)}`);
         }
       });
@@ -1352,6 +1667,7 @@ function registerAutoUpload(pctx) {
         uploadAutoFn = uploadModule.uploadAuto;
       }
       for (const { filePath, stat } of filesToUpload) {
+        const uploadStart = Date.now();
         try {
           await uploadAutoFn({
             host: effectiveCfg.host,
@@ -1363,10 +1679,27 @@ function registerAutoUpload(pctx) {
           const current = getUploadedRecord(workspaceDir);
           current[filePath] = { mtimeMs: stat.mtimeMs };
           saveUploadedRecord(workspaceDir, current);
+          captureEvent(
+            "memorylake.hook.upload",
+            {
+              success: true,
+              latency_ms: Date.now() - uploadStart
+            },
+            effectiveCfg
+          );
           api.logger.info(
             `memorylake-openclaw: auto-uploaded ${path5.basename(filePath)}`
           );
         } catch (err) {
+          captureEvent(
+            "memorylake.hook.upload",
+            {
+              success: false,
+              latency_ms: Date.now() - uploadStart,
+              error: String(err)
+            },
+            effectiveCfg
+          );
           api.logger.warn(
             `memorylake-openclaw: auto-upload failed for ${filePath}: ${String(err)}`
           );
@@ -1396,12 +1729,15 @@ function registerAutoRecall(pctx) {
       return;
     }
     if (!event.prompt) return;
+    const recallStart = Date.now();
     const effectiveCfg = resolveConfig(ctx);
     const effectiveProvider = getProvider(effectiveCfg);
     const sessionId = ctx?.sessionId ?? void 0;
     let industries;
+    let cacheHit = false;
     if (sessionId && sessionIndustriesCache.has(sessionId)) {
       industries = sessionIndustriesCache.get(sessionId);
+      cacheHit = true;
     } else {
       try {
         const projectInfo = await effectiveProvider.getProject();
@@ -1452,6 +1788,16 @@ When the user's question relates to any of these categories, use the open_data_s
     if (appendParts.length > 0) {
       result.appendSystemContext = appendParts.join("\n\n");
     }
+    captureEvent(
+      "memorylake.hook.recall",
+      {
+        success: true,
+        cache_hit: cacheHit,
+        industries_count: industries?.length ?? 0,
+        latency_ms: Date.now() - recallStart
+      },
+      effectiveCfg
+    );
     return result;
   });
 }
@@ -1727,6 +2073,7 @@ function registerAutoCapture(pctx) {
     const effectiveCfg = resolveConfig(ctx);
     const effectiveProvider = getProvider(effectiveCfg);
     const lastSent = sessionWatermarks.get(sessionId) ?? 0;
+    const captureStart = Date.now();
     try {
       const formattedMessages = [];
       let maxTimestamp = lastSent;
@@ -1753,12 +2100,31 @@ function registerAutoCapture(pctx) {
         sessionWatermarks.set(sessionId, maxTimestamp);
       }
       const capturedCount = result.results?.length ?? 0;
+      captureEvent(
+        "memorylake.hook.capture",
+        {
+          success: true,
+          captured_count: capturedCount,
+          latency_ms: Date.now() - captureStart,
+          message_count: formattedMessages.length
+        },
+        effectiveCfg
+      );
       if (capturedCount > 0) {
         api.logger.info(
           `memorylake-openclaw: auto-captured ${capturedCount} memories from ${formattedMessages.length} new message(s)`
         );
       }
     } catch (err) {
+      captureEvent(
+        "memorylake.hook.capture",
+        {
+          success: false,
+          latency_ms: Date.now() - captureStart,
+          error: String(err)
+        },
+        effectiveCfg
+      );
       api.logger.warn(`memorylake-openclaw: capture failed: ${String(err)}`);
     }
   });
@@ -1775,6 +2141,15 @@ var memoryPlugin = {
     const cfg = memoryLakeConfigSchema.parse(api.pluginConfig);
     const pctx = createPluginContext(api, cfg);
     registerMemoryPromptSection(pctx, cfg);
+    captureEvent(
+      "memorylake.plugin.registered",
+      {
+        auto_recall: cfg.autoRecall,
+        auto_capture: cfg.autoCapture,
+        auto_upload: cfg.autoUpload
+      },
+      cfg
+    );
     api.logger.info(
       `memorylake-openclaw: registered (user: ${cfg.userId}, autoRecall: ${cfg.autoRecall}, autoCapture: ${cfg.autoCapture}, autoUpload: ${cfg.autoUpload})`
     );
@@ -1788,6 +2163,15 @@ var memoryPlugin = {
     api.registerService({
       id: "memorylake-openclaw",
       start: () => {
+        captureEvent(
+          "memorylake.plugin.initialized",
+          {
+            auto_recall: cfg.autoRecall,
+            auto_capture: cfg.autoCapture,
+            auto_upload: cfg.autoUpload
+          },
+          cfg
+        );
         api.logger.info(
           `memorylake-openclaw: initialized (user: ${cfg.userId}, autoRecall: ${cfg.autoRecall}, autoCapture: ${cfg.autoCapture}, autoUpload: ${cfg.autoUpload})`
         );