@saga-ai/cli 2.12.0 → 2.13.0

package/dist/cli.cjs

@@ -583,6 +583,7 @@ async function findStory(projectPath, query, options = {}) {
 // src/lib/sessions.ts
 var import_node_child_process = require("node:child_process");
 var import_node_fs4 = require("node:fs");
+var import_promises2 = require("node:fs/promises");
 var import_node_path4 = require("node:path");
 var OUTPUT_DIR = "/tmp/saga-sessions";
 function shellEscape(str) {
@@ -741,6 +742,70 @@ async function killSession(sessionName) {
     killed: result.status === 0
   };
 }
+function parseSessionName(name) {
+  if (!name || !name.startsWith("saga__")) {
+    return null;
+  }
+  const parts = name.split("__");
+  if (parts.length !== 4) {
+    return null;
+  }
+  const [, epicSlug, storySlug, pid] = parts;
+  if (!epicSlug || !storySlug || !pid) {
+    return null;
+  }
+  return {
+    epicSlug,
+    storySlug
+  };
+}
+async function buildSessionInfo(name, status) {
+  const parsed = parseSessionName(name);
+  if (!parsed) {
+    return null;
+  }
+  const outputFile = (0, import_node_path4.join)(OUTPUT_DIR, `${name}.out`);
+  const outputAvailable = (0, import_node_fs4.existsSync)(outputFile);
+  let startTime = /* @__PURE__ */ new Date();
+  let endTime;
+  let outputPreview;
+  if (outputAvailable) {
+    try {
+      const stats = await (0, import_promises2.stat)(outputFile);
+      startTime = stats.birthtime;
+      if (status === "completed") {
+        endTime = stats.mtime;
+      }
+    } catch {
+    }
+    try {
+      const content = await (0, import_promises2.readFile)(outputFile, "utf-8");
+      const lines = content.split("\n").filter((line) => line.length > 0);
+      if (lines.length > 0) {
+        const lastLines = lines.slice(-5);
+        let preview = lastLines.join("\n");
+        if (preview.length > 500) {
+          const truncated = preview.slice(0, 500);
+          const lastNewline = truncated.lastIndexOf("\n");
+          preview = lastNewline > 0 ? truncated.slice(0, lastNewline) : truncated;
+        }
+        outputPreview = preview;
+      }
+    } catch {
+    }
+  }
+  return {
+    name,
+    epicSlug: parsed.epicSlug,
+    storySlug: parsed.storySlug,
+    status,
+    outputFile,
+    outputAvailable,
+    startTime,
+    endTime,
+    outputPreview
+  };
+}
 
 // src/commands/implement.ts
 var DEFAULT_MAX_CYCLES = 10;
@@ -1276,21 +1341,21 @@ Searched in: ${(0, import_node_path5.join)(projectPath, ".saga", "worktrees")}`)
 }
 
 // src/server/index.ts
-var import_express2 = __toESM(require("express"), 1);
+var import_express3 = __toESM(require("express"), 1);
 var import_http = require("http");
 var import_path6 = require("path");
 
 // src/server/routes.ts
-var import_express = require("express");
+var import_express2 = require("express");
 
 // src/server/parser.ts
-var import_promises2 = require("fs/promises");
+var import_promises3 = require("fs/promises");
 var import_path2 = require("path");
 var import_gray_matter2 = __toESM(require("gray-matter"), 1);
 async function toStoryDetail(story, sagaRoot) {
   let tasks = [];
   try {
-    const content = await (0, import_promises2.readFile)(story.storyPath, "utf-8");
+    const content = await (0, import_promises3.readFile)(story.storyPath, "utf-8");
     const parsed = (0, import_gray_matter2.default)(content);
     tasks = parseTasks(parsed.data.tasks);
   } catch {
@@ -1336,10 +1401,10 @@ function validateTaskStatus(status) {
 }
 async function parseStory(storyPath, epicSlug) {
   const { join: join13 } = await import("path");
-  const { stat: stat2 } = await import("fs/promises");
+  const { stat: stat3 } = await import("fs/promises");
   let content;
   try {
-    content = await (0, import_promises2.readFile)(storyPath, "utf-8");
+    content = await (0, import_promises3.readFile)(storyPath, "utf-8");
   } catch {
     return null;
   }
@@ -1358,7 +1423,7 @@ async function parseStory(storyPath, epicSlug) {
   const journalPath = join13(storyDir, "journal.md");
   let hasJournal = false;
   try {
-    await stat2(journalPath);
+    await stat3(journalPath);
     hasJournal = true;
   } catch {
   }
@@ -1376,7 +1441,7 @@ async function parseStory(storyPath, epicSlug) {
 }
 async function parseJournal(journalPath) {
   try {
-    const content = await (0, import_promises2.readFile)(journalPath, "utf-8");
+    const content = await (0, import_promises3.readFile)(journalPath, "utf-8");
     const entries = [];
     const sections = content.split(/^##\s+/m).slice(1);
     for (const section of sections) {
@@ -1455,6 +1520,142 @@ async function scanSagaDirectory(sagaRoot) {
 
 // src/server/routes.ts
 var import_path3 = require("path");
+
+// src/server/session-routes.ts
+var import_express = require("express");
+
+// src/lib/session-polling.ts
+var POLLING_INTERVAL_MS = 3e3;
+var pollingInterval = null;
+var currentSessions = [];
+var isFirstPoll = true;
+function getCurrentSessions() {
+  return [...currentSessions];
+}
+function startSessionPolling(broadcast) {
+  stopSessionPolling();
+  pollSessions(broadcast);
+  pollingInterval = setInterval(() => {
+    pollSessions(broadcast);
+  }, POLLING_INTERVAL_MS);
+}
+function stopSessionPolling() {
+  if (pollingInterval) {
+    clearInterval(pollingInterval);
+    pollingInterval = null;
+  }
+  currentSessions = [];
+  isFirstPoll = true;
+}
+async function pollSessions(broadcast) {
+  try {
+    const sessions = await discoverSessions();
+    const hasChanges = detectChanges(sessions);
+    if (hasChanges) {
+      currentSessions = sessions;
+      isFirstPoll = false;
+      broadcast({
+        type: "sessions:updated",
+        sessions
+      });
+    }
+  } catch (error) {
+    console.error("Error polling sessions:", error);
+  }
+}
+async function discoverSessions() {
+  const rawSessions = await listSessions();
+  const detailedSessions = [];
+  for (const session of rawSessions) {
+    try {
+      const statusResult = await getSessionStatus(session.name);
+      const status = statusResult.running ? "running" : "completed";
+      const detailed = await buildSessionInfo(session.name, status);
+      if (detailed) {
+        detailedSessions.push(detailed);
+      }
+    } catch (error) {
+      console.error(`Error building session info for ${session.name}:`, error);
+    }
+  }
+  detailedSessions.sort((a, b) => b.startTime.getTime() - a.startTime.getTime());
+  return detailedSessions;
+}
+function detectChanges(newSessions) {
+  if (isFirstPoll) {
+    return true;
+  }
+  if (newSessions.length !== currentSessions.length) {
+    return true;
+  }
+  const newSessionMap = /* @__PURE__ */ new Map();
+  for (const session of newSessions) {
+    newSessionMap.set(session.name, session);
+  }
+  const currentSessionMap = /* @__PURE__ */ new Map();
+  for (const session of currentSessions) {
+    currentSessionMap.set(session.name, session);
+  }
+  for (const name of newSessionMap.keys()) {
+    if (!currentSessionMap.has(name)) {
+      return true;
+    }
+  }
+  for (const name of currentSessionMap.keys()) {
+    if (!newSessionMap.has(name)) {
+      return true;
+    }
+  }
+  for (const [name, newSession] of newSessionMap) {
+    const currentSession = currentSessionMap.get(name);
+    if (currentSession && currentSession.status !== newSession.status) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/server/session-routes.ts
+function createSessionApiRouter() {
+  const router = (0, import_express.Router)();
+  router.get("/sessions", (_req, res) => {
+    try {
+      let sessions = getCurrentSessions();
+      const { epicSlug, storySlug, status } = _req.query;
+      if (epicSlug && typeof epicSlug === "string") {
+        sessions = sessions.filter((s) => s.epicSlug === epicSlug);
+        if (storySlug && typeof storySlug === "string") {
+          sessions = sessions.filter((s) => s.storySlug === storySlug);
+        }
+      }
+      if (status && typeof status === "string" && (status === "running" || status === "completed")) {
+        sessions = sessions.filter((s) => s.status === status);
+      }
+      res.json(sessions);
+    } catch (error) {
+      console.error("Error fetching sessions:", error);
+      res.status(500).json({ error: "Failed to fetch sessions" });
+    }
+  });
+  router.get("/sessions/:sessionName", (req, res) => {
+    try {
+      const { sessionName } = req.params;
+      const sessions = getCurrentSessions();
+      const session = sessions.find((s) => s.name === sessionName);
+      if (!session) {
+        res.status(404).json({ error: "Session not found" });
+        return;
+      }
+      res.json(session);
+    } catch (error) {
+      console.error("Error fetching session:", error);
+      res.status(500).json({ error: "Failed to fetch session" });
+    }
+  });
+  return router;
+}
+
+// src/server/routes.ts
 async function getEpics(sagaRoot) {
   return scanSagaDirectory(sagaRoot);
 }
@@ -1467,7 +1668,7 @@ function toEpicSummary(epic) {
   };
 }
 function createApiRouter(sagaRoot) {
-  const router = (0, import_express.Router)();
+  const router = (0, import_express2.Router)();
   router.get("/epics", async (_req, res) => {
     try {
       const epics = await getEpics(sagaRoot);
@@ -1520,6 +1721,7 @@ function createApiRouter(sagaRoot) {
       res.status(500).json({ error: "Failed to fetch story" });
     }
   });
+  router.use(createSessionApiRouter());
   router.use((_req, res) => {
     res.status(404).json({ error: "API endpoint not found" });
   });
@@ -1612,12 +1814,14 @@ function createDebouncer(delayMs) {
 async function createSagaWatcher(sagaRoot) {
   const emitter = new import_events.EventEmitter();
   const debouncer = createDebouncer(100);
-  const sagaDir = (0, import_path4.join)(sagaRoot, ".saga");
-  const watcher = import_chokidar.default.watch(sagaDir, {
+  const epicsDir = (0, import_path4.join)(sagaRoot, ".saga", "epics");
+  const archiveDir = (0, import_path4.join)(sagaRoot, ".saga", "archive");
+  const watcher = import_chokidar.default.watch([epicsDir, archiveDir], {
     persistent: true,
     ignoreInitial: true,
     // Don't emit events for existing files
-    // Use polling for reliable cross-platform behavior (especially in temp directories)
+    // Use polling for reliable cross-platform behavior in tests
+    // This is fine since we only watch epics/archive (~20 files), not entire .saga/ (79K+ files)
     usePolling: true,
     interval: 100
   });
@@ -1724,6 +1928,9 @@ async function createWebSocketServer(httpServer, sagaRoot) {
       sendToClient(ws, message);
     }
   }
+  startSessionPolling((msg) => {
+    broadcast({ event: msg.type, data: msg.sessions });
+  });
   function broadcastToSubscribers(storyKey, message) {
     for (const [ws, state] of clients) {
       if (state.subscribedStories.has(storyKey)) {
@@ -1846,6 +2053,7 @@ async function createWebSocketServer(httpServer, sagaRoot) {
     },
     async close() {
       clearInterval(heartbeatInterval);
+      stopSessionPolling();
       for (const [ws] of clients) {
         ws.close();
       }
@@ -1869,8 +2077,8 @@ async function createWebSocketServer(httpServer, sagaRoot) {
 // src/server/index.ts
 var DEFAULT_PORT = 3847;
 function createApp(sagaRoot) {
-  const app = (0, import_express2.default)();
-  app.use(import_express2.default.json());
+  const app = (0, import_express3.default)();
+  app.use(import_express3.default.json());
   app.use((_req, res, next) => {
     res.header("Access-Control-Allow-Origin", "*");
     res.header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
@@ -1883,7 +2091,7 @@ function createApp(sagaRoot) {
   app.use("/api", createApiRouter(sagaRoot));
   const clientDistPath = (0, import_path6.join)(__dirname, "client");
   const indexHtmlPath = (0, import_path6.join)(clientDistPath, "index.html");
-  app.use(import_express2.default.static(clientDistPath));
+  app.use(import_express3.default.static(clientDistPath));
   app.get("/{*splat}", (_req, res) => {
     res.sendFile("index.html", { root: clientDistPath });
   });