@h-rig/contracts 0.0.6-alpha.18 → 0.0.6-alpha.181

package/dist/src/remote-control.d.ts

@@ -0,0 +1,93 @@
+import type { CapabilityId } from "./capability-id";
+export type RemoteControlEnv = Readonly<Record<string, string | undefined>>;
+export type RemoteControlJsonRecord = Record<string, unknown>;
+export type RemoteControlMessage = {
+    readonly type: string;
+    readonly id?: string;
+    readonly timestamp?: string;
+} & RemoteControlJsonRecord;
+export type RemoteControlEndpointSelection = {
+    readonly projectRoot: string;
+    readonly host?: string | undefined;
+    readonly port?: string | undefined;
+    readonly token?: string | undefined;
+    readonly remoteAlias?: string | undefined;
+    readonly env?: RemoteControlEnv | undefined;
+};
+export type RemoteControlRemote = {
+    readonly source: "flags" | "alias" | "env";
+    readonly alias?: string | undefined;
+    readonly host: string;
+    readonly port: number;
+};
+export type RemoteControlEndpoint = RemoteControlRemote & {
+    readonly token: string;
+};
+export type RemoteControlEvent = {
+    readonly receivedAt: string;
+    readonly message: RemoteControlMessage;
+};
+export type RemoteControlWatchEvent = RemoteControlEvent & {
+    readonly summary: string;
+};
+export type RemoteControlOperationResult = {
+    readonly remote: RemoteControlRemote;
+    readonly response: RemoteControlMessage;
+};
+export type RemoteControlEndpointTestResult = RemoteControlOperationResult & {
+    readonly latencyMs: number;
+};
+export type RemoteControlWatchOptions = RemoteControlEndpointSelection & {
+    readonly eventType?: string | undefined;
+    readonly seconds?: number | undefined;
+    readonly maxCaptured?: number | undefined;
+    readonly shouldStop?: (() => boolean) | undefined;
+    readonly onEvent?: ((event: RemoteControlWatchEvent) => void) | undefined;
+};
+export type RemoteControlWatchResult = {
+    readonly remote: RemoteControlRemote;
+    readonly received: number;
+    readonly dropped: number;
+    readonly captured: readonly RemoteControlMessage[];
+    readonly event: string | null;
+    readonly seconds: number | null;
+};
+export type RemoteControlStartOrchestrationOptions = {
+    readonly maxWorkers?: number | undefined;
+    readonly maxIterations?: number | undefined;
+    readonly directMerge?: boolean | undefined;
+};
+export interface RemoteControlClient {
+    readonly remote: RemoteControlRemote;
+    readonly ping: () => Promise<RemoteControlMessage>;
+    readonly getState: () => Promise<RemoteControlMessage>;
+    readonly getTasks: () => Promise<RemoteControlMessage>;
+    readonly pause: () => Promise<RemoteControlMessage>;
+    readonly resume: () => Promise<RemoteControlMessage>;
+    readonly stop: () => Promise<RemoteControlMessage>;
+    readonly continueExecution: () => Promise<RemoteControlMessage>;
+    readonly refreshTasks: () => Promise<RemoteControlMessage>;
+    readonly addIterations: (count: number) => Promise<RemoteControlMessage>;
+    readonly removeIterations: (count: number) => Promise<RemoteControlMessage>;
+    readonly getPromptPreview: (taskId: string) => Promise<RemoteControlMessage>;
+    readonly getIterationOutput: (taskId: string) => Promise<RemoteControlMessage>;
+    readonly startOrchestration: (options: RemoteControlStartOrchestrationOptions) => Promise<RemoteControlMessage>;
+    readonly pauseOrchestration: (orchestrationId: string) => Promise<RemoteControlMessage>;
+    readonly resumeOrchestration: (orchestrationId: string) => Promise<RemoteControlMessage>;
+    readonly stopOrchestration: (orchestrationId: string) => Promise<RemoteControlMessage>;
+    readonly getOrchestrationState: (orchestrationId: string) => Promise<RemoteControlMessage>;
+}
+export interface RemoteControlService {
+    readonly resolveEndpoint: (input: RemoteControlEndpointSelection) => RemoteControlRemote;
+    readonly withClient: <T>(input: RemoteControlEndpointSelection, runner: (client: RemoteControlClient) => Promise<T>) => Promise<T>;
+    readonly testEndpoint: (input: RemoteControlEndpointSelection) => Promise<RemoteControlEndpointTestResult>;
+    readonly watch: (input: RemoteControlWatchOptions) => Promise<RemoteControlWatchResult>;
+}
+export declare class RemoteControlError extends Error {
+    readonly code: string;
+    readonly exitCode: number;
+    readonly details: RemoteControlJsonRecord | undefined;
+    constructor(code: string, message: string, exitCode?: number, details?: RemoteControlJsonRecord);
+}
+export declare const REMOTE_CONTROL_CAPABILITY_ID = "rig.remote.control";
+export declare const REMOTE_CONTROL: CapabilityId<RemoteControlService>;

package/dist/src/remote-control.js

@@ -0,0 +1,26 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/remote-control.ts
+class RemoteControlError extends Error {
+  code;
+  exitCode;
+  details;
+  constructor(code, message, exitCode = 1, details) {
+    super(message);
+    this.name = "RemoteControlError";
+    this.code = code;
+    this.exitCode = exitCode;
+    this.details = details;
+  }
+}
+var REMOTE_CONTROL_CAPABILITY_ID = "rig.remote.control";
+var REMOTE_CONTROL = makeCapabilityId(REMOTE_CONTROL_CAPABILITY_ID);
+export {
+  RemoteControlError,
+  REMOTE_CONTROL_CAPABILITY_ID,
+  REMOTE_CONTROL
+};

package/dist/src/remote.d.ts

@@ -0,0 +1,318 @@
+import { Schema } from "effect";
+export declare const RemoteEndpoint: Schema.Struct<{
+    readonly id: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly alias: Schema.Trim;
+    readonly host: Schema.Trim;
+    readonly port: Schema.Int;
+    readonly token: Schema.String;
+    readonly tokenConfigured: Schema.optional<Schema.Boolean>;
+    readonly autoConnect: Schema.optional<Schema.Boolean>;
+    readonly addedAt: Schema.String;
+    readonly lastConnectedAt: Schema.NullOr<Schema.String>;
+}>;
+export type RemoteEndpoint = typeof RemoteEndpoint.Type;
+export declare const RemoteConnectionStatus: Schema.Literals<readonly ["disconnected", "connecting", "authenticating", "connected", "reconnecting", "error"]>;
+export type RemoteConnectionStatus = typeof RemoteConnectionStatus.Type;
+export declare const RemoteConnectionSummary: Schema.Struct<{
+    readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly status: Schema.Literals<readonly ["disconnected", "connecting", "authenticating", "connected", "reconnecting", "error"]>;
+    readonly error: Schema.NullOr<Schema.String>;
+    readonly connectedAt: Schema.NullOr<Schema.String>;
+    readonly tokenExpiresAt: Schema.NullOr<Schema.String>;
+    readonly latencyMs: Schema.NullOr<Schema.Number>;
+    readonly subscribedEvents: Schema.$Array<Schema.String>;
+}>;
+export type RemoteConnectionSummary = typeof RemoteConnectionSummary.Type;
+export declare const RemoteConnectionStatusChanged: Schema.Struct<{
+    readonly endpointId: Schema.String;
+    readonly endpointAlias: Schema.String;
+    readonly status: Schema.Literals<readonly ["disconnected", "connecting", "authenticating", "connected", "reconnecting", "error"]>;
+    readonly previousStatus: Schema.Literals<readonly ["disconnected", "connecting", "authenticating", "connected", "reconnecting", "error"]>;
+    readonly error: Schema.NullOr<Schema.String>;
+    readonly connectedAt: Schema.NullOr<Schema.String>;
+    readonly latencyMs: Schema.NullOr<Schema.Number>;
+    readonly timestamp: Schema.String;
+}>;
+export type RemoteConnectionStatusChanged = typeof RemoteConnectionStatusChanged.Type;
+export declare const RemoteOrchestratorState: Schema.Struct<{
+    readonly activeTaskId: Schema.NullOr<Schema.String>;
+    readonly activeIteration: Schema.NullOr<Schema.Number>;
+    readonly maxIterations: Schema.Number;
+    readonly isPaused: Schema.Boolean;
+    readonly isRunning: Schema.Boolean;
+    readonly totalCompleted: Schema.Int;
+    readonly totalFailed: Schema.Int;
+    readonly lastActivity: Schema.NullOr<Schema.String>;
+}>;
+export type RemoteOrchestratorState = typeof RemoteOrchestratorState.Type;
+export declare const RemoteOrchestrationSummary: Schema.Struct<{
+    readonly orchestrationId: Schema.Trim;
+    readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly status: Schema.Literals<readonly ["running", "paused", "stopped", "completed"]>;
+    readonly totalTasks: Schema.Int;
+    readonly totalGroups: Schema.Int;
+    readonly maxParallelism: Schema.Int;
+    readonly startedAt: Schema.String;
+}>;
+export type RemoteOrchestrationSummary = typeof RemoteOrchestrationSummary.Type;
+export declare const RemoteIterationOutput: Schema.Struct<{
+    readonly taskId: Schema.optional<Schema.String>;
+    readonly iteration: Schema.optional<Schema.Number>;
+    readonly output: Schema.optional<Schema.String>;
+    readonly startedAt: Schema.optional<Schema.String>;
+    readonly endedAt: Schema.optional<Schema.String>;
+    readonly durationMs: Schema.optional<Schema.Number>;
+    readonly isRunning: Schema.optional<Schema.Boolean>;
+}>;
+export type RemoteIterationOutput = typeof RemoteIterationOutput.Type;
+export declare const RemoteRunnerRegisterInput: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly hostId: Schema.Trim;
+    readonly name: Schema.Trim;
+    readonly baseUrl: Schema.Trim;
+    readonly workspacePath: Schema.optional<Schema.Trim>;
+    readonly transport: Schema.optional<Schema.Trim>;
+    readonly hostname: Schema.optional<Schema.Trim>;
+    readonly region: Schema.optional<Schema.Trim>;
+    readonly labels: Schema.optional<Schema.$Array<Schema.Trim>>;
+    readonly capabilities: Schema.optional<Schema.$Array<Schema.Trim>>;
+    readonly runtimeAdapters: Schema.optional<Schema.$Array<Schema.Literal<"pi">>>;
+    readonly status: Schema.optional<Schema.Literals<readonly ["registering", "ready", "busy", "degraded", "draining", "offline", "quarantined"]>>;
+    readonly currentLeaseCount: Schema.optional<Schema.Number>;
+}>;
+export type RemoteRunnerRegisterInput = typeof RemoteRunnerRegisterInput.Type;
+export declare const RemoteRunnerHeartbeatInput: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly hostId: Schema.Trim;
+    readonly status: Schema.Literals<readonly ["registering", "ready", "busy", "degraded", "draining", "offline", "quarantined"]>;
+    readonly currentLeaseCount: Schema.optional<Schema.Number>;
+    readonly observedAt: Schema.optional<Schema.String>;
+}>;
+export type RemoteRunnerHeartbeatInput = typeof RemoteRunnerHeartbeatInput.Type;
+export declare const RemoteRunnerLifecycleResult: Schema.Struct<{
+    readonly ok: Schema.Boolean;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly hostId: Schema.Trim;
+    readonly acceptedAt: Schema.String;
+    readonly heartbeatIntervalMs: Schema.Number;
+}>;
+export type RemoteRunnerLifecycleResult = typeof RemoteRunnerLifecycleResult.Type;
+export declare const RemoteRunClaimInput: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly hostId: Schema.Trim;
+    readonly runtimeAdapters: Schema.optional<Schema.$Array<Schema.Literal<"pi">>>;
+}>;
+export type RemoteRunClaimInput = typeof RemoteRunClaimInput.Type;
+export declare const RemoteRunLeaseSummary: Schema.Struct<{
+    readonly leaseId: Schema.Trim;
+    readonly runId: Schema.Trim;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly title: Schema.Trim;
+    readonly runtimeAdapter: Schema.Literal<"pi">;
+    readonly model: Schema.NullOr<Schema.Trim>;
+    readonly runtimeMode: Schema.Literals<readonly ["approval-required", "full-access"]>;
+    readonly interactionMode: Schema.Literals<readonly ["default", "plan"]>;
+    readonly executionTarget: Schema.Literals<readonly ["local", "remote"]>;
+    readonly remoteHostId: Schema.NullOr<Schema.Trim>;
+    readonly claimedAt: Schema.String;
+}>;
+export type RemoteRunLeaseSummary = typeof RemoteRunLeaseSummary.Type;
+export declare const RemoteRunConversationEntry: Schema.Struct<{
+    readonly role: Schema.Literals<readonly ["user", "assistant", "system"]>;
+    readonly text: Schema.String;
+    readonly createdAt: Schema.String;
+}>;
+export type RemoteRunConversationEntry = typeof RemoteRunConversationEntry.Type;
+export declare const RemoteRunExecutionBundle: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly runId: Schema.Trim;
+    readonly leaseId: Schema.Trim;
+    readonly workspacePath: Schema.NullOr<Schema.Trim>;
+    readonly runtimeAdapter: Schema.Literal<"pi">;
+    readonly model: Schema.NullOr<Schema.Trim>;
+    readonly runtimeMode: Schema.Literals<readonly ["approval-required", "full-access"]>;
+    readonly interactionMode: Schema.Literals<readonly ["default", "plan"]>;
+    readonly prompt: Schema.String;
+    readonly conversation: Schema.$Array<Schema.Struct<{
+        readonly role: Schema.Literals<readonly ["user", "assistant", "system"]>;
+        readonly text: Schema.String;
+        readonly createdAt: Schema.String;
+    }>>;
+    readonly taskId: Schema.NullOr<Schema.Trim>;
+    readonly taskTitle: Schema.NullOr<Schema.Trim>;
+}>;
+export type RemoteRunExecutionBundle = typeof RemoteRunExecutionBundle.Type;
+export declare const RemoteRunClaimResult: Schema.Struct<{
+    readonly ok: Schema.Boolean;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly hostId: Schema.Trim;
+    readonly acceptedAt: Schema.String;
+    readonly lease: Schema.NullOr<Schema.Struct<{
+        readonly leaseId: Schema.Trim;
+        readonly runId: Schema.Trim;
+        readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+        readonly title: Schema.Trim;
+        readonly runtimeAdapter: Schema.Literal<"pi">;
+        readonly model: Schema.NullOr<Schema.Trim>;
+        readonly runtimeMode: Schema.Literals<readonly ["approval-required", "full-access"]>;
+        readonly interactionMode: Schema.Literals<readonly ["default", "plan"]>;
+        readonly executionTarget: Schema.Literals<readonly ["local", "remote"]>;
+        readonly remoteHostId: Schema.NullOr<Schema.Trim>;
+        readonly claimedAt: Schema.String;
+    }>>;
+    readonly bundle: Schema.NullOr<Schema.Struct<{
+        readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+        readonly runId: Schema.Trim;
+        readonly leaseId: Schema.Trim;
+        readonly workspacePath: Schema.NullOr<Schema.Trim>;
+        readonly runtimeAdapter: Schema.Literal<"pi">;
+        readonly model: Schema.NullOr<Schema.Trim>;
+        readonly runtimeMode: Schema.Literals<readonly ["approval-required", "full-access"]>;
+        readonly interactionMode: Schema.Literals<readonly ["default", "plan"]>;
+        readonly prompt: Schema.String;
+        readonly conversation: Schema.$Array<Schema.Struct<{
+            readonly role: Schema.Literals<readonly ["user", "assistant", "system"]>;
+            readonly text: Schema.String;
+            readonly createdAt: Schema.String;
+        }>>;
+        readonly taskId: Schema.NullOr<Schema.Trim>;
+        readonly taskTitle: Schema.NullOr<Schema.Trim>;
+    }>>;
+}>;
+export type RemoteRunClaimResult = typeof RemoteRunClaimResult.Type;
+export declare const RemoteRunReleaseInput: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly hostId: Schema.Trim;
+    readonly runId: Schema.Trim;
+    readonly leaseId: Schema.Trim;
+    readonly status: Schema.optional<Schema.Literals<readonly ["registering", "ready", "busy", "degraded", "draining", "offline", "quarantined"]>>;
+}>;
+export type RemoteRunReleaseInput = typeof RemoteRunReleaseInput.Type;
+export declare const RemoteRunReleaseResult: Schema.Struct<{
+    readonly ok: Schema.Boolean;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly hostId: Schema.Trim;
+    readonly runId: Schema.Trim;
+    readonly leaseId: Schema.Trim;
+    readonly acceptedAt: Schema.String;
+}>;
+export type RemoteRunReleaseResult = typeof RemoteRunReleaseResult.Type;
+export declare const RemoteRunStartInput: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly hostId: Schema.Trim;
+    readonly runId: Schema.Trim;
+    readonly leaseId: Schema.Trim;
+}>;
+export type RemoteRunStartInput = typeof RemoteRunStartInput.Type;
+export declare const RemoteRunStartResult: Schema.Struct<{
+    readonly ok: Schema.Boolean;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly hostId: Schema.Trim;
+    readonly runId: Schema.Trim;
+    readonly leaseId: Schema.Trim;
+    readonly runtimeId: Schema.Trim;
+    readonly acceptedAt: Schema.String;
+}>;
+export type RemoteRunStartResult = typeof RemoteRunStartResult.Type;
+export declare const RemoteRunLogInput: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly hostId: Schema.Trim;
+    readonly runId: Schema.Trim;
+    readonly leaseId: Schema.Trim;
+    readonly title: Schema.Trim;
+    readonly detail: Schema.optional<Schema.String>;
+    readonly tone: Schema.optional<Schema.Literals<readonly ["thinking", "tool", "info", "error"]>>;
+    readonly status: Schema.optional<Schema.Trim>;
+    readonly payload: Schema.optional<Schema.Unknown>;
+}>;
+export type RemoteRunLogInput = typeof RemoteRunLogInput.Type;
+export declare const RemoteRunMessageInput: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly hostId: Schema.Trim;
+    readonly runId: Schema.Trim;
+    readonly leaseId: Schema.Trim;
+    readonly messageId: Schema.optional<Schema.Trim>;
+    readonly text: Schema.String;
+    readonly state: Schema.optional<Schema.Literals<readonly ["streaming", "completed"]>>;
+}>;
+export type RemoteRunMessageInput = typeof RemoteRunMessageInput.Type;
+export declare const RemoteRunMutationResult: Schema.Struct<{
+    readonly ok: Schema.Boolean;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly hostId: Schema.Trim;
+    readonly runId: Schema.Trim;
+    readonly leaseId: Schema.Trim;
+    readonly acceptedAt: Schema.String;
+}>;
+export type RemoteRunMutationResult = typeof RemoteRunMutationResult.Type;
+export declare const RemoteRunCompleteInput: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly hostId: Schema.Trim;
+    readonly runId: Schema.Trim;
+    readonly leaseId: Schema.Trim;
+}>;
+export type RemoteRunCompleteInput = typeof RemoteRunCompleteInput.Type;
+export declare const RemoteRunFailInput: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly hostId: Schema.Trim;
+    readonly runId: Schema.Trim;
+    readonly leaseId: Schema.Trim;
+    readonly errorText: Schema.optional<Schema.String>;
+}>;
+export type RemoteRunFailInput = typeof RemoteRunFailInput.Type;
+export declare const RemoteRunArtifactInput: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly hostId: Schema.Trim;
+    readonly runId: Schema.Trim;
+    readonly leaseId: Schema.Trim;
+    readonly kind: Schema.Trim;
+    readonly label: Schema.Trim;
+    readonly filename: Schema.Trim;
+    readonly contentType: Schema.Trim;
+    readonly contentBase64: Schema.Trim;
+}>;
+export type RemoteRunArtifactInput = typeof RemoteRunArtifactInput.Type;
+export declare const RemoteRunArtifactResult: Schema.Struct<{
+    readonly ok: Schema.Boolean;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly hostId: Schema.Trim;
+    readonly runId: Schema.Trim;
+    readonly leaseId: Schema.Trim;
+    readonly acceptedAt: Schema.String;
+    readonly artifactPath: Schema.Trim;
+}>;
+export type RemoteRunArtifactResult = typeof RemoteRunArtifactResult.Type;
+export declare const RemoteRunArtifactSummary: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly runId: Schema.Trim;
+    readonly hostId: Schema.Trim;
+    readonly leaseId: Schema.Trim;
+    readonly kind: Schema.Trim;
+    readonly label: Schema.Trim;
+    readonly filename: Schema.Trim;
+    readonly contentType: Schema.Trim;
+    readonly uploadedAt: Schema.String;
+    readonly byteSize: Schema.Number;
+    readonly artifactPath: Schema.Trim;
+    readonly downloadPath: Schema.Trim;
+}>;
+export type RemoteRunArtifactSummary = typeof RemoteRunArtifactSummary.Type;
+export declare const RemoteRunArtifactsResult: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly runId: Schema.Trim;
+    readonly artifacts: Schema.$Array<Schema.Struct<{
+        readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+        readonly runId: Schema.Trim;
+        readonly hostId: Schema.Trim;
+        readonly leaseId: Schema.Trim;
+        readonly kind: Schema.Trim;
+        readonly label: Schema.Trim;
+        readonly filename: Schema.Trim;
+        readonly contentType: Schema.Trim;
+        readonly uploadedAt: Schema.String;
+        readonly byteSize: Schema.Number;
+        readonly artifactPath: Schema.Trim;
+        readonly downloadPath: Schema.Trim;
+    }>>;
+}>;
+export type RemoteRunArtifactsResult = typeof RemoteRunArtifactsResult.Type;