@memtensor/memos-local-openclaw-plugin 1.0.2 → 1.0.4-beta.0

package/scripts/postinstall.cjs

@@ -380,58 +380,30 @@ function sqliteBindingsExist() {
 
 if (sqliteBindingsExist()) {
   ok("better-sqlite3 is ready.");
-  console.log(`
-${GREEN}${BOLD}  ┌──────────────────────────────────────────────────┐
-  │  ✔ Setup complete!                                │
-  │                                                    │
-  │  Restart gateway:                                  │
-  │  ${CYAN}openclaw gateway stop && openclaw gateway start${GREEN}  │
-  └──────────────────────────────────────────────────┘${RESET}
-`);
-  process.exit(0);
 } else {
   warn("better-sqlite3 native bindings not found in plugin dir.");
   log(`Searched in: ${DIM}${sqliteModulePath}/build/${RESET}`);
   log("Running: npm rebuild better-sqlite3 (may take 30-60s)...");
-}
-
-const startMs = Date.now();
-
-const result = spawnSync("npm", ["rebuild", "better-sqlite3"], {
-  cwd: pluginDir,
-  stdio: "pipe",
-  shell: true,
-  timeout: 180_000,
-});
 
-const elapsed = ((Date.now() - startMs) / 1000).toFixed(1);
-const stdout = (result.stdout || "").toString().trim();
-const stderr = (result.stderr || "").toString().trim();
-
-if (stdout) log(`rebuild output: ${DIM}${stdout.slice(0, 500)}${RESET}`);
-if (stderr) warn(`rebuild stderr: ${DIM}${stderr.slice(0, 500)}${RESET}`);
+  const startMs = Date.now();
+  const result = spawnSync("npm", ["rebuild", "better-sqlite3"], {
+    cwd: pluginDir,
+    stdio: "pipe",
+    shell: true,
+    timeout: 180_000,
+  });
+  const elapsed = ((Date.now() - startMs) / 1000).toFixed(1);
+  const stdout = (result.stdout || "").toString().trim();
+  const stderr = (result.stderr || "").toString().trim();
+  if (stdout) log(`rebuild output: ${DIM}${stdout.slice(0, 500)}${RESET}`);
+  if (stderr) warn(`rebuild stderr: ${DIM}${stderr.slice(0, 500)}${RESET}`);
 
-if (result.status === 0) {
-  if (sqliteBindingsExist()) {
+  if (result.status === 0 && sqliteBindingsExist()) {
     ok(`better-sqlite3 rebuilt successfully (${elapsed}s).`);
-    console.log(`
-${GREEN}${BOLD}  ┌──────────────────────────────────────────────────┐
-  │  ✔ Setup complete!                                │
-  │                                                    │
-  │  Restart gateway:                                  │
-  │  ${CYAN}openclaw gateway stop && openclaw gateway start${GREEN}  │
-  └──────────────────────────────────────────────────┘${RESET}
-`);
-    process.exit(0);
   } else {
-    fail(`Rebuild completed but bindings still missing (${elapsed}s).`);
-    fail(`Looked in: ${sqliteModulePath}/build/`);
-  }
-} else {
-  fail(`Rebuild failed with exit code ${result.status} (${elapsed}s).`);
-}
-
-console.log(`
+    if (result.status !== 0) fail(`Rebuild failed with exit code ${result.status} (${elapsed}s).`);
+    else { fail(`Rebuild completed but bindings still missing (${elapsed}s).`); fail(`Looked in: ${sqliteModulePath}/build/`); }
+    console.log(`
 ${YELLOW}${BOLD}  ╔══════════════════════════════════════════════════════════════╗
   ║  ✖ better-sqlite3 native module build failed               ║
   ╠══════════════════════════════════════════════════════════════╣${RESET}
@@ -452,5 +424,270 @@ ${YELLOW}  ║${RESET}  ${GREEN}openclaw gateway stop && openclaw gateway start$
 ${YELLOW}  ║${RESET}                                                             ${YELLOW}║${RESET}
 ${YELLOW}${BOLD}  ╚══════════════════════════════════════════════════════════════╝${RESET}
 `);
+  }
+}
+
+/* ═══════════════════════════════════════════════════════════
+ *  Phase 3: Interactive LAN Sharing Setup
+ * ═══════════════════════════════════════════════════════════ */
+
+const rlMod = require("readline");
+const os = require("os");
+const crypto = require("crypto");
+
+function getLocalIPs() {
+  const nets = os.networkInterfaces();
+  const results = [];
+  for (const name of Object.keys(nets)) {
+    for (const net of nets[name]) {
+      if (net.family === "IPv4" && !net.internal) {
+        results.push({ name, address: net.address });
+      }
+    }
+  }
+  return results;
+}
+
+function generateTeamToken() {
+  return crypto.randomBytes(18).toString("base64url");
+}
+
+function createPrompt() {
+  const rl = rlMod.createInterface({ input: process.stdin, output: process.stdout });
+  return {
+    ask(q) { return new Promise((resolve) => rl.question(q, (a) => resolve(a.trim()))); },
+    close() { rl.close(); },
+  };
+}
+
+async function setupSharingWizard() {
+  if (!process.stdin.isTTY) {
+    log("Non-interactive environment, skipping sharing setup wizard.");
+    return;
+  }
+  if (process.env.MEMOS_SKIP_SETUP === "1") {
+    log("MEMOS_SKIP_SETUP=1, skipping sharing setup.");
+    return;
+  }
+
+  const home = process.env.HOME || process.env.USERPROFILE || "";
+  const cfgPath = path.join(home, ".openclaw", "openclaw.json");
+  if (!fs.existsSync(cfgPath)) {
+    log("~/.openclaw/openclaw.json not found, skipping sharing setup.");
+    return;
+  }
+
+  let cfg;
+  try {
+    cfg = JSON.parse(fs.readFileSync(cfgPath, "utf-8"));
+  } catch (e) {
+    warn(`Cannot parse openclaw.json: ${e.message}`);
+    return;
+  }
+
+  const pluginEntry = cfg?.plugins?.entries?.["memos-local-openclaw-plugin"];
+  const existingSharing = pluginEntry?.config?.sharing;
+
+  if (existingSharing?.enabled) {
+    const roleLabel = existingSharing.role === "hub" ? "Hub (团队中心)" : "Client (团队成员)";
+    log(`已检测到共享配置: 角色 = ${BOLD}${roleLabel}${RESET}`);
+    const prompt = createPrompt();
+    const ans = await prompt.ask(`  是否重新配置？/ Reconfigure? (y/N) > `);
+    prompt.close();
+    if (ans.toLowerCase() !== "y") {
+      ok("保留现有共享配置。");
+      return;
+    }
+  }
+
+  phase(3, "局域网共享设置 / LAN Sharing Setup");
+
+  const prompt = createPrompt();
+
+  const enableAns = await prompt.ask(`  是否启用局域网记忆共享？/ Enable LAN sharing? (y/N) > `);
+  if (enableAns.toLowerCase() !== "y") {
+    prompt.close();
+    log("未启用共享。你可以稍后在 openclaw.json 中手动配置。");
+    return;
+  }
+
+  console.log(`
+  ${BOLD}请选择你的角色 / Choose your role:${RESET}
+    ${GREEN}1)${RESET} 创建团队 (Hub)   — 成为团队管理员，其他人连接你
+    ${GREEN}2)${RESET} 加入团队 (Client) — 连接到已有的 Hub
+`);
+
+  const roleAns = await prompt.ask(`  请输入 1 或 2 / Enter 1 or 2 > `);
+
+  let sharingConfig;
+
+  if (roleAns === "1") {
+    console.log(`\n  ${CYAN}${BOLD}── Hub 设置 / Hub Setup ──${RESET}\n`);
+
+    const teamName = (await prompt.ask(`  团队名称 / Team name (默认: My Team) > `)) || "My Team";
+    const portStr = (await prompt.ask(`  Hub 端口 / Hub port (默认: 18800) > `)) || "18800";
+    const port = parseInt(portStr, 10) || 18800;
+    const teamToken = generateTeamToken();
+
+    sharingConfig = {
+      enabled: true,
+      role: "hub",
+      hub: { port, teamName, teamToken },
+    };
+
+    const localIPs = getLocalIPs();
+    const displayIP = localIPs.length > 0 ? localIPs[0].address : "<your-ip>";
+
+    console.log(`
+${GREEN}${BOLD}  ┌────────────────────────────────────────────────────────────┐
+  │  ✔ Hub 配置完成！/ Hub configured!                        │
+  │                                                            │
+  │  请将以下信息分享给团队成员:                                │
+  │  Share this info with your team:                           │
+  │                                                            │
+  │  ${CYAN}Hub 地址 / Address : ${displayIP}:${port}${GREEN}
+  │  ${CYAN}Team Token         : ${teamToken}${GREEN}
+  │                                                            │
+  │  团队成员安装插件时选择 "加入团队" 并输入以上信息。          │
+  └────────────────────────────────────────────────────────────┘${RESET}
+`);
+
+    if (localIPs.length > 1) {
+      log("检测到多个网络接口 / Multiple network interfaces:");
+      for (const ip of localIPs) {
+        log(`  ${ip.name}: ${BOLD}${ip.address}:${port}${RESET}`);
+      }
+    }
+
+  } else if (roleAns === "2") {
+    console.log(`\n  ${CYAN}${BOLD}── 加入团队 / Join Team ──${RESET}\n`);
+
+    const hubAddress = await prompt.ask(`  Hub 地址 / Hub address (如 192.168.1.100:18800) > `);
+    if (!hubAddress) {
+      prompt.close();
+      warn("Hub 地址不能为空，跳过配置。");
+      return;
+    }
+
+    const teamToken = await prompt.ask(`  Team Token (由 Hub 创建者提供 / from Hub creator) > `);
+    if (!teamToken) {
+      prompt.close();
+      warn("Team Token 不能为空，跳过配置。");
+      return;
+    }
+
+    const username = (await prompt.ask(`  你的用户名 / Your username (默认: ${os.userInfo().username}) > `)) || os.userInfo().username;
 
-process.exit(0);
+    const hubUrl = /^https?:\/\//i.test(hubAddress.trim()) ? hubAddress.trim() : `http://${hubAddress.trim()}`;
+    log(`正在加入团队 / Joining team at: ${BOLD}${hubUrl}${RESET} ...`);
+
+    let userToken = "";
+    let joinOk = false;
+
+    try {
+      const http = require("http");
+      const https = require("https");
+      const joinResult = await new Promise((resolve, reject) => {
+        const postData = JSON.stringify({ teamToken, username, deviceName: os.hostname() });
+        const url = new URL(`${hubUrl}/api/v1/hub/join`);
+        const mod = url.protocol === "https:" ? https : http;
+        const reqObj = mod.request({
+          hostname: url.hostname, port: url.port, path: url.pathname,
+          method: "POST",
+          headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(postData) },
+          timeout: 8000,
+        }, (resp) => {
+          let data = "";
+          resp.on("data", (c) => { data += c; });
+          resp.on("end", () => {
+            try { resolve({ status: resp.statusCode, body: JSON.parse(data) }); }
+            catch { resolve({ status: resp.statusCode, body: data }); }
+          });
+        });
+        reqObj.on("error", reject);
+        reqObj.on("timeout", () => { reqObj.destroy(); reject(new Error("timeout")); });
+        reqObj.write(postData);
+        reqObj.end();
+      });
+
+      if (joinResult.status === 200 && joinResult.body.userToken) {
+        userToken = joinResult.body.userToken;
+        joinOk = true;
+        ok(`加入成功！/ Joined successfully! 用户: ${BOLD}${username}${RESET}`);
+      } else if (joinResult.status === 403) {
+        prompt.close();
+        fail("Team Token 无效 / Invalid Team Token");
+        return;
+      } else {
+        warn(`Hub 返回 / Hub responded: ${joinResult.status} ${JSON.stringify(joinResult.body)}`);
+        log("配置将被保存，gateway 启动时会用 Team Token 自动重试加入。");
+      }
+    } catch (e) {
+      warn(`无法连接 Hub / Cannot reach Hub: ${e.message}`);
+      log("配置将被保存，gateway 启动时会用 Team Token 自动重试加入。");
+    }
+
+    sharingConfig = {
+      enabled: true,
+      role: "client",
+      client: { hubAddress, teamToken },
+    };
+    if (userToken) sharingConfig.client.userToken = userToken;
+
+    const statusMsg = joinOk
+      ? `已加入团队，重启 gateway 即生效`
+      : `Hub 暂不可达，gateway 启动时会自动加入`;
+    console.log(`
+${GREEN}${BOLD}  ┌────────────────────────────────────────────────────────────┐
+  │  ✔ Client 配置完成！/ Client configured!                  │
+  │  ${CYAN}Hub: ${hubAddress}${GREEN}
+  │  ${CYAN}${statusMsg}${GREEN}
+  └────────────────────────────────────────────────────────────┘${RESET}
+`);
+
+  } else {
+    prompt.close();
+    warn(`无效选择 "${roleAns}"，跳过配置。你可以稍后在 openclaw.json 中手动配置。`);
+    return;
+  }
+
+  prompt.close();
+
+  try {
+    if (!cfg.plugins) cfg.plugins = {};
+    if (!cfg.plugins.entries) cfg.plugins.entries = {};
+    if (!cfg.plugins.entries["memos-local-openclaw-plugin"]) {
+      cfg.plugins.entries["memos-local-openclaw-plugin"] = { enabled: true };
+    }
+    const entry = cfg.plugins.entries["memos-local-openclaw-plugin"];
+    if (!entry.config) entry.config = {};
+    entry.config.sharing = sharingConfig;
+
+    const backup = cfgPath + ".bak-" + Date.now();
+    fs.copyFileSync(cfgPath, backup);
+    fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2) + "\n", "utf-8");
+    ok(`配置已写入 / Config saved: ${DIM}~/.openclaw/openclaw.json${RESET}`);
+    log(`备份 / Backup: ${DIM}${backup}${RESET}`);
+  } catch (e) {
+    fail(`写入配置失败 / Config write failed: ${e.message}`);
+    warn("请手动编辑 ~/.openclaw/openclaw.json 添加 sharing 配置。");
+  }
+}
+
+(async () => {
+  try {
+    await setupSharingWizard();
+  } catch (e) {
+    warn(`Setup wizard error: ${e.message}`);
+  }
+
+  console.log(`
+${GREEN}${BOLD}  ┌──────────────────────────────────────────────────┐
+  │  ✔ Setup complete!                                │
+  │                                                    │
+  │  Restart gateway:                                  │
+  │  ${CYAN}openclaw gateway stop && openclaw gateway start${GREEN}  │
+  └──────────────────────────────────────────────────┘${RESET}
+`);
+  process.exit(0);
+})();

package/skill/memos-memory-guide/SKILL.md

@@ -5,13 +5,13 @@ description: "Use the MemOS Local memory system to search and use the user's pas
 
 # MemOS Local Memory — Agent Guide
 
-This skill describes how to use the MemOS memory tools so you can reliably search and use the user's long-term conversation history, share knowledge across agents, and discover public skills.
+This skill describes how to use the MemOS memory tools so you can reliably search and use the user's long-term conversation history, query Hub-shared team data, share tasks, and discover or pull reusable skills.
 
 ## How memory is provided each turn
 
 - **Automatic recall (hook):** At the start of each turn, the system runs a memory search using the user's current message and injects relevant past memories into your context. You do not need to call any tool for that.
 - **When that is not enough:** If the user's message is very long, vague, or the automatic search returns **no memories**, you should **generate your own short, focused query** and call `memory_search` yourself.
-- **Memory isolation:** Each agent can only see its own memories and memories marked as `public`. Other agents' private memories are invisible to you.
+- **Memory isolation:** Each agent can only see its own local private memories and local `public` memories. Hub-shared data only appears when you search with `scope="group"` or `scope="all"`.
 
 ## Tools — what they do and when to call
 
@@ -89,6 +89,30 @@ This skill describes how to use the MemOS memory tools so you can reliably searc
 - **Parameters:**
   - `skillId` (string, **required**) — The skill ID to unpublish.
 
+### network_memory_detail
+
+- **What it does:** Fetches the full content behind a Hub search hit.
+- **When to call:** A `memory_search` result came from the Hub and you need the full shared memory content.
+- **Parameters:** `remoteHitId`.
+
+### task_share / task_unshare
+
+- **What they do:** Share a local task to the Hub, or remove it later.
+- **When to call:** A task is valuable to your group or to the whole team and should be discoverable via shared search.
+- **Parameters:** `taskId`, plus sharing visibility/scope when required.
+
+### network_skill_pull
+
+- **What it does:** Pulls a Hub-shared skill bundle down into local storage.
+- **When to call:** `skill_search` found a useful Hub skill and you want to use it locally or offline.
+- **Parameters:** `skillId`.
+
+### network_team_info
+
+- **What it does:** Returns current Hub connection information, user, role, and groups.
+- **When to call:** You need to confirm whether team sharing is configured or which groups the current client belongs to.
+- **Parameters:** none.
+
 ### memory_timeline
 
 - **What it does:** Expand context around a memory search hit. Pass the `chunkId` from a search result to read the surrounding conversation messages.

package/src/client/connector.ts

@@ -0,0 +1,124 @@
+import type { Logger, MemosLocalConfig } from "../types";
+import type { GroupInfo, UserRole, UserStatus } from "../sharing/types";
+import type { SqliteStore } from "../storage/sqlite";
+import { hubRequestJson, normalizeHubUrl } from "./hub";
+
+export interface HubSessionInfo {
+  hubUrl: string;
+  userId: string;
+  username: string;
+  userToken: string;
+  role: UserRole;
+  connectedAt: number;
+}
+
+export interface HubStatusInfo {
+  connected: boolean;
+  hubUrl?: string;
+  user: null | {
+    id: string;
+    username: string;
+    role: UserRole;
+    status: UserStatus | string;
+    groups: GroupInfo[];
+  };
+}
+
+export async function connectToHub(store: SqliteStore, config: MemosLocalConfig, log?: Logger): Promise<HubSessionInfo> {
+  const hubAddress = config.sharing?.client?.hubAddress ?? "";
+  let userToken = config.sharing?.client?.userToken ?? "";
+
+  if (!userToken) {
+    const persisted = store.getClientHubConnection();
+    if (persisted?.userToken) userToken = persisted.userToken;
+  }
+
+  if (!userToken && config.sharing?.client?.teamToken) {
+    if (!log) throw new Error("hub client connection is not configured (no userToken, has teamToken but no logger for auto-join)");
+    return autoJoinHub(store, config, log);
+  }
+
+  if (!hubAddress || !userToken) {
+    throw new Error("hub client connection is not configured");
+  }
+
+  const hubUrl = normalizeHubUrl(hubAddress);
+  const me = await hubRequestJson(hubUrl, userToken, "/api/v1/hub/me", { method: "GET" }) as any;
+  store.setClientHubConnection({
+    hubUrl,
+    userId: String(me.id),
+    username: String(me.username ?? ""),
+    userToken,
+    role: String(me.role ?? "member") as UserRole,
+    connectedAt: Date.now(),
+  });
+  return store.getClientHubConnection()!;
+}
+
+export async function getHubStatus(store: SqliteStore, config: MemosLocalConfig): Promise<HubStatusInfo> {
+  const conn = store.getClientHubConnection();
+  const hubAddress = conn?.hubUrl || config.sharing?.client?.hubAddress || "";
+  const userToken = conn?.userToken || config.sharing?.client?.userToken || "";
+  if (!hubAddress || !userToken) {
+    return { connected: false, user: null };
+  }
+
+  try {
+    const me = await hubRequestJson(normalizeHubUrl(hubAddress), userToken, "/api/v1/hub/me", { method: "GET" }) as any;
+    return {
+      connected: true,
+      hubUrl: normalizeHubUrl(hubAddress),
+      user: {
+        id: String(me.id),
+        username: String(me.username ?? ""),
+        role: String(me.role ?? "member") as UserRole,
+        status: String(me.status ?? "active"),
+        groups: Array.isArray(me.groups)
+          ? me.groups.map((group: any) => ({
+              id: String(group.id),
+              name: String(group.name),
+              description: typeof group.description === "string" ? group.description : undefined,
+            }))
+          : [],
+      },
+    };
+  } catch {
+    return { connected: false, user: null };
+  }
+}
+
+export async function autoJoinHub(
+  store: SqliteStore,
+  config: MemosLocalConfig,
+  log: Logger,
+): Promise<HubSessionInfo> {
+  const hubAddress = config.sharing?.client?.hubAddress ?? "";
+  const teamToken = config.sharing?.client?.teamToken ?? "";
+  if (!hubAddress || !teamToken) {
+    throw new Error("hubAddress and teamToken are required for auto-join");
+  }
+  const hubUrl = normalizeHubUrl(hubAddress);
+  const hostname = typeof globalThis.process !== "undefined" ? (await import("os")).hostname() : "unknown";
+  const username = typeof globalThis.process !== "undefined" ? (await import("os")).userInfo().username : "user";
+
+  log.info(`Joining Hub at ${hubUrl} as "${username}"...`);
+  const result = await hubRequestJson(hubUrl, "", "/api/v1/hub/join", {
+    method: "POST",
+    body: JSON.stringify({ teamToken, username, deviceName: hostname }),
+  }) as any;
+
+  if (!result.userToken) {
+    throw new Error(`Hub join failed: ${JSON.stringify(result)}`);
+  }
+
+  log.info(`Joined Hub successfully! userId=${result.userId}`);
+  store.setClientHubConnection({
+    hubUrl,
+    userId: String(result.userId),
+    username,
+    userToken: result.userToken,
+    role: "member",
+    connectedAt: Date.now(),
+  });
+  return store.getClientHubConnection()!;
+}