@maiaos/cli 0.1.0-canary.2

package/dist/remote-node/connector.js

@@ -0,0 +1,122 @@
+import * as NodeChildProcessSpawner from "@effect/platform-node-shared/NodeChildProcessSpawner";
+import * as NodeCrypto from "@effect/platform-node-shared/NodeCrypto";
+import * as NodeFileSystem from "@effect/platform-node-shared/NodeFileSystem";
+import * as NodePath from "@effect/platform-node-shared/NodePath";
+import { MaiaClientError, } from "@maiaos/sdk";
+import { bridgeScript, openNodeBridge, shellQuote, sshCommandArguments, } from "@maiaos/sdk/node/effect";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as ChildProcess from "effect/process/ChildProcess";
+import * as Scope from "effect/Scope";
+import * as Stream from "effect/Stream";
+import { connectLocalNode, discoveryOptionsFor, newCliIdentifier, } from "../local-node/index.js";
+const spawner = NodeChildProcessSpawner.layer.pipe(Layer.provide(Layer.merge(NodeFileSystem.layer, NodePath.layer)));
+const BRIDGE_DEADLINE = Duration.seconds(30);
+const unreachable = (name, reason) => new MaiaClientError("transport_failure", reason, {
+    remoteError: {
+        code: "node_unavailable",
+        message: `Remote Node ${name}: ${reason}`,
+        retryable: true,
+    },
+});
+export const readRemoteNode = (connector, options, name) => Effect.gen(function* () {
+    const local = yield* connector(options);
+    const messageId = yield* newCliIdentifier("request");
+    const listed = yield* local.client.listRemoteNodes({}, { messageId });
+    const node = listed.nodes.find((candidate) => candidate.name === name);
+    if (node === undefined)
+        return yield* Effect.fail(unreachable(name, "no Node has this name; see maia node list."));
+    return node;
+});
+const STDERR_TAIL_BYTES = 512;
+const spawnBridge = (node) => ChildProcess.make("ssh", sshCommandArguments({
+    host: node.host,
+    script: bridgeScript(node.launcherPath),
+}), { stderr: "pipe", stdin: "pipe", stdout: "pipe" });
+const keepStderrTail = (stderr, tail) => stderr.pipe(Stream.decodeText(), Stream.runForEach((chunk) => Effect.sync(() => {
+    tail.text = `${tail.text}${chunk}`.slice(-STDERR_TAIL_BYTES);
+})), Effect.ignore, Effect.forkScoped);
+const reasonOf = (error, tail) => {
+    const said = tail.trim().split("\n").at(-1) ?? "";
+    return said === "" ? `${error.message}.` : `${error.message}: ${said}`;
+};
+const asRecorded = (node, bridge) => {
+    const { client, closed, hello } = bridge;
+    return hello.status.profile === node.profile
+        ? Effect.succeed({
+            client,
+            closed,
+            status: hello.status,
+            version: hello.version,
+        })
+        : Effect.fail(unreachable(node.name, "the bridge answers for another profile."));
+};
+export const openRemoteBridge = (node, scope) => {
+    if (node.state !== "ready")
+        return Effect.fail(unreachable(node.name, `it is ${node.state}, not ready.`));
+    const tail = { text: "" };
+    return Effect.gen(function* () {
+        const handle = yield* spawnBridge(node);
+        yield* keepStderrTail(handle.stderr, tail);
+        const bridge = yield* openNodeBridge(handle, {
+            helloDeadline: BRIDGE_DEADLINE,
+        });
+        return yield* asRecorded(node, bridge);
+    }).pipe(Effect.provide(spawner), Effect.provideService(Scope.Scope, scope), Effect.mapError((error) => error instanceof MaiaClientError
+        ? error
+        : unreachable(node.name, reasonOf(error, tail.text))));
+};
+export const makeRemoteNodeConnector = (input) => {
+    const local = input.local ?? connectLocalNode;
+    const cache = {};
+    const open = (options) => Effect.gen(function* () {
+        const cached = cache.bridge;
+        if (cached !== undefined && !(yield* cached.closed))
+            return cached;
+        const node = yield* readRemoteNode(local, options, input.name);
+        const bridge = yield* openRemoteBridge(node, input.scope);
+        cache.bridge = bridge;
+        return bridge;
+    });
+    return (options) => open(options).pipe(Effect.map((bridge) => ({
+        client: bridge.client,
+        status: bridge.status,
+    })));
+};
+const vendorCommand = (executor) => executor === "codex-cli"
+    ? { arguments_: "login --device-auth", variable: "CODEX_HOME" }
+    : { arguments_: "auth login", variable: "CLAUDE_CONFIG_DIR" };
+const directoryOf = (path) => path.slice(0, Math.max(1, path.lastIndexOf("/")));
+export const remoteSignInScript = (node, connection) => {
+    const pinned = node.executors.find((executor) => executor.executor === connection.executor);
+    if (pinned?.state !== "available" || pinned.path === undefined)
+        return undefined;
+    const vendor = vendorCommand(connection.executor);
+    const path = [
+        directoryOf(pinned.path),
+        ...(pinned.interpreter === undefined
+            ? []
+            : [directoryOf(pinned.interpreter.path)]),
+        "/usr/local/bin",
+        "/usr/bin",
+        "/bin",
+    ].join(":");
+    const account = connection.configRoot.kind === "maia-managed"
+        ? `${vendor.variable}=${shellQuote(connection.configRoot.path)} `
+        : "";
+    return `exec env PATH=${shellQuote(path)} ${account}${shellQuote(pinned.path)} ${vendor.arguments_}`;
+};
+const signInOver = (node, connection) => Effect.gen(function* () {
+    const script = remoteSignInScript(node, connection);
+    if (script === undefined)
+        return yield* Effect.fail(unreachable(node.name, `no pinned ${connection.executor} binary is available there.`));
+    const handle = yield* ChildProcess.make("ssh", sshCommandArguments({ host: node.host, script, terminal: true }), { stderr: "inherit", stdin: "inherit", stdout: "inherit" });
+    return yield* handle.exitCode.pipe(Effect.map(Number), Effect.orElseSucceed(() => 1));
+});
+export const remoteVendorLogin = (input) => (connection) => Effect.gen(function* () {
+    const options = yield* discoveryOptionsFor(input.profile);
+    const node = yield* readRemoteNode(input.connector ?? connectLocalNode, options, input.name);
+    return yield* signInOver(node, connection);
+}).pipe(Effect.scoped, Effect.provide(Layer.merge(spawner, NodeCrypto.layer)));
+//# sourceMappingURL=connector.js.map

package/dist/remote-node/index.d.ts

@@ -0,0 +1,4 @@
+export { makeRemoteNodeClient, type RemoteNodeCliDependencies, } from "./client.js";
+export { runNodeInstall, runNodeList, runNodeRemove } from "./commands.js";
+export { makeRemoteNodeConnector, remoteVendorLogin } from "./connector.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/remote-node/index.js

@@ -0,0 +1,4 @@
+export { makeRemoteNodeClient, } from "./client.js";
+export { runNodeInstall, runNodeList, runNodeRemove } from "./commands.js";
+export { makeRemoteNodeConnector, remoteVendorLogin } from "./connector.js";
+//# sourceMappingURL=index.js.map

package/dist/remote-node/reachability.d.ts

@@ -0,0 +1,22 @@
+import type { RemoteNodeRecord } from "@maiaos/sdk";
+import * as Effect from "effect/Effect";
+export type Reachability = {
+    readonly latencyMs: number;
+    readonly pid: number;
+    readonly state: "reachable";
+    readonly version: string;
+} | {
+    readonly reason: string;
+    readonly state: "not_checked";
+} | {
+    readonly reason: string;
+    readonly state: "stale";
+} | {
+    readonly reason: string;
+    readonly state: "unknown";
+} | {
+    readonly reason: string;
+    readonly state: "unreachable";
+};
+export declare const checkReachability: (node: RemoteNodeRecord) => Effect.Effect<Reachability>;
+//# sourceMappingURL=reachability.d.ts.map

package/dist/remote-node/reachability.js

@@ -0,0 +1,34 @@
+import * as Clock from "effect/Clock";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import { openRemoteBridge } from "./connector.js";
+const CHECK_DEADLINE = Duration.seconds(12);
+const greeted = (node, bridge, latencyMs) => node.maiaVersion === undefined || bridge.version === node.maiaVersion
+    ? {
+        latencyMs,
+        pid: bridge.status.pid,
+        state: "reachable",
+        version: bridge.version,
+    }
+    : {
+        reason: `it answers as maia-node ${bridge.version}, recorded ${node.maiaVersion}`,
+        state: "stale",
+    };
+export const checkReachability = (node) => node.state === "ready"
+    ? Effect.gen(function* () {
+        const started = yield* Clock.currentTimeMillis;
+        const bridge = yield* Effect.flatMap(Effect.scope, (scope) => openRemoteBridge(node, scope));
+        const finished = yield* Clock.currentTimeMillis;
+        return greeted(node, bridge, finished - started);
+    }).pipe(Effect.scoped, Effect.timeoutOrElse({
+        duration: CHECK_DEADLINE,
+        orElse: () => Effect.succeed({
+            reason: `no answer within ${Duration.format(CHECK_DEADLINE)}`,
+            state: "unknown",
+        }),
+    }), Effect.catch((error) => Effect.succeed({
+        reason: error.message,
+        state: "unreachable",
+    })))
+    : Effect.succeed({ reason: `it is ${node.state}`, state: "not_checked" });
+//# sourceMappingURL=reachability.js.map

package/dist/remote-node/text.d.ts

@@ -0,0 +1,9 @@
+import type { RemoteNodeInstallPreviewResult, RemoteNodeRecord } from "@maiaos/sdk";
+import type { Reachability } from "./reachability.js";
+export declare const planText: (preview: RemoteNodeInstallPreviewResult) => string;
+export declare const installedText: (node: RemoteNodeRecord) => string;
+export declare const removedText: (node: RemoteNodeRecord) => string;
+export declare const listText: (nodes: readonly (RemoteNodeRecord & {
+    readonly reachability: Reachability;
+})[]) => string;
+//# sourceMappingURL=text.d.ts.map

package/dist/remote-node/text.js

@@ -0,0 +1,64 @@
+import { formatRows } from "../command-line/index.js";
+const CONTROL = /[^\P{Cc}\t\n]|[‎‏‪-‮⁦-⁩]/gu;
+const printable = (text) => text.replaceAll(CONTROL, "?");
+const mebibytes = (bytes) => `${(bytes / 1_048_576).toFixed(1)} MiB`;
+const executorLine = (executor) => {
+    const name = executor.executor === "codex-cli" ? "codex " : "claude";
+    if (executor.state === "unavailable")
+        return `  ${name}   unavailable: ${executor.reason ?? "unknown"}`;
+    const interpreter = executor.interpreter === undefined
+        ? ""
+        : ` (node ${executor.interpreter.path})`;
+    return `  ${name}   ${executor.path ?? ""} sha256:${(executor.sha256 ?? "").slice(0, 12)}${interpreter}`;
+};
+const changeLines = (plan) => plan.executorChanges.map((change) => `  changed  ${change.executor}: ${change.from?.path ?? "none"} -> ${change.to?.path ?? "none"}`);
+const readyPlan = (preview) => {
+    const { name, plan } = preview;
+    return [
+        `Plan (${plan.mode}) for ${name}: maia-node ${plan.maiaVersion}, release ${plan.releaseId}, upload ${mebibytes(plan.uploadBytes)}`,
+        `  root     ${plan.root}  profile ${plan.profile}  unit ${plan.unitName}`,
+        `  bridge   ${plan.launcherPath}`,
+        `  PATH     ${plan.path}`,
+        `  maia     ${plan.cli.path} (worker MCP; maia.mjs sha256:${plan.cli.sha256.slice(0, 12)})`,
+        ...plan.executors.map(executorLine),
+        ...changeLines(plan),
+        ...(plan.prune.releases.length === 0
+            ? []
+            : [`  prune    ${plan.prune.releases.join(", ")}`]),
+        "",
+    ].join("\n");
+};
+export const planText = (preview) => {
+    if (preview.state === "ready")
+        return printable(readyPlan(preview));
+    if (preview.state === "probing")
+        return "Still probing.\n";
+    return printable([
+        `The host cannot run a contained Maia Node (${preview.facts.distro || preview.facts.os}, Linux ${preview.facts.kernel}):`,
+        ...preview.blockers.map((blocker) => `  - ${blocker.code}: ${blocker.message}${blocker.remedy === undefined ? "" : `\n    ${blocker.remedy}`}`),
+        "",
+    ].join("\n"));
+};
+const errorLine = (node) => node.error === undefined
+    ? ""
+    : `\n  ${node.error.code}: ${node.error.message}`;
+export const installedText = (node) => printable(node.state === "ready"
+    ? `${node.name} is ready: maia-node ${node.maiaVersion ?? "?"} on ${node.host}.\nNext: maia --node ${node.name} status\n`
+    : `${node.name} is ${node.state}.${errorLine(node)}\n`);
+export const removedText = (node) => printable(node.state === "removed"
+    ? `${node.name} is removed from ${node.host}.${node.remaining === undefined || node.remaining.length === 0 ? "" : `\n  Kept on the host: ${node.remaining.join(", ")}`}\n`
+    : `${node.name} is ${node.state}.${errorLine(node)}\n`);
+const reachabilityText = (reachability) => reachability.state === "reachable"
+    ? `reachable pid ${String(reachability.pid)} ${String(reachability.latencyMs)} ms`
+    : `${reachability.state}: ${reachability.reason}`;
+export const listText = (nodes) => printable(formatRows(nodes, (node) => [
+    node.name,
+    node.host,
+    node.state,
+    node.maiaVersion ?? "-",
+    reachabilityText(node.reachability),
+].join("\t"), {
+    empty: "No remote Nodes. Add one with: maia node install <host> --release <file> --node-runtime <file>",
+    headers: ["NODE", "HOST", "STATE", "VERSION", "REACHABLE"],
+}));
+//# sourceMappingURL=text.js.map

package/dist/remote-node/tree/index.d.ts

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

package/dist/remote-node/tree/index.js

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

package/dist/remote-node/tree/tree.d.ts

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

package/dist/remote-node/tree/tree.js

@@ -0,0 +1,51 @@
+const remote = () => import("../index.js");
+const status = () => import("../../status/index.js");
+const nodeStatus = [status, "runNodeStatus"];
+export const NODE_TREE = {
+    groups: [["node", "This Node, and remote Nodes over SSH (--node <name>)."]],
+    leaves: [
+        [
+            "status",
+            0,
+            "node.status",
+            "Show whether the Node is ready (maia node status).",
+            { example: "maia status", kind: "shortcut", run: nodeStatus },
+        ],
+        [
+            "node status",
+            0,
+            "node.status",
+            "Show whether the Node is ready.",
+            { example: "maia --json node status", run: nodeStatus },
+        ],
+        [
+            "node monitor",
+            0,
+            "monitor.bootstrap.create",
+            "Print a one-time loopback URL for the admin monitor.",
+            { run: [status, "runNodeMonitor"] },
+        ],
+        [
+            "node install <host> --release <maia-node.release.json> --node-runtime <node> [--name <name>] [--root <dir>] [--remote-profile <name>] [--keep <2..8>] [--codex-bin <path>] [--claude-bin <path>] [--command-id <id>] [--dry-run | --confirm-stdin | --yes]",
+            1,
+            ["node.remote.install.preview", "node.remote.install.confirm"],
+            "Install Maia Node on a remote host over SSH.",
+            { kind: "two-phase", remote: false, run: [remote, "runNodeInstall"] },
+        ],
+        [
+            "node list [--all]",
+            1,
+            "node.remote.list",
+            "List registered remote Nodes.",
+            { remote: false, run: [remote, "runNodeList"] },
+        ],
+        [
+            "node remove <node> [--purge] [--command-id <id>] [--dry-run | --confirm-stdin | --yes]",
+            1,
+            ["node.remote.remove.preview", "node.remote.remove.confirm"],
+            "Remove a registered remote Node.",
+            { kind: "two-phase", remote: false, run: [remote, "runNodeRemove"] },
+        ],
+    ],
+};
+//# sourceMappingURL=tree.js.map