@h-rig/server 0.0.6-alpha.0

package/dist/src/server-helpers/run-io.js

@@ -0,0 +1,262 @@
+// @bun
+// packages/server/src/server-helpers/run-io.ts
+import { dirname, resolve } from "path";
+import { closeSync, existsSync, mkdirSync, openSync, readSync, statSync, writeFileSync } from "fs";
+import { createReadStream } from "fs";
+import { createInterface } from "readline";
+import {
+  listAuthorityRuns,
+  readAuthorityRun,
+  readJsonlFile,
+  resolveAuthorityRunDir
+} from "@rig/runtime/control-plane/authority-files";
+
+// packages/server/src/server-helpers/normalizers.ts
+function normalizeString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+
+// packages/server/src/server-helpers/run-io.ts
+function matchesRunFilter(entry, filter) {
+  return (!filter.runId || entry.runId === filter.runId) && (!filter.taskId || entry.taskId === filter.taskId);
+}
+function readApprovalsForRuns(projectRoot, runs, filter = {}) {
+  return runs.filter((entry) => matchesRunFilter(entry, filter)).flatMap((entry) => readJsonlFile(resolve(resolveAuthorityRunDir(projectRoot, entry.runId), "approvals.jsonl")).flatMap((record) => {
+    if (!record || typeof record !== "object") {
+      return [];
+    }
+    const value = record;
+    return [
+      {
+        runId: entry.runId,
+        taskId: entry.taskId,
+        requestId: normalizeString(value.requestId) ?? normalizeString(value.id),
+        status: normalizeString(value.status),
+        record: value
+      }
+    ];
+  }));
+}
+function readApprovals(projectRoot, filter = {}) {
+  return readApprovalsForRuns(projectRoot, listAuthorityRuns(projectRoot), filter);
+}
+function readUserInputsForRuns(projectRoot, runs, filter = {}) {
+  return runs.filter((entry) => matchesRunFilter(entry, filter)).flatMap((entry) => readJsonlFile(resolve(resolveAuthorityRunDir(projectRoot, entry.runId), "user-input.jsonl")).flatMap((record) => {
+    if (!record || typeof record !== "object") {
+      return [];
+    }
+    const value = record;
+    return [
+      {
+        runId: entry.runId,
+        taskId: entry.taskId,
+        requestId: normalizeString(value.requestId) ?? normalizeString(value.id),
+        status: normalizeString(value.status),
+        record: value
+      }
+    ];
+  }));
+}
+function readUserInputs(projectRoot, filter = {}) {
+  return readUserInputsForRuns(projectRoot, listAuthorityRuns(projectRoot), filter);
+}
+function writeRunJsonlFile(projectRoot, runId, fileName, rows) {
+  const filePath = resolve(resolveAuthorityRunDir(projectRoot, runId), fileName);
+  mkdirSync(dirname(filePath), { recursive: true });
+  const next = rows.map((row) => JSON.stringify(row)).join(`
+`);
+  writeFileSync(filePath, next.length > 0 ? `${next}
+` : "", "utf8");
+}
+function resolveApproval(projectRoot, input) {
+  const approvalsPath = resolve(resolveAuthorityRunDir(projectRoot, input.runId), "approvals.jsonl");
+  const approvals = readJsonlFile(approvalsPath);
+  const resolvedAt = new Date().toISOString();
+  const rows = approvals.map((entry) => entry.requestId === input.requestId || entry.id === input.requestId ? {
+    ...entry,
+    status: "resolved",
+    decision: input.decision,
+    note: input.note ?? null,
+    resolvedAt
+  } : entry);
+  writeRunJsonlFile(projectRoot, input.runId, "approvals.jsonl", rows);
+  return { ok: true, runId: input.runId, requestId: input.requestId, decision: input.decision };
+}
+function respondToUserInput(projectRoot, input) {
+  const requestsPath = resolve(resolveAuthorityRunDir(projectRoot, input.runId), "user-input.jsonl");
+  const requests = readJsonlFile(requestsPath);
+  const resolvedAt = new Date().toISOString();
+  const rows = requests.map((entry) => entry.requestId === input.requestId || entry.id === input.requestId ? {
+    ...entry,
+    status: "resolved",
+    answers: input.answers,
+    respondedAt: resolvedAt,
+    resolvedAt
+  } : entry);
+  writeRunJsonlFile(projectRoot, input.runId, "user-input.jsonl", rows);
+  return { ok: true, runId: input.runId, requestId: input.requestId, answers: input.answers };
+}
+function isGenericRunFailure(value) {
+  return typeof value === "string" && /^Task run failed \([^)]*\)$/i.test(value.trim());
+}
+function summarizeUsefulRunError(projectRoot, runId, fallback) {
+  const logs = readJsonlFileTail(runLogsPath(projectRoot, runId), { limit: 80, maxBytes: 512 * 1024 }).filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry)));
+  const errorLines = logs.filter((entry) => normalizeString(entry.tone) === "error" || normalizeString(entry.status) === "failed").map((entry) => normalizeString(entry.detail)).filter((entry) => Boolean(entry && !isGenericRunFailure(entry)));
+  const taskSourceFailure = errorLines.find((line) => /failed to update task source/i.test(line));
+  if (taskSourceFailure)
+    return `Task source update failed: ${taskSourceFailure}`;
+  const moduleFailure = errorLines.find((line) => /cannot find module/i.test(line));
+  if (moduleFailure)
+    return `Runtime module resolution failed: ${moduleFailure}`;
+  const providerFailure = errorLines.find((line) => /no api key found|unauthorized|authentication failed|invalid api key/i.test(line));
+  if (providerFailure)
+    return `Provider authentication failed: ${providerFailure}`;
+  const nonGeneric = errorLines.at(-1);
+  return nonGeneric ?? (typeof fallback === "string" ? fallback : null);
+}
+function readRunDetails(projectRoot, runId) {
+  const run = readAuthorityRun(projectRoot, runId);
+  if (!run) {
+    return null;
+  }
+  const usefulErrorText = isGenericRunFailure(run.errorText) ? summarizeUsefulRunError(projectRoot, runId, run.errorText) : null;
+  return {
+    run: usefulErrorText ? { ...run, errorText: usefulErrorText } : run,
+    timeline: readJsonlFile(resolve(resolveAuthorityRunDir(projectRoot, runId), "timeline.jsonl")),
+    approvals: readApprovals(projectRoot, { runId }),
+    userInputs: readUserInputs(projectRoot, { runId })
+  };
+}
+function runTimelinePath(projectRoot, runId) {
+  return resolve(resolveAuthorityRunDir(projectRoot, runId), "timeline.jsonl");
+}
+function runLogsPath(projectRoot, runId) {
+  return resolve(resolveAuthorityRunDir(projectRoot, runId), "logs.jsonl");
+}
+function parseJsonlRecords(lines) {
+  return lines.map((line) => line.trim()).filter(Boolean).flatMap((line) => {
+    try {
+      return [JSON.parse(line)];
+    } catch {
+      return [];
+    }
+  });
+}
+function readJsonlFileTail(path, options) {
+  const limit = Math.max(0, Math.trunc(options.limit));
+  if (limit === 0 || !existsSync(path))
+    return [];
+  const maxBytes = Math.max(1024, Math.trunc(options.maxBytes ?? 256 * 1024));
+  const size = statSync(path).size;
+  if (size === 0)
+    return [];
+  const start = Math.max(0, size - maxBytes);
+  const length = size - start;
+  const buffer = Buffer.alloc(length);
+  const fd = openSync(path, "r");
+  try {
+    readSync(fd, buffer, 0, length, start);
+  } finally {
+    closeSync(fd);
+  }
+  const text = buffer.toString("utf8");
+  const lines = text.split(/\r?\n/);
+  const completeLines = start > 0 ? lines.slice(1) : lines;
+  return parseJsonlRecords(completeLines.filter(Boolean).slice(-limit));
+}
+function readRawRunLogs(projectRoot, runId) {
+  return readJsonlFile(runLogsPath(projectRoot, runId)).filter((entry) => Boolean(entry && typeof entry === "object"));
+}
+var INITIAL_RUN_LOG_TAIL_MAX_BYTES = 8 * 1024 * 1024;
+async function readRunLogsPage(projectRoot, runId, options = {}) {
+  const limit = Math.max(1, Math.min(Math.trunc(options.limit ?? 200), 500));
+  const cursor = options.cursor == null ? null : Number.parseInt(options.cursor, 10);
+  const logsPath = runLogsPath(projectRoot, runId);
+  if ((options.cursor == null || !Number.isFinite(cursor)) && existsSync(logsPath)) {
+    const size = statSync(logsPath).size;
+    if (size > INITIAL_RUN_LOG_TAIL_MAX_BYTES) {
+      const tail = readJsonlFileTail(logsPath, {
+        limit,
+        maxBytes: INITIAL_RUN_LOG_TAIL_MAX_BYTES
+      }).filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry)));
+      return {
+        entries: tail.toReversed(),
+        nextCursor: null,
+        hasMore: true
+      };
+    }
+  }
+  const endExclusive = cursor == null || !Number.isFinite(cursor) ? Number.POSITIVE_INFINITY : Math.max(0, cursor);
+  const window = [];
+  let index = 0;
+  let hasMore = false;
+  const stream = createReadStream(logsPath, { encoding: "utf8" });
+  stream.on("error", (error) => {
+    if (error.code !== "ENOENT") {
+      stream.destroy(error);
+    }
+  });
+  const lines = createInterface({ input: stream, crlfDelay: Infinity });
+  try {
+    for await (const line of lines) {
+      const currentIndex = index;
+      index += 1;
+      if (currentIndex >= endExclusive) {
+        break;
+      }
+      const trimmed = line.trim();
+      if (trimmed.length === 0) {
+        continue;
+      }
+      try {
+        const parsed = JSON.parse(trimmed);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+          window.push({ index: currentIndex, entry: parsed });
+        }
+      } catch {
+        window.push({
+          index: currentIndex,
+          entry: { title: "Unparsed log line", detail: line, tone: "info" }
+        });
+      }
+      if (window.length > limit) {
+        window.shift();
+        hasMore = true;
+      }
+    }
+  } catch (error) {
+    const code = error.code;
+    if (code !== "ENOENT") {
+      throw error;
+    }
+  }
+  return {
+    entries: window.toReversed().map((item) => item.entry),
+    nextCursor: hasMore ? String(window[0]?.index ?? 0) : null,
+    hasMore
+  };
+}
+function readLatestRawRunLog(projectRoot, runId) {
+  const logs = readJsonlFileTail(runLogsPath(projectRoot, runId), { limit: 20 });
+  return logs.findLast((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry))) ?? null;
+}
+function remoteArtifactsRoot(projectRoot, runId) {
+  return resolve(resolveAuthorityRunDir(projectRoot, runId), "remote-artifacts");
+}
+export {
+  writeRunJsonlFile,
+  runTimelinePath,
+  runLogsPath,
+  respondToUserInput,
+  resolveApproval,
+  remoteArtifactsRoot,
+  readUserInputsForRuns,
+  readUserInputs,
+  readRunLogsPage,
+  readRunDetails,
+  readRawRunLogs,
+  readLatestRawRunLog,
+  readJsonlFileTail,
+  readApprovalsForRuns,
+  readApprovals
+};