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

package/src/telemetry.ts

@@ -1,5 +1,5 @@
 /**
- * Telemetry module — anonymous usage analytics via PostHog.
+ * Telemetry module — anonymous usage analytics via Aliyun ARMS RUM.
  *
  * Privacy-first design:
  * - Enabled by default with anonymous data only; opt-out via TELEMETRY_ENABLED=false
@@ -8,7 +8,6 @@
  * - 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";
@@ -17,45 +16,61 @@ import type { Logger } from "./types";
 
 export interface TelemetryConfig {
   enabled?: boolean;
-  posthogApiKey?: string;
-  posthogHost?: string;
 }
 
-const DEFAULT_POSTHOG_API_KEY = "phc_7lae6UC5jyImDefX6uub7zCxWyswCGNoBifCKqjvDrI";
-const DEFAULT_POSTHOG_HOST = "https://eu.i.posthog.com";
+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;
+}
 
 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;
     }
 
-    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;
-    }
+    this.flushTimer = setInterval(() => this.flush(), FLUSH_INTERVAL_MS);
+    if (this.flushTimer.unref) this.flushTimer.unref();
+    this.log.debug("Telemetry initialized (ARMS)");
   }
 
   private loadOrCreateAnonymousId(stateDir: string): string {
@@ -81,24 +96,113 @@ 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 || !this.client) return;
+    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);
 
     try {
-      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,
-        },
+      const resp = await fetch(ARMS_ENDPOINT, {
+        method: "POST",
+        headers: { "Content-Type": "text/plain" },
+        body: JSON.stringify(payload),
+        signal: AbortSignal.timeout(SEND_TIMEOUT_MS),
       });
-    } catch {
-      // best-effort, never throw
+      this.log.debug(`Telemetry flush: ${batch.length} events → ${resp.status}`);
+    } catch (err) {
+      this.log.debug(`Telemetry flush failed: ${err}`);
     }
   }
 
@@ -131,7 +235,7 @@ export class Telemetry {
     });
   }
 
-  trackSkillEvolved(skillName: string, upgradeType: string): void {
+  trackSkillEvolved(skillName: string, upgradeType: "created" | "upgraded"): void {
     this.capture("skill_evolved", {
       skill_name: skillName,
       upgrade_type: upgradeType,
@@ -150,19 +254,28 @@ 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");
+    this.capture("daily_active", {
+      first_seen_date: this.firstSeenDate,
+    });
   }
 
   async shutdown(): Promise<void> {
-    if (this.client) {
-      try {
-        await this.client.shutdown();
-      } catch {}
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
     }
+    await this.flush();
   }
 }

package/src/tools/index.ts

@@ -1,4 +1,3 @@
 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,30 +1,12 @@
-import { hubSearchMemories } from "../client/hub";
-import type { HubScope, HubSearchResult } from "../sharing/types";
 import type { RecallEngine } from "../recall/engine";
-import type { PluginContext, ToolDefinition } from "../types";
-import type { SqliteStore } from "../storage/sqlite";
+import type { ToolDefinition } from "../types";
 
 function resolveOwnerFilter(owner: unknown): string[] {
   const resolvedOwner = typeof owner === "string" && owner.trim().length > 0 ? owner : "agent:main";
   return resolvedOwner === "public" ? ["public"] : [resolvedOwner, "public"];
 }
 
-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): ToolDefinition {
+export function createMemorySearchTool(engine: RecallEngine): ToolDefinition {
   return {
     name: "memory_search",
     description:
@@ -45,47 +27,16 @@ export function createMemorySearchTool(engine: RecallEngine, store?: SqliteStore
           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 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,
+      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 (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 };
+      return result;
     },
   };
 }

package/src/types.ts

@@ -150,8 +150,7 @@ export type SummaryProvider =
   | "bailian"
   | "cohere"
   | "mistral"
-  | "voyage"
-  | "openclaw";
+  | "voyage";
 
 export type EmbeddingProvider =
   | "openai"
@@ -161,8 +160,7 @@ export type EmbeddingProvider =
   | "cohere"
   | "mistral"
   | "voyage"
-  | "local"
-  | "openclaw";
+  | "local";
 
 export interface ProviderConfig {
   provider: string;
@@ -172,7 +170,6 @@ export interface ProviderConfig {
   headers?: Record<string, string>;
   timeoutMs?: number;
   temperature?: number;
-  capabilities?: SharingCapabilities;
 }
 
 export interface SummarizerConfig extends ProviderConfig {
@@ -249,43 +246,11 @@ 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 {
@@ -313,7 +278,6 @@ export interface MemosLocalConfig {
   };
   skillEvolution?: SkillEvolutionConfig;
   telemetry?: TelemetryConfig;
-  sharing?: SharingConfig;
 }
 
 // ─── Defaults ───
@@ -354,12 +318,6 @@ 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 {