@maiaos/cli 0.1.0-canary.2

package/dist/bootstrap/index.d.ts

@@ -0,0 +1,3 @@
+export { processIo, runProcessMain } from "./process.js";
+export { runMaiaBootstrap } from "./run.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/bootstrap/index.js

@@ -0,0 +1,3 @@
+export { processIo, runProcessMain } from "./process.js";
+export { runMaiaBootstrap } from "./run.js";
+//# sourceMappingURL=index.js.map

package/dist/bootstrap/process.d.ts

@@ -0,0 +1,5 @@
+import * as Effect from "effect/Effect";
+import type { CliIo } from "../command-line/index.js";
+export declare const processIo: () => CliIo;
+export declare const runProcessMain: (program: Effect.Effect<number>) => void;
+//# sourceMappingURL=process.d.ts.map

package/dist/bootstrap/process.js

@@ -0,0 +1,45 @@
+import process from "node:process";
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Runtime from "effect/Runtime";
+import { promptLine, terminalIsInteractive, } from "../command-line/input/index.js";
+const readProcessStdin = (request) => Effect.promise(() => import("./stdio.js")).pipe(Effect.flatMap((stdio) => stdio.readStdin(request)));
+export const processIo = () => ({
+    interactive: terminalIsInteractive(),
+    prompt: promptLine,
+    stderr(text) {
+        process.stderr.write(text);
+    },
+    stdin: readProcessStdin,
+    stdout(text) {
+        process.stdout.write(text);
+    },
+});
+const EXIT_INTERRUPTED = 130;
+const runMain = Runtime.makeRunMain(({ fiber, teardown }) => {
+    fiber.addObserver((exit) => {
+        teardown(exit, (code) => {
+            process.exitCode = code;
+        });
+    });
+});
+export const runProcessMain = (program) => {
+    runMain(program, {
+        disableErrorReporting: true,
+        teardown: (exit, onExit) => {
+            if (Exit.isSuccess(exit) && typeof exit.value === "number") {
+                onExit(exit.value);
+                return;
+            }
+            if (Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause)) {
+                onExit(EXIT_INTERRUPTED);
+                return;
+            }
+            if (Exit.isFailure(exit))
+                process.stderr.write(`${Cause.pretty(exit.cause)}\n`);
+            onExit(1);
+        },
+    });
+};
+//# sourceMappingURL=process.js.map

package/dist/bootstrap/run.d.ts

@@ -0,0 +1,25 @@
+import * as Effect from "effect/Effect";
+import type { CliIo } from "../command-line/index.js";
+type AgentModule = {
+    readonly runMaiaAgent?: (arguments_: readonly string[], options: {
+        readonly io: Pick<CliIo, "stderr" | "stdout">;
+    }) => Promise<number>;
+};
+type ProductCliModule = {
+    readonly runCli?: (arguments_: readonly string[], version: string, io: CliIo) => Effect.Effect<number>;
+};
+export type MaiaBootstrapDependencies = {
+    readonly loadAgent: () => Promise<AgentModule>;
+    readonly loadProductCli: () => Promise<ProductCliModule>;
+};
+type MaiaBootstrapInput = {
+    readonly arguments_: readonly string[];
+    readonly currentNodeVersion: string;
+    readonly expectedNodeVersion: string;
+    readonly io: CliIo;
+    readonly version: string;
+};
+export declare const isAgentInvocation: (arguments_: readonly string[]) => boolean;
+export declare const runMaiaBootstrap: (input: MaiaBootstrapInput, dependencies: MaiaBootstrapDependencies) => Effect.Effect<number>;
+export {};
+//# sourceMappingURL=run.d.ts.map

package/dist/bootstrap/run.js

@@ -0,0 +1,95 @@
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+const EXIT_SOFTWARE = 70;
+const EXIT_UNAVAILABLE = 69;
+const isDoctor = (arguments_) => !arguments_.includes("-h") &&
+    !arguments_.includes("--help") &&
+    arguments_.find((token) => !token.startsWith("-")) === "doctor";
+export const isAgentInvocation = (arguments_) => arguments_[0] === "agent";
+const reportBootstrapFailure = (subject, io) => {
+    io.stderr(`Maia ${subject} could not start; run 'maia doctor'.\n`);
+    return EXIT_SOFTWARE;
+};
+const load = (loader) => Effect.tryPromise({ catch: (error) => error, try: loader });
+const probe = (loader, passes) => load(loader).pipe(Effect.map(passes), Effect.catchCause((cause) => Cause.hasInterruptsOnly(cause) ? Effect.interrupt : Effect.succeed(false)));
+const probePayloads = (dependencies) => Effect.all([
+    probe(dependencies.loadProductCli, (module) => typeof module.runCli === "function"),
+    probe(dependencies.loadAgent, (module) => typeof module.runMaiaAgent === "function"),
+]).pipe(Effect.map(([cliPayload, agent]) => ({ agent, cliPayload })));
+const formatInstallation = (checks) => `Maia doctor failed\n${checks
+    .map((check) => `  ${check.code}: ${check.ok ? "ok" : "failed; next: reinstall Maia"}`)
+    .join("\n")}\n`;
+const writeInstallationFailure = (output) => {
+    const { arguments_, checks, input } = output;
+    const result = {
+        checks: checks.map((check) => check.ok ? check : { ...check, next: "reinstall Maia" }),
+        command: "doctor",
+        ok: false,
+        version: input.version,
+    };
+    input.io.stdout(arguments_.includes("--json")
+        ? `${JSON.stringify({ ok: true, result })}\n`
+        : formatInstallation(checks));
+    return EXIT_SOFTWARE;
+};
+const runDoctor = (input, dependencies) => Effect.flatMap(probePayloads(dependencies), (payloads) => {
+    const checks = [
+        { code: "bootstrap", ok: true },
+        {
+            code: "node_runtime",
+            ok: input.currentNodeVersion === input.expectedNodeVersion,
+        },
+        { code: "cli_payload", ok: payloads.cliPayload },
+        { code: "agent", ok: payloads.agent },
+    ];
+    return checks.every((check) => check.ok)
+        ? runProductCli(input, dependencies)
+        : Effect.succeed(writeInstallationFailure({
+            arguments_: input.arguments_,
+            checks,
+            input,
+        }));
+});
+const requireSupportedNode = (input) => {
+    if (input.currentNodeVersion === input.expectedNodeVersion)
+        return undefined;
+    input.io.stderr(`Maia CLI requires Node ${input.expectedNodeVersion}; received ${input.currentNodeVersion}.\n`);
+    return EXIT_UNAVAILABLE;
+};
+const missingEntry = Effect.fail(new Error("The payload lacks its entry."));
+const runPayload = ({ input, loader, run, subject, }) => load(loader).pipe(Effect.flatMap(run), Effect.catchCause((cause) => Cause.hasInterruptsOnly(cause)
+    ? Effect.interrupt
+    : Effect.sync(() => reportBootstrapFailure(subject, input.io))));
+const runAgent = (input, dependencies) => runPayload({
+    input,
+    loader: dependencies.loadAgent,
+    run: (module) => {
+        const runMaiaAgent = module.runMaiaAgent;
+        return typeof runMaiaAgent === "function"
+            ? Effect.tryPromise({
+                catch: (error) => error,
+                try: () => runMaiaAgent(input.arguments_.slice(1), { io: input.io }),
+            })
+            : missingEntry;
+    },
+    subject: "Agent",
+});
+const runProductCli = (input, dependencies) => runPayload({
+    input,
+    loader: dependencies.loadProductCli,
+    run: (module) => typeof module.runCli === "function"
+        ? module.runCli(input.arguments_, input.version, input.io)
+        : missingEntry,
+    subject: "CLI",
+});
+export const runMaiaBootstrap = (input, dependencies) => Effect.suspend(() => {
+    if (isDoctor(input.arguments_))
+        return runDoctor(input, dependencies);
+    const unsupportedNode = requireSupportedNode(input);
+    if (unsupportedNode !== undefined)
+        return Effect.succeed(unsupportedNode);
+    return isAgentInvocation(input.arguments_)
+        ? runAgent(input, dependencies)
+        : runProductCli(input, dependencies);
+});
+//# sourceMappingURL=run.js.map

package/dist/bootstrap/stdio.d.ts

@@ -0,0 +1,4 @@
+import * as Effect from "effect/Effect";
+import { type BoundedStdinRequest } from "../command-line/input/index.js";
+export declare const readStdin: (request: BoundedStdinRequest) => Effect.Effect<string, import("../command-line/input/arguments.js").CliArgumentError, never>;
+//# sourceMappingURL=stdio.d.ts.map

package/dist/bootstrap/stdio.js

@@ -0,0 +1,9 @@
+import * as NodeStdio from "@effect/platform-node-shared/NodeStdio";
+import * as Effect from "effect/Effect";
+import * as Stdio from "effect/Stdio";
+import { readBoundedStdin, } from "../command-line/input/index.js";
+export const readStdin = (request) => Effect.gen(function* () {
+    const stdio = yield* Stdio.Stdio;
+    return yield* readBoundedStdin(stdio.stdin, request);
+}).pipe(Effect.provide(NodeStdio.layer));
+//# sourceMappingURL=stdio.js.map

package/dist/cli/cli.d.ts

@@ -0,0 +1,17 @@
+import * as Effect from "effect/Effect";
+import type * as Scope from "effect/Scope";
+import { type CliDependencies, type CliIo } from "../command-line/index.js";
+import type { CliNodeConnector } from "../local-node/index.js";
+export type { CliDependencies, CliErrorOutput, CliIo, CliSuccessOutput, CliSuccessResult, } from "../command-line/index.js";
+export type { CliHelpResult, CliVersionResult } from "../command-tree/index.js";
+export type { CliStatusResult } from "../status/index.js";
+export type CliRemoteNode = {
+    readonly name: string;
+    readonly scope: Scope.Scope;
+};
+export type CliDependencyResolver = (profile: string | undefined, remote?: CliRemoteNode) => CliDependencies;
+type CliDependencySource = CliDependencies | CliDependencyResolver;
+export declare const makeCli: (dependencies: CliDependencySource) => (arguments_: readonly string[], version: string, io: CliIo) => Effect.Effect<number>;
+export declare const makeCliDependencies: (connector?: CliNodeConnector) => CliDependencyResolver;
+export declare const runCli: (arguments_: readonly string[], version: string, io: CliIo) => Effect.Effect<number>;
+//# sourceMappingURL=cli.d.ts.map