@maiaos/cli 0.1.0-canary.2

package/dist/hold/client.d.ts

@@ -0,0 +1,137 @@
+import { type HoldListParameters, type HoldPlaceConfirmParameters, type HoldPlacePreviewParameters, type HoldReleaseConfirmParameters, type HoldReleasePreviewParameters } from "@maiaos/sdk";
+import type { CliNodeOperations } from "../local-node/index.js";
+export declare const makeHoldClient: (node: CliNodeOperations) => {
+    confirmHoldPlace: (input: HoldPlaceConfirmParameters) => import("../local-node/client.js").CliNodeEffect<{
+        readonly actorId: string;
+        readonly commandId: string;
+        readonly delivery: "duplicate" | "new";
+        readonly hold: {
+            readonly createdAt: string;
+            readonly id: string;
+            readonly reason: string;
+            readonly revision: string;
+            readonly running: "keep" | "stop";
+            readonly schemaVersion: "maia.hold/v1";
+            readonly state: "active" | "released";
+            readonly targets: readonly {
+                readonly id: string;
+                readonly kind: "connection" | "project";
+            }[];
+            readonly updatedAt: string;
+        };
+        readonly inputDigest: string;
+        readonly receipt: {
+            readonly actorId: string;
+            readonly aggregateRevision: string;
+            readonly commandId: string;
+            readonly createdAt: string;
+            readonly eventCursor: string;
+            readonly method: string;
+            readonly receiptId: string;
+            readonly schemaVersion: 1;
+            readonly state: "succeeded";
+            readonly target: {
+                readonly id: string;
+                readonly type: string;
+            };
+            readonly updatedAt: string;
+        };
+        readonly method: "hold.place.confirm";
+        readonly stoppedSessionIds: readonly string[];
+    }>;
+    confirmHoldRelease: (input: HoldReleaseConfirmParameters) => import("../local-node/client.js").CliNodeEffect<{
+        readonly actorId: string;
+        readonly commandId: string;
+        readonly delivery: "duplicate" | "new";
+        readonly hold: {
+            readonly createdAt: string;
+            readonly id: string;
+            readonly reason: string;
+            readonly revision: string;
+            readonly running: "keep" | "stop";
+            readonly schemaVersion: "maia.hold/v1";
+            readonly state: "active" | "released";
+            readonly targets: readonly {
+                readonly id: string;
+                readonly kind: "connection" | "project";
+            }[];
+            readonly updatedAt: string;
+        };
+        readonly inputDigest: string;
+        readonly receipt: {
+            readonly actorId: string;
+            readonly aggregateRevision: string;
+            readonly commandId: string;
+            readonly createdAt: string;
+            readonly eventCursor: string;
+            readonly method: string;
+            readonly receiptId: string;
+            readonly schemaVersion: 1;
+            readonly state: "succeeded";
+            readonly target: {
+                readonly id: string;
+                readonly type: string;
+            };
+            readonly updatedAt: string;
+        };
+        readonly expectedRevision: string;
+        readonly method: "hold.release.confirm";
+    }>;
+    listHolds: (input: HoldListParameters) => import("../local-node/client.js").CliNodeEffect<{
+        readonly items: readonly {
+            readonly createdAt: string;
+            readonly id: string;
+            readonly reason: string;
+            readonly revision: string;
+            readonly running: "keep" | "stop";
+            readonly schemaVersion: "maia.hold/v1";
+            readonly state: "active" | "released";
+            readonly targets: readonly {
+                readonly id: string;
+                readonly kind: "connection" | "project";
+            }[];
+            readonly updatedAt: string;
+        }[];
+        readonly method: "hold.list";
+        readonly nextCursor?: string | undefined;
+    }>;
+    previewHoldPlace: (input: HoldPlacePreviewParameters) => import("../local-node/client.js").CliNodeEffect<{
+        readonly commandId: string;
+        readonly reason: string;
+        readonly running: "keep" | "stop";
+        readonly targets: readonly {
+            readonly id: string;
+            readonly kind: "connection" | "project";
+        }[];
+        readonly inputDigest: string;
+        readonly proof: string;
+        readonly actorId: string;
+        readonly expiresAt: string;
+        readonly issuedAt: string;
+        readonly holdId: string;
+        readonly method: "hold.place.preview";
+        readonly sessions: readonly {
+            readonly connectionId?: string | undefined;
+            readonly projectId: string;
+            readonly sessionId: string;
+            readonly state: "recovering" | "running" | "starting";
+        }[];
+    }>;
+    previewHoldRelease: (input: HoldReleasePreviewParameters) => import("../local-node/client.js").CliNodeEffect<{
+        readonly commandId: string;
+        readonly expectedRevision: string;
+        readonly holdId: string;
+        readonly inputDigest: string;
+        readonly proof: string;
+        readonly actorId: string;
+        readonly expiresAt: string;
+        readonly issuedAt: string;
+        readonly method: "hold.release.preview";
+        readonly targets: readonly {
+            readonly id: string;
+            readonly kind: "connection" | "project";
+        }[];
+    }>;
+};
+export type HoldCliDependencies = ReturnType<typeof makeHoldClient>;
+//# sourceMappingURL=client.d.ts.map

package/dist/hold/client.js

@@ -0,0 +1,12 @@
+import { holdListParametersSchema, holdPlaceConfirmParametersSchema, holdPlacePreviewParametersSchema, holdReleaseConfirmParametersSchema, holdReleasePreviewParametersSchema, } from "@maiaos/sdk";
+const makeHoldConfirmationClient = (node) => ({
+    confirmHoldPlace: (input) => node.runValidatedNodeOperation(input, holdPlaceConfirmParametersSchema, (client, parameters, options) => client.confirmHoldPlace(parameters, options), { commandId: input.commandId }),
+    confirmHoldRelease: (input) => node.runValidatedNodeOperation(input, holdReleaseConfirmParametersSchema, (client, parameters, options) => client.confirmHoldRelease(parameters, options), { commandId: input.commandId }),
+});
+export const makeHoldClient = (node) => ({
+    ...makeHoldConfirmationClient(node),
+    listHolds: (input) => node.runValidatedNodeOperation(input, holdListParametersSchema, (client, parameters, options) => client.listHolds(parameters, options)),
+    previewHoldPlace: (input) => node.runValidatedNodeOperation(input, holdPlacePreviewParametersSchema, (client, parameters, options) => client.previewHoldPlace(parameters, options)),
+    previewHoldRelease: (input) => node.runValidatedNodeOperation(input, holdReleasePreviewParametersSchema, (client, parameters, options) => client.previewHoldRelease(parameters, options)),
+});
+//# sourceMappingURL=client.js.map

package/dist/hold/commands.d.ts

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

package/dist/hold/commands.js

@@ -0,0 +1,91 @@
+import { holdListParametersSchema, holdPlaceConfirmParametersSchema, holdPlacePreviewParametersSchema, holdReleaseConfirmParametersSchema, holdReleasePreviewParametersSchema, protocolErrorSchema, } from "@maiaos/sdk";
+import { Effect } from "effect";
+import { CliArgumentError, parseOptions, readPageSize, reportError, requirePositionals, runInputTwoPhase, writeSuccess, } from "../command-line/index.js";
+import { formatHoldResult } from "./output/index.js";
+const invalidInput = () => new CliArgumentError("Invalid hold operation input.");
+const readList = (tokens) => {
+    const parsed = parseOptions(tokens, new Set(["--after", "--limit", "--state"]));
+    requirePositionals(parsed.positionals, 0);
+    const afterCursor = parsed.options.get("--after");
+    const state = parsed.options.get("--state");
+    if (state !== undefined && state !== "active" && state !== "released")
+        throw new CliArgumentError("Option '--state' must be 'active' or 'released'.");
+    return {
+        ...(afterCursor === undefined ? {} : { afterCursor }),
+        limit: readPageSize(parsed.options.get("--limit")),
+        ...(state === undefined ? {} : { state }),
+    };
+};
+const recoveryFor = (code, parameters) => code === "outcome_unknown" &&
+    typeof parameters === "object" &&
+    parameters !== null &&
+    "commandId" in parameters &&
+    "proof" in parameters &&
+    typeof parameters.commandId === "string"
+    ? { recovery: { commandId: parameters.commandId } }
+    : {};
+const writeResponse = (response, parameters, context) => {
+    if (!response.ok) {
+        const error = protocolErrorSchema.parse(response.error);
+        return reportError(error, {
+            ...context,
+            ...(response.recovery === undefined
+                ? recoveryFor(error.code, parameters)
+                : { recovery: response.recovery }),
+        });
+    }
+    writeSuccess({ command: response.value.method, result: response.value }, context, formatHoldResult);
+    return 0;
+};
+const invoke = (spec, context) => Effect.gen(function* () {
+    const input = yield* spec.input;
+    const parameters = yield* Effect.try({
+        catch: invalidInput,
+        try: () => spec.parameters.parse(input),
+    });
+    const operation = spec.operation;
+    if (operation === undefined)
+        return yield* Effect.fail(new Error("Missing hold client."));
+    const response = yield* Effect.suspend(() => operation(parameters)).pipe(Effect.catchDefect(() => Effect.fail(new Error("Hold request failed."))));
+    return yield* Effect.try({
+        catch: () => new Error("Invalid hold result."),
+        try: () => writeResponse(response, parameters, context),
+    });
+});
+const reportFailure = (context) => (error) => Effect.sync(() => reportError({
+    code: error instanceof CliArgumentError
+        ? "invalid_argument"
+        : "internal_error",
+    message: error instanceof CliArgumentError
+        ? error.message
+        : "Hold command failed.",
+    retryable: false,
+}, context));
+export const runHoldList = (tokens, context) => Effect.suspend(() => invoke({
+    input: Effect.succeed(readList(tokens)),
+    operation: context.dependencies.listHolds,
+    parameters: holdListParametersSchema,
+}, context)).pipe(Effect.catch(reportFailure(context)));
+export const runHoldPlace = (tokens, context) => runInputTwoPhase({
+    confirm: context.dependencies.confirmHoldPlace,
+    confirmSchema: holdPlaceConfirmParametersSchema,
+    context,
+    label: "hold input",
+    preview: context.dependencies.previewHoldPlace,
+    previewOnly: ["holdId", "sessions"],
+    previewSchema: holdPlacePreviewParametersSchema,
+    tokens,
+    write: (result) => writeResponse(result, undefined, context),
+}).pipe(Effect.catch(reportFailure(context)));
+export const runHoldRelease = (tokens, context) => runInputTwoPhase({
+    confirm: context.dependencies.confirmHoldRelease,
+    confirmSchema: holdReleaseConfirmParametersSchema,
+    context,
+    label: "hold input",
+    preview: context.dependencies.previewHoldRelease,
+    previewOnly: ["targets"],
+    previewSchema: holdReleasePreviewParametersSchema,
+    tokens,
+    write: (result) => writeResponse(result, undefined, context),
+}).pipe(Effect.catch(reportFailure(context)));
+//# sourceMappingURL=commands.js.map

package/dist/hold/index.d.ts

@@ -0,0 +1,3 @@
+export { type HoldCliDependencies, makeHoldClient } from "./client.js";
+export { runHoldList, runHoldPlace, runHoldRelease } from "./commands.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/hold/index.js

@@ -0,0 +1,3 @@
+export { makeHoldClient } from "./client.js";
+export { runHoldList, runHoldPlace, runHoldRelease } from "./commands.js";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,11 @@
+import type { HoldListResult, HoldPlaceConfirmResult, HoldPlacePreviewResult, HoldReleaseConfirmResult, HoldReleasePreviewResult } from "@maiaos/sdk";
+export type HoldResult = HoldListResult | HoldPlaceConfirmResult | HoldPlacePreviewResult | HoldReleaseConfirmResult | HoldReleasePreviewResult;
+export type CliHoldResult = {
+    readonly command: HoldResult["method"];
+    readonly result: HoldResult;
+};
+export declare const isHoldResult: (result: {
+    readonly command: string;
+}) => result is CliHoldResult;
+export declare const formatHoldResult: ({ result }: CliHoldResult) => string;
+//# sourceMappingURL=format.d.ts.map

package/dist/hold/output/format.js

@@ -0,0 +1,29 @@
+import { formatRows } from "../../command-line/index.js";
+export const isHoldResult = (result) => result.command.startsWith("hold.");
+const cell = (value) => Array.from(value, (character) => {
+    const point = character.codePointAt(0) ?? 0;
+    return point < 32 || (point >= 127 && point <= 159) ? " " : character;
+}).join("");
+const targetList = (targets) => targets.map((target) => `${target.kind}:${target.id}`).join(",");
+export const formatHoldResult = ({ result }) => {
+    switch (result.method) {
+        case "hold.list":
+            return formatRows(result.items, (hold) => `${hold.id}\t${hold.state}\t${hold.running}\t${targetList(hold.targets)}\t${cell(hold.reason)}`, {
+                empty: "No holds.",
+                headers: ["HOLD", "STATE", "RUNNING", "TARGETS", "REASON"],
+            });
+        case "hold.place.preview":
+            return `${result.holdId}\t${result.running}\t${targetList(result.targets)}\t${result.expiresAt}\n${result.sessions
+                .map((session) => `session\t${session.sessionId}\t${session.state}\n`)
+                .join("")}`;
+        case "hold.place.confirm":
+            return `${result.hold.id}\t${result.hold.state}\t${result.hold.running}\t${result.receipt.receiptId}\t${result.delivery}\n${result.stoppedSessionIds
+                .map((sessionId) => `stopped\t${sessionId}\n`)
+                .join("")}`;
+        case "hold.release.preview":
+            return `${result.holdId}\t${result.expectedRevision}\t${targetList(result.targets)}\t${result.expiresAt}\n`;
+        case "hold.release.confirm":
+            return `${result.hold.id}\t${result.hold.state}\t${result.hold.revision}\t${result.receipt.receiptId}\t${result.delivery}\n`;
+    }
+};
+//# sourceMappingURL=format.js.map

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

@@ -0,0 +1,2 @@
+export { type CliHoldResult, formatHoldResult, type HoldResult, isHoldResult, } from "./format.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/hold/output/index.js

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

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

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

package/dist/hold/tree/index.js

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

package/dist/hold/tree/tree.d.ts

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

package/dist/hold/tree/tree.js

@@ -0,0 +1,96 @@
+const hold = () => import("../index.js");
+const receipt = () => import("../../command-receipt/index.js");
+const context = () => import("../../context/index.js");
+const port = () => import("../../port-lease/index.js");
+export const SAFETY_TREE = {
+    groups: [
+        ["hold", "Emergency holds on exact Projects and accounts."],
+        ["receipt", "Outcomes of mutations by command ID."],
+        ["context", "The Node or attached Session context."],
+        ["port", "Advisory loopback ports."],
+        ["port lease", "Port leases for a Session."],
+    ],
+    leaves: [
+        [
+            "hold list [--state <active|released>] [--limit <1..100>] [--after <cursor>]",
+            1,
+            "hold.list",
+            "List emergency holds.",
+            { run: [hold, "runHoldList"] },
+        ],
+        [
+            "hold place (--input-stdin --dry-run | --confirm-stdin)",
+            1,
+            ["hold.place.preview", "hold.place.confirm"],
+            "Place an emergency hold after a preview.",
+            {
+                example: "maia --json hold place --input-stdin --dry-run",
+                kind: "two-phase",
+                run: [hold, "runHoldPlace"],
+            },
+        ],
+        [
+            "hold release (--input-stdin --dry-run | --confirm-stdin)",
+            1,
+            ["hold.release.preview", "hold.release.confirm"],
+            "Release a hold after a preview.",
+            { kind: "two-phase", run: [hold, "runHoldRelease"] },
+        ],
+        [
+            "receipt list [--limit <1..32>] [--after <cursor>] [--actor <actor-id>] [--method <method>] [--since <recorded-at>] [--until <recorded-at>]",
+            0,
+            "receipt.list",
+            "List mutation receipts.",
+            { run: [receipt, "runReceiptList"] },
+        ],
+        [
+            "receipt show <command-id>",
+            0,
+            "receipt.get",
+            "Show the receipt of one command ID.",
+            {
+                example: "maia --json receipt show create-1",
+                run: [receipt, "runReceiptShow"],
+            },
+        ],
+        [
+            "context show [--attached]",
+            1,
+            "context.show",
+            "Show the Node's current context, or the attached Session's.",
+            { run: [context, "runContextShow"] },
+        ],
+        [
+            "port lease acquire --purpose <label> [--session <session-id>] [--count <1..8>] [--preferred <port>] [--command-id <id>]",
+            1,
+            "port.lease.acquire",
+            "Lease loopback ports for a Session.",
+            {
+                example: "maia --json port lease acquire --purpose dev-server --command-id lease-1",
+                run: [port, "runPortLeaseAcquire"],
+            },
+        ],
+        [
+            "port lease renew <lease-id> --expected-revision <revision> [--command-id <id>]",
+            1,
+            "port.lease.renew",
+            "Renew a port lease.",
+            { run: [port, "runPortLeaseRenew"] },
+        ],
+        [
+            "port lease release <lease-id> [--command-id <id>]",
+            1,
+            "port.lease.release",
+            "Release a port lease.",
+            { run: [port, "runPortLeaseRelease"] },
+        ],
+        [
+            "port lease list [--session <session-id>] [--limit <1..100>] [--after <cursor>]",
+            1,
+            "port.lease.list",
+            "List port leases.",
+            { run: [port, "runPortLeaseList"] },
+        ],
+    ],
+};
+//# sourceMappingURL=tree.js.map

package/dist/import/client.d.ts

@@ -0,0 +1,14 @@
+import { type DiscoverySessionsListParameters, type DiscoverySessionsListResult, type SessionAdoptConfirmResult, type SessionAdoptPreviewParameters, type SessionAdoptPreviewResult, type SessionHistoryReadParameters, type SessionHistoryReadResult } from "@maiaos/sdk";
+import { type CliNodeEffect, type CliNodeOperations } from "../local-node/index.js";
+type AdoptInput = Omit<SessionAdoptPreviewParameters, "commandId"> & {
+    readonly commandId?: string;
+};
+export declare const makeDiscoveryClient: (node: CliNodeOperations) => {
+    previewSessionAdopt: (input: AdoptInput) => CliNodeEffect<SessionAdoptPreviewResult>;
+    confirmSessionAdopt: (previewId: string) => CliNodeEffect<SessionAdoptConfirmResult>;
+    listDiscoveredSessions: (input: DiscoverySessionsListParameters) => CliNodeEffect<DiscoverySessionsListResult>;
+    readSessionHistory: (input: SessionHistoryReadParameters) => CliNodeEffect<SessionHistoryReadResult>;
+};
+export type DiscoveryCliDependencies = ReturnType<typeof makeDiscoveryClient>;
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/import/client.js

@@ -0,0 +1,16 @@
+import { discoverySessionsListParametersSchema, sessionAdoptConfirmParametersSchema, sessionAdoptPreviewParametersSchema, sessionHistoryReadParametersSchema, } from "@maiaos/sdk";
+import * as Effect from "effect/Effect";
+import { commandIdentifier, } from "../local-node/index.js";
+const makePreviewClient = (node) => ({
+    previewSessionAdopt: (input) => Effect.flatMap(commandIdentifier(input.commandId), (commandId) => node.runValidatedNodeOperation({ ...input, commandId }, sessionAdoptPreviewParametersSchema, (client, parameters, options) => client.previewSessionAdopt(parameters, options))),
+});
+const makeConfirmClient = (node) => ({
+    confirmSessionAdopt: (previewId) => node.runValidatedNodeOperation({ previewId }, sessionAdoptConfirmParametersSchema, (client, parameters, options) => client.confirmSessionAdopt(parameters, options)),
+});
+export const makeDiscoveryClient = (node) => ({
+    ...makePreviewClient(node),
+    ...makeConfirmClient(node),
+    listDiscoveredSessions: (input) => node.runValidatedNodeOperation(input, discoverySessionsListParametersSchema, (client, parameters, options) => client.listDiscoveredSessions(parameters, options)),
+    readSessionHistory: (input) => node.runValidatedNodeOperation(input, sessionHistoryReadParametersSchema, (client, parameters, options) => client.readSessionHistory(parameters, options)),
+});
+//# sourceMappingURL=client.js.map

package/dist/import/commands.d.ts

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

package/dist/import/commands.js

@@ -0,0 +1,76 @@
+import { Effect } from "effect";
+import { CliArgumentError, parseOptions, readTwoPhaseMode, reportError, requirePositionals, runTwoPhase, TWO_PHASE_FLAGS, } from "../command-line/index.js";
+import { readAdopt, readHistory, readScan } from "./input.js";
+import { formatAdoptConfirm, formatAdoptPreview, formatHistory, formatScan, } from "./output.js";
+const missingClient = () => Effect.fail(new CliArgumentError("Session discovery is unavailable."));
+const write = (response, context, output) => {
+    if (!response.ok)
+        return reportError(response.error, context);
+    context.io.stdout(context.json
+        ? `${JSON.stringify({ ok: true, result: { command: output.command, result: response.value } })}\n`
+        : output.format(response.value));
+    return 0;
+};
+const required = (context, name) => {
+    const operation = context.dependencies[name];
+    return operation === undefined ? missingClient() : Effect.succeed(operation);
+};
+const failed = (context) => (error) => Effect.sync(() => reportError({
+    code: error instanceof CliArgumentError
+        ? "invalid_argument"
+        : "internal_error",
+    message: error instanceof CliArgumentError
+        ? error.message
+        : "The discovery command failed.",
+    retryable: false,
+}, context));
+export const runScan = (tokens, context) => Effect.gen(function* () {
+    const input = readScan(tokens);
+    const list = yield* required(context, "listDiscoveredSessions");
+    return write(yield* list(input), context, {
+        command: "discovery.sessions.list",
+        format: formatScan,
+    });
+}).pipe(Effect.catch(failed(context)));
+export const runHistoryRead = (tokens, context) => Effect.gen(function* () {
+    const input = readHistory(tokens);
+    const read = yield* required(context, "readSessionHistory");
+    return write(yield* read(input), context, {
+        command: "session.history.read",
+        format: formatHistory,
+    });
+}).pipe(Effect.catch(failed(context)));
+const previewIdOf = (preview) => {
+    const previewId = Reflect.get(preview, "previewId");
+    if (typeof previewId !== "string" || !previewId.startsWith("adopt_"))
+        throw new CliArgumentError("The piped preview is invalid; pipe the output of 'maia --json session adopt … --dry-run'.");
+    return previewId;
+};
+const readAdoptMode = (tokens, context) => {
+    const parsed = parseOptions(tokens, new Set(["--command-id", "--workspace"]), new Set(["--attest-ended", ...TWO_PHASE_FLAGS]));
+    const mode = readTwoPhaseMode(parsed.flags, context);
+    if (mode === "confirm-stdin")
+        requirePositionals(parsed.positionals, 0);
+    return { mode, parsed };
+};
+export const runAdopt = (tokens, context) => Effect.gen(function* () {
+    const { mode, parsed } = readAdoptMode(tokens, context);
+    const previewSessionAdopt = yield* required(context, "previewSessionAdopt");
+    const confirmSessionAdopt = yield* required(context, "confirmSessionAdopt");
+    return yield* runTwoPhase({
+        confirm: (preview) => Effect.suspend(() => confirmSessionAdopt(previewIdOf(preview))),
+        context,
+        mode,
+        preview: () => Effect.suspend(() => previewSessionAdopt(readAdopt(parsed))),
+        prompt: { describe: formatAdoptPreview, question: "Adopt this session?" },
+        writeConfirm: (result) => write(result, context, {
+            command: "session.adopt.confirm",
+            format: formatAdoptConfirm,
+        }),
+        writePreview: (result) => write(result, context, {
+            command: "session.adopt.preview",
+            format: formatAdoptPreview,
+        }),
+    });
+}).pipe(Effect.catch(failed(context)));
+//# sourceMappingURL=commands.js.map

package/dist/import/index.d.ts

@@ -0,0 +1,3 @@
+export { type DiscoveryCliDependencies, makeDiscoveryClient, } from "./client.js";
+export { runAdopt, runHistoryRead, runScan } from "./commands.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/import/index.js

@@ -0,0 +1,3 @@
+export { makeDiscoveryClient, } from "./client.js";
+export { runAdopt, runHistoryRead, runScan } from "./commands.js";
+//# sourceMappingURL=index.js.map

package/dist/import/input.d.ts

@@ -0,0 +1,16 @@
+import type { DiscoverySessionsListParameters, SessionHistoryReadParameters } from "@maiaos/sdk";
+import { type ParsedOptions } from "../command-line/index.js";
+export declare const readScan: (tokens: readonly string[]) => DiscoverySessionsListParameters;
+export declare const readNativeTarget: (value: string) => {
+    executor: "claude-code" | "codex-cli";
+    nativeId: string;
+};
+export declare const readHistory: (tokens: readonly string[]) => SessionHistoryReadParameters;
+export declare const readAdopt: (parsed: ParsedOptions) => {
+    executor: "claude-code" | "codex-cli";
+    nativeId: string;
+    attestEnded?: true | undefined;
+    commandId?: string | undefined;
+    workspaceId: string;
+};
+//# sourceMappingURL=input.d.ts.map

package/dist/import/input.js

@@ -0,0 +1,92 @@
+import { CliArgumentError, parseOptions, readPageSize, requirePositionals, } from "../command-line/index.js";
+const SOURCES = ["claude", "codex"];
+const readSources = (value) => {
+    if (value === undefined)
+        return SOURCES;
+    const names = value.split(",");
+    const sources = SOURCES.filter((source) => names.includes(source));
+    if (sources.length !== names.length || sources.length === 0)
+        throw new CliArgumentError("Option '--source' takes claude or codex, comma-separated.");
+    return sources;
+};
+const readDays = (value) => {
+    if (value === undefined)
+        return undefined;
+    const match = /^([1-9]\d{0,2})d$/u.exec(value);
+    const days = Number(match?.[1]);
+    if (match === null || days > 365)
+        throw new CliArgumentError("Option '--since' takes 1d to 365d.");
+    return days;
+};
+const readScanLimit = (value) => value === undefined ? 50 : readPageSize(value);
+export const readScan = (tokens) => {
+    const parsed = parseOptions(tokens, new Set(["--after", "--limit", "--root", "--since", "--source"]), new Set(["--include-content"]));
+    requirePositionals(parsed.positionals, 0);
+    const cursor = parsed.options.get("--after");
+    const root = parsed.options.get("--root");
+    const sinceDays = readDays(parsed.options.get("--since"));
+    return {
+        ...(cursor === undefined ? {} : { cursor }),
+        ...(parsed.flags.has("--include-content")
+            ? { includeContentFields: true }
+            : {}),
+        limit: readScanLimit(parsed.options.get("--limit")),
+        ...(root === undefined ? {} : { roots: [root] }),
+        ...(sinceDays === undefined ? {} : { sinceDays }),
+        sources: readSources(parsed.options.get("--source")),
+    };
+};
+export const readNativeTarget = (value) => {
+    const match = /^(claude|codex):(.+)$/u.exec(value);
+    if (match?.[2] === undefined)
+        throw new CliArgumentError("The vendor session must be claude:<id> or codex:<id>.");
+    return {
+        executor: match[1] === "claude" ? "claude-code" : "codex-cli",
+        nativeId: match[2],
+    };
+};
+const readInteger = (value, option, bounds) => {
+    if (value === undefined)
+        return undefined;
+    const number = Number(value);
+    if (!/^\d{1,7}$/u.test(value) ||
+        number < bounds.minimum ||
+        number > bounds.maximum)
+        throw new CliArgumentError(`Option '${option}' must be an integer from ${String(bounds.minimum)} to ${String(bounds.maximum)}.`);
+    return number;
+};
+export const readHistory = (tokens) => {
+    const parsed = parseOptions(tokens, new Set(["--limit", "--offset"]));
+    requirePositionals(parsed.positionals, 1);
+    const [target = ""] = parsed.positionals;
+    const offset = readInteger(parsed.options.get("--offset"), "--offset", {
+        maximum: 1_000_000,
+        minimum: 0,
+    });
+    return {
+        limit: readInteger(parsed.options.get("--limit"), "--limit", {
+            maximum: 50,
+            minimum: 1,
+        }) ?? 20,
+        ...(offset === undefined ? {} : { offset }),
+        target: target.includes(":")
+            ? { kind: "native", ...readNativeTarget(target) }
+            : { kind: "session", sessionId: target },
+    };
+};
+export const readAdopt = (parsed) => {
+    requirePositionals(parsed.positionals, 1);
+    const workspaceId = parsed.options.get("--workspace");
+    if (workspaceId === undefined)
+        throw new CliArgumentError("Option '--workspace' is required.");
+    const commandId = parsed.options.get("--command-id");
+    return {
+        ...(parsed.flags.has("--attest-ended")
+            ? { attestEnded: true }
+            : {}),
+        ...(commandId === undefined ? {} : { commandId }),
+        ...readNativeTarget(parsed.positionals[0] ?? ""),
+        workspaceId,
+    };
+};
+//# sourceMappingURL=input.js.map