@h-rig/cli 0.0.6-alpha.0

package/dist/src/commands/_snapshot-upload.js

@@ -0,0 +1,313 @@
+// @bun
+// packages/cli/src/commands/_snapshot-upload.ts
+import { mkdir, readdir, readFile, writeFile } from "fs/promises";
+import { dirname as dirname2, resolve as resolve2, relative, sep } from "path";
+
+// packages/cli/src/commands/_server-client.ts
+import { spawnSync } from "child_process";
+
+// packages/cli/src/runner.ts
+import { EventBus } from "@rig/runtime/control-plane/runtime/events";
+import { CliError } from "@rig/runtime/control-plane/errors";
+import { evaluate, loadPolicy, resolveAction } from "@rig/runtime/control-plane/runtime/guard";
+import { PluginManager } from "@rig/runtime/control-plane/runtime/plugins";
+import { loadRuntimeContextFromEnv } from "@rig/runtime/control-plane/runtime/context";
+import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
+import { CliError as CliError2 } from "@rig/runtime/control-plane/errors";
+
+// packages/cli/src/commands/_server-client.ts
+import { ensureLocalRigServerConnection } from "@rig/runtime/local-server";
+
+// packages/cli/src/commands/_connection-state.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, resolve } from "path";
+function resolveGlobalConnectionsPath(env = process.env) {
+  const explicit = env.RIG_CONNECTIONS_FILE?.trim();
+  if (explicit)
+    return resolve(explicit);
+  const stateDir = env.RIG_GLOBAL_STATE_DIR?.trim();
+  if (stateDir)
+    return resolve(stateDir, "connections.json");
+  return resolve(homedir(), ".rig", "connections.json");
+}
+function resolveRepoConnectionPath(projectRoot) {
+  return resolve(projectRoot, ".rig", "state", "connection.json");
+}
+function readJsonFile(path) {
+  if (!existsSync(path))
+    return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch (error) {
+    throw new CliError2(`Invalid Rig connection state at ${path}: ${error instanceof Error ? error.message : String(error)}`, 1);
+  }
+}
+function normalizeConnection(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return null;
+  const record = value;
+  if (record.kind === "local")
+    return { kind: "local", mode: "auto" };
+  if (record.kind === "remote" && typeof record.baseUrl === "string" && record.baseUrl.trim()) {
+    const baseUrl = record.baseUrl.trim().replace(/\/+$/, "");
+    return { kind: "remote", baseUrl };
+  }
+  return null;
+}
+function readGlobalConnections(options = {}) {
+  const path = resolveGlobalConnectionsPath(options.env ?? process.env);
+  const payload = readJsonFile(path);
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    return { connections: {} };
+  }
+  const rawConnections = payload.connections;
+  const connections = {};
+  if (rawConnections && typeof rawConnections === "object" && !Array.isArray(rawConnections)) {
+    for (const [alias, raw] of Object.entries(rawConnections)) {
+      const connection = normalizeConnection(raw);
+      if (connection)
+        connections[alias] = connection;
+    }
+  }
+  return { connections };
+}
+function readRepoConnection(projectRoot) {
+  const payload = readJsonFile(resolveRepoConnectionPath(projectRoot));
+  if (!payload || typeof payload !== "object" || Array.isArray(payload))
+    return null;
+  const record = payload;
+  const selected = typeof record.selected === "string" ? record.selected.trim() : "";
+  if (!selected)
+    return null;
+  return {
+    selected,
+    project: typeof record.project === "string" ? record.project : undefined,
+    linkedAt: typeof record.linkedAt === "string" ? record.linkedAt : undefined
+  };
+}
+function resolveSelectedConnection(projectRoot, options = {}) {
+  const repo = readRepoConnection(projectRoot);
+  if (!repo)
+    return null;
+  if (repo.selected === "local")
+    return { alias: "local", connection: { kind: "local", mode: "auto" } };
+  const global = readGlobalConnections(options);
+  const connection = global.connections[repo.selected];
+  if (!connection) {
+    throw new CliError2(`Selected Rig connection "${repo.selected}" was not found. Run \`rig connect list\` or \`rig connect use local\`.`, 1);
+  }
+  return { alias: repo.selected, connection };
+}
+
+// packages/cli/src/commands/_server-client.ts
+var cachedGitHubBearerToken;
+function cleanToken(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : null;
+}
+function readGitHubBearerTokenForRemote() {
+  if (cachedGitHubBearerToken !== undefined)
+    return cachedGitHubBearerToken;
+  const envToken = cleanToken(process.env.RIG_GITHUB_TOKEN) ?? cleanToken(process.env.GITHUB_TOKEN) ?? cleanToken(process.env.GH_TOKEN);
+  if (envToken) {
+    cachedGitHubBearerToken = envToken;
+    return cachedGitHubBearerToken;
+  }
+  const result = spawnSync("gh", ["auth", "token"], {
+    encoding: "utf8",
+    timeout: 5000,
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  cachedGitHubBearerToken = result.status === 0 ? cleanToken(result.stdout) : null;
+  return cachedGitHubBearerToken;
+}
+async function ensureServerForCli(projectRoot) {
+  try {
+    const selected = resolveSelectedConnection(projectRoot);
+    if (selected?.connection.kind === "remote") {
+      return {
+        baseUrl: selected.connection.baseUrl,
+        authToken: readGitHubBearerTokenForRemote(),
+        connectionKind: "remote"
+      };
+    }
+    const connection = await ensureLocalRigServerConnection(projectRoot);
+    return {
+      baseUrl: connection.baseUrl,
+      authToken: connection.authToken,
+      connectionKind: "local"
+    };
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new CliError2(error.message, 1);
+    }
+    throw error;
+  }
+}
+function mergeHeaders(headers, authToken) {
+  const merged = new Headers(headers);
+  if (authToken) {
+    merged.set("authorization", `Bearer ${authToken}`);
+  }
+  return merged;
+}
+function diagnosticMessage(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload))
+    return null;
+  const record = payload;
+  const diagnostics = Array.isArray(record.diagnostics) ? record.diagnostics : [];
+  const messages = diagnostics.flatMap((entry) => {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry))
+      return [];
+    const diagnostic = entry;
+    const kind = typeof diagnostic.kind === "string" ? diagnostic.kind : "task-source";
+    const message = typeof diagnostic.message === "string" ? diagnostic.message : null;
+    return message ? [`${kind}: ${message}`] : [];
+  });
+  return messages.length > 0 ? messages.join("; ") : null;
+}
+async function requestServerJson(context, pathname, init = {}) {
+  const server = await ensureServerForCli(context.projectRoot);
+  const response = await fetch(`${server.baseUrl}${pathname}`, {
+    ...init,
+    headers: mergeHeaders(init.headers, server.authToken)
+  });
+  const text = await response.text();
+  const payload = text.trim().length > 0 ? (() => {
+    try {
+      return JSON.parse(text);
+    } catch {
+      return null;
+    }
+  })() : null;
+  if (!response.ok) {
+    const diagnostics = diagnosticMessage(payload);
+    const detail = diagnostics ?? (text || response.statusText);
+    throw new CliError2(`Rig server request failed (${response.status}): ${detail}`, 1);
+  }
+  return payload;
+}
+
+// packages/cli/src/commands/_snapshot-upload.ts
+var UPLOADED_SNAPSHOT_PR_MARKER = "<!-- rig:uploaded-snapshot -->";
+var SNAPSHOT_ARCHIVE_VERSION = 1;
+var SNAPSHOT_ARCHIVE_CONTENT_TYPE = "application/vnd.rig.snapshot+json";
+var DEFAULT_EXCLUDED_DIRECTORIES = new Set([
+  ".git",
+  ".rig",
+  "node_modules",
+  ".turbo",
+  ".next",
+  ".cache",
+  "coverage",
+  "dist",
+  "build",
+  "out"
+]);
+function toPosixPath(path) {
+  return path.split(sep).join("/");
+}
+function assertManifestPath(root, relativePath) {
+  if (!relativePath || relativePath.startsWith("/") || relativePath.includes("\x00")) {
+    throw new Error(`Invalid snapshot path: ${relativePath}`);
+  }
+  const resolved = resolve2(root, relativePath);
+  const relativeToRoot = relative(root, resolved);
+  if (relativeToRoot.startsWith("..") || relativeToRoot === ".." || resolve2(relativeToRoot) === resolved) {
+    throw new Error(`Snapshot path escapes project root: ${relativePath}`);
+  }
+  return resolved;
+}
+async function buildSnapshotUploadManifest(projectRoot, options = {}) {
+  const root = resolve2(projectRoot);
+  const excludedDirectories = [...new Set([
+    ...DEFAULT_EXCLUDED_DIRECTORIES,
+    ...options.excludedDirectories ?? []
+  ])];
+  const excludedSet = new Set(excludedDirectories);
+  const files = [];
+  async function visit(dir) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && excludedSet.has(entry.name))
+        continue;
+      const fullPath = resolve2(dir, entry.name);
+      if (entry.isDirectory()) {
+        await visit(fullPath);
+        continue;
+      }
+      if (!entry.isFile())
+        continue;
+      files.push(toPosixPath(relative(root, fullPath)));
+    }
+  }
+  await visit(root);
+  files.sort();
+  return { root, files, excludedDirectories };
+}
+async function createSnapshotUploadArchive(projectRoot, options = {}) {
+  const manifest = await buildSnapshotUploadManifest(projectRoot, options);
+  const files = await Promise.all(manifest.files.map(async (path) => {
+    const fullPath = assertManifestPath(manifest.root, path);
+    return {
+      path,
+      contentBase64: (await readFile(fullPath)).toString("base64")
+    };
+  }));
+  return {
+    version: SNAPSHOT_ARCHIVE_VERSION,
+    root: manifest.root,
+    files,
+    excludedDirectories: manifest.excludedDirectories,
+    createdAt: (options.now?.() ?? new Date).toISOString()
+  };
+}
+function encodeSnapshotUploadArchive(archive) {
+  return Buffer.from(JSON.stringify(archive), "utf8").toString("base64");
+}
+async function writeSnapshotUploadArchive(projectRoot, outputPath, options = {}) {
+  const archive = await createSnapshotUploadArchive(projectRoot, options);
+  const target = resolve2(outputPath);
+  await mkdir(dirname2(target), { recursive: true });
+  await writeFile(target, JSON.stringify(archive, null, 2), "utf8");
+  return archive;
+}
+async function uploadSnapshotArchiveViaServer(context, input) {
+  const payload = await requestServerJson(context, `/api/projects/${encodeURIComponent(input.repoSlug)}/upload-snapshot`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      archiveContentBase64: encodeSnapshotUploadArchive(input.archive),
+      contentType: SNAPSHOT_ARCHIVE_CONTENT_TYPE,
+      baseDir: input.baseDir
+    })
+  });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+}
+function appendUploadedSnapshotPrNotice(body) {
+  if (body.includes(UPLOADED_SNAPSHOT_PR_MARKER))
+    return body;
+  const prefix = body.trimEnd();
+  const notice = [
+    UPLOADED_SNAPSHOT_PR_MARKER,
+    "This PR was seeded from an uploaded local working-tree snapshot. Review local snapshot provenance before merging if repository policy requires it."
+  ].join(`
+`);
+  return prefix.length > 0 ? `${prefix}
+
+${notice}
+` : `${notice}
+`;
+}
+export {
+  writeSnapshotUploadArchive,
+  uploadSnapshotArchiveViaServer,
+  encodeSnapshotUploadArchive,
+  createSnapshotUploadArchive,
+  buildSnapshotUploadManifest,
+  appendUploadedSnapshotPrNotice,
+  UPLOADED_SNAPSHOT_PR_MARKER,
+  SNAPSHOT_ARCHIVE_VERSION,
+  SNAPSHOT_ARCHIVE_CONTENT_TYPE
+};

package/dist/src/commands/_task-picker.js

@@ -0,0 +1,48 @@
+// @bun
+// packages/cli/src/commands/_task-picker.ts
+import { createInterface } from "readline/promises";
+function taskId(task) {
+  return typeof task.id === "string" && task.id.trim() ? task.id : "<unknown>";
+}
+function taskTitle(task) {
+  return typeof task.title === "string" && task.title.trim() ? task.title : "Untitled task";
+}
+function taskStatus(task) {
+  return typeof task.status === "string" && task.status.trim() ? task.status : "unknown";
+}
+function renderTaskPickerRows(tasks) {
+  return tasks.map((task, index) => `${index + 1}. ${taskId(task)} \xB7 ${taskStatus(task)} \xB7 ${taskTitle(task)}`);
+}
+async function selectTaskWithTextPicker(tasks, io = {}) {
+  if (tasks.length === 0)
+    return null;
+  if (tasks.length === 1)
+    return tasks[0];
+  const isTty = io.isTty ?? Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  if (!isTty) {
+    throw new Error("task run requires an interactive terminal to pick a task; pass --task <id>, --next, or --detach with a task id.");
+  }
+  const prompt = io.prompt ?? (async (question) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+      return await rl.question(question);
+    } finally {
+      rl.close();
+    }
+  });
+  console.log("Select Rig task:");
+  for (const row of renderTaskPickerRows(tasks))
+    console.log(`  ${row}`);
+  const answer = (await prompt(`Task [1-${tasks.length}] or id: `)).trim();
+  if (!answer)
+    return null;
+  if (/^\d+$/.test(answer)) {
+    const index = Number.parseInt(answer, 10) - 1;
+    return tasks[index] ?? null;
+  }
+  return tasks.find((task) => taskId(task) === answer) ?? null;
+}
+export {
+  selectTaskWithTextPicker,
+  renderTaskPickerRows
+};