@h-rig/cli 0.0.6-alpha.28 → 0.0.6-alpha.281

package/dist/src/commands/remote.js

@@ -1,507 +0,0 @@
-// @bun
-// 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";
-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}`);
-      }
-      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/src/commands/remote.ts
-import {
-  doctorManagedRemoteEndpoints,
-  listManagedRemoteEndpoints,
-  matchesEventFilter,
-  migrateManagedRemoteEndpoints,
-  RemoteCliError,
-  RemoteWsClient,
-  removeManagedRemoteEndpoint,
-  resolveRemoteEndpoint,
-  summarizeMessage,
-  updateManagedRemoteEndpointInAuthority,
-  upsertManagedRemoteEndpoint
-} from "@rig/runtime/control-plane/remote";
-
-// packages/cli/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 CliError2(`Invalid ${option} value: ${value}`);
-  }
-  return parsed;
-}
-function parseRequiredPositiveInt(value, option) {
-  if (!value) {
-    throw new CliError2(`Missing value for ${option}.`);
-  }
-  const parsed = Number.parseInt(value, 10);
-  if (!Number.isFinite(parsed) || parsed <= 0) {
-    throw new CliError2(`Invalid ${option} value: ${value}`);
-  }
-  return parsed;
-}
-
-// packages/cli/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 CliError2("remote endpoint add requires --alias, --host, --port, and --token.");
-        }
-        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 CliError2("remote endpoint update requires --id <id> or --alias <a>.");
-        }
-        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 CliError2("Remote endpoint not found.", 2);
-        }
-        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 CliError2("remote endpoint remove requires --alias.");
-        }
-        const removed = removeManagedRemoteEndpoint(alias.value, undefined, context.projectRoot);
-        if (!removed) {
-          throw new CliError2(`Remote endpoint alias not found: ${alias.value}`, 2);
-        }
-        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 CliError2("remote endpoint test requires --alias.");
-        }
-        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 CliError2(`Unknown remote endpoint command: ${subcommand}`);
-    }
-  }
-  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 CliError2("--json remote watch requires --seconds <n> to produce bounded output.", 2);
-        }
-        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 CliError2(`Unknown remote command: ${command}`);
-    }
-  } catch (error) {
-    if (error instanceof RemoteCliError) {
-      throw new CliError2(`[${error.code}] ${error.message}`, error.exitCode);
-    }
-    throw error;
-  }
-}
-export {
-  executeRemote
-};