@maiaos/cli 0.1.0-canary.2

package/dist/cli/cli.js

@@ -0,0 +1,481 @@
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import { argumentsAreBounded, CliArgumentError, parseArguments, readGlobalValue, reportError, writeSuccess, } from "../command-line/index.js";
+import { createHelpTree, createNodeHelp, findNode, formatNodeHelp, formatRootHelp, isNodeBacked, REFERENCE_USAGE, unknownPathMessage, usageHint, } from "../command-tree/index.js";
+const createArgumentError = (message) => ({
+    code: "invalid_argument",
+    message,
+    retryable: false,
+});
+const invalidInvocation = (message, output) => ({
+    exitCode: reportError(createArgumentError(message), output),
+    ok: false,
+});
+const parseInvocation = (input) => {
+    const output = { io: input.io, json: input.arguments_.includes("--json") };
+    if (!argumentsAreBounded(input.arguments_))
+        return invalidInvocation("Command arguments exceed the limit.", output);
+    try {
+        const parsed = parseArguments(input.arguments_);
+        return parsed.jsonFlagCount > 1
+            ? invalidInvocation("Option '--json' may be used only once.", {
+                io: input.io,
+                json: true,
+            })
+            : { ok: true, parsed };
+    }
+    catch (error) {
+        if (!(error instanceof CliArgumentError))
+            throw error;
+        return invalidInvocation(error.message, output);
+    }
+};
+const NO_ENVIRONMENT = {};
+const readEnvironment = (leaf) => isNodeBacked(leaf)
+    ? Effect.flatMap(Effect.promise(() => import("./environment.js")), (module) => module.environmentOptions)
+    : Effect.succeed(NO_ENVIRONMENT);
+const fromEnvironment = (option, value) => value === undefined || value === ""
+    ? undefined
+    : readGlobalValue(option, value);
+const checkGlobalOptions = (parsed, leaf, remote) => {
+    if (parsed.node !== undefined && !remote)
+        throw new CliArgumentError(leaf.remote === false
+            ? `Option '--node' does not apply to 'maia ${leaf.path.join(" ")}', which manages this machine's Nodes.`
+            : "Option '--node' is supported only by Node-backed commands.");
+    if (parsed.profile !== undefined && !isNodeBacked(leaf))
+        throw new CliArgumentError("Option '--profile' is supported only by Node-backed commands.");
+};
+const noInputFrom = (value) => value !== undefined && value !== "" && value !== "0";
+const resolveOptions = (parsed, leaf, environment) => {
+    const nodeBacked = isNodeBacked(leaf);
+    const remote = nodeBacked && leaf.remote !== false;
+    checkGlobalOptions(parsed, leaf, remote);
+    const node = parsed.node ??
+        (remote ? fromEnvironment("--node", environment.node) : undefined);
+    const profile = parsed.profile ??
+        (nodeBacked
+            ? fromEnvironment("--profile", environment.profile)
+            : undefined);
+    const noInput = parsed.noInput || noInputFrom(environment.noInput);
+    return {
+        ...parsed,
+        noInput,
+        ...(node === undefined ? {} : { node }),
+        ...(profile === undefined ? {} : { profile }),
+    };
+};
+const resolveInvocationDependencies = (source, parsed, scope) => {
+    if (typeof source !== "function") {
+        if (parsed.profile !== undefined || parsed.node !== undefined)
+            throw new CliArgumentError("This CLI dependency binding does not support '--profile' or '--node'.");
+        return source;
+    }
+    return parsed.node === undefined || scope === undefined
+        ? source(parsed.profile)
+        : source(parsed.profile, { name: parsed.node, scope });
+};
+const commandContext = (input, parsed, scope) => ({
+    dependencies: resolveInvocationDependencies(input.dependencies, parsed, scope),
+    io: parsed.noInput ? { ...input.io, interactive: false } : input.io,
+    json: parsed.json,
+    ...(parsed.node === undefined ? {} : { node: parsed.node }),
+    ...(parsed.profile === undefined ? {} : { profile: parsed.profile }),
+    version: input.version,
+});
+const reportFailure = (error, context, tokens) => error instanceof CliArgumentError
+    ? reportError(createArgumentError(error.message), {
+        ...context,
+        usage: usageHint(tokens),
+    })
+    : reportError({
+        code: "internal_error",
+        message: "Maia CLI command failed.",
+        retryable: false,
+    }, context);
+const reportFailures = (effect, context, tokens) => effect.pipe(Effect.catchDefect((defect) => defect instanceof CliArgumentError
+    ? Effect.fail(defect)
+    : Effect.die(defect)), Effect.catchCause((cause) => Cause.hasInterruptsOnly(cause)
+    ? Effect.interrupt
+    : Effect.sync(() => reportFailure(Cause.squash(cause), context, tokens))));
+const isHelpInvocation = (parsed) => parsed.help || parsed.tokens[0] === undefined || parsed.tokens[0] === "help";
+const runHelp = (input, parsed) => Effect.sync(() => {
+    const strict = parsed.tokens[0] === "help";
+    const end = parsed.tokens.indexOf("--");
+    const tokens = end === -1 ? parsed.tokens : parsed.tokens.slice(0, end);
+    const path = strict ? tokens.slice(1) : tokens;
+    const { consumed, node } = findNode(path);
+    if (consumed < path.length && (strict || node.forms.length === 0))
+        throw new CliArgumentError(unknownPathMessage(path));
+    const root = node.path.length === 0;
+    writeSuccess(root
+        ? createHelpTree(input.version)
+        : createNodeHelp(input.version, node), { io: input.io, json: parsed.json }, () => (root ? formatRootHelp(input.version) : formatNodeHelp(node)));
+    return 0;
+});
+const findLeaf = (typed) => {
+    const tokens = typed[0] === "--version" ? ["version", ...typed.slice(1)] : typed;
+    const { consumed, node } = findNode(tokens);
+    if (node.forms.length === 0)
+        throw new CliArgumentError(unknownPathMessage(tokens));
+    return { leaf: node, rest: tokens.slice(consumed) };
+};
+const leafProgram = (leaf, rest, context) => {
+    const reference = leaf.run;
+    if (reference === undefined)
+        return Effect.die(new Error("No runner."));
+    const [load, name] = reference;
+    return Effect.flatMap(Effect.promise(load), (module) => {
+        const runner = Reflect.get(module, name);
+        return typeof runner === "function"
+            ? runner(rest, context)
+            : Effect.die(new Error(`No runner ${name}.`));
+    });
+};
+const withCliServices = (program) => Effect.promise(() => import("./services.js")).pipe(Effect.flatMap((services) => services.provideCliServices(program)));
+const runResolved = (leaf, rest, context) => {
+    const usage = leaf.forms[0]?.usage ?? "";
+    if (!REFERENCE_USAGE.test(usage) || context.dependencies.call === undefined)
+        return withCliServices(leafProgram(leaf, rest, context));
+    const program = Effect.promise(() => import("../reference/index.js")).pipe(Effect.flatMap((module) => module.prepareLeaf({
+        context,
+        cwd: module.workingFolder(context.io.cwd),
+        tokens: rest,
+        usage,
+    })), Effect.flatMap((prepared) => prepared.ok
+        ? leafProgram(leaf, prepared.tokens, prepared.context)
+        : Effect.succeed(prepared.exitCode)));
+    return withCliServices(program);
+};
+const runParsed = (input, parsed) => {
+    if (isHelpInvocation(parsed))
+        return runHelp(input, parsed);
+    return Effect.gen(function* () {
+        const { leaf, rest } = findLeaf(parsed.tokens);
+        const resolved = resolveOptions(parsed, leaf, yield* readEnvironment(leaf));
+        if (parsed.node === undefined &&
+            resolved.node !== undefined &&
+            !parsed.json)
+            input.io.stderr(`node: ${resolved.node} (MAIA_NODE)\n`);
+        const run = (scope) => Effect.suspend(() => runResolved(leaf, rest, commandContext(input, resolved, scope)));
+        return yield* resolved.node === undefined
+            ? run()
+            : Effect.scoped(Effect.flatMap(Effect.scope, run));
+    });
+};
+const executeCli = (input) => Effect.suspend(() => {
+    const invocation = parseInvocation(input);
+    if (!invocation.ok)
+        return Effect.succeed(invocation.exitCode);
+    const { parsed } = invocation;
+    return reportFailures(runParsed(input, parsed), { io: input.io, json: parsed.json }, parsed.tokens);
+});
+export const makeCli = (dependencies) => (arguments_, version, io) => executeCli({
+    arguments_,
+    dependencies,
+    io,
+    version,
+});
+const loadProjectWorkspace = () => import("../project-workspace/index.js");
+const loadProvider = () => import("../provider/index.js");
+const loadOrchestration = () => import("../orchestration/index.js");
+const loadSession = () => import("../session/index.js");
+const loadTerminal = () => import("../terminal/index.js");
+const loadTurn = () => import("../session/turn/index.js");
+const loadStatus = () => import("../status/index.js");
+const loadContext = () => import("../context/index.js");
+const loadContainer = () => import("../container/index.js");
+const loadHold = () => import("../hold/index.js");
+const loadImport = () => import("../import/index.js");
+const loadInteraction = () => import("../session/interaction/index.js");
+const loadConnection = () => import("../connection/index.js");
+const loadIntegration = () => import("../integration/index.js");
+const loadPresentation = () => import("../presentation/index.js");
+const loadMcp = () => import("../mcp/index.js");
+const loadPortLease = () => import("../port-lease/index.js");
+const loadApproval = () => import("../session/approval/index.js");
+const loadRemoteNode = () => import("../remote-node/index.js");
+const loadRunLedger = () => import("../run-ledger/index.js");
+const loadProjectGuard = () => import("../project-guard/index.js");
+const loadLocalNode = () => import("../local-node/index.js");
+const lazyDependencies = (load, makeClient, binding) => Object.fromEntries(binding.names.map((name) => [
+    name,
+    (...arguments_) => Effect.promise(() => import("../local-node/index.js")).pipe(Effect.flatMap((module) => module.runLazyNodeDependency({
+        arguments_,
+        binding,
+        loadClient: load,
+        makeClient,
+        name,
+    }))),
+]));
+const makeDefaultCliDependencies = (binding) => ({
+    runAgent: (arguments_, io) => Effect.tryPromise({
+        catch: (error) => error,
+        try: () => import("@maiaos/agent").then((module) => module.runMaiaAgent(arguments_, { io })),
+    }),
+    ...lazyDependencies(loadPresentation, (module, node) => module.makePresentationClient(node), {
+        ...binding,
+        names: [
+            "showPresentationCatalog",
+            "showWorkspaceDirectory",
+            "showProjectList",
+            "showSessionList",
+        ],
+    }),
+    ...lazyDependencies(loadIntegration, (module, node) => module.makeIntegrationClient(node), {
+        ...binding,
+        names: [
+            "planCodexIntegration",
+            "statusCodexIntegration",
+            "applyCodexIntegration",
+            "removeCodexIntegration",
+            "planClaudeCodeIntegration",
+            "statusClaudeCodeIntegration",
+            "applyClaudeCodeIntegration",
+            "removeClaudeCodeIntegration",
+        ],
+    }),
+    ...lazyDependencies(loadConnection, (module, node) => module.makeConnectionClient(node), {
+        ...binding,
+        names: [
+            "createConnection",
+            "createGatewayConnection",
+            "listConnections",
+            "listConnectionModels",
+            "showConnection",
+            "showConnectionUsage",
+            "setConnectionCapacity",
+            "setConnectionState",
+            "startConnectionLogin",
+            "detectConnections",
+            "previewSystemConnections",
+            "confirmSystemConnections",
+        ],
+    }),
+    ...lazyDependencies(loadInteraction, (module, node) => module.makeInteractionClient(node), {
+        ...binding,
+        names: [
+            "createInteraction",
+            "listInteractions",
+            "showInteraction",
+            "respondToInteraction",
+            "cancelInteraction",
+        ],
+    }),
+    ...lazyDependencies(loadContainer, (module, node) => module.makeContainerClient(node), {
+        ...binding,
+        names: [
+            "listContainers",
+            "listContainerIndex",
+            "showContainer",
+            "previewContainerCreate",
+            "confirmContainerCreate",
+            "previewContainerRename",
+            "confirmContainerRename",
+        ],
+    }),
+    ...lazyDependencies(loadImport, (module, node) => module.makeDiscoveryClient(node), {
+        ...binding,
+        names: [
+            "listDiscoveredSessions",
+            "readSessionHistory",
+            "previewSessionAdopt",
+            "confirmSessionAdopt",
+        ],
+    }),
+    ...lazyDependencies(loadHold, (module, node) => module.makeHoldClient(node), {
+        ...binding,
+        names: [
+            "listHolds",
+            "previewHoldPlace",
+            "confirmHoldPlace",
+            "previewHoldRelease",
+            "confirmHoldRelease",
+        ],
+    }),
+    ...lazyDependencies(() => import("../project-workspace/index.js"), (module, node) => module.makeProjectMetadataClient(node), {
+        ...binding,
+        names: [
+            "previewProjectCreate",
+            "confirmProjectCreate",
+            "previewProjectRename",
+            "confirmProjectRename",
+        ],
+    }),
+    ...lazyDependencies(loadProjectWorkspace, (module, node) => module.makeProjectWorkspaceClient(node), {
+        ...binding,
+        names: [
+            "attachWorkspaceMembership",
+            "attachWorkspaceRepository",
+            "configureWorkspaceExecution",
+            "createExecutionCheckpoint",
+            "createExecutionPlacement",
+            "createExecutionWorktree",
+            "getReceipt",
+            "importExecutionWorktree",
+            "listProjectContext",
+            "listProjects",
+            "listReceipts",
+            "listWorkspaces",
+            "readExecutionCatalog",
+            "readExecutionFile",
+            "reconcileExecutionWorktree",
+            "recordProjectContext",
+            "registerProject",
+            "removeExecutionWorktree",
+            "runExecutionCommand",
+            "selectWorkspace",
+            "planExecutionWorktreeRemove",
+            "showExecutionCheckpoint",
+            "showExecutionPlacement",
+            "showExecutionWorktreeStatus",
+            "showProject",
+            "showProjectContext",
+            "showWorkspace",
+            "showWorkspaceContext",
+            "showWorkspaceExecution",
+        ],
+    }),
+    ...lazyDependencies(loadProvider, (module, node) => module.makeProviderClient(node), { ...binding, names: ["listProviderPools"] }),
+    ...lazyDependencies(loadOrchestration, (module, node) => module.makeOrchestrationClient(node), {
+        ...binding,
+        names: [
+            "acknowledgeRunDelivery",
+            "cancelRunQuestion",
+            "checkRunInbox",
+            "createRun",
+            "listRuns",
+            "listTasks",
+            "openRunQuestion",
+            "replyRunQuestion",
+            "settleRunDispatchTerminal",
+            "showDispatch",
+            "showRun",
+            "showTask",
+        ],
+    }),
+    ...lazyDependencies(loadSession, (module, node) => module.makeSessionClient(node), {
+        ...binding,
+        names: [
+            "acknowledgeAttachedSessionDelivery",
+            "archiveSession",
+            "awaitSessionRunning",
+            "attachSession",
+            "checkAttachedSessionInbox",
+            "applyExecutionRelocation",
+            "confirmAgentPermission",
+            "previewAgentPermission",
+            "createSession",
+            "diffSession",
+            "listSessionEvents",
+            "planExecutionRelocation",
+            "reconcileExecutionRelocation",
+            "listSessions",
+            "observeSessions",
+            "planSessions",
+            "resumeSession",
+            "runSessions",
+            "sendAttachedSessionMessage",
+            "showExecutionRelocation",
+            "showSession",
+            "startSession",
+            "stopSession",
+        ],
+    }),
+    ...lazyDependencies(loadTerminal, (module, node) => module.makeTerminalClient(node), {
+        ...binding,
+        names: [
+            "acquireTerminalController",
+            "closeTerminal",
+            "createTerminal",
+            "listTerminalEvents",
+            "listTerminals",
+            "readTerminal",
+            "releaseTerminalController",
+            "requestTerminalController",
+            "resizeTerminal",
+            "showTerminal",
+            "showTerminalControllerRequest",
+            "signalTerminal",
+            "writeTerminalInput",
+        ],
+    }),
+    ...lazyDependencies(loadTurn, (module, node) => module.makeTurnClient(node), {
+        ...binding,
+        names: ["interruptTurn", "sendTurn", "showTurn", "waitTurns"],
+    }),
+    ...lazyDependencies(loadContext, (module, node) => module.makeContextClient(node), { ...binding, names: ["showAttachedCurrentContext", "showCurrentContext"] }),
+    ...lazyDependencies(loadApproval, (module, node) => module.makeApprovalClient(node), {
+        ...binding,
+        names: ["listApprovals", "respondToApproval", "showApproval"],
+    }),
+    ...lazyDependencies(loadPortLease, (module, node) => module.makePortLeaseClient(node), {
+        ...binding,
+        names: [
+            "acquirePortLease",
+            "listPortLeases",
+            "releasePortLease",
+            "renewPortLease",
+        ],
+    }),
+    ...lazyDependencies(loadRunLedger, (module, node) => module.makeRunLedgerClient(node), {
+        ...binding,
+        names: [
+            "createRunLedger",
+            "dispatchRunLedgerTask",
+            "listRunLedgerTasks",
+            "listRunLedgers",
+            "settleRunLedgerTask",
+            "showRunLedgerTask",
+        ],
+    }),
+    ...lazyDependencies(loadProjectGuard, (module, node) => module.makeProjectGuardClient(node), {
+        ...binding,
+        names: ["confirmProjectGuard", "previewProjectGuard", "showProjectGuard"],
+    }),
+    ...lazyDependencies(loadRemoteNode, (module, node) => module.makeRemoteNodeClient(node), {
+        ...binding,
+        names: [
+            "confirmRemoteNodeInstall",
+            "confirmRemoteNodeRemove",
+            "listRemoteNodes",
+            "previewRemoteNodeInstall",
+            "previewRemoteNodeRemove",
+        ],
+    }),
+    ...lazyDependencies(loadLocalNode, (module, node) => module.makeCallClient(node), { ...binding, names: ["call"] }),
+    ...lazyDependencies(loadMcp, (module, node) => module.makeMcpClient(node), {
+        ...binding,
+        names: ["serveMcp"],
+    }),
+    ...lazyDependencies(loadStatus, (module, node) => module.makeStatusClient(node), { ...binding, names: ["createMonitorBootstrap", "readStatus"] }),
+});
+const remoteConnector = (remote, local) => {
+    const cache = {};
+    return (options) => Effect.promise(loadRemoteNode).pipe(Effect.flatMap((module) => {
+        cache.connector ??= module.makeRemoteNodeConnector({
+            ...(local === undefined ? {} : { local }),
+            name: remote.name,
+            scope: remote.scope,
+        });
+        return cache.connector(options);
+    }));
+};
+const remoteSignIn = (remote, binding) => (connection) => Effect.promise(loadRemoteNode).pipe(Effect.flatMap((module) => module.remoteVendorLogin({ ...binding, name: remote.name })(connection)));
+export const makeCliDependencies = (connector) => (profile, remote) => {
+    const binding = {
+        ...(connector === undefined ? {} : { connector }),
+        ...(profile === undefined ? {} : { profile }),
+    };
+    return remote === undefined
+        ? makeDefaultCliDependencies(binding)
+        : {
+            ...makeDefaultCliDependencies({
+                ...binding,
+                connector: remoteConnector(remote, connector),
+                remote: true,
+            }),
+            runVendorLogin: remoteSignIn(remote, binding),
+        };
+};
+export const runCli = makeCli(makeCliDependencies());
+//# sourceMappingURL=cli.js.map

package/dist/cli/environment.d.ts

@@ -0,0 +1,8 @@
+import * as Effect from "effect/Effect";
+export type EnvironmentOptions = {
+    readonly node?: string;
+    readonly noInput?: string;
+    readonly profile?: string;
+};
+export declare const environmentOptions: Effect.Effect<EnvironmentOptions>;
+//# sourceMappingURL=environment.d.ts.map

package/dist/cli/environment.js

@@ -0,0 +1,12 @@
+import * as Config from "effect/Config";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+const readVariable = (name) => Effect.map(Effect.orElseSucceed(Config.option(Config.String(name)), Option.none), (value) => Option.getOrUndefined(value));
+export const environmentOptions = Effect.gen(function* () {
+    return {
+        node: yield* readVariable("MAIA_NODE"),
+        noInput: yield* readVariable("MAIA_NO_INPUT"),
+        profile: yield* readVariable("MAIA_PROFILE"),
+    };
+});
+//# sourceMappingURL=environment.js.map

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+export { type CliDependencies, type CliDependencyResolver, type CliErrorOutput, type CliHelpResult, type CliIo, type CliStatusResult, type CliSuccessOutput, type CliSuccessResult, type CliVersionResult, makeCli, makeCliDependencies, runCli, } from "./cli.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/index.js

@@ -0,0 +1,2 @@
+export { makeCli, makeCliDependencies, runCli, } from "./cli.js";
+//# sourceMappingURL=index.js.map

package/dist/cli/services.d.ts

@@ -0,0 +1,4 @@
+import * as Effect from "effect/Effect";
+import type { CliServices } from "../command-line/index.js";
+export declare const provideCliServices: <TValue, TError>(command: Effect.Effect<TValue, TError, CliServices>) => Effect.Effect<TValue, TError>;
+//# sourceMappingURL=services.d.ts.map

package/dist/cli/services.js

@@ -0,0 +1,4 @@
+import * as NodeCrypto from "@effect/platform-node-shared/NodeCrypto";
+import * as Effect from "effect/Effect";
+export const provideCliServices = (command) => Effect.provide(command, NodeCrypto.layer);
+//# sourceMappingURL=services.js.map