@maiaos/cli 0.1.0-canary.2

package/dist/reference/tree/tree.js

@@ -0,0 +1,17 @@
+const reference = () => import("../index.js");
+export const REFERENCE_TREE = {
+    groups: [["reference", "Exact IDs for names, ID prefixes and folders."]],
+    leaves: [
+        [
+            "reference resolve <connection|container|project|session|workspace> [<reference>] [--project <project-id>]",
+            1,
+            "reference.resolve",
+            "Resolve a name, ID prefix or the current folder to an exact ID.",
+            {
+                example: "maia --json reference resolve session 'Fix the build'",
+                run: [reference, "runReferenceResolve"],
+            },
+        ],
+    ],
+};
+//# sourceMappingURL=tree.js.map

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

@@ -0,0 +1,258 @@
+import { type RemoteNodeInstallConfirmParameters, type RemoteNodeInstallPreviewParameters, type RemoteNodeListParameters, type RemoteNodeRemoveConfirmParameters, type RemoteNodeRemovePreviewParameters } from "@maiaos/sdk";
+import type { CliNodeOperations } from "../local-node/index.js";
+export declare const makeRemoteNodeClient: (node: CliNodeOperations) => {
+    confirmRemoteNodeInstall: (input: RemoteNodeInstallConfirmParameters) => import("../local-node/client.js").CliNodeEffect<{
+        readonly actorId: string;
+        readonly commandId: string;
+        readonly delivery: "duplicate" | "new";
+        readonly inputDigest: string;
+        readonly node: {
+            readonly createdAt: string;
+            readonly error?: {
+                readonly code: string;
+                readonly message: string;
+            } | undefined;
+            readonly executors: readonly {
+                readonly executor: "claude-code" | "codex-cli";
+                readonly interpreter?: {
+                    readonly path: string;
+                    readonly sha256: string;
+                } | undefined;
+                readonly path?: string | undefined;
+                readonly realPath?: string | undefined;
+                readonly reason?: string | undefined;
+                readonly sha256?: string | undefined;
+                readonly source: "discovered" | "override";
+                readonly state: "available" | "unavailable";
+            }[];
+            readonly host: string;
+            readonly installedAt?: string | undefined;
+            readonly launcherPath: string;
+            readonly maiaVersion?: string | undefined;
+            readonly name: string;
+            readonly profile: string;
+            readonly releaseId?: string | undefined;
+            readonly remaining?: readonly string[] | undefined;
+            readonly revision: string;
+            readonly root: string;
+            readonly schemaVersion: "maia.remote-node/v1";
+            readonly state: "install_failed" | "installing" | "ready" | "remove_failed" | "removed" | "removing";
+            readonly unitName: string;
+            readonly updatedAt: string;
+        };
+        readonly receipt: {
+            readonly actorId: string;
+            readonly aggregateRevision: string;
+            readonly commandId: string;
+            readonly createdAt: string;
+            readonly eventCursor: string;
+            readonly method: string;
+            readonly receiptId: string;
+            readonly schemaVersion: 1;
+            readonly state: "succeeded";
+            readonly target: {
+                readonly id: string;
+                readonly type: string;
+            };
+            readonly updatedAt: string;
+        };
+        readonly method: "node.remote.install.confirm";
+    }>;
+    previewRemoteNodeInstall: (input: RemoteNodeInstallPreviewParameters) => import("../local-node/client.js").CliNodeEffect<{
+        readonly actorId: string;
+        readonly expiresAt: string;
+        readonly inputDigest: string;
+        readonly issuedAt: string;
+        readonly proof: string;
+        readonly commandId: string;
+        readonly method: "node.remote.install.preview";
+        readonly name: string;
+        readonly plan: {
+            readonly cli: {
+                readonly path: string;
+                readonly sha256: string;
+            };
+            readonly executorChanges: readonly {
+                readonly executor: "claude-code" | "codex-cli";
+                readonly from?: {
+                    readonly path: string;
+                    readonly sha256: string;
+                } | undefined;
+                readonly to?: {
+                    readonly path: string;
+                    readonly sha256: string;
+                } | undefined;
+            }[];
+            readonly executors: readonly {
+                readonly executor: "claude-code" | "codex-cli";
+                readonly interpreter?: {
+                    readonly path: string;
+                    readonly sha256: string;
+                } | undefined;
+                readonly path?: string | undefined;
+                readonly realPath?: string | undefined;
+                readonly reason?: string | undefined;
+                readonly sha256?: string | undefined;
+                readonly source: "discovered" | "override";
+                readonly state: "available" | "unavailable";
+            }[];
+            readonly keep: number;
+            readonly launcherPath: string;
+            readonly maiaVersion: string;
+            readonly mode: "install" | "reinstall" | "upgrade";
+            readonly path: string;
+            readonly previousRelease?: string | undefined;
+            readonly profile: string;
+            readonly prune: {
+                readonly releases: readonly string[];
+                readonly runtimes: readonly string[];
+            };
+            readonly releaseId: string;
+            readonly root: string;
+            readonly runtimeId: string;
+            readonly unitName: string;
+            readonly uploadBytes: number;
+        };
+        readonly planDigest: string;
+        readonly state: "ready";
+    } | {
+        readonly commandId: string;
+        readonly method: "node.remote.install.preview";
+        readonly state: "probing";
+    } | {
+        readonly blockers: readonly {
+            readonly code: string;
+            readonly message: string;
+            readonly remedy?: string | undefined;
+        }[];
+        readonly commandId: string;
+        readonly facts: {
+            readonly activeRelease?: string | undefined;
+            readonly arch: string;
+            readonly distro: string;
+            readonly home: string;
+            readonly kernel: string;
+            readonly landlockAbi?: number | undefined;
+            readonly linger: string;
+            readonly os: string;
+            readonly root: string;
+            readonly rootState: "absent" | "empty" | "foreign" | "maia" | "symlink";
+            readonly systemdVersion?: number | undefined;
+            readonly user: string;
+        };
+        readonly method: "node.remote.install.preview";
+        readonly state: "blocked";
+    }>;
+    confirmRemoteNodeRemove: (input: RemoteNodeRemoveConfirmParameters) => import("../local-node/client.js").CliNodeEffect<{
+        readonly actorId: string;
+        readonly commandId: string;
+        readonly delivery: "duplicate" | "new";
+        readonly inputDigest: string;
+        readonly node: {
+            readonly createdAt: string;
+            readonly error?: {
+                readonly code: string;
+                readonly message: string;
+            } | undefined;
+            readonly executors: readonly {
+                readonly executor: "claude-code" | "codex-cli";
+                readonly interpreter?: {
+                    readonly path: string;
+                    readonly sha256: string;
+                } | undefined;
+                readonly path?: string | undefined;
+                readonly realPath?: string | undefined;
+                readonly reason?: string | undefined;
+                readonly sha256?: string | undefined;
+                readonly source: "discovered" | "override";
+                readonly state: "available" | "unavailable";
+            }[];
+            readonly host: string;
+            readonly installedAt?: string | undefined;
+            readonly launcherPath: string;
+            readonly maiaVersion?: string | undefined;
+            readonly name: string;
+            readonly profile: string;
+            readonly releaseId?: string | undefined;
+            readonly remaining?: readonly string[] | undefined;
+            readonly revision: string;
+            readonly root: string;
+            readonly schemaVersion: "maia.remote-node/v1";
+            readonly state: "install_failed" | "installing" | "ready" | "remove_failed" | "removed" | "removing";
+            readonly unitName: string;
+            readonly updatedAt: string;
+        };
+        readonly receipt: {
+            readonly actorId: string;
+            readonly aggregateRevision: string;
+            readonly commandId: string;
+            readonly createdAt: string;
+            readonly eventCursor: string;
+            readonly method: string;
+            readonly receiptId: string;
+            readonly schemaVersion: 1;
+            readonly state: "succeeded";
+            readonly target: {
+                readonly id: string;
+                readonly type: string;
+            };
+            readonly updatedAt: string;
+        };
+        readonly method: "node.remote.remove.confirm";
+    }>;
+    listRemoteNodes: (input: RemoteNodeListParameters) => import("../local-node/client.js").CliNodeEffect<{
+        readonly method: "node.remote.list";
+        readonly nodes: readonly {
+            readonly createdAt: string;
+            readonly error?: {
+                readonly code: string;
+                readonly message: string;
+            } | undefined;
+            readonly executors: readonly {
+                readonly executor: "claude-code" | "codex-cli";
+                readonly interpreter?: {
+                    readonly path: string;
+                    readonly sha256: string;
+                } | undefined;
+                readonly path?: string | undefined;
+                readonly realPath?: string | undefined;
+                readonly reason?: string | undefined;
+                readonly sha256?: string | undefined;
+                readonly source: "discovered" | "override";
+                readonly state: "available" | "unavailable";
+            }[];
+            readonly host: string;
+            readonly installedAt?: string | undefined;
+            readonly launcherPath: string;
+            readonly maiaVersion?: string | undefined;
+            readonly name: string;
+            readonly profile: string;
+            readonly releaseId?: string | undefined;
+            readonly remaining?: readonly string[] | undefined;
+            readonly revision: string;
+            readonly root: string;
+            readonly schemaVersion: "maia.remote-node/v1";
+            readonly state: "install_failed" | "installing" | "ready" | "remove_failed" | "removed" | "removing";
+            readonly unitName: string;
+            readonly updatedAt: string;
+        }[];
+    }>;
+    previewRemoteNodeRemove: (input: RemoteNodeRemovePreviewParameters) => import("../local-node/client.js").CliNodeEffect<{
+        readonly host: string;
+        readonly profile: string;
+        readonly actorId: string;
+        readonly expiresAt: string;
+        readonly inputDigest: string;
+        readonly issuedAt: string;
+        readonly proof: string;
+        readonly commandId: string;
+        readonly expectedRevision: string;
+        readonly method: "node.remote.remove.preview";
+        readonly name: string;
+        readonly purge: boolean;
+        readonly root: string;
+        readonly unitName: string;
+    }>;
+};
+export type RemoteNodeCliDependencies = ReturnType<typeof makeRemoteNodeClient>;
+//# sourceMappingURL=client.d.ts.map

package/dist/remote-node/client.js

@@ -0,0 +1,12 @@
+import { remoteNodeInstallConfirmParametersSchema, remoteNodeInstallPreviewParametersSchema, remoteNodeListParametersSchema, remoteNodeRemoveConfirmParametersSchema, remoteNodeRemovePreviewParametersSchema, } from "@maiaos/sdk";
+const installOperations = (node) => ({
+    confirmRemoteNodeInstall: (input) => node.runValidatedNodeOperation(input, remoteNodeInstallConfirmParametersSchema, (client, parameters, options) => client.confirmRemoteNodeInstall(parameters, options), { commandId: input.commandId }),
+    previewRemoteNodeInstall: (input) => node.runValidatedNodeOperation(input, remoteNodeInstallPreviewParametersSchema, (client, parameters, options) => client.previewRemoteNodeInstall(parameters, options)),
+});
+export const makeRemoteNodeClient = (node) => ({
+    ...installOperations(node),
+    confirmRemoteNodeRemove: (input) => node.runValidatedNodeOperation(input, remoteNodeRemoveConfirmParametersSchema, (client, parameters, options) => client.confirmRemoteNodeRemove(parameters, options), { commandId: input.commandId }),
+    listRemoteNodes: (input) => node.runValidatedNodeOperation(input, remoteNodeListParametersSchema, (client, parameters, options) => client.listRemoteNodes(parameters, options)),
+    previewRemoteNodeRemove: (input) => node.runValidatedNodeOperation(input, remoteNodeRemovePreviewParametersSchema, (client, parameters, options) => client.previewRemoteNodeRemove(parameters, options)),
+});
+//# sourceMappingURL=client.js.map

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

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

package/dist/remote-node/commands.js

@@ -0,0 +1,264 @@
+import { resolve } from "node:path";
+import process from "node:process";
+import { remoteNodeInstallConfirmParametersSchema, remoteNodeRemoveConfirmParametersSchema, } from "@maiaos/sdk";
+import * as Data from "effect/Data";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Schedule from "effect/Schedule";
+import { askToConfirm, CliArgumentError, confirmParameters, missingArgument, parseOptions, promptOrRefuse, readPipedPreview, reportError, requestedTwoPhaseMode, requirePositionals, TWO_PHASE_FLAGS, } from "../command-line/index.js";
+import { commandIdentifier, } from "../local-node/index.js";
+import { checkReachability } from "./reachability.js";
+import { installedText, listText, planText, removedText } from "./text.js";
+const WAIT_MS = 3500;
+const PROBE_DEADLINE = Duration.minutes(3);
+const JOB_DEADLINE = Duration.minutes(20);
+const EXIT_UNAVAILABLE = 69;
+const EXIT_TEMPORARY = 75;
+const cancelled = (context) => {
+    context.io.stderr("Cancelled; nothing changed on the host.\n");
+    return 1;
+};
+class NodeCommandError extends Data.TaggedError("NodeCommandError") {
+}
+const required = (effect) => Effect.flatMap(effect, (result) => result.ok
+    ? Effect.succeed(result.value)
+    : Effect.fail(new NodeCommandError({ error: result.error })));
+const operation = (value) => {
+    if (value === undefined)
+        throw new CliArgumentError("Remote Nodes are unavailable in this CLI.");
+    return value;
+};
+export const nameFromHost = (host) => {
+    const name = (host.split("@").at(-1) ?? "")
+        .toLowerCase()
+        .replaceAll(/[^a-z0-9-]+/gu, "-")
+        .replace(/^-+/u, "")
+        .slice(0, 63)
+        .replace(/-+$/u, "");
+    if (name === "")
+        throw new CliArgumentError("Name the Node with --name <name>.");
+    return name;
+};
+const readKeep = (value = "3") => {
+    if (!/^[2-8]$/u.test(value))
+        throw new CliArgumentError("--keep must be 2 to 8.");
+    return Number(value);
+};
+const ADD_OPTIONS = new Set([
+    "--claude-bin",
+    "--codex-bin",
+    "--command-id",
+    "--keep",
+    "--name",
+    "--node-runtime",
+    "--release",
+    "--remote-profile",
+    "--root",
+]);
+const optionalBinaries = (options) => {
+    const codexBin = options.get("--codex-bin");
+    const claudeBin = options.get("--claude-bin");
+    return {
+        ...(claudeBin === undefined ? {} : { claudeBin }),
+        ...(codexBin === undefined ? {} : { codexBin }),
+    };
+};
+const CONFIRM_FLAGS = new Set(["--yes", ...TWO_PHASE_FLAGS]);
+const readAdd = ({ options, positionals }) => {
+    requirePositionals(positionals, 1);
+    const host = positionals[0] ?? "";
+    const release = options.get("--release");
+    const runtime = options.get("--node-runtime");
+    if (release === undefined || runtime === undefined)
+        throw missingArgument();
+    return {
+        commandId: options.get("--command-id"),
+        parameters: {
+            ...optionalBinaries(options),
+            host,
+            keep: readKeep(options.get("--keep")),
+            name: options.get("--name") ?? nameFromHost(host),
+            nodeRuntime: resolve(process.cwd(), runtime),
+            profile: options.get("--remote-profile") ?? "default",
+            release: resolve(process.cwd(), release),
+            root: options.get("--root") ?? "~/.maia",
+        },
+    };
+};
+const confirmed = (context, question, mode) => mode === "prompt" ? askToConfirm(context, question) : Effect.succeed(true);
+const pipedPlan = (piped) => {
+    const parameters = Reflect.get(piped, "parameters");
+    const preview = Reflect.get(piped, "preview");
+    if (typeof parameters !== "object" ||
+        parameters === null ||
+        typeof preview !== "object" ||
+        preview === null)
+        return {};
+    const planDigest = Reflect.get(preview, "planDigest");
+    return {
+        ...parameters,
+        inputDigest: Reflect.get(preview, "inputDigest"),
+        ...(planDigest === undefined ? {} : { planDigest }),
+        proof: Reflect.get(preview, "proof"),
+        waitMs: WAIT_MS,
+    };
+};
+const notSettled = () => new NodeCommandError({
+    error: {
+        code: "deadline_exceeded",
+        message: "The remote Node did not settle in time; maia node list shows where it stands.",
+        retryable: true,
+    },
+});
+const repeatUntil = (effect, settled, deadline) => effect.pipe(Effect.repeat({
+    schedule: Schedule.spaced(Duration.millis(250)),
+    until: settled,
+}), Effect.timeoutOrElse({
+    duration: deadline,
+    orElse: () => Effect.fail(notSettled()),
+}));
+const write = (context, output, text) => {
+    context.io.stdout(context.json ? `${JSON.stringify({ ok: true, result: output })}\n` : text);
+};
+const exitFor = (node) => {
+    if (node.state === "ready" || node.state === "removed")
+        return 0;
+    return node.error?.code === "blocked" ? EXIT_UNAVAILABLE : EXIT_TEMPORARY;
+};
+const previewUntilSettled = (context, parameters) => {
+    const preview = operation(context.dependencies.previewRemoteNodeInstall);
+    if (!context.json)
+        context.io.stderr(`Probing ${parameters.host}…\n`);
+    return repeatUntil(required(preview({ ...parameters, waitMs: WAIT_MS })), (result) => result.state !== "probing", PROBE_DEADLINE);
+};
+const install = (context, confirmation) => {
+    const confirm = operation(context.dependencies.confirmRemoteNodeInstall);
+    if (!context.json)
+        context.io.stderr(`Installing on ${confirmation.host}; a first install takes about a minute…\n`);
+    return repeatUntil(required(confirm(confirmation)), (result) => result.node.state !== "installing", JOB_DEADLINE);
+};
+const finishInstall = (context, confirmation) => Effect.gen(function* () {
+    const result = yield* install(context, confirmation);
+    write(context, { command: "node.remote.install.confirm", result }, installedText(result.node));
+    return exitFor(result.node);
+});
+const runConfirmedInstall = (context) => Effect.flatMap(readPipedPreview(context), (piped) => Effect.flatMap(confirmParameters(remoteNodeInstallConfirmParametersSchema, pipedPlan(piped)), (confirmation) => finishInstall(context, confirmation)));
+const planInstall = (context, parsed, requested) => Effect.gen(function* () {
+    const input = readAdd(parsed);
+    const commandId = yield* commandIdentifier(input.commandId);
+    const parameters = { ...input.parameters, commandId };
+    const preview = yield* previewUntilSettled(context, parameters);
+    const planned = {
+        parameters,
+        preview,
+    };
+    if (preview.state !== "ready" || !context.json || requested === "dry-run")
+        write(context, { command: "node.remote.install.preview", result: planned }, planText(preview));
+    return planned;
+});
+export const runNodeInstall = (tokens, context) => guarded(Effect.gen(function* () {
+    const parsed = parseOptions(tokens, ADD_OPTIONS, CONFIRM_FLAGS);
+    const requested = requestedTwoPhaseMode(parsed.flags, true);
+    if (requested === "confirm-stdin")
+        return yield* runConfirmedInstall(context);
+    const planned = yield* planInstall(context, parsed, requested);
+    const { parameters, preview } = planned;
+    if (preview.state !== "ready")
+        return EXIT_UNAVAILABLE;
+    if (requested === "dry-run")
+        return 0;
+    const mode = requested ?? promptOrRefuse(context, true);
+    const question = `Install this plan on ${parameters.host} as ${parameters.name}?`;
+    if (!(yield* confirmed(context, question, mode)))
+        return cancelled(context);
+    const { inputDigest, planDigest, proof } = preview;
+    const proven = { inputDigest, planDigest, proof, waitMs: WAIT_MS };
+    return yield* finishInstall(context, { ...parameters, ...proven });
+}), context);
+const withReachability = (nodes) => Effect.forEach(nodes, (node) => Effect.map(checkReachability(node), (reachability) => ({
+    ...node,
+    reachability,
+})), { concurrency: 4 });
+export const runNodeList = (tokens, context) => guarded(Effect.gen(function* () {
+    const { flags, positionals } = parseOptions(tokens, new Set(), new Set(["--all"]));
+    requirePositionals(positionals, 0);
+    const listed = yield* required(operation(context.dependencies.listRemoteNodes)({
+        includeRemoved: flags.has("--all"),
+    }));
+    const nodes = yield* withReachability(listed.nodes);
+    write(context, { command: "node.remote.list", result: { nodes } }, listText(nodes));
+    return 0;
+}), context);
+const readRemove = ({ flags, options, positionals }) => {
+    requirePositionals(positionals, 1);
+    return {
+        commandId: options.get("--command-id"),
+        name: positionals[0] ?? "",
+        purge: flags.has("--purge"),
+    };
+};
+const removeQuestion = (node, purge) => purge
+    ? `Uninstall ${node.name} from ${node.host}:${node.root} and DELETE profile ${node.profile}'s state (its database)? Sign-ins there stay.`
+    : `Uninstall ${node.name} from ${node.host}:${node.root}? Profile ${node.profile}'s state stays for a later add.`;
+const registered = (context, name) => Effect.flatMap(required(operation(context.dependencies.listRemoteNodes)({})), (listed) => {
+    const node = listed.nodes.find((candidate) => candidate.name === name);
+    return node === undefined
+        ? Effect.fail(new CliArgumentError(`No remote Node is registered as ${name}.`))
+        : Effect.succeed(node);
+});
+const uninstall = (context, confirmation) => repeatUntil(required(operation(context.dependencies.confirmRemoteNodeRemove)(confirmation)), (value) => value.node.state !== "removing", JOB_DEADLINE);
+const finishRemove = (context, confirmation) => Effect.gen(function* () {
+    const result = yield* uninstall(context, confirmation);
+    write(context, { command: "node.remote.remove.confirm", result }, removedText(result.node));
+    return exitFor(result.node);
+});
+const confirmPipedRemove = (context) => Effect.gen(function* () {
+    const piped = yield* readPipedPreview(context);
+    return yield* finishRemove(context, yield* confirmParameters(remoteNodeRemoveConfirmParametersSchema, pipedPlan(piped)));
+});
+const planRemove = (context, parsed) => Effect.gen(function* () {
+    const input = readRemove(parsed);
+    const node = yield* registered(context, input.name);
+    const removal = {
+        commandId: yield* commandIdentifier(input.commandId),
+        expectedRevision: node.revision,
+        name: node.name,
+        purge: input.purge,
+    };
+    const preview = yield* required(operation(context.dependencies.previewRemoteNodeRemove)(removal));
+    return { preview, question: removeQuestion(node, input.purge), removal };
+});
+const writeRemovePreview = (context, { preview, question, removal }) => {
+    write(context, {
+        command: "node.remote.remove.preview",
+        result: { parameters: removal, preview },
+    }, `${question}\n`);
+    return 0;
+};
+export const runNodeRemove = (tokens, context) => guarded(Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set(["--command-id"]), new Set(["--purge", ...CONFIRM_FLAGS]));
+    const requested = requestedTwoPhaseMode(parsed.flags, true);
+    if (requested === "confirm-stdin")
+        return yield* confirmPipedRemove(context);
+    const { preview, question, removal } = yield* planRemove(context, parsed);
+    if (requested === "dry-run")
+        return writeRemovePreview(context, { preview, question, removal });
+    const mode = requested ?? promptOrRefuse(context, true);
+    if (!(yield* confirmed(context, question, mode)))
+        return cancelled(context);
+    const { inputDigest, proof } = preview;
+    const proven = { inputDigest, proof, waitMs: WAIT_MS };
+    return yield* finishRemove(context, { ...removal, ...proven });
+}), context);
+const failure = (error) => {
+    if (error instanceof NodeCommandError)
+        return error.error;
+    const usage = error instanceof CliArgumentError;
+    return {
+        code: usage ? "invalid_argument" : "internal_error",
+        message: usage ? error.message : "The node command failed.",
+        retryable: false,
+    };
+};
+const guarded = (program, context) => Effect.suspend(() => program).pipe(Effect.catch((error) => Effect.sync(() => reportError(failure(error), context))));
+//# sourceMappingURL=commands.js.map

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

@@ -0,0 +1,59 @@
+import { type Connection, type LocalNodeStatusResult, MaiaClientError, type RemoteNodeRecord } from "@maiaos/sdk";
+import { type LocalNodeEffectClient, type NodeApiEffectDiscoveryOptions } from "@maiaos/sdk/node/effect";
+import type * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import * as Scope from "effect/Scope";
+import { type CliNodeConnector } from "../local-node/index.js";
+export declare const readRemoteNode: (connector: CliNodeConnector, options: NodeApiEffectDiscoveryOptions, name: string) => Effect.Effect<{
+    readonly createdAt: string;
+    readonly error?: {
+        readonly code: string;
+        readonly message: string;
+    } | undefined;
+    readonly executors: readonly {
+        readonly executor: "claude-code" | "codex-cli";
+        readonly interpreter?: {
+            readonly path: string;
+            readonly sha256: string;
+        } | undefined;
+        readonly path?: string | undefined;
+        readonly realPath?: string | undefined;
+        readonly reason?: string | undefined;
+        readonly sha256?: string | undefined;
+        readonly source: "discovered" | "override";
+        readonly state: "available" | "unavailable";
+    }[];
+    readonly host: string;
+    readonly installedAt?: string | undefined;
+    readonly launcherPath: string;
+    readonly maiaVersion?: string | undefined;
+    readonly name: string;
+    readonly profile: string;
+    readonly releaseId?: string | undefined;
+    readonly remaining?: readonly string[] | undefined;
+    readonly revision: string;
+    readonly root: string;
+    readonly schemaVersion: "maia.remote-node/v1";
+    readonly state: "install_failed" | "installing" | "ready" | "remove_failed" | "removed" | "removing";
+    readonly unitName: string;
+    readonly updatedAt: string;
+}, unknown, Crypto.Crypto>;
+export type RemoteBridge = {
+    readonly client: LocalNodeEffectClient;
+    readonly closed: Effect.Effect<boolean>;
+    readonly status: LocalNodeStatusResult;
+    readonly version: string;
+};
+export declare const openRemoteBridge: (node: RemoteNodeRecord, scope: Scope.Scope) => Effect.Effect<RemoteBridge, MaiaClientError>;
+export declare const makeRemoteNodeConnector: (input: {
+    readonly local?: CliNodeConnector;
+    readonly name: string;
+    readonly scope: Scope.Scope;
+}) => CliNodeConnector;
+export declare const remoteSignInScript: (node: RemoteNodeRecord, connection: Connection) => string | undefined;
+export declare const remoteVendorLogin: (input: {
+    readonly connector?: CliNodeConnector;
+    readonly name: string;
+    readonly profile?: string;
+}) => (connection: Connection) => Effect.Effect<number, unknown>;
+//# sourceMappingURL=connector.d.ts.map