@maiaos/cli 0.1.0-canary.2

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

@@ -0,0 +1,65 @@
+import * as Effect from "effect/Effect";
+export declare const readPortLease: (tokens: readonly string[]) => Effect.Effect<{
+    commandId: string;
+} & ({
+    count?: undefined;
+    preferred?: undefined;
+    sessionId?: undefined;
+    purpose: string;
+} | {
+    count?: undefined;
+    preferred?: undefined;
+    sessionId: string;
+    purpose: string;
+} | {
+    count?: undefined;
+    preferred: number;
+    sessionId?: undefined;
+    purpose: string;
+} | {
+    count?: undefined;
+    preferred: number;
+    sessionId: string;
+    purpose: string;
+} | {
+    count: number;
+    preferred?: undefined;
+    sessionId?: undefined;
+    purpose: string;
+} | {
+    count: number;
+    preferred?: undefined;
+    sessionId: string;
+    purpose: string;
+} | {
+    count: number;
+    preferred: number;
+    sessionId?: undefined;
+    purpose: string;
+} | {
+    count: number;
+    preferred: number;
+    sessionId: string;
+    purpose: string;
+}), never, import("effect/Crypto").Crypto>;
+export declare const readPortRenew: (tokens: readonly string[]) => Effect.Effect<{
+    commandId: string;
+} & {
+    expectedRevision: string;
+    leaseId: string;
+}, never, import("effect/Crypto").Crypto>;
+export declare const readPortRelease: (tokens: readonly string[]) => Effect.Effect<{
+    commandId: string;
+} & {
+    leaseId: string;
+}, never, import("effect/Crypto").Crypto>;
+export declare const readPortList: (tokens: readonly string[]) => Effect.Effect<{
+    sessionId?: undefined;
+    limit: number;
+    afterCursor?: string | undefined;
+} | {
+    sessionId: string;
+    limit: number;
+    afterCursor?: string | undefined;
+}, never, never>;
+//# sourceMappingURL=input.d.ts.map

package/dist/port-lease/input.js

@@ -0,0 +1,67 @@
+import * as Effect from "effect/Effect";
+import { CliArgumentError, parseOptions, readExpectedRevision, readPageSize, requirePositionals, } from "../command-line/index.js";
+import { commandIdentifier } from "../local-node/index.js";
+const withCommandId = (options, input) => Effect.map(commandIdentifier(options.get("--command-id")), (commandId) => ({
+    commandId,
+    ...input,
+}));
+const readCount = (value) => {
+    if (value === undefined)
+        return {};
+    if (!/^[1-8]$/u.test(value))
+        throw new CliArgumentError("Option '--count' must be an integer from 1 to 8.");
+    return { count: Number(value) };
+};
+const readPreferred = (value) => {
+    if (value === undefined)
+        return {};
+    if (!/^[1-9]\d{3,4}$/u.test(value) || Number(value) > 65_535)
+        throw new CliArgumentError("Option '--preferred' must be a port from 1024 to 65535.");
+    return { preferred: Number(value) };
+};
+const readSession = (value) => value === undefined ? {} : { sessionId: value };
+export const readPortLease = (tokens) => {
+    const parsed = parseOptions(tokens, new Set([
+        "--command-id",
+        "--count",
+        "--preferred",
+        "--purpose",
+        "--session",
+    ]));
+    requirePositionals(parsed.positionals, 0);
+    const purpose = parsed.options.get("--purpose");
+    if (purpose === undefined)
+        throw new CliArgumentError("Option '--purpose' is required.");
+    return withCommandId(parsed.options, {
+        purpose,
+        ...readCount(parsed.options.get("--count")),
+        ...readPreferred(parsed.options.get("--preferred")),
+        ...readSession(parsed.options.get("--session")),
+    });
+};
+export const readPortRenew = (tokens) => {
+    const parsed = parseOptions(tokens, new Set(["--command-id", "--expected-revision"]));
+    requirePositionals(parsed.positionals, 1);
+    return withCommandId(parsed.options, {
+        expectedRevision: readExpectedRevision(parsed.options.get("--expected-revision")),
+        leaseId: parsed.positionals[0] ?? "",
+    });
+};
+export const readPortRelease = (tokens) => {
+    const parsed = parseOptions(tokens, new Set(["--command-id"]));
+    requirePositionals(parsed.positionals, 1);
+    return withCommandId(parsed.options, {
+        leaseId: parsed.positionals[0] ?? "",
+    });
+};
+export const readPortList = (tokens) => {
+    const parsed = parseOptions(tokens, new Set(["--after", "--limit", "--session"]));
+    requirePositionals(parsed.positionals, 0);
+    const afterCursor = parsed.options.get("--after");
+    return Effect.succeed({
+        limit: readPageSize(parsed.options.get("--limit")),
+        ...(afterCursor === undefined ? {} : { afterCursor }),
+        ...readSession(parsed.options.get("--session")),
+    });
+};
+//# sourceMappingURL=input.js.map

package/dist/port-lease/output/format.d.ts

@@ -0,0 +1,11 @@
+import type { PortLeaseAcquireResult, PortLeaseListResult, PortLeaseReleaseResult, PortLeaseRenewResult } from "@maiaos/sdk";
+export type PortLeaseCliResult = PortLeaseAcquireResult | PortLeaseListResult | PortLeaseReleaseResult | PortLeaseRenewResult;
+export type CliPortLeaseResult = {
+    readonly command: PortLeaseCliResult["method"];
+    readonly result: PortLeaseCliResult;
+};
+export declare const isPortLeaseResult: (result: {
+    readonly command: string;
+}) => result is CliPortLeaseResult;
+export declare const formatPortLeaseResult: ({ result, }: CliPortLeaseResult) => string;
+//# sourceMappingURL=format.d.ts.map

package/dist/port-lease/output/format.js

@@ -0,0 +1,24 @@
+import { formatRows, withNextPage } from "../../command-line/index.js";
+export const isPortLeaseResult = (result) => result.command.startsWith("port.lease.");
+const ownerText = (owner) => owner.kind === "session" ? `session:${owner.sessionId}` : "self";
+const leaseLine = (lease, ports) => `${lease.leaseId}\t${ports}\t${lease.state}\t${ownerText(lease.owner)}\t${lease.purpose}\trevision=${lease.revision}\texpires=${lease.expiresAt}`;
+const leaseRow = (lease, ports) => `${lease.leaseId}\t${ports}\t${lease.state}\t${ownerText(lease.owner)}\t${lease.purpose}\t${lease.revision}\t${lease.expiresAt}`;
+const probedPorts = (item) => item.probes
+    .map((probe) => `${String(probe.port)}${probe.inUse ? "*" : ""}`)
+    .join(",");
+const formatList = (result) => withNextPage(formatRows(result.items, (item) => leaseRow(item.lease, probedPorts(item)), {
+    empty: `No active port leases in ${String(result.range.start)}-${String(result.range.end)}.`,
+    headers: [
+        "LEASE",
+        "PORTS",
+        "STATE",
+        "OWNER",
+        "PURPOSE",
+        "REVISION",
+        "EXPIRES",
+    ],
+}), result.nextCursor);
+export const formatPortLeaseResult = ({ result, }) => result.method === "port.lease.list"
+    ? formatList(result)
+    : `${leaseLine(result.lease, result.lease.ports.join(","))}\n`;
+//# sourceMappingURL=format.js.map

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

@@ -0,0 +1,2 @@
+export { type CliPortLeaseResult, formatPortLeaseResult, isPortLeaseResult, type PortLeaseCliResult, } from "./format.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/port-lease/output/index.js

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

package/dist/presentation/client.d.ts

@@ -0,0 +1,10 @@
+import { type PresentationCatalogParameters, type PresentationCatalogResult, type PresentationDirectoryParameters, type PresentationDirectoryResult, type PresentationProjectListParameters, type PresentationProjectListResult, type PresentationSessionListParameters, type PresentationSessionListResult } from "@maiaos/sdk";
+import type { CliNodeEffect, CliNodeOperations } from "../local-node/index.js";
+export type PresentationCliDependencies = {
+    readonly showPresentationCatalog: (input: PresentationCatalogParameters) => CliNodeEffect<PresentationCatalogResult>;
+    readonly showProjectList: (input: PresentationProjectListParameters) => CliNodeEffect<PresentationProjectListResult>;
+    readonly showSessionList: (input: PresentationSessionListParameters) => CliNodeEffect<PresentationSessionListResult>;
+    readonly showWorkspaceDirectory: (input: PresentationDirectoryParameters) => CliNodeEffect<PresentationDirectoryResult>;
+};
+export declare const makePresentationClient: (node: CliNodeOperations) => PresentationCliDependencies;
+//# sourceMappingURL=client.d.ts.map

package/dist/presentation/client.js

@@ -0,0 +1,9 @@
+import { presentationCatalogParametersSchema, presentationDirectoryParametersSchema, presentationProjectListParametersSchema, presentationSessionListParametersSchema, } from "@maiaos/sdk";
+const catalog = (node, input) => node.runValidatedNodeOperation(input, presentationCatalogParametersSchema, (client, parameters, options) => client.showPresentationCatalog(parameters, options));
+export const makePresentationClient = (node) => ({
+    showPresentationCatalog: (input) => catalog(node, input),
+    showProjectList: (input) => node.runValidatedNodeOperation(input, presentationProjectListParametersSchema, (client, parameters, options) => client.showProjectList(parameters, options)),
+    showSessionList: (input) => node.runValidatedNodeOperation(input, presentationSessionListParametersSchema, (client, parameters, options) => client.showSessionList(parameters, options)),
+    showWorkspaceDirectory: (input) => node.runValidatedNodeOperation(input, presentationDirectoryParametersSchema, (client, parameters, options) => client.showWorkspaceDirectory(parameters, options)),
+});
+//# sourceMappingURL=client.js.map

package/dist/presentation/commands.d.ts

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

package/dist/presentation/commands.js

@@ -0,0 +1,78 @@
+import { presentationDirectoryParametersSchema, presentationProjectListParametersSchema, presentationSessionListParametersSchema, protocolErrorSchema, } from "@maiaos/sdk";
+import { Effect } from "effect";
+import { CliArgumentError, decodeJsonText, parseOptions, recoverStdin, reportError, requireNoArguments, requirePositionals, writeSuccess, } from "../command-line/index.js";
+import { formatPresentationResult, } from "./output/index.js";
+const invalidInput = () => new CliArgumentError("Invalid presentation input.");
+const readPresentationOptions = (tokens) => {
+    const value = parseOptions(tokens, new Set(), new Set(["--input-stdin"]));
+    requirePositionals(value.positionals, 0);
+    return value;
+};
+const writeResponse = (response, context) => {
+    if (!response.ok) {
+        const error = protocolErrorSchema.parse(response.error);
+        return reportError({ ...error, message: "Presentation operation failed." }, context);
+    }
+    writeSuccess({ command: response.value.method, result: response.value }, context, formatPresentationResult);
+    return 0;
+};
+const readPresentationInput = (tokens, context) => Effect.gen(function* () {
+    const parsed = yield* Effect.try({
+        catch: invalidInput,
+        try: () => readPresentationOptions(tokens),
+    });
+    const stdin = context.io.stdin;
+    if (!parsed.flags.has("--input-stdin") || stdin === undefined)
+        return yield* Effect.fail(invalidInput());
+    const text = yield* recoverStdin(stdin({ label: "presentation input", maxBytes: 8192, maxChunks: 32 }), invalidInput);
+    return yield* decodeJsonText(text, invalidInput);
+});
+const invoke = (operation, parameters, context) => Effect.gen(function* () {
+    if (operation === undefined)
+        return yield* Effect.fail(new Error("Missing presentation client."));
+    const response = yield* Effect.suspend(() => operation(parameters)).pipe(Effect.catchDefect(() => Effect.fail(new Error("Presentation request failed."))));
+    return yield* Effect.try({
+        catch: () => new Error("Invalid presentation result."),
+        try: () => writeResponse(response, context),
+    });
+});
+const catalog = (tokens, context) => Effect.gen(function* () {
+    yield* Effect.try({
+        catch: invalidInput,
+        try: () => {
+            requireNoArguments(tokens, "Presentation catalog");
+        },
+    });
+    return yield* invoke(context.dependencies.showPresentationCatalog, {}, context);
+});
+const readPage = (tokens, context, { operation, schema, }) => Effect.gen(function* () {
+    const input = yield* readPresentationInput(tokens, context);
+    const parameters = yield* Effect.try({
+        catch: invalidInput,
+        try: () => schema.parse(input),
+    });
+    return yield* invoke(operation, parameters, context);
+});
+const reportFailure = (context) => (error) => Effect.sync(() => reportError({
+    code: error instanceof CliArgumentError
+        ? "invalid_argument"
+        : "internal_error",
+    message: error instanceof CliArgumentError
+        ? error.message
+        : "Presentation command failed.",
+    retryable: false,
+}, context));
+export const runCatalogShow = (tokens, context) => catalog(tokens, context).pipe(Effect.catch(reportFailure(context)));
+export const runWorkspaceDirectoryShow = (tokens, context) => readPage(tokens, context, {
+    operation: context.dependencies.showWorkspaceDirectory,
+    schema: presentationDirectoryParametersSchema,
+}).pipe(Effect.catch(reportFailure(context)));
+export const runProjectListShow = (tokens, context) => readPage(tokens, context, {
+    operation: context.dependencies.showProjectList,
+    schema: presentationProjectListParametersSchema,
+}).pipe(Effect.catch(reportFailure(context)));
+export const runSessionListShow = (tokens, context) => readPage(tokens, context, {
+    operation: context.dependencies.showSessionList,
+    schema: presentationSessionListParametersSchema,
+}).pipe(Effect.catch(reportFailure(context)));
+//# sourceMappingURL=commands.js.map

package/dist/presentation/index.d.ts

@@ -0,0 +1,4 @@
+export type { PresentationCliDependencies } from "./client.js";
+export { makePresentationClient } from "./client.js";
+export { runCatalogShow, runProjectListShow, runSessionListShow, runWorkspaceDirectoryShow, } from "./commands.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/presentation/index.js

@@ -0,0 +1,3 @@
+export { makePresentationClient } from "./client.js";
+export { runCatalogShow, runProjectListShow, runSessionListShow, runWorkspaceDirectoryShow, } from "./commands.js";
+//# sourceMappingURL=index.js.map

package/dist/presentation/output/format.d.ts

@@ -0,0 +1,11 @@
+import type { PresentationCatalogResult, PresentationDirectoryResult, PresentationProjectListResult, PresentationSessionListResult } from "@maiaos/sdk";
+export type PresentationResult = PresentationCatalogResult | PresentationDirectoryResult | PresentationProjectListResult | PresentationSessionListResult;
+export type CliPresentationResult = {
+    readonly command: PresentationResult["method"];
+    readonly result: PresentationResult;
+};
+export declare const isPresentationResult: (result: {
+    readonly command: string;
+}) => result is CliPresentationResult;
+export declare const formatPresentationResult: ({ result, }: CliPresentationResult) => string;
+//# sourceMappingURL=format.d.ts.map

package/dist/presentation/output/format.js

@@ -0,0 +1,32 @@
+export const isPresentationResult = (result) => result.command === "presentation.catalog.show" ||
+    result.command === "presentation.workspace-directory.show" ||
+    result.command === "presentation.project-list.show" ||
+    result.command === "presentation.session-list.show";
+const cell = (value) => JSON.stringify(value).replaceAll(/\p{Control}/gu, " ");
+const page = (result) => {
+    if (result.method === "presentation.session-list.show")
+        return {
+            heading: "Sessions",
+            rows: result.resources.items
+                .map((item) => `${item.id}\t${item.state}\t${item.revision}\n`)
+                .join(""),
+        };
+    const items = result.method === "presentation.project-list.show"
+        ? result.resources.projects
+        : result.resources.items;
+    return {
+        heading: result.method === "presentation.project-list.show"
+            ? "Projects"
+            : "Workspace directory",
+        rows: items
+            .map((item) => `${item.id}\t${cell(item.name)}\t${item.revision}\n`)
+            .join(""),
+    };
+};
+export const formatPresentationResult = ({ result, }) => {
+    if (result.method === "presentation.catalog.show")
+        return `${result.catalogVersion}\t${result.catalogDigest}\toperator-local\n`;
+    const { heading, rows } = page(result);
+    return `${heading} (operator-local)\n${rows}${result.resources.nextCursor === undefined ? "" : `Next: ${cell(result.resources.nextCursor)}\n`}`;
+};
+//# sourceMappingURL=format.js.map

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

@@ -0,0 +1,3 @@
+export type { CliPresentationResult, PresentationResult } from "./format.js";
+export { formatPresentationResult, isPresentationResult } from "./format.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/presentation/output/index.js

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

package/dist/project-guard/client.d.ts

@@ -0,0 +1,88 @@
+import { type ProjectGuardConfirmParameters, type ProjectGuardPreviewParameters, type ProjectGuardShowParameters } from "@maiaos/sdk";
+import type { CliNodeOperations } from "../local-node/index.js";
+export declare const makeProjectGuardClient: (node: CliNodeOperations) => {
+    confirmProjectGuard: (input: ProjectGuardConfirmParameters) => import("../local-node/client.js").CliNodeEffect<{
+        readonly commandId: string;
+        readonly delivery: "duplicate" | "new";
+        readonly expectedRevision: string;
+        readonly guard: {
+            readonly limits: {
+                readonly maxDepth: number;
+                readonly maxLeasesPerSession: number;
+                readonly maxLiveChildren: number;
+                readonly maxMessagesPerMinute: number;
+            };
+            readonly projectId: string;
+            readonly revision: string;
+            readonly schemaVersion: "maia.session-guard/v1";
+            readonly source: "default" | "project";
+            readonly updatedAt?: string | undefined;
+        };
+        readonly inputDigest: string;
+        readonly method: "project.guard.confirm";
+        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;
+        };
+    }>;
+    previewProjectGuard: (input: ProjectGuardPreviewParameters) => import("../local-node/client.js").CliNodeEffect<{
+        readonly inputDigest: string;
+        readonly proof: string;
+        readonly actorId: string;
+        readonly commandId: string;
+        readonly current: {
+            readonly limits: {
+                readonly maxDepth: number;
+                readonly maxLeasesPerSession: number;
+                readonly maxLiveChildren: number;
+                readonly maxMessagesPerMinute: number;
+            };
+            readonly projectId: string;
+            readonly revision: string;
+            readonly schemaVersion: "maia.session-guard/v1";
+            readonly source: "default" | "project";
+            readonly updatedAt?: string | undefined;
+        };
+        readonly expectedRevision: string;
+        readonly expiresAt: string;
+        readonly issuedAt: string;
+        readonly limits: {
+            readonly maxDepth: number;
+            readonly maxLeasesPerSession: number;
+            readonly maxLiveChildren: number;
+            readonly maxMessagesPerMinute: number;
+        };
+        readonly method: "project.guard.preview";
+        readonly projectId: string;
+    }>;
+    showProjectGuard: (input: ProjectGuardShowParameters) => import("../local-node/client.js").CliNodeEffect<{
+        readonly guard: {
+            readonly limits: {
+                readonly maxDepth: number;
+                readonly maxLeasesPerSession: number;
+                readonly maxLiveChildren: number;
+                readonly maxMessagesPerMinute: number;
+            };
+            readonly projectId: string;
+            readonly revision: string;
+            readonly schemaVersion: "maia.session-guard/v1";
+            readonly source: "default" | "project";
+            readonly updatedAt?: string | undefined;
+        };
+        readonly method: "project.guard.show";
+    }>;
+};
+export type ProjectGuardCliDependencies = ReturnType<typeof makeProjectGuardClient>;
+//# sourceMappingURL=client.d.ts.map

package/dist/project-guard/client.js

@@ -0,0 +1,7 @@
+import { projectGuardConfirmParametersSchema, projectGuardPreviewParametersSchema, projectGuardShowParametersSchema, } from "@maiaos/sdk";
+export const makeProjectGuardClient = (node) => ({
+    confirmProjectGuard: (input) => node.runValidatedNodeOperation(input, projectGuardConfirmParametersSchema, (client, parameters, options) => client.confirmProjectGuard(parameters, options), { commandId: input.commandId }),
+    previewProjectGuard: (input) => node.runValidatedNodeOperation(input, projectGuardPreviewParametersSchema, (client, parameters, options) => client.previewProjectGuard(parameters, options)),
+    showProjectGuard: (input) => node.runValidatedNodeOperation(input, projectGuardShowParametersSchema, (client, parameters, options) => client.showProjectGuard(parameters, options)),
+});
+//# sourceMappingURL=client.js.map

package/dist/project-guard/commands.d.ts

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

package/dist/project-guard/commands.js

@@ -0,0 +1,39 @@
+import { projectGuardConfirmParametersSchema, } from "@maiaos/sdk";
+import * as Effect from "effect/Effect";
+import { CliArgumentError, confirmParameters, parseOptions, readTwoPhaseMode, requirePositionals, runTwoPhase, TWO_PHASE_FLAGS, writeNodeResult, } from "../command-line/index.js";
+import { GUARD_OPTIONS, readGuardPreview, readGuardShow } from "./input.js";
+import { formatProjectGuardResult, } from "./output/index.js";
+const write = (context) => (result) => writeNodeResult(result, context, {
+    toResult: (value) => ({ command: value.method, result: value }),
+    toText: formatProjectGuardResult,
+});
+export const runProjectGuardShow = (tokens, context) => Effect.gen(function* () {
+    const show = context.dependencies.showProjectGuard;
+    if (show === undefined)
+        return yield* Effect.die(new Error("Missing Project guard client."));
+    return write(context)(yield* show(readGuardShow(tokens)));
+});
+const confirmGuardParameters = (preview) => confirmParameters(projectGuardConfirmParametersSchema, preview, ["current"]);
+const GUARD_PROMPT = {
+    describe: (preview) => formatProjectGuardResult({ command: preview.method, result: preview }),
+    question: "Set these guards?",
+};
+export const runProjectGuardSet = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, GUARD_OPTIONS, new Set(TWO_PHASE_FLAGS));
+    const mode = readTwoPhaseMode(parsed.flags, context);
+    if (mode === "confirm-stdin")
+        requirePositionals(parsed.positionals, 0);
+    const { confirmProjectGuard, previewProjectGuard } = context.dependencies;
+    if (confirmProjectGuard === undefined || previewProjectGuard === undefined)
+        return yield* new CliArgumentError("Project guards are unavailable.");
+    return yield* runTwoPhase({
+        confirm: (preview) => Effect.flatMap(confirmGuardParameters(preview), confirmProjectGuard),
+        context,
+        mode,
+        preview: () => Effect.flatMap(readGuardPreview(parsed), previewProjectGuard),
+        prompt: GUARD_PROMPT,
+        writeConfirm: write(context),
+        writePreview: write(context),
+    });
+});
+//# sourceMappingURL=commands.js.map

package/dist/project-guard/index.d.ts

@@ -0,0 +1,3 @@
+export { makeProjectGuardClient, type ProjectGuardCliDependencies, } from "./client.js";
+export { runProjectGuardSet, runProjectGuardShow } from "./commands.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/project-guard/index.js

@@ -0,0 +1,3 @@
+export { makeProjectGuardClient, } from "./client.js";
+export { runProjectGuardSet, runProjectGuardShow } from "./commands.js";
+//# sourceMappingURL=index.js.map

package/dist/project-guard/input.d.ts

@@ -0,0 +1,18 @@
+import * as Effect from "effect/Effect";
+import { type ParsedOptions } from "../command-line/index.js";
+export declare const readGuardShow: (tokens: readonly string[]) => {
+    projectId: string;
+};
+export declare const GUARD_OPTIONS: ReadonlySet<string>;
+export declare const readGuardPreview: (parsed: ParsedOptions) => Effect.Effect<{
+    commandId: string;
+    expectedRevision: string;
+    limits: {
+        readonly maxDepth: number;
+        readonly maxLeasesPerSession: number;
+        readonly maxLiveChildren: number;
+        readonly maxMessagesPerMinute: number;
+    };
+    projectId: string;
+}, never, import("effect/Crypto").Crypto>;
+//# sourceMappingURL=input.d.ts.map

package/dist/project-guard/input.js

@@ -0,0 +1,47 @@
+import { SESSION_GUARD_BOUNDS } from "@maiaos/sdk";
+import * as Effect from "effect/Effect";
+import { CliArgumentError, parseOptions, readExpectedRevision, requirePositionals, } from "../command-line/index.js";
+import { commandIdentifier } from "../local-node/index.js";
+const LIMIT_OPTIONS = {
+    maxDepth: "--max-depth",
+    maxLeasesPerSession: "--max-leases-per-session",
+    maxLiveChildren: "--max-live-children",
+    maxMessagesPerMinute: "--max-messages-per-minute",
+};
+const readLimit = (options, limit) => {
+    const option = LIMIT_OPTIONS[limit];
+    const value = options.get(option) ?? "";
+    const { maximum, minimum } = SESSION_GUARD_BOUNDS[limit];
+    const parsed = /^\d{1,4}$/u.test(value) ? Number(value) : 0;
+    if (parsed < minimum || parsed > maximum)
+        throw new CliArgumentError(`Option '${option}' must be an integer from ${String(minimum)} to ${String(maximum)}.`);
+    return parsed;
+};
+const readLimits = (options) => ({
+    maxDepth: readLimit(options, "maxDepth"),
+    maxLeasesPerSession: readLimit(options, "maxLeasesPerSession"),
+    maxLiveChildren: readLimit(options, "maxLiveChildren"),
+    maxMessagesPerMinute: readLimit(options, "maxMessagesPerMinute"),
+});
+export const readGuardShow = (tokens) => {
+    const parsed = parseOptions(tokens, new Set());
+    requirePositionals(parsed.positionals, 1);
+    return { projectId: parsed.positionals[0] ?? "" };
+};
+export const GUARD_OPTIONS = new Set([
+    "--command-id",
+    "--expected-revision",
+    ...Object.values(LIMIT_OPTIONS),
+]);
+export const readGuardPreview = (parsed) => {
+    requirePositionals(parsed.positionals, 1);
+    const expectedRevision = readExpectedRevision(parsed.options.get("--expected-revision"));
+    const limits = readLimits(parsed.options);
+    return Effect.map(commandIdentifier(parsed.options.get("--command-id")), (commandId) => ({
+        commandId,
+        expectedRevision,
+        limits,
+        projectId: parsed.positionals[0] ?? "",
+    }));
+};
+//# sourceMappingURL=input.js.map

package/dist/project-guard/output/format.d.ts

@@ -0,0 +1,11 @@
+import type { ProjectGuardConfirmResult, ProjectGuardPreviewResult, ProjectGuardShowResult } from "@maiaos/sdk";
+export type ProjectGuardResult = ProjectGuardConfirmResult | ProjectGuardPreviewResult | ProjectGuardShowResult;
+export type CliProjectGuardResult = {
+    readonly command: ProjectGuardResult["method"];
+    readonly result: ProjectGuardResult;
+};
+export declare const isProjectGuardResult: (result: {
+    readonly command: string;
+}) => result is CliProjectGuardResult;
+export declare const formatProjectGuardResult: ({ result, }: CliProjectGuardResult) => string;
+//# sourceMappingURL=format.d.ts.map

package/dist/project-guard/output/format.js

@@ -0,0 +1,35 @@
+export const isProjectGuardResult = (result) => result.command.startsWith("project.guard.");
+const limitCells = (limits) => [
+    `maxDepth=${String(limits.maxDepth)}`,
+    `maxLiveChildren=${String(limits.maxLiveChildren)}`,
+    `maxMessagesPerMinute=${String(limits.maxMessagesPerMinute)}`,
+    `maxLeasesPerSession=${String(limits.maxLeasesPerSession)}`,
+];
+const guardLine = (guard) => [
+    guard.projectId,
+    `source=${guard.source}`,
+    `revision=${guard.revision}`,
+    ...limitCells(guard.limits),
+].join("\t");
+const previewLines = (result) => [
+    `${guardLine(result.current)}\tcurrent`,
+    [
+        result.projectId,
+        "proposed",
+        ...limitCells(result.limits),
+        `command=${result.commandId}`,
+        `expires=${result.expiresAt}`,
+    ].join("\t"),
+].join("\n");
+const formatLines = (result) => {
+    switch (result.method) {
+        case "project.guard.show":
+            return guardLine(result.guard);
+        case "project.guard.preview":
+            return previewLines(result);
+        case "project.guard.confirm":
+            return `${guardLine(result.guard)}\t${result.receipt.receiptId}\t${result.delivery}`;
+    }
+};
+export const formatProjectGuardResult = ({ result, }) => `${formatLines(result)}\n`;
+//# sourceMappingURL=format.js.map

package/dist/project-guard/output/index.d.ts

@@ -0,0 +1,2 @@
+export { type CliProjectGuardResult, formatProjectGuardResult, isProjectGuardResult, type ProjectGuardResult, } from "./format.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/project-guard/output/index.js

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