@maiaos/cli 0.1.0-canary.2

package/dist/command-line/context.d.ts

@@ -0,0 +1,178 @@
+import type { AgentPermissionConfirmParameters, AgentPermissionConfirmResult, AgentPermissionPreviewParameters, AgentPermissionPreviewResult, ExecutionCatalogGetResult, ExecutionCommandRunResult, ExecutionFileReadResult, ExecutionPlacementCreateResult, ExecutionPlacementShowResult, ExecutionRelocationApplyResult, ExecutionRelocationPlanResult, ExecutionRelocationReconcileResult, ExecutionRelocationShowResult, ExecutionWorktreeCheckpointCreateResult, ExecutionWorktreeCheckpointShowResult, ExecutionWorktreeCreateResult, ExecutionWorktreeImportResult, ExecutionWorktreeReconcileResult, ExecutionWorktreeRemoveApplyResult, ExecutionWorktreeRemovePlanResult, ExecutionWorktreeStatusResult, InvocationContextShowResult, LiveTerminalCloseResult, LiveTerminalControllerAcquireResult, LiveTerminalControllerReleaseResult, LiveTerminalControllerRequestResult, LiveTerminalControllerRequestShowResult, LiveTerminalResizeResult, LiveTerminalSignalResult, LiveTerminalWriteResult, LocalNodeStatusResult, MonitorBootstrapCreateResult, OrchestrationDispatchSettleTerminalResult, OrchestrationDispatchShowResult, OrchestrationInboxAckResult, OrchestrationInboxCheckResult, OrchestrationQuestionCancelResult, OrchestrationQuestionOpenResult, OrchestrationQuestionReplyResult, OrchestrationRunCreateResult, OrchestrationRunListResult, OrchestrationRunShowResult, OrchestrationTaskListResult, OrchestrationTaskShowResult, ProjectContextListResult, ProjectContextRecordResult, ProjectContextShowResult, ProjectListResult, ProjectRegisterResult, ProjectShowResult, ProviderPoolListResult, ReceiptGetResult, ReceiptListParameters, ReceiptListResult, SessionArchiveResult, SessionCreateResult, SessionDiffResult, SessionEventsListResult, SessionInboxAckResult, SessionInboxCheckResult, SessionListResult, SessionMessageSendResult, SessionObserveResult, SessionResumeResult, SessionShowResult, SessionStartResult, SessionStopResult, TerminalCreateResult, TerminalEventsListResult, TerminalListResult, TerminalReadResult, TerminalShowResult, TurnInterruptResult, TurnSendResult, TurnShowResult, TurnWaitResult, WorkspaceContextShowResult, WorkspaceExecutionConfigureResult, WorkspaceExecutionShowResult, WorkspaceListResult, WorkspaceMembershipAttachResult, WorkspaceRepositoryAttachResult, WorkspaceSelectResult, WorkspaceShowResult } from "@maiaos/sdk";
+import type * as Crypto from "effect/Crypto";
+import type * as Effect from "effect/Effect";
+import type { ConnectionCliDependencies, VendorLogin } from "../connection/index.js";
+import type { ContainerCliDependencies } from "../container/index.js";
+import type { ApplyExecutionRelocationInput, PlanExecutionRelocationInput, ReconcileExecutionRelocationInput } from "../execution/index.js";
+import type { HoldCliDependencies } from "../hold/index.js";
+import type { DiscoveryCliDependencies } from "../import/index.js";
+import type { IntegrationCliDependencies } from "../integration/index.js";
+import type { CliNodeCall, CliNodeEffect } from "../local-node/index.js";
+import type { AgentProviderAccess } from "../login/index.js";
+import type { McpCliDependencies } from "../mcp/index.js";
+import type { makeOrchestrationClient } from "../orchestration/index.js";
+import type { PortLeaseCliDependencies } from "../port-lease/index.js";
+import type { PresentationCliDependencies } from "../presentation/index.js";
+import type { ProjectGuardCliDependencies } from "../project-guard/index.js";
+import type { AttachRepositoryInput, AttachWorkspaceMembershipInput, ConfigureWorkspaceExecutionInput, CreateExecutionCheckpointInput, CreateExecutionPlacementInput, CreateExecutionWorktreeInput, ImportExecutionWorktreeInput, ProjectMetadataCliDependencies, ReadExecutionFileInput, ReconcileExecutionWorktreeInput, RecordProjectContextInput, RegisterProjectInput, RemoveExecutionWorktreeInput, RunExecutionCommandInput, SelectWorkspaceInput } from "../project-workspace/index.js";
+import type { RemoteNodeCliDependencies } from "../remote-node/index.js";
+import type { RunLedgerCliDependencies } from "../run-ledger/index.js";
+import type { ApprovalCliDependencies } from "../session/approval/index.js";
+import type { ArchiveSessionInput, AttachSessionInput, CreateSessionInput, DiffSessionInput, ListSessionsInput, makeSessionClient, SessionAttachStream, StartSessionInput } from "../session/index.js";
+import type { InteractionCliDependencies } from "../session/interaction/index.js";
+import type { InterruptTurnInput, SendTurnInput, WaitTurnsInput } from "../session/turn/index.js";
+import type { CreateTerminalInput, makeTerminalClient } from "../terminal/index.js";
+import type { CliArgumentError } from "./input/index.js";
+import type { CliIo, CliResolution } from "./output.js";
+type OrchestrationClient = ReturnType<typeof makeOrchestrationClient>;
+type SessionClient = ReturnType<typeof makeSessionClient>;
+type TerminalClient = ReturnType<typeof makeTerminalClient>;
+export type CliDependencies = Partial<ApprovalCliDependencies & ConnectionCliDependencies & ContainerCliDependencies & HoldCliDependencies & DiscoveryCliDependencies & IntegrationCliDependencies & PresentationCliDependencies & McpCliDependencies & InteractionCliDependencies & PortLeaseCliDependencies & ProjectGuardCliDependencies & ProjectMetadataCliDependencies & RemoteNodeCliDependencies & RunLedgerCliDependencies> & {
+    readonly acknowledgeAttachedSessionDelivery?: (input: Parameters<SessionClient["acknowledgeAttachedSessionDelivery"]>[0]) => CliNodeEffect<SessionInboxAckResult>;
+    readonly acknowledgeRunDelivery: (input: Parameters<OrchestrationClient["acknowledgeRunDelivery"]>[0]) => CliNodeEffect<OrchestrationInboxAckResult>;
+    readonly acquireTerminalController: (input: Parameters<TerminalClient["acquireTerminalController"]>[0]) => CliNodeEffect<LiveTerminalControllerAcquireResult>;
+    readonly agentProviders?: AgentProviderAccess;
+    readonly applyExecutionRelocation?: (input: ApplyExecutionRelocationInput) => CliNodeEffect<ExecutionRelocationApplyResult>;
+    readonly archiveSession?: (input: ArchiveSessionInput) => CliNodeEffect<SessionArchiveResult>;
+    readonly attachSession?: (input: AttachSessionInput) => CliNodeEffect<SessionAttachStream>;
+    readonly attachWorkspaceMembership?: (input: AttachWorkspaceMembershipInput) => CliNodeEffect<WorkspaceMembershipAttachResult>;
+    readonly attachWorkspaceRepository: (input: AttachRepositoryInput) => CliNodeEffect<WorkspaceRepositoryAttachResult>;
+    readonly awaitSessionRunning?: SessionClient["awaitSessionRunning"];
+    readonly call?: CliNodeCall;
+    readonly cancelRunQuestion: (input: Parameters<OrchestrationClient["cancelRunQuestion"]>[0]) => CliNodeEffect<OrchestrationQuestionCancelResult>;
+    readonly checkAttachedSessionInbox?: (input: Parameters<SessionClient["checkAttachedSessionInbox"]>[0]) => CliNodeEffect<SessionInboxCheckResult>;
+    readonly checkRunInbox: (input: Parameters<OrchestrationClient["checkRunInbox"]>[0]) => CliNodeEffect<OrchestrationInboxCheckResult>;
+    readonly closeTerminal: (input: Parameters<TerminalClient["closeTerminal"]>[0]) => CliNodeEffect<LiveTerminalCloseResult>;
+    readonly configureWorkspaceExecution?: (input: ConfigureWorkspaceExecutionInput) => CliNodeEffect<WorkspaceExecutionConfigureResult>;
+    readonly confirmAgentPermission?: (input: AgentPermissionConfirmParameters) => CliNodeEffect<AgentPermissionConfirmResult>;
+    readonly createExecutionCheckpoint?: (input: CreateExecutionCheckpointInput) => CliNodeEffect<ExecutionWorktreeCheckpointCreateResult>;
+    readonly createExecutionPlacement?: (input: CreateExecutionPlacementInput) => CliNodeEffect<ExecutionPlacementCreateResult>;
+    readonly createExecutionWorktree?: (input: CreateExecutionWorktreeInput) => CliNodeEffect<ExecutionWorktreeCreateResult>;
+    readonly createMonitorBootstrap?: () => CliNodeEffect<MonitorBootstrapCreateResult>;
+    readonly createRun: (input: Parameters<OrchestrationClient["createRun"]>[0]) => CliNodeEffect<OrchestrationRunCreateResult>;
+    readonly createSession: (input: CreateSessionInput) => CliNodeEffect<SessionCreateResult>;
+    readonly createTerminal: (input: CreateTerminalInput) => CliNodeEffect<TerminalCreateResult>;
+    readonly diffSession?: (input: DiffSessionInput) => CliNodeEffect<SessionDiffResult>;
+    readonly getReceipt: (commandId: string) => CliNodeEffect<ReceiptGetResult>;
+    readonly importExecutionWorktree?: (input: ImportExecutionWorktreeInput) => CliNodeEffect<ExecutionWorktreeImportResult>;
+    readonly interruptTurn: (input: InterruptTurnInput) => CliNodeEffect<TurnInterruptResult>;
+    readonly listProjectContext: (input: {
+        readonly afterCursor: string;
+        readonly limit: number;
+        readonly projectId: string;
+    }) => CliNodeEffect<ProjectContextListResult>;
+    readonly listProjects: (input: {
+        readonly afterCursor: string;
+        readonly limit: number;
+    }) => CliNodeEffect<ProjectListResult>;
+    readonly listProviderPools?: () => CliNodeEffect<ProviderPoolListResult>;
+    readonly listReceipts: (parameters: ReceiptListParameters) => CliNodeEffect<ReceiptListResult>;
+    readonly listRuns: (input: {
+        readonly afterCursor: string;
+        readonly limit: number;
+        readonly workspaceId: string;
+    }) => CliNodeEffect<OrchestrationRunListResult>;
+    readonly listSessionEvents: (input: {
+        readonly afterSessionCursor: string;
+        readonly limit: number;
+        readonly sessionId: string;
+    }) => CliNodeEffect<SessionEventsListResult>;
+    readonly listSessions: (input: ListSessionsInput) => CliNodeEffect<SessionListResult>;
+    readonly listTasks: (input: {
+        readonly afterCursor: string;
+        readonly limit: number;
+        readonly runId: string;
+    }) => CliNodeEffect<OrchestrationTaskListResult>;
+    readonly listTerminalEvents: (input: {
+        readonly afterTerminalCursor: string;
+        readonly limit: number;
+        readonly terminalId: string;
+    }) => CliNodeEffect<TerminalEventsListResult>;
+    readonly listTerminals: (input: {
+        readonly afterCursor: string;
+        readonly limit: number;
+        readonly workspaceId: string;
+    }) => CliNodeEffect<TerminalListResult>;
+    readonly listWorkspaces: (input: {
+        readonly afterCursor: string;
+        readonly limit: number;
+        readonly projectId: string;
+    }) => CliNodeEffect<WorkspaceListResult>;
+    readonly observeSessions?: (input: {
+        readonly sessionIds?: readonly string[];
+        readonly stallAfterSeconds?: number;
+    }) => CliNodeEffect<SessionObserveResult>;
+    readonly openRunQuestion: (input: Parameters<OrchestrationClient["openRunQuestion"]>[0]) => CliNodeEffect<OrchestrationQuestionOpenResult>;
+    readonly planExecutionRelocation?: (input: PlanExecutionRelocationInput) => CliNodeEffect<ExecutionRelocationPlanResult>;
+    readonly planExecutionWorktreeRemove?: (workspaceId: string) => CliNodeEffect<ExecutionWorktreeRemovePlanResult>;
+    readonly planSessions?: SessionClient["planSessions"];
+    readonly previewAgentPermission?: (input: AgentPermissionPreviewParameters) => CliNodeEffect<AgentPermissionPreviewResult>;
+    readonly readExecutionCatalog?: () => CliNodeEffect<ExecutionCatalogGetResult>;
+    readonly readExecutionFile?: (input: ReadExecutionFileInput) => CliNodeEffect<ExecutionFileReadResult>;
+    readonly readStatus: () => Effect.Effect<LocalNodeStatusResult, unknown, Crypto.Crypto>;
+    readonly readTerminal: (input: {
+        readonly afterChunkCursor: string;
+        readonly limit: number;
+        readonly terminalId: string;
+    }) => CliNodeEffect<TerminalReadResult>;
+    readonly reconcileExecutionRelocation?: (input: ReconcileExecutionRelocationInput) => CliNodeEffect<ExecutionRelocationReconcileResult>;
+    readonly reconcileExecutionWorktree?: (input: ReconcileExecutionWorktreeInput) => CliNodeEffect<ExecutionWorktreeReconcileResult>;
+    readonly recordProjectContext: (input: RecordProjectContextInput) => CliNodeEffect<ProjectContextRecordResult>;
+    readonly registerProject: (input: RegisterProjectInput) => CliNodeEffect<ProjectRegisterResult>;
+    readonly releaseTerminalController: (input: Parameters<TerminalClient["releaseTerminalController"]>[0]) => CliNodeEffect<LiveTerminalControllerReleaseResult>;
+    readonly removeExecutionWorktree?: (input: RemoveExecutionWorktreeInput) => CliNodeEffect<ExecutionWorktreeRemoveApplyResult>;
+    readonly replyRunQuestion: (input: Parameters<OrchestrationClient["replyRunQuestion"]>[0]) => CliNodeEffect<OrchestrationQuestionReplyResult>;
+    readonly requestTerminalController: (input: Parameters<TerminalClient["requestTerminalController"]>[0]) => CliNodeEffect<LiveTerminalControllerRequestResult>;
+    readonly resizeTerminal: (input: Parameters<TerminalClient["resizeTerminal"]>[0]) => CliNodeEffect<LiveTerminalResizeResult>;
+    readonly resumeSession?: (input: StartSessionInput) => CliNodeEffect<SessionResumeResult>;
+    readonly runAgent?: (arguments_: readonly string[], io: CliIo) => Effect.Effect<number, unknown>;
+    readonly runExecutionCommand?: (input: RunExecutionCommandInput) => CliNodeEffect<ExecutionCommandRunResult>;
+    readonly runSessions?: SessionClient["runSessions"];
+    readonly runVendorLogin?: VendorLogin;
+    readonly selectWorkspace?: (input: SelectWorkspaceInput) => CliNodeEffect<WorkspaceSelectResult>;
+    readonly sendAttachedSessionMessage?: (input: Parameters<SessionClient["sendAttachedSessionMessage"]>[0]) => CliNodeEffect<SessionMessageSendResult>;
+    readonly sendTurn: (input: SendTurnInput) => CliNodeEffect<TurnSendResult>;
+    readonly settleRunDispatchTerminal: (input: Parameters<OrchestrationClient["settleRunDispatchTerminal"]>[0]) => CliNodeEffect<OrchestrationDispatchSettleTerminalResult>;
+    readonly showAttachedCurrentContext?: () => CliNodeEffect<InvocationContextShowResult>;
+    readonly showCurrentContext: () => CliNodeEffect<InvocationContextShowResult>;
+    readonly showDispatch: (runId: string) => CliNodeEffect<OrchestrationDispatchShowResult>;
+    readonly showExecutionCheckpoint?: (checkpointId: string) => CliNodeEffect<ExecutionWorktreeCheckpointShowResult>;
+    readonly showExecutionPlacement?: (input: {
+        readonly kind: "attempt" | "session";
+        readonly ownerId: string;
+    }) => CliNodeEffect<ExecutionPlacementShowResult>;
+    readonly showExecutionRelocation?: (relocationId: string) => CliNodeEffect<ExecutionRelocationShowResult>;
+    readonly showExecutionWorktreeStatus?: (workspaceId: string) => CliNodeEffect<ExecutionWorktreeStatusResult>;
+    readonly showProject: (projectId: string) => CliNodeEffect<ProjectShowResult>;
+    readonly showProjectContext: (noteId: string) => CliNodeEffect<ProjectContextShowResult>;
+    readonly showRun: (runId: string) => CliNodeEffect<OrchestrationRunShowResult>;
+    readonly showSession: (sessionId: string) => CliNodeEffect<SessionShowResult>;
+    readonly showTask: (input: {
+        readonly runId: string;
+        readonly taskId: string;
+    }) => CliNodeEffect<OrchestrationTaskShowResult>;
+    readonly showTerminal: (terminalId: string) => CliNodeEffect<TerminalShowResult>;
+    readonly showTerminalControllerRequest: (input: Parameters<TerminalClient["showTerminalControllerRequest"]>[0]) => CliNodeEffect<LiveTerminalControllerRequestShowResult>;
+    readonly showTurn: (turnId: string) => CliNodeEffect<TurnShowResult>;
+    readonly showWorkspace: (workspaceId: string) => CliNodeEffect<WorkspaceShowResult>;
+    readonly showWorkspaceContext?: () => CliNodeEffect<WorkspaceContextShowResult>;
+    readonly showWorkspaceExecution?: (workspaceId: string) => CliNodeEffect<WorkspaceExecutionShowResult>;
+    readonly signalTerminal: (input: Parameters<TerminalClient["signalTerminal"]>[0]) => CliNodeEffect<LiveTerminalSignalResult>;
+    readonly startSession: (input: StartSessionInput) => CliNodeEffect<SessionStartResult>;
+    readonly stopSession?: (input: StartSessionInput) => CliNodeEffect<SessionStopResult>;
+    readonly waitTurns?: (input: WaitTurnsInput) => CliNodeEffect<TurnWaitResult>;
+    readonly writeTerminalInput: (input: Parameters<TerminalClient["writeTerminalInput"]>[0]) => CliNodeEffect<LiveTerminalWriteResult>;
+};
+export type CliServices = Crypto.Crypto;
+export type CommandEffect = Effect.Effect<number, CliArgumentError, CliServices>;
+export type CommandContext = {
+    readonly dependencies: CliDependencies;
+    readonly io: CliIo;
+    readonly json: boolean;
+    readonly node?: string;
+    readonly profile?: string;
+    readonly resolved?: readonly CliResolution[];
+    readonly version: string;
+};
+export {};
+//# sourceMappingURL=context.d.ts.map

package/dist/command-line/context.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=context.js.map

package/dist/command-line/index.d.ts

@@ -0,0 +1,7 @@
+export { type CliDependencies, type CliServices, type CommandContext, type CommandEffect, } from "./context.js";
+export { argumentsAreBounded, type ArgumentToken, CliArgumentError, missingArgument, parseArguments, type ParsedArguments, type ParsedOptions, parseOptions, readBoundedStdin, readCursor, readDuration, readExpectedRevision, readGlobalValue, readPageSize, readRevisionOption, recoverStdin, requireNoArguments, requirePositionals, tokenizeArguments, unknownCommand, } from "./input/index.js";
+export { decodeJsonText } from "./json.js";
+export { type CliCommandOutput, type CliErrorOutput, type CliIo, type CliResolution, type CliSuccessOutput, type CliSuccessResult, type NodeResultPresenter, reportError, writeNodeResult, writeSuccess, } from "./output.js";
+export { cell, formatRows, tab, withNextPage } from "./rows.js";
+export { askToConfirm, canPrompt, confirmationOf, confirmParameters, EXIT_CANCELLED, promptOrRefuse, readPipedPreview, readTwoPhaseMode, requestedTwoPhaseMode, runInputTwoPhase, runTwoPhase, TWO_PHASE_FLAGS, type TwoPhaseMode, } from "./two-phase.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/command-line/index.js

@@ -0,0 +1,6 @@
+export { argumentsAreBounded, CliArgumentError, missingArgument, parseArguments, parseOptions, readBoundedStdin, readCursor, readDuration, readExpectedRevision, readGlobalValue, readPageSize, readRevisionOption, recoverStdin, requireNoArguments, requirePositionals, tokenizeArguments, unknownCommand, } from "./input/index.js";
+export { decodeJsonText } from "./json.js";
+export { reportError, writeNodeResult, writeSuccess, } from "./output.js";
+export { cell, formatRows, tab, withNextPage } from "./rows.js";
+export { askToConfirm, canPrompt, confirmationOf, confirmParameters, EXIT_CANCELLED, promptOrRefuse, readPipedPreview, readTwoPhaseMode, requestedTwoPhaseMode, runInputTwoPhase, runTwoPhase, TWO_PHASE_FLAGS, } from "./two-phase.js";
+//# sourceMappingURL=index.js.map

package/dist/command-line/input/arguments.d.ts

@@ -0,0 +1,55 @@
+export type ParsedArguments = {
+    readonly help: boolean;
+    readonly json: boolean;
+    readonly jsonFlagCount: number;
+    readonly node?: string;
+    readonly noInput: boolean;
+    readonly profile?: string;
+    readonly tokens: readonly string[];
+};
+export type ParsedOptions = {
+    readonly flags: ReadonlySet<string>;
+    readonly options: ReadonlyMap<string, string>;
+    readonly positionals: readonly string[];
+};
+declare const CliArgumentError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "CliArgumentError";
+} & Readonly<A>;
+export declare class CliArgumentError extends CliArgumentError_base<{
+    readonly message: string;
+}> {
+    constructor(message: string);
+}
+export declare const argumentsAreBounded: (arguments_: readonly string[]) => boolean;
+type ValueOption = "--node" | "--profile";
+export declare const readGlobalValue: (option: ValueOption, value: string | undefined) => string;
+export declare const parseArguments: (arguments_: readonly string[]) => ParsedArguments;
+export declare const parseOptions: (tokens: readonly string[], allowed: ReadonlySet<string>, allowedFlags?: ReadonlySet<string>) => ParsedOptions;
+export declare const requirePositionals: (positionals: readonly string[], count: number) => void;
+export declare const missingArgument: () => CliArgumentError;
+export declare const unknownCommand: () => CliArgumentError;
+export declare const requireNoArguments: (tokens: readonly string[], command: string) => void;
+export declare const readPageSize: (value: string | undefined, maximum?: number) => number;
+export declare const readCursor: (value?: string) => string;
+export declare const readRevisionOption: (value: string | undefined, option: `--${string}`) => string;
+export declare const readExpectedRevision: (value: string | undefined) => string;
+export declare const readDuration: (value: string, option: `--${string}`, range: {
+    readonly max: number;
+    readonly min: number;
+}) => number;
+export type ArgumentToken = {
+    readonly index: number;
+    readonly inline: boolean;
+    readonly kind: "value";
+    readonly name: string;
+} | {
+    readonly index: number;
+    readonly kind: "flag";
+    readonly name: string;
+} | {
+    readonly index: number;
+    readonly kind: "positional";
+};
+export declare const tokenizeArguments: (tokens: readonly string[], valueOptions: ReadonlySet<string>) => readonly ArgumentToken[];
+export {};
+//# sourceMappingURL=arguments.d.ts.map

package/dist/command-line/input/arguments.js

@@ -0,0 +1,220 @@
+import { Buffer } from "node:buffer";
+import * as Data from "effect/Data";
+const MAX_ARGUMENT_BYTES = 16 * 1024;
+const MAX_ARGUMENT_COUNT = 32;
+const MAX_TOKEN_BYTES = 4096;
+const MAX_SIGNED_INT_64 = 9223372036854775807n;
+const DEFAULT_PAGE_SIZE = 20;
+export class CliArgumentError extends Data.TaggedError("CliArgumentError") {
+    constructor(message) {
+        super({ message });
+    }
+}
+export const argumentsAreBounded = (arguments_) => arguments_.length <= MAX_ARGUMENT_COUNT &&
+    arguments_.every((argument) => Buffer.byteLength(argument, "utf8") <= MAX_TOKEN_BYTES) &&
+    arguments_.reduce((total, argument) => total + Buffer.byteLength(argument, "utf8"), 0) <= MAX_ARGUMENT_BYTES;
+const PROFILE_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/u;
+const NODE_PATTERN = /^[a-z0-9][a-z0-9-]{0,62}$/u;
+const GLOBAL_FLAGS = new Set([
+    "--help",
+    "--json",
+    "--no-input",
+    "-h",
+]);
+export const readGlobalValue = (option, value) => {
+    if (value === undefined || value.startsWith("-"))
+        throw new CliArgumentError(`Option '${option}' requires a value.`);
+    if (!(option === "--node" ? NODE_PATTERN : PROFILE_PATTERN).test(value))
+        throw new CliArgumentError(`Option '${option}' is invalid.`);
+    return value;
+};
+const scanToken = (scan, tokens, index) => {
+    const token = tokens[index] ?? "";
+    if (GLOBAL_FLAGS.has(token)) {
+        scan.flags.set(token, (scan.flags.get(token) ?? 0) + 1);
+        return 1;
+    }
+    if (token === "--node" || token === "--profile") {
+        if (scan.values.has(token))
+            throw new CliArgumentError(`Option '${token}' may be used only once.`);
+        scan.values.set(token, readGlobalValue(token, tokens[index + 1]));
+        return 2;
+    }
+    scan.tokens.push(token);
+    return 1;
+};
+const scanFrom = (scan, tokens, index) => {
+    if (index >= tokens.length)
+        return;
+    scanFrom(scan, tokens, index + scanToken(scan, tokens, index));
+};
+const agentArguments = (arguments_) => ({
+    help: false,
+    json: false,
+    jsonFlagCount: 0,
+    noInput: false,
+    tokens: arguments_,
+});
+export const parseArguments = (arguments_) => {
+    if (arguments_[0] === "agent")
+        return agentArguments(arguments_);
+    const end = arguments_.indexOf("--");
+    const head = end === -1 ? arguments_ : arguments_.slice(0, end);
+    const scan = { flags: new Map(), tokens: [], values: new Map() };
+    scanFrom(scan, head, 0);
+    if ((scan.flags.get("--no-input") ?? 0) > 1)
+        throw new CliArgumentError("Option '--no-input' may be used only once.");
+    const node = scan.values.get("--node");
+    const profile = scan.values.get("--profile");
+    const jsonFlagCount = scan.flags.get("--json") ?? 0;
+    return {
+        help: scan.flags.has("-h") || scan.flags.has("--help"),
+        json: jsonFlagCount > 0,
+        jsonFlagCount,
+        noInput: scan.flags.has("--no-input"),
+        ...(node === undefined ? {} : { node }),
+        ...(profile === undefined ? {} : { profile }),
+        tokens: [...scan.tokens, ...(end === -1 ? [] : arguments_.slice(end))],
+    };
+};
+const parseOptionToken = (state, token) => {
+    if (state.pendingOption !== undefined) {
+        if (token.startsWith("--")) {
+            throw new CliArgumentError(`Option '${state.pendingOption}' requires a value.`);
+        }
+        state.options.set(state.pendingOption, token);
+        delete state.pendingOption;
+        return;
+    }
+    if (!token.startsWith("--")) {
+        state.positionals.push(token);
+        return;
+    }
+    if (state.allowedFlags.has(token)) {
+        if (state.flags.has(token)) {
+            throw new CliArgumentError(`Option '${token}' may be used only once.`);
+        }
+        state.flags.add(token);
+        return;
+    }
+    if (!state.allowed.has(token)) {
+        throw new CliArgumentError("The command contains an unknown option.");
+    }
+    if (state.options.has(token)) {
+        throw new CliArgumentError(`Option '${token}' may be used only once.`);
+    }
+    state.pendingOption = token;
+};
+const splitInlineValue = (token, allowed) => {
+    const separator = token.indexOf("=");
+    if (!token.startsWith("--") || separator === -1)
+        return [token];
+    const name = token.slice(0, separator);
+    return allowed.has(name) ? [name, token.slice(separator + 1)] : [token];
+};
+export const parseOptions = (tokens, allowed, allowedFlags = new Set()) => {
+    const state = {
+        allowed,
+        allowedFlags,
+        flags: new Set(),
+        options: new Map(),
+        positionals: [],
+    };
+    tokens
+        .flatMap((token) => splitInlineValue(token, allowed))
+        .forEach((token) => {
+        parseOptionToken(state, token);
+    });
+    if (state.pendingOption !== undefined) {
+        throw new CliArgumentError(`Option '${state.pendingOption}' requires a value.`);
+    }
+    return {
+        flags: state.flags,
+        options: state.options,
+        positionals: state.positionals,
+    };
+};
+export const requirePositionals = (positionals, count) => {
+    if (positionals.length === count)
+        return;
+    throw new CliArgumentError(count === 0
+        ? "The command takes no positional arguments."
+        : `The command takes ${String(count)} positional argument${count === 1 ? "" : "s"}.`);
+};
+export const missingArgument = () => new CliArgumentError("A required argument is missing.");
+export const unknownCommand = () => new CliArgumentError("The command is missing or unknown.");
+export const requireNoArguments = (tokens, command) => {
+    if (tokens.length > 0) {
+        throw new CliArgumentError(`${command} does not accept additional arguments.`);
+    }
+};
+export const readPageSize = (value, maximum = 100) => {
+    if (value === undefined)
+        return DEFAULT_PAGE_SIZE;
+    const size = /^[1-9]\d{0,2}$/u.test(value) ? Number(value) : 0;
+    if (size < 1 || size > maximum) {
+        throw new CliArgumentError(`Option '--limit' must be an integer from 1 to ${String(maximum)}.`);
+    }
+    return size;
+};
+const readInt64 = (value, errorMessage) => {
+    if (!/^(?:0|[1-9]\d*)$/u.test(value) || BigInt(value) > MAX_SIGNED_INT_64) {
+        throw new CliArgumentError(errorMessage);
+    }
+    return value;
+};
+export const readCursor = (value = "0") => readInt64(value, "Option '--after' must be a non-negative signed 64-bit integer cursor.");
+export const readRevisionOption = (value, option) => {
+    if (value === undefined) {
+        throw new CliArgumentError(`Option '${option}' is required.`);
+    }
+    return readInt64(value, `Option '${option}' must be a non-negative signed 64-bit integer.`);
+};
+export const readExpectedRevision = (value) => readRevisionOption(value, "--expected-revision");
+const DURATION = /^([1-9]\d{0,5})(s|m|h)$/u;
+const unitSeconds = (unit) => {
+    if (unit === "h")
+        return 3600;
+    return unit === "m" ? 60 : 1;
+};
+const describeSeconds = (seconds) => {
+    if (seconds % 3600 === 0)
+        return `${String(seconds / 3600)}h`;
+    return seconds % 60 === 0
+        ? `${String(seconds / 60)}m`
+        : `${String(seconds)}s`;
+};
+export const readDuration = (value, option, range) => {
+    const match = DURATION.exec(value);
+    const seconds = match === null ? 0 : Number(match[1]) * unitSeconds(match[2]);
+    if (seconds < range.min || seconds > range.max)
+        throw new CliArgumentError(`Option '${option}' must be a duration from ${describeSeconds(range.min)} to ${describeSeconds(range.max)}, such as 30s, 10m or 1h.`);
+    return seconds;
+};
+const tokenRole = (token, index, valueOptions) => {
+    if (!token.startsWith("--"))
+        return { index, kind: "positional" };
+    const [name = token, ...value] = splitInlineValue(token, valueOptions);
+    if (value.length > 0)
+        return { index, inline: true, kind: "value", name };
+    return valueOptions.has(name)
+        ? { pending: name }
+        : { index, kind: "flag", name };
+};
+export const tokenizeArguments = (tokens, valueOptions) => {
+    const end = tokens.indexOf("--");
+    return tokens.slice(0, end === -1 ? tokens.length : end).reduce(({ pending, roles }, token, index) => {
+        if (pending !== undefined)
+            return {
+                roles: [
+                    ...roles,
+                    { index, inline: false, kind: "value", name: pending },
+                ],
+            };
+        const role = tokenRole(token, index, valueOptions);
+        return "pending" in role
+            ? { pending: role.pending, roles }
+            : { roles: [...roles, role] };
+    }, { roles: [] }).roles;
+};
+//# sourceMappingURL=arguments.js.map

package/dist/command-line/input/index.d.ts

@@ -0,0 +1,4 @@
+export { argumentsAreBounded, type ArgumentToken, CliArgumentError, missingArgument, parseArguments, type ParsedArguments, type ParsedOptions, parseOptions, readCursor, readDuration, readExpectedRevision, readGlobalValue, readPageSize, readRevisionOption, requireNoArguments, requirePositionals, tokenizeArguments, unknownCommand, } from "./arguments.js";
+export { promptLine, type PromptOptions, terminalIsInteractive, } from "./prompt.js";
+export { type BoundedStdinRequest, readBoundedStdin, recoverStdin, } from "./stdin.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/command-line/input/index.js

@@ -0,0 +1,4 @@
+export { argumentsAreBounded, CliArgumentError, missingArgument, parseArguments, parseOptions, readCursor, readDuration, readExpectedRevision, readGlobalValue, readPageSize, readRevisionOption, requireNoArguments, requirePositionals, tokenizeArguments, unknownCommand, } from "./arguments.js";
+export { promptLine, terminalIsInteractive, } from "./prompt.js";
+export { readBoundedStdin, recoverStdin, } from "./stdin.js";
+//# sourceMappingURL=index.js.map

package/dist/command-line/input/prompt.d.ts

@@ -0,0 +1,8 @@
+import * as Effect from "effect/Effect";
+export type PromptOptions = {
+    readonly secret?: boolean;
+    readonly signal?: AbortSignal;
+};
+export declare const promptLine: (question: string, options?: PromptOptions) => Effect.Effect<string | undefined>;
+export declare const terminalIsInteractive: () => boolean;
+//# sourceMappingURL=prompt.d.ts.map

package/dist/command-line/input/prompt.js

@@ -0,0 +1,44 @@
+import process from "node:process";
+import { createInterface } from "node:readline/promises";
+import { Writable } from "node:stream";
+import * as Effect from "effect/Effect";
+const promptStream = (state) => new Writable({
+    write: (chunk, _encoding, done) => {
+        if (!state.muted &&
+            (typeof chunk === "string" || chunk instanceof Uint8Array)) {
+            process.stderr.write(chunk);
+        }
+        done();
+    },
+});
+const openPrompt = Effect.sync(() => {
+    const state = { muted: false };
+    return {
+        lines: createInterface({
+            input: process.stdin,
+            output: promptStream(state),
+            terminal: true,
+        }),
+        state,
+    };
+});
+const ask = ({ lines, state }, question, options) => Effect.tryPromise({
+    catch: (error) => error,
+    try: (interrupted) => {
+        const pending = lines.question(question, {
+            signal: options.signal ?? interrupted,
+        });
+        state.muted = options.secret === true;
+        return pending;
+    },
+}).pipe(Effect.map((answer) => {
+    if (state.muted)
+        process.stderr.write("\n");
+    return answer.trim();
+}), Effect.catch(() => Effect.andThen(Effect.sync(() => process.stderr.write("\n")), Effect.undefined)));
+export const promptLine = (question, options = {}) => Effect.acquireUseRelease(openPrompt, (session) => ask(session, question, options), ({ lines }) => Effect.sync(() => {
+    lines.close();
+}));
+const isTerminal = (stream) => stream.isTTY === true;
+export const terminalIsInteractive = () => isTerminal(process.stdin) && isTerminal(process.stderr);
+//# sourceMappingURL=prompt.js.map

package/dist/command-line/input/stdin-stream.d.ts

@@ -0,0 +1,4 @@
+import type * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+export declare const foldStream: <TChunk, TState, TError>(input: Stream.Stream<TChunk, unknown>, initial: () => TState, step: (state: TState, chunk: TChunk) => Effect.Effect<TState, TError>) => Effect.Effect<TState, TError>;
+//# sourceMappingURL=stdin-stream.d.ts.map

package/dist/command-line/input/stdin-stream.js

@@ -0,0 +1,3 @@
+import * as Stream from "effect/Stream";
+export const foldStream = (input, initial, step) => input.pipe(Stream.orDie, Stream.runFoldEffect(initial, step));
+//# sourceMappingURL=stdin-stream.js.map

package/dist/command-line/input/stdin.d.ts

@@ -0,0 +1,11 @@
+import * as Effect from "effect/Effect";
+import type * as Stream from "effect/Stream";
+import { CliArgumentError } from "./arguments.js";
+export type BoundedStdinRequest = {
+    readonly label: string;
+    readonly maxBytes: number;
+    readonly maxChunks: number;
+};
+export declare const readBoundedStdin: (input: Stream.Stream<string | Uint8Array, unknown>, request: BoundedStdinRequest) => Effect.Effect<string, CliArgumentError>;
+export declare const recoverStdin: <TError>(read: Effect.Effect<string, CliArgumentError>, recover: (error: unknown) => TError) => Effect.Effect<string, TError>;
+//# sourceMappingURL=stdin.d.ts.map

package/dist/command-line/input/stdin.js

@@ -0,0 +1,23 @@
+import { Buffer } from "node:buffer";
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import { CliArgumentError } from "./arguments.js";
+const collectChunk = (request, collected, chunk) => {
+    const buffer = Buffer.from(chunk);
+    const bytes = collected.bytes + buffer.byteLength;
+    if (bytes > request.maxBytes || collected.chunks.length >= request.maxChunks)
+        return Effect.fail(new CliArgumentError(`Standard input exceeds the bounded ${request.label} limit.`));
+    collected.bytes = bytes;
+    collected.chunks.push(buffer);
+    return Effect.succeed(collected);
+};
+const decodeUtf8 = (collected) => Effect.try({
+    catch: () => new CliArgumentError("Standard input must contain valid UTF-8."),
+    try: () => new TextDecoder("utf-8", { fatal: true }).decode(Buffer.concat(collected.chunks, collected.bytes)),
+});
+const loadStreamFold = () => import("./stdin-stream.js");
+export const readBoundedStdin = (input, request) => Effect.promise(loadStreamFold).pipe(Effect.flatMap(({ foldStream }) => foldStream(input, () => ({ bytes: 0, chunks: [] }), (collected, chunk) => collectChunk(request, collected, chunk))), Effect.flatMap(decodeUtf8));
+export const recoverStdin = (read, recover) => read.pipe(Effect.catchCause((cause) => Cause.hasInterruptsOnly(cause)
+    ? Effect.interrupt
+    : Effect.fail(recover(Cause.squash(cause)))));
+//# sourceMappingURL=stdin.js.map

package/dist/command-line/json-decoder.d.ts

@@ -0,0 +1,3 @@
+import * as Schema from "effect/Schema";
+export declare const decodeJson: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<unknown, Schema.SchemaError, never>;
+//# sourceMappingURL=json-decoder.d.ts.map

package/dist/command-line/json-decoder.js

@@ -0,0 +1,3 @@
+import * as Schema from "effect/Schema";
+export const decodeJson = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown));
+//# sourceMappingURL=json-decoder.js.map

package/dist/command-line/json.d.ts

@@ -0,0 +1,3 @@
+import * as Effect from "effect/Effect";
+export declare const decodeJsonText: <TError>(text: string, failure: () => TError) => Effect.Effect<unknown, TError>;
+//# sourceMappingURL=json.d.ts.map

package/dist/command-line/json.js

@@ -0,0 +1,4 @@
+import * as Effect from "effect/Effect";
+const loadDecoder = () => import("./json-decoder.js");
+export const decodeJsonText = (text, failure) => Effect.promise(loadDecoder).pipe(Effect.flatMap((decoder) => decoder.decodeJson(text)), Effect.mapError(failure));
+//# sourceMappingURL=json.js.map