@h-rig/server 0.0.6-alpha.0

package/dist/src/server-helpers/summaries.js

@@ -0,0 +1,126 @@
+// @bun
+// 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/summaries.ts
+function toTaskSummary(workspaceId, task) {
+  const createdAt = task.createdAt ?? task.updatedAt ?? new Date().toISOString();
+  const updatedAt = task.updatedAt ?? task.createdAt ?? createdAt;
+  const description = task.description ?? task.acceptanceCriteria ?? "";
+  return {
+    id: task.id,
+    workspaceId,
+    graphId: null,
+    externalId: task.externalRef,
+    title: task.title,
+    description,
+    status: task.status,
+    priority: task.priority,
+    role: task.role,
+    scope: task.scope,
+    validationKeys: task.validation,
+    sourceIssueId: task.sourceIssueId,
+    dependencies: task.dependencies,
+    parentChildDeps: task.parentChildDeps,
+    metadata: {
+      acceptanceCriteria: task.acceptanceCriteria,
+      issueType: task.issueType,
+      sourceIssueId: task.sourceIssueId,
+      ...task.sourceStatus ? { sourceStatus: task.sourceStatus } : {},
+      dependencies: task.dependencies,
+      parentChildDeps: task.parentChildDeps,
+      labels: task.labels
+    },
+    createdAt,
+    updatedAt
+  };
+}
+function buildWorkspaceGraphSummary(workspace, tasks) {
+  const timestamps = [
+    workspace.updatedAt,
+    ...tasks.map((task) => task.updatedAt),
+    ...tasks.map((task) => task.createdAt)
+  ].filter((value) => typeof value === "string" && value.length > 0);
+  const updatedAt = timestamps.toSorted().at(-1) ?? workspace.updatedAt;
+  const taskCount = tasks.length;
+  return {
+    id: `graph:${workspace.id}`,
+    workspaceId: workspace.id,
+    title: `${workspace.title} graph`,
+    description: taskCount > 0 ? `${taskCount} imported task${taskCount === 1 ? "" : "s"} from the connected Rig workspace` : "No imported tasks are available yet for this workspace",
+    createdAt: workspace.createdAt,
+    updatedAt
+  };
+}
+function toApprovalSummary(record) {
+  const createdAt = normalizeString(record.record.createdAt) ?? normalizeString(record.record.requestedAt) ?? new Date().toISOString();
+  const resolvedAt = normalizeString(record.record.resolvedAt) ?? normalizeString(record.record.respondedAt) ?? null;
+  return {
+    id: record.requestId ?? `${record.runId}-approval-${createdAt}`,
+    runId: record.runId,
+    actionId: normalizeString(record.record.actionId),
+    requestKind: normalizeString(record.record.requestKind) ?? normalizeString(record.record.kind) ?? "approval",
+    status: record.status === "resolved" ? "resolved" : "pending",
+    payload: record.record,
+    createdAt,
+    resolvedAt
+  };
+}
+function toUserInputSummary(record) {
+  const createdAt = normalizeString(record.record.createdAt) ?? normalizeString(record.record.requestedAt) ?? new Date().toISOString();
+  const resolvedAt = normalizeString(record.record.resolvedAt) ?? normalizeString(record.record.respondedAt) ?? null;
+  return {
+    id: record.requestId ?? `${record.runId}-input-${createdAt}`,
+    runId: record.runId,
+    status: record.status === "resolved" ? "resolved" : "pending",
+    payload: record.record,
+    createdAt,
+    resolvedAt
+  };
+}
+function toRunSummary(run, approvals, userInputs) {
+  const pendingApprovalCount = approvals.filter((entry) => entry.status !== "resolved").length;
+  const pendingUserInputCount = userInputs.filter((entry) => entry.status !== "resolved").length;
+  const runStatus = pendingApprovalCount > 0 ? "waiting-approval" : pendingUserInputCount > 0 ? "waiting-user-input" : run.status === "waiting" ? "queued" : run.status === "preparing" ? "preparing" : run.status === "stopped" ? "cancelled" : run.status === "done" || run.status === "completed" ? "completed" : run.status === "error" || run.status === "failed" ? "failed" : run.status === "running" ? "running" : "created";
+  const runMode = normalizeString(run.runMode) === "autonomous" ? "autonomous" : normalizeString(run.runMode) === "supervised" ? "supervised" : "interactive";
+  const runtimeMode = normalizeString(run.runtimeMode) ?? "approval-required";
+  const interactionMode = normalizeString(run.interactionMode) ?? "default";
+  return {
+    id: run.runId,
+    workspaceId: run.workspaceId,
+    taskId: run.taskId,
+    title: run.title,
+    runKind: run.taskId ? "task" : "adhoc",
+    mode: runMode,
+    runtimeMode,
+    interactionMode,
+    status: runStatus,
+    runtimeAdapter: run.runtimeAdapter,
+    model: normalizeString(run.model),
+    initialPrompt: normalizeString(run.initialPrompt),
+    executionTarget: run.mode === "remote" ? "remote" : "local",
+    remoteHostId: run.hostId,
+    remoteLeaseId: run.endpointId,
+    remoteLeaseClaimedAt: null,
+    activeRuntimeId: null,
+    latestMessageId: normalizeString(run.latestMessageId),
+    pendingApprovalCount,
+    pendingUserInputCount,
+    branch: normalizeString(run.branch),
+    worktreePath: run.worktreePath,
+    errorText: normalizeString(run.errorText),
+    createdAt: run.createdAt,
+    updatedAt: run.updatedAt,
+    startedAt: run.startedAt,
+    completedAt: run.completedAt
+  };
+}
+export {
+  toUserInputSummary,
+  toTaskSummary,
+  toRunSummary,
+  toApprovalSummary,
+  buildWorkspaceGraphSummary
+};

package/dist/src/server-helpers/task-config.js

@@ -0,0 +1,50 @@
+// @bun
+// packages/server/src/server-helpers/task-config.ts
+import { existsSync as existsSync2 } from "fs";
+
+// packages/server/src/bootstrap.ts
+import { existsSync, mkdirSync, unlinkSync, writeFileSync } from "fs";
+import { dirname, resolve } from "path";
+import { RIG_DEFINITION_DIRNAME, resolveMonorepoRoot } from "@rig/runtime";
+function normalizeOptionalString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function resolveRigServerPaths(projectRoot) {
+  const taskWorkspace = normalizeOptionalString(process.env.RIG_TASK_WORKSPACE);
+  const explicitStateDir = normalizeOptionalString(process.env.RIG_STATE_DIR);
+  const explicitLogsDir = normalizeOptionalString(process.env.RIG_LOGS_DIR);
+  const explicitSessionFile = normalizeOptionalString(process.env.RIG_SESSION_FILE);
+  const hostStateRoot = resolve(projectRoot, ".rig");
+  const monorepoRoot = resolveMonorepoRoot(projectRoot);
+  const monorepoStateRoot = resolve(monorepoRoot, ".rig");
+  const stateRoot = taskWorkspace ? resolve(taskWorkspace, ".rig") : explicitStateDir ? dirname(resolve(explicitStateDir)) : explicitLogsDir ? dirname(resolve(explicitLogsDir)) : explicitSessionFile ? dirname(dirname(resolve(explicitSessionFile))) : existsSync(hostStateRoot) ? hostStateRoot : monorepoStateRoot;
+  const stateDir = explicitStateDir ? resolve(explicitStateDir) : resolve(stateRoot, "state");
+  const logsDir = explicitLogsDir ? resolve(explicitLogsDir) : resolve(stateRoot, "logs");
+  const taskConfigPath = taskWorkspace ? resolve(taskWorkspace, ".rig", "task-config.json") : existsSync(resolve(projectRoot, ".rig", "task-config.json")) ? resolve(projectRoot, ".rig", "task-config.json") : resolve(monorepoStateRoot, "task-config.json");
+  return {
+    stateRoot,
+    stateDir,
+    logsDir,
+    controlPlaneEventsFile: resolve(logsDir, "control-plane.events.jsonl"),
+    taskConfigPath,
+    notificationsFile: resolve(projectRoot, "rig", "notifications", "targets.json"),
+    keybindingsPath: resolve(projectRoot, "rig", "keybindings.json")
+  };
+}
+
+// packages/server/src/server-helpers/task-config.ts
+async function readTaskConfig(projectRoot) {
+  const taskConfigPath = resolveRigServerPaths(projectRoot).taskConfigPath;
+  if (!existsSync2(taskConfigPath)) {
+    return {};
+  }
+  try {
+    const parsed = await Bun.file(taskConfigPath).json();
+    return parsed ?? {};
+  } catch {
+    return {};
+  }
+}
+export {
+  readTaskConfig
+};

package/dist/src/server-helpers/task-projection.js

@@ -0,0 +1,98 @@
+// @bun
+// packages/server/src/server-helpers/task-projection.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { resolve } from "path";
+function projectionPath(projectRoot) {
+  return resolve(projectRoot, ".rig", "state", "task-projection.json");
+}
+function stateDir(projectRoot) {
+  return resolve(projectRoot, ".rig", "state");
+}
+function cloneTask(task) {
+  return { ...task };
+}
+function writeTaskProjection(projectRoot, input) {
+  const activeByTask = new Map((input.activeRuns ?? []).map((run) => [run.taskId, run]));
+  const tasks = input.tasks.map((task) => {
+    const projected = cloneTask(task);
+    const active = activeByTask.get(task.id);
+    if (active) {
+      projected.status = "in_progress";
+      projected.activeRun = {
+        runId: active.runId,
+        ...active.status ? { status: active.status } : {},
+        ...active.stage ? { stage: active.stage } : {}
+      };
+    }
+    return projected;
+  });
+  const snapshot = {
+    version: 1,
+    source: input.source,
+    reason: input.reason,
+    refreshedAt: input.refreshedAt ?? new Date().toISOString(),
+    tasks
+  };
+  mkdirSync(stateDir(projectRoot), { recursive: true });
+  writeFileSync(projectionPath(projectRoot), JSON.stringify(snapshot, null, 2), "utf8");
+  return snapshot;
+}
+function readTaskProjection(projectRoot) {
+  const file = projectionPath(projectRoot);
+  if (!existsSync(file))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync(file, "utf8"));
+    return parsed && parsed.version === 1 && Array.isArray(parsed.tasks) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+async function refreshTaskProjection(projectRoot, input) {
+  const tasks = typeof input.tasks === "function" ? await input.tasks() : input.tasks;
+  const activeRuns = typeof input.activeRuns === "function" ? await input.activeRuns() : input.activeRuns;
+  return writeTaskProjection(projectRoot, {
+    source: input.source,
+    reason: input.reason ?? "refresh",
+    tasks,
+    activeRuns
+  });
+}
+function taskAssignees(task) {
+  const raw = task.assignees;
+  if (!Array.isArray(raw))
+    return [];
+  return raw.flatMap((value) => {
+    if (typeof value === "string")
+      return [value];
+    if (value && typeof value === "object" && typeof value.login === "string")
+      return [value.login];
+    return [];
+  });
+}
+function filterProjectedTasks(tasks, filter) {
+  const status = filter.status?.trim();
+  const assignedTo = filter.assignedTo?.trim();
+  const search = filter.search?.trim().toLowerCase();
+  return tasks.filter((task) => {
+    if (status && task.status !== status)
+      return false;
+    if (assignedTo && !taskAssignees(task).includes(assignedTo))
+      return false;
+    if (search) {
+      const title = typeof task.title === "string" ? task.title : "";
+      const body = typeof task.body === "string" ? task.body : "";
+      if (!`${task.id}
+${title}
+${body}`.toLowerCase().includes(search))
+        return false;
+    }
+    return true;
+  });
+}
+export {
+  writeTaskProjection,
+  refreshTaskProjection,
+  readTaskProjection,
+  filterProjectedTasks
+};

package/dist/src/server-helpers/terminal-runtime.js

@@ -0,0 +1,156 @@
+// @bun
+// packages/server/src/server-helpers/terminal-runtime.ts
+import { spawn } from "child_process";
+import { WS_CHANNELS as WS_CHANNELS2 } from "@rig/contracts";
+
+// packages/server/src/server-helpers/broadcasters.ts
+import { RIG_WS_CHANNELS } from "@rig/contracts";
+
+// packages/server/src/websocket.ts
+import {
+  WS_CHANNELS
+} from "@rig/contracts";
+function encodeWebSocketPayload(payload) {
+  return JSON.stringify(payload);
+}
+
+// packages/server/src/server-helpers/run-writers.ts
+import {
+  appendJsonlRecord,
+  readAuthorityRun as readAuthorityRun2,
+  resolveAuthorityRunDir as resolveAuthorityRunDir2,
+  writeJsonFile
+} 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";
+var INITIAL_RUN_LOG_TAIL_MAX_BYTES = 8 * 1024 * 1024;
+
+// packages/server/src/server-helpers/remote-snapshots.ts
+import { listAuthorityRemoteEndpoints } from "@rig/runtime/control-plane/authority-files";
+
+// packages/server/src/server-helpers/broadcasters.ts
+function broadcastPush(state, payload) {
+  const encoded = encodeWebSocketPayload(payload);
+  for (const socket of state.sockets) {
+    try {
+      socket.send(encoded);
+    } catch {
+      state.sockets.delete(socket);
+    }
+  }
+}
+
+// packages/server/src/server-helpers/terminal-sessions.ts
+function terminalSessionKey(threadId, terminalId) {
+  return `${threadId}::${terminalId}`;
+}
+function terminalSnapshot(session) {
+  return {
+    threadId: session.threadId,
+    terminalId: session.terminalId,
+    cwd: session.cwd,
+    status: session.status,
+    pid: session.pid,
+    history: session.history,
+    exitCode: session.exitCode,
+    exitSignal: session.exitSignal,
+    updatedAt: session.updatedAt
+  };
+}
+
+// packages/server/src/server-helpers/terminal-runtime.ts
+var DEFAULT_TERMINAL_SHELL = process.env.SHELL || "/bin/zsh";
+function pushTerminalEvent(state, event) {
+  broadcastPush(state, {
+    type: "push",
+    channel: WS_CHANNELS2.terminalEvent,
+    data: event
+  });
+}
+function createTerminalSession(state, input) {
+  const startedAt = new Date().toISOString();
+  const child = spawn(DEFAULT_TERMINAL_SHELL, [], {
+    cwd: input.cwd,
+    env: { ...process.env, ...input.env ?? {} },
+    stdio: "pipe"
+  });
+  const session = {
+    threadId: input.threadId,
+    terminalId: input.terminalId,
+    cwd: input.cwd,
+    history: "",
+    status: "running",
+    pid: child.pid ?? null,
+    exitCode: null,
+    exitSignal: null,
+    updatedAt: startedAt,
+    child
+  };
+  const sessionKey = terminalSessionKey(input.threadId, input.terminalId);
+  state.terminalSessions.set(sessionKey, session);
+  const appendOutput = (data) => {
+    const chunk = Buffer.isBuffer(data) ? data.toString("utf8") : String(data);
+    session.history += chunk;
+    session.updatedAt = new Date().toISOString();
+    pushTerminalEvent(state, {
+      type: "output",
+      threadId: session.threadId,
+      terminalId: session.terminalId,
+      createdAt: session.updatedAt,
+      data: chunk
+    });
+  };
+  child.stdout.on("data", appendOutput);
+  child.stderr.on("data", appendOutput);
+  child.on("exit", (code, signal) => {
+    session.status = "exited";
+    session.exitCode = typeof code === "number" ? code : null;
+    session.exitSignal = signal ?? null;
+    session.updatedAt = new Date().toISOString();
+    pushTerminalEvent(state, {
+      type: "exited",
+      threadId: session.threadId,
+      terminalId: session.terminalId,
+      createdAt: session.updatedAt,
+      exitCode: session.exitCode,
+      exitSignal: session.exitSignal
+    });
+  });
+  child.on("error", (error) => {
+    session.status = "error";
+    session.updatedAt = new Date().toISOString();
+    pushTerminalEvent(state, {
+      type: "error",
+      threadId: session.threadId,
+      terminalId: session.terminalId,
+      createdAt: session.updatedAt,
+      message: error.message
+    });
+  });
+  pushTerminalEvent(state, {
+    type: "started",
+    threadId: session.threadId,
+    terminalId: session.terminalId,
+    createdAt: startedAt,
+    snapshot: terminalSnapshot(session)
+  });
+  return session;
+}
+function getOrCreateTerminalSession(state, input) {
+  const existing = state.terminalSessions.get(terminalSessionKey(input.threadId, input.terminalId));
+  if (existing && existing.status !== "exited" && existing.status !== "error") {
+    return existing;
+  }
+  return createTerminalSession(state, input);
+}
+export {
+  pushTerminalEvent,
+  getOrCreateTerminalSession,
+  createTerminalSession
+};

package/dist/src/server-helpers/terminal-sessions.js

@@ -0,0 +1,22 @@
+// @bun
+// packages/server/src/server-helpers/terminal-sessions.ts
+function terminalSessionKey(threadId, terminalId) {
+  return `${threadId}::${terminalId}`;
+}
+function terminalSnapshot(session) {
+  return {
+    threadId: session.threadId,
+    terminalId: session.terminalId,
+    cwd: session.cwd,
+    status: session.status,
+    pid: session.pid,
+    history: session.history,
+    exitCode: session.exitCode,
+    exitSignal: session.exitSignal,
+    updatedAt: session.updatedAt
+  };
+}
+export {
+  terminalSnapshot,
+  terminalSessionKey
+};

package/dist/src/server-helpers/validation-failure.js

@@ -0,0 +1,31 @@
+// @bun
+// packages/server/src/server-helpers/validation-failure.ts
+import { resolve } from "path";
+import {
+  readJsonFile,
+  resolveTaskArtifactDirs
+} from "@rig/runtime/control-plane/authority-files";
+function summarizeRunValidationFailure(projectRoot, run) {
+  const artifactRoots = run.taskId ? resolveTaskArtifactDirs(projectRoot, run.taskId) : [];
+  const preferredRoots = run.artifactRoot ? [run.artifactRoot, ...artifactRoots] : artifactRoots;
+  const seen = new Set;
+  for (const artifactRoot of preferredRoots) {
+    if (!artifactRoot || seen.has(artifactRoot)) {
+      continue;
+    }
+    seen.add(artifactRoot);
+    const summary = readJsonFile(resolve(artifactRoot, "validation-summary.json"), null);
+    if (!summary || summary.status !== "fail") {
+      continue;
+    }
+    const failedCategories = Array.isArray(summary.categories) ? summary.categories.filter((entry) => String(entry?.status ?? "") !== "pass").map((entry) => String(entry?.category ?? "").trim()).filter(Boolean) : [];
+    if (failedCategories.length > 0) {
+      return `Task validation failed: ${failedCategories.join(", ")}`;
+    }
+    return "Task validation failed.";
+  }
+  return null;
+}
+export {
+  summarizeRunValidationFailure
+};