@maiaos/sdk 0.1.0-canary.2

package/dist/client/effect.js

@@ -0,0 +1,283 @@
+import { executionCatalogGetResultSchema, installedHarnessListResultSchema, integrationApplyClaudeCodeResultSchema, integrationApplyCodexResultSchema, integrationApplyPiRpcResultSchema, integrationPlanClaudeCodeResultSchema, integrationPlanCodexResultSchema, integrationPlanPiRpcResultSchema, integrationRemoveClaudeCodeResultSchema, integrationRemoveCodexResultSchema, integrationRemovePiRpcResultSchema, integrationStatusClaudeCodeResultSchema, integrationStatusCodexResultSchema, integrationStatusPiRpcResultSchema, invocationContextShowResultSchema, liveTerminalCloseResultSchema, liveTerminalControllerAcquireResultSchema, liveTerminalControllerReleaseResultSchema, liveTerminalControllerRequestResultSchema, liveTerminalControllerRequestShowResultSchema, liveTerminalResizeResultSchema, liveTerminalSignalResultSchema, liveTerminalWriteResultSchema, localNodeShutdownResultSchema, localNodeStatusResultSchema, monitorBootstrapCreateResultSchema, orchestrationDispatchSettleTerminalResultSchema, orchestrationDispatchShowResultSchema, orchestrationInboxAckResultSchema, orchestrationInboxCheckResultSchema, orchestrationQuestionCancelResultSchema, orchestrationQuestionOpenResultSchema, orchestrationQuestionReplyResultSchema, orchestrationRunCreateResultSchema, orchestrationRunListResultSchema, orchestrationRunShowResultSchema, orchestrationTaskListResultSchema, orchestrationTaskShowResultSchema, receiptGetResultSchema, receiptListResultSchema, runtimeProbeResultSchema, sessionArchiveResultSchema, sessionCreateResultSchema, sessionDiffResultSchema, sessionEventsListResultSchema, sessionListResultSchema, sessionObserveResultSchema, sessionResumeResultSchema, sessionShowResultSchema, sessionSpawnResultSchema, sessionStartResultSchema, sessionStopResultSchema, terminalCreateResultSchema, terminalEventsListResultSchema, terminalListResultSchema, terminalReadResultSchema, terminalShowResultSchema, turnInterruptResultSchema, turnSendResultSchema, turnShowResultSchema, turnWaitResultSchema, workspaceExecutionConfigureResultSchema, workspaceExecutionShowResultSchema, } from "@maiaos/protocol";
+import { executionCommandRunResultSchema, executionFileReadResultSchema, executionPlacementCreateResultSchema, executionPlacementShowResultSchema, executionWorktreeCheckpointCreateResultSchema, executionWorktreeCheckpointShowResultSchema, executionWorktreeCreateResultSchema, executionWorktreeImportResultSchema, executionWorktreeReconcileResultSchema, executionWorktreeRemoveApplyResultSchema, executionWorktreeRemovePlanResultSchema, executionWorktreeStatusResultSchema, } from "@maiaos/protocol/execution-candidate";
+import * as Effect from "effect/Effect";
+import { makeAgentPermissionOperations } from "../agent-permission/effect.js";
+import { makeApprovalOperations } from "../approval/effect.js";
+import { makeCallOperation } from "../call/effect.js";
+import { makeConnectionOperations } from "../connection/effect.js";
+import { makeContainerOperations } from "../container/effect.js";
+import { makeDiscoveryOperations } from "../discovery/effect.js";
+import { makeExecutionRelocationOperations } from "../execution/effect.js";
+import { makeHoldOperations } from "../hold/effect.js";
+import { makeInteractionOperations } from "../interaction/effect.js";
+import { makePortLeaseOperations } from "../port-lease/effect.js";
+import { makePresentationOperations } from "../presentation/effect.js";
+import { makeProjectGuardOperations } from "../project-guard/effect.js";
+import { makeProjectWorkspaceOperations } from "../project-workspace/effect.js";
+import { makeProviderPoolOperations } from "../provider-pool/effect.js";
+import { makeRemoteNodeOperations } from "../remote-node/effect.js";
+import { fromPromiseTransport, makeLocalNodeEffectRequester, } from "../request/effect.js";
+import { MaiaClientError, } from "../request/index.js";
+import { makeRunLedgerOperations } from "../run-ledger/effect.js";
+import { makeSessionMailboxOperations } from "../session/effect.js";
+import { makeVoiceManagedTurnOperations, makeVoicePiRelayOperations, } from "../voice/effect.js";
+const makeInvocationContextOperations = (request) => ({
+    showCurrentContext: (parameters, options) => request({ method: "context.show", parameters }, invocationContextShowResultSchema, options),
+});
+const makeLifecycleOperations = (request) => ({
+    createMonitorBootstrap: (options) => request({ method: "monitor.bootstrap.create", parameters: {} }, monitorBootstrapCreateResultSchema, options),
+    shutdown: (options) => request({ method: "node.shutdown", parameters: {} }, localNodeShutdownResultSchema, options),
+    status: (options) => request({ method: "node.status", parameters: {} }, localNodeStatusResultSchema, options),
+});
+const makeExecutionCatalogOperations = (request) => ({
+    configureWorkspaceExecution: (parameters, options) => request({ method: "workspace.execution.configure", parameters }, workspaceExecutionConfigureResultSchema, options),
+    readExecutionCatalog: (parameters, options) => request({ method: "execution.catalog.get", parameters }, executionCatalogGetResultSchema, options),
+    showWorkspaceExecution: (parameters, options) => request({ method: "workspace.execution.show", parameters }, workspaceExecutionShowResultSchema, options),
+});
+const placementOwnerMatches = (result, expected) => expected.kind === "session"
+    ? result.placement.kind === "session" &&
+        result.placement.sessionId === expected.ownerId
+    : result.placement.kind === "attempt" &&
+        result.placement.attemptId === expected.ownerId;
+const requirePlacementOwner = (result, expected) => placementOwnerMatches(result, expected)
+    ? Effect.succeed(result)
+    : Effect.fail(new MaiaClientError("invalid_response", "The execution placement response owner did not match the request."));
+const placementSnapshotsMatch = (result, parameters) => {
+    const placement = result.placement;
+    const ownerRevisionMatches = "sessionId" in parameters
+        ? placement.kind === "session" &&
+            placement.sessionRevision === parameters.expectedSessionRevision
+        : placement.kind === "attempt" &&
+            placement.attemptRevision === parameters.expectedAttemptRevision;
+    return (ownerRevisionMatches &&
+        placement.instanceId === parameters.instanceId &&
+        placement.instanceRevision === parameters.expectedInstanceRevision &&
+        placement.workspaceRevision === parameters.expectedWorkspaceRevision);
+};
+const requireCreatedPlacement = (result, parameters) => {
+    const owner = "sessionId" in parameters
+        ? { kind: "session", ownerId: parameters.sessionId }
+        : { kind: "attempt", ownerId: parameters.attemptId };
+    return requirePlacementOwner(result, owner).pipe(Effect.filterOrFail((placed) => placementSnapshotsMatch(placed, parameters), () => new MaiaClientError("invalid_response", "The execution placement response snapshots did not match the request.")));
+};
+const makeExecutionPlacementOperations = (request) => ({
+    createExecutionPlacement: (parameters, options) => request({ method: "execution.placement.create", parameters }, executionPlacementCreateResultSchema, options).pipe(Effect.flatMap((result) => requireCreatedPlacement(result, parameters))),
+    showExecutionPlacement: (parameters, options) => request({ method: "execution.placement.show", parameters }, executionPlacementShowResultSchema, options).pipe(Effect.flatMap((result) => requirePlacementOwner(result, parameters))),
+});
+const makeExecutionCommandOperations = (request) => ({
+    readExecutionFile: (parameters, options) => request({ method: "execution.file.read", parameters }, executionFileReadResultSchema, options),
+    runExecutionCommand: (parameters, options) => request({ method: "execution.command.run", parameters }, executionCommandRunResultSchema, options),
+});
+const matchedWorktree = (result, matches) => matches
+    ? Effect.succeed(result)
+    : Effect.fail(new MaiaClientError("invalid_response", "The execution worktree response did not match the request."));
+const requireWorktreeMutation = (result, parameters) => matchedWorktree(result, result.operation.commandId === parameters.commandId &&
+    result.operation.repositoryId === parameters.repositoryId);
+const requestExecutionWorktreeReconcile = (request, parameters, options) => request({ method: "execution.worktree.reconcile", parameters }, executionWorktreeReconcileResultSchema, options).pipe(Effect.flatMap((result) => matchedWorktree(result, result.operation.id === parameters.operationId &&
+    result.receipt.commandId === parameters.commandId)));
+const requestExecutionWorktreeRemove = (request, parameters, options) => request({ method: "execution.worktree.remove.apply", parameters }, executionWorktreeRemoveApplyResultSchema, options).pipe(Effect.flatMap((result) => matchedWorktree(result, result.operation.workspaceId === parameters.workspaceId &&
+    result.receipt.commandId === parameters.commandId)));
+const makeExecutionWorktreeCreation = (request) => ({
+    createExecutionWorktree: (parameters, options) => request({ method: "execution.worktree.create", parameters }, executionWorktreeCreateResultSchema, options).pipe(Effect.flatMap((result) => requireWorktreeMutation(result, parameters))),
+    importExecutionWorktree: (parameters, options) => request({ method: "execution.worktree.import", parameters }, executionWorktreeImportResultSchema, options).pipe(Effect.flatMap((result) => requireWorktreeMutation(result, parameters))),
+});
+const makeExecutionWorktreeSettlement = (request) => ({
+    reconcileExecutionWorktree: (parameters, options) => requestExecutionWorktreeReconcile(request, parameters, options),
+    removeExecutionWorktree: (parameters, options) => requestExecutionWorktreeRemove(request, parameters, options),
+});
+const makeExecutionWorktreeReads = (request) => ({
+    planExecutionWorktreeRemove: (parameters, options) => request({ method: "execution.worktree.remove.plan", parameters }, executionWorktreeRemovePlanResultSchema, options).pipe(Effect.flatMap((result) => matchedWorktree(result, result.plan.workspaceId === parameters.workspaceId))),
+    showExecutionWorktreeStatus: (parameters, options) => request({ method: "execution.worktree.status", parameters }, executionWorktreeStatusResultSchema, options).pipe(Effect.flatMap((result) => matchedWorktree(result, result.workspace.id === parameters.workspaceId))),
+});
+const makeExecutionCheckpointRead = (request) => ({
+    showExecutionCheckpoint: (parameters, options) => request({ method: "execution.checkpoint.show", parameters }, executionWorktreeCheckpointShowResultSchema, options).pipe(Effect.flatMap((result) => matchedWorktree(result, result.checkpoint.id === parameters.checkpointId))),
+});
+const makeExecutionCheckpointMutation = (request) => ({
+    createExecutionCheckpoint: (parameters, options) => request({ method: "execution.checkpoint.create", parameters }, executionWorktreeCheckpointCreateResultSchema, options).pipe(Effect.flatMap((result) => matchedWorktree(result, result.operation.commandId === parameters.commandId &&
+        result.operation.instanceId === parameters.instanceId))),
+});
+const makeExecutionOperations = (request) => ({
+    ...makeExecutionCatalogOperations(request),
+    ...makeExecutionCheckpointMutation(request),
+    ...makeExecutionCheckpointRead(request),
+    ...makeExecutionCommandOperations(request),
+    ...makeExecutionPlacementOperations(request),
+    ...makeExecutionWorktreeCreation(request),
+    ...makeExecutionWorktreeReads(request),
+    ...makeExecutionWorktreeSettlement(request),
+});
+const makeReceiptOperations = (request) => ({
+    getReceipt: (parameters, options) => request({ method: "receipt.get", parameters }, receiptGetResultSchema, options),
+    listReceipts: (parameters, options) => request({ method: "receipt.list", parameters }, receiptListResultSchema, options),
+});
+const makeIntegrationAuthorizationApplyOperations = (request) => ({
+    applyClaudeCodeIntegration: (parameters, options) => request({ method: "integration.apply.claude-code", parameters }, integrationApplyClaudeCodeResultSchema, options),
+    applyCodexIntegration: (parameters, options) => request({ method: "integration.apply.codex", parameters }, integrationApplyCodexResultSchema, options),
+    applyPiRpcIntegration: (parameters, options) => request({ method: "integration.apply.pi-rpc", parameters }, integrationApplyPiRpcResultSchema, options),
+});
+const makeIntegrationAuthorizationRemoveOperations = (request) => ({
+    removeClaudeCodeIntegration: (parameters, options) => request({ method: "integration.remove.claude-code", parameters }, integrationRemoveClaudeCodeResultSchema, options),
+    removeCodexIntegration: (parameters, options) => request({ method: "integration.remove.codex", parameters }, integrationRemoveCodexResultSchema, options),
+    removePiRpcIntegration: (parameters, options) => request({ method: "integration.remove.pi-rpc", parameters }, integrationRemovePiRpcResultSchema, options),
+});
+const makeIntegrationAuthorizationPlanOperations = (request) => ({
+    planClaudeCodeIntegration: (parameters, options) => request({ method: "integration.plan.claude-code", parameters }, integrationPlanClaudeCodeResultSchema, options),
+    planCodexIntegration: (parameters, options) => request({ method: "integration.plan.codex", parameters }, integrationPlanCodexResultSchema, options),
+    planPiRpcIntegration: (parameters, options) => request({ method: "integration.plan.pi-rpc", parameters }, integrationPlanPiRpcResultSchema, options),
+});
+const makeIntegrationAuthorizationStatusOperations = (request) => ({
+    statusClaudeCodeIntegration: (parameters, options) => request({ method: "integration.status.claude-code", parameters }, integrationStatusClaudeCodeResultSchema, options),
+    statusCodexIntegration: (parameters, options) => request({ method: "integration.status.codex", parameters }, integrationStatusCodexResultSchema, options),
+    statusPiRpcIntegration: (parameters, options) => request({ method: "integration.status.pi-rpc", parameters }, integrationStatusPiRpcResultSchema, options),
+});
+const makeIntegrationAuthorizationOperations = (request) => ({
+    ...makeIntegrationAuthorizationApplyOperations(request),
+    ...makeIntegrationAuthorizationPlanOperations(request),
+    ...makeIntegrationAuthorizationRemoveOperations(request),
+    ...makeIntegrationAuthorizationStatusOperations(request),
+});
+const makeRuntimeOperations = (request) => ({
+    listInstalledHarnesses: (parameters, options) => request({ method: "harness.installed.list", parameters }, installedHarnessListResultSchema, options),
+    probeRuntime: (parameters, options) => request({ method: "runtime.probe", parameters }, runtimeProbeResultSchema, options),
+});
+const makeSessionCommandOperations = (request) => ({
+    createSession: (parameters, options) => request({ method: "session.create", parameters }, sessionCreateResultSchema, options),
+    spawnSession: (parameters, options) => request({ method: "session.spawn", parameters }, sessionSpawnResultSchema, options),
+    startSession: (parameters, options) => request({ method: "session.start", parameters }, sessionStartResultSchema, options),
+});
+const makeSessionLifecycleOperations = (request) => ({
+    archiveSession: (parameters, options) => request({ method: "session.archive", parameters }, sessionArchiveResultSchema, options),
+    diffSession: (parameters, options) => request({ method: "session.diff", parameters }, sessionDiffResultSchema, options),
+    resumeSession: (parameters, options) => request({ method: "session.resume", parameters }, sessionResumeResultSchema, options),
+    stopSession: (parameters, options) => request({ method: "session.stop", parameters }, sessionStopResultSchema, options),
+});
+const makeSessionQueryOperations = (request) => ({
+    listSessionEvents: (parameters, options) => request({ method: "session.events.list", parameters }, sessionEventsListResultSchema, options),
+    listSessions: (parameters, options) => request({ method: "session.list", parameters }, sessionListResultSchema, options),
+    observeSessions: (parameters, options) => request({ method: "session.observe", parameters }, sessionObserveResultSchema, options),
+    showSession: (parameters, options) => request({ method: "session.show", parameters }, sessionShowResultSchema, options),
+});
+const makeTurnOperations = (request) => ({
+    interruptTurn: (parameters, options) => request({ method: "turn.interrupt", parameters }, turnInterruptResultSchema, options),
+    sendTurn: (parameters, options) => request({ method: "turn.send", parameters }, turnSendResultSchema, options),
+    showTurn: (parameters, options) => request({ method: "turn.show", parameters }, turnShowResultSchema, options),
+    waitTurns: (parameters, options) => request({ method: "turn.wait", parameters }, turnWaitResultSchema, options),
+});
+const makeTerminalControllerOperations = (request) => ({
+    acquireTerminalController: (parameters, options) => request({ method: "terminal.controller.acquire", parameters }, liveTerminalControllerAcquireResultSchema, options),
+    releaseTerminalController: (parameters, options) => request({ method: "terminal.controller.release", parameters }, liveTerminalControllerReleaseResultSchema, options),
+    requestTerminalController: (parameters, options) => request({ method: "terminal.controller.request", parameters }, liveTerminalControllerRequestResultSchema, options),
+});
+const makeTerminalMutationOperations = (request) => ({
+    closeTerminal: (parameters, options) => request({ method: "terminal.session.close", parameters }, liveTerminalCloseResultSchema, options),
+    resizeTerminal: (parameters, options) => request({ method: "terminal.session.resize", parameters }, liveTerminalResizeResultSchema, options),
+    signalTerminal: (parameters, options) => request({ method: "terminal.session.signal", parameters }, liveTerminalSignalResultSchema, options),
+});
+const makeTerminalWriteOperation = (request) => ({
+    writeTerminalInput: (parameters, options) => request({ method: "terminal.input.write", parameters }, liveTerminalWriteResultSchema, options),
+});
+const makeTerminalCreateOperation = (request) => ({
+    createTerminal: (parameters, options) => request({ method: "terminal.create", parameters }, terminalCreateResultSchema, options),
+});
+const makeTerminalQueryOperations = (request) => ({
+    listTerminalEvents: (parameters, options) => request({ method: "terminal.events.list", parameters }, terminalEventsListResultSchema, options),
+    listTerminals: (parameters, options) => request({ method: "terminal.list", parameters }, terminalListResultSchema, options),
+    showTerminal: (parameters, options) => request({ method: "terminal.show", parameters }, terminalShowResultSchema, options),
+});
+const makeTerminalControllerQueryOperation = (request) => ({
+    showTerminalControllerRequest: (parameters, options) => request({ method: "terminal.controller.request.show", parameters }, liveTerminalControllerRequestShowResultSchema, options),
+});
+const makeTerminalReadOperation = (request) => ({
+    readTerminal: (parameters, options) => request({ method: "terminal.read", parameters }, terminalReadResultSchema, options),
+});
+const makeOrchestrationRunOperations = (request) => ({
+    createOrchestrationRun: (parameters, options) => request({ method: "run.create", parameters }, orchestrationRunCreateResultSchema, options),
+    listOrchestrationRuns: (parameters, options) => request({ method: "run.list", parameters }, orchestrationRunListResultSchema, options),
+    showOrchestrationRun: (parameters, options) => request({ method: "run.show", parameters }, orchestrationRunShowResultSchema, options),
+});
+const makeOrchestrationTaskOperations = (request) => ({
+    listOrchestrationTasks: (parameters, options) => request({ method: "run.task.list", parameters }, orchestrationTaskListResultSchema, options),
+    showOrchestrationTask: (parameters, options) => request({ method: "run.task.show", parameters }, orchestrationTaskShowResultSchema, options),
+});
+const makeOrchestrationInboxOperations = (request) => ({
+    acknowledgeOrchestrationDelivery: (parameters, options) => request({ method: "run.inbox.ack", parameters }, orchestrationInboxAckResultSchema, options),
+    checkOrchestrationInbox: (parameters, options) => request({ method: "run.inbox.check", parameters }, orchestrationInboxCheckResultSchema, options),
+});
+const makeOrchestrationQuestionOperations = (request) => ({
+    cancelOrchestrationQuestion: (parameters, options) => request({ method: "run.question.cancel", parameters }, orchestrationQuestionCancelResultSchema, options),
+    openOrchestrationQuestion: (parameters, options) => request({ method: "run.question.open", parameters }, orchestrationQuestionOpenResultSchema, options),
+    replyOrchestrationQuestion: (parameters, options) => request({ method: "run.question.reply", parameters }, orchestrationQuestionReplyResultSchema, options),
+});
+const makeOrchestrationSettlementOperation = (request) => ({
+    settleOrchestrationDispatchTerminal: (parameters, options) => request({ method: "run.dispatch.settle-terminal", parameters }, orchestrationDispatchSettleTerminalResultSchema, options),
+});
+const makeOrchestrationDispatchShowOperation = (request) => ({
+    showOrchestrationDispatch: (parameters, options) => request({ method: "run.dispatch.show", parameters }, orchestrationDispatchShowResultSchema, options),
+});
+const invalidProjectWorkspaceResponse = () => {
+    throw new MaiaClientError("invalid_response", "The Workspace response did not match the request.");
+};
+const invalidVoicePiRelayResponse = () => {
+    throw new MaiaClientError("invalid_response", "The Pi voice relay response did not match the request.");
+};
+const makeSessionOperations = (request) => ({
+    ...makeSessionCommandOperations(request),
+    ...makeSessionLifecycleOperations(request),
+    ...makeSessionQueryOperations(request),
+    ...makeSessionMailboxOperations(request),
+});
+const makeProjectNavigationOperations = (request) => ({
+    ...makeConnectionOperations(request),
+    ...makeProjectWorkspaceOperations(request, invalidProjectWorkspaceResponse),
+    ...makeContainerOperations(request),
+    ...makePresentationOperations(request),
+});
+const makeNodeResourceOperations = (request) => ({
+    ...makePortLeaseOperations(request),
+    ...makeRemoteNodeOperations(request),
+    ...makeProviderPoolOperations(request),
+});
+const makeOperatorControlOperations = (request) => ({
+    ...makeAgentPermissionOperations(request),
+    ...makeApprovalOperations(request),
+    ...makeProjectGuardOperations(request),
+    ...makeHoldOperations(request),
+    ...makeDiscoveryOperations(request),
+});
+const makeOrchestrationOperations = (request) => ({
+    ...makeRunLedgerOperations(request),
+    ...makeOrchestrationInboxOperations(request),
+    ...makeOrchestrationQuestionOperations(request),
+    ...makeOrchestrationRunOperations(request),
+    ...makeOrchestrationTaskOperations(request),
+    ...makeOrchestrationDispatchShowOperation(request),
+    ...makeOrchestrationSettlementOperation(request),
+});
+export const makeLocalNodeEffectClient = (request) => ({
+    ...makeExecutionOperations(request),
+    ...makeExecutionRelocationOperations(request),
+    ...makeIntegrationAuthorizationOperations(request),
+    ...makeInteractionOperations(request),
+    ...makeInvocationContextOperations(request),
+    ...makeLifecycleOperations(request),
+    ...makeOrchestrationOperations(request),
+    ...makeProjectNavigationOperations(request),
+    ...makeNodeResourceOperations(request),
+    ...makeReceiptOperations(request),
+    ...makeRuntimeOperations(request),
+    ...makeSessionOperations(request),
+    ...makeOperatorControlOperations(request),
+    ...makeTerminalControllerOperations(request),
+    ...makeTerminalControllerQueryOperation(request),
+    ...makeTerminalCreateOperation(request),
+    ...makeTerminalMutationOperations(request),
+    ...makeTerminalQueryOperations(request),
+    ...makeTerminalReadOperation(request),
+    ...makeTerminalWriteOperation(request),
+    ...makeTurnOperations(request),
+    ...makeVoicePiRelayOperations(request, invalidVoicePiRelayResponse),
+    ...makeVoiceManagedTurnOperations(request),
+    ...makeCallOperation(request),
+});
+export const createLocalNodeEffectClient = (transport) => makeLocalNodeEffectClient(makeLocalNodeEffectRequester(fromPromiseTransport(transport)));
+//# sourceMappingURL=effect.js.map

package/dist/client/index.d.ts

@@ -0,0 +1,2 @@
+export { createLocalNodeClient, type LocalNodeClient, } from "./local-node-client.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/client/index.js

@@ -0,0 +1,2 @@
+export { createLocalNodeClient, } from "./local-node-client.js";
+//# sourceMappingURL=index.js.map

package/dist/client/local-node-client.d.ts

@@ -0,0 +1,100 @@
+import type { ExecutionCatalogGetParameters, ExecutionCatalogGetResult, InstalledHarnessListParameters, InstalledHarnessListResult, IntegrationApplyClaudeCodeParameters, IntegrationApplyClaudeCodeResult, IntegrationApplyCodexParameters, IntegrationApplyCodexResult, IntegrationApplyPiRpcParameters, IntegrationApplyPiRpcResult, IntegrationPlanClaudeCodeParameters, IntegrationPlanClaudeCodeResult, IntegrationPlanCodexParameters, IntegrationPlanCodexResult, IntegrationPlanPiRpcParameters, IntegrationPlanPiRpcResult, IntegrationRemoveClaudeCodeParameters, IntegrationRemoveClaudeCodeResult, IntegrationRemoveCodexParameters, IntegrationRemoveCodexResult, IntegrationRemovePiRpcParameters, IntegrationRemovePiRpcResult, IntegrationStatusClaudeCodeParameters, IntegrationStatusClaudeCodeResult, IntegrationStatusCodexParameters, IntegrationStatusCodexResult, IntegrationStatusPiRpcParameters, IntegrationStatusPiRpcResult, InvocationContextShowParameters, InvocationContextShowResult, LiveTerminalCloseParameters, LiveTerminalCloseResult, LiveTerminalControllerAcquireParameters, LiveTerminalControllerAcquireResult, LiveTerminalControllerReleaseParameters, LiveTerminalControllerReleaseResult, LiveTerminalControllerRequestParameters, LiveTerminalControllerRequestResult, LiveTerminalControllerRequestShowParameters, LiveTerminalControllerRequestShowResult, LiveTerminalResizeParameters, LiveTerminalResizeResult, LiveTerminalSignalParameters, LiveTerminalSignalResult, LiveTerminalWriteParameters, LiveTerminalWriteResult, LocalNodeShutdownResult, LocalNodeStatusResult, MonitorBootstrapCreateResult, OrchestrationDispatchSettleTerminalParameters, OrchestrationDispatchSettleTerminalResult, OrchestrationDispatchShowParameters, OrchestrationDispatchShowResult, OrchestrationInboxAckParameters, OrchestrationInboxAckResult, OrchestrationInboxCheckParameters, OrchestrationInboxCheckResult, OrchestrationQuestionCancelParameters, OrchestrationQuestionCancelResult, OrchestrationQuestionOpenParameters, OrchestrationQuestionOpenResult, OrchestrationQuestionReplyParameters, OrchestrationQuestionReplyResult, OrchestrationRunCreateParameters, OrchestrationRunCreateResult, OrchestrationRunListParameters, OrchestrationRunListResult, OrchestrationRunShowParameters, OrchestrationRunShowResult, OrchestrationTaskListParameters, OrchestrationTaskListResult, OrchestrationTaskShowParameters, OrchestrationTaskShowResult, ReceiptGetParameters, ReceiptGetResult, ReceiptListParameters, ReceiptListResult, RuntimeProbeParameters, RuntimeProbeResult, SessionArchiveParameters, SessionArchiveResult, SessionCreateParameters, SessionCreateResult, SessionDiffParameters, SessionDiffResult, SessionEventsListParameters, SessionEventsListResult, SessionListParameters, SessionListResult, SessionObserveParameters, SessionObserveResult, SessionResumeParameters, SessionResumeResult, SessionShowParameters, SessionShowResult, SessionSpawnParameters, SessionSpawnResult, SessionStartParameters, SessionStartResult, SessionStopParameters, SessionStopResult, TerminalCreateParameters, TerminalCreateResult, TerminalEventsListParameters, TerminalEventsListResult, TerminalListParameters, TerminalListResult, TerminalReadParameters, TerminalReadResult, TerminalShowParameters, TerminalShowResult, TurnInterruptParameters, TurnInterruptResult, TurnSendParameters, TurnSendResult, TurnShowParameters, TurnShowResult, TurnWaitParameters, TurnWaitResult, WorkspaceExecutionConfigureParameters, WorkspaceExecutionConfigureResult, WorkspaceExecutionShowParameters, WorkspaceExecutionShowResult } from "@maiaos/protocol";
+import type { ExecutionCommandRunParameters, ExecutionCommandRunResult, ExecutionFileReadParameters, ExecutionFileReadResult, ExecutionPlacementCreateParameters, ExecutionPlacementCreateResult, ExecutionPlacementShowParameters, ExecutionPlacementShowResult, ExecutionWorktreeCheckpointCreateParameters, ExecutionWorktreeCheckpointCreateResult, ExecutionWorktreeCheckpointShowParameters, ExecutionWorktreeCheckpointShowResult, ExecutionWorktreeCreateParameters, ExecutionWorktreeCreateResult, ExecutionWorktreeImportParameters, ExecutionWorktreeImportResult, ExecutionWorktreeReconcileParameters, ExecutionWorktreeReconcileResult, ExecutionWorktreeRemoveApplyParameters, ExecutionWorktreeRemoveApplyResult, ExecutionWorktreeRemovePlanParameters, ExecutionWorktreeRemovePlanResult, ExecutionWorktreeStatusParameters, ExecutionWorktreeStatusResult } from "@maiaos/protocol/execution-candidate";
+import type { AgentPermissionClient } from "../agent-permission/index.js";
+import type { ApprovalClient } from "../approval/index.js";
+import type { LocalNodeCallClient } from "../call/index.js";
+import type { ConnectionClient } from "../connection/index.js";
+import type { ContainerClient } from "../container/index.js";
+import type { DiscoveryClient } from "../discovery/index.js";
+import type { ExecutionRelocationClient } from "../execution/index.js";
+import type { HoldClient } from "../hold/index.js";
+import type { InteractionClient } from "../interaction/index.js";
+import type { PortLeaseClient } from "../port-lease/index.js";
+import type { PresentationClient } from "../presentation/index.js";
+import type { ProjectGuardClient } from "../project-guard/index.js";
+import type { ProjectWorkspaceClient } from "../project-workspace/index.js";
+import type { ProviderPoolClient } from "../provider-pool/index.js";
+import type { RemoteNodeClient } from "../remote-node/index.js";
+import type { LocalNodeRequestOptions, MaiaTransport } from "../request/index.js";
+import type { RunLedgerClient } from "../run-ledger/index.js";
+import type { SessionMailboxClient } from "../session/index.js";
+import type { VoiceManagedTurnClient, VoicePiRelayClient } from "../voice/index.js";
+export type LocalNodeClient = ExecutionRelocationClient & ProjectWorkspaceClient & ProviderPoolClient & AgentPermissionClient & PresentationClient & ConnectionClient & ContainerClient & HoldClient & DiscoveryClient & InteractionClient & ApprovalClient & PortLeaseClient & RemoteNodeClient & RunLedgerClient & ProjectGuardClient & SessionMailboxClient & VoicePiRelayClient & VoiceManagedTurnClient & LocalNodeCallClient & {
+    readonly acknowledgeOrchestrationDelivery: (parameters: OrchestrationInboxAckParameters, options: LocalNodeRequestOptions) => Promise<OrchestrationInboxAckResult>;
+    readonly acquireTerminalController: (parameters: LiveTerminalControllerAcquireParameters, options: LocalNodeRequestOptions) => Promise<LiveTerminalControllerAcquireResult>;
+    readonly applyClaudeCodeIntegration: (parameters: IntegrationApplyClaudeCodeParameters, options: LocalNodeRequestOptions) => Promise<IntegrationApplyClaudeCodeResult>;
+    readonly applyCodexIntegration: (parameters: IntegrationApplyCodexParameters, options: LocalNodeRequestOptions) => Promise<IntegrationApplyCodexResult>;
+    readonly applyPiRpcIntegration: (parameters: IntegrationApplyPiRpcParameters, options: LocalNodeRequestOptions) => Promise<IntegrationApplyPiRpcResult>;
+    readonly archiveSession: (parameters: SessionArchiveParameters, options: LocalNodeRequestOptions) => Promise<SessionArchiveResult>;
+    readonly cancelOrchestrationQuestion: (parameters: OrchestrationQuestionCancelParameters, options: LocalNodeRequestOptions) => Promise<OrchestrationQuestionCancelResult>;
+    readonly checkOrchestrationInbox: (parameters: OrchestrationInboxCheckParameters, options: LocalNodeRequestOptions) => Promise<OrchestrationInboxCheckResult>;
+    readonly closeTerminal: (parameters: LiveTerminalCloseParameters, options: LocalNodeRequestOptions) => Promise<LiveTerminalCloseResult>;
+    readonly configureWorkspaceExecution: (parameters: WorkspaceExecutionConfigureParameters, options: LocalNodeRequestOptions) => Promise<WorkspaceExecutionConfigureResult>;
+    readonly createExecutionCheckpoint: (parameters: ExecutionWorktreeCheckpointCreateParameters, options: LocalNodeRequestOptions) => Promise<ExecutionWorktreeCheckpointCreateResult>;
+    readonly createExecutionPlacement: (parameters: ExecutionPlacementCreateParameters, options: LocalNodeRequestOptions) => Promise<ExecutionPlacementCreateResult>;
+    readonly createExecutionWorktree: (parameters: ExecutionWorktreeCreateParameters, options: LocalNodeRequestOptions) => Promise<ExecutionWorktreeCreateResult>;
+    readonly createMonitorBootstrap: (options: LocalNodeRequestOptions) => Promise<MonitorBootstrapCreateResult>;
+    readonly createOrchestrationRun: (parameters: OrchestrationRunCreateParameters, options: LocalNodeRequestOptions) => Promise<OrchestrationRunCreateResult>;
+    readonly createSession: (parameters: SessionCreateParameters, options: LocalNodeRequestOptions) => Promise<SessionCreateResult>;
+    readonly createTerminal: (parameters: TerminalCreateParameters, options: LocalNodeRequestOptions) => Promise<TerminalCreateResult>;
+    readonly diffSession: (parameters: SessionDiffParameters, options: LocalNodeRequestOptions) => Promise<SessionDiffResult>;
+    readonly getReceipt: (parameters: ReceiptGetParameters, options: LocalNodeRequestOptions) => Promise<ReceiptGetResult>;
+    readonly importExecutionWorktree: (parameters: ExecutionWorktreeImportParameters, options: LocalNodeRequestOptions) => Promise<ExecutionWorktreeImportResult>;
+    readonly interruptTurn: (parameters: TurnInterruptParameters, options: LocalNodeRequestOptions) => Promise<TurnInterruptResult>;
+    readonly listInstalledHarnesses: (parameters: InstalledHarnessListParameters, options: LocalNodeRequestOptions) => Promise<InstalledHarnessListResult>;
+    readonly listOrchestrationRuns: (parameters: OrchestrationRunListParameters, options: LocalNodeRequestOptions) => Promise<OrchestrationRunListResult>;
+    readonly listOrchestrationTasks: (parameters: OrchestrationTaskListParameters, options: LocalNodeRequestOptions) => Promise<OrchestrationTaskListResult>;
+    readonly listReceipts: (parameters: ReceiptListParameters, options: LocalNodeRequestOptions) => Promise<ReceiptListResult>;
+    readonly listSessionEvents: (parameters: SessionEventsListParameters, options: LocalNodeRequestOptions) => Promise<SessionEventsListResult>;
+    readonly listSessions: (parameters: SessionListParameters, options: LocalNodeRequestOptions) => Promise<SessionListResult>;
+    readonly listTerminalEvents: (parameters: TerminalEventsListParameters, options: LocalNodeRequestOptions) => Promise<TerminalEventsListResult>;
+    readonly listTerminals: (parameters: TerminalListParameters, options: LocalNodeRequestOptions) => Promise<TerminalListResult>;
+    readonly observeSessions: (parameters: SessionObserveParameters, options: LocalNodeRequestOptions) => Promise<SessionObserveResult>;
+    readonly openOrchestrationQuestion: (parameters: OrchestrationQuestionOpenParameters, options: LocalNodeRequestOptions) => Promise<OrchestrationQuestionOpenResult>;
+    readonly planClaudeCodeIntegration: (parameters: IntegrationPlanClaudeCodeParameters, options: LocalNodeRequestOptions) => Promise<IntegrationPlanClaudeCodeResult>;
+    readonly planCodexIntegration: (parameters: IntegrationPlanCodexParameters, options: LocalNodeRequestOptions) => Promise<IntegrationPlanCodexResult>;
+    readonly planExecutionWorktreeRemove: (parameters: ExecutionWorktreeRemovePlanParameters, options: LocalNodeRequestOptions) => Promise<ExecutionWorktreeRemovePlanResult>;
+    readonly planPiRpcIntegration: (parameters: IntegrationPlanPiRpcParameters, options: LocalNodeRequestOptions) => Promise<IntegrationPlanPiRpcResult>;
+    readonly probeRuntime: (parameters: RuntimeProbeParameters, options: LocalNodeRequestOptions) => Promise<RuntimeProbeResult>;
+    readonly readExecutionCatalog: (parameters: ExecutionCatalogGetParameters, options: LocalNodeRequestOptions) => Promise<ExecutionCatalogGetResult>;
+    readonly readExecutionFile: (parameters: ExecutionFileReadParameters, options: LocalNodeRequestOptions) => Promise<ExecutionFileReadResult>;
+    readonly readTerminal: (parameters: TerminalReadParameters, options: LocalNodeRequestOptions) => Promise<TerminalReadResult>;
+    readonly reconcileExecutionWorktree: (parameters: ExecutionWorktreeReconcileParameters, options: LocalNodeRequestOptions) => Promise<ExecutionWorktreeReconcileResult>;
+    readonly releaseTerminalController: (parameters: LiveTerminalControllerReleaseParameters, options: LocalNodeRequestOptions) => Promise<LiveTerminalControllerReleaseResult>;
+    readonly removeClaudeCodeIntegration: (parameters: IntegrationRemoveClaudeCodeParameters, options: LocalNodeRequestOptions) => Promise<IntegrationRemoveClaudeCodeResult>;
+    readonly removeCodexIntegration: (parameters: IntegrationRemoveCodexParameters, options: LocalNodeRequestOptions) => Promise<IntegrationRemoveCodexResult>;
+    readonly removeExecutionWorktree: (parameters: ExecutionWorktreeRemoveApplyParameters, options: LocalNodeRequestOptions) => Promise<ExecutionWorktreeRemoveApplyResult>;
+    readonly removePiRpcIntegration: (parameters: IntegrationRemovePiRpcParameters, options: LocalNodeRequestOptions) => Promise<IntegrationRemovePiRpcResult>;
+    readonly replyOrchestrationQuestion: (parameters: OrchestrationQuestionReplyParameters, options: LocalNodeRequestOptions) => Promise<OrchestrationQuestionReplyResult>;
+    readonly requestTerminalController: (parameters: LiveTerminalControllerRequestParameters, options: LocalNodeRequestOptions) => Promise<LiveTerminalControllerRequestResult>;
+    readonly resizeTerminal: (parameters: LiveTerminalResizeParameters, options: LocalNodeRequestOptions) => Promise<LiveTerminalResizeResult>;
+    readonly resumeSession: (parameters: SessionResumeParameters, options: LocalNodeRequestOptions) => Promise<SessionResumeResult>;
+    readonly runExecutionCommand: (parameters: ExecutionCommandRunParameters, options: LocalNodeRequestOptions) => Promise<ExecutionCommandRunResult>;
+    readonly sendTurn: (parameters: TurnSendParameters, options: LocalNodeRequestOptions) => Promise<TurnSendResult>;
+    readonly settleOrchestrationDispatchTerminal: (parameters: OrchestrationDispatchSettleTerminalParameters, options: LocalNodeRequestOptions) => Promise<OrchestrationDispatchSettleTerminalResult>;
+    readonly showCurrentContext: (parameters: InvocationContextShowParameters, options: LocalNodeRequestOptions) => Promise<InvocationContextShowResult>;
+    readonly showExecutionCheckpoint: (parameters: ExecutionWorktreeCheckpointShowParameters, options: LocalNodeRequestOptions) => Promise<ExecutionWorktreeCheckpointShowResult>;
+    readonly showExecutionPlacement: (parameters: ExecutionPlacementShowParameters, options: LocalNodeRequestOptions) => Promise<ExecutionPlacementShowResult>;
+    readonly showExecutionWorktreeStatus: (parameters: ExecutionWorktreeStatusParameters, options: LocalNodeRequestOptions) => Promise<ExecutionWorktreeStatusResult>;
+    readonly showOrchestrationDispatch: (parameters: OrchestrationDispatchShowParameters, options: LocalNodeRequestOptions) => Promise<OrchestrationDispatchShowResult>;
+    readonly showOrchestrationRun: (parameters: OrchestrationRunShowParameters, options: LocalNodeRequestOptions) => Promise<OrchestrationRunShowResult>;
+    readonly showOrchestrationTask: (parameters: OrchestrationTaskShowParameters, options: LocalNodeRequestOptions) => Promise<OrchestrationTaskShowResult>;
+    readonly showSession: (parameters: SessionShowParameters, options: LocalNodeRequestOptions) => Promise<SessionShowResult>;
+    readonly showTerminal: (parameters: TerminalShowParameters, options: LocalNodeRequestOptions) => Promise<TerminalShowResult>;
+    readonly showTerminalControllerRequest: (parameters: LiveTerminalControllerRequestShowParameters, options: LocalNodeRequestOptions) => Promise<LiveTerminalControllerRequestShowResult>;
+    readonly showTurn: (parameters: TurnShowParameters, options: LocalNodeRequestOptions) => Promise<TurnShowResult>;
+    readonly showWorkspaceExecution: (parameters: WorkspaceExecutionShowParameters, options: LocalNodeRequestOptions) => Promise<WorkspaceExecutionShowResult>;
+    readonly shutdown: (options: LocalNodeRequestOptions) => Promise<LocalNodeShutdownResult>;
+    readonly signalTerminal: (parameters: LiveTerminalSignalParameters, options: LocalNodeRequestOptions) => Promise<LiveTerminalSignalResult>;
+    readonly spawnSession: (parameters: SessionSpawnParameters, options: LocalNodeRequestOptions) => Promise<SessionSpawnResult>;
+    readonly startSession: (parameters: SessionStartParameters, options: LocalNodeRequestOptions) => Promise<SessionStartResult>;
+    readonly status: (options: LocalNodeRequestOptions) => Promise<LocalNodeStatusResult>;
+    readonly statusClaudeCodeIntegration: (parameters: IntegrationStatusClaudeCodeParameters, options: LocalNodeRequestOptions) => Promise<IntegrationStatusClaudeCodeResult>;
+    readonly statusCodexIntegration: (parameters: IntegrationStatusCodexParameters, options: LocalNodeRequestOptions) => Promise<IntegrationStatusCodexResult>;
+    readonly statusPiRpcIntegration: (parameters: IntegrationStatusPiRpcParameters, options: LocalNodeRequestOptions) => Promise<IntegrationStatusPiRpcResult>;
+    readonly stopSession: (parameters: SessionStopParameters, options: LocalNodeRequestOptions) => Promise<SessionStopResult>;
+    readonly waitTurns: (parameters: TurnWaitParameters, options: LocalNodeRequestOptions) => Promise<TurnWaitResult>;
+    readonly writeTerminalInput: (parameters: LiveTerminalWriteParameters, options: LocalNodeRequestOptions) => Promise<LiveTerminalWriteResult>;
+};
+export declare const createLocalNodeClient: (transport: MaiaTransport) => LocalNodeClient;
+//# sourceMappingURL=local-node-client.d.ts.map

package/dist/client/local-node-client.js

@@ -0,0 +1,4 @@
+import { toPromiseClient } from "../request/effect.js";
+import { createLocalNodeEffectClient } from "./effect.js";
+export const createLocalNodeClient = (transport) => toPromiseClient(createLocalNodeEffectClient(transport));
+//# sourceMappingURL=local-node-client.js.map

package/dist/connection/connection.d.ts

@@ -0,0 +1,19 @@
+import type { ConnectionCapacitySetParameters, ConnectionCapacitySetResult, ConnectionCreateParameters, ConnectionCreateResult, ConnectionDetectParameters, ConnectionDetectResult, ConnectionGatewayCreateParameters, ConnectionGatewayCreateResult, ConnectionListParameters, ConnectionListResult, ConnectionLoginStartParameters, ConnectionLoginStartResult, ConnectionModelsListParameters, ConnectionModelsListResult, ConnectionShowParameters, ConnectionShowResult, ConnectionStateSetParameters, ConnectionStateSetResult, ConnectionSystemConfirmParameters, ConnectionSystemConfirmResult, ConnectionSystemPreviewParameters, ConnectionSystemPreviewResult, ConnectionUsageShowParameters, ConnectionUsageShowResult } from "@maiaos/protocol";
+import type { LocalNodeRequester, LocalNodeRequestOptions } from "../request/index.js";
+export type ConnectionClient = {
+    readonly confirmSystemConnections: (parameters: ConnectionSystemConfirmParameters, options: LocalNodeRequestOptions) => Promise<ConnectionSystemConfirmResult>;
+    readonly createConnection: (parameters: ConnectionCreateParameters, options: LocalNodeRequestOptions) => Promise<ConnectionCreateResult>;
+    readonly createGatewayConnection: (parameters: ConnectionGatewayCreateParameters, options: LocalNodeRequestOptions) => Promise<ConnectionGatewayCreateResult>;
+    readonly detectConnections: (parameters: ConnectionDetectParameters, options: LocalNodeRequestOptions) => Promise<ConnectionDetectResult>;
+    readonly listConnectionModels: (parameters: ConnectionModelsListParameters, options: LocalNodeRequestOptions) => Promise<ConnectionModelsListResult>;
+    readonly listConnections: (parameters: ConnectionListParameters, options: LocalNodeRequestOptions) => Promise<ConnectionListResult>;
+    readonly previewSystemConnections: (parameters: ConnectionSystemPreviewParameters, options: LocalNodeRequestOptions) => Promise<ConnectionSystemPreviewResult>;
+    readonly setConnectionCapacity: (parameters: ConnectionCapacitySetParameters, options: LocalNodeRequestOptions) => Promise<ConnectionCapacitySetResult>;
+    readonly setConnectionState: (parameters: ConnectionStateSetParameters, options: LocalNodeRequestOptions) => Promise<ConnectionStateSetResult>;
+    readonly showConnection: (parameters: ConnectionShowParameters, options: LocalNodeRequestOptions) => Promise<ConnectionShowResult>;
+    readonly showConnectionUsage: (parameters: ConnectionUsageShowParameters, options: LocalNodeRequestOptions) => Promise<ConnectionUsageShowResult>;
+    readonly startConnectionLogin: (parameters: ConnectionLoginStartParameters, options: LocalNodeRequestOptions) => Promise<ConnectionLoginStartResult>;
+};
+export declare const makeConnectionClient: (request: LocalNodeRequester) => ConnectionClient;
+export { type Connection, type ConnectionCapacitySetParameters, connectionCapacitySetParametersSchema, type ConnectionCapacitySetResult, connectionCapacitySetResultSchema, type ConnectionCreateParameters, connectionCreateParametersSchema, type ConnectionCreateResult, connectionCreateResultSchema, type ConnectionDetectParameters, connectionDetectParametersSchema, type ConnectionDetectResult, connectionDetectResultSchema, type ConnectionExecutor, connectionExecutorSchema, type ConnectionGatewayCreateParameters, connectionGatewayCreateParametersSchema, type ConnectionGatewayCreateResult, connectionGatewayCreateResultSchema, type ConnectionListParameters, connectionListParametersSchema, type ConnectionListResult, connectionListResultSchema, type ConnectionLoginStartParameters, connectionLoginStartParametersSchema, type ConnectionLoginStartResult, connectionLoginStartResultSchema, type ConnectionModelId, connectionModelIdSchema, type ConnectionModelsListParameters, connectionModelsListParametersSchema, type ConnectionModelsListResult, connectionModelsListResultSchema, connectionSchema, type ConnectionShowParameters, connectionShowParametersSchema, type ConnectionShowResult, connectionShowResultSchema, type ConnectionStateSetParameters, connectionStateSetParametersSchema, type ConnectionStateSetResult, connectionStateSetResultSchema, type ConnectionSystemConfirmParameters, connectionSystemConfirmParametersSchema, type ConnectionSystemConfirmResult, connectionSystemConfirmResultSchema, type ConnectionSystemPreviewParameters, connectionSystemPreviewParametersSchema, type ConnectionSystemPreviewResult, connectionSystemPreviewResultSchema, type ConnectionUsage, connectionUsageSchema, type ConnectionUsageShowParameters, connectionUsageShowParametersSchema, type ConnectionUsageShowResult, connectionUsageShowResultSchema, type DetectedExecutor, detectedExecutorSchema, MAX_CONNECTION_MODELS, MAX_CONNECTION_PAGE_SIZE, MAX_CONNECTION_SESSIONS, MAX_CONNECTION_USAGE_WINDOWS, MAX_GATEWAY_BASE_URL_LENGTH, } from "@maiaos/protocol";
+//# sourceMappingURL=connection.d.ts.map

package/dist/connection/connection.js

@@ -0,0 +1,5 @@
+import { fromPromiseRequester, toPromiseClient } from "../request/effect.js";
+import { makeConnectionOperations } from "./effect.js";
+export const makeConnectionClient = (request) => toPromiseClient(makeConnectionOperations(fromPromiseRequester(request)));
+export { connectionCapacitySetParametersSchema, connectionCapacitySetResultSchema, connectionCreateParametersSchema, connectionCreateResultSchema, connectionDetectParametersSchema, connectionDetectResultSchema, connectionExecutorSchema, connectionGatewayCreateParametersSchema, connectionGatewayCreateResultSchema, connectionListParametersSchema, connectionListResultSchema, connectionLoginStartParametersSchema, connectionLoginStartResultSchema, connectionModelIdSchema, connectionModelsListParametersSchema, connectionModelsListResultSchema, connectionSchema, connectionShowParametersSchema, connectionShowResultSchema, connectionStateSetParametersSchema, connectionStateSetResultSchema, connectionSystemConfirmParametersSchema, connectionSystemConfirmResultSchema, connectionSystemPreviewParametersSchema, connectionSystemPreviewResultSchema, connectionUsageSchema, connectionUsageShowParametersSchema, connectionUsageShowResultSchema, detectedExecutorSchema, MAX_CONNECTION_MODELS, MAX_CONNECTION_PAGE_SIZE, MAX_CONNECTION_SESSIONS, MAX_CONNECTION_USAGE_WINDOWS, MAX_GATEWAY_BASE_URL_LENGTH, } from "@maiaos/protocol";
+//# sourceMappingURL=connection.js.map

package/dist/connection/effect.d.ts

@@ -0,0 +1,5 @@
+import { type EffectClient, type LocalNodeEffectRequester } from "../request/effect.js";
+import { MaiaClientError } from "../request/index.js";
+import type { ConnectionClient } from "./connection.js";
+export declare const makeConnectionOperations: <TError>(request: LocalNodeEffectRequester<TError>) => EffectClient<ConnectionClient, MaiaClientError | TError>;
+//# sourceMappingURL=effect.d.ts.map

package/dist/connection/effect.js

@@ -0,0 +1,119 @@
+import { connectionCapacitySetResultSchema, connectionCreateResultSchema, connectionDetectResultSchema, connectionGatewayCreateResultSchema, connectionListResultSchema, connectionLoginStartResultSchema, connectionModelsListResultSchema, connectionShowResultSchema, connectionStateSetResultSchema, connectionSystemConfirmResultSchema, connectionSystemPreviewResultSchema, connectionUsageShowResultSchema, } from "@maiaos/protocol";
+import { verifiedMutation, } from "../request/effect.js";
+import { MaiaClientError } from "../request/index.js";
+const requireMatch = (matches) => {
+    if (!matches)
+        throw new MaiaClientError("invalid_response", "The connection response did not match the request.");
+};
+const parseCreate = (value, input) => {
+    const result = connectionCreateResultSchema.parse(value);
+    const record = result.connection;
+    requireMatch(result.commandId === input.commandId &&
+        record.name === input.name &&
+        record.executor === input.executor &&
+        record.configRoot.kind === input.configRootKind &&
+        (input.maxConcurrentSessions === undefined ||
+            record.maxConcurrentSessions === input.maxConcurrentSessions));
+    return result;
+};
+const parseGatewayCreate = (value, input) => {
+    const result = connectionGatewayCreateResultSchema.parse(value);
+    const record = result.connection;
+    requireMatch(result.commandId === input.commandId &&
+        record.name === input.name &&
+        record.gateway?.baseUrl === input.baseUrl &&
+        (input.maxConcurrentSessions === undefined ||
+            record.maxConcurrentSessions === input.maxConcurrentSessions));
+    return result;
+};
+const parseModelsList = (value, input) => {
+    const result = connectionModelsListResultSchema.parse(value);
+    requireMatch(result.connectionId === input.connectionId);
+    return result;
+};
+const parseList = (value, input) => {
+    const result = connectionListResultSchema.parse(value);
+    requireMatch(result.items.length <= input.limit &&
+        (result.nextCursor === undefined ||
+            result.nextCursor !== input.afterCursor));
+    return result;
+};
+const parseShow = (value, input) => {
+    const result = connectionShowResultSchema.parse(value);
+    requireMatch(result.connection.connectionId === input.connectionId);
+    return result;
+};
+const parseStateSet = (value, input) => {
+    const result = connectionStateSetResultSchema.parse(value);
+    requireMatch(result.commandId === input.commandId &&
+        result.connection.connectionId === input.connectionId &&
+        result.expectedRevision === input.expectedRevision &&
+        result.connection.state === input.state);
+    return result;
+};
+const parseCapacitySet = (value, input) => {
+    const result = connectionCapacitySetResultSchema.parse(value);
+    requireMatch(result.commandId === input.commandId &&
+        result.connection.connectionId === input.connectionId &&
+        result.expectedRevision === input.expectedRevision &&
+        result.connection.maxConcurrentSessions === input.maxConcurrentSessions);
+    return result;
+};
+const parseUsageShow = (value, input) => {
+    const result = connectionUsageShowResultSchema.parse(value);
+    requireMatch(result.connection.connectionId === input.connectionId);
+    return result;
+};
+const revisedMatches = (result, input) => result.commandId === input.commandId &&
+    result.connection.connectionId === input.connectionId &&
+    result.expectedRevision === input.expectedRevision;
+const parseLoginStart = (value, input) => {
+    const result = connectionLoginStartResultSchema.parse(value);
+    requireMatch(revisedMatches(result, input) &&
+        (input.flow === "browser") === (result.login.authUrl !== undefined));
+    return result;
+};
+const parseSystemPreview = (value, input) => {
+    const result = connectionSystemPreviewResultSchema.parse(value);
+    requireMatch(result.commandId === input.commandId);
+    return result;
+};
+const parseSystemConfirm = (value, input) => {
+    const result = connectionSystemConfirmResultSchema.parse(value);
+    requireMatch(result.commandId === input.commandId &&
+        result.inputDigest === input.inputDigest);
+    return result;
+};
+const makeSystemOperations = (read, mutate) => ({
+    confirmSystemConnections: (parameters, options) => mutate({ method: "connection.system.confirm", parameters }, { parse: (value) => parseSystemConfirm(value, parameters) }, options),
+    detectConnections: (parameters, options) => read({ method: "connection.detect", parameters }, { parse: (value) => connectionDetectResultSchema.parse(value) }, options),
+    previewSystemConnections: (parameters, options) => read({ method: "connection.system.preview", parameters }, { parse: (value) => parseSystemPreview(value, parameters) }, options),
+});
+const makeConnectionReads = (request) => ({
+    listConnections: (parameters, options) => request({ method: "connection.list", parameters }, { parse: (value) => parseList(value, parameters) }, options),
+    showConnection: (parameters, options) => request({ method: "connection.show", parameters }, { parse: (value) => parseShow(value, parameters) }, options),
+    showConnectionUsage: (parameters, options) => request({ method: "connection.usage.show", parameters }, { parse: (value) => parseUsageShow(value, parameters) }, options),
+});
+const makeConnectionRecordMutations = (request) => ({
+    createConnection: (parameters, options) => request({ method: "connection.create", parameters }, { parse: (value) => parseCreate(value, parameters) }, options),
+    setConnectionCapacity: (parameters, options) => request({ method: "connection.capacity.set", parameters }, { parse: (value) => parseCapacitySet(value, parameters) }, options),
+    setConnectionState: (parameters, options) => request({ method: "connection.state.set", parameters }, { parse: (value) => parseStateSet(value, parameters) }, options),
+});
+const makeConnectionAccessMutations = (request) => ({
+    startConnectionLogin: (parameters, options) => request({ method: "connection.login.start", parameters }, { parse: (value) => parseLoginStart(value, parameters) }, options),
+});
+const makeGatewayOperations = (read, mutate) => ({
+    createGatewayConnection: (parameters, options) => mutate({ method: "connection.gateway.create", parameters }, { parse: (value) => parseGatewayCreate(value, parameters) }, options),
+    listConnectionModels: (parameters, options) => read({ method: "connection.models.list", parameters }, { parse: (value) => parseModelsList(value, parameters) }, options),
+});
+export const makeConnectionOperations = (request) => {
+    const verified = (payload, output, options) => verifiedMutation(request(payload, output, options), options);
+    return {
+        ...makeConnectionReads(request),
+        ...makeConnectionRecordMutations(verified),
+        ...makeConnectionAccessMutations(verified),
+        ...makeGatewayOperations(request, verified),
+        ...makeSystemOperations(request, verified),
+    };
+};
+//# sourceMappingURL=effect.js.map

package/dist/connection/index.d.ts

@@ -0,0 +1,2 @@
+export { type Connection, type ConnectionCapacitySetParameters, connectionCapacitySetParametersSchema, type ConnectionCapacitySetResult, connectionCapacitySetResultSchema, type ConnectionClient, type ConnectionCreateParameters, connectionCreateParametersSchema, type ConnectionCreateResult, connectionCreateResultSchema, type ConnectionDetectParameters, connectionDetectParametersSchema, type ConnectionDetectResult, connectionDetectResultSchema, type ConnectionExecutor, connectionExecutorSchema, type ConnectionGatewayCreateParameters, connectionGatewayCreateParametersSchema, type ConnectionGatewayCreateResult, connectionGatewayCreateResultSchema, type ConnectionListParameters, connectionListParametersSchema, type ConnectionListResult, connectionListResultSchema, type ConnectionLoginStartParameters, connectionLoginStartParametersSchema, type ConnectionLoginStartResult, connectionLoginStartResultSchema, type ConnectionModelId, connectionModelIdSchema, type ConnectionModelsListParameters, connectionModelsListParametersSchema, type ConnectionModelsListResult, connectionModelsListResultSchema, connectionSchema, type ConnectionShowParameters, connectionShowParametersSchema, type ConnectionShowResult, connectionShowResultSchema, type ConnectionStateSetParameters, connectionStateSetParametersSchema, type ConnectionStateSetResult, connectionStateSetResultSchema, type ConnectionSystemConfirmParameters, connectionSystemConfirmParametersSchema, type ConnectionSystemConfirmResult, connectionSystemConfirmResultSchema, type ConnectionSystemPreviewParameters, connectionSystemPreviewParametersSchema, type ConnectionSystemPreviewResult, connectionSystemPreviewResultSchema, type ConnectionUsage, connectionUsageSchema, type ConnectionUsageShowParameters, connectionUsageShowParametersSchema, type ConnectionUsageShowResult, connectionUsageShowResultSchema, type DetectedExecutor, detectedExecutorSchema, makeConnectionClient, MAX_CONNECTION_MODELS, MAX_CONNECTION_PAGE_SIZE, MAX_CONNECTION_SESSIONS, MAX_CONNECTION_USAGE_WINDOWS, MAX_GATEWAY_BASE_URL_LENGTH, } from "./connection.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/connection/index.js

@@ -0,0 +1,2 @@
+export { connectionCapacitySetParametersSchema, connectionCapacitySetResultSchema, connectionCreateParametersSchema, connectionCreateResultSchema, connectionDetectParametersSchema, connectionDetectResultSchema, connectionExecutorSchema, connectionGatewayCreateParametersSchema, connectionGatewayCreateResultSchema, connectionListParametersSchema, connectionListResultSchema, connectionLoginStartParametersSchema, connectionLoginStartResultSchema, connectionModelIdSchema, connectionModelsListParametersSchema, connectionModelsListResultSchema, connectionSchema, connectionShowParametersSchema, connectionShowResultSchema, connectionStateSetParametersSchema, connectionStateSetResultSchema, connectionSystemConfirmParametersSchema, connectionSystemConfirmResultSchema, connectionSystemPreviewParametersSchema, connectionSystemPreviewResultSchema, connectionUsageSchema, connectionUsageShowParametersSchema, connectionUsageShowResultSchema, detectedExecutorSchema, makeConnectionClient, MAX_CONNECTION_MODELS, MAX_CONNECTION_PAGE_SIZE, MAX_CONNECTION_SESSIONS, MAX_CONNECTION_USAGE_WINDOWS, MAX_GATEWAY_BASE_URL_LENGTH, } from "./connection.js";
+//# sourceMappingURL=index.js.map

package/dist/container/container.d.ts

@@ -0,0 +1,14 @@
+import type { ContainerCreateConfirmParameters, ContainerCreateConfirmResult, ContainerCreatePreviewParameters, ContainerCreatePreviewResult, ContainerIndexListParameters, ContainerIndexListResult, ContainerListParameters, ContainerListResult, ContainerRenameConfirmParameters, ContainerRenameConfirmResult, ContainerRenamePreviewParameters, ContainerRenamePreviewResult, ContainerShowParameters, ContainerShowResult } from "@maiaos/protocol";
+import type { LocalNodeRequester, LocalNodeRequestOptions } from "../request/index.js";
+export type ContainerClient = {
+    readonly confirmContainerCreate: (parameters: ContainerCreateConfirmParameters, options: LocalNodeRequestOptions) => Promise<ContainerCreateConfirmResult>;
+    readonly confirmContainerRename: (parameters: ContainerRenameConfirmParameters, options: LocalNodeRequestOptions) => Promise<ContainerRenameConfirmResult>;
+    readonly listContainerIndex: (parameters: ContainerIndexListParameters, options: LocalNodeRequestOptions) => Promise<ContainerIndexListResult>;
+    readonly listContainers: (parameters: ContainerListParameters, options: LocalNodeRequestOptions) => Promise<ContainerListResult>;
+    readonly previewContainerCreate: (parameters: ContainerCreatePreviewParameters, options: LocalNodeRequestOptions) => Promise<ContainerCreatePreviewResult>;
+    readonly previewContainerRename: (parameters: ContainerRenamePreviewParameters, options: LocalNodeRequestOptions) => Promise<ContainerRenamePreviewResult>;
+    readonly showContainer: (parameters: ContainerShowParameters, options: LocalNodeRequestOptions) => Promise<ContainerShowResult>;
+};
+export declare const makeContainerClient: (request: LocalNodeRequester) => ContainerClient;
+export { type Container, type ContainerCreateConfirmParameters, containerCreateConfirmParametersSchema, type ContainerCreateConfirmResult, type ContainerCreatePreviewParameters, containerCreatePreviewParametersSchema, type ContainerCreatePreviewResult, type ContainerIndexEntry, type ContainerIndexListParameters, containerIndexListParametersSchema, type ContainerIndexListResult, type ContainerIndexProject, type ContainerListParameters, containerListParametersSchema, type ContainerListResult, type ContainerProjectSummary, containerProjectSummarySchema, type ContainerRenameConfirmParameters, containerRenameConfirmParametersSchema, type ContainerRenameConfirmResult, type ContainerRenamePreviewParameters, containerRenamePreviewParametersSchema, type ContainerRenamePreviewResult, containerSchema, type ContainerShowParameters, containerShowParametersSchema, type ContainerShowResult, } from "@maiaos/protocol";
+//# sourceMappingURL=container.d.ts.map