@h-rig/cli-surface-plugin 0.0.6-alpha.157 → 0.0.6-alpha.159

package/dist/src/commands/remote-client.d.ts

@@ -0,0 +1,152 @@
+import { type ManagedRemoteEndpoint } from "@rig/core/remote-config";
+export { DEFAULT_REMOTE_PORT, REMOTES_CONFIG_PATH, listManagedRemoteEndpoints, loadRemotesConfig, RemoteCliError, removeManagedRemoteEndpoint, resolveOwnerNamespaceKey, resolveRegistryBaseUrl, resolveRelayUrl, resolveSelectedRemote, resolveSshTarget, upsertManagedRemoteEndpoint, } from "@rig/core/remote-config";
+export type { ManagedRemoteEndpoint, SelectedRemote } from "@rig/core/remote-config";
+type JsonRecord = Record<string, unknown>;
+type OperationResult = {
+    type: "operation_result";
+    success: boolean;
+    error?: string;
+} & JsonRecord;
+type PromptPreviewResponse = {
+    type: "prompt_preview_response";
+    success: boolean;
+    prompt?: string;
+    source?: string;
+    error?: string;
+};
+type IterationOutputResponse = {
+    type: "iteration_output_response";
+    success: boolean;
+    taskId?: string;
+    iteration?: number;
+    output?: string;
+    startedAt?: string;
+    endedAt?: string;
+    durationMs?: number;
+    isRunning?: boolean;
+    error?: string;
+};
+type StartOrchestrationResponse = {
+    type: "orchestrate:start_response";
+    success: boolean;
+    error?: string;
+    orchestrationId?: string;
+    totalTasks?: number;
+    totalGroups?: number;
+    maxParallelism?: number;
+};
+type OrchestrationStateResponse = {
+    type: "orchestrate:state_response";
+    success: boolean;
+    error?: string;
+    state?: unknown;
+};
+type StateResponse = {
+    type: "state_response";
+    state: unknown;
+};
+type TasksResponse = {
+    type: "tasks_response";
+    tasks: unknown;
+};
+export type RemoteMessage = {
+    type: string;
+    id?: string;
+    timestamp?: string;
+} & JsonRecord;
+export type RemoteEndpoint = {
+    source: "flags" | "alias" | "env";
+    alias?: string;
+    host: string;
+    port: number;
+    token: string;
+    configPath: string;
+};
+export type ResolveRemoteOptions = {
+    projectRoot?: string | undefined;
+    host?: string | undefined;
+    port?: string | undefined;
+    token?: string | undefined;
+    remoteAlias?: string | undefined;
+    env?: Record<string, string | undefined> | undefined;
+};
+export type RemoteEvent = {
+    receivedAt: string;
+    message: RemoteMessage;
+};
+export declare function resolveRemoteEndpoint(options: ResolveRemoteOptions): RemoteEndpoint;
+export type RemoteClientOptions = {
+    connectTimeoutMs?: number;
+    authTimeoutMs?: number;
+    requestTimeoutMs?: number;
+    subscriptionTimeoutMs?: number;
+    onEvent?: (event: RemoteEvent) => void;
+};
+export declare class RemoteWsClient {
+    readonly endpoint: RemoteEndpoint;
+    private ws;
+    private connected;
+    private pending;
+    private onEvent;
+    private requestTimeoutMs;
+    private connectTimeoutMs;
+    private authTimeoutMs;
+    private subscriptionTimeoutMs;
+    private connectionToken;
+    private connectionTokenExpiresAt;
+    private tokenRefreshTimer;
+    constructor(endpoint: RemoteEndpoint, options?: RemoteClientOptions);
+    setEventHandler(handler: ((event: RemoteEvent) => void) | undefined): void;
+    connect(): Promise<void>;
+    disconnect(): void;
+    subscribe(eventTypes?: string[]): Promise<OperationResult>;
+    unsubscribe(): Promise<OperationResult>;
+    getState(): Promise<StateResponse>;
+    getTasks(): Promise<TasksResponse>;
+    pause(): Promise<OperationResult>;
+    resume(): Promise<OperationResult>;
+    interrupt(): Promise<OperationResult>;
+    continueExecution(): Promise<OperationResult>;
+    refreshTasks(): Promise<OperationResult>;
+    addIterations(count: number): Promise<OperationResult>;
+    removeIterations(count: number): Promise<OperationResult>;
+    getPromptPreview(taskId: string): Promise<PromptPreviewResponse>;
+    getIterationOutput(taskId: string): Promise<IterationOutputResponse>;
+    startOrchestration(options: {
+        maxWorkers?: number;
+        maxIterations?: number;
+        directMerge?: boolean;
+    }): Promise<StartOrchestrationResponse>;
+    pauseOrchestration(orchestrationId: string): Promise<OperationResult>;
+    resumeOrchestration(orchestrationId: string): Promise<OperationResult>;
+    stopOrchestration(orchestrationId: string): Promise<OperationResult>;
+    getOrchestrationState(orchestrationId: string): Promise<OrchestrationStateResponse>;
+    ping(): Promise<RemoteMessage>;
+    private request;
+    private routeMessage;
+    private scheduleTokenRefresh;
+    private clearTokenRefreshTimer;
+    private clearPending;
+}
+export declare function matchesEventFilter(message: RemoteMessage, expectedType?: string): boolean;
+export declare function summarizeMessage(message: RemoteMessage): string;
+export declare function migrateManagedRemoteEndpoints(projectRoot: string, legacyPath?: string): {
+    imported: number;
+    skipped: number;
+    sourcePath: string;
+};
+export declare function doctorManagedRemoteEndpoints(projectRoot: string): {
+    manifestPath: string;
+    secretsPath: string;
+    endpointCount: number;
+    missingSecrets: string[];
+    warnings: string[];
+};
+export declare function updateManagedRemoteEndpointInAuthority(projectRoot: string, input: {
+    endpointId?: string | undefined;
+    alias?: string | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    token?: string | undefined;
+    autoConnect?: boolean | undefined;
+}): ManagedRemoteEndpoint | null;

package/dist/src/commands/remote-client.js

@@ -0,0 +1,475 @@
+// @bun
+// packages/cli-surface-plugin/src/commands/remote-client.ts
+import { dirname } from "path";
+import { resolveAuthorityPaths } from "@rig/core/server-paths";
+import {
+  DEFAULT_REMOTE_PORT,
+  REMOTES_CONFIG_PATH,
+  doctorAuthorityRemoteEndpoints,
+  importLegacyRemoteEndpoints,
+  listAuthorityRemoteEndpoints,
+  loadRemotesConfig,
+  markAuthorityRemoteEndpointConnected,
+  normalizeString,
+  RemoteCliError,
+  updateAuthorityRemoteEndpoint
+} from "@rig/core/remote-config";
+import {
+  DEFAULT_REMOTE_PORT as DEFAULT_REMOTE_PORT2,
+  REMOTES_CONFIG_PATH as REMOTES_CONFIG_PATH2,
+  listManagedRemoteEndpoints,
+  loadRemotesConfig as loadRemotesConfig2,
+  RemoteCliError as RemoteCliError2,
+  removeManagedRemoteEndpoint,
+  resolveOwnerNamespaceKey,
+  resolveRegistryBaseUrl as resolveRegistryBaseUrl2,
+  resolveRelayUrl as resolveRelayUrl2,
+  resolveSelectedRemote,
+  resolveSshTarget,
+  upsertManagedRemoteEndpoint
+} from "@rig/core/remote-config";
+var DEFAULT_TIMEOUTS = {
+  connectMs: 5000,
+  authMs: 5000,
+  requestMs: 30000,
+  subscriptionMs: 1e4
+};
+function resolveRemoteEndpoint(options) {
+  const env = options.env ?? process.env;
+  const envHost = normalizeString(env.RIG_REMOTE_HOST);
+  const envToken = normalizeString(env.RIG_REMOTE_TOKEN);
+  const envPort = parsePort(normalizeString(env.RIG_REMOTE_PORT), "RIG_REMOTE_PORT");
+  const envAlias = normalizeString(env.RIG_REMOTE_ALIAS);
+  const explicitHost = normalizeString(options.host);
+  const explicitToken = normalizeString(options.token);
+  const explicitPort = parsePort(normalizeString(options.port), "--port");
+  const explicitProvided = Boolean(explicitHost || explicitToken || explicitPort !== null);
+  const requestedAlias = normalizeString(options.remoteAlias) || envAlias;
+  let endpoint = {
+    source: "env",
+    host: envHost || "",
+    port: envPort ?? DEFAULT_REMOTE_PORT,
+    token: envToken || "",
+    configPath: REMOTES_CONFIG_PATH
+  };
+  if (requestedAlias) {
+    if (options.projectRoot) {
+      const remote = listAuthorityRemoteEndpoints(options.projectRoot).find((entry) => entry.alias === requestedAlias);
+      if (!remote) {
+        const configPath = resolveAuthorityPaths(options.projectRoot).remoteEndpointsPath;
+        throw new RemoteCliError("RIG_REMOTE_ALIAS_NOT_FOUND", `Remote alias '${requestedAlias}' was not found in ${configPath}.`, 2, { alias: requestedAlias, configPath });
+      }
+      endpoint = {
+        source: "alias",
+        alias: requestedAlias,
+        host: remote.host,
+        port: remote.port,
+        token: remote.token,
+        configPath: resolveAuthorityPaths(options.projectRoot).remoteEndpointsPath
+      };
+    } else {
+      const config = loadRemotesConfig();
+      const remote = config.remotes?.[requestedAlias];
+      if (!remote) {
+        throw new RemoteCliError("RIG_REMOTE_ALIAS_NOT_FOUND", `Remote alias '${requestedAlias}' was not found in ${REMOTES_CONFIG_PATH}.`, 2, { alias: requestedAlias, configPath: REMOTES_CONFIG_PATH });
+      }
+      endpoint = {
+        source: "alias",
+        alias: requestedAlias,
+        host: normalizeString(remote.host) || "",
+        port: Number.isFinite(remote.port) ? Number(remote.port) : DEFAULT_REMOTE_PORT,
+        token: normalizeString(remote.token) || "",
+        configPath: REMOTES_CONFIG_PATH
+      };
+    }
+  }
+  if (explicitProvided) {
+    endpoint = {
+      ...endpoint,
+      source: "flags",
+      host: explicitHost || endpoint.host,
+      port: explicitPort ?? endpoint.port,
+      token: explicitToken || endpoint.token
+    };
+  }
+  if (!endpoint.host) {
+    throw new RemoteCliError("RIG_REMOTE_HOST_REQUIRED", "Remote host is required. Pass --host, --remote <alias>, or set RIG_REMOTE_HOST.", 2);
+  }
+  if (!Number.isFinite(endpoint.port) || endpoint.port <= 0 || endpoint.port > 65535) {
+    throw new RemoteCliError("RIG_REMOTE_INVALID_PORT", `Invalid remote port: ${endpoint.port}.`, 2);
+  }
+  return endpoint;
+}
+
+class RemoteWsClient {
+  endpoint;
+  ws = null;
+  connected = false;
+  pending = new Map;
+  onEvent;
+  requestTimeoutMs;
+  connectTimeoutMs;
+  authTimeoutMs;
+  subscriptionTimeoutMs;
+  connectionToken = null;
+  connectionTokenExpiresAt = null;
+  tokenRefreshTimer = null;
+  constructor(endpoint, options = {}) {
+    this.endpoint = endpoint;
+    this.onEvent = options.onEvent;
+    this.connectTimeoutMs = options.connectTimeoutMs ?? DEFAULT_TIMEOUTS.connectMs;
+    this.authTimeoutMs = options.authTimeoutMs ?? DEFAULT_TIMEOUTS.authMs;
+    this.requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_TIMEOUTS.requestMs;
+    this.subscriptionTimeoutMs = options.subscriptionTimeoutMs ?? DEFAULT_TIMEOUTS.subscriptionMs;
+  }
+  setEventHandler(handler) {
+    this.onEvent = handler;
+  }
+  async connect() {
+    if (this.connected) {
+      return;
+    }
+    const url = `ws://${this.endpoint.host}:${this.endpoint.port}`;
+    await new Promise((resolve, reject) => {
+      let authResolved = false;
+      let connectTimer = setTimeout(() => {
+        connectTimer = null;
+        reject(new RemoteCliError("RIG_REMOTE_CONNECT_TIMEOUT", `Timed out connecting to ${url} after ${this.connectTimeoutMs}ms.`, 3, { host: this.endpoint.host, port: this.endpoint.port, timeoutMs: this.connectTimeoutMs }));
+      }, this.connectTimeoutMs);
+      const ws = new WebSocket(url);
+      this.ws = ws;
+      ws.onopen = () => {
+        const authMessage = {
+          type: "auth",
+          id: crypto.randomUUID(),
+          timestamp: new Date().toISOString(),
+          token: this.connectionToken || this.endpoint.token,
+          tokenType: this.connectionToken ? "connection" : "server"
+        };
+        let authTimer = setTimeout(() => {
+          authTimer = null;
+          reject(new RemoteCliError("RIG_REMOTE_AUTH_TIMEOUT", `Timed out waiting for auth response from ${url} after ${this.authTimeoutMs}ms.`, 3, { host: this.endpoint.host, port: this.endpoint.port, timeoutMs: this.authTimeoutMs }));
+        }, this.authTimeoutMs);
+        ws.send(JSON.stringify(authMessage));
+        const originalOnMessage = ws.onmessage;
+        ws.onmessage = (event) => {
+          const message = parseIncomingMessage(event.data);
+          if (!message) {
+            return;
+          }
+          if (message.type === "auth_response" && !authResolved) {
+            authResolved = true;
+            if (connectTimer) {
+              clearTimeout(connectTimer);
+              connectTimer = null;
+            }
+            if (authTimer) {
+              clearTimeout(authTimer);
+              authTimer = null;
+            }
+            const auth = message;
+            if (!auth.success) {
+              reject(new RemoteCliError("RIG_REMOTE_AUTH_FAILED", auth.error || "Remote authentication failed.", 3, { host: this.endpoint.host, port: this.endpoint.port }));
+              return;
+            }
+            if (auth.connectionToken && auth.connectionTokenExpiresAt) {
+              this.connectionToken = auth.connectionToken;
+              this.connectionTokenExpiresAt = auth.connectionTokenExpiresAt;
+              this.scheduleTokenRefresh();
+            }
+            if (this.endpoint.configPath.endsWith("endpoints.toml")) {
+              const projectRoot = dirname(dirname(dirname(this.endpoint.configPath)));
+              try {
+                markAuthorityRemoteEndpointConnected(projectRoot, this.endpoint.alias ? listAuthorityRemoteEndpoints(projectRoot).find((entry) => entry.alias === this.endpoint.alias)?.id ?? "" : "");
+              } catch {}
+            }
+            this.connected = true;
+            ws.onmessage = (event2) => {
+              const next = parseIncomingMessage(event2.data);
+              if (!next) {
+                return;
+              }
+              this.routeMessage(next);
+            };
+            resolve();
+            return;
+          }
+          if (typeof originalOnMessage === "function") {
+            originalOnMessage.call(ws, event);
+          }
+        };
+      };
+      ws.onerror = () => {
+        if (connectTimer) {
+          clearTimeout(connectTimer);
+          connectTimer = null;
+        }
+        if (!authResolved) {
+          reject(new RemoteCliError("RIG_REMOTE_CONNECT_FAILED", `Failed to connect to ${url}.`, 3, { host: this.endpoint.host, port: this.endpoint.port }));
+        }
+      };
+      ws.onclose = () => {
+        this.connected = false;
+        this.clearPending("Connection closed");
+      };
+    });
+  }
+  disconnect() {
+    this.connected = false;
+    this.clearTokenRefreshTimer();
+    this.clearPending("Connection closed");
+    if (this.ws) {
+      try {
+        this.ws.close();
+      } catch {}
+      this.ws = null;
+    }
+  }
+  async subscribe(eventTypes = []) {
+    const message = { type: "subscribe" };
+    if (eventTypes.length > 0) {
+      message.eventTypes = eventTypes;
+    }
+    const response = await this.request(message, this.subscriptionTimeoutMs);
+    return expectType(response, "operation_result");
+  }
+  async unsubscribe() {
+    return expectType(await this.request({ type: "unsubscribe" }), "operation_result");
+  }
+  async getState() {
+    return expectType(await this.request({ type: "get_state" }), "state_response");
+  }
+  async getTasks() {
+    return expectType(await this.request({ type: "get_tasks" }), "tasks_response");
+  }
+  async pause() {
+    return expectType(await this.request({ type: "pause" }), "operation_result");
+  }
+  async resume() {
+    return expectType(await this.request({ type: "resume" }), "operation_result");
+  }
+  async interrupt() {
+    return expectType(await this.request({ type: "interrupt" }), "operation_result");
+  }
+  async continueExecution() {
+    return expectType(await this.request({ type: "continue" }), "operation_result");
+  }
+  async refreshTasks() {
+    return expectType(await this.request({ type: "refresh_tasks" }), "operation_result");
+  }
+  async addIterations(count) {
+    return expectType(await this.request({ type: "add_iterations", count }), "operation_result");
+  }
+  async removeIterations(count) {
+    return expectType(await this.request({ type: "remove_iterations", count }), "operation_result");
+  }
+  async getPromptPreview(taskId) {
+    return expectType(await this.request({ type: "get_prompt_preview", taskId }), "prompt_preview_response");
+  }
+  async getIterationOutput(taskId) {
+    return expectType(await this.request({ type: "get_iteration_output", taskId }), "iteration_output_response");
+  }
+  async startOrchestration(options) {
+    return expectType(await this.request({
+      type: "orchestrate:start",
+      maxWorkers: options.maxWorkers,
+      maxIterations: options.maxIterations,
+      directMerge: options.directMerge
+    }), "orchestrate:start_response");
+  }
+  async pauseOrchestration(orchestrationId) {
+    return expectType(await this.request({ type: "orchestrate:pause", orchestrationId }), "operation_result");
+  }
+  async resumeOrchestration(orchestrationId) {
+    return expectType(await this.request({ type: "orchestrate:resume", orchestrationId }), "operation_result");
+  }
+  async stopOrchestration(orchestrationId) {
+    return expectType(await this.request({ type: "orchestrate:stop", orchestrationId }), "operation_result");
+  }
+  async getOrchestrationState(orchestrationId) {
+    return expectType(await this.request({ type: "orchestrate:get_state", orchestrationId }), "orchestrate:state_response");
+  }
+  async ping() {
+    return this.request({ type: "ping" });
+  }
+  async request(payload, timeoutMs = this.requestTimeoutMs) {
+    if (!this.connected || !this.ws) {
+      throw new RemoteCliError("RIG_REMOTE_NOT_CONNECTED", "Remote client is not connected.", 3);
+    }
+    const id = crypto.randomUUID();
+    const message = {
+      ...payload,
+      id,
+      timestamp: new Date().toISOString()
+    };
+    return await new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new RemoteCliError("RIG_REMOTE_REQUEST_TIMEOUT", `Timed out waiting for response to '${String(payload.type)}' after ${timeoutMs}ms.`, 3, { requestType: payload.type, requestId: id, timeoutMs }));
+      }, timeoutMs);
+      this.pending.set(id, { resolve, reject, timeout });
+      this.ws?.send(JSON.stringify(message));
+    });
+  }
+  routeMessage(message) {
+    if (message.id && this.pending.has(message.id)) {
+      const pending = this.pending.get(message.id);
+      if (pending) {
+        clearTimeout(pending.timeout);
+        this.pending.delete(message.id);
+        pending.resolve(message);
+      }
+      return;
+    }
+    if (message.type === "token_refresh_response") {
+      const token = normalizeString(message.connectionToken);
+      const expiresAt = normalizeString(message.connectionTokenExpiresAt);
+      if (token && expiresAt) {
+        this.connectionToken = token;
+        this.connectionTokenExpiresAt = expiresAt;
+        this.scheduleTokenRefresh();
+      }
+    }
+    this.onEvent?.({ receivedAt: new Date().toISOString(), message });
+  }
+  scheduleTokenRefresh() {
+    this.clearTokenRefreshTimer();
+    if (!this.connectionToken || !this.connectionTokenExpiresAt || !this.ws || !this.connected) {
+      return;
+    }
+    const expiresAt = new Date(this.connectionTokenExpiresAt).getTime();
+    if (!Number.isFinite(expiresAt)) {
+      return;
+    }
+    const refreshAt = expiresAt - 60 * 60 * 1000;
+    const delay = Math.max(0, refreshAt - Date.now());
+    this.tokenRefreshTimer = setTimeout(() => {
+      if (!this.connected || !this.ws || !this.connectionToken) {
+        return;
+      }
+      const refreshMessage = {
+        type: "token_refresh",
+        id: crypto.randomUUID(),
+        timestamp: new Date().toISOString(),
+        connectionToken: this.connectionToken
+      };
+      this.ws.send(JSON.stringify(refreshMessage));
+    }, delay);
+  }
+  clearTokenRefreshTimer() {
+    if (this.tokenRefreshTimer) {
+      clearTimeout(this.tokenRefreshTimer);
+      this.tokenRefreshTimer = null;
+    }
+  }
+  clearPending(reason) {
+    for (const [requestId, pending] of this.pending.entries()) {
+      clearTimeout(pending.timeout);
+      pending.reject(new RemoteCliError("RIG_REMOTE_REQUEST_CANCELLED", `${reason} (request ${requestId}).`, 3, { requestId }));
+      this.pending.delete(requestId);
+    }
+  }
+}
+function matchesEventFilter(message, expectedType) {
+  if (!expectedType) {
+    return true;
+  }
+  if (message.type === expectedType) {
+    return true;
+  }
+  if (message.type === "engine_event") {
+    const eventType = normalizeString(message.event?.type);
+    return eventType === expectedType;
+  }
+  if (message.type === "parallel_event") {
+    const eventType = normalizeString(message.event?.type);
+    return eventType === expectedType;
+  }
+  return false;
+}
+function summarizeMessage(message) {
+  if (message.type === "pong") {
+    return "pong";
+  }
+  if (message.type === "engine_event") {
+    const eventType = normalizeString(message.event?.type);
+    return eventType ? `engine_event:${eventType}` : "engine_event";
+  }
+  if (message.type === "parallel_event") {
+    const eventType = normalizeString(message.event?.type);
+    const orchestrationId = normalizeString(message.orchestrationId);
+    return orchestrationId ? `parallel_event:${eventType || "unknown"}:${orchestrationId}` : `parallel_event:${eventType || "unknown"}`;
+  }
+  return message.type;
+}
+function migrateManagedRemoteEndpoints(projectRoot, legacyPath = REMOTES_CONFIG_PATH) {
+  return importLegacyRemoteEndpoints(projectRoot, legacyPath);
+}
+function doctorManagedRemoteEndpoints(projectRoot) {
+  return doctorAuthorityRemoteEndpoints(projectRoot);
+}
+function updateManagedRemoteEndpointInAuthority(projectRoot, input) {
+  const updated = updateAuthorityRemoteEndpoint(projectRoot, input);
+  if (!updated)
+    return null;
+  return {
+    id: updated.id,
+    alias: updated.alias,
+    host: updated.host,
+    port: updated.port,
+    token: updated.token,
+    addedAt: updated.addedAt,
+    lastConnected: updated.lastConnectedAt
+  };
+}
+function parsePort(value, label) {
+  if (!value) {
+    return null;
+  }
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0 || parsed > 65535) {
+    throw new RemoteCliError("RIG_REMOTE_INVALID_PORT", `Invalid port for ${label}: ${value}.`, 2, { label, value });
+  }
+  return parsed;
+}
+function parseIncomingMessage(raw) {
+  if (typeof raw !== "string") {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || typeof parsed.type !== "string") {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function expectType(message, expectedType) {
+  if (message.type !== expectedType) {
+    throw new RemoteCliError("RIG_REMOTE_UNEXPECTED_RESPONSE", `Unexpected response type: ${message.type}. Expected ${expectedType}.`, 3, { expectedType, actualType: message.type, message });
+  }
+  return message;
+}
+export {
+  upsertManagedRemoteEndpoint,
+  updateManagedRemoteEndpointInAuthority,
+  summarizeMessage,
+  resolveSshTarget,
+  resolveSelectedRemote,
+  resolveRemoteEndpoint,
+  resolveRelayUrl2 as resolveRelayUrl,
+  resolveRegistryBaseUrl2 as resolveRegistryBaseUrl,
+  resolveOwnerNamespaceKey,
+  removeManagedRemoteEndpoint,
+  migrateManagedRemoteEndpoints,
+  matchesEventFilter,
+  loadRemotesConfig2 as loadRemotesConfig,
+  listManagedRemoteEndpoints,
+  doctorManagedRemoteEndpoints,
+  RemoteWsClient,
+  RemoteCliError2 as RemoteCliError,
+  REMOTES_CONFIG_PATH2 as REMOTES_CONFIG_PATH,
+  DEFAULT_REMOTE_PORT2 as DEFAULT_REMOTE_PORT
+};

package/dist/src/commands/remote.d.ts

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