@h-rig/server 0.0.6-alpha.0

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

@@ -0,0 +1,161 @@
+// @bun
+// 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 { resolve as resolve2 } from "path";
+import {
+  appendJsonlRecord,
+  readAuthorityRun as readAuthorityRun2,
+  resolveAuthorityRunDir as resolveAuthorityRunDir2,
+  writeJsonFile
+} 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
+import { dirname, resolve } from "path";
+import {
+  listAuthorityRuns,
+  readAuthorityRun,
+  readJsonlFile,
+  resolveAuthorityRunDir
+} from "@rig/runtime/control-plane/authority-files";
+function runLogsPath(projectRoot, runId) {
+  return resolve(resolveAuthorityRunDir(projectRoot, runId), "logs.jsonl");
+}
+var INITIAL_RUN_LOG_TAIL_MAX_BYTES = 8 * 1024 * 1024;
+
+// packages/server/src/server-helpers/run-writers.ts
+function appendRunLogEntry(projectRoot, runId, value) {
+  if (!readAuthorityRun2(projectRoot, runId)) {
+    return;
+  }
+  appendJsonlRecord(runLogsPath(projectRoot, runId), value);
+  patchRunRecord(projectRoot, runId, {});
+  return value;
+}
+function patchRunRecord(projectRoot, runId, patch) {
+  const current = readAuthorityRun2(projectRoot, runId);
+  if (!current) {
+    throw new Error(`Run not found: ${runId}`);
+  }
+  const next = {
+    ...current,
+    ...patch,
+    updatedAt: normalizeString(patch.updatedAt) ?? new Date().toISOString()
+  };
+  writeJsonFile(resolve2(resolveAuthorityRunDir2(projectRoot, runId), "run.json"), next);
+  return next;
+}
+
+// packages/server/src/server-helpers/remote-snapshots.ts
+import { listAuthorityRemoteEndpoints } from "@rig/runtime/control-plane/authority-files";
+function normalizeIsoTimestamp(value) {
+  const normalized = normalizeString(value);
+  if (!normalized)
+    return null;
+  const timestamp = Date.parse(normalized);
+  return Number.isFinite(timestamp) ? new Date(timestamp).toISOString() : null;
+}
+
+// packages/server/src/server-helpers/event-emitter.ts
+function nextSequence(carrier) {
+  const current = carrier.sequence ?? 0;
+  const next = current + 1;
+  carrier.sequence = next;
+  return next;
+}
+function buildRigEvent(carrier, input) {
+  const createdAt = normalizeIsoTimestamp(input.createdAt) ?? new Date().toISOString();
+  const sequence = nextSequence(carrier);
+  return {
+    id: `rig-event-${sequence}`,
+    sequence,
+    createdAt,
+    type: input.type,
+    aggregateId: input.aggregateId,
+    payload: input.payload ?? {}
+  };
+}
+
+// packages/server/src/server-helpers/broadcasters.ts
+var SERVER_EVENT_JOURNAL_LIMIT = 5000;
+function broadcastPush(state, payload) {
+  const encoded = encodeWebSocketPayload(payload);
+  for (const socket of state.sockets) {
+    try {
+      socket.send(encoded);
+    } catch {
+      state.sockets.delete(socket);
+    }
+  }
+}
+function buildSnapshotInvalidatedPush(state, reason = "snapshot-mutated") {
+  return {
+    type: "push",
+    channel: RIG_WS_CHANNELS.snapshotInvalidated,
+    data: {
+      sequence: state.sequence,
+      updatedAt: new Date().toISOString(),
+      reason
+    }
+  };
+}
+function broadcastSnapshotInvalidation(state, reason) {
+  broadcastPush(state, buildSnapshotInvalidatedPush(state, reason));
+}
+function buildRunLogAppendedPush(runId, entry) {
+  return {
+    type: "push",
+    channel: RIG_WS_CHANNELS.runLogAppended,
+    data: {
+      runId,
+      entry
+    }
+  };
+}
+function broadcastRunLogAppended(state, runId, entry) {
+  if (!entry) {
+    return;
+  }
+  broadcastPush(state, buildRunLogAppendedPush(runId, entry));
+}
+function appendRunLogEntryAndBroadcast(state, runId, value, reason) {
+  const entry = appendRunLogEntry(state.projectRoot, runId, value);
+  broadcastRunLogAppended(state, runId, entry);
+  broadcastSnapshotInvalidation(state, reason);
+  return entry;
+}
+function emitRigEvent(state, input) {
+  const event = buildRigEvent(state, input);
+  state.eventJournal.push(event);
+  if (state.eventJournal.length > SERVER_EVENT_JOURNAL_LIMIT) {
+    state.eventJournal.splice(0, state.eventJournal.length - SERVER_EVENT_JOURNAL_LIMIT);
+  }
+  broadcastPush(state, {
+    type: "push",
+    channel: RIG_WS_CHANNELS.event,
+    data: event
+  });
+  return event;
+}
+export {
+  emitRigEvent,
+  broadcastSnapshotInvalidation,
+  broadcastRunLogAppended,
+  broadcastPush,
+  appendRunLogEntryAndBroadcast,
+  SERVER_EVENT_JOURNAL_LIMIT
+};

package/dist/src/server-helpers/conversation-snapshot.js

@@ -0,0 +1,382 @@
+// @bun
+// packages/server/src/server-helpers/conversation-snapshot.ts
+import { existsSync as existsSync2, readdirSync, statSync as statSync2 } from "fs";
+import { dirname as dirname2, resolve as resolve2 } from "path";
+import {
+  listAuthorityRuns as listAuthorityRuns2,
+  readJsonlFile as readJsonlFile2
+} 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/remote-snapshots.ts
+import { listAuthorityRemoteEndpoints } from "@rig/runtime/control-plane/authority-files";
+function normalizeIsoTimestamp(value) {
+  const normalized = normalizeString(value);
+  if (!normalized)
+    return null;
+  const timestamp = Date.parse(normalized);
+  return Number.isFinite(timestamp) ? new Date(timestamp).toISOString() : null;
+}
+
+// packages/server/src/server-helpers/run-io.ts
+import { dirname, resolve } from "path";
+import { closeSync, existsSync, mkdirSync, openSync, readSync, statSync, writeFileSync } from "fs";
+import {
+  listAuthorityRuns,
+  readAuthorityRun,
+  readJsonlFile,
+  resolveAuthorityRunDir
+} from "@rig/runtime/control-plane/authority-files";
+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));
+}
+var INITIAL_RUN_LOG_TAIL_MAX_BYTES = 8 * 1024 * 1024;
+
+// packages/server/src/server-helpers/conversation-snapshot.ts
+function readClaudeSessionRecords(run) {
+  if (!run.worktreePath)
+    return [];
+  const runtimeRoot = dirname2(run.worktreePath);
+  const projectsRoot = resolve2(runtimeRoot, "home", ".claude", "projects");
+  if (!existsSync2(projectsRoot))
+    return [];
+  const candidatePaths = [];
+  const visit = (dirPath, depth) => {
+    if (depth > 2)
+      return;
+    for (const entry of readdirSync(dirPath, { withFileTypes: true })) {
+      const nextPath = resolve2(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        visit(nextPath, depth + 1);
+        continue;
+      }
+      if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+        candidatePaths.push(nextPath);
+      }
+    }
+  };
+  visit(projectsRoot, 0);
+  const entries = candidatePaths.map((path) => {
+    const records2 = readJsonlFile2(path).filter((raw) => !!raw && typeof raw === "object" && !Array.isArray(raw));
+    return {
+      path,
+      mtimeMs: statSync2(path).mtimeMs,
+      records: records2
+    };
+  }).filter((entry) => {
+    const normalizedWorktree = run.worktreePath.replaceAll("\\", "/");
+    return entry.records.some((record) => {
+      const cwd = normalizeString(record.cwd)?.replaceAll("\\", "/");
+      return cwd === normalizedWorktree;
+    });
+  }).sort((left, right) => left.mtimeMs - right.mtimeMs);
+  if (entries.length === 0)
+    return [];
+  const startedAt = Date.parse(run.startedAt ?? run.createdAt);
+  const completedAt = run.completedAt ? Date.parse(run.completedAt) : Number.POSITIVE_INFINITY;
+  const lookbackMs = 60000;
+  const lookaheadMs = 5 * 60000;
+  const records = [];
+  for (const entry of entries) {
+    for (const record of entry.records) {
+      const timestamp = Date.parse(normalizeIsoTimestamp(record.timestamp) ?? "");
+      if (Number.isFinite(startedAt) && Number.isFinite(timestamp)) {
+        if (timestamp < startedAt - lookbackMs)
+          continue;
+        if (Number.isFinite(completedAt) && timestamp > completedAt + lookaheadMs)
+          continue;
+      }
+      records.push(record);
+    }
+  }
+  return records.sort((left, right) => {
+    const leftAt = Date.parse(normalizeIsoTimestamp(left.timestamp) ?? "") || 0;
+    const rightAt = Date.parse(normalizeIsoTimestamp(right.timestamp) ?? "") || 0;
+    return leftAt - rightAt;
+  });
+}
+function buildClaudeStreamLogs(run) {
+  const sessionRecords = readClaudeSessionRecords(run);
+  if (sessionRecords.length === 0)
+    return [];
+  const logs = [];
+  const pendingToolUses = new Map;
+  for (const record of sessionRecords) {
+    const entryType = normalizeString(record.type);
+    const createdAt = normalizeIsoTimestamp(record.timestamp) ?? run.updatedAt;
+    if (entryType === "summary") {
+      continue;
+    }
+    if (entryType === "system" || entryType === "result") {
+      logs.push({
+        id: normalizeString(record.uuid) ?? `${run.runId}-claude-${logs.length + 1}`,
+        runId: run.runId,
+        title: entryType === "result" ? "Agent result" : "Agent session initialized",
+        detail: JSON.stringify(record),
+        tone: entryType === "result" && record.is_error === true ? "error" : "info",
+        status: run.completedAt ? "completed" : "running",
+        payload: record,
+        createdAt
+      });
+      continue;
+    }
+    const message = record.message;
+    if (!message || typeof message !== "object" || Array.isArray(message))
+      continue;
+    const messageRecord = message;
+    const role = normalizeString(messageRecord.role) ?? entryType ?? "assistant";
+    const content = Array.isArray(messageRecord.content) ? messageRecord.content : [];
+    for (const item of content) {
+      if (!item || typeof item !== "object" || Array.isArray(item))
+        continue;
+      const contentRecord = item;
+      const contentType = normalizeString(contentRecord.type);
+      if (contentType === "tool_use") {
+        const toolUseId = normalizeString(contentRecord.id);
+        if (!toolUseId)
+          continue;
+        pendingToolUses.set(toolUseId, {
+          id: toolUseId,
+          name: normalizeString(contentRecord.name),
+          input: contentRecord.input ?? {},
+          timestamp: createdAt,
+          record: contentRecord
+        });
+        continue;
+      }
+      if (contentType === "tool_result") {
+        const toolUseId = normalizeString(contentRecord.tool_use_id);
+        const pending = toolUseId ? pendingToolUses.get(toolUseId) ?? null : null;
+        if (pending && toolUseId) {
+          pendingToolUses.delete(toolUseId);
+        }
+        const detail2 = JSON.stringify({
+          type: "claude_tool_activity",
+          session_id: normalizeString(record.sessionId) ?? normalizeString(record.session_id),
+          uuid: normalizeString(record.uuid),
+          tool_use_id: toolUseId,
+          tool_name: pending?.name ?? null,
+          tool_input: pending?.input ?? null,
+          tool_result: contentRecord.content ?? contentRecord,
+          is_error: contentRecord.is_error === true,
+          raw: {
+            toolUse: pending?.record ?? null,
+            toolResult: contentRecord
+          }
+        });
+        logs.push({
+          id: toolUseId ? `${run.runId}-claude-tool-${toolUseId}` : normalizeString(record.uuid) ?? `${run.runId}-claude-${logs.length + 1}`,
+          runId: run.runId,
+          title: "Tool activity",
+          detail: detail2,
+          tone: contentRecord.is_error === true ? "error" : "tool",
+          status: run.completedAt ? "completed" : "running",
+          payload: {
+            toolUseId,
+            toolName: pending?.name ?? null,
+            toolInput: pending?.input ?? null,
+            content: contentRecord.content ?? null,
+            isError: contentRecord.is_error === true
+          },
+          createdAt: pending?.timestamp ?? createdAt
+        });
+        continue;
+      }
+      const detail = JSON.stringify({
+        type: role,
+        message: {
+          role,
+          content: [contentRecord]
+        },
+        session_id: normalizeString(record.sessionId) ?? normalizeString(record.session_id),
+        uuid: normalizeString(record.uuid)
+      });
+      logs.push({
+        id: normalizeString(record.uuid) ? `${normalizeString(record.uuid)}:${contentType ?? "content"}:${logs.length + 1}` : `${run.runId}-claude-${logs.length + 1}`,
+        runId: run.runId,
+        title: role === "assistant" ? "Assistant output" : role === "user" ? "Tool activity" : "Agent output",
+        detail,
+        tone: contentType === "text" ? "info" : "tool",
+        status: run.completedAt ? "completed" : "running",
+        payload: contentRecord,
+        createdAt
+      });
+    }
+  }
+  for (const pending of pendingToolUses.values()) {
+    logs.push({
+      id: `${run.runId}-claude-tool-${pending.id}`,
+      runId: run.runId,
+      title: "Tool activity",
+      detail: JSON.stringify({
+        type: "claude_tool_use",
+        tool_use_id: pending.id,
+        tool_name: pending.name,
+        tool_input: pending.input,
+        raw: pending.record
+      }),
+      tone: "tool",
+      status: "running",
+      payload: {
+        toolUseId: pending.id,
+        toolName: pending.name,
+        toolInput: pending.input
+      },
+      createdAt: pending.timestamp
+    });
+  }
+  return logs.sort((left, right) => Date.parse(left.createdAt) - Date.parse(right.createdAt));
+}
+var snapshotCache = new Map;
+var RUN_LOG_SNAPSHOT_TAIL_LIMIT = 200;
+function runListSignature(runs) {
+  return runs.slice().sort((a, b) => a.runId.localeCompare(b.runId)).map((run) => `${run.runId}|${run.updatedAt ?? ""}|${run.completedAt ?? ""}`).join(";");
+}
+function invalidateConversationSnapshotCache(projectRoot) {
+  if (projectRoot) {
+    snapshotCache.delete(projectRoot);
+    return;
+  }
+  snapshotCache.clear();
+}
+function buildConversationSnapshot(projectRoot, options = {}) {
+  const runs = listAuthorityRuns2(projectRoot);
+  const signature = runListSignature(runs);
+  if (!options.force) {
+    const cached = snapshotCache.get(projectRoot);
+    if (cached && cached.signature === signature) {
+      return cached.snapshot;
+    }
+  }
+  const conversations = [];
+  const messages = [];
+  const logs = [];
+  const actions = [];
+  for (const run of runs) {
+    const conversationId = `conversation:${run.runId}`;
+    conversations.push({
+      id: conversationId,
+      runId: run.runId,
+      title: run.title,
+      createdAt: run.createdAt,
+      updatedAt: run.updatedAt
+    });
+    const timeline = readJsonlFile2(runTimelinePath(projectRoot, run.runId));
+    for (const raw of timeline) {
+      if (!raw || typeof raw !== "object")
+        continue;
+      const entry = raw;
+      const type = normalizeString(entry.type) ?? "system_message";
+      const createdAt = normalizeString(entry.createdAt) ?? run.updatedAt;
+      if (type === "user_message" || type === "assistant_message" || type === "system_message") {
+        const role = type === "assistant_message" ? "assistant" : type === "user_message" ? "user" : "system";
+        messages.push({
+          id: normalizeString(entry.id) ?? `${run.runId}-${messages.length + 1}`,
+          conversationId,
+          role,
+          text: typeof entry.text === "string" ? entry.text : "",
+          attachments: Array.isArray(entry.attachments) ? entry.attachments : [],
+          state: normalizeString(entry.state) === "streaming" ? "streaming" : normalizeString(entry.state) === "interrupted" ? "interrupted" : normalizeString(entry.state) === "errored" ? "errored" : "completed",
+          createdAt,
+          completedAt: normalizeString(entry.completedAt) ?? (normalizeString(entry.state) === "streaming" ? null : createdAt)
+        });
+        continue;
+      }
+      if (type === "action") {
+        actions.push({
+          id: normalizeString(entry.id) ?? `${run.runId}-action-${actions.length + 1}`,
+          runId: run.runId,
+          messageId: normalizeString(entry.messageId),
+          actionType: normalizeString(entry.actionType) ?? "task",
+          title: normalizeString(entry.title) ?? "Run step",
+          detail: normalizeString(entry.detail),
+          state: normalizeString(entry.state) ?? "completed",
+          payload: entry.payload ?? {},
+          startedAt: createdAt,
+          completedAt: normalizeString(entry.completedAt) ?? null
+        });
+      }
+    }
+    const runLogs = readJsonlFileTail(runLogsPath(projectRoot, run.runId), {
+      limit: RUN_LOG_SNAPSHOT_TAIL_LIMIT,
+      maxBytes: 512 * 1024
+    });
+    const claudeStreamLogs = buildClaudeStreamLogs(run);
+    const hasClaudeStreamLogs = claudeStreamLogs.length > 0;
+    for (const raw of runLogs) {
+      if (!raw || typeof raw !== "object")
+        continue;
+      const entry = raw;
+      const createdAt = normalizeString(entry.createdAt) ?? run.updatedAt;
+      const rawDetail = normalizeString(entry.detail);
+      if (hasClaudeStreamLogs && rawDetail) {
+        try {
+          const parsed = JSON.parse(rawDetail);
+          const parsedType = normalizeString(parsed.type);
+          if (parsedType === "assistant" || parsedType === "user" || parsedType === "system" || parsedType === "result") {
+            continue;
+          }
+        } catch {}
+      }
+      logs.push({
+        id: normalizeString(entry.id) ?? `${run.runId}-log-${logs.length + 1}`,
+        runId: run.runId,
+        title: normalizeString(entry.title) ?? "Run log",
+        detail: normalizeString(entry.detail),
+        tone: normalizeString(entry.tone) === "error" ? "error" : normalizeString(entry.tone) === "tool" ? "tool" : normalizeString(entry.tone) === "thinking" ? "thinking" : "info",
+        status: normalizeString(entry.status),
+        payload: entry.payload ?? {},
+        createdAt
+      });
+    }
+    logs.push(...claudeStreamLogs);
+  }
+  logs.sort((left, right) => Date.parse(left.createdAt) - Date.parse(right.createdAt));
+  const snapshot = { conversations, messages, logs, actions };
+  snapshotCache.set(projectRoot, { signature, snapshot });
+  return snapshot;
+}
+export {
+  readClaudeSessionRecords,
+  invalidateConversationSnapshotCache,
+  buildConversationSnapshot,
+  buildClaudeStreamLogs
+};

package/dist/src/server-helpers/event-emitter.js

@@ -0,0 +1,41 @@
+// @bun
+// packages/server/src/server-helpers/remote-snapshots.ts
+import { listAuthorityRemoteEndpoints } 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/remote-snapshots.ts
+function normalizeIsoTimestamp(value) {
+  const normalized = normalizeString(value);
+  if (!normalized)
+    return null;
+  const timestamp = Date.parse(normalized);
+  return Number.isFinite(timestamp) ? new Date(timestamp).toISOString() : null;
+}
+
+// packages/server/src/server-helpers/event-emitter.ts
+function nextSequence(carrier) {
+  const current = carrier.sequence ?? 0;
+  const next = current + 1;
+  carrier.sequence = next;
+  return next;
+}
+function buildRigEvent(carrier, input) {
+  const createdAt = normalizeIsoTimestamp(input.createdAt) ?? new Date().toISOString();
+  const sequence = nextSequence(carrier);
+  return {
+    id: `rig-event-${sequence}`,
+    sequence,
+    createdAt,
+    type: input.type,
+    aggregateId: input.aggregateId,
+    payload: input.payload ?? {}
+  };
+}
+export {
+  nextSequence,
+  buildRigEvent
+};