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

package/src/config.ts

@@ -1,5 +1,6 @@
 import * as path from "path";
-import { DEFAULTS, type MemosLocalConfig, type PluginContext, type Logger } from "./types";
+import { DEFAULTS, type MemosLocalConfig, type PluginContext, type Logger, type EmbeddingConfig, type SummarizerConfig } from "./types";
+import { OpenClawAPIClient, type HostModelsConfig } from "./openclaw-api";
 
 const ENV_RE = /\$\{([A-Z_][A-Z0-9_]*)\}/g;
 
@@ -20,6 +21,24 @@ function deepResolveEnv<T>(obj: T): T {
   return obj;
 }
 
+function resolveProviderFallback<T extends { provider?: string; capabilities?: unknown }>(
+  config: T | undefined,
+  fallbackProvider: T["provider"],
+  enabled: boolean,
+): T | undefined {
+  if (!config) {
+    return enabled
+      ? ({ provider: fallbackProvider } as T)
+      : undefined;
+  }
+
+  if (config.provider == null && enabled) {
+    return { ...config, provider: fallbackProvider };
+  }
+
+  return config;
+}
+
 export function resolveConfig(raw: Partial<MemosLocalConfig> | undefined, stateDir: string): MemosLocalConfig {
   const cfg = deepResolveEnv(raw ?? {});
 
@@ -27,6 +46,11 @@ export function resolveConfig(raw: Partial<MemosLocalConfig> | undefined, stateD
   const telemetryEnabled =
     cfg.telemetry?.enabled ??
     (telemetryEnvVar === "false" || telemetryEnvVar === "0" ? false : true);
+  const sharingCapabilities = {
+    hostEmbedding: cfg.sharing?.capabilities?.hostEmbedding ?? false,
+    hostCompletion: cfg.sharing?.capabilities?.hostCompletion ?? false,
+    hostSkill: cfg.sharing?.capabilities?.hostSkill ?? false,
+  };
 
   return {
     ...cfg,
@@ -51,7 +75,64 @@ export function resolveConfig(raw: Partial<MemosLocalConfig> | undefined, stateD
     },
     telemetry: {
       enabled: telemetryEnabled,
+      posthogApiKey: cfg.telemetry?.posthogApiKey ?? process.env.POSTHOG_API_KEY ?? "",
+      posthogHost: cfg.telemetry?.posthogHost ?? process.env.POSTHOG_HOST ?? "",
     },
+    summarizer: (() => {
+      const summarizerConfig = resolveProviderFallback<SummarizerConfig>(
+        cfg.summarizer,
+        "openclaw",
+        sharingCapabilities.hostCompletion,
+      );
+      return summarizerConfig
+        ? {
+            ...summarizerConfig,
+            capabilities: sharingCapabilities,
+          }
+        : undefined;
+    })(),
+    embedding: (() => {
+      const embeddingConfig = resolveProviderFallback<EmbeddingConfig>(
+        cfg.embedding,
+        "openclaw",
+        sharingCapabilities.hostEmbedding,
+      );
+      return embeddingConfig
+        ? {
+            ...embeddingConfig,
+            capabilities: sharingCapabilities,
+          }
+        : undefined;
+    })(),
+    skillEvolution: cfg.skillEvolution ? {
+      ...cfg.skillEvolution,
+      summarizer: (() => {
+        const skSumCfg = resolveProviderFallback<SummarizerConfig>(
+          cfg.skillEvolution!.summarizer as SummarizerConfig | undefined,
+          "openclaw",
+          sharingCapabilities.hostSkill,
+        );
+        return skSumCfg
+          ? { ...skSumCfg, capabilities: sharingCapabilities }
+          : undefined;
+      })(),
+    } : undefined,
+    sharing: (() => {
+      const role = cfg.sharing?.role ?? "client";
+      const enabled = cfg.sharing?.enabled ?? false;
+      const hub = role === "hub" ? {
+        port: cfg.sharing?.hub?.port ?? 18800,
+        teamName: cfg.sharing?.hub?.teamName ?? "",
+        teamToken: cfg.sharing?.hub?.teamToken ?? "",
+      } : { port: 18800, teamName: "", teamToken: "" };
+      const client = role === "client" ? {
+        hubAddress: cfg.sharing?.client?.hubAddress ?? "",
+        userToken: cfg.sharing?.client?.userToken ?? "",
+        teamToken: cfg.sharing?.client?.teamToken ?? "",
+        pendingUserId: cfg.sharing?.client?.pendingUserId ?? "",
+      } : { hubAddress: "", userToken: "", teamToken: "", pendingUserId: "" };
+      return { enabled, role, hub, client, capabilities: sharingCapabilities };
+    })(),
   };
 }
 
@@ -60,6 +141,7 @@ export function buildContext(
   workspaceDir: string,
   rawConfig: Partial<MemosLocalConfig> | undefined,
   log?: Logger,
+  hostModels?: HostModelsConfig,
 ): PluginContext {
   const defaultLog: Logger = {
     debug: (...args) => console.debug("[memos-local]", ...args),
@@ -68,10 +150,19 @@ export function buildContext(
     error: (...args) => console.error("[memos-local]", ...args),
   };
 
+  const logger = log ?? defaultLog;
+  const config = resolveConfig(rawConfig, stateDir);
+
+  // Create OpenClawAPI instance if host capabilities are enabled
+  const openclawAPI = (config.sharing?.capabilities?.hostEmbedding || config.sharing?.capabilities?.hostCompletion || config.sharing?.capabilities?.hostSkill)
+    ? new OpenClawAPIClient(logger, hostModels)
+    : undefined;
+
   return {
     stateDir,
     workspaceDir,
-    config: resolveConfig(rawConfig, stateDir),
-    log: log ?? defaultLog,
+    config,
+    log: logger,
+    openclawAPI,
   };
 }

package/src/embedding/index.ts

@@ -1,4 +1,4 @@
-import type { EmbeddingConfig, Logger } from "../types";
+import type { EmbeddingConfig, Logger, OpenClawAPI } from "../types";
 import { embedOpenAI } from "./providers/openai";
 import { embedGemini } from "./providers/gemini";
 import { embedCohere, embedCohereQuery } from "./providers/cohere";
@@ -11,9 +11,13 @@ export class Embedder {
   constructor(
     private cfg: EmbeddingConfig | undefined,
     private log: Logger,
+    private openclawAPI?: OpenClawAPI,
   ) {}
 
   get provider(): string {
+    if (this.cfg?.provider === "openclaw" && this.cfg.capabilities?.hostEmbedding !== true) {
+      return "local";
+    }
     return this.cfg?.provider ?? "local";
   }
 
@@ -81,4 +85,20 @@ export class Embedder {
       throw err;
     }
   }
+
+  private async embedOpenClaw(texts: string[]): Promise<number[][]> {
+    if (!this.openclawAPI) {
+      throw new Error(
+        "OpenClaw API not available. Ensure sharing.capabilities.hostEmbedding is enabled in config."
+      );
+    }
+
+    this.log.debug(`Calling OpenClaw embed API for ${texts.length} texts`);
+    const response = await this.openclawAPI.embed({
+      texts,
+      model: this.cfg?.model,
+    });
+
+    return response.embeddings;
+  }
 }

package/src/hub/auth.ts

@@ -0,0 +1,78 @@
+import { createHmac, randomBytes, timingSafeEqual } from "crypto";
+import type { UserRole, UserStatus } from "../sharing/types";
+
+type UserTokenPayload = {
+  userId: string;
+  username: string;
+  role: UserRole;
+  status: UserStatus;
+  exp: number;
+};
+
+function base64url(input: Buffer | string): string {
+  return Buffer.from(input)
+    .toString("base64")
+    .replace(/\+/g, "-")
+    .replace(/\//g, "_")
+    .replace(/=+$/g, "");
+}
+
+function unbase64url(input: string): Buffer {
+  const padded = input.replace(/-/g, "+").replace(/_/g, "/") + "===".slice((input.length + 3) % 4);
+  return Buffer.from(padded, "base64");
+}
+
+function sign(value: string, secret: string): string {
+  return base64url(createHmac("sha256", secret).update(value).digest());
+}
+
+export function createTeamToken(secret: string): string {
+  const nonce = base64url(randomBytes(12));
+  const body = `team.${nonce}`;
+  return `${body}.${sign(body, secret)}`;
+}
+
+export function verifyTeamToken(token: string, secret: string): boolean {
+  const idx = token.lastIndexOf(".");
+  if (idx <= 0) return false;
+  const body = token.slice(0, idx);
+  const sig = token.slice(idx + 1);
+  const expected = sign(body, secret);
+  try {
+    return timingSafeEqual(Buffer.from(sig), Buffer.from(expected));
+  } catch {
+    return false;
+  }
+}
+
+export function issueUserToken(
+  payload: { userId: string; username: string; role: UserRole; status: UserStatus },
+  secret: string,
+  ttlMs = 24 * 60 * 60 * 1000,
+): string {
+  const full: UserTokenPayload = { ...payload, exp: Date.now() + ttlMs };
+  const body = base64url(JSON.stringify(full));
+  return `${body}.${sign(body, secret)}`;
+}
+
+export function verifyUserToken(token: string, secret: string): Omit<UserTokenPayload, "exp"> | null {
+  const idx = token.lastIndexOf(".");
+  if (idx <= 0) return null;
+  const body = token.slice(0, idx);
+  const sig = token.slice(idx + 1);
+  const expected = sign(body, secret);
+
+  try {
+    if (!timingSafeEqual(Buffer.from(sig), Buffer.from(expected))) return null;
+    const parsed = JSON.parse(unbase64url(body).toString("utf8")) as UserTokenPayload;
+    if (parsed.exp < Date.now()) return null;
+    return {
+      userId: parsed.userId,
+      username: parsed.username,
+      role: parsed.role,
+      status: parsed.status,
+    };
+  } catch {
+    return null;
+  }
+}