@maiaos/cli 0.1.0-canary.2

package/dist/orchestration/output/human.js

@@ -0,0 +1,252 @@
+import { cell, formatRows, tab, withNextPage, writeNodeResult, } from "../../command-line/index.js";
+import { projectDispatchSettleResult, projectDispatchShowDispatch, projectInboxAckResult, projectQuestionCancelResult, projectQuestionOpenResult, projectQuestionReplyResult, projectRunCreateResult, projectRunShowResult, } from "./compact-aggregate.js";
+import { projectRunListResult, } from "./compact-run-list.js";
+export const formatInboxAck = (result) => `${tab([
+    result.command,
+    result.receipt.commandId,
+    result.runId,
+    result.owner.kind,
+    result.owner.id,
+    result.mailboxRevision,
+    result.receipt.state,
+])}\n${tab([
+    result.delivery.deliveryId,
+    result.delivery.sequence,
+    result.delivery.type,
+    cell(result.delivery.subject),
+])}\n`;
+const formatInboxCheck = (result) => {
+    const header = tab([
+        result.command,
+        result.runId,
+        result.owner.kind,
+        result.owner.id,
+        String(result.count),
+        result.mailboxRevision,
+    ]);
+    if (result.items.length === 0)
+        return `${header}\n`;
+    return `${header}\n${result.items
+        .map((item) => tab([item.deliveryId, item.sequence, item.type, cell(item.subject)]))
+        .join("\n")}\n`;
+};
+export const formatRunList = (result) => withNextPage(formatRows(result.items, (item) => tab([
+    item.id,
+    item.state,
+    item.revision,
+    item.terminalId,
+    item.rootTaskId,
+    item.dispatchTaskId,
+]), {
+    empty: "No runs.",
+    headers: [
+        "RUN",
+        "STATE",
+        "REVISION",
+        "TERMINAL",
+        "ROOT TASK",
+        "DISPATCH TASK",
+    ],
+}), result.nextCursor);
+const formatTaskList = (result) => withNextPage(formatRows(result.items, (item) => tab([item.id, item.clientKey, item.state, item.revision]), { empty: "No tasks.", headers: ["TASK", "KEY", "STATE", "REVISION"] }), result.nextCursor);
+const formatTaskShow = (result) => [
+    tab([
+        result.command,
+        result.task.runId,
+        result.task.id,
+        result.task.clientKey,
+        result.task.state,
+        result.task.revision,
+    ]),
+    cell(result.task.objective),
+    "",
+].join("\n");
+const formatDispatchShow = (result) => {
+    const header = tab([
+        result.command,
+        result.dispatch.runId,
+        result.dispatch.id,
+        result.dispatch.taskId,
+        result.dispatch.state,
+        result.dispatch.revision,
+    ]);
+    if (result.dispatch.state !== "failed" ||
+        result.dispatch.failure === undefined) {
+        return `${header}\n`;
+    }
+    return `${header}\n${result.dispatch.failure.code}\t${result.dispatch.failure.platform}\n`;
+};
+const formatFailedDispatchLine = (dispatch) => dispatch.state === "failed" && dispatch.failure !== undefined
+    ? `${dispatch.failure.code}\t${dispatch.failure.platform}\n`
+    : "";
+const formatMailboxLines = (mailboxes) => `${mailboxes.map((mailbox) => `${mailbox.owner.kind}\t${mailbox.id}\t${mailbox.revision}`).join("\n")}\n`;
+const formatQuestionLines = (question) => {
+    if (question === undefined)
+        return "";
+    const lines = [
+        `${question.id}\t${question.state}\t${question.revision}`,
+        cell(question.subject),
+        cell(question.body),
+    ];
+    if (question.state === "answered" && question.answer !== undefined) {
+        lines.push(cell(question.answer));
+    }
+    return `${lines.join("\n")}\n`;
+};
+const formatDeliveryLine = (delivery) => delivery === undefined
+    ? ""
+    : `${delivery.deliveryId}\t${delivery.sequence}\t${delivery.type}\t${cell(delivery.subject)}\n`;
+const formatCompactAggregateBody = (aggregate, delivery) => `${formatFailedDispatchLine(aggregate.dispatch)}${formatMailboxLines(aggregate.mailboxes)}${formatQuestionLines(aggregate.question)}${formatDeliveryLine(delivery)}`;
+export const formatRunShow = (result) => `${tab([
+    result.command,
+    result.aggregate.run.id,
+    result.aggregate.run.state,
+    result.aggregate.run.revision,
+    result.aggregate.dispatch.id,
+    result.aggregate.dispatch.state,
+    result.aggregate.dispatch.revision,
+])}\n${formatCompactAggregateBody(result.aggregate)}`;
+export const formatRunCreate = (result) => `${tab([
+    result.command,
+    result.delivery,
+    result.receipt.commandId,
+    result.aggregate.run.id,
+    result.aggregate.run.revision,
+    result.aggregate.dispatch.id,
+    result.aggregate.dispatch.revision,
+])}\n${formatCompactAggregateBody(result.aggregate, result.initialDelivery)}`;
+const formatQuestionMutation = (result) => `${tab([
+    result.command,
+    result.receipt.commandId,
+    result.aggregate.run.id,
+    result.aggregate.question?.id ?? "",
+    result.aggregate.question?.revision ?? "",
+    result.aggregate.run.revision,
+    result.aggregate.dispatch.revision,
+])}\n${formatCompactAggregateBody(result.aggregate, result.delivery)}`;
+export const formatQuestionOpen = (result) => formatQuestionMutation(result);
+const formatQuestionReply = (result) => formatQuestionMutation(result);
+export const formatQuestionCancel = (result) => `${tab([
+    result.command,
+    result.receipt.commandId,
+    result.aggregate.run.id,
+    result.aggregate.run.revision,
+    result.aggregate.dispatch.revision,
+])}\n${formatCompactAggregateBody(result.aggregate)}`;
+const formatDispatchSettle = (result) => `${tab([
+    result.command,
+    result.receipt.commandId,
+    result.aggregate.run.id,
+    result.aggregate.dispatch.state,
+    result.aggregate.run.revision,
+    result.aggregate.dispatch.revision,
+])}\n${formatCompactAggregateBody(result.aggregate, result.delivery)}`;
+export const formatCompactOrchestration = (result) => {
+    if (result.command === "run.inbox.ack")
+        return formatInboxAck(result);
+    if (result.command === "run.inbox.check")
+        return formatInboxCheck(result);
+    if (result.command === "run.task.list")
+        return formatTaskList(result);
+    if (result.command === "run.task.show")
+        return formatTaskShow(result);
+    if (result.command === "run.dispatch.show")
+        return formatDispatchShow(result);
+    if (result.command === "run.show")
+        return formatRunShow(result);
+    if (result.command === "run.create")
+        return formatRunCreate(result);
+    if (result.command === "run.question.open")
+        return formatQuestionOpen(result);
+    if (result.command === "run.question.reply") {
+        return formatQuestionReply(result);
+    }
+    if (result.command === "run.question.cancel") {
+        return formatQuestionCancel(result);
+    }
+    if (result.command === "run.dispatch.settle-terminal") {
+        return formatDispatchSettle(result);
+    }
+    return formatRunList(result);
+};
+const projectInboxCheckItem = (delivery) => ({
+    body: delivery.message.body,
+    deliveryId: delivery.id,
+    mailboxId: delivery.mailboxId,
+    sequence: delivery.sequence,
+    subject: delivery.message.subject,
+    type: delivery.message.type,
+});
+const projectedResultWriter = (project) => (result, context) => writeNodeResult(result, context, {
+    toResult: project,
+    toText: formatCompactOrchestration,
+});
+export const writeInboxAckResult = projectedResultWriter(projectInboxAckResult);
+export const writeInboxCheckResult = (result, context) => writeNodeResult(result, context, {
+    toResult: (value) => ({
+        command: "run.inbox.check",
+        count: value.items.length,
+        items: value.items.map(projectInboxCheckItem),
+        mailboxId: value.mailbox.id,
+        mailboxRevision: value.mailbox.revision,
+        owner: {
+            id: value.mailbox.owner.id,
+            kind: value.mailbox.owner.kind,
+        },
+        runId: value.mailbox.runId,
+    }),
+    toText: formatCompactOrchestration,
+});
+const projectTaskListItem = (task) => ({
+    clientKey: task.clientKey,
+    dependencyTaskIds: task.dependencyTaskIds,
+    id: task.id,
+    revision: task.revision,
+    state: task.state,
+});
+export const writeRunListResult = (result, context, workspaceId) => writeNodeResult(result, context, {
+    toResult: (value) => projectRunListResult(value, workspaceId),
+    toText: formatCompactOrchestration,
+});
+export const writeTaskListResult = (result, context) => writeNodeResult(result, context, {
+    toResult: (value) => ({
+        command: "run.task.list",
+        count: value.items.length,
+        items: value.items.map(projectTaskListItem),
+        ...(value.nextCursor === undefined
+            ? {}
+            : { nextCursor: value.nextCursor }),
+        runId: value.runId,
+    }),
+    toText: formatCompactOrchestration,
+});
+const projectTaskShowTask = (task) => ({
+    clientKey: task.clientKey,
+    dependencyTaskIds: task.dependencyTaskIds,
+    id: task.id,
+    objective: task.objective,
+    revision: task.revision,
+    runId: task.runId,
+    state: task.state,
+});
+export const writeTaskShowResult = (result, context) => writeNodeResult(result, context, {
+    toResult: (value) => ({
+        command: "run.task.show",
+        task: projectTaskShowTask(value.task),
+    }),
+    toText: formatCompactOrchestration,
+});
+export const writeDispatchShowResult = (result, context) => writeNodeResult(result, context, {
+    toResult: (value) => ({
+        command: "run.dispatch.show",
+        dispatch: projectDispatchShowDispatch(value.dispatch),
+    }),
+    toText: formatCompactOrchestration,
+});
+export const writeRunShowResult = projectedResultWriter(projectRunShowResult);
+export const writeRunCreateResult = projectedResultWriter(projectRunCreateResult);
+export const writeQuestionOpenResult = projectedResultWriter(projectQuestionOpenResult);
+export const writeQuestionReplyResult = projectedResultWriter(projectQuestionReplyResult);
+export const writeQuestionCancelResult = projectedResultWriter(projectQuestionCancelResult);
+export const writeDispatchSettleResult = projectedResultWriter(projectDispatchSettleResult);
+//# sourceMappingURL=human.js.map

package/dist/orchestration/output/index.d.ts

@@ -0,0 +1,4 @@
+export { type CliCompactDelivery, type CliCompactQuestion, type CliDispatchSettleResult, type CliDispatchShowDispatch, type CliInboxAckResult, type CliQuestionCancelResult, type CliQuestionOpenResult, type CliQuestionReplyResult, type CliRunCreateResult, type CliRunShowResult, projectDispatchSettleResult, projectDispatchShowDispatch, projectInboxAckResult, projectQuestionCancelResult, projectQuestionOpenResult, projectQuestionReplyResult, projectRunCreateResult, projectRunShowResult, } from "./compact-aggregate.js";
+export { type CliRunListResult, projectRunListResult, } from "./compact-run-list.js";
+export { type CliOrchestrationResult, formatCompactOrchestration, formatInboxAck, formatQuestionCancel, formatQuestionOpen, formatRunCreate, formatRunList, formatRunShow, writeDispatchSettleResult, writeDispatchShowResult, writeInboxAckResult, writeInboxCheckResult, writeQuestionCancelResult, writeQuestionOpenResult, writeQuestionReplyResult, writeRunCreateResult, writeRunListResult, writeRunShowResult, writeTaskListResult, writeTaskShowResult, } from "./human.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/orchestration/output/index.js

@@ -0,0 +1,4 @@
+export { projectDispatchSettleResult, projectDispatchShowDispatch, projectInboxAckResult, projectQuestionCancelResult, projectQuestionOpenResult, projectQuestionReplyResult, projectRunCreateResult, projectRunShowResult, } from "./compact-aggregate.js";
+export { projectRunListResult, } from "./compact-run-list.js";
+export { formatCompactOrchestration, formatInboxAck, formatQuestionCancel, formatQuestionOpen, formatRunCreate, formatRunList, formatRunShow, writeDispatchSettleResult, writeDispatchShowResult, writeInboxAckResult, writeInboxCheckResult, writeQuestionCancelResult, writeQuestionOpenResult, writeQuestionReplyResult, writeRunCreateResult, writeRunListResult, writeRunShowResult, writeTaskListResult, writeTaskShowResult, } from "./human.js";
+//# sourceMappingURL=index.js.map

package/dist/orchestration/tree/index.d.ts

@@ -0,0 +1,2 @@
+export { RUN_TREE } from "./tree.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/orchestration/tree/index.js

@@ -0,0 +1,2 @@
+export { RUN_TREE } from "./tree.js";
+//# sourceMappingURL=index.js.map

package/dist/orchestration/tree/tree.d.ts

@@ -0,0 +1,3 @@
+import type { TreeFragment } from "../../command-tree/index.js";
+export declare const RUN_TREE: TreeFragment;
+//# sourceMappingURL=tree.d.ts.map

package/dist/orchestration/tree/tree.js

@@ -0,0 +1,142 @@
+const run = () => import("../index.js");
+const ledger = () => import("../../run-ledger/index.js");
+export const RUN_TREE = {
+    groups: [
+        ["run", "Orchestration runs and the durable Run ledger."],
+        ["run task", "A run's tasks."],
+        ["run inbox", "Run and dispatch inboxes."],
+        ["run question", "Questions on a dispatch."],
+        ["run dispatch", "A run's dispatch."],
+        ["run ledger", "The durable Run ledger."],
+        ["run ledger task", "Ledger tasks."],
+    ],
+    leaves: [
+        [
+            "run create --workspace <workspace-id> --terminal <terminal-id> --graph-stdin [--command-id <id>]",
+            1,
+            "run.create",
+            "Create an orchestration run from a task graph.",
+            { run: [run, "runCreate"] },
+        ],
+        [
+            "run list --workspace <workspace-id> [--limit <1..100>] [--after <cursor>]",
+            1,
+            "run.list",
+            "List a Workspace's runs.",
+            { run: [run, "runList"] },
+        ],
+        [
+            "run show <run-id>",
+            1,
+            "run.show",
+            "Show one run.",
+            { run: [run, "runShow"] },
+        ],
+        [
+            "run task list --run <run-id> [--limit <1..32>] [--after <cursor>]",
+            1,
+            "run.task.list",
+            "List a run's tasks.",
+            { run: [run, "runTaskList"] },
+        ],
+        [
+            "run task show <task-id> --run <run-id>",
+            1,
+            "run.task.show",
+            "Show one run task.",
+            { run: [run, "runTaskShow"] },
+        ],
+        [
+            "run inbox check --run <run-id> --owner <run|dispatch> --owner-id <id> --coordinator-epoch 1 [--limit <1..16>]",
+            1,
+            "run.inbox.check",
+            "Check a run or dispatch inbox.",
+            { run: [run, "runInboxCheck"] },
+        ],
+        [
+            "run inbox ack <delivery-id> --run <run-id> --owner <run|dispatch> --owner-id <id> --expected-mailbox-revision <revision> --coordinator-epoch 1 [--command-id <id>]",
+            1,
+            "run.inbox.ack",
+            "Acknowledge one inbox delivery.",
+            { run: [run, "runInboxAck"] },
+        ],
+        [
+            "run question open --run <run-id> --dispatch <dispatch-id> --subject <text> --body-stdin --expected-run-revision <revision> --expected-dispatch-revision <revision> --coordinator-epoch 1 [--command-id <id>]",
+            1,
+            "run.question.open",
+            "Open a question on a dispatch.",
+            { run: [run, "runQuestionOpen"] },
+        ],
+        [
+            "run question reply <question-id> --run <run-id> --dispatch <dispatch-id> --answer-stdin --expected-run-revision <revision> --expected-dispatch-revision <revision> --expected-question-revision <revision> --coordinator-epoch 1 [--command-id <id>]",
+            1,
+            "run.question.reply",
+            "Reply to a dispatch question.",
+            { run: [run, "runQuestionReply"] },
+        ],
+        [
+            "run question cancel <question-id> --run <run-id> --dispatch <dispatch-id> --expected-run-revision <revision> --expected-dispatch-revision <revision> --expected-question-revision <revision> --coordinator-epoch 1 [--command-id <id>]",
+            1,
+            "run.question.cancel",
+            "Cancel a dispatch question.",
+            { run: [run, "runQuestionCancel"] },
+        ],
+        [
+            "run dispatch show --run <run-id>",
+            1,
+            "run.dispatch.show",
+            "Show a run's dispatch.",
+            { run: [run, "runDispatchShow"] },
+        ],
+        [
+            "run dispatch settle-terminal <dispatch-id> --run <run-id> --expected-run-revision <revision> --expected-dispatch-revision <revision> --coordinator-epoch 1 [--command-id <id>]",
+            1,
+            "run.dispatch.settle-terminal",
+            "Settle a dispatch whose terminal ended.",
+            { run: [run, "runDispatchSettleTerminal"] },
+        ],
+        [
+            "run ledger create --workspace <workspace-id> --graph-stdin [--command-id <id>]",
+            1,
+            "run.ledger.create",
+            "Create a ledger run from a task graph.",
+            { run: [ledger, "runLedgerCreate"] },
+        ],
+        [
+            "run ledger list --workspace <workspace-id> [--limit <1..100>] [--after <cursor>]",
+            1,
+            "run.ledger.list",
+            "List a Workspace's ledger runs.",
+            { run: [ledger, "runLedgerList"] },
+        ],
+        [
+            "run ledger task list --run <run-id> [--ready]",
+            1,
+            "run.ledger.task.list",
+            "List a ledger run's tasks.",
+            { run: [ledger, "runLedgerTaskList"] },
+        ],
+        [
+            "run ledger task show <task-id> --run <run-id>",
+            1,
+            "run.ledger.task.show",
+            "Show one ledger task.",
+            { run: [ledger, "runLedgerTaskShow"] },
+        ],
+        [
+            "run ledger task dispatch <task-id> --run <run-id> --session <session-id> --expected-task-revision <revision> --expected-session-revision <revision> [--command-id <id>]",
+            1,
+            "run.ledger.task.dispatch",
+            "Dispatch a ledger task to a Session.",
+            { run: [ledger, "runLedgerTaskDispatch"] },
+        ],
+        [
+            "run ledger task settle <task-id> --run <run-id> --session <session-id> --outcome <succeeded|failed> --expected-task-revision <revision> --evidence-stdin [--turn <turn-id>] [--command-id <id>]",
+            1,
+            "run.ledger.task.settle",
+            "Settle a ledger task with evidence.",
+            { run: [ledger, "runLedgerTaskSettle"] },
+        ],
+    ],
+};
+//# sourceMappingURL=tree.js.map

package/dist/port-lease/client.d.ts

@@ -0,0 +1,160 @@
+import { type PortLeaseAcquireParameters, type PortLeaseListParameters, type PortLeaseReleaseParameters, type PortLeaseRenewParameters } from "@maiaos/sdk";
+import type { CliNodeOperations } from "../local-node/index.js";
+export declare const makePortLeaseClient: (node: CliNodeOperations) => {
+    acquirePortLease: (input: PortLeaseAcquireParameters) => import("../local-node/client.js").CliNodeEffect<{
+        readonly commandId: string;
+        readonly delivery: "duplicate" | "new";
+        readonly lease: {
+            readonly endReason?: "owner_missing" | "owner_released" | "session_ended" | "ttl_expired" | undefined;
+            readonly expiresAt: string;
+            readonly grantedAt: string;
+            readonly leaseId: string;
+            readonly owner: {
+                readonly kind: "session";
+                readonly sessionId: string;
+            } | {
+                readonly kind: "principal";
+                readonly principalId: string;
+            };
+            readonly ports: readonly number[];
+            readonly purpose: string;
+            readonly revision: string;
+            readonly schemaVersion: "maia.port-lease/v1";
+            readonly state: "active" | "expired" | "released";
+            readonly updatedAt: string;
+        };
+        readonly receipt: {
+            readonly actorId: string;
+            readonly aggregateRevision: string;
+            readonly commandId: string;
+            readonly createdAt: string;
+            readonly eventCursor: string;
+            readonly method: string;
+            readonly receiptId: string;
+            readonly schemaVersion: 1;
+            readonly state: "succeeded";
+            readonly target: {
+                readonly id: string;
+                readonly type: string;
+            };
+            readonly updatedAt: string;
+        };
+        readonly method: "port.lease.acquire";
+    }>;
+    releasePortLease: (input: PortLeaseReleaseParameters) => import("../local-node/client.js").CliNodeEffect<{
+        readonly commandId: string;
+        readonly delivery: "duplicate" | "new";
+        readonly lease: {
+            readonly endReason?: "owner_missing" | "owner_released" | "session_ended" | "ttl_expired" | undefined;
+            readonly expiresAt: string;
+            readonly grantedAt: string;
+            readonly leaseId: string;
+            readonly owner: {
+                readonly kind: "session";
+                readonly sessionId: string;
+            } | {
+                readonly kind: "principal";
+                readonly principalId: string;
+            };
+            readonly ports: readonly number[];
+            readonly purpose: string;
+            readonly revision: string;
+            readonly schemaVersion: "maia.port-lease/v1";
+            readonly state: "active" | "expired" | "released";
+            readonly updatedAt: string;
+        };
+        readonly receipt: {
+            readonly actorId: string;
+            readonly aggregateRevision: string;
+            readonly commandId: string;
+            readonly createdAt: string;
+            readonly eventCursor: string;
+            readonly method: string;
+            readonly receiptId: string;
+            readonly schemaVersion: 1;
+            readonly state: "succeeded";
+            readonly target: {
+                readonly id: string;
+                readonly type: string;
+            };
+            readonly updatedAt: string;
+        };
+        readonly method: "port.lease.release";
+    }>;
+    renewPortLease: (input: PortLeaseRenewParameters) => import("../local-node/client.js").CliNodeEffect<{
+        readonly commandId: string;
+        readonly delivery: "duplicate" | "new";
+        readonly lease: {
+            readonly endReason?: "owner_missing" | "owner_released" | "session_ended" | "ttl_expired" | undefined;
+            readonly expiresAt: string;
+            readonly grantedAt: string;
+            readonly leaseId: string;
+            readonly owner: {
+                readonly kind: "session";
+                readonly sessionId: string;
+            } | {
+                readonly kind: "principal";
+                readonly principalId: string;
+            };
+            readonly ports: readonly number[];
+            readonly purpose: string;
+            readonly revision: string;
+            readonly schemaVersion: "maia.port-lease/v1";
+            readonly state: "active" | "expired" | "released";
+            readonly updatedAt: string;
+        };
+        readonly receipt: {
+            readonly actorId: string;
+            readonly aggregateRevision: string;
+            readonly commandId: string;
+            readonly createdAt: string;
+            readonly eventCursor: string;
+            readonly method: string;
+            readonly receiptId: string;
+            readonly schemaVersion: 1;
+            readonly state: "succeeded";
+            readonly target: {
+                readonly id: string;
+                readonly type: string;
+            };
+            readonly updatedAt: string;
+        };
+        readonly expectedRevision: string;
+        readonly method: "port.lease.renew";
+    }>;
+    listPortLeases: (input: PortLeaseListParameters) => import("../local-node/client.js").CliNodeEffect<{
+        readonly items: readonly {
+            readonly lease: {
+                readonly endReason?: "owner_missing" | "owner_released" | "session_ended" | "ttl_expired" | undefined;
+                readonly expiresAt: string;
+                readonly grantedAt: string;
+                readonly leaseId: string;
+                readonly owner: {
+                    readonly kind: "session";
+                    readonly sessionId: string;
+                } | {
+                    readonly kind: "principal";
+                    readonly principalId: string;
+                };
+                readonly ports: readonly number[];
+                readonly purpose: string;
+                readonly revision: string;
+                readonly schemaVersion: "maia.port-lease/v1";
+                readonly state: "active" | "expired" | "released";
+                readonly updatedAt: string;
+            };
+            readonly probes: readonly {
+                readonly inUse: boolean;
+                readonly port: number;
+            }[];
+        }[];
+        readonly method: "port.lease.list";
+        readonly nextCursor?: string | undefined;
+        readonly range: {
+            readonly end: number;
+            readonly start: number;
+        };
+    }>;
+};
+export type PortLeaseCliDependencies = ReturnType<typeof makePortLeaseClient>;
+//# sourceMappingURL=client.d.ts.map

package/dist/port-lease/client.js

@@ -0,0 +1,11 @@
+import { portLeaseAcquireParametersSchema, portLeaseListParametersSchema, portLeaseReleaseParametersSchema, portLeaseRenewParametersSchema, } from "@maiaos/sdk";
+const mutationClient = (node) => ({
+    acquirePortLease: (input) => node.runValidatedNodeOperation(input, portLeaseAcquireParametersSchema, (client, parameters, options) => client.acquirePortLease(parameters, options), { commandId: input.commandId }),
+    releasePortLease: (input) => node.runValidatedNodeOperation(input, portLeaseReleaseParametersSchema, (client, parameters, options) => client.releasePortLease(parameters, options), { commandId: input.commandId }),
+    renewPortLease: (input) => node.runValidatedNodeOperation(input, portLeaseRenewParametersSchema, (client, parameters, options) => client.renewPortLease(parameters, options), { commandId: input.commandId }),
+});
+export const makePortLeaseClient = (node) => ({
+    ...mutationClient(node),
+    listPortLeases: (input) => node.runValidatedNodeOperation(input, portLeaseListParametersSchema, (client, parameters, options) => client.listPortLeases(parameters, options)),
+});
+//# sourceMappingURL=client.js.map

package/dist/port-lease/commands.d.ts

@@ -0,0 +1,6 @@
+import { type CommandContext, type CommandEffect } from "../command-line/index.js";
+export declare const runPortLeaseAcquire: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runPortLeaseList: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runPortLeaseRelease: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runPortLeaseRenew: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+//# sourceMappingURL=commands.d.ts.map

package/dist/port-lease/commands.js

@@ -0,0 +1,17 @@
+import * as Effect from "effect/Effect";
+import { writeNodeResult, } from "../command-line/index.js";
+import { readPortLease, readPortList, readPortRelease, readPortRenew, } from "./input.js";
+import { formatPortLeaseResult, } from "./output/index.js";
+const run = (operation, input, context) => {
+    if (operation === undefined)
+        return Effect.die(new Error("Missing port lease client."));
+    return input.pipe(Effect.flatMap(operation), Effect.map((result) => writeNodeResult(result, context, {
+        toResult: (value) => ({ command: value.method, result: value }),
+        toText: formatPortLeaseResult,
+    })));
+};
+export const runPortLeaseAcquire = (tokens, context) => run(context.dependencies.acquirePortLease, readPortLease(tokens), context);
+export const runPortLeaseList = (tokens, context) => run(context.dependencies.listPortLeases, readPortList(tokens), context);
+export const runPortLeaseRelease = (tokens, context) => run(context.dependencies.releasePortLease, readPortRelease(tokens), context);
+export const runPortLeaseRenew = (tokens, context) => run(context.dependencies.renewPortLease, readPortRenew(tokens), context);
+//# sourceMappingURL=commands.js.map

package/dist/port-lease/index.d.ts

@@ -0,0 +1,3 @@
+export { makePortLeaseClient, type PortLeaseCliDependencies, } from "./client.js";
+export { runPortLeaseAcquire, runPortLeaseList, runPortLeaseRelease, runPortLeaseRenew, } from "./commands.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/port-lease/index.js

@@ -0,0 +1,3 @@
+export { makePortLeaseClient, } from "./client.js";
+export { runPortLeaseAcquire, runPortLeaseList, runPortLeaseRelease, runPortLeaseRenew, } from "./commands.js";
+//# sourceMappingURL=index.js.map