@maiaos/cli 0.1.0-canary.2

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

@@ -0,0 +1,112 @@
+import type { AgentPermissionConfirmResult, AgentPermissionPreviewResult, SessionArchiveResult, SessionCreateResult, SessionDiffResult, SessionEventsListResult, SessionInboxAckResult, SessionInboxCheckResult, SessionListResult, SessionMessageSendResult, SessionObserveResult, SessionShowResult, SessionStartResult } from "@maiaos/sdk";
+import { type CliIo } from "../../command-line/index.js";
+import type { CliNodeResult } from "../../local-node/index.js";
+import { type CliSessionTasksResult } from "./tasks.js";
+type CliSessionInboxCheckDelivery = {
+    readonly attemptCount: number;
+    readonly deliveryId: string;
+    readonly firstCheckedAt?: string;
+    readonly lastCheckedAt?: string;
+    readonly mailboxId: string;
+    readonly message: SessionInboxCheckResult["deliveries"][number]["message"];
+    readonly sequence: string;
+};
+export type CliSessionResult = {
+    readonly command: "session.agent-permission.confirm";
+    readonly result: AgentPermissionConfirmResult;
+} | {
+    readonly command: "session.agent-permission.preview";
+    readonly result: AgentPermissionPreviewResult;
+} | {
+    readonly command: "session.archive";
+    readonly result: {
+        readonly archive?: SessionArchiveResult["archive"];
+        readonly delivery: SessionArchiveResult["delivery"];
+        readonly receipt: SessionArchiveResult["receipt"];
+        readonly revision: string;
+        readonly sessionId: string;
+        readonly state: SessionArchiveResult["session"]["state"];
+    };
+} | {
+    readonly command: "session.create";
+    readonly result: {
+        readonly delivery: SessionCreateResult["delivery"];
+        readonly executor?: SessionCreateResult["session"]["executor"];
+        readonly receipt: SessionCreateResult["receipt"];
+        readonly revision: string;
+        readonly sessionId: string;
+        readonly state: SessionCreateResult["session"]["state"];
+        readonly title?: string;
+        readonly workspaceId: string;
+        readonly workspaceRevision: string;
+        readonly worktree?: SessionCreateResult["session"]["worktree"];
+    };
+} | {
+    readonly command: "session.create.tasks";
+    readonly result: CliSessionTasksResult;
+} | {
+    readonly command: "session.diff";
+    readonly result: SessionDiffResult;
+} | {
+    readonly command: "session.events.list";
+    readonly result: SessionEventsListResult;
+} | {
+    readonly command: "session.inbox.ack";
+    readonly result: {
+        readonly delivery: SessionInboxAckResult["delivery"];
+        readonly deliveryRecord: {
+            readonly acknowledgedAt: string;
+            readonly acknowledgingSessionId: string;
+            readonly deliveryId: string;
+            readonly mailboxId: string;
+            readonly messageId: string;
+            readonly sequence: string;
+        };
+        readonly mailboxId: string;
+        readonly mailboxRevision: string;
+        readonly receipt: SessionInboxAckResult["receipt"];
+    };
+} | {
+    readonly command: "session.inbox.check";
+    readonly result: {
+        readonly count: number;
+        readonly deliveries: readonly CliSessionInboxCheckDelivery[];
+        readonly mailboxId: string;
+        readonly mailboxRevision: string;
+    };
+} | {
+    readonly command: "session.list";
+    readonly result: SessionListResult;
+} | {
+    readonly command: "session.message.send";
+    readonly result: {
+        readonly delivery: SessionMessageSendResult["delivery"];
+        readonly deliveryId: string;
+        readonly mailboxId: string;
+        readonly message: Omit<SessionMessageSendResult["message"], "body" | "schemaVersion" | "subject">;
+        readonly receipt: SessionMessageSendResult["receipt"];
+        readonly sequence: string;
+    };
+} | {
+    readonly command: "session.observe";
+    readonly result: SessionObserveResult;
+} | {
+    readonly command: "session.resume" | "session.start" | "session.stop";
+    readonly result: {
+        readonly delivery: SessionStartResult["delivery"];
+        readonly receipt: SessionStartResult["receipt"];
+        readonly revision: string;
+        readonly sessionId: string;
+        readonly state: SessionStartResult["session"]["state"];
+    };
+} | {
+    readonly command: "session.show";
+    readonly result: SessionShowResult;
+};
+export declare const formatSessionResult: (result: CliSessionResult) => string;
+export declare const writeSessionResult: <TValue>(result: CliNodeResult<TValue>, context: {
+    readonly io: CliIo;
+    readonly json: boolean;
+}, map: (value: TValue) => CliSessionResult) => number;
+export {};
+//# sourceMappingURL=human.d.ts.map

package/dist/session/output/human.js

@@ -0,0 +1,71 @@
+import { cell, formatRows, tab, writeNodeResult, } from "../../command-line/index.js";
+import { formatSessionDiff } from "./diff.js";
+import { formatFailure, formatSessionEvents } from "./failure.js";
+import { formatSessionObservation } from "./observe.js";
+import { formatSessionList, formatSessionTasks, } from "./tasks.js";
+const formatSessionInbox = (deliveries) => formatRows(deliveries, (delivery) => `${delivery.deliveryId}\t${delivery.sequence}\t${cell(delivery.message.senderSessionId)}\t${cell(delivery.message.subject)}\t${cell(delivery.message.body)}`);
+const formatSessionCreation = (result) => `${tab([
+    result.sessionId,
+    ...(result.executor === undefined ? [] : [result.executor.connectionId]),
+    ...(result.worktree === undefined
+        ? []
+        : [result.workspaceId, result.worktree.branch]),
+])}\nnext: maia session start ${result.sessionId} --expected-revision ${result.revision} --wait\n`;
+const formatArchive = ({ archive, revision, sessionId, state, }) => {
+    const kept = archive === undefined
+        ? ["no worktree to keep"]
+        : [archive.branch, archive.snapshot, `prune after ${archive.pruneAfter}`];
+    return `${tab([sessionId, state, revision, ...kept])}\n`;
+};
+const formatCodingSession = (result) => {
+    if (result.command === "session.create")
+        return formatSessionCreation(result.result);
+    if (result.command === "session.create.tasks")
+        return formatSessionTasks(result.result);
+    if (result.command === "session.diff")
+        return formatSessionDiff(result.result);
+    return formatArchive(result.result);
+};
+const formatAgentPermission = (result) => result.command === "session.agent-permission.preview"
+    ? `${result.result.sessionId}\t${result.result.expiresAt}\n`
+    : `${result.result.receipt.receiptId}\t${result.result.delivery}\n`;
+const formatSessionShow = ({ session, }) => `${session.id}\t${session.state}\t${session.workspaceId}\n${formatFailure(session.failure)}`;
+const formatLifecycle = ({ revision, sessionId, state, }) => `${sessionId}\t${state}\t${revision}\n${state === "starting" ? `next: maia session start ${sessionId} --expected-revision ${revision} --wait returns once it runs; maia session show ${sessionId} shows it now\n` : ""}`;
+const formatSessions = (result) => result.items.length === 0 ? "No Sessions.\n" : formatSessionList(result);
+const formatInboxAck = ({ delivery, deliveryRecord, mailboxRevision, }) => `${tab([deliveryRecord.deliveryId, delivery, mailboxRevision])}\n`;
+const formatMessageSend = ({ delivery, deliveryId, sequence, }) => `${tab([deliveryId, delivery, sequence])}\n`;
+export const formatSessionResult = (result) => {
+    switch (result.command) {
+        case "session.agent-permission.confirm":
+        case "session.agent-permission.preview":
+            return formatAgentPermission(result);
+        case "session.archive":
+        case "session.create":
+        case "session.create.tasks":
+        case "session.diff":
+            return formatCodingSession(result);
+        case "session.events.list":
+            return formatSessionEvents(result.result.items);
+        case "session.inbox.ack":
+            return formatInboxAck(result.result);
+        case "session.inbox.check":
+            return formatSessionInbox(result.result.deliveries);
+        case "session.list":
+            return formatSessions(result.result);
+        case "session.message.send":
+            return formatMessageSend(result.result);
+        case "session.observe":
+            return formatSessionObservation(result.result);
+        case "session.show":
+            return formatSessionShow(result.result);
+        case "session.resume":
+        case "session.start":
+        case "session.stop":
+            return formatLifecycle(result.result);
+    }
+};
+export const writeSessionResult = (result, context, map) => writeNodeResult(result, context, {
+    toResult: map,
+    toText: formatSessionResult,
+});
+//# sourceMappingURL=human.js.map

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

@@ -0,0 +1,6 @@
+export { formatSessionDiff } from "./diff.js";
+export { formatFailure, formatFailureCell, formatSessionEvents, } from "./failure.js";
+export { type CliSessionResult, formatSessionResult, writeSessionResult, } from "./human.js";
+export { formatSessionObservation } from "./observe.js";
+export { type CliSessionTaskItem, type CliSessionTasksResult, formatSessionList, formatSessionTasks, } from "./tasks.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/session/output/index.js

@@ -0,0 +1,6 @@
+export { formatSessionDiff } from "./diff.js";
+export { formatFailure, formatFailureCell, formatSessionEvents, } from "./failure.js";
+export { formatSessionResult, writeSessionResult, } from "./human.js";
+export { formatSessionObservation } from "./observe.js";
+export { formatSessionList, formatSessionTasks, } from "./tasks.js";
+//# sourceMappingURL=index.js.map

package/dist/session/output/observe.d.ts

@@ -0,0 +1,4 @@
+import type { SessionObserveResult } from "@maiaos/sdk";
+export declare const formatDuration: (milliseconds: number) => string;
+export declare const formatSessionObservation: (result: SessionObserveResult) => string;
+//# sourceMappingURL=observe.d.ts.map

package/dist/session/output/observe.js

@@ -0,0 +1,46 @@
+const SECOND = 1000;
+const MINUTE = 60 * SECOND;
+const HOUR = 60 * MINUTE;
+const MEBIBYTE = 1024 * 1024;
+const pad = (value) => String(value).padStart(2, "0");
+export const formatDuration = (milliseconds) => {
+    if (milliseconds < SECOND)
+        return `${String(milliseconds)}ms`;
+    if (milliseconds < MINUTE)
+        return `${String(Math.floor(milliseconds / SECOND))}s`;
+    if (milliseconds < HOUR)
+        return `${String(Math.floor(milliseconds / MINUTE))}m${pad(Math.floor((milliseconds % MINUTE) / SECOND))}s`;
+    return `${String(Math.floor(milliseconds / HOUR))}h${pad(Math.floor((milliseconds % HOUR) / MINUTE))}m`;
+};
+const measured = (value, format) => (value === undefined ? "n/a" : format(value));
+const describeProcess = (runtime) => {
+    const usage = runtime.process;
+    if (usage === undefined)
+        return "process=n/a";
+    const cpu = measured(usage.cpuTimeMilliseconds, formatDuration);
+    const rss = measured(usage.rssBytes, (bytes) => `${String(Math.round(bytes / MEBIBYTE))}MiB`);
+    const count = measured(usage.processCount, String);
+    return `cpu=${cpu}\trss=${rss}\tprocs=${count}`;
+};
+const describeTurn = (runtime) => runtime.turn === undefined
+    ? "turn=-"
+    : `turn=${runtime.turn.turnId}\telapsed=${formatDuration(runtime.turn.elapsedMilliseconds)}`;
+const describeRuntime = (runtime) => {
+    const { activity, health } = runtime;
+    return [
+        runtime.runtime,
+        health,
+        describeTurn(runtime),
+        `idle=${formatDuration(activity.idleMilliseconds)}`,
+        `events=${String(activity.eventCount)}`,
+        `last=${activity.lastEventKind ?? "-"}`,
+        `declined=${String(activity.declinedRequests)}`,
+        describeProcess(runtime),
+    ].join("\t");
+};
+export const formatSessionObservation = (result) => {
+    const header = `observed ${result.observedAt}\tstall-after=${String(result.stallAfterSeconds)}s`;
+    const lines = result.items.map((item) => `${item.sessionId}\t${item.attention ?? "-"}\t${item.runtime === undefined ? "not-live" : describeRuntime(item.runtime)}`);
+    return `${[header, ...(lines.length === 0 ? ["No live sessions."] : lines)].join("\n")}\n`;
+};
+//# sourceMappingURL=observe.js.map

package/dist/session/output/tasks.d.ts

@@ -0,0 +1,19 @@
+import type { SessionCreationOutcome, SessionListResult } from "@maiaos/sdk";
+export type CliSessionTaskItem = {
+    readonly error?: SessionCreationOutcome["error"];
+    readonly line: number;
+    readonly receipts: SessionCreationOutcome["receipts"];
+    readonly recovery?: {
+        readonly commandId: string;
+    };
+    readonly sessionId?: string;
+    readonly stage: SessionCreationOutcome["stage"];
+    readonly turnId?: string;
+};
+export type CliSessionTasksResult = {
+    readonly items: readonly CliSessionTaskItem[];
+    readonly workspaceId: string;
+};
+export declare const formatSessionTasks: (result: CliSessionTasksResult) => string;
+export declare const formatSessionList: (result: SessionListResult) => string;
+//# sourceMappingURL=tasks.d.ts.map

package/dist/session/output/tasks.js

@@ -0,0 +1,34 @@
+import { cell, formatRows, tab, withNextPage, } from "../../command-line/index.js";
+import { formatFailureCell } from "./failure.js";
+const failure = ({ error }) => error === undefined
+    ? "-"
+    : `${error.operationId}:${error.code ?? error.kind}${error.failure === undefined ? "" : ` (${formatFailureCell(error.failure)})`}`;
+const receiptIds = ({ receipts }) => {
+    const ids = [receipts.create, receipts.start, receipts.send].flatMap((receipt) => (receipt === undefined ? [] : [receipt.receiptId]));
+    return ids.length === 0 ? "-" : ids.join(",");
+};
+export const formatSessionTasks = (result) => result.items
+    .map((item) => `${[
+    String(item.line),
+    item.stage,
+    item.sessionId ?? "-",
+    item.turnId ?? "-",
+    failure(item),
+    receiptIds(item),
+    item.recovery?.commandId ?? "-",
+].join("\t")}\n`)
+    .join("");
+export const formatSessionList = (result) => {
+    const attention = new Map((result.attention ?? []).map((item) => [item.sessionId, item.attention]));
+    return withNextPage(formatRows(result.items, (session) => tab([
+        session.id,
+        session.state,
+        session.workspaceId,
+        attention.get(session.id) ?? "-",
+        cell(session.title ?? "-"),
+    ]), {
+        empty: "No Sessions.",
+        headers: ["SESSION", "STATE", "WORKSPACE", "ATTENTION", "TITLE"],
+    }), result.nextCursor);
+};
+//# sourceMappingURL=tasks.js.map

package/dist/session/rename.d.ts

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

package/dist/session/rename.js

@@ -0,0 +1,37 @@
+import * as Effect from "effect/Effect";
+import { cell, CliArgumentError, parseOptions, readExpectedRevision, requirePositionals, writeNodeResult, } from "../command-line/index.js";
+import { commandIdentifier } from "../local-node/index.js";
+const readRename = (tokens) => {
+    const parsed = parseOptions(tokens, new Set(["--command-id", "--expected-revision", "--title"]));
+    requirePositionals(parsed.positionals, 1);
+    const title = parsed.options.get("--title");
+    if (title === undefined)
+        throw new CliArgumentError("Option '--title' is required.");
+    return {
+        commandId: parsed.options.get("--command-id"),
+        expectedRevision: readExpectedRevision(parsed.options.get("--expected-revision")),
+        sessionId: parsed.positionals[0] ?? "",
+        title,
+    };
+};
+const presenter = {
+    toResult: (value) => ({
+        command: "session.rename",
+        result: {
+            delivery: value.delivery,
+            receipt: value.receipt,
+            revision: value.session.revision,
+            sessionId: value.session.id,
+            title: value.session.title ?? "",
+        },
+    }),
+    toText: ({ result, }) => `${result.sessionId}\t${cell(result.title)}\trevision ${result.revision}\n`,
+};
+export const runSessionRename = (tokens, context) => {
+    const { commandId, ...rename } = readRename(tokens);
+    const { call } = context.dependencies;
+    if (call === undefined)
+        return Effect.die(new Error("Missing the typed Node call."));
+    return Effect.flatMap(commandIdentifier(commandId), (exactCommandId) => Effect.map(call("session.rename", { ...rename, commandId: exactCommandId }), (result) => writeNodeResult(result, context, presenter)));
+};
+//# sourceMappingURL=rename.js.map

package/dist/session/task-file.d.ts

@@ -0,0 +1,5 @@
+import * as Effect from "effect/Effect";
+import { CliArgumentError } from "../command-line/index.js";
+export declare const MAX_TASK_FILE_BYTES: number;
+export declare const readTaskFile: (path: string) => Effect.Effect<string, CliArgumentError>;
+//# sourceMappingURL=task-file.d.ts.map

package/dist/session/task-file.js

@@ -0,0 +1,23 @@
+import * as NodeFileSystem from "@effect/platform-node-shared/NodeFileSystem";
+import { MAX_SESSION_CREATION_TASKS, MAX_TURN_INPUT_BYTES } from "@maiaos/sdk";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import { CliArgumentError } from "../command-line/index.js";
+export const MAX_TASK_FILE_BYTES = MAX_SESSION_CREATION_TASKS * (MAX_TURN_INPUT_BYTES + 2);
+const unreadable = () => new CliArgumentError("Option '--from-file' must name a readable file.");
+export const readTaskFile = (path) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const info = yield* fs.stat(path);
+    if (info.type !== "File")
+        return yield* unreadable();
+    if (Number(info.size) > MAX_TASK_FILE_BYTES)
+        return yield* new CliArgumentError(`Option '--from-file' must name a file of at most ${String(MAX_TASK_FILE_BYTES)} bytes.`);
+    const bytes = yield* fs.readFile(path);
+    if (bytes.byteLength > MAX_TASK_FILE_BYTES)
+        return yield* unreadable();
+    return yield* Effect.try({
+        catch: () => new CliArgumentError("Option '--from-file' must name a UTF-8 file."),
+        try: () => new TextDecoder("utf-8", { fatal: true }).decode(bytes),
+    });
+}).pipe(Effect.catchTag("PlatformError", () => Effect.fail(unreadable())), Effect.provide(NodeFileSystem.layer));
+//# sourceMappingURL=task-file.js.map

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

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

package/dist/session/tree/index.js

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

package/dist/session/tree/tree.d.ts

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