@maiaos/cli 0.1.0-canary.2

package/dist/container/commands.js

@@ -0,0 +1,100 @@
+import { containerCreateConfirmParametersSchema, containerCreatePreviewParametersSchema, containerIndexListParametersSchema, containerListParametersSchema, containerRenameConfirmParametersSchema, containerRenamePreviewParametersSchema, containerShowParametersSchema, protocolErrorSchema, } from "@maiaos/sdk";
+import { Effect } from "effect";
+import { CliArgumentError, parseOptions, readPageSize, reportError, requirePositionals, runInputTwoPhase, writeSuccess, } from "../command-line/index.js";
+import { formatContainerResult } from "./output/index.js";
+const invalidInput = () => new CliArgumentError("Invalid container operation input.");
+const MAX_INDEX_LIMIT = 500;
+const readPage = (action, tokens) => {
+    const parsed = parseOptions(tokens, new Set(["--after", "--limit"]));
+    requirePositionals(parsed.positionals, action === "show" ? 1 : 0);
+    const afterCursor = parsed.options.get("--after");
+    return {
+        ...(afterCursor === undefined ? {} : { afterCursor }),
+        ...(action === "show" ? { containerId: parsed.positionals[0] } : {}),
+        limit: readPageSize(parsed.options.get("--limit"), action === "index" ? MAX_INDEX_LIMIT : undefined),
+    };
+};
+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, message: "Container operation failed." }, {
+            ...context,
+            ...(response.recovery === undefined
+                ? recoveryFor(error.code, parameters)
+                : { recovery: response.recovery }),
+        });
+    }
+    const value = response.value;
+    writeSuccess({ command: value.method, result: value }, context, formatContainerResult);
+    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 container client."));
+    const response = yield* Effect.suspend(() => operation(parameters)).pipe(Effect.catchDefect(() => Effect.fail(new Error("Container request failed."))));
+    return yield* Effect.try({
+        catch: () => new Error("Invalid container 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
+        : "Container command failed.",
+    retryable: false,
+}, context));
+const leaf = (program) => (tokens, context) => Effect.suspend(() => program(tokens, context)).pipe(Effect.catch(reportFailure(context)));
+export const runContainerList = leaf((tokens, context) => invoke({
+    input: Effect.succeed(readPage("list", tokens)),
+    operation: context.dependencies.listContainers,
+    parameters: containerListParametersSchema,
+}, context));
+export const runContainerShow = leaf((tokens, context) => invoke({
+    input: Effect.succeed(readPage("show", tokens)),
+    operation: context.dependencies.showContainer,
+    parameters: containerShowParametersSchema,
+}, context));
+export const runContainerIndexList = leaf((tokens, context) => invoke({
+    input: Effect.sync(() => readPage("index", tokens)),
+    operation: context.dependencies.listContainerIndex,
+    parameters: containerIndexListParametersSchema,
+}, context));
+export const runContainerCreate = leaf((tokens, context) => runInputTwoPhase({
+    confirm: context.dependencies.confirmContainerCreate,
+    confirmSchema: containerCreateConfirmParametersSchema,
+    context,
+    label: "container input",
+    preview: context.dependencies.previewContainerCreate,
+    previewOnly: ["containerId"],
+    previewSchema: containerCreatePreviewParametersSchema,
+    tokens,
+    write: (result) => writeResponse(result, undefined, context),
+}));
+export const runContainerRename = leaf((tokens, context) => runInputTwoPhase({
+    confirm: context.dependencies.confirmContainerRename,
+    confirmSchema: containerRenameConfirmParametersSchema,
+    context,
+    label: "container input",
+    preview: context.dependencies.previewContainerRename,
+    previewSchema: containerRenamePreviewParametersSchema,
+    tokens,
+    write: (result) => writeResponse(result, undefined, context),
+}));
+//# sourceMappingURL=commands.js.map

package/dist/container/index.d.ts

@@ -0,0 +1,3 @@
+export { type ContainerCliDependencies, makeContainerClient, } from "./client.js";
+export { runContainerCreate, runContainerIndexList, runContainerList, runContainerRename, runContainerShow, } from "./commands.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/container/index.js

@@ -0,0 +1,3 @@
+export { makeContainerClient, } from "./client.js";
+export { runContainerCreate, runContainerIndexList, runContainerList, runContainerRename, runContainerShow, } from "./commands.js";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,11 @@
+import type { ContainerCreateConfirmResult, ContainerCreatePreviewResult, ContainerIndexListResult, ContainerListResult, ContainerRenameConfirmResult, ContainerRenamePreviewResult, ContainerShowResult } from "@maiaos/sdk";
+export type ContainerResult = ContainerCreateConfirmResult | ContainerCreatePreviewResult | ContainerIndexListResult | ContainerListResult | ContainerRenameConfirmResult | ContainerRenamePreviewResult | ContainerShowResult;
+export type CliContainerResult = {
+    readonly command: ContainerResult["method"];
+    readonly result: ContainerResult;
+};
+export declare const isContainerResult: (result: {
+    readonly command: string;
+}) => result is CliContainerResult;
+export declare const formatContainerResult: ({ result, }: CliContainerResult) => string;
+//# sourceMappingURL=format.d.ts.map

package/dist/container/output/format.js

@@ -0,0 +1,28 @@
+import { formatRows } from "../../command-line/index.js";
+export const isContainerResult = (result) => result.command.startsWith("container.");
+const cell = (value) => value.replaceAll(/[\u0000-\u001F\u007F-\u009F]/gu, " ");
+const projectCount = (count) => `${String(count)} ${count === 1 ? "Project" : "Projects"}`;
+const formatIndex = (result) => result.items.length === 0
+    ? "No containers.\n"
+    : result.items
+        .map((item) => `${item.container.id}\t${cell(item.container.name)}\t${projectCount(item.projectCount)}\n${item.projects
+        .map((project) => `\t${project.id}\t${cell(project.name)}${project.path === undefined ? "" : `\t${cell(project.path)}`}\n`)
+        .join("")}`)
+        .join("");
+export const formatContainerResult = ({ result, }) => {
+    switch (result.method) {
+        case "container.list":
+            return formatRows(result.items, (item) => `${item.id}\t${cell(item.name)}\t${item.revision}`, { empty: "No containers.", headers: ["CONTAINER", "NAME", "REVISION"] });
+        case "container.show":
+            return `${result.container.id}\t${cell(result.container.name)}\t${result.container.revision}\n${result.projects.map((item) => `${item.id}\t${cell(item.name)}\t${item.revision}\n`).join("")}`;
+        case "container.index.list":
+            return formatIndex(result);
+        case "container.create.preview":
+        case "container.rename.preview":
+            return `${result.containerId}\t${cell(result.name)}\t${result.expiresAt}\n`;
+        case "container.create.confirm":
+        case "container.rename.confirm":
+            return `${result.container.id}\t${cell(result.container.name)}\t${result.container.revision}\t${result.receipt.receiptId}\t${result.delivery}\n`;
+    }
+};
+//# sourceMappingURL=format.js.map

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

@@ -0,0 +1,2 @@
+export { type CliContainerResult, type ContainerResult, formatContainerResult, isContainerResult, } from "./format.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/container/output/index.js

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

package/dist/context/client.d.ts

@@ -0,0 +1,7 @@
+import type { InvocationContextShowResult } from "@maiaos/sdk";
+import type { CliNodeEffect, CliNodeOperations } from "../local-node/index.js";
+export declare const makeContextClient: (node: CliNodeOperations) => {
+    showAttachedCurrentContext: () => CliNodeEffect<InvocationContextShowResult>;
+    showCurrentContext: () => CliNodeEffect<InvocationContextShowResult>;
+};
+//# sourceMappingURL=client.d.ts.map

package/dist/context/client.js

@@ -0,0 +1,21 @@
+import { INVOCATION_CONTEXT_ERROR_NODE_UNAVAILABLE, invocationContextShowParametersSchema, } from "@maiaos/sdk";
+import * as Effect from "effect/Effect";
+const mapUnavailableContext = (result) => !result.ok && result.error.code === "node_unavailable"
+    ? {
+        error: {
+            code: INVOCATION_CONTEXT_ERROR_NODE_UNAVAILABLE,
+            message: "The authenticated Maia node is unavailable.",
+            retryable: true,
+        },
+        ok: false,
+    }
+    : result;
+export const makeContextClient = (node) => ({
+    showAttachedCurrentContext: () => node
+        .runDiscoveryOperation((options) => Effect.promise(() => import("@maiaos/sdk/node/effect")).pipe(Effect.flatMap((sdk) => sdk.showAttachedCurrentContextEffect(options))))
+        .pipe(Effect.map(mapUnavailableContext)),
+    showCurrentContext: () => node
+        .runValidatedNodeOperation({}, invocationContextShowParametersSchema, (client, parameters, options) => client.showCurrentContext(parameters, options))
+        .pipe(Effect.map(mapUnavailableContext)),
+});
+//# sourceMappingURL=client.js.map

package/dist/context/commands.d.ts

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

package/dist/context/commands.js

@@ -0,0 +1,27 @@
+import * as Effect from "effect/Effect";
+import { CliArgumentError, parseOptions, requirePositionals, writeNodeResult, } from "../command-line/index.js";
+const project = (value) => ({
+    actorId: value.actorId,
+    allowedActions: value.allowedActions,
+    command: "context.show",
+    contextRevision: value.contextRevision,
+    ...(value.principal.kind === "session"
+        ? { expiresAt: value.expiresAt, related: value.related }
+        : {}),
+    principal: value.principal,
+});
+export const runContextShow = (tokens, context) => {
+    const parsed = parseOptions(tokens, new Set(), new Set(["--attached"]));
+    requirePositionals(parsed.positionals, 0);
+    const operation = parsed.flags.has("--attached")
+        ? context.dependencies.showAttachedCurrentContext
+        : context.dependencies.showCurrentContext;
+    if (operation === undefined) {
+        throw new CliArgumentError("Attached context is unavailable.");
+    }
+    return Effect.map(operation(), (result) => writeNodeResult(result, context, {
+        toResult: project,
+        toText: (value) => `${value.principal.kind}\t${value.principal.id}\t${value.actorId}\n`,
+    }));
+};
+//# sourceMappingURL=commands.js.map

package/dist/context/index.d.ts

@@ -0,0 +1,3 @@
+export { makeContextClient } from "./client.js";
+export { runContextShow } from "./commands.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/context/index.js

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

package/dist/development/cli.d.ts

@@ -0,0 +1,3 @@
+import * as Effect from "effect/Effect";
+export declare const runDevelopmentCli: (arguments_?: readonly string[]) => Effect.Effect<number>;
+//# sourceMappingURL=cli.d.ts.map

package/dist/development/cli.js

@@ -0,0 +1,44 @@
+import { dirname, join } from "node:path";
+import process from "node:process";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import * as NodeFileSystem from "@effect/platform-node-shared/NodeFileSystem";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import { processIo, runMaiaBootstrap, runProcessMain, } from "../bootstrap/index.js";
+import { decodeJsonText } from "../command-line/index.js";
+const packageDirectory = dirname(fileURLToPath(import.meta.url));
+const invalidManifest = () => new TypeError("The CLI package manifest is invalid.");
+const invalidVersion = () => new TypeError("The CLI package version is invalid.");
+const manifestVersion = (manifest) => {
+    if (typeof manifest !== "object" || manifest === null)
+        return Effect.fail(invalidManifest());
+    return "version" in manifest &&
+        typeof manifest.version === "string" &&
+        manifest.version.length > 0
+        ? Effect.succeed(manifest.version)
+        : Effect.fail(invalidVersion());
+};
+const readPackageVersion = Effect.gen(function* () {
+    const fileSystem = yield* FileSystem.FileSystem;
+    const text = yield* fileSystem.readFileString(join(packageDirectory, "../../package.json"));
+    return yield* manifestVersion(yield* decodeJsonText(text, invalidManifest));
+}).pipe(Effect.provide(NodeFileSystem.layer));
+const reportStartFailure = (error) => Effect.sync(() => {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`${message}\n`);
+    return 1;
+});
+export const runDevelopmentCli = (arguments_ = process.argv.slice(2)) => readPackageVersion.pipe(Effect.flatMap((version) => runMaiaBootstrap({
+    arguments_,
+    currentNodeVersion: process.versions.node,
+    expectedNodeVersion: "24.22.1",
+    io: processIo(),
+    version,
+}, {
+    loadAgent: () => import("@maiaos/agent"),
+    loadProductCli: () => import("../index.js"),
+})), Effect.catch(reportStartFailure));
+if (import.meta.url === pathToFileURL(process.argv[1] ?? "").href) {
+    runProcessMain(runDevelopmentCli());
+}
+//# sourceMappingURL=cli.js.map

package/dist/execution/client.d.ts

@@ -0,0 +1,25 @@
+import type { ExecutionRelocationApplyResult, ExecutionRelocationPlanResult, ExecutionRelocationReconcileResult, ExecutionRelocationShowResult } from "@maiaos/sdk";
+import { type CliNodeEffect, type CliNodeOperations } from "../local-node/index.js";
+export type PlanExecutionRelocationInput = {
+    readonly expectedFencingEpoch: string;
+    readonly expectedPlacementRevision: string;
+    readonly expectedSessionRevision: string;
+    readonly sessionId: string;
+};
+export type ApplyExecutionRelocationInput = PlanExecutionRelocationInput & {
+    readonly commandId?: string;
+    readonly planDigest: string;
+    readonly planId: string;
+};
+export type ReconcileExecutionRelocationInput = {
+    readonly commandId?: string;
+    readonly expectedOperationRevision: string;
+    readonly relocationId: string;
+};
+export declare const makeRelocateClient: (node: CliNodeOperations) => {
+    applyExecutionRelocation: (input: ApplyExecutionRelocationInput) => CliNodeEffect<ExecutionRelocationApplyResult>;
+    planExecutionRelocation: (input: PlanExecutionRelocationInput) => CliNodeEffect<ExecutionRelocationPlanResult>;
+    reconcileExecutionRelocation: (input: ReconcileExecutionRelocationInput) => CliNodeEffect<ExecutionRelocationReconcileResult>;
+    showExecutionRelocation: (relocationId: string) => CliNodeEffect<ExecutionRelocationShowResult>;
+};
+//# sourceMappingURL=client.d.ts.map

package/dist/execution/client.js

@@ -0,0 +1,24 @@
+import { executionRelocationApplyParametersSchema, executionRelocationPlanParametersSchema, executionRelocationReconcileParametersSchema, executionRelocationShowParametersSchema, LOCAL_HOST_PROFILE_ID, } from "@maiaos/sdk";
+import * as Effect from "effect/Effect";
+import { commandIdentifier, } from "../local-node/index.js";
+export const makeRelocateClient = (node) => {
+    const planExecutionRelocation = (input) => node.runValidatedNodeOperation({ ...input, targetProfileId: LOCAL_HOST_PROFILE_ID }, executionRelocationPlanParametersSchema, (client, parameters, options) => client.planExecutionRelocation(parameters, options));
+    const applyExecutionRelocation = (input) => {
+        return Effect.flatMap(commandIdentifier(input.commandId), (commandId) => {
+            return node.runValidatedNodeOperation({ ...input, commandId }, executionRelocationApplyParametersSchema, (client, parameters, options) => client.applyExecutionRelocation(parameters, options), { commandId });
+        });
+    };
+    const showExecutionRelocation = (relocationId) => node.runValidatedNodeOperation({ relocationId }, executionRelocationShowParametersSchema, (client, parameters, options) => client.showExecutionRelocation(parameters, options));
+    const reconcileExecutionRelocation = (input) => {
+        return Effect.flatMap(commandIdentifier(input.commandId), (commandId) => {
+            return node.runValidatedNodeOperation({ ...input, commandId }, executionRelocationReconcileParametersSchema, (client, parameters, options) => client.reconcileExecutionRelocation(parameters, options), { commandId });
+        });
+    };
+    return {
+        applyExecutionRelocation,
+        planExecutionRelocation,
+        reconcileExecutionRelocation,
+        showExecutionRelocation,
+    };
+};
+//# sourceMappingURL=client.js.map

package/dist/execution/index.d.ts

@@ -0,0 +1,3 @@
+export { type ApplyExecutionRelocationInput, makeRelocateClient, type PlanExecutionRelocationInput, type ReconcileExecutionRelocationInput, } from "./client.js";
+export { runRelocationApply, runRelocationPlan, runRelocationReconcile, runRelocationShow, } from "./relocation.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/execution/index.js

@@ -0,0 +1,3 @@
+export { makeRelocateClient, } from "./client.js";
+export { runRelocationApply, runRelocationPlan, runRelocationReconcile, runRelocationShow, } from "./relocation.js";
+//# sourceMappingURL=index.js.map

package/dist/execution/relocation.d.ts

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

package/dist/execution/relocation.js

@@ -0,0 +1,123 @@
+import * as Effect from "effect/Effect";
+import { missingArgument, parseOptions, readRevisionOption, requirePositionals, writeNodeResult, } from "../command-line/index.js";
+const formatRelocation = (result) => {
+    if (result.command === "execution.relocation.plan")
+        return `${result.result.plan.id}\t${String(result.result.plan.eligible)}\t${String(result.result.plan.blockers.length)}\n`;
+    if (result.command === "execution.relocation.show")
+        return `${result.result.operation.id}\t${result.result.operation.state}\n`;
+    return `${result.result.operation.id}\t${result.result.operation.state}\t${result.result.operation.cleanup}\n`;
+};
+const worktreeCommandId = (options) => {
+    const commandId = options.get("--command-id");
+    return commandId === undefined ? {} : { commandId };
+};
+const readFenceOptions = (options) => ({
+    expectedFencingEpoch: readRevisionOption(options.get("--expected-epoch"), "--expected-epoch"),
+    expectedPlacementRevision: readRevisionOption(options.get("--expected-placement-revision"), "--expected-placement-revision"),
+    expectedSessionRevision: readRevisionOption(options.get("--expected-session-revision"), "--expected-session-revision"),
+});
+export const runRelocationPlan = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set([
+        "--expected-epoch",
+        "--expected-placement-revision",
+        "--expected-session-revision",
+    ]));
+    requirePositionals(parsed.positionals, 1);
+    const sessionId = parsed.positionals[0];
+    if (sessionId === undefined)
+        throw missingArgument();
+    const operation = context.dependencies.planExecutionRelocation;
+    if (operation === undefined)
+        throw new Error("Missing relocation client.");
+    const result = yield* operation({
+        ...readFenceOptions(parsed.options),
+        sessionId,
+    });
+    return writeNodeResult(result, context, {
+        toResult: (value) => ({
+            command: "execution.relocation.plan",
+            result: value,
+        }),
+        toText: formatRelocation,
+    });
+});
+const readApplyArguments = (tokens) => {
+    const parsed = parseOptions(tokens, new Set([
+        "--command-id",
+        "--expected-epoch",
+        "--expected-placement-revision",
+        "--expected-session-revision",
+        "--plan",
+        "--plan-digest",
+    ]));
+    requirePositionals(parsed.positionals, 1);
+    const sessionId = parsed.positionals[0];
+    const planId = parsed.options.get("--plan");
+    const planDigest = parsed.options.get("--plan-digest");
+    if (sessionId === undefined ||
+        planId === undefined ||
+        planDigest === undefined)
+        throw missingArgument();
+    return { parsed, planDigest, planId, sessionId };
+};
+export const runRelocationApply = (tokens, context) => Effect.gen(function* () {
+    const { parsed, planDigest, planId, sessionId } = readApplyArguments(tokens);
+    const operation = context.dependencies.applyExecutionRelocation;
+    if (operation === undefined)
+        throw new Error("Missing relocation client.");
+    const result = yield* operation({
+        ...readFenceOptions(parsed.options),
+        planDigest,
+        planId,
+        sessionId,
+        ...worktreeCommandId(parsed.options),
+    });
+    return writeNodeResult(result, context, {
+        toResult: (value) => ({
+            command: "execution.relocation.apply",
+            result: value,
+        }),
+        toText: formatRelocation,
+    });
+});
+export const runRelocationShow = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set());
+    requirePositionals(parsed.positionals, 1);
+    const relocationId = parsed.positionals[0];
+    if (relocationId === undefined)
+        throw missingArgument();
+    const operation = context.dependencies.showExecutionRelocation;
+    if (operation === undefined)
+        throw new Error("Missing relocation client.");
+    const result = yield* operation(relocationId);
+    return writeNodeResult(result, context, {
+        toResult: (value) => ({
+            command: "execution.relocation.show",
+            result: value,
+        }),
+        toText: formatRelocation,
+    });
+});
+export const runRelocationReconcile = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set(["--command-id", "--expected-operation-revision"]));
+    requirePositionals(parsed.positionals, 1);
+    const relocationId = parsed.positionals[0];
+    if (relocationId === undefined)
+        throw missingArgument();
+    const operation = context.dependencies.reconcileExecutionRelocation;
+    if (operation === undefined)
+        throw new Error("Missing relocation client.");
+    const result = yield* operation({
+        expectedOperationRevision: readRevisionOption(parsed.options.get("--expected-operation-revision"), "--expected-operation-revision"),
+        relocationId,
+        ...worktreeCommandId(parsed.options),
+    });
+    return writeNodeResult(result, context, {
+        toResult: (value) => ({
+            command: "execution.relocation.reconcile",
+            result: value,
+        }),
+        toText: formatRelocation,
+    });
+});
+//# sourceMappingURL=relocation.js.map

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

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

package/dist/execution/tree/index.js

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

package/dist/execution/tree/tree.d.ts

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

package/dist/execution/tree/tree.js

@@ -0,0 +1,137 @@
+const execution = () => import("../../project-workspace/index.js");
+const relocation = () => import("../index.js");
+export const EXECUTION_TREE = {
+    groups: [
+        ["execution", "Execution environments, worktrees and placements."],
+        ["execution catalog", "The execution environments this Node offers."],
+        ["execution command", "Commands in an execution instance."],
+        ["execution file", "Files in an execution instance."],
+        ["execution checkpoint", "Execution checkpoints."],
+        ["execution worktree", "Project worktrees."],
+        ["execution worktree remove", "Reviewed worktree removal."],
+        ["execution placement", "Where Sessions and attempts run."],
+        ["execution relocation", "Move a Session to another placement."],
+    ],
+    leaves: [
+        [
+            "execution catalog show",
+            1,
+            "execution.catalog.get",
+            "List the execution environments this Node offers.",
+            { run: [execution, "runExecutionCatalogShow"] },
+        ],
+        [
+            "execution command run <instance-id> --expected-revision <revision> [--command-id <id>] -- <absolute-executable> [arguments...]",
+            1,
+            "execution.command.run",
+            "Run one command in an execution instance.",
+            { run: [execution, "runExecutionCommandRun"] },
+        ],
+        [
+            "execution file read <instance-id> <relative-path> --expected-revision <revision> [--command-id <id>]",
+            1,
+            "execution.file.read",
+            "Read one file from an execution instance.",
+            { run: [execution, "runExecutionFileRead"] },
+        ],
+        [
+            "execution checkpoint create --instance <instance-id> --expected-instance-revision <revision> [--command-id <id>]",
+            1,
+            "execution.checkpoint.create",
+            "Checkpoint an execution instance.",
+            { run: [execution, "runExecutionCheckpointCreate"] },
+        ],
+        [
+            "execution checkpoint show <checkpoint-id>",
+            1,
+            "execution.checkpoint.show",
+            "Show one execution checkpoint.",
+            { run: [execution, "runExecutionCheckpointShow"] },
+        ],
+        [
+            "execution worktree create --project <project-id> --repository <repository-id> --base <base-revision> --expected-project-revision <revision> [--command-id <id>]",
+            1,
+            "execution.worktree.create",
+            "Create a Git worktree for a Project repository.",
+            { run: [execution, "runExecutionWorktreeCreate"] },
+        ],
+        [
+            "execution worktree import <root-path> --project <project-id> --repository <repository-id> --expected-project-revision <revision> [--command-id <id>]",
+            1,
+            "execution.worktree.import",
+            "Import an existing worktree into a Project.",
+            { run: [execution, "runExecutionWorktreeImport"] },
+        ],
+        [
+            "execution worktree status <workspace-id>",
+            1,
+            "execution.worktree.status",
+            "Show a worktree's status.",
+            { run: [execution, "runExecutionWorktreeStatus"] },
+        ],
+        [
+            "execution worktree reconcile <operation-id> --expected-operation-revision <revision> [--command-id <id>]",
+            1,
+            "execution.worktree.reconcile",
+            "Finish an interrupted worktree operation.",
+            { run: [execution, "runExecutionWorktreeReconcile"] },
+        ],
+        [
+            "execution worktree remove plan <workspace-id>",
+            1,
+            "execution.worktree.remove.plan",
+            "Plan the removal of a worktree.",
+            { run: [execution, "runExecutionWorktreeRemovePlan"] },
+        ],
+        [
+            "execution worktree remove apply <workspace-id> --plan <plan-id> --plan-digest <digest> --expected-workspace-revision <revision> [--command-id <id>]",
+            1,
+            "execution.worktree.remove.apply",
+            "Remove a worktree with a reviewed plan.",
+            { run: [execution, "runExecutionWorktreeRemoveApply"] },
+        ],
+        [
+            "execution placement create (--session <session-id> --expected-session-revision <revision> | --attempt <attempt-id> --run <run-id> --task <task-id> --expected-attempt-revision <revision>) --instance <instance-id> --expected-workspace-revision <revision> --expected-instance-revision <revision> [--command-id <id>]",
+            1,
+            "execution.placement.create",
+            "Place a Session or run attempt on an execution instance.",
+            { run: [execution, "runExecutionPlacementCreate"] },
+        ],
+        [
+            "execution placement show (--session <session-id> | --attempt <attempt-id>)",
+            1,
+            "execution.placement.show",
+            "Show where a Session or run attempt is placed.",
+            { run: [execution, "runExecutionPlacementShow"] },
+        ],
+        [
+            "execution relocation plan <session-id> --expected-session-revision <revision> --expected-placement-revision <revision> --expected-epoch <epoch>",
+            1,
+            "execution.relocation.plan",
+            "Plan moving a Session to another placement.",
+            { run: [relocation, "runRelocationPlan"] },
+        ],
+        [
+            "execution relocation apply <session-id> --plan <plan-id> --plan-digest <digest> --expected-session-revision <revision> --expected-placement-revision <revision> --expected-epoch <epoch> [--command-id <id>]",
+            1,
+            "execution.relocation.apply",
+            "Move a Session with a reviewed plan.",
+            { run: [relocation, "runRelocationApply"] },
+        ],
+        [
+            "execution relocation show <relocation-id>",
+            1,
+            "execution.relocation.show",
+            "Show one relocation.",
+            { run: [relocation, "runRelocationShow"] },
+        ],
+        [
+            "execution relocation reconcile <relocation-id> --expected-operation-revision <revision> [--command-id <id>]",
+            1,
+            "execution.relocation.reconcile",
+            "Finish an interrupted relocation.",
+            { run: [relocation, "runRelocationReconcile"] },
+        ],
+    ],
+};
+//# sourceMappingURL=tree.js.map