@h-rig/server 0.0.6-alpha.0

package/dist/src/orchestration.js

@@ -0,0 +1,402 @@
+// @bun
+// packages/server/src/orchestration.ts
+function nowIso() {
+  return new Date().toISOString();
+}
+function findMutableProject(readModel, projectId) {
+  return readModel.projects.find((project) => project.id === projectId) ?? null;
+}
+function findMutableThread(readModel, threadId) {
+  return readModel.threads.find((thread) => thread.id === threadId) ?? null;
+}
+function createEmptyOrchestrationReadModel(updatedAt = nowIso()) {
+  return {
+    snapshotSequence: 0,
+    projects: [],
+    threads: [],
+    updatedAt
+  };
+}
+function createEmptyOrchestrationProject(input) {
+  const createdAt = input.createdAt ?? nowIso();
+  return {
+    id: input.id,
+    title: input.title,
+    workspaceRoot: input.workspaceRoot,
+    defaultModel: input.defaultModel ?? null,
+    scripts: [],
+    createdAt,
+    updatedAt: createdAt,
+    deletedAt: null
+  };
+}
+function createEmptyOrchestrationThread(input) {
+  const createdAt = input.createdAt ?? nowIso();
+  return {
+    id: input.id,
+    projectId: input.projectId,
+    title: input.title,
+    model: input.model,
+    runtimeMode: input.runtimeMode,
+    interactionMode: input.interactionMode,
+    branch: input.branch ?? null,
+    worktreePath: input.worktreePath ?? null,
+    latestTurn: null,
+    createdAt,
+    updatedAt: createdAt,
+    deletedAt: null,
+    messages: [],
+    proposedPlans: [],
+    activities: [],
+    checkpoints: [],
+    session: null
+  };
+}
+function appendActivity(thread, input) {
+  thread.activities = [
+    ...thread.activities,
+    {
+      id: `activity:${thread.id}:${thread.activities.length + 1}`,
+      tone: input.tone ?? "info",
+      kind: input.kind,
+      summary: input.summary,
+      payload: input.payload,
+      turnId: input.turnId ?? null,
+      sequence: thread.activities.length,
+      createdAt: input.createdAt ?? nowIso()
+    }
+  ];
+}
+function upsertAssistantMessage(thread, messageId, createdAt) {
+  const existing = thread.messages.find((message) => message.id === messageId);
+  if (existing) {
+    return existing;
+  }
+  const next = {
+    id: messageId,
+    role: "assistant",
+    text: "",
+    attachments: [],
+    turnId: thread.latestTurn?.turnId ?? null,
+    streaming: true,
+    createdAt,
+    updatedAt: createdAt
+  };
+  thread.messages = [...thread.messages, next];
+  return next;
+}
+function upsertProposedPlan(thread, proposedPlan) {
+  const existingIndex = thread.proposedPlans.findIndex((item) => item.id === proposedPlan.id);
+  if (existingIndex >= 0) {
+    const next = [...thread.proposedPlans];
+    next[existingIndex] = proposedPlan;
+    thread.proposedPlans = next;
+    return;
+  }
+  thread.proposedPlans = [...thread.proposedPlans, proposedPlan];
+}
+function applyOrchestrationCommand(readModel, command, updatedAt = nowIso()) {
+  const next = {
+    snapshotSequence: readModel.snapshotSequence + 1,
+    updatedAt,
+    projects: readModel.projects.map((project) => ({ ...project, scripts: [...project.scripts] })),
+    threads: readModel.threads.map((thread) => ({
+      ...thread,
+      messages: [...thread.messages],
+      proposedPlans: [...thread.proposedPlans],
+      activities: [...thread.activities],
+      checkpoints: [...thread.checkpoints],
+      latestTurn: thread.latestTurn ? { ...thread.latestTurn } : null,
+      session: thread.session ? { ...thread.session } : null
+    }))
+  };
+  switch (command.type) {
+    case "project.create": {
+      const project = findMutableProject(next, command.projectId);
+      if (project) {
+        project.title = command.title;
+        project.workspaceRoot = command.workspaceRoot;
+        project.defaultModel = command.defaultModel ?? null;
+        project.updatedAt = command.createdAt;
+        project.deletedAt = null;
+      } else {
+        next.projects.push(createEmptyOrchestrationProject({
+          id: command.projectId,
+          title: command.title,
+          workspaceRoot: command.workspaceRoot,
+          defaultModel: command.defaultModel ?? null,
+          createdAt: command.createdAt
+        }));
+      }
+      return next;
+    }
+    case "project.meta.update": {
+      const project = findMutableProject(next, command.projectId);
+      if (!project)
+        return next;
+      if ("title" in command && command.title)
+        project.title = command.title;
+      if ("workspaceRoot" in command && command.workspaceRoot)
+        project.workspaceRoot = command.workspaceRoot;
+      if ("defaultModel" in command)
+        project.defaultModel = command.defaultModel ?? null;
+      if (Array.isArray(command.scripts))
+        project.scripts = [...command.scripts];
+      project.updatedAt = updatedAt;
+      return next;
+    }
+    case "project.delete": {
+      next.projects = next.projects.filter((project) => project.id !== command.projectId);
+      next.threads = next.threads.filter((thread) => thread.projectId !== command.projectId);
+      return next;
+    }
+    case "thread.create": {
+      const thread = findMutableThread(next, command.threadId);
+      if (thread) {
+        thread.projectId = command.projectId;
+        thread.title = command.title;
+        thread.model = command.model;
+        thread.runtimeMode = command.runtimeMode;
+        thread.interactionMode = command.interactionMode;
+        thread.branch = command.branch ?? null;
+        thread.worktreePath = command.worktreePath ?? null;
+        thread.updatedAt = command.createdAt;
+        thread.deletedAt = null;
+      } else {
+        next.threads.push(createEmptyOrchestrationThread({
+          id: command.threadId,
+          projectId: command.projectId,
+          title: command.title,
+          model: command.model,
+          runtimeMode: command.runtimeMode,
+          interactionMode: command.interactionMode,
+          branch: command.branch ?? null,
+          worktreePath: command.worktreePath ?? null,
+          createdAt: command.createdAt
+        }));
+      }
+      return next;
+    }
+    case "thread.meta.update": {
+      const thread = findMutableThread(next, command.threadId);
+      if (!thread)
+        return next;
+      if ("title" in command && command.title)
+        thread.title = command.title;
+      if ("model" in command && command.model)
+        thread.model = command.model;
+      if ("branch" in command)
+        thread.branch = command.branch ?? null;
+      if ("worktreePath" in command)
+        thread.worktreePath = command.worktreePath ?? null;
+      thread.updatedAt = updatedAt;
+      return next;
+    }
+    case "thread.runtime-mode.set":
+    case "thread.interaction-mode.set":
+    case "thread.session.stop":
+    case "thread.turn.start":
+    case "thread.turn.interrupt":
+    case "thread.approval.respond":
+    case "thread.user-input.respond":
+    case "thread.checkpoint.revert": {
+      const thread = findMutableThread(next, command.threadId);
+      if (!thread)
+        return next;
+      const createdAt = "createdAt" in command ? command.createdAt : updatedAt;
+      if (command.type === "thread.runtime-mode.set") {
+        thread.runtimeMode = command.runtimeMode;
+      }
+      if (command.type === "thread.interaction-mode.set") {
+        thread.interactionMode = command.interactionMode;
+      }
+      if (command.type === "thread.turn.start") {
+        const turnId = `turn-${thread.id}-${thread.messages.length + 1}`;
+        thread.messages = [
+          ...thread.messages,
+          {
+            id: command.message.messageId,
+            role: "user",
+            text: command.message.text,
+            attachments: [...command.message.attachments ?? []],
+            turnId,
+            streaming: false,
+            createdAt,
+            updatedAt: createdAt
+          }
+        ];
+        thread.latestTurn = {
+          turnId,
+          state: "running",
+          requestedAt: createdAt,
+          startedAt: createdAt,
+          completedAt: null,
+          assistantMessageId: null
+        };
+        thread.session = {
+          threadId: thread.id,
+          status: "running",
+          providerName: command.provider ?? null,
+          runtimeMode: command.runtimeMode,
+          activeTurnId: thread.latestTurn.turnId,
+          lastError: null,
+          updatedAt: createdAt
+        };
+      }
+      if (command.type === "thread.turn.interrupt") {
+        if (thread.latestTurn) {
+          thread.latestTurn = {
+            ...thread.latestTurn,
+            state: "interrupted",
+            completedAt: createdAt
+          };
+        }
+        if (thread.session) {
+          thread.session = {
+            ...thread.session,
+            status: "interrupted",
+            updatedAt: createdAt
+          };
+        }
+      }
+      if (command.type === "thread.session.stop" && thread.session) {
+        thread.session = {
+          ...thread.session,
+          status: "stopped",
+          activeTurnId: null,
+          updatedAt: createdAt
+        };
+      }
+      appendActivity(thread, {
+        kind: command.type,
+        summary: command.type.replace(/^thread\./, "").replaceAll(".", " "),
+        payload: command,
+        turnId: thread.latestTurn?.turnId ?? null,
+        createdAt
+      });
+      thread.updatedAt = createdAt;
+      return next;
+    }
+    case "thread.session.set": {
+      const thread = findMutableThread(next, command.threadId);
+      if (!thread)
+        return next;
+      thread.session = command.session;
+      thread.updatedAt = command.createdAt;
+      return next;
+    }
+    case "thread.message.assistant.delta": {
+      const thread = findMutableThread(next, command.threadId);
+      if (!thread)
+        return next;
+      upsertAssistantMessage(thread, command.messageId, command.createdAt);
+      thread.messages = thread.messages.map((message) => message.id === command.messageId ? {
+        ...message,
+        text: message.text + command.delta,
+        turnId: command.turnId ?? message.turnId,
+        streaming: true,
+        updatedAt: command.createdAt
+      } : message);
+      thread.updatedAt = command.createdAt;
+      return next;
+    }
+    case "thread.message.assistant.complete": {
+      const thread = findMutableThread(next, command.threadId);
+      if (!thread)
+        return next;
+      upsertAssistantMessage(thread, command.messageId, command.createdAt);
+      thread.messages = thread.messages.map((message) => message.id === command.messageId ? {
+        ...message,
+        turnId: command.turnId ?? message.turnId,
+        streaming: false,
+        updatedAt: command.createdAt
+      } : message);
+      if (thread.latestTurn) {
+        thread.latestTurn = {
+          ...thread.latestTurn,
+          state: "completed",
+          completedAt: command.createdAt,
+          assistantMessageId: command.messageId
+        };
+      }
+      if (thread.session) {
+        thread.session = {
+          ...thread.session,
+          status: "ready",
+          activeTurnId: null,
+          updatedAt: command.createdAt
+        };
+      }
+      thread.updatedAt = command.createdAt;
+      return next;
+    }
+    case "thread.proposed-plan.upsert": {
+      const thread = findMutableThread(next, command.threadId);
+      if (!thread)
+        return next;
+      upsertProposedPlan(thread, command.proposedPlan);
+      thread.updatedAt = command.createdAt;
+      return next;
+    }
+    case "thread.turn.diff.complete": {
+      const thread = findMutableThread(next, command.threadId);
+      if (!thread)
+        return next;
+      thread.checkpoints = [
+        ...thread.checkpoints.filter((checkpoint) => checkpoint.turnId !== command.turnId),
+        {
+          turnId: command.turnId,
+          checkpointTurnCount: command.checkpointTurnCount,
+          checkpointRef: command.checkpointRef,
+          status: command.status,
+          files: [...command.files],
+          assistantMessageId: command.assistantMessageId ?? null,
+          completedAt: command.completedAt
+        }
+      ];
+      if (thread.latestTurn?.turnId === command.turnId) {
+        thread.latestTurn = {
+          ...thread.latestTurn,
+          state: "completed",
+          completedAt: command.completedAt,
+          assistantMessageId: command.assistantMessageId ?? thread.latestTurn.assistantMessageId
+        };
+      }
+      thread.updatedAt = command.createdAt;
+      return next;
+    }
+    case "thread.activity.append": {
+      const thread = findMutableThread(next, command.threadId);
+      if (!thread)
+        return next;
+      thread.activities = [...thread.activities, command.activity];
+      thread.updatedAt = command.createdAt;
+      return next;
+    }
+    case "thread.revert.complete": {
+      const thread = findMutableThread(next, command.threadId);
+      if (!thread)
+        return next;
+      appendActivity(thread, {
+        kind: command.type,
+        summary: "revert complete",
+        payload: { turnCount: command.turnCount },
+        createdAt: command.createdAt
+      });
+      thread.updatedAt = command.createdAt;
+      return next;
+    }
+    case "thread.delete": {
+      next.threads = next.threads.filter((thread) => thread.id !== command.threadId);
+      return next;
+    }
+    default:
+      return next;
+  }
+}
+export {
+  createEmptyOrchestrationThread,
+  createEmptyOrchestrationReadModel,
+  createEmptyOrchestrationProject,
+  applyOrchestrationCommand
+};

package/dist/src/remote.js

@@ -0,0 +1,123 @@
+// @bun
+// packages/server/src/remote.ts
+function createConnectedRemoteConnection(endpointId, connectedAt = new Date().toISOString()) {
+  return {
+    endpointId,
+    status: "connected",
+    error: null,
+    connectedAt,
+    tokenExpiresAt: null,
+    latencyMs: null,
+    subscribedEvents: []
+  };
+}
+function createDisconnectedRemoteConnection(endpointId) {
+  return {
+    endpointId,
+    status: "disconnected",
+    error: null,
+    connectedAt: null,
+    tokenExpiresAt: null,
+    latencyMs: null,
+    subscribedEvents: []
+  };
+}
+function registerRemoteHost(input, acceptedAt = new Date().toISOString()) {
+  return {
+    workspaceId: input.workspaceId,
+    hostId: input.hostId,
+    name: input.name,
+    baseUrl: input.baseUrl,
+    workspacePath: input.workspacePath ?? null,
+    transport: input.transport ?? "websocket",
+    hostname: input.hostname ?? null,
+    region: input.region ?? null,
+    labels: [...input.labels ?? []],
+    capabilities: [...input.capabilities ?? []],
+    runtimeAdapters: [...input.runtimeAdapters ?? []],
+    status: input.status ?? "ready",
+    currentLeaseCount: input.currentLeaseCount ?? 0,
+    registeredAt: acceptedAt,
+    lastHeartbeatAt: acceptedAt
+  };
+}
+function heartbeatRemoteHost(host, input, acceptedAt = new Date().toISOString()) {
+  return {
+    ...host,
+    status: input.status ?? host.status,
+    currentLeaseCount: input.currentLeaseCount ?? host.currentLeaseCount,
+    lastHeartbeatAt: input.observedAt ?? acceptedAt
+  };
+}
+function createWorkspaceRemoteHostSummary(host, manifestPath) {
+  return {
+    id: host.hostId,
+    name: host.name,
+    baseUrl: host.baseUrl,
+    workspacePath: host.workspacePath,
+    transport: host.transport,
+    hostname: host.hostname,
+    region: host.region,
+    labels: [...host.labels],
+    capabilities: [...host.capabilities],
+    runtimeAdapters: [...host.runtimeAdapters],
+    status: host.status,
+    currentLeaseCount: host.currentLeaseCount,
+    lastHeartbeatAt: host.lastHeartbeatAt,
+    registeredAt: host.registeredAt,
+    manifestPath
+  };
+}
+function createRemoteLeaseAssignment(args) {
+  const claimedAt = args.claimedAt ?? new Date().toISOString();
+  const leaseId = args.leaseId ?? `lease-${args.run.runId}`;
+  return {
+    lease: {
+      leaseId,
+      runId: args.run.runId,
+      workspaceId: args.run.workspaceId,
+      title: args.run.title,
+      runtimeAdapter: args.run.runtimeAdapter,
+      model: args.run.model,
+      runtimeMode: args.run.runtimeMode,
+      interactionMode: args.run.interactionMode,
+      executionTarget: "remote",
+      remoteHostId: args.hostId,
+      claimedAt
+    },
+    bundle: {
+      workspaceId: args.run.workspaceId,
+      runId: args.run.runId,
+      leaseId,
+      workspacePath: args.workspacePath ?? null,
+      runtimeAdapter: args.run.runtimeAdapter,
+      model: args.run.model,
+      runtimeMode: args.run.runtimeMode,
+      interactionMode: args.run.interactionMode,
+      prompt: args.prompt,
+      conversation: [...args.conversation ?? []],
+      taskId: args.run.taskId,
+      taskTitle: args.run.title
+    }
+  };
+}
+function createRemoteOrchestrationSummary(input) {
+  return {
+    orchestrationId: input.orchestrationId,
+    endpointId: input.endpointId,
+    status: input.status,
+    totalTasks: input.totalTasks,
+    totalGroups: input.totalGroups,
+    maxParallelism: input.maxParallelism,
+    startedAt: input.startedAt ?? new Date().toISOString()
+  };
+}
+export {
+  registerRemoteHost,
+  heartbeatRemoteHost,
+  createWorkspaceRemoteHostSummary,
+  createRemoteOrchestrationSummary,
+  createRemoteLeaseAssignment,
+  createDisconnectedRemoteConnection,
+  createConnectedRemoteConnection
+};

package/dist/src/scheduler.js

@@ -0,0 +1,84 @@
+// @bun
+// packages/server/src/scheduler.ts
+import { normalizeTaskLifecycleStatus } from "@rig/runtime/control-plane/state-sync/types";
+var TERMINAL_RUN_STATUSES = new Set(["done", "completed", "error", "failed", "stopped", "cancelled"]);
+var RUNNABLE_TASK_STATUSES = new Set(["draft", "open", "ready", "queued"]);
+var REMOTE_READY_STATUSES = new Set(["ready", "idle", "connected"]);
+function resolveLocalSchedulerWorkerCount(env = process.env) {
+  const raw = env.RIG_SCHEDULER_LOCAL_WORKERS?.trim();
+  if (!raw) {
+    return Number.MAX_SAFE_INTEGER;
+  }
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed)) {
+    return Number.MAX_SAFE_INTEGER;
+  }
+  return Math.max(0, parsed);
+}
+function planSchedulerWork(input) {
+  const taskById = new Map(input.tasks.map((task) => [task.id, task]));
+  const activeTaskIds = new Set(input.runs.filter((run) => isActiveRun(run) && typeof run.taskId === "string" && run.taskId.length > 0).map((run) => run.taskId));
+  const activeLocalRuns = input.runs.filter((run) => isActiveRun(run) && typeof run.taskId === "string" && run.taskId.length > 0 && !isRemoteRun(run));
+  const occupiedRemoteHosts = new Set(input.runs.filter((run) => isActiveRun(run) && isRemoteRun(run) && typeof run.hostId === "string" && run.hostId.length > 0).map((run) => run.hostId));
+  const pruneTaskIds = [];
+  const eligibleQueue = input.queue.filter((entry) => {
+    const task = taskById.get(entry.taskId);
+    const normalizedStatus = task ? normalizeTaskLifecycleStatus(task.status) : null;
+    if (!task || !normalizedStatus || !RUNNABLE_TASK_STATUSES.has(normalizedStatus)) {
+      pruneTaskIds.push(entry.taskId);
+      return false;
+    }
+    if (activeTaskIds.has(entry.taskId)) {
+      pruneTaskIds.push(entry.taskId);
+      return false;
+    }
+    return true;
+  });
+  let freeLocalWorkers = Math.max(0, input.localWorkerCount - activeLocalRuns.length);
+  const dispatches = [];
+  const deferredForRemote = [];
+  for (const entry of eligibleQueue) {
+    if (freeLocalWorkers > 0) {
+      dispatches.push({ taskId: entry.taskId, workerKind: "local" });
+      freeLocalWorkers -= 1;
+      continue;
+    }
+    deferredForRemote.push(entry);
+  }
+  const availableRemoteWorkers = input.remoteWorkers.filter((worker) => REMOTE_READY_STATUSES.has(worker.status)).filter((worker) => !occupiedRemoteHosts.has(worker.hostId)).toSorted((left, right) => {
+    if (left.currentLeaseCount !== right.currentLeaseCount) {
+      return left.currentLeaseCount - right.currentLeaseCount;
+    }
+    return left.registeredAt.localeCompare(right.registeredAt) || left.hostId.localeCompare(right.hostId);
+  });
+  for (let index = 0;index < Math.min(deferredForRemote.length, availableRemoteWorkers.length); index += 1) {
+    const entry = deferredForRemote[index];
+    const worker = availableRemoteWorkers[index];
+    if (!entry || !worker) {
+      continue;
+    }
+    dispatches.push({
+      taskId: entry.taskId,
+      workerKind: "remote",
+      hostId: worker.hostId
+    });
+  }
+  return {
+    pruneTaskIds: Array.from(new Set(pruneTaskIds)),
+    dispatches
+  };
+}
+function isActiveRun(run) {
+  const status = normalizeStatus(run.status);
+  return !TERMINAL_RUN_STATUSES.has(status);
+}
+function isRemoteRun(run) {
+  return normalizeStatus(run.mode) === "remote";
+}
+function normalizeStatus(value) {
+  return typeof value === "string" ? value.trim().toLowerCase() : "";
+}
+export {
+  resolveLocalSchedulerWorkerCount,
+  planSchedulerWork
+};