@h-rig/cli-surface-plugin 0.0.6-alpha.146

package/dist/src/commands/remote.js

@@ -0,0 +1,516 @@
+// @bun
+// packages/cli-surface-plugin/src/runner.ts
+import { EventBus } from "@rig/runtime/control-plane/runtime/events";
+import { CliError as RuntimeCliError } from "@rig/runtime/control-plane/errors";
+import { evaluate, loadPolicy, resolveAction } from "@rig/runtime/control-plane/runtime/guard";
+import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
+
+class CliError extends RuntimeCliError {
+  hint;
+  constructor(message, exitCode = 1, options = {}) {
+    super(message, exitCode);
+    if (options.hint?.trim()) {
+      this.hint = options.hint.trim();
+    }
+  }
+}
+function takeFlag(args, flag) {
+  const rest = [];
+  let value = false;
+  for (const arg of args) {
+    if (arg === flag) {
+      value = true;
+      continue;
+    }
+    rest.push(arg);
+  }
+  return { value, rest };
+}
+function takeOption(args, option) {
+  const rest = [];
+  let value;
+  for (let index = 0;index < args.length; index += 1) {
+    const current = args[index];
+    if (current === option) {
+      const next = args[index + 1];
+      if (!next || next.startsWith("-")) {
+        throw new CliError(`Missing value for ${option}`, 1, { hint: `Provide a value after ${option}, e.g. \`${option} <value>\`.` });
+      }
+      value = next;
+      index += 1;
+      continue;
+    }
+    if (current !== undefined) {
+      rest.push(current);
+    }
+  }
+  return { value, rest };
+}
+function requireNoExtraArgs(args, usage) {
+  if (args.length > 0) {
+    throw new CliError(`Unexpected arguments: ${args.join(" ")}
+Usage: ${usage}`);
+  }
+}
+function requireTask(taskId, usage) {
+  if (!taskId) {
+    throw new CliError(`Missing --task option.
+Usage: ${usage}`);
+  }
+  return taskId;
+}
+
+// packages/cli-surface-plugin/src/commands/remote.ts
+import {
+  doctorAuthorityRemoteEndpoints as doctorManagedRemoteEndpoints,
+  importLegacyRemoteEndpoints as migrateManagedRemoteEndpoints,
+  listManagedRemoteEndpoints,
+  RemoteCliError,
+  removeManagedRemoteEndpoint,
+  updateAuthorityRemoteEndpoint as updateManagedRemoteEndpointInAuthority,
+  upsertManagedRemoteEndpoint
+} from "@rig/runtime/control-plane/remote-config";
+import {
+  matchesEventFilter,
+  RemoteWsClient,
+  resolveRemoteEndpoint,
+  summarizeMessage
+} from "@rig/runtime/control-plane/remote";
+
+// packages/cli-surface-plugin/src/commands/_parsers.ts
+function parseOptionalPositiveInt(value, option) {
+  if (!value) {
+    return;
+  }
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new CliError(`Invalid ${option} value: ${value}`, 1, { hint: `Pass a positive integer, e.g. \`${option} 10\`.` });
+  }
+  return parsed;
+}
+function parseRequiredPositiveInt(value, option) {
+  if (!value) {
+    throw new CliError(`Missing value for ${option}.`, 1, { hint: `Provide a value after ${option}, e.g. \`${option} 10\`.` });
+  }
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new CliError(`Invalid ${option} value: ${value}`, 1, { hint: `Pass a positive integer, e.g. \`${option} 10\`.` });
+  }
+  return parsed;
+}
+
+// packages/cli-surface-plugin/src/commands/remote.ts
+function assertRemoteOperationSuccess(command, response) {
+  if (!("success" in response)) {
+    return;
+  }
+  if (response.success === false) {
+    const error = typeof response.error === "string" && response.error || `${command} failed without explicit error detail from remote server.`;
+    throw new RemoteCliError("RIG_REMOTE_OPERATION_FAILED", error, 3, { command, response: redactSecretFields(response) });
+  }
+}
+function redactRemoteEndpoint(endpoint) {
+  const { token, ...rest } = endpoint;
+  return {
+    ...rest,
+    token: "",
+    tokenConfigured: token.trim().length > 0
+  };
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isSecretKey(key) {
+  const normalized = key.toLowerCase();
+  return normalized === "token" || normalized === "authtoken" || normalized === "authorization" || normalized === "connectiontoken" || normalized === "access_token" || normalized === "secret";
+}
+function redactSecretFields(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => redactSecretFields(entry));
+  }
+  if (!isRecord(value)) {
+    return value;
+  }
+  const redacted = {};
+  for (const [key, entry] of Object.entries(value)) {
+    redacted[key] = isSecretKey(key) && typeof entry === "string" ? entry.trim().length > 0 ? "[redacted]" : "" : redactSecretFields(entry);
+  }
+  return redacted;
+}
+async function executeRemote(context, args) {
+  const [command = "status", ...rest] = args;
+  if (command === "endpoint" || command === "endpoints") {
+    const [subcommand = "list", ...subRest] = rest;
+    switch (subcommand) {
+      case "list": {
+        requireNoExtraArgs(subRest, "rig remote endpoint list");
+        const endpoints = listManagedRemoteEndpoints(undefined, context.projectRoot);
+        const redactedEndpoints = endpoints.map((endpoint2) => redactRemoteEndpoint(endpoint2));
+        if (context.outputMode === "text") {
+          if (endpoints.length === 0) {
+            console.log("No remote endpoints configured.");
+          } else {
+            for (const endpoint2 of endpoints) {
+              console.log(`- ${endpoint2.alias} \xB7 ${endpoint2.host}:${endpoint2.port}${endpoint2.lastConnected ? ` \xB7 last connected ${endpoint2.lastConnected}` : ""}`);
+            }
+          }
+        }
+        return { ok: true, group: "remote", command: "endpoint list", details: { endpoints: redactedEndpoints } };
+      }
+      case "add": {
+        let pending2 = subRest;
+        const alias = takeOption(pending2, "--alias");
+        pending2 = alias.rest;
+        const host = takeOption(pending2, "--host");
+        pending2 = host.rest;
+        const port = takeOption(pending2, "--port");
+        pending2 = port.rest;
+        const token = takeOption(pending2, "--token");
+        pending2 = token.rest;
+        requireNoExtraArgs(pending2, "rig remote endpoint add --alias <a> --host <h> --port <n> --token <t>");
+        if (!alias.value || !host.value || !token.value || !port.value) {
+          throw new CliError("remote endpoint add requires --alias, --host, --port, and --token.", 1, { hint: "Re-run as `rig remote endpoint add --alias <a> --host <h> --port <n> --token <t>`." });
+        }
+        const created = upsertManagedRemoteEndpoint({
+          alias: alias.value,
+          host: host.value,
+          port: parseRequiredPositiveInt(port.value, "--port"),
+          token: token.value
+        }, undefined, context.projectRoot);
+        if (context.outputMode === "text") {
+          console.log(`Saved remote endpoint ${created.alias} -> ${created.host}:${created.port}`);
+        }
+        return { ok: true, group: "remote", command: "endpoint add", details: redactRemoteEndpoint(created) };
+      }
+      case "update": {
+        let pending2 = subRest;
+        const endpointId = takeOption(pending2, "--id");
+        pending2 = endpointId.rest;
+        const alias = takeOption(pending2, "--alias");
+        pending2 = alias.rest;
+        const host = takeOption(pending2, "--host");
+        pending2 = host.rest;
+        const port = takeOption(pending2, "--port");
+        pending2 = port.rest;
+        const token = takeOption(pending2, "--token");
+        pending2 = token.rest;
+        requireNoExtraArgs(pending2, "rig remote endpoint update --id <id> [--alias <a>] [--host <h>] [--port <n>] [--token <t>]");
+        if (!endpointId.value && !alias.value) {
+          throw new CliError("remote endpoint update requires --id <id> or --alias <a>.", 1, { hint: "List endpoints with `rig remote endpoint list`, then pass --id or --alias." });
+        }
+        const updated = updateManagedRemoteEndpointInAuthority(context.projectRoot, {
+          endpointId: endpointId.value || undefined,
+          alias: alias.value || undefined,
+          host: host.value || undefined,
+          port: port.value ? parseRequiredPositiveInt(port.value, "--port") : undefined,
+          token: token.value || undefined
+        });
+        if (!updated) {
+          throw new CliError("Remote endpoint not found.", 2, { hint: "Run `rig remote endpoint list` to see configured endpoints." });
+        }
+        if (context.outputMode === "text") {
+          console.log(`Updated remote endpoint ${updated.alias} -> ${updated.host}:${updated.port}`);
+        }
+        return { ok: true, group: "remote", command: "endpoint update", details: redactRemoteEndpoint(updated) };
+      }
+      case "remove": {
+        let pending2 = subRest;
+        const alias = takeOption(pending2, "--alias");
+        pending2 = alias.rest;
+        requireNoExtraArgs(pending2, "rig remote endpoint remove --alias <a>");
+        if (!alias.value) {
+          throw new CliError("remote endpoint remove requires --alias.", 1, { hint: "Run `rig remote endpoint list` to find the alias, then `rig remote endpoint remove --alias <a>`." });
+        }
+        const removed = removeManagedRemoteEndpoint(alias.value, undefined, context.projectRoot);
+        if (!removed) {
+          throw new CliError(`Remote endpoint alias not found: ${alias.value}`, 2, { hint: "Run `rig remote endpoint list` to see configured endpoint aliases." });
+        }
+        if (context.outputMode === "text") {
+          console.log(`Removed remote endpoint ${alias.value}`);
+        }
+        return { ok: true, group: "remote", command: "endpoint remove", details: { alias: alias.value } };
+      }
+      case "test": {
+        let pending2 = subRest;
+        const alias = takeOption(pending2, "--alias");
+        pending2 = alias.rest;
+        requireNoExtraArgs(pending2, "rig remote endpoint test --alias <a>");
+        if (!alias.value) {
+          throw new CliError("remote endpoint test requires --alias.", 1, { hint: "Run `rig remote endpoint list` to find the alias, then `rig remote endpoint test --alias <a>`." });
+        }
+        const endpoint2 = resolveRemoteEndpoint({ remoteAlias: alias.value, projectRoot: context.projectRoot });
+        const client = new RemoteWsClient(endpoint2);
+        const startedAt = Date.now();
+        try {
+          await client.connect();
+          const response = await client.ping();
+          const latencyMs = Date.now() - startedAt;
+          if (context.outputMode === "text") {
+            console.log(`Remote endpoint ${alias.value} responded in ${latencyMs}ms.`);
+          }
+          return {
+            ok: true,
+            group: "remote",
+            command: "endpoint test",
+            details: {
+              alias: alias.value,
+              host: endpoint2.host,
+              port: endpoint2.port,
+              latencyMs,
+              response: redactSecretFields(response)
+            }
+          };
+        } finally {
+          client.disconnect();
+        }
+      }
+      case "migrate": {
+        requireNoExtraArgs(subRest, "rig remote endpoint migrate");
+        const result = migrateManagedRemoteEndpoints(context.projectRoot);
+        if (context.outputMode === "text") {
+          console.log(`Imported ${result.imported} endpoint(s) from ${result.sourcePath}${result.skipped > 0 ? `, skipped ${result.skipped}` : ""}.`);
+        }
+        return { ok: true, group: "remote", command: "endpoint migrate", details: result };
+      }
+      case "doctor": {
+        requireNoExtraArgs(subRest, "rig remote endpoint doctor");
+        const result = doctorManagedRemoteEndpoints(context.projectRoot);
+        if (context.outputMode === "text") {
+          console.log(JSON.stringify(result, null, 2));
+        }
+        return { ok: true, group: "remote", command: "endpoint doctor", details: result };
+      }
+      default:
+        throw new CliError(`Unknown remote endpoint command: ${subcommand}`, 1, { hint: "Run `rig remote --help` for endpoint commands (list|add|update|remove|test)." });
+    }
+  }
+  let pending = rest;
+  const remoteAliasResult = takeOption(pending, "--remote");
+  pending = remoteAliasResult.rest;
+  const hostResult = takeOption(pending, "--host");
+  pending = hostResult.rest;
+  const portResult = takeOption(pending, "--port");
+  pending = portResult.rest;
+  const tokenResult = takeOption(pending, "--token");
+  pending = tokenResult.rest;
+  const endpoint = resolveRemoteEndpoint({
+    host: hostResult.value,
+    port: portResult.value,
+    token: tokenResult.value,
+    remoteAlias: remoteAliasResult.value,
+    projectRoot: context.projectRoot
+  });
+  const remoteMeta = {
+    source: endpoint.source,
+    alias: endpoint.alias || null,
+    host: endpoint.host,
+    port: endpoint.port
+  };
+  const withClient = async (runner) => {
+    const client = new RemoteWsClient(endpoint);
+    try {
+      await client.connect();
+      return await runner(client);
+    } finally {
+      client.disconnect();
+    }
+  };
+  const toDetails = (response) => ({
+    command: `remote ${command}`,
+    remote: remoteMeta,
+    requestId: response.id || null,
+    messageType: response.type,
+    payload: redactSecretFields(response),
+    error: null
+  });
+  try {
+    switch (command) {
+      case "test": {
+        requireNoExtraArgs(pending, "rig remote test [--remote <alias>] [--host <host>] [--port <n>] [--token <token>]");
+        const response = await withClient((client) => client.ping());
+        return { ok: true, group: "remote", command, details: toDetails(response) };
+      }
+      case "status": {
+        requireNoExtraArgs(pending, "rig remote status [--remote <alias>] [--host <host>] [--port <n>] [--token <token>]");
+        const response = await withClient((client) => client.getState());
+        return { ok: true, group: "remote", command, details: toDetails(response) };
+      }
+      case "tasks": {
+        requireNoExtraArgs(pending, "rig remote tasks [--remote <alias>] [--host <host>] [--port <n>] [--token <token>]");
+        const response = await withClient((client) => client.getTasks());
+        return { ok: true, group: "remote", command, details: toDetails(response) };
+      }
+      case "watch": {
+        let watchPending = pending;
+        const secondsResult = takeOption(watchPending, "--seconds");
+        watchPending = secondsResult.rest;
+        const eventResult = takeOption(watchPending, "--event");
+        watchPending = eventResult.rest;
+        requireNoExtraArgs(watchPending, "rig remote watch [--seconds <n>] [--event <type>] [--remote <alias>] [--host <host>] [--port <n>] [--token <token>]");
+        const seconds = parseOptionalPositiveInt(secondsResult.value, "--seconds");
+        const eventFilter = eventResult.value || undefined;
+        if (context.outputMode === "json" && !seconds) {
+          throw new CliError("--json remote watch requires --seconds <n> to produce bounded output.", 2, { hint: "Re-run as `rig remote watch --seconds 10 --json`." });
+        }
+        const captured = [];
+        let dropped = 0;
+        let received = 0;
+        let stop = false;
+        const onSignal = () => {
+          stop = true;
+        };
+        process.once("SIGINT", onSignal);
+        process.once("SIGTERM", onSignal);
+        try {
+          await withClient(async (client) => {
+            client.setEventHandler((event) => {
+              if (!matchesEventFilter(event.message, eventFilter)) {
+                return;
+              }
+              received += 1;
+              if (context.outputMode === "text") {
+                console.log(`[${event.receivedAt}] ${summarizeMessage(event.message)}`);
+              } else if (captured.length < 200) {
+                captured.push(event.message);
+              } else {
+                dropped += 1;
+              }
+            });
+            const subscribed = await client.subscribe(eventFilter ? [eventFilter] : []);
+            if (!subscribed.success) {
+              throw new RemoteCliError("RIG_REMOTE_SUBSCRIBE_FAILED", subscribed.error || "Failed to subscribe to remote events.", 3);
+            }
+            if (seconds) {
+              await Bun.sleep(seconds * 1000);
+              return;
+            }
+            while (!stop) {
+              await Bun.sleep(250);
+            }
+          });
+        } finally {
+          process.off("SIGINT", onSignal);
+          process.off("SIGTERM", onSignal);
+        }
+        return {
+          ok: true,
+          group: "remote",
+          command,
+          details: {
+            command: "remote watch",
+            remote: remoteMeta,
+            messageType: "stream",
+            requestId: null,
+            payload: context.outputMode === "json" ? captured : null,
+            error: null,
+            received,
+            dropped,
+            event: eventFilter || null,
+            seconds: seconds || null
+          }
+        };
+      }
+      case "pause":
+      case "resume":
+      case "stop":
+      case "continue":
+      case "refresh": {
+        requireNoExtraArgs(pending, `rig remote ${command} [--remote <alias>] [--host <host>] [--port <n>] [--token <token>]`);
+        const response = await withClient(async (client) => {
+          switch (command) {
+            case "pause":
+              return await client.pause();
+            case "resume":
+              return await client.resume();
+            case "stop":
+              return await client.interrupt();
+            case "continue":
+              return await client.continueExecution();
+            default:
+              return await client.refreshTasks();
+          }
+        });
+        assertRemoteOperationSuccess(command, response);
+        return { ok: true, group: "remote", command, details: toDetails(response) };
+      }
+      case "add-iterations":
+      case "remove-iterations": {
+        let countPending = pending;
+        const countResult = takeOption(countPending, "--count");
+        countPending = countResult.rest;
+        requireNoExtraArgs(countPending, `rig remote ${command} --count <n> [--remote <alias>] [--host <host>] [--port <n>] [--token <token>]`);
+        const count = parseRequiredPositiveInt(countResult.value, "--count");
+        const response = await withClient(async (client) => command === "add-iterations" ? await client.addIterations(count) : await client.removeIterations(count));
+        assertRemoteOperationSuccess(command, response);
+        return { ok: true, group: "remote", command, details: toDetails(response) };
+      }
+      case "prompt-preview":
+      case "iteration-output": {
+        let taskPending = pending;
+        const taskResult = takeOption(taskPending, "--task");
+        taskPending = taskResult.rest;
+        requireNoExtraArgs(taskPending, `rig remote ${command} --task <id> [--remote <alias>] [--host <host>] [--port <n>] [--token <token>]`);
+        const taskId = requireTask(taskResult.value, `rig remote ${command} --task <id>`);
+        const response = await withClient(async (client) => command === "prompt-preview" ? await client.getPromptPreview(taskId) : await client.getIterationOutput(taskId));
+        assertRemoteOperationSuccess(command, response);
+        return { ok: true, group: "remote", command, details: toDetails(response) };
+      }
+      case "orchestrate-start": {
+        let orchestrationPending = pending;
+        const maxWorkersResult = takeOption(orchestrationPending, "--max-workers");
+        orchestrationPending = maxWorkersResult.rest;
+        const maxIterationsResult = takeOption(orchestrationPending, "--max-iterations");
+        orchestrationPending = maxIterationsResult.rest;
+        const directMergeResult = takeFlag(orchestrationPending, "--direct-merge");
+        orchestrationPending = directMergeResult.rest;
+        requireNoExtraArgs(orchestrationPending, "rig remote orchestrate-start [--max-workers <n>] [--max-iterations <n>] [--direct-merge]");
+        const response = await withClient((client) => client.startOrchestration({
+          maxWorkers: parseOptionalPositiveInt(maxWorkersResult.value, "--max-workers"),
+          maxIterations: parseOptionalPositiveInt(maxIterationsResult.value, "--max-iterations"),
+          directMerge: directMergeResult.value
+        }));
+        assertRemoteOperationSuccess(command, response);
+        return {
+          ok: true,
+          group: "remote",
+          command,
+          details: toDetails(response)
+        };
+      }
+      case "orchestrate-pause":
+      case "orchestrate-resume":
+      case "orchestrate-stop":
+      case "orchestrate-state": {
+        let orchestrationPending = pending;
+        const idResult = takeOption(orchestrationPending, "--id");
+        orchestrationPending = idResult.rest;
+        requireNoExtraArgs(orchestrationPending, `rig remote ${command} --id <orch-id> [--remote <alias>] [--host <host>] [--port <n>] [--token <token>]`);
+        const orchestrationId = requireTask(idResult.value, `rig remote ${command} --id <orch-id> [--remote <alias>] [--host <host>] [--port <n>] [--token <token>]`);
+        const response = await withClient(async (client) => {
+          switch (command) {
+            case "orchestrate-pause":
+              return await client.pauseOrchestration(orchestrationId);
+            case "orchestrate-resume":
+              return await client.resumeOrchestration(orchestrationId);
+            case "orchestrate-stop":
+              return await client.stopOrchestration(orchestrationId);
+            default:
+              return await client.getOrchestrationState(orchestrationId);
+          }
+        });
+        assertRemoteOperationSuccess(command, response);
+        return { ok: true, group: "remote", command, details: toDetails(response) };
+      }
+      default:
+        throw new CliError(`Unknown remote command: ${command}`, 1, { hint: "Run `rig remote --help` to list remote commands." });
+    }
+  } catch (error) {
+    if (error instanceof RemoteCliError) {
+      throw new CliError(`[${error.code}] ${error.message}`, error.exitCode);
+    }
+    throw error;
+  }
+}
+export {
+  executeRemote
+};

package/dist/src/commands/repo-git-harness.d.ts

@@ -0,0 +1,5 @@
+import { type RunnerContext } from "../runner";
+import type { CommandOutcome } from "@rig/runtime";
+export declare function executeRepo(context: RunnerContext, args: string[]): Promise<CommandOutcome>;
+export declare function executeGit(context: RunnerContext, args: string[]): Promise<CommandOutcome>;
+export declare function executeHarness(context: RunnerContext, args: string[]): Promise<CommandOutcome>;