@h-rig/server 0.0.6-alpha.13 → 0.0.6-alpha.15

package/dist/src/server-helpers/github-project-status-sync.js

@@ -116,6 +116,7 @@ var DEFAULT_PROJECT_STATUSES = {
   running: "In Progress",
   prOpen: "In Review",
   ciFixing: "In Review",
+  merging: "Merging",
   done: "Done",
   needsAttention: "Needs Attention"
 };
@@ -129,6 +130,8 @@ function lifecycleStatusForTaskStatus(status) {
     return "prOpen";
   if (normalized === "ci_fixing" || normalized === "fixing")
     return "ciFixing";
+  if (normalized === "merging" || normalized === "merge")
+    return "merging";
   if (normalized === "failed" || normalized === "needs_attention" || normalized === "blocked")
     return "needsAttention";
   if (normalized === "in_progress" || normalized === "running" || normalized === "ready" || normalized === "open")

package/dist/src/server-helpers/http-router.js

@@ -224,6 +224,18 @@ function readJsonlFileTail(path, options) {
   const completeLines = start > 0 ? lines.slice(1) : lines;
   return parseJsonlRecords(completeLines.filter(Boolean).slice(-limit));
 }
+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));
@@ -788,6 +800,11 @@ import {
   buildTaskRunLifecycleComment,
   updateConfiguredTaskSourceTask
 } from "@rig/runtime/control-plane/tasks/source-lifecycle";
+import {
+  closeIssueAfterMergedPr,
+  commitRunChanges,
+  runPrAutomation
+} from "@rig/runtime/control-plane/native/pr-automation";
 
 // packages/server/src/scheduler.ts
 import { normalizeTaskLifecycleStatus } from "@rig/runtime/control-plane/state-sync/types";
@@ -1027,6 +1044,9 @@ function asRecord(value) {
 function asString(value) {
   return typeof value === "string" && value.trim().length > 0 ? value : undefined;
 }
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
 async function defaultGraphQLFetch(query, variables, token) {
   const response = await fetch("https://api.github.com/graphql", {
     method: "POST",
@@ -1043,6 +1063,32 @@ async function defaultGraphQLFetch(query, variables, token) {
   }
   return json.data;
 }
+function projectNodesFrom(data) {
+  const root = asRecord(data);
+  const owner = asRecord(root?.organization) ?? asRecord(root?.user);
+  const projects = asRecord(owner?.projectsV2);
+  const nodes = projects?.nodes;
+  return Array.isArray(nodes) ? nodes : [];
+}
+async function listGitHubProjects(input) {
+  const query = `
+    query RigListProjects($owner: String!, $first: Int!) {
+      organization(login: $owner) { projectsV2(first: $first, orderBy: { field: UPDATED_AT, direction: DESC }) { nodes { id number title url } } }
+      user(login: $owner) { projectsV2(first: $first, orderBy: { field: UPDATED_AT, direction: DESC }) { nodes { id number title url } } }
+    }
+  `;
+  const fetchGraphQL = input.fetchGraphQL ?? defaultGraphQLFetch;
+  const data = await fetchGraphQL(query, { owner: input.owner, first: input.first ?? 20 }, input.token);
+  return projectNodesFrom(data).flatMap((node) => {
+    const record = asRecord(node);
+    const id = asString(record?.id);
+    const number = asNumber(record?.number);
+    const title = asString(record?.title);
+    if (!id || number === undefined || !title)
+      return [];
+    return [{ id, number, title, ...asString(record?.url) ? { url: asString(record?.url) } : {} }];
+  });
+}
 async function resolveProjectStatusField(input) {
   const query = `
     query RigProjectStatusField($projectId: ID!) {
@@ -1137,6 +1183,7 @@ var DEFAULT_PROJECT_STATUSES = {
   running: "In Progress",
   prOpen: "In Review",
   ciFixing: "In Review",
+  merging: "Merging",
   done: "Done",
   needsAttention: "Needs Attention"
 };
@@ -1150,6 +1197,8 @@ function lifecycleStatusForTaskStatus(status) {
     return "prOpen";
   if (normalized === "ci_fixing" || normalized === "fixing")
     return "ciFixing";
+  if (normalized === "merging" || normalized === "merge")
+    return "merging";
   if (normalized === "failed" || normalized === "needs_attention" || normalized === "blocked")
     return "needsAttention";
   if (normalized === "in_progress" || normalized === "running" || normalized === "ready" || normalized === "open")
@@ -1225,7 +1274,8 @@ var TERMINAL_RUN_STATUSES2 = new Set([
   "needs-attention",
   "stopped"
 ]);
-var RESUMABLE_LOCAL_RUN_STATUSES = new Set(["created", "preparing", "running", "validating", "reviewing"]);
+var RESUMABLE_SERVER_CLOSEOUT_STATUSES = new Set(["pending", "running"]);
+var ACTIVE_LOCAL_RUN_STATUSES = new Set(["created", "preparing", "running", "validating", "reviewing"]);
 
 // packages/server/src/server-helpers/ws-router.ts
 import {
@@ -2000,6 +2050,75 @@ function buildProjectConfigStatus(root) {
     suggestion: kind === "missing" ? "Run `rig init` in the project root to scaffold rig.config.ts." : null
   };
 }
+var RIG_GITHUB_LIFECYCLE_LABELS = [
+  "ready",
+  "blocked",
+  "in-progress",
+  "under-review",
+  "failed",
+  "cancelled",
+  "rig:running",
+  "rig:pr-open",
+  "rig:ci-fixing",
+  "rig:merging",
+  "rig:done",
+  "rig:needs-attention"
+];
+function githubProjectsEnabled(config) {
+  if (!config || typeof config !== "object" || Array.isArray(config))
+    return false;
+  const root = config;
+  const github = root.github && typeof root.github === "object" && !Array.isArray(root.github) ? root.github : null;
+  const projects = github?.projects && typeof github.projects === "object" && !Array.isArray(github.projects) ? github.projects : null;
+  return projects?.enabled === true;
+}
+function githubIssueSourceRepo(config) {
+  if (!config || typeof config !== "object" || Array.isArray(config))
+    return null;
+  const root = config;
+  const taskSource = root.taskSource && typeof root.taskSource === "object" && !Array.isArray(root.taskSource) ? root.taskSource : null;
+  const owner = normalizeString(taskSource?.owner);
+  const repo = normalizeString(taskSource?.repo);
+  if (taskSource?.kind === "github-issues" && owner && repo)
+    return { owner, repo };
+  const project = root.project && typeof root.project === "object" && !Array.isArray(root.project) ? root.project : null;
+  const slug = normalizeString(project?.repo) ?? normalizeString(project?.name);
+  const match = slug?.match(/^([^/]+)\/([^/]+)$/);
+  return match ? { owner: match[1], repo: match[2] } : null;
+}
+async function ensureGitHubLifecycleLabels(projectRoot, config) {
+  const repo = githubIssueSourceRepo(config);
+  if (!repo)
+    return { ok: false, ready: false, labelsReady: false, reason: "not-github-issues-source", labels: RIG_GITHUB_LIFECYCLE_LABELS };
+  const token = createGitHubAuthStore(projectRoot).readToken();
+  if (!token)
+    return { ok: false, ready: false, labelsReady: false, reason: "missing-token", repo, labels: RIG_GITHUB_LIFECYCLE_LABELS };
+  const existingResponse = await fetch(`https://api.github.com/repos/${repo.owner}/${repo.repo}/labels?per_page=100`, {
+    headers: { accept: "application/vnd.github+json", authorization: `Bearer ${token}`, "user-agent": "rig-server" }
+  });
+  const existingJson = await existingResponse.json().catch(() => []);
+  const existing = new Set(Array.isArray(existingJson) ? existingJson.flatMap((entry) => entry && typeof entry === "object" && typeof entry.name === "string" ? [entry.name] : []) : []);
+  const created = [];
+  const alreadyPresent = [];
+  const failed = [];
+  for (const label of RIG_GITHUB_LIFECYCLE_LABELS) {
+    if (existing.has(label)) {
+      alreadyPresent.push(label);
+      continue;
+    }
+    const response = await fetch(`https://api.github.com/repos/${repo.owner}/${repo.repo}/labels`, {
+      method: "POST",
+      headers: { accept: "application/vnd.github+json", authorization: `Bearer ${token}`, "content-type": "application/json", "user-agent": "rig-server" },
+      body: JSON.stringify({ name: label, color: label.startsWith("rig:") ? "6f42c1" : "ededed", description: label.startsWith("rig:") ? "Task status managed by Rig" : "Task lifecycle status managed by Rig" })
+    });
+    if (response.ok || response.status === 422) {
+      (response.status === 422 ? alreadyPresent : created).push(label);
+    } else {
+      failed.push({ label, error: await response.text().catch(() => response.statusText) });
+    }
+  }
+  return { ok: failed.length === 0, ready: failed.length === 0, labelsReady: failed.length === 0, repo, labels: RIG_GITHUB_LIFECYCLE_LABELS, created, existing: alreadyPresent, failed };
+}
 function normalizeCommit(value) {
   const raw = normalizeString(value);
   return raw && /^[0-9a-f]{7,40}$/i.test(raw) ? raw : null;
@@ -2398,15 +2517,33 @@ say "Installing @h-rig/cli@latest"
 bun add -g @h-rig/cli@latest
 
 export BUN_INSTALL="\${BUN_INSTALL:-$HOME/.bun}"
-export PATH="$BUN_INSTALL/bin:$PATH"
+BUN_RIG="$BUN_INSTALL/bin/rig"
+if [ ! -x "$BUN_RIG" ]; then
+  printf 'rig-install: expected Bun global rig at %s but it was not executable.
+' "$BUN_RIG" >&2
+  exit 1
+fi
+
+USER_BIN="$HOME/.local/bin"
+mkdir -p "$USER_BIN"
+cat > "$USER_BIN/rig" <<'RIG_SHIM'
+#!/usr/bin/env bash
+set -euo pipefail
+exec "\${BUN_INSTALL:-$HOME/.bun}/bin/rig" "$@"
+RIG_SHIM
+chmod +x "$USER_BIN/rig"
+
+export PATH="$USER_BIN:$BUN_INSTALL/bin:$PATH"
+if command -v hash >/dev/null 2>&1; then hash -r; fi
 
 if ! command -v rig >/dev/null 2>&1; then
-  printf 'rig-install: rig installed, but rig is not on PATH. Add %s/bin to PATH and retry.
-' "$BUN_INSTALL" >&2
+  printf 'rig-install: rig installed, but rig is not on PATH. Add %s and %s/bin to PATH and retry.
+' "$USER_BIN" "$BUN_INSTALL" >&2
   exit 1
 fi
 
 say "Verifying rig"
+"$BUN_RIG" --help >/dev/null
 rig --help >/dev/null
 say "Done. Run: rig --help"
 `;
@@ -3145,16 +3282,12 @@ data: ${JSON.stringify({ connectedAt: new Date().toISOString() })}
           if (!source) {
             return deps.badRequest("No task source is configured");
           }
+          if (!source.updateTask && !(update.status && source.updateStatus)) {
+            return deps.badRequest("Configured task source does not support updates");
+          }
           const taskBeforeUpdate = source.get ? await source.get(id).catch(() => {
             return;
           }) : (await deps.snapshotService.getWorkspaceTasks().catch(() => [])).find((task) => task.id === id);
-          if (source.updateTask) {
-            await source.updateTask(id, update);
-          } else if (update.status && source.updateStatus) {
-            await source.updateStatus(id, update.status);
-          } else {
-            return deps.badRequest("Configured task source does not support updates");
-          }
           const issueNodeId = normalizeString(body.issueNodeId) ?? extractGitHubIssueNodeId(taskBeforeUpdate);
           const projectSync = update.status ? await syncGitHubProjectStatusForTaskUpdate({
             taskId: id,
@@ -3163,6 +3296,35 @@ data: ${JSON.stringify({ connectedAt: new Date().toISOString() })}
             token: createGitHubAuthStore(state.projectRoot).readToken(),
             config: ctx?.config
           }).catch((error) => ({ synced: false, reason: `error:${error instanceof Error ? error.message : String(error)}` })) : { synced: false, reason: "missing-status" };
+          if (update.status && githubProjectsEnabled(ctx?.config) && projectSync.synced === false) {
+            return deps.jsonResponse({ ok: false, id, projectSync, error: `GitHub Project status sync failed: ${String(projectSync.reason)}` }, 502);
+          }
+          try {
+            if (source.updateTask) {
+              await source.updateTask(id, update);
+            } else if (update.status && source.updateStatus) {
+              await source.updateStatus(id, update.status);
+            }
+          } catch (error) {
+            let rollback = null;
+            const previousStatus = normalizeString(taskBeforeUpdate?.status) ?? normalizeString(taskBeforeUpdate?.sourceStatus);
+            if (update.status && previousStatus && githubProjectsEnabled(ctx?.config) && projectSync.synced !== false) {
+              rollback = await syncGitHubProjectStatusForTaskUpdate({
+                taskId: id,
+                status: previousStatus,
+                issueNodeId,
+                token: createGitHubAuthStore(state.projectRoot).readToken(),
+                config: ctx?.config
+              }).catch((rollbackError) => ({ synced: false, reason: `rollback-error:${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}` }));
+            }
+            return deps.jsonResponse({
+              ok: false,
+              id,
+              projectSync,
+              rollback,
+              error: `Task source update failed: ${error instanceof Error ? error.message : String(error)}`
+            }, 502);
+          }
           deps.snapshotService.invalidate("github-issue-updated");
           await state.taskProjectionReconciler?.tick("github-issue-updated").catch(() => {
             return;
@@ -3171,25 +3333,40 @@ data: ${JSON.stringify({ connectedAt: new Date().toISOString() })}
           return deps.jsonResponse({ ok: true, id, projectSync });
         }
         if (url.pathname === "/api/workspace/task-labels") {
+          const ctx = await getCachedPluginHostContext(state.projectRoot).catch(() => null);
+          if (url.searchParams.get("ensure") === "1" || req.method === "POST") {
+            return deps.jsonResponse(await ensureGitHubLifecycleLabels(state.projectRoot, ctx?.config));
+          }
           return deps.jsonResponse({
             ok: true,
             ready: true,
             labelsReady: true,
-            labels: [
-              "ready",
-              "blocked",
-              "in-progress",
-              "under-review",
-              "failed",
-              "cancelled",
-              "rig:running",
-              "rig:pr-open",
-              "rig:ci-fixing",
-              "rig:done",
-              "rig:needs-attention"
-            ],
-            note: "GitHub issue lifecycle labels are created on demand by the configured task source when supported."
+            labels: [...RIG_GITHUB_LIFECYCLE_LABELS],
+            note: "Lifecycle labels are required during init; call POST /api/workspace/task-labels or ?ensure=1 to proactively create them."
+          });
+        }
+        if (url.pathname === "/api/github/projects" && req.method === "GET") {
+          const owner = normalizeString(url.searchParams.get("owner"));
+          if (!owner)
+            return deps.badRequest("owner is required");
+          const token = createGitHubAuthStore(state.projectRoot).readToken();
+          if (!token)
+            return deps.jsonResponse({ ok: false, error: "missing-token", projects: [] }, 401);
+          const projects = await listGitHubProjects({ owner, token }).catch((error) => {
+            throw new Error(error instanceof Error ? error.message : String(error));
           });
+          return deps.jsonResponse({ ok: true, projects });
+        }
+        const projectStatusMatch = url.pathname.match(/^\/api\/github\/projects\/([^/]+)\/status-field$/);
+        if (projectStatusMatch && req.method === "GET") {
+          const projectId = decodeURIComponent(projectStatusMatch[1]);
+          const token = createGitHubAuthStore(state.projectRoot).readToken();
+          if (!token)
+            return deps.jsonResponse({ ok: false, error: "missing-token" }, 401);
+          const field = await resolveProjectStatusField({ projectId, token }).catch((error) => {
+            throw new Error(error instanceof Error ? error.message : String(error));
+          });
+          return deps.jsonResponse({ ok: true, field });
         }
         if (url.pathname === "/api/workspace/issue-analysis/run" && req.method === "POST") {
           const body = await deps.readJsonBody(req);
@@ -4355,6 +4532,69 @@ data: ${JSON.stringify({ connectedAt: new Date().toISOString() })}
           }
           const run = leaseValidation.run;
           const completedAt = new Date().toISOString();
+          const workspaceDir = normalizeString(body.workspaceDir) ?? normalizeString(body.runtimeWorkspace) ?? normalizeString(run.worktreePath);
+          if (run.taskId && workspaceDir) {
+            patchRunRecord(state.projectRoot, runId, {
+              status: "reviewing",
+              completedAt: null,
+              hostId,
+              endpointId: leaseId,
+              worktreePath: workspaceDir,
+              serverCloseout: {
+                status: "pending",
+                phase: "queued",
+                requestedAt: completedAt,
+                updatedAt: completedAt,
+                runtimeWorkspace: workspaceDir,
+                branch: normalizeString(body.branch) ?? normalizeString(run.branch) ?? `rig/${run.taskId}-${runId}`,
+                taskId: run.taskId,
+                source: "remote-complete"
+              }
+            });
+            deps.appendRunLogEntryAndBroadcast(state, runId, {
+              id: `log:${runId}:remote-server-closeout-requested`,
+              title: "Server-owned closeout requested",
+              detail: "Remote run completed provider work and handed commit/PR/review/merge closeout to the Rig server.",
+              tone: "info",
+              status: "reviewing",
+              createdAt: completedAt,
+              payload: { workspaceDir, hostId, leaseId }
+            }, "remote-server-closeout-requested");
+            deps.runServerOwnedPrCloseout(state, runId).catch((error) => {
+              const detail = error instanceof Error ? error.message : String(error);
+              patchRunRecord(state.projectRoot, runId, {
+                status: "failed",
+                completedAt: new Date().toISOString(),
+                errorText: detail,
+                serverCloseout: {
+                  status: "failed",
+                  phase: "failed",
+                  updatedAt: new Date().toISOString(),
+                  error: detail
+                }
+              });
+              deps.appendRunLogEntryAndBroadcast(state, runId, {
+                id: `log:${runId}:remote-server-closeout-failed`,
+                title: "Server-owned closeout failed",
+                detail,
+                tone: "error",
+                status: "failed",
+                createdAt: new Date().toISOString()
+              }, "remote-server-closeout-failed");
+            }).finally(() => {
+              deps.reconcileScheduler(state, "remote-server-closeout-terminal");
+            });
+            deps.broadcastSnapshotInvalidation(state);
+            return deps.jsonResponse({
+              ok: true,
+              workspaceId: normalizeString(body.workspaceId) ?? RIG_WORKSPACE_ID,
+              hostId,
+              runId,
+              leaseId,
+              closeout: "server-owned",
+              acceptedAt: new Date().toISOString()
+            });
+          }
           patchRunRecord(state.projectRoot, runId, {
             status: "completed",
             completedAt,
@@ -4497,6 +4737,14 @@ data: ${JSON.stringify({ connectedAt: new Date().toISOString() })}
           const page = await readRunLogsPage(state.projectRoot, runId, { limit, cursor });
           return deps.jsonResponse(page);
         }
+        const runTimelineMatch = url.pathname.match(/^\/api\/runs\/([^/]+)\/timeline$/);
+        if (runTimelineMatch) {
+          const runId = decodeURIComponent(runTimelineMatch[1]);
+          const limit = Number.parseInt(url.searchParams.get("limit") || "500", 10);
+          const cursor = normalizeString(url.searchParams.get("cursor"));
+          const page = await readRunTimelinePage(state.projectRoot, runId, { limit, cursor });
+          return deps.jsonResponse(page);
+        }
         const runSteerMatch = url.pathname.match(/^\/api\/runs\/([^/]+)\/steer$/);
         if (runSteerMatch && req.method === "POST") {
           const runId = decodeURIComponent(runSteerMatch[1]);

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

@@ -167,6 +167,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 +264,7 @@ export {
   remoteArtifactsRoot,
   readUserInputsForRuns,
   readUserInputs,
+  readRunTimelinePage,
   readRunLogsPage,
   readRunDetails,
   readRawRunLogs,