@chenbihao/pomasa-dashboard 1.0.0

package/dist/cli.js

@@ -0,0 +1,1045 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// server/utils/paths.ts
+var paths_exports = {};
+__export(paths_exports, {
+  assertPathInsideBase: () => assertPathInsideBase,
+  assertSafeMasName: () => assertSafeMasName,
+  assertSafeProjectName: () => assertSafeProjectName,
+  assertValidWorkdir: () => assertValidWorkdir
+});
+import path from "path";
+function assertPathInsideBase(filePath, baseDir) {
+  const resolved = path.resolve(filePath);
+  const base = path.resolve(baseDir);
+  if (!(resolved === base || resolved.startsWith(base + path.sep))) {
+    throw new Error("Path traversal detected");
+  }
+  return resolved;
+}
+function assertSafeProjectName(name) {
+  if (!name || name.includes("..") || name.includes("/") || name.includes("\\")) {
+    throw new Error("Invalid project name");
+  }
+  return name;
+}
+function assertSafeMasName(name) {
+  if (!name || name.includes("..") || name.includes("/") || name.includes("\\")) {
+    throw new Error("MAS name contains invalid characters");
+  }
+  return name;
+}
+function assertValidWorkdir(workdir) {
+  if (!workdir) throw new Error("Missing workdir parameter");
+  if (!path.isAbsolute(workdir)) throw new Error("workdir must be an absolute path");
+  return workdir;
+}
+var init_paths = __esm({
+  "server/utils/paths.ts"() {
+  }
+});
+
+// server/setup.ts
+import express from "express";
+import cors from "cors";
+import path7 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { createServer } from "http";
+
+// server/websocket/terminal.ts
+import { WebSocketServer, WebSocket } from "ws";
+var ptyModule = null;
+var ptyAvailable = false;
+try {
+  ptyModule = await import("node-pty");
+  ptyAvailable = true;
+} catch {
+  console.warn("[terminal] node-pty not available, falling back to child_process.spawn");
+  console.warn("[terminal] Interactive programs (vim, htop, etc.) and resize will not work");
+}
+function spawnWithPty(ws, cwd, cols, rows) {
+  const isWin = process.platform === "win32";
+  const shell = isWin ? "powershell.exe" : "bash";
+  const shellArgs = isWin ? [] : ["--login"];
+  const ptyProc = ptyModule.spawn(shell, shellArgs, {
+    name: "xterm-256color",
+    cols: cols || 80,
+    rows: rows || 24,
+    cwd,
+    env: process.env
+  });
+  ptyProc.onData((data) => {
+    if (ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify({ type: "output", data }));
+    }
+  });
+  ptyProc.onExit(({ exitCode }) => {
+    if (ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify({ type: "exit", code: exitCode }));
+    }
+  });
+  return {
+    write: (data) => ptyProc.write(data),
+    resize: (cols2, rows2) => ptyProc.resize(cols2, rows2),
+    kill: () => ptyProc.kill(),
+    pid: ptyProc.pid
+  };
+}
+function spawnWithChildProcess(ws, cwd) {
+  const { spawn } = __require("child_process");
+  const isWin = process.platform === "win32";
+  const shell = isWin ? "powershell.exe" : "bash";
+  const shellArgs = isWin ? [] : ["--login"];
+  const child = spawn(shell, shellArgs, {
+    cwd,
+    env: process.env,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  child.stdout?.on("data", (data) => {
+    if (ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify({ type: "output", data: data.toString() }));
+    }
+  });
+  child.stderr?.on("data", (data) => {
+    if (ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify({ type: "output", data: data.toString() }));
+    }
+  });
+  child.on("error", (err) => {
+    if (ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify({ type: "output", data: `\r
+[Error] ${err.message}\r
+` }));
+      ws.send(JSON.stringify({ type: "exit", code: 1 }));
+    }
+  });
+  child.on("exit", (code) => {
+    if (ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify({ type: "exit", code: code ?? 0 }));
+    }
+  });
+  return {
+    write: (data) => child.stdin?.write(data),
+    resize: (_cols, _rows) => {
+    },
+    kill: () => child.kill(),
+    pid: child.pid ?? -1
+  };
+}
+function spawnShell(ws, cwd, cols, rows) {
+  if (ptyAvailable && ptyModule) {
+    return spawnWithPty(ws, cwd, cols, rows);
+  }
+  return spawnWithChildProcess(ws, cwd);
+}
+function setupTerminalWebSocket(server) {
+  const wss = new WebSocketServer({ server, path: "/api/terminal" });
+  wss.on("connection", (ws) => {
+    let shellProcess = null;
+    ws.on("message", (data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        if (msg.type === "start") {
+          const cwd = msg.cwd || process.cwd();
+          const cols = msg.cols || 80;
+          const rows = msg.rows || 24;
+          shellProcess = spawnShell(ws, cwd, cols, rows);
+          ws.send(JSON.stringify({
+            type: "info",
+            pty: ptyAvailable,
+            pid: shellProcess.pid
+          }));
+        } else if (msg.type === "input" && shellProcess) {
+          shellProcess.write(msg.data);
+        } else if (msg.type === "resize" && shellProcess) {
+          shellProcess.resize(msg.cols, msg.rows);
+        } else if (msg.type === "kill" && shellProcess) {
+          shellProcess.kill();
+        }
+      } catch (err) {
+        console.error("WebSocket error:", err);
+      }
+    });
+    ws.on("close", () => {
+      if (shellProcess) {
+        shellProcess.kill();
+        shellProcess = null;
+      }
+    });
+  });
+  return wss;
+}
+
+// server/routes/projects.ts
+init_paths();
+import { Router as Router2 } from "express";
+import path4 from "path";
+import fs3 from "fs/promises";
+
+// server/services/projectScanner.ts
+import path2 from "path";
+import fs from "fs/promises";
+async function countExpectedAgents(projectPath) {
+  try {
+    const orchPath = path2.join(projectPath, "agents", "00.orchestrator.md");
+    const content = await fs.readFile(orchPath, "utf-8");
+    const match = content.match(/--stages\s+'([^']+)'/);
+    if (match) {
+      return match[1].split(",").filter((s) => s.trim()).length;
+    }
+  } catch {
+  }
+  return 0;
+}
+async function countAgentFiles(projectPath) {
+  try {
+    const agentsDir = path2.join(projectPath, "agents");
+    const entries = await fs.readdir(agentsDir);
+    return entries.filter((f) => f.endsWith(".md") && f !== "00.orchestrator.md").length;
+  } catch {
+  }
+  return 0;
+}
+async function detectPrepStages(projectPath) {
+  let s01done = false, s01ts = null;
+  try {
+    const stat = await fs.stat(path2.join(projectPath, "user_input_template.md"));
+    s01done = true;
+    s01ts = stat.mtime.toISOString();
+  } catch {
+  }
+  let blueprintState = "pending";
+  let blueprintTs = null;
+  let blueprintDetail;
+  let orchExists = false;
+  try {
+    const stat = await fs.stat(path2.join(projectPath, "agents", "00.orchestrator.md"));
+    orchExists = true;
+    blueprintTs = stat.mtime.toISOString();
+    const [actual, expected] = await Promise.all([
+      countAgentFiles(projectPath),
+      countExpectedAgents(projectPath)
+    ]);
+    if (expected > 0) {
+      blueprintDetail = `${actual}/${expected}`;
+      blueprintState = actual >= expected ? "done" : "running";
+    } else {
+      blueprintState = actual > 0 ? "running" : "pending";
+      if (actual > 0) blueprintDetail = `${actual}`;
+    }
+  } catch {
+  }
+  let s04done = false, s04ts = null;
+  try {
+    const stat = await fs.stat(path2.join(projectPath, "README.md"));
+    s04done = true;
+    s04ts = stat.mtime.toISOString();
+  } catch {
+  }
+  return [
+    { id: "0.1", labelKey: "pipeline.createTemplate", state: s01done ? "done" : "pending", ts: s01ts },
+    {
+      id: "0.2",
+      labelKey: blueprintState === "done" ? "pipeline.createBlueprintDone" : "pipeline.createBlueprint",
+      state: blueprintState === "done" ? "done" : orchExists ? "running" : "pending",
+      ts: blueprintTs,
+      detail: blueprintDetail
+    },
+    { id: "0.3", labelKey: "pipeline.structureCreated", state: s04done ? "done" : "pending", ts: s04ts }
+  ];
+}
+async function scanProject(name, projectPath, obsPath) {
+  let status = "unknown";
+  let orchStages = 0;
+  let orchCompleted = 0;
+  let lastUpdate = null;
+  let hasAlerts = false;
+  let instance = null;
+  let prepDetail;
+  let hasObservation = false;
+  const PREP_STEPS = 3;
+  let prepDone = 0;
+  try {
+    await fs.access(path2.join(projectPath, "user_input_template.md"));
+    prepDone++;
+  } catch {
+  }
+  let blueprintComplete = false;
+  try {
+    await fs.access(path2.join(projectPath, "agents", "00.orchestrator.md"));
+    const [actual, expected] = await Promise.all([
+      countAgentFiles(projectPath),
+      countExpectedAgents(projectPath)
+    ]);
+    if (expected > 0) {
+      prepDetail = `${actual}/${expected}`;
+      blueprintComplete = actual >= expected;
+    } else {
+      blueprintComplete = actual > 0;
+      if (actual > 0) prepDetail = `${actual}`;
+    }
+  } catch {
+  }
+  if (blueprintComplete) prepDone++;
+  try {
+    await fs.access(path2.join(projectPath, "README.md"));
+    prepDone++;
+  } catch {
+  }
+  const prepAllDone = prepDone >= PREP_STEPS;
+  try {
+    await fs.access(obsPath);
+    hasObservation = true;
+    const obsEntries = await fs.readdir(obsPath, { withFileTypes: true });
+    const instanceDir = obsEntries.find((e) => e.isDirectory() && !e.name.startsWith("."));
+    if (instanceDir) {
+      instance = instanceDir.name;
+      const instancePath = path2.join(obsPath, instanceDir.name);
+      try {
+        const manifestContent = await fs.readFile(path2.join(instancePath, "run_manifest.json"), "utf-8");
+        const manifest = JSON.parse(manifestContent);
+        orchStages = manifest.stages.length;
+        const assignedDir = path2.join(instancePath, "00.orchestrator", "assigned");
+        try {
+          const assignedFiles = await fs.readdir(assignedDir);
+          for (const stage of manifest.stages) {
+            const statusFile = `${stage.id.replace(/^\d+\./, "")}.json`;
+            const matchFile = assignedFiles.find((f) => f === statusFile || f === `${stage.id}.json`);
+            if (matchFile) {
+              try {
+                const sc = await fs.readFile(path2.join(assignedDir, matchFile), "utf-8");
+                const sd = JSON.parse(sc);
+                if (sd.state === "done" || sd.state === "completed") orchCompleted++;
+                if (sd.state === "failed") status = "failed";
+                if (sd.ts > (lastUpdate ?? "")) lastUpdate = sd.ts;
+              } catch {
+              }
+            }
+          }
+        } catch {
+        }
+        try {
+          const runLog = path2.join(instancePath, "00.orchestrator", "run.jsonl");
+          const content = await fs.readFile(runLog, "utf-8");
+          for (const line of content.split("\n")) {
+            if (!line.trim()) continue;
+            try {
+              const entry = JSON.parse(line);
+              if (entry.level === "WARN" || entry.level === "ERROR") {
+                hasAlerts = true;
+                break;
+              }
+            } catch {
+            }
+          }
+        } catch {
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  let manifestExists = false;
+  try {
+    const obsEntries = await fs.readdir(obsPath, { withFileTypes: true });
+    const instanceDir = obsEntries.find((e) => e.isDirectory() && !e.name.startsWith("."));
+    if (instanceDir) {
+      await fs.access(path2.join(obsPath, instanceDir.name, "run_manifest.json"));
+      manifestExists = true;
+    }
+  } catch {
+  }
+  const totalStages = manifestExists ? 1 + orchStages : 1;
+  const completedStages = manifestExists ? 1 + orchCompleted : 0;
+  const progress = totalStages > 0 ? completedStages / totalStages : 0;
+  if (status === "failed") {
+  } else if (manifestExists && completedStages === totalStages && totalStages > 1) {
+    status = "completed";
+  } else if (manifestExists && orchCompleted > 0) {
+    status = "running";
+  } else if (manifestExists) {
+    status = "running";
+  } else if (prepAllDone) {
+    status = "ready";
+  } else if (prepDone > 0) {
+    status = "preparing";
+  } else {
+    status = "pending";
+  }
+  return {
+    name,
+    path: projectPath,
+    hasObservation,
+    status,
+    progress,
+    stages: totalStages,
+    stagesCompleted: completedStages,
+    lastUpdate,
+    hasAlerts,
+    instance,
+    prepDetail
+  };
+}
+async function findInstanceDir(workdir, projectName) {
+  const { assertValidWorkdir: assertValidWorkdir2, assertSafeProjectName: assertSafeProjectName2 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
+  const validWorkdir = assertValidWorkdir2(workdir);
+  const safeName = assertSafeProjectName2(projectName);
+  const projectPath = path2.join(validWorkdir, safeName);
+  const obsPath = path2.join(projectPath, "_observation");
+  const obsEntries = await fs.readdir(obsPath, { withFileTypes: true });
+  const instanceDir = obsEntries.find((e) => e.isDirectory() && !e.name.startsWith("."));
+  if (!instanceDir) return null;
+  return {
+    projectPath,
+    obsPath,
+    instancePath: path2.join(obsPath, instanceDir.name),
+    instanceName: instanceDir.name
+  };
+}
+
+// server/routes/filesystem.ts
+init_paths();
+import { Router } from "express";
+import path3 from "path";
+import fs2 from "fs/promises";
+var router = Router();
+async function buildFileTree(dirPath, maxDepth = 3, currentDepth = 0) {
+  if (currentDepth >= maxDepth) return [];
+  const entries = await fs2.readdir(dirPath, { withFileTypes: true });
+  const nodes = [];
+  const sortedEntries = entries.sort((a, b) => {
+    if (a.isDirectory() && !b.isDirectory()) return -1;
+    if (!a.isDirectory() && b.isDirectory()) return 1;
+    return a.name.localeCompare(b.name);
+  });
+  for (const entry of sortedEntries) {
+    if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+    const fullPath = path3.join(dirPath, entry.name);
+    const node = {
+      name: entry.name,
+      path: fullPath,
+      type: entry.isDirectory() ? "directory" : "file"
+    };
+    if (entry.isDirectory()) {
+      node.children = await buildFileTree(fullPath, maxDepth, currentDepth + 1);
+    }
+    nodes.push(node);
+  }
+  return nodes;
+}
+router.get("/tree", async (req, res) => {
+  const dirPath = req.query.path;
+  const depth = Math.min(Math.max(parseInt(req.query.depth) || 3, 1), 10);
+  if (!dirPath) {
+    return res.status(400).json({ error: "Missing path parameter" });
+  }
+  try {
+    const resolved = assertPathInsideBase(dirPath, dirPath);
+    const stat = await fs2.stat(resolved);
+    if (!stat.isDirectory()) {
+      return res.status(400).json({ error: "Path is not a directory" });
+    }
+    const tree = await buildFileTree(resolved, depth);
+    res.json({ tree });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to read directory";
+    res.status(400).json({ error: message });
+  }
+});
+router.get("/file", async (req, res) => {
+  const filePath = req.query.path;
+  if (!filePath) {
+    return res.status(400).json({ error: "Missing path parameter" });
+  }
+  try {
+    const resolved = assertPathInsideBase(filePath, filePath);
+    const content = await fs2.readFile(resolved, "utf-8");
+    res.json({ content });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to read file";
+    res.status(400).json({ error: message });
+  }
+});
+router.get("/changes", async (req, res) => {
+  const dirPath = req.query.path;
+  if (!dirPath) {
+    return res.status(400).json({ error: "Missing path parameter" });
+  }
+  try {
+    const resolved = assertPathInsideBase(dirPath, dirPath);
+    const entries = await fs2.readdir(resolved, { withFileTypes: true });
+    const fingerprints = {};
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+      try {
+        const stat = await fs2.stat(path3.join(resolved, entry.name));
+        fingerprints[entry.name] = stat.mtimeMs;
+      } catch {
+      }
+    }
+    res.json({ fingerprints });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to check changes";
+    res.status(400).json({ error: message });
+  }
+});
+router.get("/stat", async (req, res) => {
+  const filePath = req.query.path;
+  if (!filePath) {
+    return res.status(400).json({ error: "Missing path parameter" });
+  }
+  try {
+    const resolved = assertPathInsideBase(filePath, filePath);
+    const stat = await fs2.stat(resolved);
+    res.json({ mtimeMs: stat.mtimeMs, size: stat.size });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to stat file";
+    res.status(400).json({ error: message });
+  }
+});
+router.get("/dirs", async (req, res) => {
+  const dirPath = req.query.path;
+  if (!dirPath) {
+    return res.status(400).json({ error: "Missing path parameter" });
+  }
+  try {
+    const resolved = assertPathInsideBase(dirPath, dirPath);
+    const entries = await fs2.readdir(resolved, { withFileTypes: true });
+    const dirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => ({
+      name: e.name,
+      path: path3.join(resolved, e.name)
+    })).sort((a, b) => a.name.localeCompare(b.name));
+    res.json({ dirs });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to list directories";
+    res.status(400).json({ error: message });
+  }
+});
+var filesystem_default = router;
+
+// server/routes/projects.ts
+var router2 = Router2();
+router2.get("/", async (req, res) => {
+  const workdir = req.query.workdir;
+  try {
+    const validWorkdir = assertValidWorkdir(workdir);
+    const entries = await fs3.readdir(validWorkdir, { withFileTypes: true });
+    const projects = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+      const projectPath = path4.join(validWorkdir, entry.name);
+      const obsPath = path4.join(projectPath, "_observation");
+      const project = await scanProject(entry.name, projectPath, obsPath);
+      projects.push(project);
+    }
+    res.json({ projects });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to scan work directory";
+    res.status(400).json({ error: message });
+  }
+});
+router2.get("/:name/manifest", async (req, res) => {
+  const workdir = req.query.workdir;
+  try {
+    const validWorkdir = assertValidWorkdir(workdir);
+    const safeName = assertSafeProjectName(req.params.name);
+    const projectPath = path4.join(validWorkdir, safeName);
+    const prepStages = await detectPrepStages(projectPath);
+    try {
+      const info = await findInstanceDir(workdir, req.params.name);
+      if (!info) {
+        return res.json({ instance: null, created: null, stages: [], prepStages });
+      }
+      try {
+        const manifestPath = path4.join(info.instancePath, "run_manifest.json");
+        const content = await fs3.readFile(manifestPath, "utf-8");
+        const manifest = JSON.parse(content);
+        manifest.prepStages = prepStages;
+        res.json(manifest);
+      } catch {
+        res.json({ instance: info.instanceName, created: null, stages: [], prepStages });
+      }
+    } catch {
+      res.json({ instance: null, created: null, stages: [], prepStages });
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to read manifest";
+    res.status(400).json({ error: message });
+  }
+});
+router2.get("/:name/status", async (req, res) => {
+  const workdir = req.query.workdir;
+  try {
+    assertSafeProjectName(req.params.name);
+    const info = await findInstanceDir(workdir, req.params.name);
+    if (!info) return res.status(404).json({ error: "No instance found" });
+    const agents = {};
+    const assignedDir = path4.join(info.instancePath, "00.orchestrator", "assigned");
+    try {
+      const assignedFiles = await fs3.readdir(assignedDir);
+      for (const file of assignedFiles) {
+        if (!file.endsWith(".json")) continue;
+        const key = file.replace(".json", "");
+        const content = await fs3.readFile(path4.join(assignedDir, file), "utf-8");
+        if (!agents[key]) agents[key] = { assigned: null, self: null };
+        agents[key].assigned = JSON.parse(content);
+      }
+    } catch {
+    }
+    const stageDirs = await fs3.readdir(info.instancePath, { withFileTypes: true });
+    for (const dir of stageDirs) {
+      if (!dir.isDirectory() || dir.name.startsWith(".") || dir.name === "00.orchestrator" || dir.name === "_fallback") continue;
+      const statusFile = path4.join(info.instancePath, dir.name, "status.json");
+      try {
+        const content = await fs3.readFile(statusFile, "utf-8");
+        if (!agents[dir.name]) agents[dir.name] = { assigned: null, self: null };
+        agents[dir.name].self = JSON.parse(content);
+      } catch {
+      }
+    }
+    res.json({ agents });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to read status";
+    res.status(400).json({ error: message });
+  }
+});
+router2.get("/:name/events", async (req, res) => {
+  const workdir = req.query.workdir;
+  try {
+    assertSafeProjectName(req.params.name);
+    const info = await findInstanceDir(workdir, req.params.name);
+    if (!info) return res.status(404).json({ error: "No instance found" });
+    const events = [];
+    const runLog = path4.join(info.instancePath, "00.orchestrator", "run.jsonl");
+    try {
+      const content = await fs3.readFile(runLog, "utf-8");
+      for (const line of content.split("\n")) {
+        if (line.trim()) {
+          try {
+            events.push(JSON.parse(line));
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+    const stageDirs = await fs3.readdir(info.instancePath, { withFileTypes: true });
+    for (const dir of stageDirs) {
+      if (!dir.isDirectory() || dir.name.startsWith(".") || dir.name === "00.orchestrator") continue;
+      const logFile = path4.join(info.instancePath, dir.name, "_log.jsonl");
+      try {
+        const content = await fs3.readFile(logFile, "utf-8");
+        for (const line of content.split("\n")) {
+          if (line.trim()) {
+            try {
+              events.push(JSON.parse(line));
+            } catch {
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    events.sort((a, b) => {
+      const tsA = a.ts || "";
+      const tsB = b.ts || "";
+      return tsA.localeCompare(tsB);
+    });
+    res.json({ events });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to read events";
+    res.status(400).json({ error: message });
+  }
+});
+router2.get("/:name/logs/:agentKey", async (req, res) => {
+  const workdir = req.query.workdir;
+  const agentKey = req.params.agentKey;
+  try {
+    assertSafeProjectName(req.params.name);
+    const info = await findInstanceDir(workdir, req.params.name);
+    if (!info) return res.status(404).json({ error: "No instance found" });
+    const logFile = path4.join(info.instancePath, agentKey, "_log.jsonl");
+    try {
+      const content = await fs3.readFile(logFile, "utf-8");
+      const lines = content.split("\n").filter((l) => l.trim());
+      const logs = lines.map((l) => {
+        try {
+          return JSON.parse(l);
+        } catch {
+          return null;
+        }
+      }).filter(Boolean);
+      res.json({ logs });
+    } catch {
+      res.json({ logs: [] });
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to read agent log";
+    res.status(400).json({ error: message });
+  }
+});
+router2.get("/:name/agents", async (req, res) => {
+  const workdir = req.query.workdir;
+  try {
+    const validWorkdir = assertValidWorkdir(workdir);
+    const safeName = assertSafeProjectName(req.params.name);
+    const agentsDir = path4.join(validWorkdir, safeName, "agents");
+    const entries = await fs3.readdir(agentsDir);
+    const mdFiles = entries.filter((f) => f.endsWith(".md")).sort();
+    const agents = await Promise.all(
+      mdFiles.map(async (fileName) => {
+        const filePath = path4.join(agentsDir, fileName);
+        const content = await fs3.readFile(filePath, "utf-8");
+        const name = fileName.replace(".md", "");
+        return { name, fileName, path: filePath, content };
+      })
+    );
+    res.json({ agents });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to read agent blueprints";
+    res.status(400).json({ error: message });
+  }
+});
+router2.get("/:name/files/:section", async (req, res) => {
+  const workdir = req.query.workdir;
+  const section = req.params.section;
+  const allowedSections = ["references", "workspace", "wip", "agents", "scripts", "library", "wiki", "_output"];
+  if (!allowedSections.includes(section)) {
+    return res.status(400).json({ error: `Invalid section. Allowed: ${allowedSections.join(", ")}` });
+  }
+  try {
+    const validWorkdir = assertValidWorkdir(workdir);
+    const safeName = assertSafeProjectName(req.params.name);
+    const sectionPath = path4.join(validWorkdir, safeName, section);
+    try {
+      const stat = await fs3.stat(sectionPath);
+      if (!stat.isDirectory()) {
+        return res.json({ tree: [] });
+      }
+    } catch {
+      return res.json({ tree: [] });
+    }
+    const tree = await buildFileTree(sectionPath, 5);
+    res.json({ tree });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to read project files";
+    res.status(400).json({ error: message });
+  }
+});
+router2.get("/:name/config", async (req, res) => {
+  const workdir = req.query.workdir;
+  try {
+    const validWorkdir = assertValidWorkdir(workdir);
+    const safeName = assertSafeProjectName(req.params.name);
+    const projectPath = path4.join(validWorkdir, safeName);
+    const readFile = async (fileName) => {
+      try {
+        return await fs3.readFile(path4.join(projectPath, fileName), "utf-8");
+      } catch {
+        return null;
+      }
+    };
+    const [config, readme, template] = await Promise.all([
+      readFile("config.yml"),
+      readFile("README.md"),
+      readFile("user_input_template.md")
+    ]);
+    res.json({ config, readme, template });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to read project config";
+    res.status(400).json({ error: message });
+  }
+});
+var projects_default = router2;
+
+// server/routes/framework.ts
+import { Router as Router3 } from "express";
+import path5 from "path";
+import fs4 from "fs/promises";
+var router3 = Router3();
+async function findSkillsDir() {
+  let dir = process.cwd();
+  for (let i = 0; i < 5; i++) {
+    const candidate = path5.join(dir, "skills", "pomasa");
+    try {
+      await fs4.access(candidate);
+      return candidate;
+    } catch {
+    }
+    const parent = path5.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+router3.get("/patterns", async (_req, res) => {
+  const skillsDir = await findSkillsDir();
+  if (!skillsDir) {
+    return res.json({ patterns: [] });
+  }
+  const skillsPath = path5.join(skillsDir, "pattern-catalog");
+  try {
+    const entries = await fs4.readdir(skillsPath, { withFileTypes: true });
+    const patterns = [];
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name === "README.md") continue;
+      const match = entry.name.match(/^(COR|STR|BHV|QUA)-(\d+)-(.+)\.md$/);
+      if (!match) continue;
+      const [, prefix, num, nameSlug] = match;
+      const filePath = path5.join(skillsPath, entry.name);
+      const content = await fs4.readFile(filePath, "utf-8");
+      let necessity = "Optional";
+      if (content.includes("**Necessity**: Required")) necessity = "Required";
+      else if (content.includes("**Necessity**: Recommended")) necessity = "Recommended";
+      const problemMatch = content.match(/## Problem\s*\n\n(.+?)(?:\n\n|\n##)/s);
+      const description = problemMatch ? problemMatch[1].replace(/\n/g, " ").trim().slice(0, 100) : "";
+      patterns.push({
+        id: `${prefix}-${num.padStart(2, "0")}`,
+        name: nameSlug.replace(/-/g, " "),
+        category: prefix,
+        necessity,
+        description
+      });
+    }
+    res.json({ patterns });
+  } catch (err) {
+    console.error("Failed to load patterns:", err);
+    res.json({ patterns: [] });
+  }
+});
+router3.get("/generator", async (_req, res) => {
+  const skillsDir = await findSkillsDir();
+  if (!skillsDir) {
+    return res.status(404).json({ error: "POMASA skills not found. Run this command from within a POMASA project directory." });
+  }
+  const generatorPath = path5.join(skillsDir, "SKILL.md");
+  try {
+    const content = await fs4.readFile(generatorPath, "utf-8");
+    res.json({ content });
+  } catch {
+    res.status(404).json({ error: "Generator not found" });
+  }
+});
+router3.get("/template", async (_req, res) => {
+  const skillsDir = await findSkillsDir();
+  if (!skillsDir) {
+    return res.status(404).json({ error: "POMASA skills not found. Run this command from within a POMASA project directory." });
+  }
+  const templatePath = path5.join(skillsDir, "user_input_template.md");
+  const templatePathZh = path5.join(skillsDir, "user_input_template_zh.md");
+  try {
+    let content;
+    try {
+      content = await fs4.readFile(templatePath, "utf-8");
+    } catch {
+      content = await fs4.readFile(templatePathZh, "utf-8");
+    }
+    res.json({ content });
+  } catch {
+    res.status(404).json({ error: "Template not found" });
+  }
+});
+var framework_default = router3;
+
+// server/routes/mas.ts
+init_paths();
+import { Router as Router4 } from "express";
+import path6 from "path";
+import fs5 from "fs/promises";
+import { fileURLToPath } from "url";
+var __dirname = path6.dirname(fileURLToPath(import.meta.url));
+var router4 = Router4();
+function sendSse(res, data) {
+  res.write(`data: ${JSON.stringify(data)}
+
+`);
+}
+router4.post("/create", async (req, res) => {
+  const { targetDir, masName, userInput, selectedPatterns, language } = req.body;
+  res.setHeader("Content-Type", "text/event-stream");
+  res.setHeader("Cache-Control", "no-cache");
+  res.setHeader("Connection", "keep-alive");
+  try {
+    if (!targetDir || !masName) {
+      sendSse(res, { type: "error", content: "Missing targetDir or masName" });
+      sendSse(res, { type: "done", code: 1 });
+      return res.end();
+    }
+    assertSafeMasName(masName);
+    assertPathInsideBase(targetDir, targetDir);
+    const masPath = path6.join(targetDir, masName);
+    try {
+      await fs5.access(masPath);
+      sendSse(res, { type: "error", content: "Directory already exists" });
+      sendSse(res, { type: "done", code: 1 });
+      return res.end();
+    } catch {
+    }
+    await fs5.mkdir(masPath, { recursive: true });
+    const templateFile = language === "zh" ? "user_input_template_zh.md" : "user_input_template.md";
+    const templatePath = path6.resolve(__dirname, "../../templates", templateFile);
+    let template = await fs5.readFile(templatePath, "utf-8");
+    const ui = userInput;
+    const isZhLang = language === "zh";
+    const formats = ui.deliverableFormats || "Markdown";
+    const deliverableBlock = isZhLang ? [
+      `- [x] Markdown\uFF08\u59CB\u7EC8\u751F\u6210\uFF09`,
+      `- [${formats.includes("pdf") ? "x" : " "}] PDF\uFF08\u63A8\u8350\uFF0C\u4FBF\u4E8E\u5206\u53D1\uFF09`,
+      `- [${formats.includes("docx") ? "x" : " "}] DOCX\uFF08\u63A8\u8350\uFF0C\u4FBF\u4E8E\u7F16\u8F91\uFF09`,
+      `- [${formats.includes("wiki") ? "x" : " "}] Wiki\uFF08\u6301\u4E45\u5316\u7684 Obsidian \u77E5\u8BC6\u56FE\u8C31\uFF0C\u7528\u4E8E\u8DE8\u6B21\u8FD0\u884C\u7684\u7814\u7A76\u79EF\u7D2F\uFF09`
+    ].join("\n") : [
+      `- [x] Markdown (always generated)`,
+      `- [${formats.includes("pdf") ? "x" : " "}] PDF (recommended, for distribution)`,
+      `- [${formats.includes("docx") ? "x" : " "}] DOCX (recommended, for editing)`,
+      `- [${formats.includes("wiki") ? "x" : " "}] Wiki (persistent Obsidian knowledge graph, for compounding research across runs)`
+    ].join("\n");
+    const ql = ui.qualityLevel || "standard";
+    const qualityBlock = isZhLang ? [
+      `- [${ql === "simple" ? "x" : " "}] \u7B80\u5355\uFF08Simple\uFF09\uFF1A\u4EC5\u91C7\u7528\u5FC5\u9700\u7684\u6A21\u5F0F\uFF0C\u4E0D\u8FDB\u884C\u989D\u5916\u7684\u8D28\u91CF\u68C0\u67E5`,
+      `- [${ql === "standard" ? "x" : " "}] \u6807\u51C6\uFF08Standard\uFF0C\u9ED8\u8BA4\uFF09\uFF1A\u91C7\u7528 QUA-01 \u5D4C\u5165\u5F0F\u8D28\u91CF\u6807\u51C6 + BHV-05 \u57FA\u4E8E\u4E8B\u5B9E\u7684\u7F51\u7EDC\u7814\u7A76`,
+      `- [${ql === "strict" ? "x" : " "}] \u4E25\u683C\uFF08Strict\uFF09\uFF1A\u91C7\u7528 QUA-01 + QUA-02 \u591A\u5C42\u8D28\u91CF\u4FDD\u8BC1 + BHV-05 \u57FA\u4E8E\u4E8B\u5B9E\u7684\u7F51\u7EDC\u7814\u7A76`
+    ].join("\n") : [
+      `- [${ql === "simple" ? "x" : " "}] Simple: Only adopt required patterns, no additional quality checks`,
+      `- [${ql === "standard" ? "x" : " "}] Standard (default): Adopt QUA-01 Embedded Quality Standards + BHV-05 Grounded Web Research`,
+      `- [${ql === "strict" ? "x" : " "}] Strict: Adopt QUA-01 + QUA-02 Multi-Layer Quality Assurance + BHV-05 Grounded Web Research`
+    ].join("\n");
+    const ol = ui.observabilityLevel || "normal";
+    const obsBlock = isZhLang ? [
+      `- [${ol === "none" ? "x" : " "}] none\uFF1A\u4E0D\u4EA7\u751F\u6267\u884C\u65E5\u5FD7\uFF08\u8282\u7701 token\uFF09\uFF1B\u7F16\u6392\u8005\u4ECD\u4EC5\u8BB0\u5F55\u9A8C\u6536\u5224\u5B9A`,
+      `- [${ol === "minimal" ? "x" : " "}] minimal\uFF1A\u53EA\u8BB0\u5F55\u9519\u8BEF\uFF08ERROR\uFF09`,
+      `- [${ol === "normal" ? "x" : " "}] normal\uFF08\u9ED8\u8BA4\uFF09\uFF1A\u8BB0\u5F55\u9519\u8BEF + \u8B66\u544A\uFF08\u542B agent \u7684\u964D\u7EA7\u3001\u7F29\u8303\u56F4\u3001\u56F0\u96BE\uFF09`,
+      `- [${ol === "detailed" ? "x" : " "}] detailed\uFF1A\u8BB0\u5F55\u5168\u90E8\uFF08\u542B\u5168\u94FE\u8DEF INFO \u91CC\u7A0B\u7891\uFF09`
+    ].join("\n") : [
+      `- [${ol === "none" ? "x" : " "}] none: No execution logs (saves tokens); the orchestrator still records acceptance verdicts only`,
+      `- [${ol === "minimal" ? "x" : " "}] minimal: Log errors only`,
+      `- [${ol === "normal" ? "x" : " "}] normal (default): Log errors + warnings (including agent degradations, scope reductions, and difficulties)`,
+      `- [${ol === "detailed" ? "x" : " "}] detailed: Log everything (including INFO milestones across the full chain)`
+    ].join("\n");
+    const refLines = (ui.existingReferences || "").split("\n").filter((l) => l.trim());
+    const refBlock = refLines.length > 0 ? refLines.map((l) => `- ${l.trim()}`).join("\n") : "- None";
+    const replacements = {
+      "{{BLUEPRINT_LANGUAGE}}": ui.blueprintLanguage || "Chinese",
+      "{{REPORT_LANGUAGE}}": ui.reportLanguage || "Chinese",
+      "{{PROJECT_IDENTIFIER}}": ui.projectIdentifier || masName,
+      "{{RESEARCH_TOPIC}}": ui.researchTopic || "",
+      "{{INITIAL_IDEAS}}": ui.initialIdeas || "",
+      "{{DATA_SOURCES}}": ui.dataSources || "",
+      "{{EXISTING_REFERENCES}}": refBlock,
+      "{{ANALYSIS_METHODS}}": ui.analysisMethods || "",
+      "{{REPORT_FORMAT}}": ui.reportFormat || "",
+      "{{REPORT_STRUCTURE}}": ui.reportStructure || "",
+      "{{DELIVERABLE_FORMATS}}": deliverableBlock,
+      "{{QUALITY_LEVEL}}": qualityBlock,
+      "{{OBSERVABILITY_LEVEL}}": obsBlock,
+      "{{PATTERN_OVERRIDES}}": ui.patternOverrides || "None",
+      "{{OTHER_REQUIREMENTS}}": ui.otherRequirements || "None",
+      "{{SELECTED_PATTERNS}}": selectedPatterns.join(", ")
+    };
+    for (const [placeholder, value] of Object.entries(replacements)) {
+      template = template.replaceAll(placeholder, value);
+    }
+    await fs5.writeFile(path6.join(masPath, "user_input_template.md"), template);
+    sendSse(res, { type: "output", content: "Created user_input_template.md\n" });
+    const dirs = ["agents", "references", "workspace", "_observation"];
+    for (const dir of dirs) {
+      await fs5.mkdir(path6.join(masPath, dir), { recursive: true });
+      sendSse(res, { type: "output", content: `Created directory: ${dir}/
+` });
+    }
+    sendSse(res, { type: "output", content: "\n--- Completed ---\n" });
+    sendSse(res, { type: "done", code: 0, masPath });
+    res.end();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error during creation";
+    sendSse(res, { type: "error", content: message });
+    sendSse(res, { type: "done", code: 1 });
+    res.end();
+  }
+});
+var mas_default = router4;
+
+// server/setup.ts
+var __dirname2 = path7.dirname(fileURLToPath2(import.meta.url));
+function createApp() {
+  const app = express();
+  const server = createServer(app);
+  app.use(cors());
+  app.use(express.json({ limit: "10mb" }));
+  app.use("/api/projects", projects_default);
+  app.use("/api/framework", framework_default);
+  app.use("/api/fs", filesystem_default);
+  app.use("/api/mas", mas_default);
+  setupTerminalWebSocket(server);
+  const distDir = path7.resolve(__dirname2, "../dist");
+  app.use(express.static(distDir));
+  app.use("/api", (_req, res) => {
+    res.status(404).json({ error: "Not found" });
+  });
+  app.get("/{*splat}", (_req, res) => {
+    res.sendFile(path7.join(distDir, "index.html"));
+  });
+  return { app, server };
+}
+function startServer(port2, maxRetries = 10) {
+  const { server } = createApp();
+  return new Promise((resolve, reject) => {
+    server.on("error", (err) => {
+      if (err.code === "EADDRINUSE" && maxRetries > 0) {
+        console.log(`Port ${port2} in use, trying ${port2 + 1}...`);
+        server.removeAllListeners("error");
+        startServer(port2 + 1, maxRetries - 1).then(resolve).catch(reject);
+      } else {
+        reject(err);
+      }
+    });
+    server.listen(port2, () => {
+      console.log(`POMASA Dashboard running at http://localhost:${port2}`);
+      console.log(`API at http://localhost:${port2}/api`);
+      console.log(`WebSocket terminal at ws://localhost:${port2}/api/terminal`);
+      resolve(server);
+    });
+  });
+}
+
+// server/cli.ts
+process.on("uncaughtException", (err) => {
+  console.error("[uncaughtException]", err);
+});
+process.on("unhandledRejection", (reason) => {
+  console.error("[unhandledRejection]", reason);
+});
+var port = 3001;
+var portArg = process.argv.indexOf("--port");
+if (portArg !== -1 && process.argv[portArg + 1]) {
+  port = parseInt(process.argv[portArg + 1], 10);
+} else if (process.env.PORT) {
+  port = parseInt(process.env.PORT, 10);
+}
+startServer(port).then(async () => {
+  const url = `http://localhost:${port}`;
+  try {
+    const open = (await import("open")).default;
+    await open(url);
+    console.log(`Opened ${url} in browser`);
+  } catch {
+    console.log(`Please open ${url} in your browser`);
+  }
+}).catch((err) => {
+  console.error("Failed to start server:", err);
+  process.exit(1);
+});