@maiaos/cli 0.1.0-canary.2

package/dist/status/client.d.ts

@@ -0,0 +1,119 @@
+import type { MonitorBootstrapCreateResult } from "@maiaos/sdk";
+import type { CliNodeEffect, CliNodeOperations } from "../local-node/index.js";
+export declare const makeStatusClient: (node: CliNodeOperations) => {
+    createMonitorBootstrap: () => CliNodeEffect<MonitorBootstrapCreateResult>;
+    readStatus: () => import("effect/Effect").Effect<{
+        readonly instanceId: string;
+        readonly lifecycle: "draining" | "failed" | "ready" | "starting" | "stopped";
+        readonly pid: number;
+        readonly profile: string;
+        readonly startedAt: string;
+        readonly method: "node.status";
+        readonly processResources: {
+            readonly activeTrees: number;
+            readonly admission: {
+                readonly availableTrees: number;
+                readonly capacity: number;
+                readonly queuedSpawns: 0;
+                readonly state: "available" | "degraded" | "pressured" | "saturated" | "unavailable";
+                readonly usedTrees: number;
+            };
+            readonly capability: {
+                readonly hardLimitEnforcement: "enforced";
+                readonly metricSampling: "host_sampled";
+                readonly mode: "hard_containment";
+                readonly observedPressureTermination: "disabled";
+                readonly releaseQualified: false;
+                readonly sourceCandidate: true;
+            } | {
+                readonly hardLimitEnforcement: "unavailable";
+                readonly metricSampling: "host_sampled";
+                readonly mode: "macos_cooperative";
+                readonly observedPressureTermination: "disabled";
+                readonly releaseQualified: false;
+                readonly sourceCandidate: true;
+            } | {
+                readonly hardLimitEnforcement: "unavailable";
+                readonly metricSampling: "unavailable";
+                readonly mode: "unavailable";
+                readonly observedPressureTermination: "disabled";
+                readonly releaseQualified: false;
+                readonly sourceCandidate: false;
+            };
+            readonly cleanupUnknownTrees: number;
+            readonly fencedTrees: number;
+            readonly nextStep: "close_idle_terminal" | "inspect_cleanup_unknown" | "inspect_observed_pressure" | "none" | "verify_native_host";
+            readonly observations: {
+                readonly cpuTimeMilliseconds: {
+                    readonly availableTrees: number;
+                    readonly budget: "declared_per_tree_limit" | "unavailable_not_declared";
+                    readonly maximumValue?: number | undefined;
+                    readonly state: "available" | "partial" | "unavailable";
+                    readonly unavailableTrees: number;
+                    readonly warningTrees: number;
+                };
+                readonly fileDescriptorCount: {
+                    readonly availableTrees: number;
+                    readonly budget: "declared_per_tree_limit" | "unavailable_not_declared";
+                    readonly maximumValue?: number | undefined;
+                    readonly state: "available" | "partial" | "unavailable";
+                    readonly unavailableTrees: number;
+                    readonly warningTrees: number;
+                };
+                readonly ioReadBytes: {
+                    readonly availableTrees: number;
+                    readonly budget: "declared_per_tree_limit" | "unavailable_not_declared";
+                    readonly maximumValue?: number | undefined;
+                    readonly state: "available" | "partial" | "unavailable";
+                    readonly unavailableTrees: number;
+                    readonly warningTrees: number;
+                };
+                readonly ioWriteBytes: {
+                    readonly availableTrees: number;
+                    readonly budget: "declared_per_tree_limit" | "unavailable_not_declared";
+                    readonly maximumValue?: number | undefined;
+                    readonly state: "available" | "partial" | "unavailable";
+                    readonly unavailableTrees: number;
+                    readonly warningTrees: number;
+                };
+                readonly observedPeakRssBytes: {
+                    readonly availableTrees: number;
+                    readonly budget: "declared_per_tree_limit" | "unavailable_not_declared";
+                    readonly maximumValue?: number | undefined;
+                    readonly state: "available" | "partial" | "unavailable";
+                    readonly unavailableTrees: number;
+                    readonly warningTrees: number;
+                };
+                readonly processCount: {
+                    readonly availableTrees: number;
+                    readonly budget: "declared_per_tree_limit" | "unavailable_not_declared";
+                    readonly maximumValue?: number | undefined;
+                    readonly state: "available" | "partial" | "unavailable";
+                    readonly unavailableTrees: number;
+                    readonly warningTrees: number;
+                };
+                readonly rssBytes: {
+                    readonly availableTrees: number;
+                    readonly budget: "declared_per_tree_limit" | "unavailable_not_declared";
+                    readonly maximumValue?: number | undefined;
+                    readonly state: "available" | "partial" | "unavailable";
+                    readonly unavailableTrees: number;
+                    readonly warningTrees: number;
+                };
+                readonly treeCount: number;
+            };
+            readonly pressure: "admission_degraded" | "cleanup_unknown" | "healthy" | "observed_pressure" | "warning";
+            readonly supervision: {
+                readonly trackedTrees: number;
+                readonly watcherFibers: number;
+            };
+        };
+        readonly storage: {
+            readonly integrity: "ok";
+            readonly journalMode: "wal";
+            readonly schemaTag: string;
+            readonly schemaVersion: number;
+        };
+    }, unknown, import("effect/Crypto").Crypto>;
+};
+//# sourceMappingURL=client.d.ts.map

package/dist/status/client.js

@@ -0,0 +1,5 @@
+export const makeStatusClient = (node) => ({
+    createMonitorBootstrap: () => node.runNodeClientOperation((client, options) => client.createMonitorBootstrap(options)),
+    readStatus: () => node.readStatus,
+});
+//# sourceMappingURL=client.js.map

package/dist/status/command.d.ts

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

package/dist/status/command.js

@@ -0,0 +1,40 @@
+import { protocolErrorSchema } from "@maiaos/sdk";
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Predicate from "effect/Predicate";
+import { reportError, requireNoArguments, writeNodeResult, writeSuccess, } from "../command-line/index.js";
+import { formatHumanStatus, projectStatusResult } from "./output/index.js";
+const createUnavailableError = () => ({
+    code: "node_unavailable",
+    message: "The local Maia node is unavailable: start it with 'maia-node --desktop', or 'pnpm dev:node' in a dev worktree, then retry.",
+    retryable: true,
+});
+const unavailableError = (cause) => {
+    const error = Cause.squash(cause);
+    const remote = Predicate.hasProperty(error, "remoteError")
+        ? protocolErrorSchema.safeParse(error.remoteError)
+        : undefined;
+    return remote?.success === true && remote.data.code === "node_unavailable"
+        ? remote.data
+        : createUnavailableError();
+};
+export const runNodeStatus = (tokens, context) => Effect.suspend(() => {
+    requireNoArguments(tokens, "Status");
+    return context.dependencies.readStatus();
+}).pipe(Effect.flatMap((node) => Effect.sync(() => {
+    writeSuccess(projectStatusResult(node), context, () => formatHumanStatus({ command: "status", node }));
+    return 0;
+})), Effect.catchCause((cause) => Cause.hasInterruptsOnly(cause)
+    ? Effect.interrupt
+    : Effect.sync(() => reportError(unavailableError(cause), context))));
+export const runNodeMonitor = (tokens, context) => {
+    requireNoArguments(tokens, "Monitor");
+    const create = context.dependencies.createMonitorBootstrap;
+    return create === undefined
+        ? Effect.die(new Error("No monitor."))
+        : Effect.map(create(), (result) => writeNodeResult(result, context, {
+            toResult: (value) => ({ command: "monitor", result: value }),
+            toText: ({ result: value }) => `${value.url}\n`,
+        }));
+};
+//# sourceMappingURL=command.js.map

package/dist/status/doctor.d.ts

@@ -0,0 +1,15 @@
+import { type CommandContext, type CommandEffect } from "../command-line/index.js";
+export type DoctorCheck = {
+    readonly code: string;
+    readonly detail?: string;
+    readonly next?: string;
+    readonly ok: boolean;
+};
+export type CliDoctorResult = {
+    readonly checks: readonly DoctorCheck[];
+    readonly command: "doctor";
+    readonly ok: boolean;
+    readonly version: string;
+};
+export declare const runDoctor: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+//# sourceMappingURL=doctor.d.ts.map

package/dist/status/doctor.js

@@ -0,0 +1,111 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { requireNoArguments, writeSuccess, } from "../command-line/index.js";
+const EXIT_FAILED = 70;
+const vendorWords = (executor) => executor === "codex-cli"
+    ? { integration: "codex", login: "codex" }
+    : { integration: "claude-code", login: "claude" };
+const answer = (effect) => effect === undefined
+    ? Effect.undefined
+    : Effect.map(Effect.orElseSucceed(effect, () => ({ ok: false })), (result) => (result.ok ? result.value : undefined));
+const hasAccount = (item, connections) => item.connection?.state === "enabled" ||
+    (connections?.items ?? []).some((connection) => connection.executor === item.executor && connection.state === "enabled");
+const workerPromptChecks = (item, version) => {
+    const code = `${item.executor}.worker-prompt`;
+    switch (item.workerPrompt) {
+        case undefined:
+            return [];
+        case "ok":
+            return [{ code, ok: true }];
+        case "inconclusive":
+            return [{ code, detail: "probe inconclusive", ok: true }];
+        case "failed":
+            return [
+                {
+                    code,
+                    detail: `skills.* keys no longer honored by ${version === undefined ? "this Codex" : `Codex ${version}`}`,
+                    next: "update Maia",
+                    ok: false,
+                },
+            ];
+    }
+};
+const vendorChecks = (item, connections) => {
+    const { integration, login } = vendorWords(item.executor);
+    if (!item.binary.found)
+        return [{ code: item.executor, detail: "not installed", ok: true }];
+    return [
+        {
+            code: `${item.executor}.account`,
+            next: `maia setup, or maia login ${login}`,
+            ok: hasAccount(item, connections),
+        },
+        {
+            code: `${item.executor}.executable`,
+            next: `maia integration plan ${integration}`,
+            ok: item.executableApproved,
+        },
+        ...workerPromptChecks(item, item.binary.version),
+    ].map((check) => check.ok && check.detail === undefined
+        ? { code: check.code, ok: true }
+        : check);
+};
+const nodeChecks = (detected, connections) => {
+    if (detected === undefined)
+        return [{ code: "vendors", next: "maia connection detect", ok: false }];
+    const checks = detected.executors.flatMap((item) => vendorChecks(item, connections));
+    const usable = detected.executors.some((item) => item.binary.found &&
+        item.executableApproved &&
+        hasAccount(item, connections));
+    return [
+        ...checks,
+        ...(usable
+            ? []
+            : [
+                {
+                    code: "worker",
+                    detail: "no Claude Code or Codex worker is ready",
+                    next: "install Claude Code or Codex, then maia setup",
+                    ok: false,
+                },
+            ]),
+    ];
+};
+const formatDoctor = (result) => `Maia doctor ${result.ok ? "ok" : "failed"}\n${result.checks
+    .map((check) => `  ${check.code}: ${check.ok ? "ok" : "failed"}${check.detail === undefined ? "" : ` (${check.detail})`}${check.ok || check.next === undefined ? "" : `; next: ${check.next}`}\n`)
+    .join("")}`;
+const readLifecycle = (dependencies) => Effect.map(Effect.option(Effect.map(Effect.suspend(() => dependencies.readStatus()), (node) => node.lifecycle)), Option.getOrUndefined);
+const nodeCheck = (lifecycle) => lifecycle === undefined
+    ? {
+        code: "node",
+        next: "maia-node --desktop, or pnpm dev:node in a dev worktree",
+        ok: false,
+    }
+    : { code: "node", detail: lifecycle, ok: true };
+const readChecks = (context) => Effect.gen(function* () {
+    const { dependencies, version } = context;
+    const lifecycle = yield* readLifecycle(dependencies);
+    const base = [
+        { code: "cli", detail: version, ok: true },
+        nodeCheck(lifecycle),
+    ];
+    if (lifecycle === undefined)
+        return base;
+    const detected = yield* answer(dependencies.detectConnections?.({}));
+    const connections = yield* answer(dependencies.listConnections?.({ limit: 100 }));
+    return [...base, ...nodeChecks(detected, connections)];
+});
+export const runDoctor = (tokens, context) => Effect.gen(function* () {
+    requireNoArguments(tokens, "Doctor");
+    const checks = yield* readChecks(context);
+    const ok = checks.every((check) => check.ok);
+    const result = {
+        checks,
+        command: "doctor",
+        ok,
+        version: context.version,
+    };
+    writeSuccess(result, context, formatDoctor);
+    return ok ? 0 : EXIT_FAILED;
+});
+//# sourceMappingURL=doctor.js.map

package/dist/status/index.d.ts

@@ -0,0 +1,5 @@
+export { makeStatusClient } from "./client.js";
+export { runNodeMonitor, runNodeStatus } from "./command.js";
+export { type CliDoctorResult, type DoctorCheck, runDoctor } from "./doctor.js";
+export { type CliStatusResult } from "./output/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/status/index.js

@@ -0,0 +1,4 @@
+export { makeStatusClient } from "./client.js";
+export { runNodeMonitor, runNodeStatus } from "./command.js";
+export { runDoctor } from "./doctor.js";
+//# sourceMappingURL=index.js.map

package/dist/status/output/compact.d.ts

@@ -0,0 +1,31 @@
+import type { LocalNodeStatusResult } from "@maiaos/sdk";
+export declare const sumObservationWarningTrees: (observations: LocalNodeStatusResult["processResources"]["observations"]) => number;
+export type CliCompactStatusResult = {
+    readonly command: "status";
+    readonly instanceId: LocalNodeStatusResult["instanceId"];
+    readonly lifecycle: LocalNodeStatusResult["lifecycle"];
+    readonly pid: LocalNodeStatusResult["pid"];
+    readonly processResources: {
+        readonly admission: {
+            readonly capacity: LocalNodeStatusResult["processResources"]["admission"]["capacity"];
+            readonly state: LocalNodeStatusResult["processResources"]["admission"]["state"];
+            readonly usedTrees: LocalNodeStatusResult["processResources"]["admission"]["usedTrees"];
+        };
+        readonly capability: {
+            readonly hardLimitEnforcement: LocalNodeStatusResult["processResources"]["capability"]["hardLimitEnforcement"];
+            readonly mode: LocalNodeStatusResult["processResources"]["capability"]["mode"];
+            readonly releaseQualified: LocalNodeStatusResult["processResources"]["capability"]["releaseQualified"];
+        };
+        readonly nextStep: LocalNodeStatusResult["processResources"]["nextStep"];
+        readonly pressure: LocalNodeStatusResult["processResources"]["pressure"];
+        readonly warningTrees: number;
+    };
+    readonly profile: LocalNodeStatusResult["profile"];
+    readonly storage: {
+        readonly integrity: LocalNodeStatusResult["storage"]["integrity"];
+        readonly journalMode: LocalNodeStatusResult["storage"]["journalMode"];
+        readonly schemaVersion: LocalNodeStatusResult["storage"]["schemaVersion"];
+    };
+};
+export declare const projectStatusResult: (node: LocalNodeStatusResult) => CliCompactStatusResult;
+//# sourceMappingURL=compact.d.ts.map

package/dist/status/output/compact.js

@@ -0,0 +1,46 @@
+const observedMetricKeys = [
+    "cpuTimeMilliseconds",
+    "fileDescriptorCount",
+    "ioReadBytes",
+    "ioWriteBytes",
+    "observedPeakRssBytes",
+    "processCount",
+    "rssBytes",
+];
+const warningTreesFromMetric = (metric) => "warningTrees" in metric && typeof metric.warningTrees === "number"
+    ? metric.warningTrees
+    : undefined;
+export const sumObservationWarningTrees = (observations) => observedMetricKeys.reduce((total, key) => {
+    const warningTrees = warningTreesFromMetric(observations[key]);
+    return warningTrees === undefined ? total : total + warningTrees;
+}, 0);
+const projectStatusAdmission = (admission) => ({
+    capacity: admission.capacity,
+    state: admission.state,
+    usedTrees: admission.usedTrees,
+});
+const projectStatusCapability = (capability) => ({
+    hardLimitEnforcement: capability.hardLimitEnforcement,
+    mode: capability.mode,
+    releaseQualified: capability.releaseQualified,
+});
+export const projectStatusResult = (node) => ({
+    command: "status",
+    instanceId: node.instanceId,
+    lifecycle: node.lifecycle,
+    pid: node.pid,
+    processResources: {
+        admission: projectStatusAdmission(node.processResources.admission),
+        capability: projectStatusCapability(node.processResources.capability),
+        nextStep: node.processResources.nextStep,
+        pressure: node.processResources.pressure,
+        warningTrees: sumObservationWarningTrees(node.processResources.observations),
+    },
+    profile: node.profile,
+    storage: {
+        integrity: node.storage.integrity,
+        journalMode: node.storage.journalMode,
+        schemaVersion: node.storage.schemaVersion,
+    },
+});
+//# sourceMappingURL=compact.js.map

package/dist/status/output/human.d.ts

@@ -0,0 +1,7 @@
+import type { LocalNodeStatusResult } from "@maiaos/sdk";
+export type CliStatusResult = {
+    readonly command: "status";
+    readonly node: LocalNodeStatusResult;
+};
+export declare const formatHumanStatus: (result: CliStatusResult) => string;
+//# sourceMappingURL=human.d.ts.map

package/dist/status/output/human.js

@@ -0,0 +1,30 @@
+const processResourceNextStep = (nextStep) => {
+    switch (nextStep) {
+        case "close_idle_terminal":
+            return "close an idle Maia terminal, then retry";
+        case "inspect_cleanup_unknown":
+            return "inspect cleanup-unknown terminals and processes before restart";
+        case "inspect_observed_pressure":
+            return "inspect per-tree pressure warnings; termination stays disabled";
+        case "none":
+            return "none";
+        case "verify_native_host":
+            return "verify the native process host";
+    }
+};
+const formatObservedMetric = (label, metric) => `${label} ${metric.state}${metric.maximumValue === undefined ? "" : ` max ${String(metric.maximumValue)}`}; budget ${metric.budget}; ${String(metric.warningTrees)} warning`;
+export const formatHumanStatus = (result) => {
+    const { node } = result;
+    const resources = node.processResources;
+    const observed = resources.observations;
+    return `Maia node ${node.lifecycle}\n  profile: ${node.profile}\n  pid: ${String(node.pid)}\n  instance: ${node.instanceId}\n  storage: ${node.storage.integrity} (${node.storage.journalMode})\n  process resources: ${resources.pressure} (${resources.capability.mode}; hard limits ${resources.capability.hardLimitEnforcement}; release qualified ${String(resources.capability.releaseQualified)})\n  admission: ${resources.admission.state}; ${String(resources.admission.usedTrees)}/${String(resources.admission.capacity)} used; ${String(resources.admission.availableTrees)} available; ${String(resources.admission.queuedSpawns)} queued\n  ownership: ${String(resources.activeTrees)} active; ${String(resources.fencedTrees)} fenced; ${String(resources.cleanupUnknownTrees)} cleanup unknown; ${String(resources.supervision.watcherFibers)} watcher fibers\n  latest target observations: ${[
+        formatObservedMetric("cpu-ms", observed.cpuTimeMilliseconds),
+        formatObservedMetric("rss-bytes", observed.rssBytes),
+        formatObservedMetric("peak-rss-bytes", observed.observedPeakRssBytes),
+        formatObservedMetric("processes", observed.processCount),
+        formatObservedMetric("fds", observed.fileDescriptorCount),
+        formatObservedMetric("io-read-bytes", observed.ioReadBytes),
+        formatObservedMetric("io-write-bytes", observed.ioWriteBytes),
+    ].join("; ")}\n  observed-pressure termination: ${resources.capability.observedPressureTermination}; samples are advisory, not hard enforcement or automatic kill\n  inspect: --json compact; SDK lossless\n  next step: ${processResourceNextStep(resources.nextStep)}\n  get started: maia doctor checks accounts and integrations; maia setup uses the installed CLIs\n`;
+};
+//# sourceMappingURL=human.js.map

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

@@ -0,0 +1,3 @@
+export { type CliCompactStatusResult, projectStatusResult } from "./compact.js";
+export { type CliStatusResult, formatHumanStatus } from "./human.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/status/output/index.js

@@ -0,0 +1,3 @@
+export { projectStatusResult } from "./compact.js";
+export { formatHumanStatus } from "./human.js";
+//# sourceMappingURL=index.js.map

package/dist/terminal/arguments.d.ts

@@ -0,0 +1,13 @@
+import type { LiveTerminalCloseParameters } from "@maiaos/sdk";
+import { type ParsedOptions } from "../command-line/index.js";
+export declare const readTerminalColumns: (value: string | undefined, fallback?: number) => number;
+export declare const readTerminalRows: (value: string | undefined, fallback?: number) => number;
+export declare const readTerminalGeneration: (parsed: ParsedOptions) => number;
+export declare const readTerminalLeaseDuration: (parsed: ParsedOptions) => number;
+export declare const readTerminalInputSequence: (parsed: ParsedOptions) => number;
+export declare const readTerminalExpectedRevision: (parsed: ParsedOptions) => string;
+type TerminalControllerFenceInput = Omit<LiveTerminalCloseParameters, "commandId">;
+export declare const readTerminalControllerFence: (parsed: ParsedOptions, terminalId: string) => TerminalControllerFenceInput;
+export declare const terminalControllerFenceOptionNames: readonly ["--command-id", "--controller-epoch", "--controller-expires-at", "--controller-id", "--controller-revision", "--expected-revision", "--terminal-generation"];
+export {};
+//# sourceMappingURL=arguments.d.ts.map

package/dist/terminal/arguments.js

@@ -0,0 +1,79 @@
+import { MAX_TERMINAL_COLUMNS, MAX_TERMINAL_CONTROLLER_LEASE_MS, MAX_TERMINAL_GENERATION, MAX_TERMINAL_INPUT_SEQUENCE, MAX_TERMINAL_ROWS, MIN_TERMINAL_COLUMNS, MIN_TERMINAL_CONTROLLER_LEASE_MS, MIN_TERMINAL_ROWS, } from "@maiaos/sdk";
+import { CliArgumentError } from "../command-line/index.js";
+const MAX_SIGNED_SQLITE_INTEGER = 9223372036854775807n;
+const requiredOption = (parsed, name) => {
+    const value = parsed.options.get(name);
+    if (value === undefined) {
+        throw new CliArgumentError(`Option '${name}' is required.`);
+    }
+    return value;
+};
+const readBoundedInteger = (value, bounds) => {
+    const { maximum, minimum, name } = bounds;
+    if (!/^[1-9]\d*$/u.test(value)) {
+        throw new CliArgumentError(`Option '${name}' must be an integer from ${String(minimum)} to ${String(maximum)}.`);
+    }
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed) || parsed < minimum || parsed > maximum) {
+        throw new CliArgumentError(`Option '${name}' must be an integer from ${String(minimum)} to ${String(maximum)}.`);
+    }
+    return parsed;
+};
+const readRevision = (value, name) => {
+    if (!/^(?:0|[1-9]\d*)$/u.test(value) ||
+        BigInt(value) > MAX_SIGNED_SQLITE_INTEGER) {
+        throw new CliArgumentError(`Option '${name}' must be a non-negative signed 64-bit integer.`);
+    }
+    return value;
+};
+export const readTerminalColumns = (value, fallback) => readBoundedInteger(value ?? String(fallback), {
+    maximum: MAX_TERMINAL_COLUMNS,
+    minimum: MIN_TERMINAL_COLUMNS,
+    name: "--columns",
+});
+export const readTerminalRows = (value, fallback) => readBoundedInteger(value ?? String(fallback), {
+    maximum: MAX_TERMINAL_ROWS,
+    minimum: MIN_TERMINAL_ROWS,
+    name: "--rows",
+});
+export const readTerminalGeneration = (parsed) => readBoundedInteger(requiredOption(parsed, "--terminal-generation"), {
+    maximum: MAX_TERMINAL_GENERATION,
+    minimum: 1,
+    name: "--terminal-generation",
+});
+export const readTerminalLeaseDuration = (parsed) => readBoundedInteger(requiredOption(parsed, "--lease-ms"), {
+    maximum: MAX_TERMINAL_CONTROLLER_LEASE_MS,
+    minimum: MIN_TERMINAL_CONTROLLER_LEASE_MS,
+    name: "--lease-ms",
+});
+export const readTerminalInputSequence = (parsed) => readBoundedInteger(requiredOption(parsed, "--input-sequence"), {
+    maximum: MAX_TERMINAL_INPUT_SEQUENCE,
+    minimum: 1,
+    name: "--input-sequence",
+});
+export const readTerminalExpectedRevision = (parsed) => readRevision(requiredOption(parsed, "--expected-revision"), "--expected-revision");
+export const readTerminalControllerFence = (parsed, terminalId) => {
+    const terminalGeneration = readTerminalGeneration(parsed);
+    return {
+        controller: {
+            epoch: readRevision(requiredOption(parsed, "--controller-epoch"), "--controller-epoch"),
+            expiresAt: requiredOption(parsed, "--controller-expires-at"),
+            id: requiredOption(parsed, "--controller-id"),
+            revision: readRevision(requiredOption(parsed, "--controller-revision"), "--controller-revision"),
+            terminalGeneration,
+            terminalId,
+        },
+        expectedTerminalRevision: readTerminalExpectedRevision(parsed),
+        terminalId,
+    };
+};
+export const terminalControllerFenceOptionNames = [
+    "--command-id",
+    "--controller-epoch",
+    "--controller-expires-at",
+    "--controller-id",
+    "--controller-revision",
+    "--expected-revision",
+    "--terminal-generation",
+];
+//# sourceMappingURL=arguments.js.map

package/dist/terminal/client.d.ts

@@ -0,0 +1,79 @@
+import type { LiveTerminalCloseParameters, LiveTerminalCloseResult, LiveTerminalControllerAcquireParameters, LiveTerminalControllerAcquireResult, LiveTerminalControllerReleaseParameters, LiveTerminalControllerReleaseResult, LiveTerminalControllerRequestParameters, LiveTerminalControllerRequestResult, LiveTerminalControllerRequestShowParameters, LiveTerminalControllerRequestShowResult, LiveTerminalResizeParameters, LiveTerminalResizeResult, LiveTerminalSignalParameters, LiveTerminalSignalResult, LiveTerminalWriteParameters, LiveTerminalWriteResult, TerminalCreateResult, TerminalEventsListResult, TerminalListResult, TerminalReadResult, TerminalShowResult } from "@maiaos/sdk";
+import { type CliNodeEffect, type CliNodeOperations } from "../local-node/index.js";
+export type CreateTerminalInput = {
+    readonly columns: number;
+    readonly commandId?: string;
+    readonly interactive: true;
+    readonly rows: number;
+    readonly workspaceId: string;
+} | {
+    readonly commandId?: string;
+    readonly interactive?: false;
+    readonly workspaceId: string;
+};
+export declare const makeTerminalClient: (node: CliNodeOperations) => {
+    acquireTerminalController: (input: Omit<LiveTerminalControllerAcquireParameters, "commandId"> & {
+        readonly commandId?: string;
+    }) => CliNodeEffect<LiveTerminalControllerAcquireResult>;
+    closeTerminal: (input: Omit<{
+        readonly commandId: string;
+        readonly controller: {
+            readonly epoch: string;
+            readonly expiresAt: string;
+            readonly id: string;
+            readonly revision: string;
+            readonly terminalGeneration: number;
+            readonly terminalId: string;
+        };
+        readonly expectedTerminalRevision: string;
+        readonly terminalId: string;
+    }, "commandId"> & {
+        readonly commandId?: string;
+    }) => CliNodeEffect<LiveTerminalCloseResult>;
+    createTerminal: (input: CreateTerminalInput) => CliNodeEffect<TerminalCreateResult>;
+    listTerminalEvents: (input: {
+        readonly afterTerminalCursor: string;
+        readonly limit: number;
+        readonly terminalId: string;
+    }) => CliNodeEffect<TerminalEventsListResult>;
+    listTerminals: (input: {
+        readonly afterCursor: string;
+        readonly limit: number;
+        readonly workspaceId: string;
+    }) => CliNodeEffect<TerminalListResult>;
+    readTerminal: (input: {
+        readonly afterChunkCursor: string;
+        readonly limit: number;
+        readonly terminalId: string;
+    }) => CliNodeEffect<TerminalReadResult>;
+    releaseTerminalController: (input: Omit<{
+        readonly commandId: string;
+        readonly controller: {
+            readonly epoch: string;
+            readonly expiresAt: string;
+            readonly id: string;
+            readonly revision: string;
+            readonly terminalGeneration: number;
+            readonly terminalId: string;
+        };
+        readonly expectedTerminalRevision: string;
+        readonly terminalId: string;
+    }, "commandId"> & {
+        readonly commandId?: string;
+    }) => CliNodeEffect<LiveTerminalControllerReleaseResult>;
+    requestTerminalController: (input: Omit<LiveTerminalControllerRequestParameters, "commandId"> & {
+        readonly commandId?: string;
+    }) => CliNodeEffect<LiveTerminalControllerRequestResult>;
+    resizeTerminal: (input: Omit<LiveTerminalResizeParameters, "commandId"> & {
+        readonly commandId?: string;
+    }) => CliNodeEffect<LiveTerminalResizeResult>;
+    showTerminal: (terminalId: string) => CliNodeEffect<TerminalShowResult>;
+    showTerminalControllerRequest: (input: LiveTerminalControllerRequestShowParameters) => CliNodeEffect<LiveTerminalControllerRequestShowResult>;
+    signalTerminal: (input: Omit<LiveTerminalSignalParameters, "commandId"> & {
+        readonly commandId?: string;
+    }) => CliNodeEffect<LiveTerminalSignalResult>;
+    writeTerminalInput: (input: Omit<LiveTerminalWriteParameters, "commandId"> & {
+        readonly commandId?: string;
+    }) => CliNodeEffect<LiveTerminalWriteResult>;
+};
+//# sourceMappingURL=client.d.ts.map