@h-rig/server 0.0.6-alpha.0

package/dist/src/server-helpers/orchestration-ops.js

@@ -0,0 +1,287 @@
+// @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/orchestration.ts
+function createEmptyOrchestrationProject(input) {
+  return {
+    id: input.id,
+    title: input.title,
+    workspaceRoot: input.workspaceRoot,
+    defaultModel: input.defaultModel,
+    scripts: [],
+    createdAt: input.createdAt,
+    updatedAt: input.createdAt,
+    deletedAt: null
+  };
+}
+function createEmptyOrchestrationThread(input) {
+  return {
+    id: input.id,
+    projectId: input.projectId,
+    title: input.title,
+    model: input.model,
+    runtimeMode: input.runtimeMode,
+    interactionMode: input.interactionMode,
+    branch: input.branch,
+    worktreePath: input.worktreePath,
+    latestTurn: null,
+    createdAt: input.createdAt,
+    updatedAt: input.createdAt,
+    deletedAt: null,
+    messages: [],
+    proposedPlans: [],
+    activities: [],
+    checkpoints: [],
+    session: null
+  };
+}
+
+// packages/server/src/server-helpers/orchestration-ops.ts
+function buildOrchestrationSnapshot(state) {
+  return {
+    snapshotSequence: Math.max(0, state.sequence),
+    projects: state.orchestration.projects,
+    threads: state.orchestration.threads,
+    updatedAt: new Date().toISOString()
+  };
+}
+function findOrchestrationProject(state, projectId) {
+  return state.orchestration.projects.find((project) => project.id === projectId) ?? null;
+}
+function findOrchestrationThread(state, threadId) {
+  return state.orchestration.threads.find((thread) => thread.id === threadId) ?? null;
+}
+function appendOrchestrationActivity(thread, input) {
+  const activities = Array.isArray(thread.activities) ? [...thread.activities] : [];
+  activities.push({
+    id: `activity-${Date.now()}-${activities.length + 1}`,
+    tone: input.kind.includes("error") ? "error" : input.kind.includes("approval") ? "approval" : "info",
+    kind: input.kind,
+    summary: input.summary,
+    payload: input.payload ?? {},
+    turnId: input.turnId ?? null,
+    createdAt: input.createdAt
+  });
+  thread.activities = activities;
+  thread.updatedAt = input.createdAt;
+}
+function applyOrchestrationCommand(state, command) {
+  const type = normalizeString(command.type);
+  if (!type) {
+    throw new Error("command.type is required");
+  }
+  switch (type) {
+    case "project.create": {
+      const projectId = normalizeString(command.projectId);
+      const title = normalizeString(command.title);
+      const workspaceRoot = normalizeString(command.workspaceRoot);
+      const createdAt = normalizeString(command.createdAt) ?? new Date().toISOString();
+      if (!projectId || !title || !workspaceRoot) {
+        throw new Error("project.create requires projectId, title, and workspaceRoot");
+      }
+      const existing = findOrchestrationProject(state, projectId);
+      if (existing) {
+        existing.title = title;
+        existing.workspaceRoot = workspaceRoot;
+        existing.defaultModel = normalizeString(command.defaultModel);
+        existing.updatedAt = createdAt;
+        existing.deletedAt = null;
+      } else {
+        state.orchestration.projects.push(createEmptyOrchestrationProject({
+          id: projectId,
+          title,
+          workspaceRoot,
+          defaultModel: normalizeString(command.defaultModel),
+          createdAt
+        }));
+      }
+      return;
+    }
+    case "project.meta.update": {
+      const projectId = normalizeString(command.projectId);
+      const project = projectId ? findOrchestrationProject(state, projectId) : null;
+      if (!project)
+        return;
+      const nextTitle = normalizeString(command.title);
+      const nextWorkspaceRoot = normalizeString(command.workspaceRoot);
+      if (nextTitle)
+        project.title = nextTitle;
+      if (nextWorkspaceRoot)
+        project.workspaceRoot = nextWorkspaceRoot;
+      if ("defaultModel" in command)
+        project.defaultModel = normalizeString(command.defaultModel);
+      if (Array.isArray(command.scripts))
+        project.scripts = command.scripts;
+      project.updatedAt = new Date().toISOString();
+      return;
+    }
+    case "project.delete": {
+      const projectId = normalizeString(command.projectId);
+      if (!projectId)
+        return;
+      state.orchestration.projects = state.orchestration.projects.filter((project) => project.id !== projectId);
+      state.orchestration.threads = state.orchestration.threads.filter((thread) => thread.projectId !== projectId);
+      return;
+    }
+    case "thread.create": {
+      const threadId = normalizeString(command.threadId);
+      const projectId = normalizeString(command.projectId);
+      const title = normalizeString(command.title);
+      const model = normalizeString(command.model);
+      const runtimeMode = normalizeString(command.runtimeMode) ?? "full-access";
+      const interactionMode = normalizeString(command.interactionMode) ?? "default";
+      const createdAt = normalizeString(command.createdAt) ?? new Date().toISOString();
+      if (!threadId || !projectId || !title || !model) {
+        throw new Error("thread.create requires threadId, projectId, title, and model");
+      }
+      const existing = findOrchestrationThread(state, threadId);
+      if (existing) {
+        existing.title = title;
+        existing.model = model;
+        existing.runtimeMode = runtimeMode;
+        existing.interactionMode = interactionMode;
+        existing.branch = normalizeString(command.branch);
+        existing.worktreePath = normalizeString(command.worktreePath);
+        existing.updatedAt = createdAt;
+        existing.deletedAt = null;
+      } else {
+        state.orchestration.threads.push(createEmptyOrchestrationThread({
+          id: threadId,
+          projectId,
+          title,
+          model,
+          runtimeMode,
+          interactionMode,
+          branch: normalizeString(command.branch),
+          worktreePath: normalizeString(command.worktreePath),
+          createdAt
+        }));
+      }
+      return;
+    }
+    case "thread.meta.update": {
+      const threadId = normalizeString(command.threadId);
+      const thread = threadId ? findOrchestrationThread(state, threadId) : null;
+      if (!thread)
+        return;
+      const nextTitle = normalizeString(command.title);
+      const nextModel = normalizeString(command.model);
+      if (nextTitle)
+        thread.title = nextTitle;
+      if (nextModel)
+        thread.model = nextModel;
+      if ("branch" in command)
+        thread.branch = normalizeString(command.branch);
+      if ("worktreePath" in command)
+        thread.worktreePath = normalizeString(command.worktreePath);
+      thread.updatedAt = new Date().toISOString();
+      return;
+    }
+    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 threadId = normalizeString(command.threadId);
+      const thread = threadId ? findOrchestrationThread(state, threadId) : null;
+      if (!thread)
+        return;
+      const createdAt = normalizeString(command.createdAt) ?? new Date().toISOString();
+      if (type === "thread.runtime-mode.set") {
+        thread.runtimeMode = normalizeString(command.runtimeMode) ?? thread.runtimeMode;
+      }
+      if (type === "thread.interaction-mode.set") {
+        thread.interactionMode = normalizeString(command.interactionMode) ?? thread.interactionMode;
+      }
+      if (type === "thread.turn.start") {
+        const message = command.message && typeof command.message === "object" ? command.message : null;
+        const turnId = `turn-${Date.now()}`;
+        const messages = Array.isArray(thread.messages) ? [...thread.messages] : [];
+        if (message) {
+          messages.push({
+            id: normalizeString(message.messageId) ?? `message-${Date.now()}`,
+            role: "user",
+            text: typeof message.text === "string" ? message.text : "",
+            attachments: Array.isArray(message.attachments) ? message.attachments : [],
+            turnId,
+            streaming: false,
+            createdAt,
+            updatedAt: createdAt
+          });
+          thread.messages = messages;
+        }
+        thread.latestTurn = {
+          turnId,
+          state: "running",
+          requestedAt: createdAt,
+          startedAt: createdAt,
+          completedAt: null,
+          assistantMessageId: null
+        };
+        thread.session = {
+          threadId,
+          status: "running",
+          providerName: normalizeString(command.provider),
+          runtimeMode: normalizeString(command.runtimeMode) ?? thread.runtimeMode ?? "full-access",
+          activeTurnId: turnId,
+          lastError: null,
+          updatedAt: createdAt
+        };
+      }
+      if (type === "thread.turn.interrupt") {
+        if (thread.latestTurn && typeof thread.latestTurn === "object") {
+          thread.latestTurn = {
+            ...thread.latestTurn,
+            state: "interrupted",
+            completedAt: createdAt
+          };
+        }
+        if (thread.session && typeof thread.session === "object") {
+          thread.session = {
+            ...thread.session,
+            status: "interrupted",
+            updatedAt: createdAt
+          };
+        }
+      }
+      if (type === "thread.session.stop" && thread.session && typeof thread.session === "object") {
+        thread.session = {
+          ...thread.session,
+          status: "stopped",
+          activeTurnId: null,
+          updatedAt: createdAt
+        };
+      }
+      appendOrchestrationActivity(thread, {
+        kind: type,
+        summary: type.replace(/^thread\./, "").replaceAll(".", " "),
+        createdAt,
+        turnId: thread.latestTurn && typeof thread.latestTurn === "object" ? normalizeString(thread.latestTurn.turnId) : null,
+        payload: command
+      });
+      return;
+    }
+    case "thread.delete": {
+      const threadId = normalizeString(command.threadId);
+      if (!threadId)
+        return;
+      state.orchestration.threads = state.orchestration.threads.filter((thread) => thread.id !== threadId);
+      return;
+    }
+    default:
+      return;
+  }
+}
+export {
+  findOrchestrationThread,
+  findOrchestrationProject,
+  buildOrchestrationSnapshot,
+  applyOrchestrationCommand,
+  appendOrchestrationActivity
+};

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

@@ -0,0 +1,39 @@
+// @bun
+// packages/server/src/server-helpers/orchestration.ts
+function createEmptyOrchestrationProject(input) {
+  return {
+    id: input.id,
+    title: input.title,
+    workspaceRoot: input.workspaceRoot,
+    defaultModel: input.defaultModel,
+    scripts: [],
+    createdAt: input.createdAt,
+    updatedAt: input.createdAt,
+    deletedAt: null
+  };
+}
+function createEmptyOrchestrationThread(input) {
+  return {
+    id: input.id,
+    projectId: input.projectId,
+    title: input.title,
+    model: input.model,
+    runtimeMode: input.runtimeMode,
+    interactionMode: input.interactionMode,
+    branch: input.branch,
+    worktreePath: input.worktreePath,
+    latestTurn: null,
+    createdAt: input.createdAt,
+    updatedAt: input.createdAt,
+    deletedAt: null,
+    messages: [],
+    proposedPlans: [],
+    activities: [],
+    checkpoints: [],
+    session: null
+  };
+}
+export {
+  createEmptyOrchestrationThread,
+  createEmptyOrchestrationProject
+};

package/dist/src/server-helpers/plugin-host-cache.js

@@ -0,0 +1,86 @@
+// @bun
+var __require = import.meta.require;
+
+// packages/server/src/server-helpers/plugin-host-cache.ts
+import { existsSync, statSync } from "fs";
+import { resolve } from "path";
+var contextCache = new Map;
+var taskListCache = new Map;
+var DEFAULT_TASK_LIST_TTL_MS = 2000;
+function getPluginHostConfigMtime(projectRoot) {
+  for (const name of ["rig.config.ts", "rig.config.json"]) {
+    const path = resolve(projectRoot, name);
+    if (existsSync(path)) {
+      try {
+        return statSync(path).mtimeMs;
+      } catch {
+        return null;
+      }
+    }
+  }
+  return null;
+}
+async function getCachedPluginHostContext(projectRoot) {
+  const mtimeMs = getPluginHostConfigMtime(projectRoot);
+  if (mtimeMs === null) {
+    contextCache.delete(projectRoot);
+    return null;
+  }
+  const cached = contextCache.get(projectRoot);
+  if (cached && cached.mtimeMs === mtimeMs && cached.ctx) {
+    return cached.ctx;
+  }
+  try {
+    const { buildPluginHostContext } = await import("@rig/runtime/control-plane/plugin-host-context");
+    const ctx = await buildPluginHostContext(projectRoot);
+    if (!ctx) {
+      contextCache.delete(projectRoot);
+      return null;
+    }
+    contextCache.set(projectRoot, { mtimeMs, ctx });
+    return ctx;
+  } catch (err) {
+    contextCache.delete(projectRoot);
+    throw err;
+  }
+}
+async function getCachedTaskSourceList(projectRoot, options = {}) {
+  const ctx = await getCachedPluginHostContext(projectRoot);
+  if (!ctx)
+    return null;
+  const sources = ctx.taskSourceRegistry.list();
+  if (sources.length === 0)
+    return null;
+  const source = sources[0];
+  const cacheKey = `${projectRoot}::${source.kind}`;
+  const ttl = Math.max(0, options.ttlMs ?? DEFAULT_TASK_LIST_TTL_MS);
+  const now = Date.now();
+  if (!options.force) {
+    const cached = taskListCache.get(cacheKey);
+    if (cached && cached.expiresAt > now) {
+      return { kind: source.kind, tasks: cached.tasks };
+    }
+  }
+  const tasks = await source.list();
+  taskListCache.set(cacheKey, { expiresAt: now + ttl, tasks });
+  return { kind: source.kind, tasks };
+}
+function invalidatePluginHostCache(projectRoot) {
+  contextCache.delete(projectRoot);
+  for (const key of taskListCache.keys()) {
+    if (key.startsWith(`${projectRoot}::`)) {
+      taskListCache.delete(key);
+    }
+  }
+}
+function resetPluginHostCacheForTests() {
+  contextCache.clear();
+  taskListCache.clear();
+}
+export {
+  resetPluginHostCacheForTests,
+  invalidatePluginHostCache,
+  getPluginHostConfigMtime,
+  getCachedTaskSourceList,
+  getCachedPluginHostContext
+};

package/dist/src/server-helpers/project-fs-ops.js

@@ -0,0 +1,194 @@
+// @bun
+// packages/server/src/server-helpers/project-fs-ops.ts
+import { spawn, spawnSync } from "child_process";
+import { mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "fs";
+import { dirname, isAbsolute, relative, resolve } from "path";
+function normalizeRelativePath(cwd, relativePath) {
+  const safeRoot = resolve(cwd);
+  const resolvedPath = resolve(safeRoot, relativePath);
+  const relativeToRoot = relative(safeRoot, resolvedPath);
+  if (relativeToRoot.startsWith("..") || isAbsolute(relativeToRoot)) {
+    throw new Error("Path escapes workspace");
+  }
+  return resolvedPath;
+}
+function gitResult(projectRoot, args) {
+  const result = spawnSync("git", args, {
+    cwd: projectRoot,
+    encoding: "utf8"
+  });
+  return {
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+    exitCode: result.status ?? 1
+  };
+}
+function listDirectoryEntries(input) {
+  const targetPath = normalizeRelativePath(input.cwd, input.relativePath);
+  const entries = readdirSync(targetPath, { withFileTypes: true }).slice(0, input.limit).map((entry) => {
+    const fullPath = resolve(targetPath, entry.name);
+    const stat = statSync(fullPath);
+    return {
+      name: entry.name,
+      relativePath: input.relativePath === "." ? entry.name : `${input.relativePath.replace(/\/+$/, "")}/${entry.name}`,
+      kind: entry.isDirectory() ? "directory" : "file",
+      sizeBytes: entry.isDirectory() ? undefined : stat.size,
+      modifiedAt: stat.mtime.toISOString()
+    };
+  });
+  return {
+    entries,
+    truncated: readdirSync(targetPath).length > input.limit
+  };
+}
+function readProjectFile(input) {
+  const targetPath = normalizeRelativePath(input.cwd, input.relativePath);
+  const buffer = readFileSync(targetPath);
+  const maxBytes = 512 * 1024;
+  return {
+    relativePath: input.relativePath,
+    contents: buffer.subarray(0, maxBytes).toString("utf8"),
+    truncated: buffer.length > maxBytes,
+    sizeBytes: buffer.length,
+    maxBytes
+  };
+}
+function writeProjectFile(input) {
+  const targetPath = normalizeRelativePath(input.cwd, input.relativePath);
+  mkdirSync(dirname(targetPath), { recursive: true });
+  writeFileSync(targetPath, input.contents, "utf8");
+  return {
+    relativePath: input.relativePath
+  };
+}
+function searchProjectEntries(input) {
+  const results = [];
+  const query = input.query.toLowerCase();
+  const visit = (currentPath, relativePath = ".") => {
+    if (results.length >= input.limit)
+      return;
+    for (const entry of readdirSync(currentPath, { withFileTypes: true })) {
+      if (results.length >= input.limit)
+        return;
+      const nextRelative = relativePath === "." ? entry.name : `${relativePath}/${entry.name}`;
+      if (entry.name.toLowerCase().includes(query)) {
+        results.push({
+          path: nextRelative,
+          kind: entry.isDirectory() ? "directory" : "file",
+          ...relativePath === "." ? {} : { parentPath: relativePath }
+        });
+      }
+      if (entry.isDirectory() && !entry.name.startsWith(".git")) {
+        visit(resolve(currentPath, entry.name), nextRelative);
+      }
+    }
+  };
+  visit(input.cwd);
+  return {
+    entries: results,
+    truncated: results.length >= input.limit
+  };
+}
+function readGitStatus(cwd) {
+  const branch = gitResult(cwd, ["branch", "--show-current"]).stdout.trim() || null;
+  const shortStatus = gitResult(cwd, ["status", "--short"]).stdout.trim().split(/\r?\n/).filter(Boolean);
+  const diffStat = gitResult(cwd, ["diff", "--numstat"]).stdout.trim().split(/\r?\n/).filter(Boolean);
+  const files = diffStat.map((line) => {
+    const [insertionsRaw, deletionsRaw, ...pathParts] = line.split(/\t+/);
+    return {
+      path: pathParts.join("\t"),
+      insertions: Number.parseInt(insertionsRaw || "0", 10) || 0,
+      deletions: Number.parseInt(deletionsRaw || "0", 10) || 0
+    };
+  });
+  const aheadBehindRaw = branch ? gitResult(cwd, ["rev-list", "--left-right", "--count", `${branch}...@{upstream}`]) : { stdout: "", stderr: "", exitCode: 1 };
+  const [aheadRaw, behindRaw] = aheadBehindRaw.stdout.trim().split(/\s+/);
+  return {
+    branch,
+    hasWorkingTreeChanges: shortStatus.length > 0,
+    workingTree: {
+      files,
+      insertions: files.reduce((sum, file) => sum + file.insertions, 0),
+      deletions: files.reduce((sum, file) => sum + file.deletions, 0)
+    },
+    hasUpstream: aheadBehindRaw.exitCode === 0,
+    aheadCount: Number.parseInt(aheadRaw || "0", 10) || 0,
+    behindCount: Number.parseInt(behindRaw || "0", 10) || 0,
+    pr: null
+  };
+}
+function listGitBranches(cwd) {
+  const branchOutput = gitResult(cwd, ["branch", "--format=%(refname:short)|%(HEAD)"]).stdout;
+  const currentBranch = gitResult(cwd, ["branch", "--show-current"]).stdout.trim();
+  const branches = branchOutput.split(/\r?\n/).filter(Boolean).map((line) => {
+    const [name, headMarker] = line.split("|");
+    return {
+      name: name.trim(),
+      current: headMarker?.trim() === "*",
+      isDefault: name?.trim() === currentBranch,
+      worktreePath: cwd
+    };
+  });
+  return { branches, isRepo: branches.length > 0 || !!currentBranch };
+}
+function createGitWorktree(input) {
+  const worktreePath = input.path ?? resolve(input.cwd, "..", input.newBranch);
+  mkdirSync(dirname(worktreePath), { recursive: true });
+  const result = gitResult(input.cwd, [
+    "worktree",
+    "add",
+    "-b",
+    input.newBranch,
+    worktreePath,
+    input.branch
+  ]);
+  if (result.exitCode !== 0) {
+    throw new Error(result.stderr || "git worktree add failed");
+  }
+  return {
+    worktree: {
+      path: worktreePath,
+      branch: input.newBranch
+    }
+  };
+}
+function removeGitWorktree(input) {
+  const args = ["worktree", "remove"];
+  if (input.force) {
+    args.push("--force");
+  }
+  args.push(input.path);
+  const result = gitResult(input.cwd, args);
+  if (result.exitCode !== 0) {
+    throw new Error(result.stderr || "git worktree remove failed");
+  }
+}
+function readGitPatch(cwd, relativePath) {
+  const args = ["diff", "--", ...relativePath ? [relativePath] : []];
+  return {
+    diff: gitResult(cwd, args).stdout
+  };
+}
+function openInEditor(cwd, editor) {
+  if (editor === "file-manager") {
+    const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "explorer" : "xdg-open";
+    spawn(command, [cwd], { detached: true, stdio: "ignore" }).unref();
+    return;
+  }
+  const binary = editor === "vscode" ? "code" : editor === "cursor" ? "cursor" : editor;
+  spawn(binary, [cwd], { detached: true, stdio: "ignore" }).unref();
+}
+export {
+  writeProjectFile,
+  searchProjectEntries,
+  removeGitWorktree,
+  readProjectFile,
+  readGitStatus,
+  readGitPatch,
+  openInEditor,
+  normalizeRelativePath,
+  listGitBranches,
+  listDirectoryEntries,
+  gitResult,
+  createGitWorktree
+};