@memtensor/memos-local-openclaw-plugin 0.1.4 → 0.1.6

package/src/viewer/server.ts

@@ -1,5 +1,6 @@
 import http from "node:http";
 import crypto from "node:crypto";
+import { execSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import type { SqliteStore } from "../storage/sqlite";
@@ -27,6 +28,7 @@ export class ViewerServer {
   private readonly embedder: Embedder;
   private readonly port: number;
   private readonly log: Logger;
+  private readonly dataDir: string;
   private readonly authFile: string;
   private readonly auth: AuthState;
 
@@ -38,6 +40,7 @@ export class ViewerServer {
     this.embedder = opts.embedder;
     this.port = opts.port;
     this.log = opts.log;
+    this.dataDir = opts.dataDir;
     this.authFile = path.join(opts.dataDir, "viewer-auth.json");
     this.auth = { passwordHash: null, sessions: new Map() };
     this.resetToken = crypto.randomBytes(16).toString("hex");
@@ -156,14 +159,24 @@ export class ViewerServer {
       if (p === "/api/memories" && req.method === "GET") this.serveMemories(res, url);
       else if (p === "/api/stats") this.serveStats(res);
       else if (p === "/api/metrics") this.serveMetrics(res, url);
+      else if (p === "/api/tool-metrics") this.serveToolMetrics(res, url);
       else if (p === "/api/search") this.serveSearch(req, res, url);
       else if (p === "/api/tasks" && req.method === "GET") this.serveTasks(res, url);
       else if (p.startsWith("/api/task/") && req.method === "GET") this.serveTaskDetail(res, p);
+      else       if (p === "/api/skills" && req.method === "GET") this.serveSkills(res, url);
+      else if (p.match(/^\/api\/skill\/[^/]+\/download$/) && req.method === "GET") this.serveSkillDownload(res, p);
+      else if (p.match(/^\/api\/skill\/[^/]+\/files$/) && req.method === "GET") this.serveSkillFiles(res, p);
+      else if (p.startsWith("/api/skill/") && req.method === "GET") this.serveSkillDetail(res, p);
       else if (p === "/api/memory" && req.method === "POST") this.handleCreate(req, res);
+      else if (p.startsWith("/api/memory/") && req.method === "GET") this.serveMemoryDetail(res, p);
       else if (p.startsWith("/api/memory/") && req.method === "PUT") this.handleUpdate(req, res, p);
       else if (p.startsWith("/api/memory/") && req.method === "DELETE") this.handleDelete(res, p);
       else if (p === "/api/session" && req.method === "DELETE") this.handleDeleteSession(res, url);
       else if (p === "/api/memories" && req.method === "DELETE") this.handleDeleteAll(res);
+      else if (p === "/api/logs" && req.method === "GET") this.serveLogs(res, url);
+      else if (p === "/api/log-tools" && req.method === "GET") this.serveLogTools(res);
+      else if (p === "/api/config" && req.method === "GET") this.serveConfig(res);
+      else if (p === "/api/config" && req.method === "PUT") this.handleSaveConfig(req, res);
       else if (p === "/api/auth/logout" && req.method === "POST") this.handleLogout(req, res);
       else {
         res.writeHead(404, { "Content-Type": "application/json" });
@@ -275,14 +288,14 @@ export class ViewerServer {
   // ─── Pages ───
 
   private serveViewer(res: http.ServerResponse): void {
-    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-cache" });
+    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-store, no-cache, must-revalidate, max-age=0", "Pragma": "no-cache", "Expires": "0" });
     res.end(viewerHTML);
   }
 
   // ─── Data APIs ───
 
   private serveMemories(res: http.ServerResponse, url: URL): void {
-    const limit = Math.min(Number(url.searchParams.get("limit")) || 30, 200);
+    const limit = Math.min(Number(url.searchParams.get("limit")) || 40, 200);
     const page = Math.max(1, Number(url.searchParams.get("page")) || 1);
     const offset = (page - 1) * limit;
     const session = url.searchParams.get("session") ?? undefined;
@@ -318,6 +331,12 @@ export class ViewerServer {
     this.jsonResponse(res, data);
   }
 
+  private serveToolMetrics(res: http.ServerResponse, url: URL): void {
+    const minutes = Math.min(1440, Math.max(10, Number(url.searchParams.get("minutes")) || 60));
+    const data = this.store.getToolMetrics(minutes);
+    this.jsonResponse(res, data);
+  }
+
   private serveTasks(res: http.ServerResponse, url: URL): void {
     this.store.recordViewerEvent("tasks_list");
     const status = url.searchParams.get("status") ?? undefined;
@@ -357,6 +376,20 @@ export class ViewerServer {
       createdAt: c.createdAt,
     }));
 
+    const relatedSkills = this.store.getSkillsByTask(taskId);
+    const skillLinks = relatedSkills.map((rs) => ({
+      skillId: rs.skill.id,
+      skillName: rs.skill.name,
+      relation: rs.relation,
+      versionAt: rs.versionAt,
+      status: rs.skill.status,
+      qualityScore: rs.skill.qualityScore,
+    }));
+
+    const db = (this.store as any).db;
+    const meta = db.prepare("SELECT skill_status, skill_reason FROM tasks WHERE id = ?").get(taskId) as
+      { skill_status: string | null; skill_reason: string | null } | undefined;
+
     this.jsonResponse(res, {
       id: task.id,
       sessionKey: task.sessionKey,
@@ -366,6 +399,9 @@ export class ViewerServer {
       startedAt: task.startedAt,
       endedAt: task.endedAt,
       chunks: chunkItems,
+      skillStatus: meta?.skill_status ?? null,
+      skillReason: meta?.skill_reason ?? null,
+      skillLinks,
     });
   }
 
@@ -381,11 +417,22 @@ export class ViewerServer {
       "SELECT session_key, COUNT(*) as count, MIN(created_at) as earliest, MAX(created_at) as latest FROM chunks GROUP BY session_key ORDER BY latest DESC",
     ).all() as any[];
 
+    let skillCount = 0;
+    try { skillCount = (db.prepare("SELECT COUNT(*) as count FROM skills").get() as any).count; } catch { /* table may not exist yet */ }
+
+    let dedupBreakdown: Record<string, number> = {};
+    try {
+      const dedupRows = db.prepare("SELECT dedup_status, COUNT(*) as count FROM chunks GROUP BY dedup_status").all() as any[];
+      dedupBreakdown = Object.fromEntries(dedupRows.map((d: any) => [d.dedup_status ?? "active", d.count]));
+    } catch { /* column may not exist yet */ }
+
     this.jsonResponse(res, {
       totalMemories: total.count, totalSessions: sessions.count, totalEmbeddings: embeddings.count,
+      totalSkills: skillCount,
       embeddingProvider: this.embedder.provider,
       roleBreakdown: Object.fromEntries(roles.map((r: any) => [r.role, r.count])),
       kindBreakdown: Object.fromEntries(kinds.map((k: any) => [k.kind, k.count])),
+      dedupBreakdown,
       timeRange: { earliest: timeRange.earliest, latest: timeRange.latest },
       sessions: sessionList,
     });
@@ -456,6 +503,136 @@ export class ViewerServer {
     });
   }
 
+  // ─── Skills API ───
+
+  private serveSkills(res: http.ServerResponse, url: URL): void {
+    const status = url.searchParams.get("status") ?? undefined;
+    const skills = this.store.listSkills({ status });
+    this.jsonResponse(res, { skills });
+  }
+
+  private serveSkillDetail(res: http.ServerResponse, urlPath: string): void {
+    const skillId = urlPath.replace("/api/skill/", "");
+    const skill = this.store.getSkill(skillId);
+    if (!skill) {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Skill not found" }));
+      return;
+    }
+
+    const versions = this.store.getSkillVersions(skillId);
+    const relatedTasks = this.store.getTasksBySkill(skillId);
+    const files = fs.existsSync(skill.dirPath) ? this.walkDir(skill.dirPath, skill.dirPath) : [];
+
+    this.jsonResponse(res, {
+      skill,
+      versions: versions.map(v => ({
+        id: v.id,
+        version: v.version,
+        content: v.content,
+        changelog: v.changelog,
+        changeSummary: v.changeSummary,
+        upgradeType: v.upgradeType,
+        sourceTaskId: v.sourceTaskId,
+        metrics: v.metrics,
+        qualityScore: v.qualityScore,
+        createdAt: v.createdAt,
+      })),
+      relatedTasks: relatedTasks.map(rt => ({
+        task: {
+          id: rt.task.id,
+          title: rt.task.title,
+          status: rt.task.status,
+          startedAt: rt.task.startedAt,
+        },
+        relation: rt.relation,
+      })),
+      files,
+    });
+  }
+
+  private serveSkillFiles(res: http.ServerResponse, urlPath: string): void {
+    const skillId = urlPath.replace("/api/skill/", "").replace("/files", "");
+    const skill = this.store.getSkill(skillId);
+    if (!skill) {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Skill not found" }));
+      return;
+    }
+
+    if (!fs.existsSync(skill.dirPath)) {
+      this.jsonResponse(res, { files: [], error: "Skill directory not found" });
+      return;
+    }
+
+    const files = this.walkDir(skill.dirPath, skill.dirPath);
+    this.jsonResponse(res, { files });
+  }
+
+  private walkDir(dir: string, root: string): Array<{ path: string; type: string; size: number }> {
+    const results: Array<{ path: string; type: string; size: number }> = [];
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        const relPath = path.relative(root, fullPath);
+        if (entry.isDirectory()) {
+          results.push(...this.walkDir(fullPath, root));
+        } else {
+          const stat = fs.statSync(fullPath);
+          const ext = path.extname(entry.name).toLowerCase();
+          let type = "file";
+          if (entry.name === "SKILL.md") type = "skill";
+          else if ([".sh", ".py", ".ts", ".js"].includes(ext)) type = "script";
+          else if ([".md", ".txt", ".json"].includes(ext)) type = "reference";
+          results.push({ path: relPath, type, size: stat.size });
+        }
+      }
+    } catch { /* directory may not exist */ }
+    return results;
+  }
+
+  private serveSkillDownload(res: http.ServerResponse, urlPath: string): void {
+    const skillId = urlPath.replace("/api/skill/", "").replace("/download", "");
+    const skill = this.store.getSkill(skillId);
+    if (!skill) {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Skill not found" }));
+      return;
+    }
+
+    if (!fs.existsSync(skill.dirPath)) {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Skill directory not found" }));
+      return;
+    }
+
+    const zipName = `${skill.name}-v${skill.version}.zip`;
+    const tmpPath = path.join(require("os").tmpdir(), zipName);
+
+    try {
+      try { fs.unlinkSync(tmpPath); } catch { /* no-op */ }
+      execSync(
+        `cd "${path.dirname(skill.dirPath)}" && zip -r "${tmpPath}" "${path.basename(skill.dirPath)}"`,
+        { timeout: 15_000 },
+      );
+
+      const data = fs.readFileSync(tmpPath);
+      res.writeHead(200, {
+        "Content-Type": "application/zip",
+        "Content-Disposition": `attachment; filename="${zipName}"`,
+        "Content-Length": String(data.length),
+      });
+      res.end(data);
+
+      try { fs.unlinkSync(tmpPath); } catch { /* cleanup */ }
+    } catch (err) {
+      this.log.error(`Skill download zip failed: ${err}`);
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: `Failed to create zip: ${err}` }));
+    }
+  }
+
   // ─── CRUD ───
 
   private handleCreate(req: http.IncomingMessage, res: http.ServerResponse): void {
@@ -469,7 +646,9 @@ export class ViewerServer {
           id, sessionKey: data.session_key || "manual", turnId: `manual-${now}`, seq: 0,
           role: data.role || "user", content: data.content || "", kind: data.kind || "paragraph",
           summary: data.summary || data.content?.slice(0, 100) || "",
-          taskId: null, createdAt: now, updatedAt: now, embedding: null,
+          taskId: null, skillId: null, dedupStatus: "active", dedupTarget: null, dedupReason: null,
+          mergeCount: 0, lastHitAt: null, mergeHistory: "[]",
+          createdAt: now, updatedAt: now, embedding: null,
         });
         this.jsonResponse(res, { ok: true, id, message: "Memory created" });
       } catch (err) {
@@ -479,6 +658,17 @@ export class ViewerServer {
     });
   }
 
+  private serveMemoryDetail(res: http.ServerResponse, urlPath: string): void {
+    const chunkId = urlPath.replace("/api/memory/", "");
+    const chunk = this.store.getChunk(chunkId);
+    if (!chunk) {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Not found" }));
+      return;
+    }
+    this.jsonResponse(res, { memory: chunk });
+  }
+
   private handleUpdate(req: http.IncomingMessage, res: http.ServerResponse, urlPath: string): void {
     const chunkId = urlPath.replace("/api/memory/", "");
     this.readBody(req, (body) => {
@@ -508,11 +698,102 @@ export class ViewerServer {
   }
 
   private handleDeleteAll(res: http.ServerResponse): void {
-    this.jsonResponse(res, { ok: true, deleted: this.store.deleteAll() });
+    const result = this.store.deleteAll();
+    // Clean up skills-store directory
+    const skillsStoreDir = path.join(this.dataDir, "skills-store");
+    try {
+      if (fs.existsSync(skillsStoreDir)) {
+        fs.rmSync(skillsStoreDir, { recursive: true });
+        fs.mkdirSync(skillsStoreDir, { recursive: true });
+        this.log.info("Cleared skills-store directory");
+      }
+    } catch (err) {
+      this.log.warn(`Failed to clear skills-store: ${err}`);
+    }
+    this.jsonResponse(res, { ok: true, deleted: result });
   }
 
   // ─── Helpers ───
 
+  // ─── Config API ───
+
+  private getOpenClawConfigPath(): string {
+    const home = process.env.HOME || process.env.USERPROFILE || "";
+    return path.join(home, ".openclaw", "openclaw.json");
+  }
+
+  private serveConfig(res: http.ServerResponse): void {
+    try {
+      const cfgPath = this.getOpenClawConfigPath();
+      if (!fs.existsSync(cfgPath)) {
+        this.jsonResponse(res, {});
+        return;
+      }
+      const raw = JSON.parse(fs.readFileSync(cfgPath, "utf-8"));
+      const pluginEntry = raw?.plugins?.entries?.["memos-local"]?.config ?? {};
+      const result: Record<string, unknown> = { ...pluginEntry };
+      if (raw?.plugins?.entries?.["memos-local"]?.config?.viewerPort == null) {
+        const topLevel = raw?.plugins?.entries?.["memos-local"] ?? {};
+        if (topLevel.viewerPort) result.viewerPort = topLevel.viewerPort;
+      }
+      this.jsonResponse(res, result);
+    } catch (e) {
+      this.log.warn(`serveConfig error: ${e}`);
+      this.jsonResponse(res, {});
+    }
+  }
+
+  private handleSaveConfig(req: http.IncomingMessage, res: http.ServerResponse): void {
+    this.readBody(req, (body) => {
+      try {
+        const newCfg = JSON.parse(body);
+        const cfgPath = this.getOpenClawConfigPath();
+        let raw: Record<string, unknown> = {};
+        if (fs.existsSync(cfgPath)) {
+          raw = JSON.parse(fs.readFileSync(cfgPath, "utf-8"));
+        }
+
+        if (!raw.plugins) raw.plugins = {};
+        const plugins = raw.plugins as Record<string, unknown>;
+        if (!plugins.entries) plugins.entries = {};
+        const entries = plugins.entries as Record<string, unknown>;
+        if (!entries["memos-local"]) entries["memos-local"] = { enabled: true };
+        const entry = entries["memos-local"] as Record<string, unknown>;
+        if (!entry.config) entry.config = {};
+        const config = entry.config as Record<string, unknown>;
+
+        if (newCfg.embedding) config.embedding = newCfg.embedding;
+        if (newCfg.summarizer) config.summarizer = newCfg.summarizer;
+        if (newCfg.skillEvolution) config.skillEvolution = newCfg.skillEvolution;
+        if (newCfg.viewerPort) config.viewerPort = newCfg.viewerPort;
+
+        fs.mkdirSync(path.dirname(cfgPath), { recursive: true });
+        fs.writeFileSync(cfgPath, JSON.stringify(raw, null, 2), "utf-8");
+        this.log.info("Plugin config updated via Viewer");
+        this.jsonResponse(res, { ok: true });
+      } catch (e) {
+        this.log.warn(`handleSaveConfig error: ${e}`);
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: String(e) }));
+      }
+    });
+  }
+
+  private serveLogs(res: http.ServerResponse, url: URL): void {
+    const limit = Math.min(Number(url.searchParams.get("limit") ?? 20), 200);
+    const offset = Math.max(0, Number(url.searchParams.get("offset") ?? 0));
+    const tool = url.searchParams.get("tool") || undefined;
+    const { logs, total } = this.store.getApiLogs(limit, offset, tool);
+    const page = Math.floor(offset / limit) + 1;
+    const totalPages = Math.ceil(total / limit);
+    this.jsonResponse(res, { logs, total, page, totalPages, limit, offset });
+  }
+
+  private serveLogTools(res: http.ServerResponse): void {
+    const tools = this.store.getApiLogToolNames();
+    this.jsonResponse(res, { tools });
+  }
+
   private readBody(req: http.IncomingMessage, cb: (body: string) => void): void {
     let body = "";
     req.on("data", (chunk: Buffer) => { body += chunk.toString(); });

package/skill/SKILL.md

@@ -1,59 +0,0 @@
----
-name: memos-local
-description: "Local long-term conversation memory (MemOS). All past conversations are recorded and searchable. Use this skill whenever the conversation involves user-specific information such as identity, preferences, project details, past decisions, or personal facts. Also use it when you cannot fully answer a question or would otherwise need to ask the user for more details — always search memory first, because the answer may already exist in a previous conversation. Similarly, when the user references something from the past (e.g. 'last time', 'as before', 'continue'), search memory to retrieve the relevant context. Start with memory_search for lightweight hits, then drill down with memory_get, task_summary, or memory_timeline as needed."
-metadata: { "openclaw": { "emoji": "🧠" } }
----
-
-# MemOS — Long-Term Memory (Local)
-
-You have a local long-term memory that records conversation history. When you need historical information, use the tools below to search and drill down, aiming to get **enough to answer** with the **shortest context**.
-
-## Tools
-
-| Tool              | What it does                                                             |
-| ----------------- | ------------------------------------------------------------------------ |
-| `memory_search`   | Lightweight search of conversation history. Returns hit summaries + IDs/refs (information may be truncated/compressed). |
-| `memory_get`      | Fetch the **full original text** of a hit by `chunkId` (use when the summary is insufficient / the original is longer but you only need this one entry). |
-| `task_summary`    | Get the **full task-level context summary** for the task a hit belongs to by `taskId` (use when you judge that more key information may be in other turns of the same task). |
-| `memory_timeline` | Expand the context before and after a hit using its `ref` (use when you need the cause-and-effect / chronological details of a conversation). |
-| `memory_viewer`   | Returns the Memory Viewer URL (http://127.0.0.1:18799). |
-
-## When to Trigger a Search (Trigger)
-
-Trigger a search when any of the following applies:
-
-* The current context is insufficient to answer definitively (missing key parameters/links/paths/versions/decisions, etc.)
-* You are about to ask the user for information (try searching memory first)
-* The user references history ("last time / before / continue / as previously planned")
-* You need user-specific information (preferences, identity, project config, directory structure, deployment method, etc.)
-
-## Layered Retrieval Strategy (Minimum Information → Progressive Completion)
-
-```text
-Step 1: memory_search(query="keywords")
-  - Goal: quickly get 1-6 most relevant hits (summary + chunkId/taskId/ref)
-
-Step 2: Sufficiency check
-  - If hit summaries are enough to support the answer → answer directly, stop drilling down
-  - If summary is insufficient/truncated but "looks useful" → memory_get(chunkId)
-
-Step 3: Related but missing broader context → task_summary(taskId)
-  - Applies when: you judge that missing information may be in other turns of the same task
-  - Note: conversations are split into tasks by topic/time; each hit typically belongs to a taskId
-  - Example: search hits "steps to apply for GPT key", but the summary lacks the website link/prerequisites
-             → calling task_summary retrieves the more complete context and details for that task
-
-Step 4: Still need cause-and-effect / chronological details → memory_timeline(ref)
-  - Applies when: you need to expand several turns before and after a hit to fill in details and context
-
-Step 5: Still insufficient
-  - Identify the specific missing fields and ask the user a minimal follow-up question
-```
-
-## Rules
-
-* **If you don't know the answer, or you are about to ask the user for clarification/details, you MUST call `memory_search` first.** The user may have already provided this information in a previous conversation. Never say "I don't know" or ask the user without searching memory first.
-* Always `memory_search` first, then decide whether to use `memory_get` / `task_summary` / `memory_timeline`
-* `memory_get` is for "summary isn't enough but this hit is very likely the answer" — avoid pulling in excessive irrelevant context
-* `task_summary` is for "hit is relevant, but the answer may be scattered across other parts of the same task" — use the task-level summary to fill in at once
-* `memory_timeline` should only be used when you genuinely need surrounding context — avoid unnecessarily expanding the context window