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

package/src/hub/user-manager.ts

@@ -1,139 +0,0 @@
-import { randomUUID, createHash } from "crypto";
-import { issueUserToken } from "./auth";
-import type { Logger } from "../types";
-import type { UserInfo } from "../sharing/types";
-import type { SqliteStore } from "../storage/sqlite";
-
-type ManagedHubUser = UserInfo & { tokenHash: string; createdAt: number; approvedAt: number | null };
-
-export class HubUserManager {
-  constructor(private store: SqliteStore, private log: Logger) {}
-
-  createPendingUser(input: { username: string; deviceName?: string }): ManagedHubUser {
-    const user = {
-      id: randomUUID(),
-      username: input.username,
-      deviceName: input.deviceName,
-      role: "member" as const,
-      status: "pending" as const,
-      groups: [],
-      tokenHash: "",
-      createdAt: Date.now(),
-      approvedAt: null,
-    };
-    this.store.upsertHubUser(user);
-    return user;
-  }
-
-  listPendingUsers(): ManagedHubUser[] {
-    return this.store.listHubUsers("pending");
-  }
-
-  approveUser(userId: string, token: string): ManagedHubUser | null {
-    const user = this.store.getHubUser(userId);
-    if (!user) return null;
-    const updated = {
-      ...user,
-      status: "active" as const,
-      tokenHash: createHash("sha256").update(token).digest("hex"),
-      approvedAt: Date.now(),
-    };
-    this.store.upsertHubUser(updated);
-    return updated;
-  }
-
-  ensureBootstrapAdmin(secret: string, username = "admin", bootstrapUserId?: string, bootstrapToken?: string): { user: ManagedHubUser; token: string } {
-    if (bootstrapUserId) {
-      const bootstrapUser = this.store.getHubUser(bootstrapUserId);
-      if (bootstrapUser && bootstrapUser.role === "admin" && bootstrapUser.status === "active") {
-        if (bootstrapToken && bootstrapUser.tokenHash === createHash("sha256").update(bootstrapToken).digest("hex")) {
-          return { user: bootstrapUser, token: bootstrapToken };
-        }
-        const refreshedToken = issueUserToken(
-          { userId: bootstrapUser.id, username: bootstrapUser.username, role: bootstrapUser.role, status: bootstrapUser.status },
-          secret,
-          3650 * 24 * 60 * 60 * 1000,
-        );
-        const refreshedUser: ManagedHubUser = {
-          ...bootstrapUser,
-          tokenHash: createHash("sha256").update(refreshedToken).digest("hex"),
-        };
-        this.store.upsertHubUser(refreshedUser);
-        return { user: refreshedUser, token: refreshedToken };
-      }
-    }
-
-    const existing = this.store.listHubUsers().find((user) => user.role === "admin" && user.status === "active");
-    if (existing) {
-      const refreshedToken = issueUserToken(
-        { userId: existing.id, username: existing.username, role: existing.role, status: existing.status },
-        secret,
-        3650 * 24 * 60 * 60 * 1000,
-      );
-      const refreshedUser: ManagedHubUser = {
-        ...existing,
-        tokenHash: createHash("sha256").update(refreshedToken).digest("hex"),
-      };
-      this.store.upsertHubUser(refreshedUser);
-      return { user: refreshedUser, token: refreshedToken };
-    }
-
-    const user: ManagedHubUser = {
-      id: randomUUID(),
-      username,
-      deviceName: "hub",
-      role: "admin",
-      status: "active",
-      groups: [],
-      tokenHash: "",
-      createdAt: Date.now(),
-      approvedAt: Date.now(),
-    };
-    const token = issueUserToken(
-      { userId: user.id, username: user.username, role: user.role, status: user.status },
-      secret,
-      3650 * 24 * 60 * 60 * 1000,
-    );
-    user.tokenHash = createHash("sha256").update(token).digest("hex");
-    this.store.upsertHubUser(user);
-    return { user, token };
-  }
-
-  isUsernameTaken(username: string, excludeUserId?: string): boolean {
-    const users = this.store.listHubUsers();
-    return users.some(u => u.username === username && u.id !== excludeUserId);
-  }
-
-  updateUsername(userId: string, newUsername: string): ManagedHubUser | null {
-    const user = this.store.getHubUser(userId);
-    if (!user) return null;
-    const updated = { ...user, username: newUsername };
-    this.store.upsertHubUser(updated);
-    return updated;
-  }
-
-  rejectUser(userId: string): ManagedHubUser | null {
-    const user = this.store.getHubUser(userId);
-    if (!user) return null;
-    const updated = {
-      ...user,
-      status: "rejected" as const,
-      approvedAt: Date.now(),
-    };
-    this.store.upsertHubUser(updated);
-    return updated;
-  }
-
-  resetToPending(userId: string): ManagedHubUser | null {
-    const user = this.store.getHubUser(userId);
-    if (!user) return null;
-    const updated = {
-      ...user,
-      status: "pending" as const,
-      tokenHash: "",
-      approvedAt: null,
-    };
-    this.store.upsertHubUser(updated);
-    return updated;
-  }
-}

package/src/openclaw-api.ts

@@ -1,287 +0,0 @@
-/**
- * OpenClaw Host Model Proxy
- *
- * Reads the host's configured model providers (api.config.models.providers)
- * and proxies completion / embedding requests via OpenAI-compatible HTTP calls.
- */
-
-import type { Logger, OpenClawAPI } from "./types";
-
-// ── Request / Response types ────────────────────────────────────────
-
-export interface OpenClawEmbedRequest {
-  texts: string[];
-  model?: string;
-}
-
-export interface OpenClawEmbedResponse {
-  embeddings: number[][];
-  dimensions: number;
-}
-
-export interface OpenClawCompleteRequest {
-  prompt: string;
-  maxTokens?: number;
-  temperature?: number;
-  model?: string;
-}
-
-export interface OpenClawCompleteResponse {
-  text: string;
-}
-
-// ── Host model config (mirrors OpenClaw SDK types loosely) ──────────
-
-export interface HostModelDefinition {
-  id: string;
-  name: string;
-  api?: string;
-  [key: string]: unknown;
-}
-
-export interface HostModelProvider {
-  baseUrl: string;
-  apiKey?: string | { source: string; provider: string; id: string };
-  api?: string;
-  headers?: Record<string, string>;
-  models: HostModelDefinition[];
-}
-
-export interface HostModelsConfig {
-  providers?: Record<string, HostModelProvider>;
-}
-
-// ── Resolved provider info (internal) ───────────────────────────────
-
-interface ResolvedProvider {
-  name: string;
-  baseUrl: string;
-  apiKey?: string;
-  api?: string;
-  headers?: Record<string, string>;
-  model: string;
-}
-
-// ── Client ──────────────────────────────────────────────────────────
-
-export class OpenClawAPIClient implements OpenClawAPI {
-  private completionProvider: ResolvedProvider | undefined;
-  private embeddingProvider: ResolvedProvider | undefined;
-
-  constructor(
-    private log: Logger,
-    hostModels?: HostModelsConfig,
-  ) {
-    if (hostModels?.providers) {
-      this.completionProvider = pickCompletionProvider(hostModels.providers, log);
-      this.embeddingProvider = pickEmbeddingProvider(hostModels.providers, log);
-    }
-  }
-
-  // ── Embedding ─────────────────────────────────────────────────────
-
-  async embed(request: OpenClawEmbedRequest): Promise<OpenClawEmbedResponse> {
-    const provider = this.embeddingProvider;
-    if (!provider) {
-      throw new Error(
-        "No host embedding provider available. " +
-        "Configure a model provider with an embedding model in OpenClaw, " +
-        "or use an explicit embedding provider (openai, gemini, cohere, etc.)."
-      );
-    }
-
-    const model = request.model ?? provider.model;
-    const endpoint = normalizeEndpoint(provider.baseUrl, "/embeddings");
-
-    this.log.debug(`OpenClawAPI.embed → ${provider.name} (${model}) [${request.texts.length} texts]`);
-
-    const resp = await fetch(endpoint, {
-      method: "POST",
-      headers: buildHeaders(provider),
-      body: JSON.stringify({ input: request.texts, model }),
-      signal: AbortSignal.timeout(30_000),
-    });
-
-    if (!resp.ok) {
-      const body = await resp.text();
-      throw new Error(`Host embedding failed (${provider.name} ${resp.status}): ${body}`);
-    }
-
-    const json = (await resp.json()) as {
-      data: Array<{ embedding: number[] }>;
-    };
-
-    const embeddings = json.data.map((d) => d.embedding);
-    const dimensions = embeddings[0]?.length ?? 0;
-
-    this.log.debug(`OpenClawAPI.embed ← ${embeddings.length} vectors, dim=${dimensions}`);
-    return { embeddings, dimensions };
-  }
-
-  // ── Completion ────────────────────────────────────────────────────
-
-  async complete(request: OpenClawCompleteRequest): Promise<OpenClawCompleteResponse> {
-    const provider = this.completionProvider;
-    if (!provider) {
-      throw new Error(
-        "No host completion provider available. " +
-        "Configure a model provider in OpenClaw, " +
-        "or use an explicit summarizer provider (openai, anthropic, gemini, etc.)."
-      );
-    }
-
-    const model = request.model ?? provider.model;
-    const endpoint = normalizeEndpoint(provider.baseUrl, "/chat/completions");
-
-    this.log.debug(`OpenClawAPI.complete → ${provider.name} (${model})`);
-
-    const body: Record<string, unknown> = {
-      model,
-      messages: [{ role: "user", content: request.prompt }],
-      temperature: request.temperature ?? 0,
-    };
-    if (request.maxTokens) {
-      body.max_tokens = request.maxTokens;
-    }
-
-    const resp = await fetch(endpoint, {
-      method: "POST",
-      headers: buildHeaders(provider),
-      body: JSON.stringify(body),
-      signal: AbortSignal.timeout(60_000),
-    });
-
-    if (!resp.ok) {
-      const respBody = await resp.text();
-      throw new Error(`Host completion failed (${provider.name} ${resp.status}): ${respBody}`);
-    }
-
-    const json = (await resp.json()) as {
-      choices: Array<{ message: { content: string } }>;
-    };
-
-    const text = json.choices?.[0]?.message?.content ?? "";
-    this.log.debug(`OpenClawAPI.complete ← ${text.length} chars`);
-    return { text };
-  }
-}
-
-// ── Helpers ─────────────────────────────────────────────────────────
-
-/**
- * Resolve a SecretInput (string | SecretRef) to a plain string.
- * For env-sourced SecretRef, reads from process.env.
- * Other sources are not supported — returns undefined.
- */
-function resolveApiKey(
-  input: string | { source: string; provider: string; id: string } | undefined,
-): string | undefined {
-  if (!input) return undefined;
-  if (typeof input === "string") return input;
-  // SecretRef — only env source is supported in plugin context
-  if (input.source === "env") return process.env[input.id];
-  return undefined;
-}
-
-function buildHeaders(provider: ResolvedProvider): Record<string, string> {
-  const headers: Record<string, string> = {
-    "Content-Type": "application/json",
-    ...provider.headers,
-  };
-  if (provider.apiKey) {
-    headers["Authorization"] = `Bearer ${provider.apiKey}`;
-  }
-  return headers;
-}
-
-/**
- * Normalize base URL + path suffix.
- * e.g. "https://api.openai.com/v1" + "/chat/completions"
- *   → "https://api.openai.com/v1/chat/completions"
- */
-function normalizeEndpoint(baseUrl: string, suffix: string): string {
-  const base = baseUrl.replace(/\/+$/, "");
-  // If baseUrl already ends with the suffix, don't double-append
-  if (base.endsWith(suffix)) return base;
-  return `${base}${suffix}`;
-}
-
-/**
- * Pick the best provider for chat completions.
- * Priority: openai-completions API > has apiKey > first with models.
- */
-function pickCompletionProvider(
-  providers: Record<string, HostModelProvider>,
-  log: Logger,
-): ResolvedProvider | undefined {
-  const entries = Object.entries(providers).filter(([, p]) => p.models?.length > 0);
-  if (entries.length === 0) return undefined;
-
-  // Sort: prefer openai-completions api, then providers with apiKey
-  entries.sort(([, a], [, b]) => {
-    const aScore = (a.api === "openai-completions" ? 2 : 0) + (resolveApiKey(a.apiKey) ? 1 : 0);
-    const bScore = (b.api === "openai-completions" ? 2 : 0) + (resolveApiKey(b.apiKey) ? 1 : 0);
-    return bScore - aScore;
-  });
-
-  const [name, provider] = entries[0];
-  const model = provider.models[0].id;
-  log.info(`Host completion provider: ${name} → ${model}`);
-
-  return {
-    name,
-    baseUrl: provider.baseUrl,
-    apiKey: resolveApiKey(provider.apiKey),
-    api: provider.api,
-    headers: provider.headers,
-    model,
-  };
-}
-
-/**
- * Pick the best provider for embeddings.
- * Priority: model name contains "embed" > first provider with apiKey.
- */
-function pickEmbeddingProvider(
-  providers: Record<string, HostModelProvider>,
-  log: Logger,
-): ResolvedProvider | undefined {
-  const entries = Object.entries(providers).filter(([, p]) => p.models?.length > 0);
-  if (entries.length === 0) return undefined;
-
-  // Try to find a provider that has an embedding model
-  for (const [name, provider] of entries) {
-    const embedModel = provider.models.find((m) =>
-      m.id.toLowerCase().includes("embed") || m.name.toLowerCase().includes("embed"),
-    );
-    if (embedModel) {
-      log.info(`Host embedding provider: ${name} → ${embedModel.id}`);
-      return {
-        name,
-        baseUrl: provider.baseUrl,
-        apiKey: resolveApiKey(provider.apiKey),
-        api: provider.api,
-        headers: provider.headers,
-        model: embedModel.id,
-      };
-    }
-  }
-
-  // Fallback: use first provider with apiKey, pick first model
-  const withKey = entries.find(([, p]) => !!resolveApiKey(p.apiKey));
-  if (withKey) {
-    const [name, provider] = withKey;
-    const model = provider.models[0].id;
-    log.info(`Host embedding provider (fallback): ${name} → ${model}`);
-    return {
-      name,
-      baseUrl: provider.baseUrl,
-      apiKey: resolveApiKey(provider.apiKey),
-      api: provider.api,
-      headers: provider.headers,
-      model,
-    };
-  }
-
-  return undefined;
-}

package/src/sharing/types.contract.ts

@@ -1,40 +0,0 @@
-import type {
-  ClientModeConfig as RootClientModeConfig,
-  HubModeConfig as RootHubModeConfig,
-  SharingCapabilities as RootSharingCapabilities,
-  SharingConfig as RootSharingConfig,
-  SharingRole as RootSharingRole,
-} from "../types";
-import type {
-  ClientModeConfig as SharingClientModeConfig,
-  GroupInfo,
-  HubModeConfig as SharingHubModeConfig,
-  HubSearchHit,
-  NetworkSearchResult,
-  SharingCapabilities as SharingSharingCapabilities,
-  SharingConfig as SharingSharingConfig,
-  SharingRole as SharingSharingRole,
-  SkillBundle,
-  UserInfo,
-} from "./types";
-
-type Assert<T extends true> = T;
-type Equal<A, B> =
-  (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2)
-    ? ((<T>() => T extends B ? 1 : 2) extends (<T>() => T extends A ? 1 : 2) ? true : false)
-    : false;
-type Extends<A, B> = A extends B ? true : false;
-
-type _SharingRoleMatchesRoot = Assert<Equal<SharingSharingRole, RootSharingRole>>;
-type _SharingCapabilitiesMatchRoot = Assert<Equal<SharingSharingCapabilities, RootSharingCapabilities>>;
-type _HubModeConfigMatchesRoot = Assert<Equal<SharingHubModeConfig, RootHubModeConfig>>;
-type _ClientModeConfigMatchesRoot = Assert<Equal<SharingClientModeConfig, RootClientModeConfig>>;
-type _SharingConfigMatchesRoot = Assert<Equal<SharingSharingConfig, RootSharingConfig>>;
-
-type _GroupInfoExists = Assert<Extends<GroupInfo, { id: string; name: string }>>;
-type _UserInfoExists = Assert<Extends<UserInfo, { id: string; username: string }>>;
-type _HubSearchHitExists = Assert<Extends<HubSearchHit, { remoteHitId: string; hubRank: number }>>;
-type _NetworkSearchResultExists = Assert<Extends<NetworkSearchResult, { local: unknown; hub: unknown }>>;
-type _SkillBundleExists = Assert<Extends<SkillBundle, { metadata: unknown; bundle: unknown }>>;
-
-export {};

package/src/sharing/types.ts

@@ -1,102 +0,0 @@
-import type {
-  ClientModeConfig,
-  HubModeConfig,
-  Role,
-  SearchResult,
-  SharingCapabilities,
-  SharingConfig,
-  SharingRole,
-  SkillGenerateOutput,
-} from "../types";
-
-export type HubScope = "local" | "group" | "all";
-export type SharedVisibility = "group" | "public";
-export type UserRole = "admin" | "member";
-export type UserStatus = "pending" | "active" | "blocked" | "rejected";
-
-export type { ClientModeConfig, HubModeConfig, SharingCapabilities, SharingConfig, SharingRole };
-
-export interface GroupInfo {
-  id: string;
-  name: string;
-  description?: string;
-}
-
-export interface UserInfo {
-  id: string;
-  username: string;
-  deviceName?: string;
-  role: UserRole;
-  status: UserStatus;
-  groups: GroupInfo[];
-}
-
-export interface HubSearchHit {
-  remoteHitId: string;
-  summary: string;
-  excerpt: string;
-  hubRank: number;
-  taskTitle: string | null;
-  ownerName: string;
-  groupName: string | null;
-  visibility: SharedVisibility;
-  source: {
-    ts: number;
-    role: Role;
-  };
-}
-
-export interface HubSearchMeta {
-  totalCandidates: number;
-  searchedGroups: string[];
-  includedPublic: boolean;
-}
-
-export interface HubSearchResult {
-  hits: HubSearchHit[];
-  meta: HubSearchMeta;
-}
-
-export interface HubMemoryDetail {
-  remoteHitId: string;
-  content: string;
-  summary: string;
-  source: {
-    ts: number;
-    role: Role;
-  };
-}
-
-export interface HubSkillHit {
-  skillId: string;
-  name: string;
-  description: string;
-  version: number;
-  visibility: SharedVisibility;
-  groupName: string | null;
-  ownerName: string;
-  qualityScore: number | null;
-}
-
-export interface HubSkillSearchResult {
-  hits: HubSkillHit[];
-}
-
-export interface NetworkSearchResult {
-  local: SearchResult;
-  hub: HubSearchResult;
-}
-
-export interface SkillBundleMetadata {
-  id: string;
-  name: string;
-  description: string;
-  version: number;
-  qualityScore: number | null;
-}
-
-export interface SkillBundle {
-  metadata: SkillBundleMetadata;
-  bundle: SkillGenerateOutput;
-}
-

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

@@ -1,34 +0,0 @@
-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,
-    }),
-  };
-}