@h-rig/server 0.0.6-alpha.0

package/README.md

@@ -0,0 +1,14 @@
+# Rig Server
+
+`@rig/server` is the local server that powers desktop, web, and TUI flows.
+
+## Responsibilities
+
+- serve workspace snapshots and artifacts
+- broker approvals and remote endpoint state
+- expose websocket events for the UI
+
+## Commands
+
+- `bun run rig server start`
+- `bun test packages/server/src/server.test.ts`

package/dist/src/bootstrap.js

@@ -0,0 +1,161 @@
+// @bun
+// 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 normalizeOptionalBoolean(value, fallback) {
+  if (typeof value !== "string") {
+    return fallback;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (["1", "true", "yes", "on"].includes(normalized)) {
+    return true;
+  }
+  if (["0", "false", "no", "off"].includes(normalized)) {
+    return false;
+  }
+  return fallback;
+}
+function parseRigServerArgs(args, env = process.env) {
+  const command = args[0] || "start";
+  if (command !== "start" && command !== "notify-test") {
+    throw new Error(`Unknown command: ${command}`);
+  }
+  let host = env.RIG_SERVER_HOST || "127.0.0.1";
+  let port = Number.parseInt(env.RIG_SERVER_PORT || "8787", 10);
+  let pollMs = Number.parseInt(env.RIG_SERVER_POLL_MS || "1000", 10);
+  let upstreamSyncMs = Number.parseInt(env.RIG_SERVER_UPSTREAM_SYNC_MS || "900000", 10);
+  let upstreamSyncOnStart = normalizeOptionalBoolean(env.RIG_SERVER_UPSTREAM_SYNC_ON_START, true);
+  let authToken = normalizeOptionalString(env.RIG_SERVER_AUTH_TOKEN);
+  let eventType = "manual.test";
+  for (let index = 1;index < args.length; index += 1) {
+    const current = args[index];
+    const next = args[index + 1];
+    if (current === "--host") {
+      if (!next)
+        throw new Error("Missing value for --host");
+      host = next;
+      index += 1;
+      continue;
+    }
+    if (current === "--port") {
+      if (!next)
+        throw new Error("Missing value for --port");
+      port = Number.parseInt(next, 10);
+      index += 1;
+      continue;
+    }
+    if (current === "--poll-ms") {
+      if (!next)
+        throw new Error("Missing value for --poll-ms");
+      pollMs = Number.parseInt(next, 10);
+      index += 1;
+      continue;
+    }
+    if (current === "--upstream-sync-ms") {
+      if (!next)
+        throw new Error("Missing value for --upstream-sync-ms");
+      upstreamSyncMs = Number.parseInt(next, 10);
+      index += 1;
+      continue;
+    }
+    if (current === "--upstream-sync-on-start") {
+      upstreamSyncOnStart = true;
+      continue;
+    }
+    if (current === "--no-upstream-sync-on-start") {
+      upstreamSyncOnStart = false;
+      continue;
+    }
+    if (current === "--auth-token") {
+      if (!next)
+        throw new Error("Missing value for --auth-token");
+      authToken = normalizeOptionalString(next);
+      index += 1;
+      continue;
+    }
+    if (current === "--event") {
+      if (!next)
+        throw new Error("Missing value for --event");
+      eventType = next;
+      index += 1;
+      continue;
+    }
+    throw new Error(`Unknown option: ${current}`);
+  }
+  if (!Number.isFinite(port) || port < 0) {
+    throw new Error(`Invalid --port: ${port}`);
+  }
+  if (!Number.isFinite(pollMs) || pollMs <= 0) {
+    throw new Error(`Invalid --poll-ms: ${pollMs}`);
+  }
+  if (!Number.isFinite(upstreamSyncMs) || upstreamSyncMs < 0) {
+    throw new Error(`Invalid --upstream-sync-ms: ${upstreamSyncMs}`);
+  }
+  return { command, host, port, pollMs, upstreamSyncMs, upstreamSyncOnStart, authToken, eventType };
+}
+function resolvePublishedRigServerStatePath(projectRoot) {
+  return resolve(resolveRigServerPaths(projectRoot).stateDir, "rig-server.json");
+}
+function publishRigServerState(projectRoot, payload) {
+  const filePath = resolvePublishedRigServerStatePath(projectRoot);
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, `${JSON.stringify(payload, null, 2)}
+`, "utf8");
+}
+function clearPublishedRigServerState(projectRoot) {
+  const filePath = resolvePublishedRigServerStatePath(projectRoot);
+  if (!existsSync(filePath)) {
+    return;
+  }
+  try {
+    unlinkSync(filePath);
+  } catch {}
+}
+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")
+  };
+}
+function resolveRigProjectRoot(input) {
+  if (input?.envProjectRoot) {
+    return input.envProjectRoot;
+  }
+  const cwd = input?.cwd ?? process.cwd();
+  const fallbackRoot = input?.fallbackRoot ?? cwd;
+  const candidates = [cwd, fallbackRoot];
+  for (const candidate of candidates) {
+    if (existsSync(resolve(candidate, RIG_DEFINITION_DIRNAME))) {
+      return candidate;
+    }
+  }
+  return fallbackRoot;
+}
+export {
+  resolveRigServerPaths,
+  resolveRigProjectRoot,
+  resolvePublishedRigServerStatePath,
+  publishRigServerState,
+  parseRigServerArgs,
+  clearPublishedRigServerState
+};