/**
 * Memory Viewer — API Server (Hono)
 *
 * Provides REST endpoints for browsing, reading, editing, and searching
 * Markdown files, plus a WebSocket channel that pushes live file-change
 * notifications to connected clients.
 */
import { Hono } from "hono";
import { compress } from "hono/compress";
import { cors } from "hono/cors";
import { serveStatic } from "@hono/node-server/serve-static";
import { createNodeWebSocket } from "@hono/node-ws";
import { serve } from "@hono/node-server";
import fs from "fs";
import path from "path";
import os from "os";
import Database from "better-sqlite3";
import { exec as execCallback } from "child_process";
import util from "util";
import { watch } from "chokidar";
import type { WSContext } from "hono/ws";

const exec = util.promisify(execCallback);

// ---------------------------------------------------------------------------
// Agent Config Types
// ---------------------------------------------------------------------------
interface AgentConfig {
  id: string;
  name: string;
  workspace?: string;
  agentDir?: string;
  identity?: {
    name?: string;
    emoji?: string;
  };
  skills?: string[];
}

interface AgentsConfig {
  defaults: {
    workspace?: string;
  };
  list: AgentConfig[];
}

interface OpenClawConfig {
  agents?: AgentsConfig;
}

interface AgentInfo {
  id: string;
  name: string;
  workspace: string;
  emoji: string;
  skills?: string[];
}

// ---------------------------------------------------------------------------
// Settings
// ---------------------------------------------------------------------------
const SETTINGS_DIR = path.join(os.homedir(), ".config", "memory-viewer");
const SETTINGS_FILE = path.join(SETTINGS_DIR, "settings.json");

interface AppSettings {
  embedding: {
    enabled: boolean;
    apiUrl: string;
    apiKey: string;
    model: string;
  };
  pluginsDir: string;
}

const DEFAULT_SETTINGS: AppSettings = {
  embedding: { enabled: false, apiUrl: "", apiKey: "", model: "" },
  pluginsDir: "",
};

function loadSettings(): AppSettings {
  try {
    const raw = fs.readFileSync(SETTINGS_FILE, "utf-8");
    return { ...DEFAULT_SETTINGS, ...JSON.parse(raw) };
  } catch {
    return { ...DEFAULT_SETTINGS };
  }
}

function saveSettings(s: AppSettings): void {
  fs.mkdirSync(SETTINGS_DIR, { recursive: true });
  fs.writeFileSync(SETTINGS_FILE, JSON.stringify(s, null, 2));
}

let appSettings = loadSettings();

// ---------------------------------------------------------------------------
// Config
// ---------------------------------------------------------------------------
const PORT = Number(process.env.PORT) || 3001;
const DEFAULT_WORKSPACE = process.env.WORKSPACE_DIR || path.join(os.homedir(), "clawd");
const STATIC_DIR = process.env.STATIC_DIR || path.join(import.meta.dirname, "..", "dist");

const app = new Hono();
export { app }; // Export for testing
const { injectWebSocket, upgradeWebSocket } = createNodeWebSocket({ app });

app.use("*", compress());
app.use("*", cors({ origin: "*" }));

// ---------------------------------------------------------------------------
// Agent Management
// ---------------------------------------------------------------------------
const OPENCLAW_CONFIG_PATH = path.join(os.homedir(), ".openclaw", "openclaw.json");

function loadOpenClawConfig(): OpenClawConfig | null {
  try {
    if (fs.existsSync(OPENCLAW_CONFIG_PATH)) {
      const raw = fs.readFileSync(OPENCLAW_CONFIG_PATH, "utf-8");
      return JSON.parse(raw);
    }
  } catch (e) {
    console.error("Failed to load OpenClaw config:", e);
  }
  return null;
}

function getAgentWorkspace(agentConfig: AgentConfig, defaults: { workspace?: string }): string {
  // Priority: workspace > agentDir > defaults.workspace > DEFAULT_WORKSPACE
  if (agentConfig.workspace) {
    return agentConfig.workspace;
  }
  if (agentConfig.agentDir) {
    return agentConfig.agentDir;
  }
  if (defaults.workspace) {
    return defaults.workspace;
  }
  return DEFAULT_WORKSPACE;
}

function getAgents(): AgentInfo[] {
  const config = loadOpenClawConfig();
  if (!config?.agents?.list) {
    // Return default agent if no config
    return [{
      id: "default",
      name: "Default Agent",
      workspace: DEFAULT_WORKSPACE,
      emoji: "🤖",
    }];
  }

  const defaults = config.agents.defaults || {};
  
  return config.agents.list.map((agent) => ({
    id: agent.id,
    name: agent.name || agent.id,
    workspace: getAgentWorkspace(agent, defaults),
    emoji: agent.identity?.emoji || "🤖",
    skills: agent.skills || undefined,
  }));
}

function getAgentById(agentId: string): AgentInfo | null {
  const agents = getAgents();
  return agents.find((a) => a.id === agentId) || null;
}

// Get workspace for a given agent ID
function getWorkspaceForAgent(agentId: string | null | undefined): string {
  if (!agentId || agentId === "default") {
    // Try to find "default" agent in config, otherwise use default workspace
    const agent = getAgentById("default");
    if (agent) return agent.workspace;
    return DEFAULT_WORKSPACE;
  }
  
  const agent = getAgentById(agentId);
  if (agent) return agent.workspace;
  
  // Fallback to default workspace if agent not found
  return DEFAULT_WORKSPACE;
}

// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------

function safePath(filePath: string | undefined | null, workspace: string): string | null {
  if (!filePath || filePath.includes("..") || !filePath.endsWith(".md")) return null;
  const full = path.resolve(workspace, filePath);
  if (!full.startsWith(path.resolve(workspace))) return null;
  return full;
}

interface TreeNode {
  name: string;
  type: "file" | "dir";
  path: string;
  children?: TreeNode[];
}

function scanDir(dir: string, prefix = ""): TreeNode[] {
  const result: TreeNode[] = [];
  let entries: fs.Dirent[];
  try {
    entries = fs.readdirSync(dir, { withFileTypes: true });
  } catch {
    return result;
  }
  for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
    if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
    const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
    if (entry.isDirectory()) {
      const children = scanDir(path.join(dir, entry.name), relPath);
      if (children.length > 0) {
        result.push({ name: entry.name, type: "dir", path: relPath, children });
      }
    } else if (entry.name.endsWith(".md")) {
      result.push({ name: entry.name, type: "file", path: relPath });
    }
  }
  return result;
}

function collectMdFiles(dir: string, prefix = ""): string[] {
  const files: string[] = [];
  let entries: fs.Dirent[];
  try {
    entries = fs.readdirSync(dir, { withFileTypes: true });
  } catch {
    return files;
  }
  for (const entry of entries) {
    if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
    const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
    if (entry.isDirectory()) {
      files.push(...collectMdFiles(path.join(dir, entry.name), relPath));
    } else if (entry.name.endsWith(".md")) {
      files.push(relPath);
    }
  }
  return files;
}

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
// REST API
// ---------------------------------------------------------------------------

// Get agent from query parameter
function getAgentFromQuery(c: any): { agentId: string; workspace: string } {
  const agentId = c.req.query("agent") || "default";
  const workspace = getWorkspaceForAgent(agentId);
  return { agentId, workspace };
}

// Agents API
app.get("/api/agents", (c) => {
  return c.json(getAgents());
});

app.get("/api/skills", (c) => {
  const { workspace } = getAgentFromQuery(c);
  const skillsDir = path.join(workspace, "skills");
  const results: { id: string; name: string; description: string; path: string }[] = [];
  let entries: fs.Dirent[];
  try {
    entries = fs.readdirSync(skillsDir, { withFileTypes: true });
  } catch {
    return c.json([]);
  }
  for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
    if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
    const skillMd = path.join(skillsDir, entry.name, "SKILL.md");
    if (!fs.existsSync(skillMd)) continue;
    const content = fs.readFileSync(skillMd, "utf-8");
    let name = entry.name;
    let description = "";
    const fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
    if (fmMatch) {
      const nameMatch = fmMatch[1].match(/^name:\s*(.+)/m);
      const descMatch = fmMatch[1].match(/^description:\s*(.+)/m);
      if (nameMatch) name = nameMatch[1].trim().replace(/^["']|["']$/g, "");
      if (descMatch) description = descMatch[1].trim().replace(/^["']|["']$/g, "");
    }
    results.push({ id: entry.name, name, description, path: `skills/${entry.name}/SKILL.md` });
  }
  return c.json(results);
});

app.get("/api/files", (c) => {
  const { workspace } = getAgentFromQuery(c);
  return c.json(scanDir(workspace));
});

app.get("/api/file", (c) => {
  const { workspace } = getAgentFromQuery(c);
  const full = safePath(c.req.query("path"), workspace);
  if (!full) return c.json({ error: "Invalid path" }, 400);
  if (!fs.existsSync(full)) return c.json({ error: "Not found" }, 404);
  const content = fs.readFileSync(full, "utf-8");
  const stat = fs.statSync(full);
  return c.json({ content, mtime: stat.mtime, size: stat.size });
});

app.put("/api/file", async (c) => {
  const { workspace } = getAgentFromQuery(c);
  const { path: filePath, content, expectedMtime } = await c.req.json();
  const full = safePath(filePath, workspace);
  if (!full) return c.json({ error: "Invalid path" }, 400);

  if (expectedMtime && fs.existsSync(full)) {
    const currentMtime = fs.statSync(full).mtime.toISOString();
    if (currentMtime !== expectedMtime) {
      const currentContent = fs.readFileSync(full, "utf-8");
      return c.json({
        error: "conflict",
        message: "File was modified since you started editing",
        serverMtime: currentMtime,
        serverContent: currentContent,
      }, 409);
    }
  }

  fs.mkdirSync(path.dirname(full), { recursive: true });
  fs.writeFileSync(full, content, "utf-8");
  const stat = fs.statSync(full);
  return c.json({ ok: true, mtime: stat.mtime });
});

app.get("/api/resolve-wikilink", (c) => {
  const { workspace } = getAgentFromQuery(c);
  const link = (c.req.query("link") || "").trim();
  if (!link) return c.json({ error: "Missing link parameter" }, 400);

  const allFiles = collectMdFiles(workspace);

  // Try exact path match first
  const exactPath = link.endsWith(".md") ? link : `${link}.md`;
  if (allFiles.includes(exactPath)) {
    return c.json({ found: true, path: exactPath });
  }

  // Try case-insensitive exact path
  const exactLower = exactPath.toLowerCase();
  const ciMatch = allFiles.find((f) => f.toLowerCase() === exactLower);
  if (ciMatch) {
    return c.json({ found: true, path: ciMatch });
  }

  // Try filename-only match (fuzzy)
  const linkLower = link.toLowerCase();
  const byName = allFiles.find((f) => {
    const name = path.basename(f, ".md");
    return name.toLowerCase() === linkLower;
  });
  if (byName) {
    return c.json({ found: true, path: byName });
  }

  return c.json({ found: false, path: null });
});

app.get("/api/search", (c) => {
  const { workspace } = getAgentFromQuery(c);
  const q = (c.req.query("q") || "").trim().toLowerCase();
  if (!q || q.length < 2) return c.json([]);

  const files = collectMdFiles(workspace);
  const results: { path: string; matches: { line: number; text: string }[] }[] = [];

  for (const relPath of files) {
    const full = path.join(workspace, relPath);
    let content: string;
    try {
      content = fs.readFileSync(full, "utf-8");
    } catch {
      continue;
    }
    const lines = content.split("\n");
    const matches: { line: number; text: string }[] = [];
    for (let i = 0; i < lines.length; i++) {
      if (lines[i].toLowerCase().includes(q)) {
        matches.push({ line: i + 1, text: lines[i].substring(0, 200) });
        if (matches.length >= 5) break;
      }
    }
    if (matches.length > 0) results.push({ path: relPath, matches });
    if (results.length >= 50) break;
  }
  return c.json(results);
});

// QMD availability detection — cached at startup
let qmdAvailable: boolean | null = null;
let qmdHasVectors = false;

async function detectQmd(): Promise<void> {
  try {
    const { stdout } = await exec(
      `export PATH="$HOME/.bun/bin:$PATH" && qmd status 2>/dev/null`,
      { timeout: 5000 }
    );
    qmdAvailable = stdout.includes("Documents");
    qmdHasVectors = /Vectors:\s*[1-9]/.test(stdout);
    console.log(`🔍 QMD: ${qmdAvailable ? "available" : "not found"}${qmdHasVectors ? " (vectors ready)" : ""}`);
  } catch {
    qmdAvailable = false;
    qmdHasVectors = false;
    console.log("🔍 QMD: not installed");
  }
}

// Run detection on startup
detectQmd();

// External plugins directory
const PLUGINS_DIR = appSettings.pluginsDir || process.env.PLUGINS_DIR || "";

app.get("/api/plugins", (c) => {
  if (!PLUGINS_DIR || !fs.existsSync(PLUGINS_DIR)) return c.json([]);
  try {
    const plugins: { id: string; name: string; entry: string }[] = [];
    for (const dir of fs.readdirSync(PLUGINS_DIR, { withFileTypes: true })) {
      if (!dir.isDirectory()) continue;
      const manifestPath = path.join(PLUGINS_DIR, dir.name, "plugin.json");
      if (fs.existsSync(manifestPath)) {
        const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
        plugins.push({ id: manifest.id || dir.name, name: manifest.name || dir.name, entry: manifest.entry || "index.js" });
      }
    }
    return c.json(plugins);
  } catch { return c.json([]); }
});

// Serve plugin files
app.get("/api/plugins/:id/*", (c) => {
  if (!PLUGINS_DIR) return c.text("No plugins dir", 404);
  const pluginId = c.req.param("id");
  const filePath = c.req.path.replace(`/api/plugins/${pluginId}/`, "");
  const full = path.join(PLUGINS_DIR, pluginId, filePath);
  if (!full.startsWith(path.join(PLUGINS_DIR, pluginId))) return c.text("Forbidden", 403);
  if (!fs.existsSync(full)) return c.text("Not found", 404);
  const content = fs.readFileSync(full, "utf-8");
  const ext = path.extname(full);
  const ct = ext === ".js" ? "application/javascript" : ext === ".css" ? "text/css" : "text/plain";
  return c.text(content, 200, { "Content-Type": ct });
});

app.get("/api/capabilities", (c) => {
  const embeddingReady = appSettings.embedding.enabled && !!appSettings.embedding.apiUrl && !!appSettings.embedding.apiKey;
  return c.json({
    qmd: qmdAvailable === true,
    qmdBm25: qmdAvailable === true,
    qmdVector: qmdHasVectors || embeddingReady,
    embeddingApi: embeddingReady,
  });
});

// Settings API
app.get("/api/settings", (c) => {
  return c.json({
    embedding: {
      enabled: appSettings.embedding.enabled,
      apiUrl: appSettings.embedding.apiUrl,
      apiKeySet: !!appSettings.embedding.apiKey,
      model: appSettings.embedding.model,
    },
  });
});

app.put("/api/settings", async (c) => {
  const body = await c.req.json();
  if (body.embedding) {
    appSettings.embedding.enabled = body.embedding.enabled ?? appSettings.embedding.enabled;
    appSettings.embedding.apiUrl = body.embedding.apiUrl ?? appSettings.embedding.apiUrl;
    appSettings.embedding.model = body.embedding.model ?? appSettings.embedding.model;
    if (body.embedding.apiKey) {
      appSettings.embedding.apiKey = body.embedding.apiKey;
    }
  }
  saveSettings(appSettings);
  return c.json({ ok: true });
});

app.get("/api/settings/embedding-stats", (c) => {
  const { workspace } = getAgentFromQuery(c);
  try {
    const db = getEmbeddingsDb();
    const model = appSettings.embedding.model || "text-embedding-3-small";
    const total = (db.prepare("SELECT COUNT(*) as n FROM embeddings WHERE model = ?").get(model) as any)?.n || 0;
    const allFiles = collectMdFiles(workspace).length;
    const dbSize = fs.existsSync(EMBEDDINGS_DB_PATH) ? fs.statSync(EMBEDDINGS_DB_PATH).size : 0;
    return c.json({
      cachedFiles: total,
      totalFiles: allFiles,
      coverage: allFiles > 0 ? Math.round((total / allFiles) * 100) : 0,
      dbSize,
      model,
    });
  } catch {
    return c.json({ cachedFiles: 0, totalFiles: 0, coverage: 0, dbSize: 0, model: "" });
  }
});

app.post("/api/settings/test-embedding", async (c) => {
  const { apiUrl, apiKey, model } = await c.req.json();
  const url = apiUrl || appSettings.embedding.apiUrl;
  const key = apiKey || appSettings.embedding.apiKey;
  const mdl = model || appSettings.embedding.model || "text-embedding-3-small";

  if (!url) return c.json({ ok: false, message: "API URL is required" });

  try {
    const resp = await fetch(url, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        ...(key ? { Authorization: `Bearer ${key}` } : {}),
      },
      body: JSON.stringify({ input: "test", model: mdl }),
      signal: AbortSignal.timeout(10000),
    });
    const data: any = await resp.json();
    if (data.data?.[0]?.embedding) {
      const dim = data.data[0].embedding.length;
      return c.json({ ok: true, message: `✅ ${dim}维向量` });
    }
    return c.json({ ok: false, message: data.error?.message || "Unexpected response" });
  } catch (e: any) {
    return c.json({ ok: false, message: e.message || "Connection failed" });
  }
});

function qmdUriToRelPath(uri: string): string {
  // qmd://clawd-memory/memory/survival.md → memory/survival.md
  // qmd://clawd-root/MEMORY.md → MEMORY.md
  // All collections index from workspace root, so just strip the qmd://collection/ prefix
  const match = uri.match(/^qmd:\/\/[^/]+\/(.+)$/);
  return match ? match[1] : uri;
}

// Embedding API helper
async function getEmbedding(text: string): Promise<number[] | null> {
  const { apiUrl, apiKey, model } = appSettings.embedding;
  if (!apiUrl || !apiKey) return null;
  try {
    const resp = await fetch(apiUrl, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        Authorization: `Bearer ${apiKey}`,
      },
      body: JSON.stringify({ input: text, model: model || "text-embedding-3-small" }),
      signal: AbortSignal.timeout(10000),
    });
    const data: any = await resp.json();
    return data.data?.[0]?.embedding ?? null;
  } catch {
    return null;
  }
}

function cosineSim(a: number[], b: number[]): number {
  let dot = 0, na = 0, nb = 0;
  for (let i = 0; i < a.length; i++) {
    dot += a[i] * b[i];
    na += a[i] * a[i];
    nb += b[i] * b[i];
  }
  return dot / (Math.sqrt(na) * Math.sqrt(nb) + 1e-10);
}

// SQLite embedding cache — persistent across restarts
const EMBEDDINGS_DB_PATH = path.join(SETTINGS_DIR, "embeddings.sqlite");
let embeddingsDb: Database.Database | null = null;

function getEmbeddingsDb(): Database.Database {
  if (!embeddingsDb) {
    fs.mkdirSync(SETTINGS_DIR, { recursive: true });
    embeddingsDb = new Database(EMBEDDINGS_DB_PATH);
    embeddingsDb.pragma("journal_mode = WAL");
    embeddingsDb.exec(`
      CREATE TABLE IF NOT EXISTS embeddings (
        file_path TEXT PRIMARY KEY,
        mtime REAL NOT NULL,
        model TEXT NOT NULL,
        embedding BLOB NOT NULL
      )
    `);
  }
  return embeddingsDb;
}

function getCachedEmbedding(filePath: string, mtime: number): number[] | null {
  const db = getEmbeddingsDb();
  const model = appSettings.embedding.model || "text-embedding-3-small";
  const row = db.prepare("SELECT embedding FROM embeddings WHERE file_path = ? AND mtime = ? AND model = ?").get(filePath, mtime, model) as any;
  if (!row) return null;
  return Array.from(new Float64Array(row.embedding.buffer, row.embedding.byteOffset, row.embedding.byteLength / 8));
}

function setCachedEmbedding(filePath: string, mtime: number, embedding: number[]): void {
  const db = getEmbeddingsDb();
  const model = appSettings.embedding.model || "text-embedding-3-small";
  const buf = Buffer.from(new Float64Array(embedding).buffer);
  db.prepare("INSERT OR REPLACE INTO embeddings (file_path, mtime, model, embedding) VALUES (?, ?, ?, ?)").run(filePath, mtime, model, buf);
}

async function getFileEmbeddings(files: string[], workspace: string): Promise<Map<string, number[]>> {
  const result = new Map<string, number[]>();
  const toEmbed: string[] = [];

  for (const relPath of files) {
    const full = path.join(workspace, relPath);
    try {
      const stat = fs.statSync(full);
      const cached = getCachedEmbedding(relPath, stat.mtimeMs);
      if (cached) {
        result.set(relPath, cached);
      } else {
        toEmbed.push(relPath);
      }
    } catch { /* skip */ }
  }

  // Embed uncached files (max 20 per request to stay responsive)
  for (const relPath of toEmbed.slice(0, 20)) {
    const full = path.join(workspace, relPath);
    try {
      const content = fs.readFileSync(full, "utf-8").substring(0, 2000);
      const emb = await getEmbedding(content);
      if (emb) {
        const stat = fs.statSync(full);
        setCachedEmbedding(relPath, stat.mtimeMs, emb);
        result.set(relPath, emb);
      }
    } catch { /* skip */ }
  }

  return result;
}

app.get("/api/semantic-search", async (c) => {
  const { workspace } = getAgentFromQuery(c);
  const q = (c.req.query("q") || "").trim();
  const mode = c.req.query("mode") || "bm25"; // bm25 | vector
  if (!q || q.length < 2) return c.json([]);

  // BM25 mode: use QMD
  if (mode === "bm25" && qmdAvailable) {
    try {
      const { stdout } = await exec(
        `export PATH="$HOME/.bun/bin:$PATH" && qmd search ${JSON.stringify(q)} -n 10 --json`,
        { timeout: 20000 }
      );
      const raw: { docid: string; score: number; file: string; title: string; snippet: string }[] = JSON.parse(stdout);
      return c.json(raw.map((r) => ({
        path: qmdUriToRelPath(r.file),
        title: r.title,
        snippet: r.snippet.replace(/@@ [^@]+ @@[^\n]*\n?/, "").substring(0, 300),
        score: Math.round(r.score * 100),
      })));
    } catch (e: any) {
      console.error("BM25 search error:", e.message);
      return c.json([]);
    }
  }

  // Vector mode: use embedding API
  if (mode === "vector" && appSettings.embedding.enabled && appSettings.embedding.apiKey) {
    try {
      const queryEmb = await getEmbedding(q);
      if (!queryEmb) return c.json([]);

      const files = collectMdFiles(workspace);
      const fileEmbs = await getFileEmbeddings(files, workspace);

      const scored: { path: string; score: number; snippet: string; title: string }[] = [];
      for (const [filePath, emb] of fileEmbs) {
        const sim = cosineSim(queryEmb, emb);
        const full = path.join(workspace, filePath);
        let content = "";
        try { content = fs.readFileSync(full, "utf-8"); } catch { continue; }
        const firstLine = content.split("\n").find(l => l.startsWith("#"))?.replace(/^#+\s*/, "") || filePath;
        scored.push({
          path: filePath,
          score: Math.round(sim * 100),
          title: firstLine,
          snippet: content.substring(0, 300).replace(/\n/g, " "),
        });
      }

      scored.sort((a, b) => b.score - a.score);
      return c.json(scored.slice(0, 10));
    } catch (e: any) {
      console.error("Vector search error:", e.message);
      return c.json([]);
    }
  }

  return c.json([]);
});

// ============================================================================
// Tags API - Extract and manage tags from markdown files
// ============================================================================

interface TagInfo {
  name: string;
  count: number;
  files: string[];
}

interface FileWithTags {
  path: string;
  title: string;
  preview: string;
  date: string;
  tags: string[];
}

// Extract tags from content: ## headers and #hashtags
function extractTags(content: string): string[] {
  const tags = new Set<string>();

  // Extract ## headers
  const headers = content.match(/^##\s+(.+)$/gm) || [];
  headers.forEach(h => {
    const tag = h.replace(/^##\s+/, "").replace(/[*_`]/g, "").trim();
    if (tag.length < 30 && tag.length > 0) tags.add(tag);
  });

  // Extract #hashtags (but not markdown headers)
  const hashtags = content.match(/(?<![#\w])#([\w\u4e00-\u9fa5_-]+)/g) || [];
  hashtags.forEach(h => {
    const tag = h.replace(/^#/, "").trim();
    if (tag.length < 30 && tag.length > 0) tags.add(tag);
  });

  return Array.from(tags);
}

// Scan all markdown files and extract tags
function scanAllTags(workspace: string): Map<string, TagInfo> {
  const tagMap = new Map<string, TagInfo>();
  const mdFiles = collectMdFiles(workspace);

  for (const relPath of mdFiles) {
    const fullPath = path.join(workspace, relPath);
    try {
      const content = fs.readFileSync(fullPath, "utf-8");
      const tags = extractTags(content);

      for (const tag of tags) {
        if (!tagMap.has(tag)) {
          tagMap.set(tag, { name: tag, count: 0, files: [] });
        }
        const info = tagMap.get(tag)!;
        info.count++;
        info.files.push(relPath);
      }
    } catch { /* skip */ }
  }

  return tagMap;
}

app.get("/api/tags", (c) => {
  const { workspace } = getAgentFromQuery(c);
  const tagMap = scanAllTags(workspace);
  const tags = Array.from(tagMap.values()).sort((a, b) => b.count - a.count);
  return c.json(tags);
});

app.get("/api/files-by-tag/:tag", (c) => {
  const { workspace } = getAgentFromQuery(c);
  const tagParam = decodeURIComponent(c.req.param("tag"));
  const tagMap = scanAllTags(workspace);
  const tagInfo = tagMap.get(tagParam);

  if (!tagInfo) {
    return c.json([]);
  }

  const results: FileWithTags[] = [];
  for (const relPath of tagInfo.files) {
    const fullPath = path.join(workspace, relPath);
    try {
      const content = fs.readFileSync(fullPath, "utf-8");
      const clean = content.replace(/^---[\s\S]*?---/, "").trim();
      const titleMatch = clean.match(/^#\s+(.+)$/m);
      const title = titleMatch ? titleMatch[1].trim() : path.basename(relPath, ".md");
      const lines = clean.split("\n").filter(l => l.trim() && !l.startsWith("#"));
      let preview = lines.slice(0, 2).join(" ").replace(/[*_`\[\]]/g, "").trim();
      if (preview.length > 120) preview = preview.slice(0, 120) + "…";
      const date = relPath.match(/(\d{4}-\d{2}-\d{2})/)?.[1] || "";
      const fileTags = extractTags(content);

      results.push({
        path: relPath,
        title,
        preview: preview || "(空)",
        date,
        tags: fileTags,
      });
    } catch { /* skip */ }
  }

  // Sort by date (newest first)
  results.sort((a, b) => b.date.localeCompare(a.date));
  return c.json(results);
});

app.get("/api/timeline", (c) => {
  const { workspace } = getAgentFromQuery(c);
  const memoryDir = path.join(workspace, "memory");
  const results: { date: string; path: string; title: string; preview: string; tags: string[]; charCount: number }[] = [];

  function scanDir(dir: string, rel: string) {
    let entries: fs.Dirent[];
    try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
    for (const e of entries) {
      if (e.isDirectory()) {
        scanDir(path.join(dir, e.name), rel ? `${rel}/${e.name}` : e.name);
      } else if (e.isFile() && /^\d{4}-\d{2}-\d{2}(-\w+)?\.md$/.test(e.name)) {
        const filePath = `memory/${rel ? rel + "/" : ""}${e.name}`;
        const fullPath = path.join(dir, e.name);
        try {
          const content = fs.readFileSync(fullPath, "utf-8");
          const date = e.name.match(/(\d{4}-\d{2}-\d{2})/)?.[1] || "";
          const clean = content.replace(/^---[\s\S]*?---/, "").trim();
          const titleMatch = clean.match(/^#\s+(.+)$/m);
          const title = titleMatch ? titleMatch[1].trim() : e.name.replace(/\.md$/, "");
          const lines = clean.split("\n").filter(l => l.trim() && !l.startsWith("#"));
          let preview = lines.slice(0, 2).join(" ").replace(/[*_`\[\]]/g, "").trim();
          if (preview.length > 120) preview = preview.slice(0, 120) + "…";
          const headers = content.match(/^##\s+(.+)$/gm) || [];
          const tags = headers.map(h => h.replace(/^##\s+/, "").replace(/[*_`]/g, "").trim()).filter(t => t.length < 20).slice(0, 4);
          results.push({ date, path: filePath, title, preview: preview || "(空)", tags, charCount: content.length });
        } catch { /* skip */ }
      }
    }
  }

  scanDir(memoryDir, "");
  results.sort((a, b) => b.date.localeCompare(a.date));
  return c.json(results);
});

app.get("/api/recent", (c) => {
  const { workspace } = getAgentFromQuery(c);
  const files = collectMdFiles(workspace);
  const withStats = files.map((relPath) => {
    const full = path.join(workspace, relPath);
    try {
      const stat = fs.statSync(full);
      return { path: relPath, mtime: stat.mtime.getTime(), size: stat.size };
    } catch {
      return null;
    }
  }).filter(Boolean) as { path: string; mtime: number; size: number }[];
  withStats.sort((a, b) => b.mtime - a.mtime);
  const limit = Math.min(Number(c.req.query("limit")) || 10, 50);
  return c.json(withStats.slice(0, limit));
});

app.get("/api/stats/monthly", (c) => {
  const { workspace } = getAgentFromQuery(c);
  const memoryDir = path.join(workspace, "memory");
  const counts: Record<string, number> = {};
  let entries: fs.Dirent[];
  try {
    entries = fs.readdirSync(memoryDir, { withFileTypes: true });
  } catch {
    return c.json([]);
  }
  for (const entry of entries) {
    if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
    const match = entry.name.match(/^(\d{4}-\d{2})/);
    if (match) {
      counts[match[1]] = (counts[match[1]] || 0) + 1;
    } else {
      try {
        const stat = fs.statSync(path.join(memoryDir, entry.name));
        const month = stat.mtime.toISOString().slice(0, 7);
        counts[month] = (counts[month] || 0) + 1;
      } catch { /* skip */ }
    }
  }
  const result = Object.entries(counts)
    .map(([month, count]) => ({ month, count }))
    .sort((a, b) => a.month.localeCompare(b.month));
  return c.json(result);
});

app.get("/api/stats/daily", (c) => {
  const { workspace } = getAgentFromQuery(c);
  const memoryDir = path.join(workspace, "memory");
  const results: { date: string; count: number; size: number }[] = [];
  let entries: fs.Dirent[];
  try {
    entries = fs.readdirSync(memoryDir, { withFileTypes: true });
  } catch {
    return c.json([]);
  }
  const dateMap = new Map<string, { count: number; size: number }>();
  for (const entry of entries) {
    if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
    const match = entry.name.match(/^(\d{4}-\d{2}-\d{2})/);
    if (!match) continue;
    const date = match[1];
    try {
      const stat = fs.statSync(path.join(memoryDir, entry.name));
      const existing = dateMap.get(date);
      if (existing) {
        existing.count++;
        existing.size += stat.size;
      } else {
        dateMap.set(date, { count: 1, size: stat.size });
      }
    } catch { /* skip */ }
  }
  for (const [date, val] of dateMap) {
    results.push({ date, count: val.count, size: val.size });
  }
  results.sort((a, b) => a.date.localeCompare(b.date));
  return c.json(results);
});

app.get("/api/info", (c) => {
  const { workspace } = getAgentFromQuery(c);
  let name = "Unknown Bot";
  let description = "";
  for (const fname of ["IDENTITY.md", "SOUL.md"]) {
    const fpath = path.join(workspace, fname);
    if (fs.existsSync(fpath)) {
      const content = fs.readFileSync(fpath, "utf-8");
      const heading = content.match(/^#\s+(.+)/m);
      if (heading) name = heading[1].trim();
      const lines = content.split("\n").filter((l) => l.trim() && !l.startsWith("#"));
      if (lines.length > 0) description = lines[0].trim().substring(0, 200);
      break;
    }
  }
  return c.json({ name, version: "1.0.0", description });
});

app.get("/api/system", (c) => {
  const { workspace } = getAgentFromQuery(c);
  const uptime = os.uptime();
  const memTotal = os.totalmem();
  const memFree = os.freemem();
  const load = os.loadavg();
  const platform = `${os.platform()} ${os.release()}`;
  const hostname = os.hostname();

  const today = new Date().toISOString().split("T")[0];
  const todayPath = path.join(workspace, "memory", `${today}.md`);
  let todayMemory = null;
  if (fs.existsSync(todayPath)) {
    const content = fs.readFileSync(todayPath, "utf-8");
    todayMemory = {
      filename: `memory/${today}.md`,
      snippet: content.split("\n").slice(0, 10).join("\n"),
      length: content.length,
    };
  }

  const totalFiles = collectMdFiles(workspace).length;

  return c.json({
    uptime, memTotal, memFree, memUsed: memTotal - memFree,
    load, platform, hostname, todayMemory, totalFiles,
  });
});

app.get("/api/agent/status", async (c) => {
  // 1. Config
  const home = os.homedir();
  const configPath = path.join(home, ".openclaw", "openclaw.json");
  let safeConfig: any = {};
  try {
    if (fs.existsSync(configPath)) {
      const raw = JSON.parse(fs.readFileSync(configPath, "utf-8"));
      // Whitelist specific fields
      safeConfig = {
        version: raw.version,
        update: raw.update,
        models: { mode: raw.models?.mode },
        agents: { defaults: raw.agents?.defaults },
        gateway: {
          port: raw.gateway?.port,
          mode: raw.gateway?.mode,
        },
      };
    }
  } catch (e) {
    console.error("Failed to read config", e);
    safeConfig = { error: "Could not read config" };
  }

  // 2. Gateway Status
  let gatewayStatus = null;
  try {
    const { stdout } = await exec("openclaw gateway status --json");
    gatewayStatus = JSON.parse(stdout);
  } catch (e) {
    // console.error("Failed to get gateway status", e);
    // fallback or null
  }

  // 3. Heartbeat
  let heartbeat = null;
  try {
    const hbPath = path.join(DEFAULT_WORKSPACE, "memory", "heartbeat-state.json");
    if (fs.existsSync(hbPath)) {
      heartbeat = JSON.parse(fs.readFileSync(hbPath, "utf-8"));
    }
  } catch (e) {
    console.error("Failed to read heartbeat", e);
  }

  return c.json({
    config: safeConfig,
    gateway: gatewayStatus,
    heartbeat
  });
});

// ---------------------------------------------------------------------------
// Gateway Chat Proxy
// ---------------------------------------------------------------------------
app.post("/api/gateway/chat", async (c) => {
  const { gatewayUrl, token, messages } = await c.req.json();
  if (!gatewayUrl || !token || !messages) {
    return c.json({ error: "Missing gatewayUrl, token, or messages" }, 400);
  }
  try {
    const url = `${gatewayUrl.replace(/\/+$/, "")}/v1/chat/completions`;
    const controller = new AbortController();
    const timeout = setTimeout(() => controller.abort(), 30000);

    const resp = await fetch(url, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        Authorization: `Bearer ${token}`,
      },
      body: JSON.stringify({ model: "default", messages }),
      signal: controller.signal,
    });
    clearTimeout(timeout);

    if (!resp.ok) {
      const text = await resp.text();
      return c.json({ error: text }, resp.status as any);
    }
    const data = await resp.json();
    return c.json(data);
  } catch (err: any) {
    if (err.name === "AbortError") {
      return c.json({ error: "Gateway request timeout (30s)" }, 504);
    }
    return c.json({ error: err.message || "Gateway request failed" }, 502);
  }
});

// ---------------------------------------------------------------------------
// AI Summarize
// ---------------------------------------------------------------------------
const GATEWAY_CHAT_URL = process.env.GATEWAY_CHAT_URL || "http://silicon-01:3001/v1/chat/completions";
const SUMMARIZE_MODEL = process.env.SUMMARIZE_MODEL || "kimi-k2.5";

app.post("/api/summarize", async (c) => {
  const { workspace } = getAgentFromQuery(c);
  const { path: filePath, content: providedContent, save } = await c.req.json();
  const full = safePath(filePath, workspace);
  if (!full) return c.json({ error: "Invalid path" }, 400);

  let content = providedContent;
  if (!content) {
    if (!fs.existsSync(full)) return c.json({ error: "Not found" }, 404);
    content = fs.readFileSync(full, "utf-8");
  }

  // Strip existing frontmatter for summarization
  const bodyMatch = content.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n?([\s\S]*)$/);
  const body = bodyMatch ? bodyMatch[1] : content;

  if (body.trim().length < 50) {
    return c.json({ error: "Content too short to summarize" }, 400);
  }

  try {
    const resp = await fetch(GATEWAY_CHAT_URL, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        model: SUMMARIZE_MODEL,
        messages: [
          {
            role: "system",
            content: "You are a concise summarizer. Given a markdown document, produce a brief summary (1-3 sentences, max 200 chars). Reply with ONLY the summary text, no quotes, no prefix.",
          },
          { role: "user", content: body.slice(0, 8000) },
        ],
        max_tokens: 256,
        temperature: 0.3,
      }),
      signal: AbortSignal.timeout(30000),
    });

    if (!resp.ok) {
      const text = await resp.text();
      return c.json({ error: `Gateway error: ${text}` }, 502);
    }

    const data: any = await resp.json();
    const summary = (data.choices?.[0]?.message?.content || "").trim();
    if (!summary) return c.json({ error: "Empty summary returned" }, 502);

    // Optionally save to file frontmatter
    if (save) {
      const existingFm = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
      let newContent: string;
      if (existingFm) {
        // Update or add summary field in existing frontmatter
        const fmContent = existingFm[1];
        if (/^summary:/m.test(fmContent)) {
          const updatedFm = fmContent.replace(/^summary:.*$/m, `summary: "${summary.replace(/"/g, '\\"')}"`);
          newContent = content.replace(existingFm[0], `---\n${updatedFm}\n---`);
        } else {
          newContent = content.replace(existingFm[0], `---\n${fmContent}\nsummary: "${summary.replace(/"/g, '\\"')}"\n---`);
        }
      } else {
        newContent = `---\nsummary: "${summary.replace(/"/g, '\\"')}"\n---\n${content}`;
      }
      fs.writeFileSync(full, newContent, "utf-8");
      const stat = fs.statSync(full);
      return c.json({ summary, saved: true, mtime: stat.mtime });
    }

    return c.json({ summary, saved: false });
  } catch (err: any) {
    if (err.name === "AbortError" || err.name === "TimeoutError") {
      return c.json({ error: "Gateway timeout (30s)" }, 504);
    }
    return c.json({ error: err.message || "Summarize failed" }, 502);
  }
});

// ---------------------------------------------------------------------------
// WebSocket — live file change notifications
// ---------------------------------------------------------------------------
const wsClients = new Set<WSContext>();

app.get("/ws", upgradeWebSocket(() => ({
  onOpen(_event, ws) {
    wsClients.add(ws);
  },
  onClose(_event, ws) {
    wsClients.delete(ws);
  },
})));

function broadcast(data: object) {
  const msg = JSON.stringify(data);
  for (const ws of wsClients) {
    try { ws.send(msg); } catch { /* ignore */ }
  }
}

const watcher = watch(path.join(DEFAULT_WORKSPACE, "**/*.md"), {
  ignoreInitial: true,
  ignored: /(^|[/\\])\.(git|node_modules)/,
  awaitWriteFinish: { stabilityThreshold: 300 },
});

watcher.on("all", (event, filePath) => {
  const rel = path.relative(DEFAULT_WORKSPACE, filePath);
  broadcast({ type: "file-change", event, path: rel });
});

// ---------------------------------------------------------------------------
// Workspace assets (images, SVGs, etc.)
// ---------------------------------------------------------------------------
app.get("/workspace-assets/*", async (c) => {
  const { workspace } = getAgentFromQuery(c);
  const assetPath = c.req.path.replace("/workspace-assets/", "");
  const fullPath = path.join(workspace, "assets", assetPath);
  if (!fullPath.startsWith(path.join(workspace, "assets"))) {
    return c.json({ error: "Invalid path" }, 403);
  }
  if (!fs.existsSync(fullPath)) {
    return c.json({ error: "Not found" }, 404);
  }
  const ext = path.extname(fullPath).toLowerCase();
  const mimeTypes: Record<string, string> = {
    ".svg": "image/svg+xml",
    ".png": "image/png",
    ".jpg": "image/jpeg",
    ".jpeg": "image/jpeg",
    ".gif": "image/gif",
    ".webp": "image/webp",
  };
  const contentType = mimeTypes[ext] || "application/octet-stream";
  const content = fs.readFileSync(fullPath);
  c.header("Content-Type", contentType);
  c.header("Cache-Control", "public, max-age=3600");
  return c.body(content);
});

// ---------------------------------------------------------------------------
// Cron API — read OpenClaw cron jobs and run history
// ---------------------------------------------------------------------------
const CRON_JOBS_FILE = path.join(os.homedir(), ".openclaw", "cron", "jobs.json");
const CRON_RUNS_DIR = path.join(os.homedir(), ".openclaw", "cron", "runs");

interface CronJob {
  id: string;
  name?: string;
  enabled: boolean;
  schedule?: { kind: string; expr?: string; everyMs?: number; at?: string };
  payload?: { kind: string; text?: string; message?: string };
  sessionTarget?: string;
  agentId?: string;
  wakeMode?: string;
  state?: { nextRunAtMs?: number; lastRunAtMs?: number; lastStatus?: string };
  delivery?: { mode?: string };
}

function readCronJobs(): CronJob[] {
  try {
    const data = fs.readFileSync(CRON_JOBS_FILE, "utf-8");
    const json = JSON.parse(data);
    return json.jobs || [];
  } catch {
    return [];
  }
}

function writeCronJobs(jobs: CronJob[]): boolean {
  try {
    fs.copyFileSync(CRON_JOBS_FILE, CRON_JOBS_FILE + ".bak");
    fs.writeFileSync(CRON_JOBS_FILE, JSON.stringify({ version: 1, jobs }, null, 2));
    return true;
  } catch {
    return false;
  }
}

function readCronRuns(jobId: string): any[] {
  try {
    const runFile = path.join(CRON_RUNS_DIR, `${jobId}.jsonl`);
    const data = fs.readFileSync(runFile, "utf-8");
    return data.trim().split("\n").filter(Boolean).map(line => {
      try { return JSON.parse(line); } catch { return null; }
    }).filter(Boolean).reverse();
  } catch {
    return [];
  }
}

function formatCronJob(job: CronJob) {
  let scheduleDisplay = "-";
  if (job.schedule) {
    if (job.schedule.kind === "cron" && job.schedule.expr) scheduleDisplay = job.schedule.expr;
    else if (job.schedule.kind === "every" && job.schedule.everyMs) scheduleDisplay = `every ${Math.round(job.schedule.everyMs / 60000)}m`;
    else if (job.schedule.kind === "at" && job.schedule.at) scheduleDisplay = `at ${job.schedule.at}`;
  }
  return {
    id: job.id,
    name: job.name || "Unnamed",
    enabled: job.enabled !== false,
    schedule: scheduleDisplay,
    scheduleRaw: job.schedule,
    nextRun: job.state?.nextRunAtMs ? new Date(job.state.nextRunAtMs).toISOString() : null,
    lastRun: job.state?.lastRunAtMs ? new Date(job.state.lastRunAtMs).toISOString() : null,
    lastStatus: job.state?.lastStatus || null,
    sessionTarget: job.sessionTarget || job.agentId || "-",
    wakeMode: job.wakeMode || "next-heartbeat",
    payloadKind: job.payload?.kind || "-",
    deliveryMode: job.delivery?.mode || "-",
  };
}

app.get("/api/crons", (c) => {
  const jobs = readCronJobs();
  return c.json({ crons: jobs.map(formatCronJob) });
});

app.get("/api/crons/:id/runs", (c) => {
  const { id } = c.req.param();
  const runs = readCronRuns(id);
  return c.json({ runs: runs.slice(0, 30) });
});

app.post("/api/crons/:id/toggle", async (c) => {
  const { id } = c.req.param();
  const { enabled } = await c.req.json();
  try {
    const configPath = path.join(os.homedir(), ".openclaw", "openclaw.json");
    const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
    const port = config.gateway?.port || 18789;
    const token = config.gateway?.auth?.token || "";

    const method = enabled ? "cron.update" : "cron.update";
    const resp = await fetch(`http://127.0.0.1:${port}/rpc`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        ...(token ? { Authorization: `Bearer ${token}` } : {}),
      },
      body: JSON.stringify({
        jsonrpc: "2.0",
        id: 1,
        method: "cron.update",
        params: { jobId: id, patch: { enabled } },
      }),
      signal: AbortSignal.timeout(10000),
    });
    const result = await resp.json() as any;
    if (result.error) {
      return c.json({ success: false, error: result.error.message }, 500);
    }
    return c.json({ success: true, job: result.result });
  } catch (e: any) {
    // Fallback to direct file write
    const jobs = readCronJobs();
    const idx = jobs.findIndex(j => j.id === id);
    if (idx === -1) return c.json({ error: "Job not found" }, 404);
    jobs[idx].enabled = enabled;
    const ok = writeCronJobs(jobs);
    return c.json({ success: ok, job: formatCronJob(jobs[idx]) });
  }
});

app.post("/api/crons/:id/run", async (c) => {
  const { id } = c.req.param();
  try {
    const { execSync } = await import("child_process");
    const scriptPath = path.join(import.meta.dirname || __dirname, "cron-trigger.mjs");
    const result = execSync(`node ${scriptPath} ${id}`, {
      timeout: 12000,
      cwd: path.dirname(scriptPath),
      encoding: "utf-8",
    }).trim();
    const parsed = JSON.parse(result) as any;
    return c.json(parsed, parsed.success ? 200 : 500);
  } catch (e: any) {
    const stderr = e.stderr?.trim() || e.message;
    return c.json({ success: false, error: stderr }, 500);
  }
});

// System Crons API — heartbeat, compaction, pruning, session cleanup
// ---------------------------------------------------------------------------
app.get("/api/system-crons", (c) => {
  try {
    const configPath = path.join(os.homedir(), ".openclaw", "openclaw.json");
    const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
    const defaults = config.agents?.defaults || {};
    const agentList = config.agents?.list || [];

    const systemCrons: any[] = [];

    // Heartbeat
    const hbEvery = defaults.heartbeat?.every || "disabled";
    systemCrons.push({
      id: "sys-heartbeat",
      name: "💓 心跳检测",
      type: "heartbeat",
      schedule: hbEvery === "disabled" ? "禁用" : `每 ${hbEvery}`,
      enabled: hbEvery !== "disabled",
      description: "定期唤醒 agent 执行 HEARTBEAT.md 检查",
      agents: agentList.map((a: any) => ({
        id: a.id,
        name: a.identity?.name || a.name || a.id,
        heartbeat: a.heartbeat?.every || hbEvery,
        enabled: (a.heartbeat?.every || hbEvery) !== "disabled",
      })),
    });

    // Compaction
    const compMode = defaults.compaction?.mode || "off";
    const flushEnabled = defaults.compaction?.memoryFlush?.enabled || false;
    const flushThreshold = defaults.compaction?.memoryFlush?.softThresholdTokens;
    systemCrons.push({
      id: "sys-compaction",
      name: "🗜️ 上下文压缩",
      type: "compaction",
      schedule: "按需触发",
      enabled: compMode !== "off",
      description: `模式: ${compMode}${flushEnabled ? ` | Memory flush: ${flushThreshold ? flushThreshold + " tokens" : "启用"}` : ""}`,
    });

    // Context Pruning
    const pruneMode = defaults.contextPruning?.mode || "off";
    const pruneTTL = defaults.contextPruning?.ttl;
    systemCrons.push({
      id: "sys-context-pruning",
      name: "✂️ 上下文修剪",
      type: "context-pruning",
      schedule: pruneTTL ? `TTL ${pruneTTL}` : "按需",
      enabled: pruneMode !== "off",
      description: `模式: ${pruneMode}${pruneTTL ? ` | 缓存过期: ${pruneTTL}` : ""}`,
    });

    // Session cleanup (2026.2.9 feature)
    systemCrons.push({
      id: "sys-session-cleanup",
      name: "🗑️ Session 清理",
      type: "session-cleanup",
      schedule: "自动",
      enabled: true,
      description: "自动修剪过期 session，防止磁盘占满",
    });

    // QMD Memory refresh
    const qmd = config.memory?.qmd;
    if (qmd && config.memory?.backend === "qmd") {
      systemCrons.push({
        id: "sys-qmd-refresh",
        name: "🧠 QMD 记忆索引",
        type: "qmd",
        schedule: qmd.update?.interval ? `每 ${qmd.update.interval}` : "手动",
        enabled: true,
        description: `后台刷新: ${qmd.update?.onBoot ? "启动时 + " : ""}${qmd.update?.interval || "手动"}`,
      });
    }

    return c.json({ systemCrons });
  } catch (e: any) {
    return c.json({ error: e.message }, 500);
  }
});

// ---------------------------------------------------------------------------
// Static file serving
// ---------------------------------------------------------------------------
if (fs.existsSync(STATIC_DIR)) {
  app.use("/assets/*", serveStatic({
    root: STATIC_DIR,
    rewriteRequestPath: (p) => p,
  }));
  app.use("*", serveStatic({ root: STATIC_DIR }));
  // SPA fallback
  app.get("*", (c) => {
    const html = fs.readFileSync(path.join(STATIC_DIR, "index.html"), "utf-8");
    c.header("Cache-Control", "no-cache, no-store, must-revalidate");
    return c.html(html);
  });
}

// ---------------------------------------------------------------------------
// Start
// ---------------------------------------------------------------------------
if (process.env.NODE_ENV !== 'test') {
  const server = serve({ fetch: app.fetch, port: PORT, hostname: "0.0.0.0" }, (info) => {
    console.log(`📝 Memory Viewer running at http://localhost:${info.port}`);
    console.log(`📂 Default Workspace: ${DEFAULT_WORKSPACE}`);
  });
  injectWebSocket(server);
}