@maiaos/cli 0.1.0-canary.2

package/dist/session/commands.js

@@ -0,0 +1,488 @@
+import { MAX_SESSION_INBOX_CHECK_LIMIT, MAX_SESSION_MESSAGE_BODY_BYTES, MAX_SESSION_OBSERVE_IDS, MAX_SESSION_STALL_AFTER_SECONDS, MIN_SESSION_STALL_AFTER_SECONDS, sessionBaseRefSchema, sessionCreateParametersSchema, } from "@maiaos/sdk";
+import { Effect } from "effect";
+import { CliArgumentError, parseOptions, readCursor, readDuration, readExpectedRevision, readPageSize, requirePositionals, } from "../command-line/index.js";
+import { runSessionTasks, } from "./create-tasks.js";
+import { writeSessionResult } from "./output/index.js";
+const SESSION_CREATE_OPTIONS = new Set([
+    "--base",
+    "--command-id",
+    "--connection",
+    "--executor",
+    "--model",
+    "--agent-definition",
+    "--agent-definition-version",
+    "--agent-definition-digest",
+    "--role",
+    "--title",
+]);
+const summarizeSessionCreation = (result) => ({
+    ...(result.session.agentDefinitionRef === undefined
+        ? {}
+        : { agentDefinitionRef: result.session.agentDefinitionRef }),
+    ...(result.session.executor === undefined
+        ? {}
+        : { executor: result.session.executor }),
+    delivery: result.delivery,
+    receipt: result.receipt,
+    revision: result.session.revision,
+    sessionId: result.session.id,
+    state: result.session.state,
+    ...(result.session.title === undefined
+        ? {}
+        : { title: result.session.title }),
+    workspaceId: result.session.workspaceId,
+    workspaceRevision: result.session.workspaceRevision,
+    ...(result.session.worktree === undefined
+        ? {}
+        : { worktree: result.session.worktree }),
+});
+const summarizeSessionLifecycle = (result) => ({
+    delivery: result.delivery,
+    receipt: result.receipt,
+    revision: result.session.revision,
+    sessionId: result.session.id,
+    state: result.session.state,
+});
+const readSessionEventPageSize = (value) => {
+    if (value === undefined)
+        return 20;
+    if (!/^(?:[1-9]|[12]\d|3[0-2])$/u.test(value)) {
+        throw new CliArgumentError("Option '--limit' must be an integer from 1 to 32 for session events.");
+    }
+    return Number(value);
+};
+const readSessionCreateOptions = (parsed) => {
+    requirePositionals(parsed.positionals, 0);
+    const workspaceId = parsed.options.get("--workspace");
+    if (workspaceId === undefined)
+        throw new CliArgumentError(parsed.options.has("--project")
+            ? "Option '--project' needs '--message', '--prompt-stdin' or '--from-file'; name a Workspace with '--workspace' otherwise."
+            : "Option '--workspace' is required.");
+    const input = readSessionSelection(parsed.options, workspaceId);
+    const definition = readDefinitionSelection(parsed.options, input);
+    requireOneSelection({ ...input, ...definition });
+    return { ...input, ...definition };
+};
+const requireOneSelection = (input) => {
+    if (input.definitionRef !== undefined &&
+        (input.connectionId !== undefined || input.executor !== undefined))
+        throw new CliArgumentError("Use one of '--connection', '--executor' or '--agent-definition'.");
+    if (input.model !== undefined && input.connectionId === undefined)
+        throw new CliArgumentError("Option '--model' needs '--connection' with a gateway connection.");
+};
+const readSessionRole = (value) => {
+    if (value === undefined)
+        return {};
+    if (value === "worker" || value === "orchestrator")
+        return { role: value };
+    throw new CliArgumentError("Option '--role' must be worker or orchestrator.");
+};
+const readSessionSelection = (options, workspaceId) => {
+    const commandId = options.get("--command-id");
+    const connectionId = options.get("--connection");
+    const executor = readExecutorKind(options.get("--executor"));
+    const model = options.get("--model");
+    const title = options.get("--title");
+    const selection = {
+        ...(commandId === undefined ? {} : { commandId }),
+        ...(connectionId === undefined ? {} : { connectionId }),
+        ...(executor === undefined ? {} : { executor }),
+        ...(model === undefined ? {} : { model }),
+        ...readSessionRole(options.get("--role")),
+        ...(title === undefined ? {} : { title }),
+        workspaceId,
+    };
+    const baseRef = readBaseRef(options.get("--base"), selection);
+    return { ...selection, ...(baseRef === undefined ? {} : { baseRef }) };
+};
+const readBaseRef = (value, selection) => {
+    if (value === undefined)
+        return;
+    if (selection.connectionId === undefined && selection.executor === undefined)
+        throw new CliArgumentError("Option '--base' needs '--connection' or '--executor'.");
+    if (sessionBaseRefSchema.safeParse(value).success)
+        return value;
+    throw new CliArgumentError("Option '--base' must name a branch, tag or commit without ranges, revision suffixes or a leading dash.");
+};
+const readExecutorKind = (value) => {
+    if (value === undefined || value === "codex-cli" || value === "claude-code")
+        return value;
+    throw new CliArgumentError("Option '--executor' must be codex-cli or claude-code.");
+};
+const readDefinitionSelection = (options, input) => {
+    const key = options.get("--agent-definition");
+    const version = options.get("--agent-definition-version");
+    const contentDigest = options.get("--agent-definition-digest");
+    if (key === undefined &&
+        version === undefined &&
+        contentDigest === undefined) {
+        return {};
+    }
+    const validated = sessionCreateParametersSchema.safeParse({
+        ...input,
+        commandId: input.commandId ?? "command_validate",
+        definitionRef: { contentDigest, key, version },
+        expectedRevision: "0",
+    });
+    if (!validated.success) {
+        throw new CliArgumentError("Agent definition selection requires valid '--agent-definition', '--agent-definition-version', and '--agent-definition-digest' together.");
+    }
+    return { definitionRef: validated.data.definitionRef };
+};
+const TASK_OPTIONS = new Set([
+    ...SESSION_CREATE_OPTIONS,
+    "--from-file",
+    "--message",
+    "--project",
+    "--workspace",
+]);
+const taskSource = (parsed) => {
+    const file = parsed.options.get("--from-file");
+    const message = parsed.options.get("--message");
+    const stdin = parsed.flags.has("--prompt-stdin");
+    if ([file, message, stdin ? "" : undefined].filter((value) => value !== undefined).length > 1)
+        throw new CliArgumentError("Use one of '--message', '--prompt-stdin' or '--from-file'.");
+    if (file !== undefined && parsed.options.has("--title"))
+        throw new CliArgumentError("Option '--title' names one Session; with '--from-file' each Session takes its task's first line.");
+    if (file !== undefined)
+        return { kind: "file", path: file };
+    if (message !== undefined)
+        return { kind: "message", text: message };
+    return stdin ? { kind: "stdin" } : undefined;
+};
+const readTaskWorkspace = (parsed, source) => {
+    requirePositionals(parsed.positionals, 0);
+    const named = parsed.options.get("--workspace");
+    if ((named === undefined) === !parsed.options.has("--project"))
+        throw new CliArgumentError("Name one Workspace with '--workspace', or a Project with '--project'.");
+    if (parsed.options.has("--agent-definition"))
+        throw new CliArgumentError("Option '--agent-definition' does not apply to Session tasks.");
+    if (parsed.options.has("--command-id") && source.kind === "file")
+        throw new CliArgumentError("Option '--command-id' names one Session; use it with '--message' or '--prompt-stdin'.");
+    return named;
+};
+const readSessionTasks = (parsed, source) => {
+    const workspaceId = readTaskWorkspace(parsed, source);
+    const projectId = parsed.options.get("--project");
+    const commandId = parsed.options.get("--command-id");
+    const { workspaceId: _placeholder, ...selection } = readSessionSelection(parsed.options, workspaceId ?? "workspace_default");
+    requireOneSelection({ ...selection, workspaceId: _placeholder });
+    return {
+        ...(commandId === undefined ? {} : { commandId }),
+        ...(projectId === undefined ? {} : { projectId }),
+        selection,
+        source,
+        ...(workspaceId === undefined ? {} : { workspaceId }),
+    };
+};
+export const runSessionCreate = (tokens, context) => {
+    const parsed = parseOptions(tokens, TASK_OPTIONS, new Set(["--prompt-stdin"]));
+    const source = taskSource(parsed);
+    if (source !== undefined)
+        return runSessionTasks(readSessionTasks(parsed, source), context);
+    return Effect.map(context.dependencies.createSession(readSessionCreateOptions(parsed)), (result) => writeSessionResult(result, context, (value) => ({
+        command: "session.create",
+        result: summarizeSessionCreation(value),
+    })));
+};
+const readSessionList = (tokens) => {
+    const parsed = parseOptions(tokens, new Set(["--after", "--limit", "--project", "--state"]), new Set(["--all", "--attention"]));
+    requirePositionals(parsed.positionals, 0);
+    const projectId = parsed.options.get("--project");
+    if ((projectId === undefined) === !parsed.flags.has("--all"))
+        throw new CliArgumentError("Use one of '--project' or '--all'.");
+    const states = parsed.options.get("--state")?.split(",");
+    return {
+        afterCursor: readCursor(parsed.options.get("--after")),
+        limit: readPageSize(parsed.options.get("--limit")),
+        ...(projectId === undefined ? {} : { projectId }),
+        ...(parsed.flags.has("--attention") ? { attention: true } : {}),
+        ...(states === undefined ? {} : { states }),
+    };
+};
+export const runSessionList = (tokens, context) => Effect.gen(function* () {
+    const result = yield* context.dependencies.listSessions(readSessionList(tokens));
+    return writeSessionResult(result, context, (value) => ({
+        command: "session.list",
+        result: value,
+    }));
+});
+export const runSessionShow = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set());
+    requirePositionals(parsed.positionals, 1);
+    const sessionId = parsed.positionals[0];
+    if (sessionId === undefined) {
+        throw new CliArgumentError("The session identifier is missing.");
+    }
+    const result = yield* context.dependencies.showSession(sessionId);
+    return writeSessionResult(result, context, (value) => ({
+        command: "session.show",
+        result: value,
+    }));
+});
+const readLifecycleInput = (parsed) => {
+    const sessionId = parsed.positionals[0];
+    if (sessionId === undefined) {
+        throw new CliArgumentError("The session identifier is missing.");
+    }
+    const commandId = parsed.options.get("--command-id");
+    return {
+        expectedRevision: readExpectedRevision(parsed.options.get("--expected-revision")),
+        sessionId,
+        ...(commandId === undefined ? {} : { commandId }),
+    };
+};
+const parseSessionLifecycle = (verb, tokens, flags = new Set()) => {
+    const parsed = parseOptions(tokens, new Set(["--command-id", "--expected-revision"]), flags);
+    requirePositionals(parsed.positionals, 1);
+    return { flags: parsed.flags, input: readLifecycleInput(parsed) };
+};
+export const runSessionStart = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set(["--command-id", "--expected-revision", "--timeout"]), new Set(["--wait"]));
+    requirePositionals(parsed.positionals, 1);
+    const input = readLifecycleInput(parsed);
+    const wait = parsed.flags.has("--wait");
+    const timeout = parsed.options.get("--timeout");
+    if (timeout !== undefined && !wait)
+        throw new CliArgumentError("Option '--timeout' needs '--wait'.");
+    const deadlineMilliseconds = timeout === undefined
+        ? RUNNING_DEADLINE_MILLISECONDS
+        : readDuration(timeout, "--timeout", { max: 3600, min: 1 }) * 1000;
+    const result = yield* context.dependencies.startSession(input);
+    if (!wait || !result.ok)
+        return writeSessionResult(result, context, (value) => ({
+            command: "session.start",
+            result: summarizeSessionLifecycle(value),
+        }));
+    return yield* waitUntilRunning(result.value, context, deadlineMilliseconds);
+});
+const RUNNING_DEADLINE_MILLISECONDS = 120_000;
+const EXIT_NOT_RUNNING = 70;
+const EXIT_STILL_STARTING = 74;
+const waitUntilRunning = (started, context, deadlineMilliseconds) => Effect.gen(function* () {
+    const { awaitSessionRunning } = context.dependencies;
+    if (awaitSessionRunning === undefined)
+        return yield* new CliArgumentError("Waiting for a Session is unavailable.");
+    const awaited = yield* awaitSessionRunning({
+        deadlineMilliseconds,
+        sessionId: started.session.id,
+    });
+    const code = writeSessionResult(awaited, context, (session) => ({
+        command: "session.start",
+        result: {
+            ...summarizeSessionLifecycle(started),
+            revision: session.revision,
+            state: session.state,
+        },
+    }));
+    if (code !== 0 || !awaited.ok || awaited.value.state === "running")
+        return code;
+    return awaited.value.state === "failed" ||
+        awaited.value.state.startsWith("stop")
+        ? EXIT_NOT_RUNNING
+        : EXIT_STILL_STARTING;
+});
+export const runSessionStop = (tokens, context) => Effect.gen(function* () {
+    const { input } = parseSessionLifecycle("stop", tokens);
+    const { stopSession } = context.dependencies;
+    if (stopSession === undefined)
+        throw new CliArgumentError("Session stop is unavailable.");
+    const result = yield* stopSession(input);
+    return writeSessionResult(result, context, (value) => ({
+        command: "session.stop",
+        result: summarizeSessionLifecycle(value),
+    }));
+});
+export const runSessionResume = (tokens, context) => Effect.gen(function* () {
+    const { input } = parseSessionLifecycle("resume", tokens);
+    const { resumeSession } = context.dependencies;
+    if (resumeSession === undefined)
+        throw new CliArgumentError("Session resume is unavailable.");
+    const result = yield* resumeSession(input);
+    return writeSessionResult(result, context, (value) => ({
+        command: "session.resume",
+        result: summarizeSessionLifecycle(value),
+    }));
+});
+export const runSessionEventsList = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set(["--after", "--limit", "--session"]));
+    requirePositionals(parsed.positionals, 0);
+    const sessionId = requireSessionOption(parsed.options, "--session");
+    const result = yield* context.dependencies.listSessionEvents({
+        afterSessionCursor: readCursor(parsed.options.get("--after")),
+        limit: readSessionEventPageSize(parsed.options.get("--limit")),
+        sessionId,
+    });
+    return writeSessionResult(result, context, (value) => ({
+        command: "session.events.list",
+        result: value,
+    }));
+});
+const readStallAfter = (value) => value === undefined
+    ? undefined
+    : readDuration(value, "--stall-after", {
+        max: MAX_SESSION_STALL_AFTER_SECONDS,
+        min: MIN_SESSION_STALL_AFTER_SECONDS,
+    });
+export const runSessionObserve = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set(["--stall-after"]));
+    if (parsed.positionals.length > MAX_SESSION_OBSERVE_IDS)
+        throw new CliArgumentError(`Observe at most ${String(MAX_SESSION_OBSERVE_IDS)} Sessions.`);
+    const stallAfterSeconds = readStallAfter(parsed.options.get("--stall-after"));
+    const { observeSessions } = context.dependencies;
+    if (observeSessions === undefined)
+        throw new CliArgumentError("Session observation is unavailable.");
+    const result = yield* observeSessions({
+        ...(parsed.positionals.length === 0
+            ? {}
+            : { sessionIds: parsed.positionals }),
+        ...(stallAfterSeconds === undefined ? {} : { stallAfterSeconds }),
+    });
+    return writeSessionResult(result, context, (value) => ({
+        command: "session.observe",
+        result: value,
+    }));
+});
+const requireSessionOption = (options, name) => {
+    const value = options.get(name);
+    if (value !== undefined)
+        return value;
+    throw new CliArgumentError(`Option '${name}' is required.`);
+};
+const requireAttachedFlag = (flags) => {
+    if (flags.has("--attached"))
+        return;
+    throw new CliArgumentError("Option '--attached' is required.");
+};
+const summarizeMessageSend = (result) => ({
+    delivery: result.delivery,
+    deliveryId: result.deliveryId,
+    mailboxId: result.mailboxId,
+    message: {
+        createdAt: result.message.createdAt,
+        digest: result.message.digest,
+        id: result.message.id,
+        recipientSessionId: result.message.recipientSessionId,
+        senderSessionId: result.message.senderSessionId,
+        workspaceId: result.message.workspaceId,
+    },
+    receipt: result.receipt,
+    sequence: result.sequence,
+});
+const readSessionMessageBody = (context) => {
+    if (context.io.stdin === undefined)
+        throw new CliArgumentError("Session message body requires standard input.");
+    return context.io.stdin({
+        label: "Session message body",
+        maxBytes: MAX_SESSION_MESSAGE_BODY_BYTES,
+        maxChunks: 256,
+    });
+};
+const parseSessionMessageSend = (tokens) => {
+    const parsed = parseOptions(tokens, new Set(["--command-id", "--session", "--subject"]), new Set(["--attached", "--body-stdin"]));
+    requirePositionals(parsed.positionals, 0);
+    requireAttachedFlag(parsed.flags);
+    if (!parsed.flags.has("--body-stdin"))
+        throw new CliArgumentError("Option '--body-stdin' is required.");
+    const recipientSessionId = requireSessionOption(parsed.options, "--session");
+    const commandId = parsed.options.get("--command-id");
+    return {
+        ...(commandId === undefined ? {} : { commandId }),
+        recipientSessionId,
+        subject: requireSessionOption(parsed.options, "--subject"),
+    };
+};
+export const runSessionMessageSend = (tokens, context) => Effect.gen(function* () {
+    const input = parseSessionMessageSend(tokens);
+    const operation = context.dependencies.sendAttachedSessionMessage;
+    if (operation === undefined)
+        throw new CliArgumentError("Attached Session messaging is unavailable.");
+    const result = yield* operation({
+        ...input,
+        body: yield* readSessionMessageBody(context),
+    });
+    return writeSessionResult(result, context, (value) => ({
+        command: "session.message.send",
+        result: summarizeMessageSend(value),
+    }));
+});
+const projectInboxDelivery = (delivery) => ({
+    attemptCount: delivery.attemptCount,
+    deliveryId: delivery.id,
+    firstCheckedAt: delivery.firstCheckedAt,
+    lastCheckedAt: delivery.lastCheckedAt,
+    mailboxId: delivery.mailboxId,
+    message: delivery.message,
+    sequence: delivery.sequence,
+});
+const readSessionInboxLimit = (value) => {
+    if (!/^\d+$/u.test(value))
+        throw new CliArgumentError("Session inbox limit must be an integer.");
+    const limit = Number(value);
+    if (limit >= 1 && limit <= MAX_SESSION_INBOX_CHECK_LIMIT)
+        return limit;
+    throw new CliArgumentError(`Session inbox limit must be from 1 to ${String(MAX_SESSION_INBOX_CHECK_LIMIT)}.`);
+};
+const parseSessionInboxCheck = (tokens) => {
+    const parsed = parseOptions(tokens, new Set(["--limit"]), new Set(["--attached"]));
+    requirePositionals(parsed.positionals, 0);
+    requireAttachedFlag(parsed.flags);
+    const limit = parsed.options.get("--limit");
+    return {
+        ...(limit === undefined ? {} : { limit: readSessionInboxLimit(limit) }),
+    };
+};
+export const runSessionInboxCheck = (tokens, context) => Effect.gen(function* () {
+    const operation = context.dependencies.checkAttachedSessionInbox;
+    if (operation === undefined)
+        throw new CliArgumentError("Attached Session inbox is unavailable.");
+    const result = yield* operation(parseSessionInboxCheck(tokens));
+    return writeSessionResult(result, context, (value) => ({
+        command: "session.inbox.check",
+        result: {
+            count: value.deliveries.length,
+            deliveries: value.deliveries.map(projectInboxDelivery),
+            mailboxId: value.mailbox.id,
+            mailboxRevision: value.mailbox.revision,
+        },
+    }));
+});
+const summarizeInboxAck = (result) => ({
+    delivery: result.delivery,
+    deliveryRecord: {
+        acknowledgedAt: result.deliveryRecord.acknowledgedAt,
+        acknowledgingSessionId: result.deliveryRecord.acknowledgingSessionId,
+        deliveryId: result.deliveryRecord.id,
+        mailboxId: result.deliveryRecord.mailboxId,
+        messageId: result.deliveryRecord.message.id,
+        sequence: result.deliveryRecord.sequence,
+    },
+    mailboxId: result.mailboxId,
+    mailboxRevision: result.mailboxRevision,
+    receipt: result.receipt,
+});
+const parseSessionInboxAck = (tokens) => {
+    const parsed = parseOptions(tokens, new Set(["--command-id", "--expected-mailbox-revision"]), new Set(["--attached"]));
+    requirePositionals(parsed.positionals, 1);
+    requireAttachedFlag(parsed.flags);
+    const deliveryId = parsed.positionals[0];
+    if (deliveryId === undefined)
+        throw new CliArgumentError("The delivery identifier is missing.");
+    const commandId = parsed.options.get("--command-id");
+    return {
+        ...(commandId === undefined ? {} : { commandId }),
+        deliveryId,
+        expectedMailboxRevision: readExpectedRevision(parsed.options.get("--expected-mailbox-revision")),
+    };
+};
+export const runSessionInboxAck = (tokens, context) => Effect.gen(function* () {
+    const operation = context.dependencies.acknowledgeAttachedSessionDelivery;
+    if (operation === undefined)
+        throw new CliArgumentError("Attached Session acknowledgement is unavailable.");
+    const result = yield* operation(parseSessionInboxAck(tokens));
+    return writeSessionResult(result, context, (value) => ({
+        command: "session.inbox.ack",
+        result: summarizeInboxAck(value),
+    }));
+});
+//# sourceMappingURL=commands.js.map

package/dist/session/create-tasks.d.ts

@@ -0,0 +1,20 @@
+import { type CommandContext, type CommandEffect } from "../command-line/index.js";
+import type { CreateSessionInput } from "./client.js";
+export type SessionTaskSource = {
+    readonly kind: "file";
+    readonly path: string;
+} | {
+    readonly kind: "message";
+    readonly text: string;
+} | {
+    readonly kind: "stdin";
+};
+export type SessionTasksRequest = {
+    readonly commandId?: string;
+    readonly projectId?: string;
+    readonly selection: Omit<CreateSessionInput, "workspaceId">;
+    readonly source: SessionTaskSource;
+    readonly workspaceId?: string;
+};
+export declare const runSessionTasks: (request: SessionTasksRequest, context: CommandContext) => CommandEffect;
+//# sourceMappingURL=create-tasks.d.ts.map

package/dist/session/create-tasks.js

@@ -0,0 +1,110 @@
+import { MAX_SESSION_CREATION_TASKS, MAX_TURN_INPUT_BYTES, } from "@maiaos/sdk";
+import { Effect } from "effect";
+import { CliArgumentError, reportError, writeSuccess, } from "../command-line/index.js";
+import { formatSessionTasks } from "./output/index.js";
+import { readTaskFile } from "./task-file.js";
+const EXIT_OUTCOME_UNKNOWN = 76;
+const EXIT_REFUSED = 70;
+const readText = (source, context) => {
+    if (source.kind === "message")
+        return Effect.succeed(source.text);
+    if (source.kind === "file")
+        return readTaskFile(source.path);
+    if (context.io.stdin === undefined)
+        return Effect.fail(new CliArgumentError("Standard input is unavailable."));
+    return context.io.stdin({
+        label: "Session task",
+        maxBytes: MAX_TURN_INPUT_BYTES,
+        maxChunks: 1024,
+    });
+};
+const refusalMessage = (refusal) => refusal.reason === "too_long"
+    ? `Task line ${String(refusal.line)} exceeds ${String(MAX_TURN_INPUT_BYTES)} bytes.`
+    : `A batch holds at most ${String(MAX_SESSION_CREATION_TASKS)} tasks; line ${String(refusal.line)} is beyond it.`;
+const toInput = (request, text) => {
+    const { baseRef, connectionId, executor, model, role, title } = request.selection;
+    const { projectId, source, workspaceId } = request;
+    return {
+        ...(projectId === undefined ? {} : { projectId }),
+        session: {
+            ...(connectionId === undefined ? {} : { connectionId }),
+            ...(executor === undefined ? {} : { executor }),
+            ...(model === undefined ? {} : { model }),
+            ...(role === undefined ? {} : { role }),
+            ...(title === undefined ? {} : { title }),
+            ...(baseRef === undefined ? {} : { worktree: { baseRef } }),
+        },
+        split: source.kind === "file" ? "lines" : "whole",
+        text,
+        ...(workspaceId === undefined ? {} : { workspaceId }),
+    };
+};
+const reportItem = (plan, outcome) => {
+    const commandId = outcome.stage === "unknown" ? outcome.error?.commandId : undefined;
+    const { error, index, receipts, sessionId, stage, turnId } = outcome;
+    return {
+        ...(error === undefined ? {} : { error }),
+        line: plan.items[index]?.line ?? 0,
+        receipts,
+        ...(commandId === undefined ? {} : { recovery: { commandId } }),
+        ...(sessionId === undefined ? {} : { sessionId }),
+        stage,
+        ...(turnId === undefined ? {} : { turnId }),
+    };
+};
+const MAX_TASK_COMMAND_ID_LENGTH = 122;
+const withCommandId = (plan, commandId) => {
+    if (commandId === undefined)
+        return plan;
+    if (plan.items.length !== 1)
+        throw new CliArgumentError("Option '--command-id' names one Session; the input holds several tasks.");
+    if (commandId.length > MAX_TASK_COMMAND_ID_LENGTH)
+        throw new CliArgumentError(`Option '--command-id' takes at most ${String(MAX_TASK_COMMAND_ID_LENGTH)} characters with a first message.`);
+    return {
+        ...plan,
+        items: plan.items.map((item) => ({
+            ...item,
+            commands: {
+                create: commandId,
+                send: `${commandId}.send`,
+                start: `${commandId}.start`,
+            },
+        })),
+    };
+};
+const exitCode = (items) => {
+    if (items.some((item) => item.stage === "unknown"))
+        return EXIT_OUTCOME_UNKNOWN;
+    return items.every((item) => item.stage === "sent" || item.stage === "started")
+        ? 0
+        : EXIT_REFUSED;
+};
+const writeBatch = (plan, outcomes, context) => {
+    const items = outcomes.map((outcome) => reportItem(plan, outcome));
+    const code = exitCode(items);
+    writeSuccess({
+        command: "session.create.tasks",
+        result: { items, workspaceId: plan.workspaceId },
+    }, { ...context, ok: code === 0 }, ({ result }) => formatSessionTasks(result));
+    return code;
+};
+export const runSessionTasks = (request, context) => Effect.gen(function* () {
+    const { planSessions, runSessions } = context.dependencies;
+    if (planSessions === undefined || runSessions === undefined)
+        return yield* new CliArgumentError("Session tasks are unavailable.");
+    const text = yield* readText(request.source, context);
+    if (text.trim() === "")
+        return yield* new CliArgumentError("The task text is empty.");
+    const planned = yield* planSessions(toInput(request, text));
+    if (!planned.ok)
+        return reportError(planned.error, context);
+    const plan = withCommandId(planned.value, request.commandId);
+    const [refusal] = plan.refusals;
+    if (refusal !== undefined)
+        return yield* new CliArgumentError(refusalMessage(refusal));
+    const ran = yield* runSessions(plan);
+    if (!ran.ok)
+        return reportError(ran.error, context);
+    return writeBatch(plan, ran.value, context);
+});
+//# sourceMappingURL=create-tasks.js.map

package/dist/session/index.d.ts

@@ -0,0 +1,9 @@
+export { runAgentPermissionSet } from "./agent-permission.js";
+export { runSessionAttach } from "./attach.js";
+export type { AttachSessionInput, SessionAttachStream, } from "./attach-client.js";
+export { type CreateSessionInput, type ListSessionsInput, makeSessionClient, type StartSessionInput, } from "./client.js";
+export { type ArchiveSessionInput, type DiffSessionInput, } from "./coding-client.js";
+export { runSessionArchive, runSessionDiff } from "./coding-commands.js";
+export { runSessionCreate, runSessionEventsList, runSessionInboxAck, runSessionInboxCheck, runSessionList, runSessionMessageSend, runSessionObserve, runSessionResume, runSessionShow, runSessionStart, runSessionStop, } from "./commands.js";
+export { runSessionRename } from "./rename.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/session/index.js

@@ -0,0 +1,7 @@
+export { runAgentPermissionSet } from "./agent-permission.js";
+export { runSessionAttach } from "./attach.js";
+export { makeSessionClient, } from "./client.js";
+export { runSessionArchive, runSessionDiff } from "./coding-commands.js";
+export { runSessionCreate, runSessionEventsList, runSessionInboxAck, runSessionInboxCheck, runSessionList, runSessionMessageSend, runSessionObserve, runSessionResume, runSessionShow, runSessionStart, runSessionStop, } from "./commands.js";
+export { runSessionRename } from "./rename.js";
+//# sourceMappingURL=index.js.map