@h-rig/server 0.0.6-alpha.3 → 0.0.6-alpha.31

package/dist/src/server-helpers/inspector-jobs.js

@@ -3973,21 +3973,10 @@ async function runInspectorLocalReview(projectRoot, input) {
       details: null
     };
   }
-  const [{ RuntimeEventBus }, { PluginManager }, { verifyTask }] = await Promise.all([
-    import("@rig/runtime/control-plane/runtime/events"),
-    import("@rig/runtime/control-plane/runtime/plugins"),
-    import("@rig/runtime/control-plane/native/verifier")
-  ]);
-  const eventBus = new RuntimeEventBus({ projectRoot, runId: `inspector-review:${taskId}` });
-  const plugins = await PluginManager.load({
-    projectRoot,
-    runId: `inspector-review:${taskId}`,
-    eventBus
-  });
+  const { verifyTask } = await import("@rig/runtime/control-plane/native/verifier");
   const outcome = await verifyTask({
     projectRoot,
     taskId,
-    plugins,
     skipAiReview: true
   });
   return {

package/dist/src/server-helpers/issue-analysis.js

@@ -1,6 +1,5 @@
 // @bun
 // packages/server/src/server-helpers/issue-analysis.ts
-import { execFile } from "child_process";
 import { createHash } from "crypto";
 function stableIssueHash(issue) {
   const labels = Array.isArray(issue.labels) ? [...issue.labels].map(String).sort() : [];
@@ -134,16 +133,33 @@ function parseIssueAnalysisResult(raw) {
   return result;
 }
 function createDefaultPiIssueAnalysisCommandRunner() {
-  return (command, args, options) => new Promise((resolve) => {
-    execFile(command, [...args], {
-      timeout: options.timeoutMs,
-      maxBuffer: 10 * 1024 * 1024,
-      env: options.env ? { ...process.env, ...options.env } : process.env
-    }, (error, stdout, stderr) => {
-      const exitCode = typeof error?.code === "number" ? error.code : error ? 1 : 0;
-      resolve({ exitCode, stdout: String(stdout ?? ""), stderr: String(stderr ?? "") });
+  return async (command, args, options) => {
+    const env = options.env ? { ...process.env, ...options.env } : process.env;
+    const proc = Bun.spawn([command, ...args], {
+      stdout: "pipe",
+      stderr: "pipe",
+      env
     });
-  });
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      proc.kill();
+    }, options.timeoutMs);
+    try {
+      const [stdout, stderr, exitCode] = await Promise.all([
+        new Response(proc.stdout).text(),
+        new Response(proc.stderr).text(),
+        proc.exited
+      ]);
+      return {
+        exitCode: timedOut && exitCode === 0 ? 1 : exitCode,
+        stdout,
+        stderr: timedOut && stderr.trim().length === 0 ? `Pi issue analysis timed out after ${options.timeoutMs}ms` : stderr
+      };
+    } finally {
+      clearTimeout(timer);
+    }
+  };
 }
 function createPiIssueAnalyzer(input = {}) {
   const piBinary = input.piBinary ?? process.env.RIG_ISSUE_ANALYSIS_PI_BINARY ?? "pi";

package/dist/src/server-helpers/pi-session-proxy.js

@@ -0,0 +1,84 @@
+// @bun
+// packages/server/src/server-helpers/pi-session-proxy.ts
+import { readAuthorityRun as readAuthorityRun2 } from "@rig/runtime/control-plane/authority-files";
+
+// packages/server/src/server-helpers/run-io.ts
+import {
+  listAuthorityRuns,
+  readAuthorityRun,
+  readJsonlFile,
+  resolveAuthorityRunDir
+} from "@rig/runtime/control-plane/authority-files";
+function readRunPiSessionMetadata(projectRoot, runId) {
+  const run = readAuthorityRun(projectRoot, runId);
+  const metadata = run?.piSessionPrivate;
+  if (!metadata || typeof metadata !== "object" || Array.isArray(metadata))
+    return null;
+  const record = metadata;
+  const publicMetadata = record.public;
+  const daemonConnection = record.daemonConnection;
+  if (!publicMetadata || typeof publicMetadata !== "object" || Array.isArray(publicMetadata))
+    return null;
+  if (!daemonConnection || typeof daemonConnection !== "object" || Array.isArray(daemonConnection))
+    return null;
+  return metadata;
+}
+var INITIAL_RUN_LOG_TAIL_MAX_BYTES = 8 * 1024 * 1024;
+
+// packages/server/src/server-helpers/pi-session-proxy.ts
+function resolveRunPiSessionProxy(projectRoot, runId) {
+  const run = readAuthorityRun2(projectRoot, runId);
+  if (!run)
+    return null;
+  const privateMetadata = readRunPiSessionMetadata(projectRoot, runId);
+  if (!privateMetadata)
+    return { pending: true, runId, status: typeof run.status === "string" ? run.status : undefined };
+  const connection = privateMetadata.daemonConnection;
+  if (connection.mode !== "http")
+    throw new Error("Only loopback HTTP Rig Pi session daemon connections are supported");
+  const token = tokenFromRef(connection.tokenRef);
+  if (!token)
+    throw new Error("Rig Pi session daemon token is unavailable");
+  return {
+    runId,
+    sessionId: privateMetadata.public.sessionId,
+    metadata: privateMetadata.public,
+    privateMetadata,
+    baseUrl: connection.baseUrl.replace(/\/+$/, ""),
+    token
+  };
+}
+async function proxyRunPiHttp(projectRoot, runId, input) {
+  const resolved = resolveRunPiSessionProxy(projectRoot, runId);
+  if (resolved === null)
+    return { status: 404, payload: { ok: false, error: "Run not found" } };
+  if ("pending" in resolved)
+    return { status: 409, payload: { ready: false, runId, status: resolved.status, retryAfterMs: 500 } };
+  const response = await fetch(`${resolved.baseUrl}${input.daemonPath}`, {
+    method: input.method,
+    headers: {
+      authorization: `Bearer ${resolved.token}`,
+      ...input.body === undefined ? {} : { "content-type": "application/json" }
+    },
+    body: input.body === undefined ? undefined : JSON.stringify(input.body)
+  });
+  const text = await response.text();
+  const payload = text.trim() ? JSON.parse(text) : null;
+  return { status: response.status, payload };
+}
+function buildRunPiDaemonWebSocketUrl(resolved) {
+  const url = new URL(`${resolved.baseUrl}/sessions/${encodeURIComponent(resolved.sessionId)}/events`);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  url.searchParams.set("token", resolved.token);
+  return url.toString();
+}
+function tokenFromRef(ref) {
+  if (ref.startsWith("inline:"))
+    return ref.slice("inline:".length) || null;
+  return null;
+}
+export {
+  resolveRunPiSessionProxy,
+  proxyRunPiHttp,
+  buildRunPiDaemonWebSocketUrl
+};

package/dist/src/server-helpers/project-registry.js

@@ -115,8 +115,13 @@ function upsertProjectRecord(projectRoot, input) {
 function linkProjectCheckout(projectRoot, repoSlug, checkout) {
   return upsertProjectRecord(projectRoot, { repoSlug, checkout });
 }
+function projectRegistryContainsCheckout(projectRoot, checkoutPath) {
+  const target = resolve(checkoutPath);
+  return Object.values(readRegistry(projectRoot)).some((project) => project.checkouts.some((checkout) => checkout.path ? resolve(checkout.path) === target : false));
+}
 export {
   upsertProjectRecord,
+  projectRegistryContainsCheckout,
   normalizeRepoSlug,
   linkProjectCheckout,
   getProjectRecord,

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

@@ -114,14 +114,29 @@ function summarizeUsefulRunError(projectRoot, runId, fallback) {
   const nonGeneric = errorLines.at(-1);
   return nonGeneric ?? (typeof fallback === "string" ? fallback : null);
 }
+function readRunPiSessionMetadata(projectRoot, runId) {
+  const run = readAuthorityRun(projectRoot, runId);
+  const metadata = run?.piSessionPrivate;
+  if (!metadata || typeof metadata !== "object" || Array.isArray(metadata))
+    return null;
+  const record = metadata;
+  const publicMetadata = record.public;
+  const daemonConnection = record.daemonConnection;
+  if (!publicMetadata || typeof publicMetadata !== "object" || Array.isArray(publicMetadata))
+    return null;
+  if (!daemonConnection || typeof daemonConnection !== "object" || Array.isArray(daemonConnection))
+    return null;
+  return metadata;
+}
 function readRunDetails(projectRoot, runId) {
   const run = readAuthorityRun(projectRoot, runId);
   if (!run) {
     return null;
   }
   const usefulErrorText = isGenericRunFailure(run.errorText) ? summarizeUsefulRunError(projectRoot, runId, run.errorText) : null;
+  const { piSessionPrivate: _piSessionPrivate, ...publicRun } = run;
   return {
-    run: usefulErrorText ? { ...run, errorText: usefulErrorText } : run,
+    run: usefulErrorText ? { ...publicRun, errorText: usefulErrorText } : publicRun,
     timeline: readJsonlFile(resolve(resolveAuthorityRunDir(projectRoot, runId), "timeline.jsonl")),
     approvals: readApprovals(projectRoot, { runId }),
     userInputs: readUserInputs(projectRoot, { runId })
@@ -167,6 +182,18 @@ function readJsonlFileTail(path, options) {
 function readRawRunLogs(projectRoot, runId) {
   return readJsonlFile(runLogsPath(projectRoot, runId)).filter((entry) => Boolean(entry && typeof entry === "object"));
 }
+async function readRunTimelinePage(projectRoot, runId, options = {}) {
+  const limit = Math.max(1, Math.min(Math.trunc(options.limit ?? 200), 500));
+  const cursor = options.cursor == null ? 0 : Number.parseInt(options.cursor, 10);
+  const entries = readJsonlFile(runTimelinePath(projectRoot, runId)).filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry)));
+  const startInclusive = Number.isFinite(cursor) ? Math.max(0, Math.min(cursor, entries.length)) : 0;
+  const endExclusive = Math.min(entries.length, startInclusive + limit);
+  return {
+    entries: entries.slice(startInclusive, endExclusive).map((entry, offset) => ({ ...entry, cursor: startInclusive + offset + 1 })),
+    nextCursor: String(endExclusive),
+    hasMore: endExclusive < entries.length
+  };
+}
 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));
@@ -252,6 +279,8 @@ export {
   remoteArtifactsRoot,
   readUserInputsForRuns,
   readUserInputs,
+  readRunTimelinePage,
+  readRunPiSessionMetadata,
   readRunLogsPage,
   readRunDetails,
   readRawRunLogs,