@memtensor/memos-local-openclaw-plugin 1.0.4-beta.6 → 1.0.4-beta.7

package/src/telemetry.ts

@@ -1,5 +1,5 @@
 /**
- * Telemetry module — anonymous usage analytics via Aliyun ARMS RUM.
+ * Telemetry module — anonymous usage analytics via PostHog.
  *
  * Privacy-first design:
  * - Enabled by default with anonymous data only; opt-out via TELEMETRY_ENABLED=false
@@ -8,6 +8,7 @@
  * - Only sends aggregate counts, tool names, latencies, and version info
  */
 
+import { PostHog } from "posthog-node";
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
@@ -16,61 +17,45 @@ import type { Logger } from "./types";
 
 export interface TelemetryConfig {
   enabled?: boolean;
+  posthogApiKey?: string;
+  posthogHost?: string;
 }
 
-const ARMS_ENDPOINT =
-  "https://proj-xtrace-e218d9316b328f196a3c640cc7ca84-cn-hangzhou.cn-hangzhou.log.aliyuncs.com" +
-  "/rum/web/v2" +
-  "?workspace=default-cms-1026429231103299-cn-hangzhou" +
-  "&service_id=a3u72ukxmr@066657d42a13a9a9f337f";
-
-const ARMS_PID = "a3u72ukxmr@066657d42a13a9a9f337f";
-const ARMS_ENV = "prod";
-
-const FLUSH_AT = 10;
-const FLUSH_INTERVAL_MS = 30_000;
-const SEND_TIMEOUT_MS = 30_000;
-const SESSION_TTL_MS = 30 * 60_000; // 30 min inactivity → new session
-interface ArmsEvent {
-  event_type: "custom";
-  type: string;
-  name: string;
-  group: string;
-  value: number;
-  properties: Record<string, string | number | boolean>;
-  timestamp: number;
-  event_id: string;
-  times: number;
-}
+const DEFAULT_POSTHOG_API_KEY = "phc_7lae6UC5jyImDefX6uub7zCxWyswCGNoBifCKqjvDrI";
+const DEFAULT_POSTHOG_HOST = "https://eu.i.posthog.com";
 
 export class Telemetry {
+  private client: PostHog | null = null;
   private distinctId: string;
   private enabled: boolean;
   private pluginVersion: string;
   private log: Logger;
   private dailyPingSent = false;
   private dailyPingDate = "";
-  private buffer: ArmsEvent[] = [];
-  private flushTimer: ReturnType<typeof setInterval> | null = null;
-  private sessionId: string;
-  private firstSeenDate: string;
 
   constructor(config: TelemetryConfig, stateDir: string, pluginVersion: string, log: Logger) {
     this.log = log;
     this.pluginVersion = pluginVersion;
     this.enabled = config.enabled !== false;
     this.distinctId = this.loadOrCreateAnonymousId(stateDir);
-    this.firstSeenDate = this.loadOrCreateFirstSeen(stateDir);
-    this.sessionId = this.loadOrCreateSessionId(stateDir);
 
     if (!this.enabled) {
       this.log.debug("Telemetry disabled (opt-out via TELEMETRY_ENABLED=false)");
       return;
     }
 
-    this.flushTimer = setInterval(() => this.flush(), FLUSH_INTERVAL_MS);
-    if (this.flushTimer.unref) this.flushTimer.unref();
-    this.log.debug("Telemetry initialized (ARMS)");
+    const apiKey = config.posthogApiKey || DEFAULT_POSTHOG_API_KEY;
+    try {
+      this.client = new PostHog(apiKey, {
+        host: config.posthogHost || DEFAULT_POSTHOG_HOST,
+        flushAt: 10,
+        flushInterval: 30_000,
+      });
+      this.log.debug("Telemetry initialized (PostHog)");
+    } catch (err) {
+      this.log.warn(`Telemetry init failed: ${err}`);
+      this.enabled = false;
+    }
   }
 
   private loadOrCreateAnonymousId(stateDir: string): string {
@@ -96,113 +81,24 @@ export class Telemetry {
     return newId;
   }
 
-  private loadOrCreateSessionId(stateDir: string): string {
-    const filePath = path.join(stateDir, "memos-local", ".session");
-    try {
-      const raw = fs.readFileSync(filePath, "utf-8").trim();
-      const sep = raw.indexOf("|");
-      if (sep > 0) {
-        const ts = parseInt(raw.slice(0, sep), 10);
-        const id = raw.slice(sep + 1);
-        if (id.length > 10 && Date.now() - ts < SESSION_TTL_MS) {
-          this.touchSession(filePath, id);
-          return id;
-        }
-      }
-    } catch {}
-    const newId = uuidv4();
-    this.touchSession(filePath, newId);
-    return newId;
-  }
-
-  private touchSession(filePath: string, id: string): void {
-    try {
-      fs.mkdirSync(path.dirname(filePath), { recursive: true });
-      fs.writeFileSync(filePath, `${Date.now()}|${id}`, "utf-8");
-    } catch {}
-  }
-
-  private loadOrCreateFirstSeen(stateDir: string): string {
-    const filePath = path.join(stateDir, "memos-local", ".first-seen");
-    try {
-      const existing = fs.readFileSync(filePath, "utf-8").trim();
-      if (existing.length === 10) return existing;
-    } catch {}
-    const today = new Date().toISOString().slice(0, 10);
-    try {
-      fs.mkdirSync(path.dirname(filePath), { recursive: true });
-      fs.writeFileSync(filePath, today, "utf-8");
-    } catch {}
-    return today;
-  }
-
   private capture(event: string, properties?: Record<string, unknown>): void {
-    if (!this.enabled) return;
-
-    const safeProps: Record<string, string | number | boolean> = {
-      plugin_version: this.pluginVersion,
-      os: os.platform(),
-      os_version: os.release(),
-      node_version: process.version,
-      arch: os.arch(),
-    };
-    if (properties) {
-      for (const [k, v] of Object.entries(properties)) {
-        if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
-          safeProps[k] = v;
-        }
-      }
-    }
-
-    this.buffer.push({
-      event_type: "custom",
-      type: "memos_plugin",
-      name: event,
-      group: "memos_local",
-      value: 1,
-      properties: safeProps,
-      timestamp: Date.now(),
-      event_id: uuidv4(),
-      times: 1,
-    });
-
-    if (this.buffer.length >= FLUSH_AT) {
-      this.flush();
-    }
-  }
-
-  private buildPayload(events: ArmsEvent[]): Record<string, unknown> {
-    return {
-      app: {
-        id: ARMS_PID,
-        env: ARMS_ENV,
-        version: this.pluginVersion,
-        type: "node",
-      },
-      user: { id: this.distinctId },
-      session: { id: this.sessionId },
-      net: {},
-      view: { id: "plugin", name: "memos-local-openclaw" },
-      events,
-      _v: "1.0.0",
-    };
-  }
-
-  private async flush(): Promise<void> {
-    if (this.buffer.length === 0) return;
-    const batch = this.buffer.splice(0);
-    const payload = this.buildPayload(batch);
+    if (!this.enabled || !this.client) return;
 
     try {
-      const resp = await fetch(ARMS_ENDPOINT, {
-        method: "POST",
-        headers: { "Content-Type": "text/plain" },
-        body: JSON.stringify(payload),
-        signal: AbortSignal.timeout(SEND_TIMEOUT_MS),
+      this.client.capture({
+        distinctId: this.distinctId,
+        event,
+        properties: {
+          plugin_version: this.pluginVersion,
+          os: os.platform(),
+          os_version: os.release(),
+          node_version: process.version,
+          arch: os.arch(),
+          ...properties,
+        },
       });
-      this.log.debug(`Telemetry flush: ${batch.length} events → ${resp.status}`);
-    } catch (err) {
-      this.log.debug(`Telemetry flush failed: ${err}`);
+    } catch {
+      // best-effort, never throw
     }
   }
 
@@ -235,7 +131,7 @@ export class Telemetry {
     });
   }
 
-  trackSkillEvolved(skillName: string, upgradeType: "created" | "upgraded"): void {
+  trackSkillEvolved(skillName: string, upgradeType: string): void {
     this.capture("skill_evolved", {
       skill_name: skillName,
       upgrade_type: upgradeType,
@@ -254,28 +150,19 @@ export class Telemetry {
     });
   }
 
-  trackError(source: string, errorType: string): void {
-    this.capture("plugin_error", {
-      error_source: source,
-      error_type: errorType,
-    });
-  }
-
   private maybeSendDailyPing(): void {
     const today = new Date().toISOString().slice(0, 10);
     if (this.dailyPingSent && this.dailyPingDate === today) return;
     this.dailyPingSent = true;
     this.dailyPingDate = today;
-    this.capture("daily_active", {
-      first_seen_date: this.firstSeenDate,
-    });
+    this.capture("daily_active");
   }
 
   async shutdown(): Promise<void> {
-    if (this.flushTimer) {
-      clearInterval(this.flushTimer);
-      this.flushTimer = null;
+    if (this.client) {
+      try {
+        await this.client.shutdown();
+      } catch {}
     }
-    await this.flush();
   }
 }

package/src/tools/index.ts

@@ -1,3 +1,4 @@
 export { createMemorySearchTool } from "./memory-search";
 export { createMemoryTimelineTool } from "./memory-timeline";
 export { createMemoryGetTool } from "./memory-get";
+export { createNetworkMemoryDetailTool } from "./network-memory-detail";

package/src/tools/memory-search.ts

@@ -1,12 +1,30 @@
+import { hubSearchMemories } from "../client/hub";
+import type { HubScope, HubSearchResult } from "../sharing/types";
 import type { RecallEngine } from "../recall/engine";
-import type { ToolDefinition } from "../types";
+import type { PluginContext, ToolDefinition } from "../types";
+import type { SqliteStore } from "../storage/sqlite";
 
 function resolveOwnerFilter(owner: unknown): string[] {
   const resolvedOwner = typeof owner === "string" && owner.trim().length > 0 ? owner : "agent:main";
   return resolvedOwner === "public" ? ["public"] : [resolvedOwner, "public"];
 }
 
-export function createMemorySearchTool(engine: RecallEngine): ToolDefinition {
+function resolveScope(scope: unknown): HubScope {
+  return scope === "group" || scope === "all" ? scope : "local";
+}
+
+function emptyHubResult(scope: HubScope): HubSearchResult {
+  return {
+    hits: [],
+    meta: {
+      totalCandidates: 0,
+      searchedGroups: [],
+      includedPublic: scope === "all",
+    },
+  };
+}
+
+export function createMemorySearchTool(engine: RecallEngine, store?: SqliteStore, ctx?: PluginContext, sharedState?: { lastSearchTime: number }): ToolDefinition {
   return {
     name: "memory_search",
     description:
@@ -27,16 +45,48 @@ export function createMemorySearchTool(engine: RecallEngine): ToolDefinition {
           type: "number",
           description: "Minimum relevance score threshold 0-1 (default 0.45, floor 0.35).",
         },
+        scope: {
+          type: "string",
+          description: "Search scope: local (default), group, or all. Group/all return split local and hub sections.",
+        },
+        hubAddress: {
+          type: "string",
+          description: "Optional hub address override for group/all search, integration tests, or manual routing.",
+        },
+        userToken: {
+          type: "string",
+          description: "Optional hub bearer token override for group/all search or integration tests.",
+        },
       },
     },
     handler: async (input) => {
-      const result = await engine.search({
-        query: (input.query as string) ?? "",
-        maxResults: input.maxResults as number | undefined,
-        minScore: input.minScore as number | undefined,
-        ownerFilter: resolveOwnerFilter(input.owner),
+      if (sharedState) sharedState.lastSearchTime = Date.now();
+      const query = (input.query as string) ?? "";
+      const maxResults = input.maxResults as number | undefined;
+      const minScore = input.minScore as number | undefined;
+      const ownerFilter = resolveOwnerFilter(input.owner);
+      const scope = resolveScope(input.scope);
+
+      const localSearch = engine.search({
+        query,
+        maxResults,
+        minScore,
+        ownerFilter,
       });
-      return result;
+
+      if (scope === "local" || !store || !ctx) {
+        return localSearch;
+      }
+
+      const [local, hub] = await Promise.all([
+        localSearch,
+        hubSearchMemories(store, ctx, { query, maxResults, scope, hubAddress: input.hubAddress as string | undefined, userToken: input.userToken as string | undefined }).catch((err) => {
+          ctx.log.warn(`Hub search failed, using local-only results: ${err}`);
+          return emptyHubResult(scope);
+        }),
+      ]);
+
+      return { local, hub };
     },
   };
 }

package/src/tools/network-memory-detail.ts

@@ -0,0 +1,34 @@
+import { hubGetMemoryDetail } from "../client/hub";
+import type { PluginContext, ToolDefinition } from "../types";
+import type { SqliteStore } from "../storage/sqlite";
+
+export function createNetworkMemoryDetailTool(store: SqliteStore, ctx: PluginContext): ToolDefinition {
+  return {
+    name: "network_memory_detail",
+    description:
+      "Fetch the full detail for one Hub search hit using its remoteHitId. Use this after memory_search(scope=group|all) when you need the full shared content.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        remoteHitId: {
+          type: "string",
+          description: "The remoteHitId returned by memory_search hub results.",
+        },
+        hubAddress: {
+          type: "string",
+          description: "Optional hub address override for integration tests or manual routing.",
+        },
+        userToken: {
+          type: "string",
+          description: "Optional hub bearer token override for integration tests.",
+        },
+      },
+      required: ["remoteHitId"],
+    },
+    handler: async (input) => hubGetMemoryDetail(store, ctx, {
+      remoteHitId: String(input.remoteHitId ?? ""),
+      hubAddress: input.hubAddress as string | undefined,
+      userToken: input.userToken as string | undefined,
+    }),
+  };
+}

package/src/types.ts

@@ -150,7 +150,8 @@ export type SummaryProvider =
   | "bailian"
   | "cohere"
   | "mistral"
-  | "voyage";
+  | "voyage"
+  | "openclaw";
 
 export type EmbeddingProvider =
   | "openai"
@@ -160,7 +161,8 @@ export type EmbeddingProvider =
   | "cohere"
   | "mistral"
   | "voyage"
-  | "local";
+  | "local"
+  | "openclaw";
 
 export interface ProviderConfig {
   provider: string;
@@ -170,6 +172,7 @@ export interface ProviderConfig {
   headers?: Record<string, string>;
   timeoutMs?: number;
   temperature?: number;
+  capabilities?: SharingCapabilities;
 }
 
 export interface SummarizerConfig extends ProviderConfig {
@@ -246,11 +249,43 @@ export interface SkillEvolutionConfig {
   minConfidence?: number;
   maxSkillLines?: number;
   autoInstall?: boolean;
+  /** Optional independent LLM config for skill evaluation/validation. Falls back to main summarizer if not set. */
   summarizer?: SummarizerConfig;
 }
 
 export interface TelemetryConfig {
   enabled?: boolean;
+  posthogApiKey?: string;
+  posthogHost?: string;
+}
+
+export type SharingRole = "hub" | "client";
+
+export interface SharingCapabilities {
+  hostEmbedding?: boolean;
+  hostCompletion?: boolean;
+  hostSkill?: boolean;
+}
+
+export interface HubModeConfig {
+  port?: number;
+  teamName?: string;
+  teamToken?: string;
+}
+
+export interface ClientModeConfig {
+  hubAddress?: string;
+  userToken?: string;
+  teamToken?: string;
+  pendingUserId?: string;
+}
+
+export interface SharingConfig {
+  enabled?: boolean;
+  role?: SharingRole;
+  hub?: HubModeConfig;
+  client?: ClientModeConfig;
+  capabilities?: SharingCapabilities;
 }
 
 export interface MemosLocalConfig {
@@ -278,6 +313,7 @@ export interface MemosLocalConfig {
   };
   skillEvolution?: SkillEvolutionConfig;
   telemetry?: TelemetryConfig;
+  sharing?: SharingConfig;
 }
 
 // ─── Defaults ───
@@ -318,6 +354,12 @@ export interface PluginContext {
   workspaceDir: string;
   config: MemosLocalConfig;
   log: Logger;
+  openclawAPI?: OpenClawAPI;
+}
+
+export interface OpenClawAPI {
+  embed(request: { texts: string[]; model?: string }): Promise<{ embeddings: number[][]; dimensions: number }>;
+  complete(request: { prompt: string; maxTokens?: number; temperature?: number; model?: string }): Promise<{ text: string }>;
 }
 
 export interface Logger {