ralph-dashboard 2.3.8

package/dist/server/index.js

@@ -0,0 +1,1419 @@
+#!/usr/bin/env bun
+// @bun
+
+// server/server.ts
+import { join as join5, dirname } from "path";
+import { fileURLToPath } from "url";
+import { existsSync as existsSync7, readFileSync as readFileSync4 } from "fs";
+
+// server/services/log-parser.ts
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+import {
+  readFileSync as readFileSync2,
+  existsSync as existsSync3,
+  writeFileSync,
+  renameSync,
+  unlinkSync
+} from "fs";
+
+// server/services/checklist-service.ts
+import { readFileSync, existsSync as existsSync2 } from "fs";
+
+// server/services/file-finder.ts
+import { existsSync, readdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var RALPH_BASE_DIR = join(homedir(), ".claude", "ralph-wiggum-pro");
+var TRANSCRIPTS_DIR = join(RALPH_BASE_DIR, "transcripts");
+var OLD_TRANSCRIPTS_DIR = join(homedir(), ".claude", "ralph-wiggum-pro-logs", "transcripts");
+function getTranscriptsDir() {
+  return TRANSCRIPTS_DIR;
+}
+function findFileByLoopId(loopId, suffix) {
+  if (existsSync(TRANSCRIPTS_DIR)) {
+    const files = readdirSync(TRANSCRIPTS_DIR);
+    const match = files.find((f) => f.endsWith(`-${loopId}-${suffix}`) || f === `${loopId}-${suffix}`);
+    if (match) {
+      return join(TRANSCRIPTS_DIR, match);
+    }
+  }
+  if (existsSync(OLD_TRANSCRIPTS_DIR)) {
+    const files = readdirSync(OLD_TRANSCRIPTS_DIR);
+    const match = files.find((f) => f.endsWith(`-${loopId}-${suffix}`) || f === `${loopId}-${suffix}`);
+    if (match) {
+      return join(OLD_TRANSCRIPTS_DIR, match);
+    }
+  }
+  return null;
+}
+function fileExistsForLoopId(loopId, suffix) {
+  return findFileByLoopId(loopId, suffix) !== null;
+}
+
+// server/services/checklist-service.ts
+function validateLoopId(loopId) {
+  const safePattern = /^[a-zA-Z0-9._-]{1,256}$/;
+  if (!safePattern.test(loopId)) {
+    return false;
+  }
+  if (loopId.includes("..")) {
+    return false;
+  }
+  return true;
+}
+function getChecklistPath(loopId) {
+  if (!validateLoopId(loopId)) {
+    throw new Error(`Invalid loop_id format: ${loopId}`);
+  }
+  return findFileByLoopId(loopId, "checklist.json");
+}
+function getChecklist(loopId) {
+  try {
+    const path = getChecklistPath(loopId);
+    if (!path || !existsSync2(path)) {
+      return null;
+    }
+    const content = readFileSync(path, "utf-8");
+    const checklist = JSON.parse(content);
+    if (!checklist.loop_id || !checklist.completion_criteria) {
+      return null;
+    }
+    return checklist;
+  } catch {
+    return null;
+  }
+}
+function getChecklistProgress(checklist) {
+  const criteriaTotal = checklist.completion_criteria.length;
+  const criteriaCompleted = checklist.completion_criteria.filter((item) => item.status === "completed").length;
+  return {
+    criteria: `${criteriaCompleted}/${criteriaTotal} criteria`,
+    criteriaCompleted,
+    criteriaTotal
+  };
+}
+function getChecklistWithProgress(loopId) {
+  const checklist = getChecklist(loopId);
+  if (!checklist) {
+    return { checklist: null, progress: null };
+  }
+  const progress = getChecklistProgress(checklist);
+  return { checklist, progress };
+}
+
+// server/services/log-parser.ts
+var RALPH_BASE_DIR2 = process.env.RALPH_TEST_BASE_DIR || join2(homedir2(), ".claude", "ralph-wiggum-pro");
+var LOGS_DIR = join2(RALPH_BASE_DIR2, "logs");
+var LOG_FILE = join2(LOGS_DIR, "sessions.jsonl");
+var OLD_LOG_FILE = join2(homedir2(), ".claude", "ralph-wiggum-pro-logs", "sessions.jsonl");
+function extractCompletionPromiseFromTask(task) {
+  if (!task) {
+    return { task, completionPromise: null };
+  }
+  const match = task.match(/--completion-promise=["']?([^"'\s]+)["']?/);
+  if (!match) {
+    return { task, completionPromise: null };
+  }
+  const completionPromise = match[1];
+  const cleanedTask = task.replace(/\s*--completion-promise=["']?[^"'\s]+["']?\s*/g, " ").trim();
+  return { task: cleanedTask, completionPromise };
+}
+function getLogFilePath() {
+  return LOG_FILE;
+}
+function parseIterationFromContent(content) {
+  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!frontmatterMatch) {
+    return null;
+  }
+  const frontmatter = frontmatterMatch[1];
+  if (!frontmatter.includes("session_id:")) {
+    return null;
+  }
+  const iterationMatch = frontmatter.match(/^iteration:\s*(\d+)/m);
+  if (!iterationMatch) {
+    return null;
+  }
+  return parseInt(iterationMatch[1], 10);
+}
+function readIterationFromStateFile(stateFilePath, maxRetries = 2) {
+  for (let attempt = 0;attempt < maxRetries; attempt++) {
+    try {
+      if (!existsSync3(stateFilePath)) {
+        return null;
+      }
+      const content = readFileSync2(stateFilePath, "utf-8");
+      const iteration = parseIterationFromContent(content);
+      if (iteration !== null) {
+        return iteration;
+      }
+      if (attempt < maxRetries - 1) {
+        const start = Date.now();
+        while (Date.now() - start < 10) {}
+      }
+    } catch {
+      if (attempt < maxRetries - 1) {
+        continue;
+      }
+      return null;
+    }
+  }
+  return null;
+}
+function parseEntriesFromFile(filePath) {
+  if (!existsSync3(filePath)) {
+    return [];
+  }
+  const content = readFileSync2(filePath, "utf-8");
+  const lines = content.split(`
+`).filter((line) => line.trim());
+  const entries = [];
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      entries.push(entry);
+    } catch {
+      console.warn("Skipping malformed log entry:", line.slice(0, 50));
+    }
+  }
+  return entries;
+}
+function parseLogFile() {
+  const newEntries = parseEntriesFromFile(LOG_FILE);
+  const oldEntries = parseEntriesFromFile(OLD_LOG_FILE);
+  return [...oldEntries, ...newEntries];
+}
+function mergeSessions(entries) {
+  const loopMap = new Map;
+  for (const entry of entries) {
+    const loopId = entry.loop_id || entry.loop_id || entry.session_id;
+    const existing = loopMap.get(loopId) || {};
+    if (entry.status === "active") {
+      existing.start = entry;
+    } else if (entry.status === "completed") {
+      existing.completion = entry;
+    }
+    loopMap.set(loopId, existing);
+  }
+  const sessions = [];
+  for (const [loop_id, { start, completion }] of loopMap) {
+    if (!start && completion) {
+      sessions.push({
+        loop_id,
+        session_id: completion.session_id,
+        status: "orphaned",
+        outcome: completion.outcome,
+        project: "",
+        project_name: "(orphaned entry)",
+        state_file_path: undefined,
+        task: `Orphaned: ${completion.outcome}`,
+        started_at: completion.ended_at,
+        ended_at: completion.ended_at,
+        duration_seconds: completion.duration_seconds ?? 0,
+        iterations: completion.iterations ?? null,
+        max_iterations: 0,
+        completion_promise: null,
+        error_reason: completion.error_reason ?? null,
+        has_checklist: false,
+        checklist_progress: null
+      });
+      continue;
+    }
+    if (!start) {
+      continue;
+    }
+    const startTime = new Date(start.started_at);
+    const completionTime = completion?.ended_at ? new Date(completion.ended_at) : null;
+    const isActive = !completion || completionTime && startTime > completionTime;
+    const now = new Date;
+    const durationSeconds = isActive ? Math.floor((now.getTime() - startTime.getTime()) / 1000) : completion?.duration_seconds ?? 0;
+    let status;
+    if (isActive) {
+      status = "active";
+    } else if (completion) {
+      status = completion.outcome;
+    } else {
+      status = "active";
+    }
+    if (status === "active" && start.state_file_path) {
+      if (!existsSync3(start.state_file_path)) {
+        status = "orphaned";
+      }
+    }
+    let iterations = completion?.iterations ?? null;
+    if (isActive && start.state_file_path) {
+      iterations = readIterationFromStateFile(start.state_file_path);
+    }
+    const { task: cleanedTask, completionPromise: extractedPromise } = extractCompletionPromiseFromTask(start.task);
+    const completionPromise = start.completion_promise || extractedPromise;
+    const task = cleanedTask ?? start.task;
+    let hasChecklist = false;
+    let checklistProgress = null;
+    try {
+      const checklistResult = getChecklistWithProgress(loop_id);
+      if (checklistResult.checklist) {
+        hasChecklist = true;
+        checklistProgress = checklistResult.progress?.criteria ?? null;
+      }
+    } catch {}
+    sessions.push({
+      loop_id,
+      session_id: start.session_id,
+      status,
+      outcome: completion?.outcome,
+      project: start.project,
+      project_name: start.project_name,
+      state_file_path: start.state_file_path,
+      task,
+      started_at: start.started_at,
+      ended_at: completion?.ended_at ?? null,
+      duration_seconds: durationSeconds,
+      iterations,
+      max_iterations: start.max_iterations,
+      completion_promise: completionPromise,
+      error_reason: completion?.error_reason ?? null,
+      has_checklist: hasChecklist,
+      checklist_progress: checklistProgress
+    });
+  }
+  sessions.sort((a, b) => {
+    if (a.status === "active" && b.status !== "active")
+      return -1;
+    if (a.status !== "active" && b.status === "active")
+      return 1;
+    return new Date(b.started_at).getTime() - new Date(a.started_at).getTime();
+  });
+  return sessions;
+}
+function getSessions() {
+  const entries = parseLogFile();
+  return mergeSessions(entries);
+}
+function getSessionById(loopId) {
+  const sessions = getSessions();
+  return sessions.find((s) => s.loop_id === loopId) ?? null;
+}
+function deleteTranscriptFiles(loopId, sessionId) {
+  const suffixes = ["iterations.jsonl", "full.jsonl", "checklist.json"];
+  for (const suffix of suffixes) {
+    const filePath = findFileByLoopId(loopId, suffix);
+    if (filePath && existsSync3(filePath)) {
+      try {
+        unlinkSync(filePath);
+      } catch {}
+    }
+  }
+  if (sessionId && sessionId !== loopId) {
+    for (const suffix of suffixes) {
+      const filePath = findFileByLoopId(sessionId, suffix);
+      if (filePath && existsSync3(filePath)) {
+        try {
+          unlinkSync(filePath);
+        } catch {}
+      }
+    }
+  }
+}
+function deleteSession(loopId) {
+  const session = getSessionById(loopId);
+  if (session?.state_file_path && existsSync3(session.state_file_path)) {
+    try {
+      unlinkSync(session.state_file_path);
+    } catch {}
+  }
+  deleteTranscriptFiles(loopId, session?.session_id);
+  if (!existsSync3(LOG_FILE)) {
+    return false;
+  }
+  const content = readFileSync2(LOG_FILE, "utf-8");
+  const lines = content.split(`
+`).filter((line) => line.trim());
+  const filteredLines = [];
+  let found = false;
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      const entryLoopId = entry.loop_id || entry.loop_id || entry.session_id;
+      if (entryLoopId === loopId) {
+        found = true;
+        continue;
+      }
+      filteredLines.push(line);
+    } catch {
+      filteredLines.push(line);
+    }
+  }
+  if (!found) {
+    return false;
+  }
+  const tempFile = LOG_FILE + ".tmp." + Date.now();
+  writeFileSync(tempFile, filteredLines.join(`
+`) + (filteredLines.length > 0 ? `
+` : ""));
+  renameSync(tempFile, LOG_FILE);
+  return true;
+}
+function deleteAllArchivedSessions() {
+  const sessions = getSessions();
+  const archivedSessions = sessions.filter((s) => s.status !== "active");
+  if (archivedSessions.length === 0) {
+    return 0;
+  }
+  const loopIdsToDelete = new Set(archivedSessions.map((s) => s.loop_id));
+  for (const session of archivedSessions) {
+    if (session.state_file_path && existsSync3(session.state_file_path)) {
+      try {
+        unlinkSync(session.state_file_path);
+      } catch {}
+    }
+    deleteTranscriptFiles(session.loop_id, session.session_id);
+  }
+  if (!existsSync3(LOG_FILE)) {
+    return archivedSessions.length;
+  }
+  const content = readFileSync2(LOG_FILE, "utf-8");
+  const lines = content.split(`
+`).filter((line) => line.trim());
+  const filteredLines = lines.filter((line) => {
+    try {
+      const entry = JSON.parse(line);
+      const entryLoopId = entry.loop_id || entry.loop_id || entry.session_id;
+      return !loopIdsToDelete.has(entryLoopId);
+    } catch {
+      return true;
+    }
+  });
+  const tempFile = LOG_FILE + ".tmp." + Date.now();
+  writeFileSync(tempFile, filteredLines.join(`
+`) + (filteredLines.length > 0 ? `
+` : ""));
+  renameSync(tempFile, LOG_FILE);
+  return archivedSessions.length;
+}
+
+// server/api/sessions.ts
+function handleGetSessions() {
+  try {
+    const sessions = getSessions();
+    const activeCount = sessions.filter((s) => s.status === "active").length;
+    const response = {
+      sessions,
+      total: sessions.length,
+      active_count: activeCount
+    };
+    return Response.json(response);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const response = {
+      error: "FETCH_ERROR",
+      message: `Failed to fetch sessions: ${errorMessage}`
+    };
+    return Response.json(response, { status: 500 });
+  }
+}
+function handleGetSession(loopId) {
+  try {
+    const session = getSessionById(loopId);
+    if (!session) {
+      const response = {
+        error: "NOT_FOUND",
+        message: `Loop not found: ${loopId}`
+      };
+      return Response.json(response, { status: 404 });
+    }
+    return Response.json(session);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const response = {
+      error: "FETCH_ERROR",
+      message: `Failed to fetch session: ${errorMessage}`
+    };
+    return Response.json(response, { status: 500 });
+  }
+}
+
+// server/services/loop-manager.ts
+import { existsSync as existsSync4, unlinkSync as unlinkSync2, appendFileSync } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join3, resolve } from "path";
+var RALPH_BASE_DIR3 = join3(homedir3(), ".claude", "ralph-wiggum-pro");
+var LOOPS_DIR = join3(RALPH_BASE_DIR3, "loops");
+function validateStateFilePath(stateFilePath) {
+  try {
+    const resolvedPath = resolve(stateFilePath);
+    const expectedBase = resolve(LOOPS_DIR);
+    return resolvedPath.startsWith(expectedBase);
+  } catch {
+    return false;
+  }
+}
+function cancelLoop(session) {
+  if (session.status !== "active") {
+    return {
+      success: false,
+      message: `Loop ${session.loop_id} is not active (status: ${session.status})`
+    };
+  }
+  const stateFilePath = session.state_file_path;
+  if (!stateFilePath) {
+    return {
+      success: false,
+      message: `No state file found for loop ${session.loop_id}`
+    };
+  }
+  if (!validateStateFilePath(stateFilePath)) {
+    return {
+      success: false,
+      message: `Invalid state file path for loop ${session.loop_id}`
+    };
+  }
+  if (!existsSync4(stateFilePath)) {
+    return {
+      success: false,
+      message: `State file no longer exists for loop ${session.loop_id}`
+    };
+  }
+  try {
+    unlinkSync2(stateFilePath);
+    const logEntry = {
+      loop_id: session.loop_id,
+      session_id: session.session_id,
+      status: "completed",
+      outcome: "cancelled",
+      ended_at: new Date().toISOString(),
+      duration_seconds: Math.floor((Date.now() - new Date(session.started_at).getTime()) / 1000),
+      iterations: session.iterations ?? 0
+    };
+    appendFileSync(getLogFilePath(), JSON.stringify(logEntry) + `
+`);
+    return {
+      success: true,
+      message: `Successfully cancelled loop ${session.loop_id}`
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `Failed to cancel loop ${session.loop_id}`
+    };
+  }
+}
+
+// server/api/cancel.ts
+function handleCancelSession(loopId) {
+  try {
+    const session = getSessionById(loopId);
+    if (!session) {
+      const response2 = {
+        error: "NOT_FOUND",
+        message: `Loop not found: ${loopId}`
+      };
+      return Response.json(response2, { status: 404 });
+    }
+    if (session.status !== "active") {
+      const response2 = {
+        error: "INVALID_STATE",
+        message: `Cannot cancel loop: status is '${session.status}', expected 'active'`
+      };
+      return Response.json(response2, { status: 400 });
+    }
+    const result = cancelLoop(session);
+    if (!result.success) {
+      const response2 = {
+        error: "CANCEL_FAILED",
+        message: result.message
+      };
+      return Response.json(response2, { status: 500 });
+    }
+    const response = {
+      success: true,
+      message: result.message,
+      loop_id: loopId
+    };
+    return Response.json(response);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const response = {
+      error: "CANCEL_ERROR",
+      message: `Failed to cancel loop: ${errorMessage}`
+    };
+    return Response.json(response, { status: 500 });
+  }
+}
+
+// server/api/delete.ts
+function handleDeleteSession(loopId) {
+  try {
+    const session = getSessionById(loopId);
+    if (!session) {
+      const response2 = {
+        error: "NOT_FOUND",
+        message: `Loop not found: ${loopId}`
+      };
+      return Response.json(response2, { status: 404 });
+    }
+    if (session.status === "active") {
+      const response2 = {
+        error: "INVALID_STATE",
+        message: `Cannot delete active loop. Cancel it first.`
+      };
+      return Response.json(response2, { status: 400 });
+    }
+    const deleted = deleteSession(loopId);
+    if (!deleted) {
+      const response2 = {
+        error: "DELETE_FAILED",
+        message: `Failed to delete loop from log file`
+      };
+      return Response.json(response2, { status: 500 });
+    }
+    const response = {
+      success: true,
+      message: `Loop permanently deleted from history`,
+      loop_id: loopId
+    };
+    return Response.json(response);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const response = {
+      error: "DELETE_ERROR",
+      message: `Failed to delete loop: ${errorMessage}`
+    };
+    return Response.json(response, { status: 500 });
+  }
+}
+function handleDeleteAllArchivedSessions() {
+  try {
+    const deletedCount = deleteAllArchivedSessions();
+    const response = {
+      success: true,
+      deleted_count: deletedCount,
+      message: `Permanently deleted ${deletedCount} archived session(s) and their transcripts`
+    };
+    return Response.json(response);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const response = {
+      error: "DELETE_ERROR",
+      message: `Failed to delete archived sessions: ${errorMessage}`
+    };
+    return Response.json(response, { status: 500 });
+  }
+}
+
+// server/api/archive.ts
+import { appendFileSync as appendFileSync2 } from "fs";
+function handleArchiveSession(loopId) {
+  try {
+    const session = getSessionById(loopId);
+    if (!session) {
+      const response2 = {
+        error: "NOT_FOUND",
+        message: `Loop not found: ${loopId}`
+      };
+      return Response.json(response2, { status: 404 });
+    }
+    if (session.status !== "orphaned") {
+      const response2 = {
+        error: "INVALID_STATE",
+        message: `Cannot archive loop: status is '${session.status}', expected 'orphaned'`
+      };
+      return Response.json(response2, { status: 400 });
+    }
+    const logEntry = {
+      loop_id: session.loop_id,
+      session_id: session.session_id,
+      status: "completed",
+      outcome: "archived",
+      ended_at: new Date().toISOString(),
+      duration_seconds: Math.floor((Date.now() - new Date(session.started_at).getTime()) / 1000),
+      iterations: session.iterations ?? null
+    };
+    appendFileSync2(getLogFilePath(), JSON.stringify(logEntry) + `
+`);
+    const response = {
+      success: true,
+      message: `Successfully archived orphaned loop ${loopId}`,
+      loop_id: loopId
+    };
+    return Response.json(response);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const response = {
+      error: "ARCHIVE_ERROR",
+      message: `Failed to archive loop: ${errorMessage}`
+    };
+    return Response.json(response, { status: 500 });
+  }
+}
+
+// server/services/transcript-service.ts
+import { readFileSync as readFileSync3, existsSync as existsSync5 } from "fs";
+function getIterationsFilePath(loopId) {
+  return findFileByLoopId(loopId, "iterations.jsonl");
+}
+function getFullTranscriptFilePath(loopId) {
+  return findFileByLoopId(loopId, "full.jsonl");
+}
+function hasIterations(loopId) {
+  return fileExistsForLoopId(loopId, "iterations.jsonl");
+}
+function hasFullTranscript(loopId) {
+  return getFullTranscriptFilePath(loopId) !== null;
+}
+function getIterations(loopId) {
+  const filePath = getIterationsFilePath(loopId);
+  if (!filePath || !existsSync5(filePath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync3(filePath, "utf-8");
+    const lines = content.split(`
+`).filter((line) => line.trim());
+    const entries = [];
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        entries.push(entry);
+      } catch {
+        console.warn("Skipping malformed iteration entry:", line.slice(0, 50));
+      }
+    }
+    return entries;
+  } catch (error) {
+    console.error("Failed to read iterations for loop:", loopId, error);
+    return null;
+  }
+}
+function getFullTranscript(loopId) {
+  const filePath = getFullTranscriptFilePath(loopId);
+  if (!filePath || !existsSync5(filePath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync3(filePath, "utf-8");
+    const lines = content.split(`
+`).filter((line) => line.trim());
+    const messages = [];
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.message?.role && entry.message?.content) {
+          const role = entry.message.role;
+          const textContent = entry.message.content.filter((c) => c.type === "text" && c.text).map((c) => c.text).join(`
+`);
+          if (textContent) {
+            messages.push({ role, content: textContent });
+          }
+        }
+      } catch {
+        console.warn("Skipping malformed transcript entry:", line.slice(0, 50));
+      }
+    }
+    return messages;
+  } catch (error) {
+    console.error("Failed to read full transcript for loop:", loopId, error);
+    return null;
+  }
+}
+
+// server/api/transcript.ts
+function handleGetIterations(loopId) {
+  try {
+    const iterations = getIterations(loopId);
+    if (iterations === null) {
+      const response2 = {
+        error: "NOT_FOUND",
+        message: `No transcript iterations found for loop: ${loopId}`
+      };
+      return Response.json(response2, { status: 404 });
+    }
+    const response = { iterations };
+    return Response.json(response);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const response = {
+      error: "FETCH_ERROR",
+      message: `Failed to fetch iterations: ${errorMessage}`
+    };
+    return Response.json(response, { status: 500 });
+  }
+}
+function handleGetFullTranscript(loopId) {
+  try {
+    const messages = getFullTranscript(loopId);
+    if (messages === null) {
+      const response2 = {
+        error: "NOT_FOUND",
+        message: `No full transcript found for loop: ${loopId}`
+      };
+      return Response.json(response2, { status: 404 });
+    }
+    const response = { messages };
+    return Response.json(response);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const response = {
+      error: "FETCH_ERROR",
+      message: `Failed to fetch full transcript: ${errorMessage}`
+    };
+    return Response.json(response, { status: 500 });
+  }
+}
+function handleCheckTranscriptAvailability(loopId) {
+  try {
+    const response = {
+      hasIterations: hasIterations(loopId),
+      hasFullTranscript: hasFullTranscript(loopId)
+    };
+    return Response.json(response);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const response = {
+      error: "CHECK_ERROR",
+      message: `Failed to check transcript availability: ${errorMessage}`
+    };
+    return Response.json(response, { status: 500 });
+  }
+}
+
+// server/api/checklist.ts
+function handleGetChecklist(loopId) {
+  try {
+    const result = getChecklistWithProgress(loopId);
+    if (!result.checklist) {
+      const response2 = {
+        error: "NOT_FOUND",
+        message: `Checklist not found for loop_id: ${loopId}`
+      };
+      return Response.json(response2, { status: 404 });
+    }
+    const response = {
+      checklist: result.checklist,
+      progress: result.progress
+    };
+    return Response.json(response);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    if (errorMessage.includes("Invalid loop_id")) {
+      const response2 = {
+        error: "INVALID_LOOP_ID",
+        message: errorMessage
+      };
+      return Response.json(response2, { status: 400 });
+    }
+    const response = {
+      error: "FETCH_ERROR",
+      message: `Failed to fetch checklist: ${errorMessage}`
+    };
+    return Response.json(response, { status: 500 });
+  }
+}
+
+// server/services/websocket-service.ts
+import { watch } from "fs";
+import {
+  openSync,
+  readSync,
+  fstatSync,
+  closeSync,
+  existsSync as existsSync6,
+  mkdirSync,
+  statSync
+} from "fs";
+import { join as join4 } from "path";
+var watchers = new Map;
+var DEBOUNCE_MS = 100;
+var MAX_SUBSCRIPTIONS_PER_CLIENT = 10;
+function findIterationsFilePath(loopId) {
+  return findFileByLoopId(loopId, "iterations.jsonl");
+}
+function getIterationsWatchTarget(loopId) {
+  return {
+    dir: getTranscriptsDir(),
+    suffix: `-${loopId}-iterations.jsonl`
+  };
+}
+function readNewIterations(filePath, state) {
+  if (!existsSync6(filePath)) {
+    return [];
+  }
+  let fd = null;
+  try {
+    fd = openSync(filePath, "r");
+    const stats = fstatSync(fd);
+    if (stats.size <= state.lastSize) {
+      return [];
+    }
+    const newBytesCount = stats.size - state.lastSize;
+    const buffer = Buffer.alloc(newBytesCount);
+    readSync(fd, buffer, 0, newBytesCount, state.lastSize);
+    state.lastSize = stats.size;
+    const newContent = buffer.toString("utf-8");
+    const lines = newContent.split(`
+`).filter((line) => line.trim());
+    const newEntries = [];
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        newEntries.push(entry);
+      } catch {}
+    }
+    return newEntries;
+  } catch (error) {
+    console.error("Error reading new iterations:", error);
+    return [];
+  } finally {
+    if (fd !== null) {
+      try {
+        closeSync(fd);
+      } catch {}
+    }
+  }
+}
+function broadcastIterations(loopId, iterations) {
+  const state = watchers.get(loopId);
+  if (!state || iterations.length === 0)
+    return;
+  const message = JSON.stringify({
+    type: "iterations",
+    loopId,
+    iterations
+  });
+  for (const client of state.clients) {
+    if (client.readyState !== 1) {
+      state.clients.delete(client);
+      continue;
+    }
+    try {
+      client.send(message);
+    } catch (error) {
+      console.error("Error sending to WebSocket client:", error);
+      state.clients.delete(client);
+    }
+  }
+}
+function findChecklistFilePath(loopId) {
+  return findFileByLoopId(loopId, "checklist.json");
+}
+function broadcastChecklist(loopId) {
+  const state = watchers.get(loopId);
+  if (!state)
+    return;
+  const checklistData = getChecklistWithProgress(loopId);
+  if (!checklistData.checklist)
+    return;
+  const message = JSON.stringify({
+    type: "checklist",
+    loopId,
+    checklist: checklistData.checklist,
+    progress: checklistData.progress
+  });
+  for (const client of state.clients) {
+    if (client.readyState !== 1) {
+      state.clients.delete(client);
+      continue;
+    }
+    try {
+      client.send(message);
+    } catch (error) {
+      console.error("Error sending checklist to WebSocket client:", error);
+      state.clients.delete(client);
+    }
+  }
+}
+function handleChecklistChange(loopId) {
+  const state = watchers.get(loopId);
+  if (!state)
+    return;
+  if (state.checklistDebounceTimer) {
+    clearTimeout(state.checklistDebounceTimer);
+  }
+  state.checklistDebounceTimer = setTimeout(() => {
+    broadcastChecklist(loopId);
+    state.checklistDebounceTimer = null;
+  }, DEBOUNCE_MS);
+}
+function setupChecklistWatcher(loopId, state) {
+  if (state.checklistWatcher) {
+    state.checklistWatcher.close();
+    state.checklistWatcher = null;
+  }
+  const checklistPath = findChecklistFilePath(loopId);
+  if (checklistPath && existsSync6(checklistPath)) {
+    try {
+      const stats = statSync(checklistPath);
+      state.checklistLastModified = stats.mtimeMs;
+    } catch (error) {
+      console.debug(`Could not stat checklist file ${checklistPath}:`, error);
+      state.checklistLastModified = 0;
+    }
+    state.checklistFilePath = checklistPath;
+    state.checklistWatcher = watch(checklistPath, { persistent: false }, (eventType) => {
+      if (eventType === "change") {
+        handleChecklistChange(loopId);
+      }
+    });
+    state.checklistWatcher.on("error", (error) => {
+      console.error(`Checklist watcher error for ${loopId}:`, error);
+    });
+    console.log(`Started checklist watcher for loop: ${loopId}`);
+  } else {
+    state.checklistFilePath = null;
+  }
+}
+function handleDirectoryChangeForChecklist(loopId, filename) {
+  const state = watchers.get(loopId);
+  if (!state)
+    return;
+  if (filename && filename.endsWith("-checklist.json") && filename.includes(loopId)) {
+    setupChecklistWatcher(loopId, state);
+    handleChecklistChange(loopId);
+  }
+}
+function handleFileChange(loopId, filePath) {
+  const state = watchers.get(loopId);
+  if (!state)
+    return;
+  if (state.debounceTimer) {
+    clearTimeout(state.debounceTimer);
+  }
+  state.debounceTimer = setTimeout(() => {
+    const newIterations = readNewIterations(filePath, state);
+    if (newIterations.length > 0) {
+      broadcastIterations(loopId, newIterations);
+    }
+    state.debounceTimer = null;
+  }, DEBOUNCE_MS);
+}
+function handleDirectoryChange(loopId, targetSuffix, filename) {
+  const state = watchers.get(loopId);
+  if (!state)
+    return;
+  handleDirectoryChangeForChecklist(loopId, filename);
+  if (!state.watchingDirectory)
+    return;
+  if (filename && filename.endsWith(targetSuffix)) {
+    const filePath = join4(getTranscriptsDir(), filename);
+    if (state.watcher) {
+      state.watcher.close();
+    }
+    state.watchingDirectory = false;
+    state.filePath = filePath;
+    state.watcher = watch(filePath, { persistent: false }, (eventType) => {
+      if (eventType === "change") {
+        handleFileChange(loopId, filePath);
+      }
+    });
+    state.watcher.on("error", (error) => {
+      console.error(`Watcher error for ${loopId}:`, error);
+    });
+    console.log(`Switched to file watcher for loop: ${loopId}`);
+    handleFileChange(loopId, filePath);
+  }
+}
+function countClientSubscriptions(client) {
+  let count = 0;
+  for (const state of watchers.values()) {
+    if (state.clients.has(client)) {
+      count++;
+    }
+  }
+  return count;
+}
+function canClientSubscribe(client) {
+  return countClientSubscriptions(client) < MAX_SUBSCRIPTIONS_PER_CLIENT;
+}
+function subscribeToLoop(loopId, client) {
+  if (!canClientSubscribe(client)) {
+    return {
+      success: false,
+      message: `Maximum subscriptions (${MAX_SUBSCRIPTIONS_PER_CLIENT}) reached`
+    };
+  }
+  let state = watchers.get(loopId);
+  if (!state) {
+    let lastSize = 0;
+    let watcher = null;
+    let watchingDirectory = false;
+    let filePath = null;
+    filePath = findIterationsFilePath(loopId);
+    if (filePath && existsSync6(filePath)) {
+      try {
+        const fd = openSync(filePath, "r");
+        const stats = fstatSync(fd);
+        lastSize = stats.size;
+        closeSync(fd);
+      } catch {}
+      watcher = watch(filePath, { persistent: false }, (eventType) => {
+        if (eventType === "change") {
+          handleFileChange(loopId, filePath);
+        }
+      });
+      watcher.on("error", (error) => {
+        console.error(`Watcher error for ${loopId}:`, error);
+      });
+      console.log(`Started file watcher for loop: ${loopId}`);
+    } else {
+      const { dir, suffix } = getIterationsWatchTarget(loopId);
+      if (!existsSync6(dir)) {
+        try {
+          mkdirSync(dir, { recursive: true });
+        } catch {}
+      }
+      if (existsSync6(dir)) {
+        watchingDirectory = true;
+        watcher = watch(dir, { persistent: false }, (eventType, filename) => {
+          if (eventType === "rename") {
+            handleDirectoryChange(loopId, suffix, filename);
+          }
+        });
+        watcher.on("error", (error) => {
+          console.error(`Directory watcher error for ${loopId}:`, error);
+        });
+        console.log(`Started directory watcher for loop: ${loopId} (file not yet created)`);
+      } else {
+        console.log(`Cannot watch loop ${loopId}: transcript directory does not exist`);
+      }
+    }
+    state = {
+      watcher,
+      lastSize,
+      debounceTimer: null,
+      clients: new Set,
+      watchingDirectory,
+      filePath,
+      checklistWatcher: null,
+      checklistLastModified: 0,
+      checklistDebounceTimer: null,
+      checklistFilePath: null
+    };
+    watchers.set(loopId, state);
+    setupChecklistWatcher(loopId, state);
+  }
+  state.clients.add(client);
+  console.log(`Client subscribed to loop ${loopId} (${state.clients.size} clients)`);
+  return { success: true };
+}
+function unsubscribeFromLoop(loopId, client) {
+  const state = watchers.get(loopId);
+  if (!state)
+    return;
+  state.clients.delete(client);
+  console.log(`Client unsubscribed from loop ${loopId} (${state.clients.size} clients)`);
+  if (state.clients.size === 0) {
+    if (state.debounceTimer) {
+      clearTimeout(state.debounceTimer);
+    }
+    if (state.watcher) {
+      state.watcher.close();
+    }
+    if (state.checklistDebounceTimer) {
+      clearTimeout(state.checklistDebounceTimer);
+    }
+    if (state.checklistWatcher) {
+      state.checklistWatcher.close();
+    }
+    watchers.delete(loopId);
+    console.log(`Stopped watching transcript and checklist for loop: ${loopId}`);
+  }
+}
+function unsubscribeFromAll(client) {
+  for (const [loopId, state] of watchers) {
+    if (state.clients.has(client)) {
+      unsubscribeFromLoop(loopId, client);
+    }
+  }
+}
+function cleanupAllWatchers() {
+  for (const state of watchers.values()) {
+    if (state.debounceTimer) {
+      clearTimeout(state.debounceTimer);
+    }
+    if (state.watcher) {
+      state.watcher.close();
+    }
+    if (state.checklistDebounceTimer) {
+      clearTimeout(state.checklistDebounceTimer);
+    }
+    if (state.checklistWatcher) {
+      state.checklistWatcher.close();
+    }
+  }
+  watchers.clear();
+  console.log("All transcript and checklist watchers cleaned up");
+}
+
+// server/server.ts
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname(__filename2);
+function resolveDist() {
+  const prodPath = join5(__dirname2, "..");
+  if (existsSync7(join5(prodPath, "index.html"))) {
+    return prodPath;
+  }
+  return join5(__dirname2, "..", "dist");
+}
+var DIST_DIR = resolveDist();
+function validateLoopId2(loopId) {
+  const validPattern = /^[a-zA-Z0-9._-]+$/;
+  const noPathTraversal = !loopId.includes("..");
+  return validPattern.test(loopId) && noPathTraversal;
+}
+function invalidLoopIdResponse() {
+  return Response.json({
+    error: "INVALID_LOOP_ID",
+    message: "Invalid loop ID format. Loop ID must contain only alphanumeric characters, hyphens, underscores, and dots."
+  }, { status: 400 });
+}
+function getMimeType(path) {
+  const ext = path.split(".").pop()?.toLowerCase();
+  const mimeTypes = {
+    html: "text/html",
+    css: "text/css",
+    js: "application/javascript",
+    json: "application/json",
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    svg: "image/svg+xml",
+    ico: "image/x-icon"
+  };
+  return mimeTypes[ext ?? ""] ?? "application/octet-stream";
+}
+function serveStaticFile(path) {
+  const filePath = join5(DIST_DIR, path);
+  if (!existsSync7(filePath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync4(filePath);
+    return new Response(content, {
+      headers: { "Content-Type": getMimeType(path) }
+    });
+  } catch {
+    return null;
+  }
+}
+function createServer(options) {
+  const { port, host } = options;
+  const server = Bun.serve({
+    port,
+    hostname: host,
+    fetch(req, server2) {
+      const url = new URL(req.url);
+      const path = url.pathname;
+      if (path === "/ws" && req.headers.get("upgrade") === "websocket") {
+        const loopId = url.searchParams.get("loopId");
+        if (!loopId || !validateLoopId2(loopId)) {
+          return new Response("Invalid loopId", { status: 400 });
+        }
+        const success = server2.upgrade(req, { data: { loopId } });
+        if (success) {
+          return;
+        }
+        return new Response("WebSocket upgrade failed", { status: 500 });
+      }
+      if (path.startsWith("/api/")) {
+        const securityHeaders = {
+          "Access-Control-Allow-Origin": "*",
+          "Access-Control-Allow-Methods": "GET, POST, DELETE, OPTIONS",
+          "Access-Control-Allow-Headers": "Content-Type",
+          "Content-Security-Policy": "default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval'; style-src 'self' 'unsafe-inline';",
+          "X-Content-Type-Options": "nosniff",
+          "X-Frame-Options": "DENY",
+          "X-XSS-Protection": "1; mode=block",
+          "Referrer-Policy": "strict-origin-when-cross-origin",
+          "Strict-Transport-Security": "max-age=31536000; includeSubDomains"
+        };
+        if (req.method === "OPTIONS") {
+          return new Response(null, { headers: securityHeaders });
+        }
+        let response;
+        if (path === "/api/sessions" && req.method === "GET") {
+          response = handleGetSessions();
+        } else if (path.match(/^\/api\/sessions\/[^/]+$/) && req.method === "GET") {
+          const loopId = path.split("/").pop();
+          if (!validateLoopId2(loopId)) {
+            response = invalidLoopIdResponse();
+          } else {
+            response = handleGetSession(loopId);
+          }
+        } else if (path.match(/^\/api\/sessions\/[^/]+\/cancel$/) && req.method === "POST") {
+          const parts = path.split("/");
+          const loopId = parts[parts.length - 2];
+          if (!validateLoopId2(loopId)) {
+            response = invalidLoopIdResponse();
+          } else {
+            response = handleCancelSession(loopId);
+          }
+        } else if (path.match(/^\/api\/sessions\/[^/]+\/archive$/) && req.method === "POST") {
+          const parts = path.split("/");
+          const loopId = parts[parts.length - 2];
+          if (!validateLoopId2(loopId)) {
+            response = invalidLoopIdResponse();
+          } else {
+            response = handleArchiveSession(loopId);
+          }
+        } else if (path === "/api/sessions" && req.method === "DELETE") {
+          response = handleDeleteAllArchivedSessions();
+        } else if (path.match(/^\/api\/sessions\/[^/]+$/) && req.method === "DELETE") {
+          const loopId = path.split("/").pop();
+          if (!validateLoopId2(loopId)) {
+            response = invalidLoopIdResponse();
+          } else {
+            response = handleDeleteSession(loopId);
+          }
+        } else if (path.match(/^\/api\/transcript\/[^/]+\/iterations$/) && req.method === "GET") {
+          const parts = path.split("/");
+          const loopId = parts[parts.length - 2];
+          if (!validateLoopId2(loopId)) {
+            response = invalidLoopIdResponse();
+          } else {
+            response = handleGetIterations(loopId);
+          }
+        } else if (path.match(/^\/api\/transcript\/[^/]+\/full$/) && req.method === "GET") {
+          const parts = path.split("/");
+          const loopId = parts[parts.length - 2];
+          if (!validateLoopId2(loopId)) {
+            response = invalidLoopIdResponse();
+          } else {
+            response = handleGetFullTranscript(loopId);
+          }
+        } else if (path.match(/^\/api\/transcript\/[^/]+$/) && req.method === "GET") {
+          const loopId = path.split("/").pop();
+          if (!validateLoopId2(loopId)) {
+            response = invalidLoopIdResponse();
+          } else {
+            response = handleCheckTranscriptAvailability(loopId);
+          }
+        } else if (path.match(/^\/api\/checklist\/[^/]+$/) && req.method === "GET") {
+          const loopId = path.split("/").pop();
+          if (!validateLoopId2(loopId)) {
+            response = invalidLoopIdResponse();
+          } else {
+            response = handleGetChecklist(loopId);
+          }
+        } else {
+          response = Response.json({ error: "NOT_FOUND", message: "API endpoint not found" }, { status: 404 });
+        }
+        const headers = new Headers(response.headers);
+        Object.entries(securityHeaders).forEach(([key, value]) => {
+          headers.set(key, value);
+        });
+        return new Response(response.body, {
+          status: response.status,
+          headers
+        });
+      }
+      if (existsSync7(DIST_DIR)) {
+        const staticResponse = serveStaticFile(path === "/" ? "index.html" : path.slice(1));
+        if (staticResponse) {
+          return staticResponse;
+        }
+        if (!path.includes(".")) {
+          const indexResponse = serveStaticFile("index.html");
+          if (indexResponse) {
+            return indexResponse;
+          }
+        }
+      }
+      return new Response("Not Found", { status: 404 });
+    },
+    websocket: {
+      open(ws) {
+        const { loopId } = ws.data;
+        console.log(`WebSocket connected for loop: ${loopId}`);
+        const result = subscribeToLoop(loopId, ws);
+        if (!result.success) {
+          ws.send(JSON.stringify({ type: "error", message: result.message }));
+        }
+      },
+      close(ws) {
+        console.log(`WebSocket disconnected for loop: ${ws.data.loopId}`);
+        unsubscribeFromAll(ws);
+      },
+      message(ws, message) {
+        try {
+          const data = JSON.parse(message.toString());
+          if (data.type === "subscribe" && data.loopId && validateLoopId2(data.loopId)) {
+            const result = subscribeToLoop(data.loopId, ws);
+            if (!result.success) {
+              ws.send(JSON.stringify({ type: "error", message: result.message }));
+            }
+          }
+        } catch {}
+      }
+    }
+  });
+  process.once("SIGINT", () => {
+    cleanupAllWatchers();
+    server.stop();
+    process.exit(0);
+  });
+  process.once("SIGTERM", () => {
+    cleanupAllWatchers();
+    server.stop();
+    process.exit(0);
+  });
+  return server;
+}
+
+// server/index.ts
+function parseArgs() {
+  const args = process.argv.slice(2);
+  let port = 3847;
+  let host = "localhost";
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--port" || arg === "-p") {
+      const value = args[++i];
+      const parsed = parseInt(value, 10);
+      if (isNaN(parsed) || parsed < 1 || parsed > 65535) {
+        console.error(`Invalid port: ${value}`);
+        process.exit(1);
+      }
+      port = parsed;
+    } else if (arg === "--host" || arg === "-h") {
+      host = args[++i] || "localhost";
+    } else if (arg === "--help") {
+      console.log(`
+Ralph Dashboard - Web UI for Ralph Wiggum loops
+
+USAGE:
+  ralph-dashboard [OPTIONS]
+
+OPTIONS:
+  --port, -p <PORT>   Port to listen on (default: 3847)
+  --host, -h <HOST>   Host to bind to (default: localhost)
+                      Use 0.0.0.0 for public access
+  --help              Show this help message
+
+EXAMPLES:
+  ralph-dashboard                        # Start on localhost:3847
+  ralph-dashboard --port 8080            # Start on localhost:8080
+  ralph-dashboard --host 0.0.0.0         # Allow remote access
+  ralph-dashboard -p 8080 -h 0.0.0.0     # Both options
+`);
+      process.exit(0);
+    }
+  }
+  return { port, host };
+}
+function main() {
+  const { port, host } = parseArgs();
+  console.log(`
+\uD83D\uDD04 Ralph Dashboard
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+`);
+  createServer({ port, host });
+  const displayHost = host === "0.0.0.0" ? "localhost" : host;
+  const publicNote = host === "0.0.0.0" ? " (public access enabled)" : "";
+  console.log(`  \uD83C\uDF10 Server running at: http://${displayHost}:${port}${publicNote}`);
+  console.log(`  \uD83D\uDCCA View your Ralph loops in the browser`);
+  console.log(`  \u23F9  Press Ctrl+C to stop`);
+  console.log(`
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+`);
+}
+main();