helloloop 0.9.1 → 0.10.0

package/src/dashboard_tui.mjs

@@ -0,0 +1,289 @@
+import { collectDashboardSnapshot } from "./dashboard_command.mjs";
+import { sleep } from "./common.mjs";
+import { loadRuntimeSettings } from "./runtime_settings_loader.mjs";
+import { hasRetryBudget, pickRetryDelaySeconds } from "./runtime_settings.mjs";
+
+const STATUS_GROUPS = [
+  { key: "in_progress", label: "进行中" },
+  { key: "pending", label: "待处理" },
+  { key: "done", label: "已完成" },
+  { key: "blocked", label: "阻塞" },
+  { key: "failed", label: "失败" },
+];
+
+const KEYBOARD_HELP = [
+  "←/→ 切换仓库",
+  "↑/↓ 滚动",
+  "1-9 直达仓库",
+  "r 刷新",
+  "q 退出",
+];
+
+function truncateText(text, maxWidth) {
+  if (maxWidth <= 0) {
+    return "";
+  }
+  const normalized = String(text || "").replace(/\s+/gu, " ").trim();
+  if (normalized.length <= maxWidth) {
+    return normalized.padEnd(maxWidth, " ");
+  }
+  if (maxWidth <= 1) {
+    return normalized.slice(0, maxWidth);
+  }
+  return `${normalized.slice(0, Math.max(0, maxWidth - 1))}…`;
+}
+
+function repeat(char, count) {
+  return count > 0 ? char.repeat(count) : "";
+}
+
+function normalizeSelectedIndex(snapshot, currentIndex) {
+  if (!snapshot.sessions.length) {
+    return 0;
+  }
+  const bounded = Number(currentIndex || 0);
+  if (!Number.isFinite(bounded) || bounded < 0) {
+    return 0;
+  }
+  return Math.min(bounded, snapshot.sessions.length - 1);
+}
+
+function groupTasks(session) {
+  const grouped = new Map(STATUS_GROUPS.map((item) => [item.key, []]));
+  for (const task of Array.isArray(session?.tasks) ? session.tasks : []) {
+    const status = String(task.status || "pending");
+    const bucket = grouped.get(status) || grouped.get("pending");
+    bucket.push(task);
+  }
+  return grouped;
+}
+
+function renderRepoTabs(snapshot, selectedIndex, width) {
+  const tabs = snapshot.sessions.map((session, index) => {
+    const active = index === selectedIndex ? "*" : " ";
+    const task = session.latestStatus?.taskTitle || session.nextTask?.title || "无任务";
+    return `${active}${index + 1}.${session.repoName} ${session.runtime?.status || "idle"} ${task}`;
+  });
+
+  const line = tabs.join("  |  ");
+  return truncateText(line, width);
+}
+
+function buildSessionMetaLines(session, width) {
+  const lines = [
+    `仓库：${session.repoRoot}`,
+    `会话：${session.sessionId}`,
+    `当前任务：${session.latestStatus?.taskTitle || "无"}`,
+    `运行状态：${session.runtime?.status || "idle"}${Number.isFinite(Number(session.runtime?.heartbeat?.idleSeconds)) && Number(session.runtime?.heartbeat?.idleSeconds) > 0 ? ` | idle=${session.runtime.heartbeat.idleSeconds}s` : ""}`,
+    `当前动作：${session.activity?.current?.label || session.latestStatus?.message || session.runtime?.failureReason || "等待新事件"}`,
+    `backlog：总计 ${session.summary?.total || 0} / 待处理 ${session.summary?.pending || 0} / 进行中 ${session.summary?.inProgress || 0} / 已完成 ${session.summary?.done || 0} / 阻塞 ${session.summary?.blocked || 0} / 失败 ${session.summary?.failed || 0}`,
+  ];
+
+  return lines.map((line) => truncateText(line, width));
+}
+
+function renderTaskLine(task, width) {
+  const meta = `[${task.priority || "P2"}|${task.risk || "low"}]`;
+  return truncateText(`${meta} ${task.title}`, width);
+}
+
+function renderTaskSections(session, width) {
+  const sections = [];
+  const grouped = groupTasks(session);
+
+  for (const statusGroup of STATUS_GROUPS) {
+    const tasks = grouped.get(statusGroup.key) || [];
+    sections.push(`${statusGroup.label} (${tasks.length})`);
+    if (!tasks.length) {
+      sections.push("  - 无");
+      sections.push("");
+      continue;
+    }
+
+    for (const task of tasks) {
+      sections.push(`  - ${renderTaskLine(task, Math.max(10, width - 4))}`);
+    }
+    sections.push("");
+  }
+
+  return sections;
+}
+
+function renderEmptyState(width, height, message) {
+  const lines = [
+    "HelloLoop TUI Dashboard",
+    repeat("=", Math.max(20, Math.min(width, 40))),
+    "",
+    message,
+  ];
+  while (lines.length < height) {
+    lines.push("");
+  }
+  return lines.slice(0, height).map((line) => truncateText(line, width)).join("\n");
+}
+
+function renderTui(snapshot, state) {
+  const width = Math.max(60, Number(process.stdout.columns || 120));
+  const height = Math.max(24, Number(process.stdout.rows || 40));
+
+  if (!snapshot.sessions.length) {
+    return renderEmptyState(width, height, "当前没有已登记仓库或后台会话。");
+  }
+
+  const selectedIndex = normalizeSelectedIndex(snapshot, state.selectedIndex);
+  const selectedSession = snapshot.sessions[selectedIndex];
+  const lines = [
+    truncateText(`HelloLoop TUI Dashboard | 仓库 ${snapshot.repoCount || 0} | 活跃会话 ${snapshot.activeCount || 0} | 任务总计 ${snapshot.taskTotals?.total || 0} | 待处理 ${snapshot.taskTotals?.pending || 0} | 进行中 ${snapshot.taskTotals?.inProgress || 0} | 已完成 ${snapshot.taskTotals?.done || 0}`, width),
+    truncateText(`更新时间：${snapshot.generatedAt} | 键位：${KEYBOARD_HELP.join(" / ")}`, width),
+    repeat("─", width),
+    renderRepoTabs(snapshot, selectedIndex, width),
+    repeat("─", width),
+    ...buildSessionMetaLines(selectedSession, width),
+    repeat("─", width),
+  ];
+
+  const contentLines = renderTaskSections(selectedSession, width);
+  const availableContentHeight = Math.max(1, height - lines.length - 1);
+  const maxOffset = Math.max(0, contentLines.length - availableContentHeight);
+  const scrollOffset = Math.min(Math.max(0, Number(state.scrollOffset || 0)), maxOffset);
+
+  const visibleContent = contentLines.slice(scrollOffset, scrollOffset + availableContentHeight);
+  const footer = truncateText(
+    `仓库 ${selectedIndex + 1}/${snapshot.sessions.length} | 滚动 ${scrollOffset + 1}-${Math.min(contentLines.length, scrollOffset + visibleContent.length)}/${contentLines.length}`,
+    width,
+  );
+
+  while (visibleContent.length < availableContentHeight) {
+    visibleContent.push("");
+  }
+
+  return [...lines, ...visibleContent, footer]
+    .slice(0, height)
+    .map((line) => truncateText(line, width))
+    .join("\n");
+}
+
+function applyInputKey(buffer, state, snapshot) {
+  const input = String(buffer || "");
+  if (!input) {
+    return false;
+  }
+
+  if (input === "\u0003" || input === "q") {
+    state.running = false;
+    return true;
+  }
+  if (input === "r") {
+    state.forceRefresh = true;
+    return true;
+  }
+  if (input === "\u001b[C") {
+    state.selectedIndex = Math.min(snapshot.sessions.length - 1, state.selectedIndex + 1);
+    state.scrollOffset = 0;
+    return true;
+  }
+  if (input === "\u001b[D") {
+    state.selectedIndex = Math.max(0, state.selectedIndex - 1);
+    state.scrollOffset = 0;
+    return true;
+  }
+  if (input === "\u001b[A") {
+    state.scrollOffset = Math.max(0, state.scrollOffset - 1);
+    return true;
+  }
+  if (input === "\u001b[B") {
+    state.scrollOffset += 1;
+    return true;
+  }
+
+  const digit = Number.parseInt(input, 10);
+  if (Number.isInteger(digit) && digit > 0 && digit <= snapshot.sessions.length) {
+    state.selectedIndex = digit - 1;
+    state.scrollOffset = 0;
+    return true;
+  }
+
+  return false;
+}
+
+function enterAlternateScreen() {
+  process.stdout.write("\x1b[?1049h\x1b[?25l");
+}
+
+function leaveAlternateScreen() {
+  process.stdout.write("\x1b[?25h\x1b[?1049l");
+}
+
+export async function runDashboardTuiCommand(options = {}) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    throw new Error("HelloLoop TUI 需要在真实终端中运行。");
+  }
+
+  const pollMs = Math.max(500, Number(options.pollMs || options.watchPollMs || 1500));
+  const observerRetry = loadRuntimeSettings({
+    globalConfigFile: options.globalConfigFile,
+  }).observerRetry;
+
+  const state = {
+    running: true,
+    selectedIndex: 0,
+    scrollOffset: 0,
+    forceRefresh: true,
+  };
+  let lastFrame = "";
+  let retryCount = 0;
+  let lastSnapshot = collectDashboardSnapshot();
+
+  const onData = (buffer) => {
+    applyInputKey(buffer, state, lastSnapshot);
+  };
+
+  enterAlternateScreen();
+  process.stdin.setEncoding("utf8");
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  process.stdin.on("data", onData);
+
+  try {
+    while (state.running) {
+      try {
+        lastSnapshot = collectDashboardSnapshot();
+        retryCount = 0;
+      } catch (error) {
+        const nextAttempt = retryCount + 1;
+        if (!observerRetry.enabled || !hasRetryBudget(observerRetry.maxRetryCount, nextAttempt)) {
+          throw error;
+        }
+
+        const delaySeconds = pickRetryDelaySeconds(observerRetry.retryDelaysSeconds, nextAttempt);
+        const frame = renderEmptyState(
+          Math.max(60, Number(process.stdout.columns || 120)),
+          Math.max(24, Number(process.stdout.rows || 40)),
+          `看板采集失败，将在 ${delaySeconds} 秒后自动重试（第 ${nextAttempt} 次）：${String(error?.message || error || "unknown error")}`,
+        );
+        process.stdout.write("\x1b[H\x1b[2J");
+        process.stdout.write(frame);
+        retryCount = nextAttempt;
+        await sleep(delaySeconds * 1000);
+        continue;
+      }
+
+      const frame = renderTui(lastSnapshot, state);
+      if (frame !== lastFrame || state.forceRefresh) {
+        process.stdout.write("\x1b[H\x1b[2J");
+        process.stdout.write(frame);
+        lastFrame = frame;
+        state.forceRefresh = false;
+      }
+
+      await sleep(pollMs);
+    }
+  } finally {
+    process.stdin.off("data", onData);
+    process.stdin.setRawMode(false);
+    process.stdin.pause();
+    leaveAlternateScreen();
+  }
+
+  return 0;
+}

package/src/dashboard_web.mjs

@@ -0,0 +1,351 @@
+import fs from "node:fs";
+import http from "node:http";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import {
+  ensureDir,
+  fileExists,
+  nowIso,
+  readJson,
+  sleep,
+  tailText,
+  writeJson,
+} from "./common.mjs";
+import { collectDashboardSnapshot, buildDashboardSnapshotSignature } from "./dashboard_command.mjs";
+import { renderDashboardWebHtml } from "./dashboard_web_page.mjs";
+import { resolveUserSettingsHome } from "./engine_selection_settings.mjs";
+import { spawnNodeProcess } from "./node_process_launch.mjs";
+
+const DEFAULT_BIND = "127.0.0.1";
+const DEFAULT_PORT = 3210;
+const WEB_SERVER_ENV = "HELLOLOOP_WEB_SERVER_ACTIVE";
+const BUNDLE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+function dashboardRuntimeRoot() {
+  return path.join(resolveUserSettingsHome(), "runtime", "web-dashboard");
+}
+
+function dashboardRuntimeFiles() {
+  const root = dashboardRuntimeRoot();
+  ensureDir(root);
+  return {
+    root,
+    stateFile: path.join(root, "server.json"),
+    stdoutFile: path.join(root, "server-stdout.log"),
+    stderrFile: path.join(root, "server-stderr.log"),
+  };
+}
+
+function readJsonIfExists(filePath) {
+  try {
+    return filePath && fileExists(filePath) ? readJson(filePath) : null;
+  } catch {
+    return null;
+  }
+}
+
+function isPidAlive(pid) {
+  const value = Number(pid || 0);
+  if (!Number.isFinite(value) || value <= 0) {
+    return false;
+  }
+  try {
+    process.kill(value, 0);
+    return true;
+  } catch (error) {
+    return String(error?.code || "") === "EPERM";
+  }
+}
+
+function normalizeBind(value) {
+  const bind = String(value || "").trim();
+  return bind || DEFAULT_BIND;
+}
+
+function normalizePort(value) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 0 || parsed > 65535) {
+    return DEFAULT_PORT;
+  }
+  return parsed;
+}
+
+function writeWebServerState(patch) {
+  const files = dashboardRuntimeFiles();
+  const current = readJsonIfExists(files.stateFile) || {};
+  writeJson(files.stateFile, {
+    ...current,
+    ...patch,
+    updatedAt: nowIso(),
+  });
+}
+
+function readWebServerState() {
+  const files = dashboardRuntimeFiles();
+  const state = readJsonIfExists(files.stateFile);
+  if (!state) {
+    return null;
+  }
+  if (!isPidAlive(state.pid)) {
+    try {
+      fs.rmSync(files.stateFile, { force: true });
+    } catch {
+      // ignore stale state cleanup failure
+    }
+    return null;
+  }
+  return state;
+}
+
+function removeWebServerStateIfOwned(pid) {
+  const files = dashboardRuntimeFiles();
+  const state = readJsonIfExists(files.stateFile);
+  if (state?.pid === pid) {
+    try {
+      fs.rmSync(files.stateFile, { force: true });
+    } catch {
+      // ignore cleanup failure
+    }
+  }
+}
+
+function buildWebUrl(bind, port) {
+  return `http://${bind}:${port}`;
+}
+
+function renderStartSummary(state) {
+  return [
+    "HelloLoop Web Dashboard 已启动",
+    `- 地址：${state.url}`,
+    `- PID：${state.pid}`,
+    `- 监听：${state.bind}:${state.port}`,
+  ].join("\n");
+}
+
+function renderExistingSummary(state) {
+  return [
+    "HelloLoop Web Dashboard 已在运行",
+    `- 地址：${state.url}`,
+    `- PID：${state.pid}`,
+  ].join("\n");
+}
+
+async function waitForWebServerLaunch(launchId, timeoutMs = 8000) {
+  const files = dashboardRuntimeFiles();
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const state = readJsonIfExists(files.stateFile);
+    if (state?.launchId === launchId && isPidAlive(state.pid)) {
+      return state;
+    }
+    await sleep(150);
+  }
+  const stderr = fileExists(files.stderrFile) ? fs.readFileSync(files.stderrFile, "utf8") : "";
+  throw new Error(tailText(stderr, 40) || "HelloLoop Web Dashboard 启动超时。");
+}
+
+async function stopWebDashboardServer() {
+  const state = readWebServerState();
+  if (!state) {
+    console.log("HelloLoop Web Dashboard 当前未运行。");
+    return 0;
+  }
+
+  try {
+    process.kill(state.pid);
+  } catch {
+    // ignore if already down
+  }
+
+  const deadline = Date.now() + 5000;
+  while (Date.now() < deadline) {
+    if (!isPidAlive(state.pid)) {
+      removeWebServerStateIfOwned(state.pid);
+      console.log(`HelloLoop Web Dashboard 已停止：${state.url}`);
+      return 0;
+    }
+    await sleep(150);
+  }
+
+  throw new Error(`HelloLoop Web Dashboard 停止超时：pid=${state.pid}`);
+}
+
+function sendJson(response, statusCode, payload) {
+  response.writeHead(statusCode, {
+    "Content-Type": "application/json; charset=utf-8",
+    "Cache-Control": "no-store",
+  });
+  response.end(`${JSON.stringify(payload, null, 2)}\n`);
+}
+
+function createSseClient(response, snapshot) {
+  let previousSignature = "";
+  response.writeHead(200, {
+    "Content-Type": "text/event-stream; charset=utf-8",
+    "Cache-Control": "no-cache, no-transform",
+    Connection: "keep-alive",
+  });
+  response.write(`data: ${JSON.stringify(snapshot)}\n\n`);
+  previousSignature = buildDashboardSnapshotSignature(snapshot);
+  return {
+    push(nextSnapshot) {
+      const nextSignature = buildDashboardSnapshotSignature(nextSnapshot);
+      if (nextSignature === previousSignature) {
+        return;
+      }
+      previousSignature = nextSignature;
+      response.write(`data: ${JSON.stringify(nextSnapshot)}\n\n`);
+    },
+  };
+}
+
+async function startWebDashboardServer(options = {}) {
+  const files = dashboardRuntimeFiles();
+  const bind = normalizeBind(options.bind);
+  const preferredPort = normalizePort(options.port);
+  const pollMs = Math.max(500, Number(options.pollMs || options.watchPollMs || 1500));
+  const initialSnapshot = collectDashboardSnapshot();
+  const clients = new Set();
+  let lastSnapshot = initialSnapshot;
+
+  const server = http.createServer((request, response) => {
+    const url = new URL(request.url || "/", buildWebUrl(bind, preferredPort));
+    if (url.pathname === "/api/snapshot") {
+      sendJson(response, 200, collectDashboardSnapshot());
+      return;
+    }
+    if (url.pathname === "/events") {
+      const client = createSseClient(response, lastSnapshot);
+      clients.add(client);
+      request.on("close", () => clients.delete(client));
+      return;
+    }
+    if (url.pathname === "/healthz") {
+      sendJson(response, 200, { ok: true, generatedAt: nowIso() });
+      return;
+    }
+    response.writeHead(200, {
+      "Content-Type": "text/html; charset=utf-8",
+      "Cache-Control": "no-store",
+    });
+    response.end(renderDashboardWebHtml({
+      initialSnapshot: lastSnapshot,
+    }));
+  });
+
+  let settledPort = preferredPort;
+  await new Promise((resolve, reject) => {
+    const onError = (error) => {
+      if (String(error?.code || "") === "EADDRINUSE" && !options.port) {
+        server.off("error", onError);
+        server.listen(0, bind, resolve);
+        return;
+      }
+      reject(error);
+    };
+    server.once("error", onError);
+    server.listen(preferredPort, bind, resolve);
+  });
+  const address = server.address();
+  settledPort = Number(address?.port || preferredPort);
+  const state = {
+    pid: process.pid,
+    bind,
+    port: settledPort,
+    url: buildWebUrl(bind, settledPort),
+    startedAt: nowIso(),
+    launchId: String(options.launchId || "").trim(),
+    pollMs,
+  };
+  writeWebServerState(state);
+
+  const timer = setInterval(() => {
+    lastSnapshot = collectDashboardSnapshot();
+    writeWebServerState({
+      ...state,
+      generatedAt: lastSnapshot.generatedAt,
+    });
+    for (const client of clients) {
+      client.push(lastSnapshot);
+    }
+  }, pollMs);
+
+  const shutdown = () => {
+    clearInterval(timer);
+    server.close(() => {
+      removeWebServerStateIfOwned(process.pid);
+      process.exit(0);
+    });
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+
+  console.log(renderStartSummary({
+    ...state,
+    url: buildWebUrl(bind, settledPort),
+  }));
+}
+
+async function launchWebDashboardServer(options = {}) {
+  const existing = readWebServerState();
+  if (existing) {
+    console.log(renderExistingSummary(existing));
+    return 0;
+  }
+
+  const files = dashboardRuntimeFiles();
+  const launchId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const stdoutFd = fs.openSync(files.stdoutFile, "w");
+  const stderrFd = fs.openSync(files.stderrFile, "w");
+
+  try {
+    const args = [
+      path.join(BUNDLE_ROOT, "bin", "helloloop.js"),
+      "__web-server",
+      "--bind",
+      normalizeBind(options.bind),
+      "--launch-id",
+      launchId,
+      "--poll-ms",
+      String(Math.max(500, Number(options.pollMs || options.watchPollMs || 1500))),
+    ];
+    if (options.port !== undefined && options.port !== null && options.port !== "") {
+      args.push("--port", String(options.port));
+    }
+
+    const child = spawnNodeProcess({
+      args,
+      cwd: process.cwd(),
+      detached: true,
+      stdio: ["ignore", stdoutFd, stderrFd],
+      env: {
+        [WEB_SERVER_ENV]: "1",
+      },
+    });
+    child.unref();
+  } finally {
+    fs.closeSync(stdoutFd);
+    fs.closeSync(stderrFd);
+  }
+
+  const state = await waitForWebServerLaunch(launchId);
+  console.log(renderStartSummary(state));
+  return 0;
+}
+
+export async function runDashboardWebCommand(options = {}) {
+  if (options.stop === true) {
+    return stopWebDashboardServer();
+  }
+  const existing = readWebServerState();
+  if (existing) {
+    console.log(renderExistingSummary(existing));
+    return 0;
+  }
+  if (options.foreground === true || process.env[WEB_SERVER_ENV] === "1") {
+    await startWebDashboardServer(options);
+    return 0;
+  }
+  return launchWebDashboardServer(options);
+}