@memtensor/memos-local-openclaw-plugin 0.1.3 → 0.1.5

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");
@@ -155,12 +158,25 @@ 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" });
@@ -272,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;
@@ -302,12 +318,93 @@ export class ViewerServer {
     const totalRow = db.prepare("SELECT COUNT(*) as count FROM chunks" + where).get(...params) as any;
     const memories = db.prepare("SELECT * FROM chunks" + where + ` ORDER BY created_at ${sortBy} LIMIT ? OFFSET ?`).all(...params, limit, offset);
 
+    this.store.recordViewerEvent("list");
     this.jsonResponse(res, {
       memories, page, limit, total: totalRow.count,
       totalPages: Math.ceil(totalRow.count / limit),
     });
   }
 
+  private serveMetrics(res: http.ServerResponse, url: URL): void {
+    const days = Math.min(90, Math.max(7, Number(url.searchParams.get("days")) || 30));
+    const data = this.store.getMetrics(days);
+    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;
+    const limit = Math.min(100, Math.max(1, Number(url.searchParams.get("limit")) || 50));
+    const offset = Math.max(0, Number(url.searchParams.get("offset")) || 0);
+    const { tasks, total } = this.store.listTasks({ status, limit, offset });
+
+    const items = tasks.map((t) => ({
+      id: t.id,
+      sessionKey: t.sessionKey,
+      title: t.title,
+      summary: t.summary ? (t.summary.length > 300 ? t.summary.slice(0, 297) + "..." : t.summary) : "",
+      status: t.status,
+      startedAt: t.startedAt,
+      endedAt: t.endedAt,
+      chunkCount: this.store.countChunksByTask(t.id),
+    }));
+
+    this.jsonResponse(res, { tasks: items, total, limit, offset });
+  }
+
+  private serveTaskDetail(res: http.ServerResponse, urlPath: string): void {
+    const taskId = urlPath.replace("/api/task/", "");
+    const task = this.store.getTask(taskId);
+    if (!task) {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Task not found" }));
+      return;
+    }
+
+    const chunks = this.store.getChunksByTask(taskId);
+    const chunkItems = chunks.map((c) => ({
+      id: c.id,
+      role: c.role,
+      content: c.content.length > 500 ? c.content.slice(0, 497) + "..." : c.content,
+      summary: c.summary,
+      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,
+      title: task.title,
+      summary: task.summary,
+      status: task.status,
+      startedAt: task.startedAt,
+      endedAt: task.endedAt,
+      chunks: chunkItems,
+      skillStatus: meta?.skill_status ?? null,
+      skillReason: meta?.skill_reason ?? null,
+      skillLinks,
+    });
+  }
+
   private serveStats(res: http.ServerResponse): void {
     const db = (this.store as any).db;
     const total = db.prepare("SELECT COUNT(*) as count FROM chunks").get() as any;
@@ -320,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,
     });
@@ -385,6 +493,7 @@ export class ViewerServer {
       if (!seenIds.has(r.id)) { seenIds.add(r.id); merged.push(r); }
     }
 
+    this.store.recordViewerEvent("search");
     this.jsonResponse(res, {
       results: merged,
       query: q,
@@ -394,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 {
@@ -407,6 +646,8 @@ 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, 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" });
@@ -417,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) => {
@@ -446,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.md

@@ -1,43 +0,0 @@
-# Memory Recall Skill — memos-local
-
-You have access to long-term conversation memory through four tools:
-`memory_search`, `memory_timeline`, `memory_get`, `memory_viewer` (returns the web dashboard URL).
-
-## When to Search
-
-- **DO search** when the user asks about a previous conversation, a specific detail (command, error, parameter, decision) you don't have in the current context, or when the topic clearly references past interactions.
-- **DO NOT search** when the current context already contains enough information to answer accurately.
-
-## Progressive Recall Chain
-
-Follow this 3-step chain. Stop as soon as you have sufficient evidence.
-
-### Step 1 — `memory_search`
-
-Start with the default call (no extra parameters → top 6 results, minScore 0.45).
-
-- If results are insufficient, **refine the query first** (add entity names, exact commands, error keywords).
-- If still insufficient, increase `maxResults` to 12, then 20.
-- As a last resort, lower `minScore` to 0.35.
-- **Never repeat the exact same query with the same parameters** — vary query wording or adjust parameters.
-
-### Step 2 — `memory_timeline`
-
-When a search hit looks relevant but the `original_excerpt` is too short to confirm, call `memory_timeline` with the hit's `ref` to get surrounding context (±2 turns by default).
-
-### Step 3 — `memory_get`
-
-When you need the exact original text (to verify a command, a code snippet, an error stack), call `memory_get` with the `ref` and request up to 2000 characters (max 8000).
-
-## How to Answer
-
-1. **Evidence-based**: Only state facts backed by `original_excerpt`, timeline entries, or `memory_get` content. Do not fabricate details.
-2. **Cite sources**: When referencing a memory, mention the approximate time and context (e.g., "In our conversation about deploying the API…").
-3. **Acknowledge gaps**: If memory search returns no relevant results, say so honestly rather than guessing.
-
-## Anti-Patterns to Avoid
-
-- Searching on every single turn (only search when needed).
-- Repeating the same failed query without modification.
-- Ignoring `original_excerpt` and only using `summary` — the excerpt is the primary evidence.
-- Making claims based solely on `summary` without checking the original text when details matter.