@maiaos/sdk 0.1.0-canary.2

package/dist/node/discovery.js

@@ -0,0 +1,408 @@
+import { close as closeFileDescriptor, constants, fstat as inspectFileDescriptor, read as readFileDescriptor, } from "node:fs";
+import { lstat, open } from "node:fs/promises";
+import { dirname } from "node:path";
+import { LOCAL_NODE_TOKEN_LENGTH, localNodeTokenSchema, MAX_NODE_API_CONNECTION_DESCRIPTOR_BYTES, nodeApiConnectionDescriptorSchema, } from "@maiaos/protocol";
+import { INVOCATION_ATTACHMENT_CREDENTIAL_BYTES } from "@maiaos/protocol/invocation-context-candidate";
+import { resolveCurrentLocalNodeProfileLocation, } from "@maiaos/protocol/node-profile";
+import * as Crypto from "effect/Crypto";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { MaiaClientError } from "../request/index.js";
+import { createNodeApiEffectClient } from "./http.js";
+const INVOCATION_ATTACHMENT_DESCRIPTOR = 3;
+const INVOCATION_ATTACHMENT_READ_DEADLINE = "1 second";
+const MAX_CREDENTIAL_FILE_BYTES = LOCAL_NODE_TOKEN_LENGTH + 1;
+const NEWLINE_BYTE = 10;
+const PRIVATE_MODE_MASK = 0o077;
+const REQUEST_DEADLINE_MS = 5000;
+const utf8Decoder = new TextDecoder("utf-8", { fatal: true });
+const decodeJson = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown));
+class LocalNodeTransportError extends Data.TaggedError("LocalNodeTransportError") {
+}
+const makeTransportError = (reason, message) => new LocalNodeTransportError({ message, reason });
+const failTransport = (reason, message) => Effect.fail(makeTransportError(reason, message));
+const ownedByCurrentUser = (metadata) => typeof process.getuid !== "function" ||
+    metadata.uid === BigInt(process.getuid());
+const hasPrivateMode = (metadata) => process.platform === "win32" ||
+    (Number(metadata.mode) & PRIVATE_MODE_MASK) === 0;
+const validatePrivateDirectoryMetadata = Effect.fn("LocalNodeTransport.validatePrivateDirectoryMetadata")(function* (metadata) {
+    if (!metadata.isDirectory() || metadata.isSymbolicLink()) {
+        return yield* Effect.fail(makeTransportError("endpoint_invalid", "A Maia local transport directory is unsafe."));
+    }
+    if (!ownedByCurrentUser(metadata)) {
+        return yield* Effect.fail(makeTransportError("endpoint_invalid", "A Maia local transport directory has an invalid owner."));
+    }
+    if (!hasPrivateMode(metadata)) {
+        return yield* Effect.fail(makeTransportError("endpoint_invalid", "A Maia local transport directory is not private."));
+    }
+});
+const validatePrivateDirectory = Effect.fn("LocalNodeTransport.validatePrivateDirectory")(function* (path) {
+    const metadata = yield* Effect.tryPromise({
+        catch: () => makeTransportError("endpoint_invalid", "A Maia local transport directory is unavailable."),
+        try: () => lstat(path, { bigint: true }),
+    });
+    yield* validatePrivateDirectoryMetadata(metadata);
+});
+const sameFileSnapshot = (left, right) => left.dev === right.dev &&
+    left.ino === right.ino &&
+    left.size === right.size &&
+    left.ctimeNs === right.ctimeNs &&
+    left.mtimeNs === right.mtimeNs;
+const validateCredentialMetadata = Effect.fn("LocalNodeTransport.validateCredentialMetadata")(function* (metadata) {
+    if (!metadata.isFile() ||
+        metadata.isSymbolicLink() ||
+        metadata.nlink !== 1n ||
+        metadata.size > BigInt(MAX_CREDENTIAL_FILE_BYTES)) {
+        return yield* failTransport("credential_invalid", "The Maia local credential is unsafe.");
+    }
+    if (!ownedByCurrentUser(metadata)) {
+        return yield* failTransport("credential_invalid", "The Maia local credential has an invalid owner.");
+    }
+    if (!hasPrivateMode(metadata)) {
+        return yield* failTransport("credential_invalid", "The Maia local credential is not private.");
+    }
+});
+const readBoundedCredential = Effect.fn("LocalNodeTransport.readBoundedCredential")(function* (handle) {
+    const bytes = Buffer.alloc(MAX_CREDENTIAL_FILE_BYTES + 1);
+    let offset = 0;
+    let complete = false;
+    yield* Effect.whileLoop({
+        body: () => Effect.tryPromise({
+            catch: () => makeTransportError("credential_invalid", "The Maia local credential could not be read."),
+            try: () => handle.read(bytes, offset, bytes.byteLength - offset, offset),
+        }),
+        step: (result) => {
+            complete = result.bytesRead === 0;
+            offset += result.bytesRead;
+        },
+        while: () => !complete && offset < bytes.byteLength,
+    });
+    return bytes.subarray(0, offset);
+});
+const decodeCredential = Effect.fn("LocalNodeTransport.decodeCredential")(function* (bytes) {
+    return yield* Effect.try({
+        catch: () => makeTransportError("credential_invalid", "The Maia local credential is invalid."),
+        try: () => {
+            if (bytes.byteLength !== MAX_CREDENTIAL_FILE_BYTES ||
+                bytes[MAX_CREDENTIAL_FILE_BYTES - 1] !== NEWLINE_BYTE) {
+                throw new Error("Invalid local credential framing.");
+            }
+            const token = utf8Decoder.decode(bytes.subarray(0, LOCAL_NODE_TOKEN_LENGTH));
+            return localNodeTokenSchema.parse(token);
+        },
+    });
+});
+const statCredentialHandle = Effect.fn("LocalNodeTransport.statCredentialHandle")(function* (handle) {
+    return yield* Effect.tryPromise({
+        catch: () => makeTransportError("credential_invalid", "The Maia local credential metadata is unavailable."),
+        try: () => handle.stat({ bigint: true }),
+    });
+});
+const statCredentialPath = Effect.fn("LocalNodeTransport.statCredentialPath")(function* (credentialPath) {
+    return yield* Effect.tryPromise({
+        catch: () => makeTransportError("credential_invalid", "The Maia local credential changed while being read."),
+        try: () => lstat(credentialPath, { bigint: true }),
+    });
+});
+const validateCredentialSnapshot = Effect.fn("LocalNodeTransport.validateCredentialSnapshot")(function* (input) {
+    const after = yield* statCredentialHandle(input.handle);
+    yield* validateCredentialMetadata(after);
+    const current = yield* statCredentialPath(input.credentialPath);
+    yield* validateCredentialMetadata(current);
+    if (!sameFileSnapshot(input.before, after) ||
+        !sameFileSnapshot(after, current)) {
+        return yield* Effect.fail(makeTransportError("credential_invalid", "The Maia local credential changed while being read."));
+    }
+    return yield* decodeCredential(input.bytes);
+});
+const readCredentialHandle = Effect.fn("LocalNodeTransport.readCredentialHandle")(function* (credentialPath, handle) {
+    const before = yield* statCredentialHandle(handle);
+    yield* validateCredentialMetadata(before);
+    const bytes = yield* readBoundedCredential(handle);
+    return yield* validateCredentialSnapshot({
+        before,
+        bytes,
+        credentialPath,
+        handle,
+    }).pipe(Effect.ensuring(Effect.sync(() => bytes.fill(0))));
+});
+const openCredential = Effect.fn("LocalNodeTransport.openCredential")(function* (credentialPath) {
+    const flags = constants.O_RDONLY |
+        (process.platform === "win32"
+            ? 0
+            : constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    return yield* Effect.tryPromise({
+        catch: () => makeTransportError("credential_invalid", "The Maia local credential is unavailable."),
+        try: () => open(credentialPath, flags),
+    });
+});
+const closeCredential = Effect.fn("LocalNodeTransport.closeCredential")(function* (handle) {
+    yield* Effect.tryPromise({
+        catch: () => makeTransportError("credential_invalid", "The Maia local credential could not be closed."),
+        try: () => handle.close(),
+    });
+});
+const readCredential = Effect.fn("LocalNodeTransport.readCredential")(function* (credentialPath) {
+    yield* validatePrivateDirectory(dirname(credentialPath)).pipe(Effect.mapError(() => makeTransportError("credential_invalid", "The Maia local credential directory is unsafe.")));
+    return yield* Effect.acquireUseRelease(openCredential(credentialPath), (handle) => readCredentialHandle(credentialPath, handle), closeCredential);
+});
+const encodeInvocationCredential = (credential) => {
+    const copy = Buffer.from(credential);
+    try {
+        return copy.toString("base64url");
+    }
+    finally {
+        copy.fill(0);
+    }
+};
+const inheritedAttachmentError = () => makeTransportError("credential_invalid", "The inherited Invocation attachment is invalid or unavailable.");
+const inspectInheritedAttachment = () => Effect.callback((resume) => {
+    inspectFileDescriptor(INVOCATION_ATTACHMENT_DESCRIPTOR, (error, metadata) => {
+        resume(error === null
+            ? Effect.succeed(metadata)
+            : Effect.fail(inheritedAttachmentError()));
+    });
+});
+const readInheritedChunk = Effect.fn("LocalNodeAttachment.readChunk")(function* (buffer, offset, length) {
+    return yield* Effect.callback((resume) => {
+        readFileDescriptor(INVOCATION_ATTACHMENT_DESCRIPTOR, { buffer, length, offset }, (error, bytesRead) => {
+            resume(error === null
+                ? Effect.succeed(bytesRead)
+                : Effect.fail(inheritedAttachmentError()));
+        });
+    });
+});
+const fillInheritedCredential = (buffer, offset = 0) => offset === buffer.byteLength
+    ? Effect.void
+    : readInheritedChunk(buffer, offset, buffer.byteLength - offset).pipe(Effect.flatMap((bytesRead) => bytesRead === 0
+        ? Effect.fail(inheritedAttachmentError())
+        : fillInheritedCredential(buffer, offset + bytesRead)));
+const closeInheritedAttachment = () => Effect.callback((resume) => {
+    closeFileDescriptor(INVOCATION_ATTACHMENT_DESCRIPTOR, () => {
+        resume(Effect.void);
+    });
+});
+const readInheritedAttachmentCredential = Effect.fn("LocalNodeAttachment.readCredential")(function* () {
+    const metadata = yield* inspectInheritedAttachment();
+    if (!metadata.isFIFO())
+        return yield* Effect.fail(inheritedAttachmentError());
+    const credential = Buffer.alloc(INVOCATION_ATTACHMENT_CREDENTIAL_BYTES);
+    const extra = Buffer.alloc(1);
+    return yield* Effect.gen(function* () {
+        yield* fillInheritedCredential(credential);
+        const extraBytes = yield* readInheritedChunk(extra, 0, 1);
+        if (extraBytes !== 0)
+            return yield* Effect.fail(inheritedAttachmentError());
+        return Uint8Array.from(credential);
+    }).pipe(Effect.ensuring(Effect.sync(() => {
+        credential.fill(0);
+        extra.fill(0);
+    })));
+});
+const acquireInheritedAttachmentCredential = () => Effect.acquireUseRelease(Effect.void, () => readInheritedAttachmentCredential().pipe(Effect.timeoutOrElse({
+    duration: INVOCATION_ATTACHMENT_READ_DEADLINE,
+    orElse: () => Effect.fail(inheritedAttachmentError()),
+})), () => closeInheritedAttachment());
+const validateDescriptorMetadata = Effect.fn("LocalNodeDiscovery.validateDescriptorMetadata")(function* (metadata) {
+    if (!metadata.isFile() ||
+        metadata.isSymbolicLink() ||
+        metadata.nlink !== 1n ||
+        metadata.size <= 0n ||
+        metadata.size > BigInt(MAX_NODE_API_CONNECTION_DESCRIPTOR_BYTES)) {
+        return yield* failTransport("discovery_invalid", "The Maia local connection descriptor is unsafe.");
+    }
+    if (!ownedByCurrentUser(metadata) || !hasPrivateMode(metadata)) {
+        return yield* failTransport("discovery_invalid", "The Maia local connection descriptor is not private.");
+    }
+});
+const openDescriptor = Effect.fn("LocalNodeDiscovery.openDescriptor")(function* (path) {
+    const flags = constants.O_RDONLY |
+        (process.platform === "win32"
+            ? 0
+            : constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    return yield* Effect.tryPromise({
+        catch: () => makeTransportError("discovery_invalid", "The Maia local connection descriptor is unavailable."),
+        try: () => open(path, flags),
+    });
+});
+const closeDescriptor = Effect.fn("LocalNodeDiscovery.closeDescriptor")(function* (handle) {
+    yield* Effect.tryPromise({
+        catch: () => makeTransportError("discovery_invalid", "The Maia local connection descriptor could not be closed."),
+        try: () => handle.close(),
+    });
+});
+const readDescriptorChunk = (handle, bytes, offset) => Effect.tryPromise({
+    catch: () => makeTransportError("discovery_invalid", "The Maia local connection descriptor could not be read."),
+    try: () => handle.read(bytes, offset, bytes.byteLength - offset, offset),
+});
+const readDescriptorBytes = Effect.fn("LocalNodeDiscovery.readDescriptorBytes")(function* (handle) {
+    const bytes = Buffer.alloc(MAX_NODE_API_CONNECTION_DESCRIPTOR_BYTES + 1);
+    let offset = 0;
+    let complete = false;
+    yield* Effect.whileLoop({
+        body: () => readDescriptorChunk(handle, bytes, offset),
+        step: (result) => {
+            complete = result.bytesRead === 0;
+            offset += result.bytesRead;
+        },
+        while: () => !complete && offset < bytes.byteLength,
+    });
+    if (offset === 0 || offset > MAX_NODE_API_CONNECTION_DESCRIPTOR_BYTES) {
+        bytes.fill(0);
+        return yield* failTransport("discovery_invalid", "The Maia local connection descriptor exceeds its resource limit.");
+    }
+    return bytes.subarray(0, offset);
+});
+const statDescriptorHandle = Effect.fn("LocalNodeDiscovery.statDescriptorHandle")(function* (handle) {
+    return yield* Effect.tryPromise({
+        catch: () => makeTransportError("discovery_invalid", "The Maia local connection descriptor metadata is unavailable."),
+        try: () => handle.stat({ bigint: true }),
+    });
+});
+const statDescriptorPath = Effect.fn("LocalNodeDiscovery.statDescriptorPath")(function* (path) {
+    return yield* Effect.tryPromise({
+        catch: () => makeTransportError("discovery_invalid", "The Maia local connection descriptor changed while being read."),
+        try: () => lstat(path, { bigint: true }),
+    });
+});
+const resolveDiscoveryLocation = Effect.fn("LocalNodeDiscovery.resolveLocation")(function* (options) {
+    return yield* Effect.try({
+        catch: () => makeTransportError("discovery_invalid", "The Maia local profile could not be resolved."),
+        try: () => resolveCurrentLocalNodeProfileLocation({
+            profile: options.profile ?? "default",
+            ...(options.runtimeRootOverride === undefined
+                ? {}
+                : { runtimeRootOverride: options.runtimeRootOverride }),
+        }),
+    });
+});
+const transportErrorFromStatusFailure = (error) => {
+    if (error instanceof MaiaClientError &&
+        (error.code === "deadline_exceeded" ||
+            error.code === "outcome_unknown" ||
+            error.code === "saturated")) {
+        return makeTransportError(error.code, error.message);
+    }
+    return makeTransportError("transport_failed", "The discovered Maia local node is unavailable.");
+};
+const validateDiscoveredIdentity = Effect.fn("LocalNodeDiscovery.validateIdentity")(function* (descriptor, status) {
+    if (status.instanceId !== descriptor.instanceId ||
+        status.lifecycle !== "ready" ||
+        status.pid !== descriptor.pid ||
+        status.profile !== descriptor.profile ||
+        status.startedAt !== descriptor.startedAt) {
+        return yield* failTransport("discovery_invalid", "The discovered Maia local node identity did not match.");
+    }
+});
+const withDiscoveryDeadline = (effect) => effect.pipe(Effect.timeoutOrElse({
+    duration: REQUEST_DEADLINE_MS,
+    orElse: () => Effect.fail(makeTransportError("deadline_exceeded", "The Maia local discovery deadline expired.")),
+}));
+const classifiedDiscoveryError = (error) => error instanceof LocalNodeTransportError &&
+    (error.reason === "deadline_exceeded" ||
+        error.reason === "outcome_unknown" ||
+        error.reason === "saturated")
+    ? new MaiaClientError(error.reason, error.message, { cause: error })
+    : undefined;
+const invalidDescriptor = () => makeTransportError("discovery_invalid", "The Maia Node API connection descriptor is invalid.");
+const decodeNodeApiDescriptor = Effect.fn("NodeApiDiscovery.decodeDescriptor")(function* (bytes) {
+    return yield* Effect.try({
+        catch: invalidDescriptor,
+        try: () => utf8Decoder.decode(bytes),
+    }).pipe(Effect.flatMap((text) => Effect.mapError(decodeJson(text), invalidDescriptor)), Effect.flatMap((value) => Effect.try({
+        catch: invalidDescriptor,
+        try: () => nodeApiConnectionDescriptorSchema.parse(value),
+    })), Effect.ensuring(Effect.sync(() => bytes.fill(0))));
+});
+const readNodeApiDescriptorHandle = Effect.fn("NodeApiDiscovery.readDescriptorHandle")(function* (path, handle) {
+    const before = yield* statDescriptorHandle(handle);
+    yield* validateDescriptorMetadata(before);
+    if (before.size > BigInt(MAX_NODE_API_CONNECTION_DESCRIPTOR_BYTES)) {
+        return yield* failTransport("discovery_invalid", "The Maia Node API connection descriptor exceeds its resource limit.");
+    }
+    const bytes = yield* readDescriptorBytes(handle);
+    const after = yield* statDescriptorHandle(handle);
+    yield* validateDescriptorMetadata(after);
+    const current = yield* statDescriptorPath(path);
+    yield* validateDescriptorMetadata(current);
+    if (!sameFileSnapshot(before, after) || !sameFileSnapshot(after, current)) {
+        bytes.fill(0);
+        return yield* failTransport("discovery_invalid", "The Maia Node API connection descriptor changed while being read.");
+    }
+    return yield* decodeNodeApiDescriptor(bytes);
+});
+const readNodeApiDescriptor = Effect.fn("NodeApiDiscovery.readDescriptor")(function* (path) {
+    yield* validatePrivateDirectory(dirname(path)).pipe(Effect.mapError(() => makeTransportError("discovery_invalid", "The Maia Node API connection directory is unsafe.")));
+    const beforeOpen = yield* statDescriptorPath(path);
+    yield* validateDescriptorMetadata(beforeOpen);
+    return yield* Effect.acquireUseRelease(openDescriptor(path), (handle) => readNodeApiDescriptorHandle(path, handle), closeDescriptor);
+});
+const validateDiscoveredNodeApiDescriptor = Effect.fn("NodeApiDiscovery.validateDescriptor")(function* (descriptor, expected) {
+    if (descriptor.profile !== expected.profile ||
+        descriptor.credentialPath !== expected.credentialPath) {
+        return yield* failTransport("discovery_invalid", "The Maia Node API connection descriptor does not match its profile.");
+    }
+});
+const readDiscoveredNodeApi = Effect.fn("NodeApiDiscovery.read")(function* (options) {
+    const location = yield* resolveDiscoveryLocation(options);
+    const descriptor = yield* readNodeApiDescriptor(location.connectionDescriptorPath);
+    yield* validateDiscoveredNodeApiDescriptor(descriptor, location);
+    const token = yield* readCredential(descriptor.credentialPath);
+    return { descriptor, token };
+});
+export const newMessageId = (prefix) => Effect.gen(function* () {
+    const crypto = yield* Crypto.Crypto;
+    const uuid = yield* Effect.orDie(crypto.randomUUIDv4);
+    return `${prefix}_${uuid.replaceAll("-", "")}`;
+});
+export const connectDiscoveredNodeApi = (options, open) => withDiscoveryDeadline(Effect.gen(function* () {
+    const { descriptor, token } = yield* readDiscoveredNodeApi(options);
+    const opened = open(descriptor, token);
+    const messageId = yield* newMessageId("discovery");
+    const status = yield* opened
+        .status(messageId)
+        .pipe(Effect.mapError(transportErrorFromStatusFailure));
+    yield* validateDiscoveredIdentity(descriptor, status);
+    return { client: opened.client, descriptor, status };
+}));
+export const discoveryFailure = (error) => classifiedDiscoveryError(error) ??
+    new MaiaClientError("transport_failure", "The Maia Node API could not be discovered.", { cause: error });
+export const connectNodeApiEffect = (options = {}) => connectDiscoveredNodeApi(options, (descriptor, token) => {
+    const client = createNodeApiEffectClient({
+        credential: token,
+        endpoint: descriptor.endpoint,
+        ...(options.principal === undefined
+            ? {}
+            : { principal: options.principal }),
+    });
+    return { client, status: (messageId) => client.status({ messageId }) };
+}).pipe(Effect.mapError(discoveryFailure));
+export const acquireAttachedCredential = () => acquireInheritedAttachmentCredential();
+const attachedCredentialFailure = (error) => new MaiaClientError("transport_failure", "The inherited Invocation attachment is invalid or unavailable.", { cause: error });
+export const attachedTransportOptions = (descriptor, credential, readToken) => ({
+    credential: readToken(readCredential(descriptor.credentialPath)),
+    endpoint: descriptor.endpoint,
+    invocationAuthentication: {
+        credential: encodeInvocationCredential(credential),
+        scheme: "maia.invocation-attachment/v1",
+    },
+});
+export const requireAttachmentPlatform = () => process.platform === "darwin"
+    ? Effect.void
+    : Effect.fail(new MaiaClientError("transport_failure", "Inherited Invocation attachments are unsupported on this platform."));
+const attachedMessageId = (prefix, options) => options.messageId === undefined
+    ? newMessageId(prefix)
+    : Effect.succeed(options.messageId);
+const withAttachedLocalNodeEffect = (options, operation) => Effect.gen(function* () {
+    yield* requireAttachmentPlatform();
+    const connection = yield* connectNodeApiEffect(options);
+    const credential = yield* acquireAttachedCredential().pipe(Effect.mapError(attachedCredentialFailure));
+    const client = createNodeApiEffectClient(attachedTransportOptions(connection.descriptor, credential, (read) => read));
+    return yield* operation(client).pipe(Effect.ensuring(Effect.sync(() => credential.fill(0))));
+});
+export const showAttachedCurrentContextEffect = (options = {}) => withAttachedLocalNodeEffect(options, (client) => attachedMessageId("context_attached", options).pipe(Effect.flatMap((messageId) => client.showCurrentContext({}, { messageId }))));
+export const sendAttachedSessionMessageEffect = (parameters, options = {}) => withAttachedLocalNodeEffect(options, (client) => attachedMessageId("session_message", options).pipe(Effect.flatMap((messageId) => client.sendSessionMessage(parameters, { messageId }))));
+export const checkAttachedSessionInboxEffect = (parameters, options = {}) => withAttachedLocalNodeEffect(options, (client) => attachedMessageId("session_inbox_check", options).pipe(Effect.flatMap((messageId) => client.checkSessionInbox(parameters, { messageId }))));
+export const acknowledgeAttachedSessionDeliveryEffect = (parameters, options = {}) => withAttachedLocalNodeEffect(options, (client) => attachedMessageId("session_inbox_ack", options).pipe(Effect.flatMap((messageId) => client.acknowledgeSessionDelivery(parameters, { messageId }))));
+//# sourceMappingURL=discovery.js.map

package/dist/node/effect.d.ts

@@ -0,0 +1,9 @@
+export { createLocalNodeEffectClient, type LocalNodeEffectClient, } from "../client/effect.js";
+export { awaitSessionRunningEffect, createSessionsEffect, planSessionCreationEffect, type SessionCreationEffectClient, } from "../session-creation/effect.js";
+export { attachSessionEffect, type SessionAttachEffectOptions, } from "./attach.js";
+export { BridgeError, type BridgeHello, type NodeBridge, openNodeBridge, } from "./bridge.js";
+export { decodeRequestFrame, decodeServerFrame, encodeFrame, type FrameLine, splitFrameLines, } from "./bridge-frame.js";
+export { acknowledgeAttachedSessionDeliveryEffect, type AttachedLocalNodeEffectOptions, checkAttachedSessionInboxEffect, connectNodeApiEffect, type DiscoveredNodeApiEffectConnection, type NodeApiEffectDiscoveryOptions, sendAttachedSessionMessageEffect, showAttachedCurrentContextEffect, } from "./discovery.js";
+export { connectSessionNodeApiEffect, type SessionNodeApiEffectConnection, type SessionNodeApiEffectOptions, } from "./session.js";
+export { bootstrapArguments, bridgeScript, encodedScriptBytes, isPlainAbsolutePath, PATH_SEGMENT_PATTERN, REMOTE_BOOTSTRAP, remoteCommandWords, shellQuote, SSH_OPTIONS, sshCommandArguments, } from "./ssh.js";
+//# sourceMappingURL=effect.d.ts.map

package/dist/node/effect.js

@@ -0,0 +1,9 @@
+export { createLocalNodeEffectClient, } from "../client/effect.js";
+export { awaitSessionRunningEffect, createSessionsEffect, planSessionCreationEffect, } from "../session-creation/effect.js";
+export { attachSessionEffect, } from "./attach.js";
+export { BridgeError, openNodeBridge, } from "./bridge.js";
+export { decodeRequestFrame, decodeServerFrame, encodeFrame, splitFrameLines, } from "./bridge-frame.js";
+export { acknowledgeAttachedSessionDeliveryEffect, checkAttachedSessionInboxEffect, connectNodeApiEffect, sendAttachedSessionMessageEffect, showAttachedCurrentContextEffect, } from "./discovery.js";
+export { connectSessionNodeApiEffect, } from "./session.js";
+export { bootstrapArguments, bridgeScript, encodedScriptBytes, isPlainAbsolutePath, PATH_SEGMENT_PATTERN, REMOTE_BOOTSTRAP, remoteCommandWords, shellQuote, SSH_OPTIONS, sshCommandArguments, } from "./ssh.js";
+//# sourceMappingURL=effect.js.map

package/dist/node/fetch.d.ts

@@ -0,0 +1,2 @@
+export declare const platformFetch: () => typeof globalThis.fetch | undefined;
+//# sourceMappingURL=fetch.d.ts.map

package/dist/node/fetch.js

@@ -0,0 +1,2 @@
+export const platformFetch = () => globalThis.fetch;
+//# sourceMappingURL=fetch.js.map

package/dist/node/http.d.ts

@@ -0,0 +1,27 @@
+import { type ProtocolRequestEnvelope } from "@maiaos/protocol";
+import * as Effect from "effect/Effect";
+import { type LocalNodeEffectClient } from "../client/effect.js";
+import { type MaiaEffectTransport } from "../request/effect.js";
+import { MaiaClientError, type TransportRequestOptions } from "../request/index.js";
+import type { NodeApiCredential, NodeApiTransportOptions } from "./transport.js";
+export type NodeApiEffectCredential = Effect.Effect<string, unknown> | NodeApiCredential;
+export type NodeApiEffectTransportOptions = Omit<NodeApiTransportOptions, "credential"> & {
+    readonly credential: NodeApiEffectCredential;
+};
+type NodeApiTransportErrorReason = "cancelled" | "deadline_exceeded" | "invalid_response" | "outcome_unknown" | "saturated" | "transport_failure";
+declare const NodeApiTransportError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "NodeApiTransportError";
+} & Readonly<A>;
+declare class NodeApiTransportError extends NodeApiTransportError_base<{
+    readonly message: string;
+    readonly reason: NodeApiTransportErrorReason;
+}> {
+}
+export declare const toClientError: (error: unknown, signal?: AbortSignal) => MaiaClientError;
+export declare const resolveCredential: (credential: NodeApiEffectCredential) => Effect.Effect<string, NodeApiTransportError, never>;
+export type NodeApiHttpRequest = (envelope: ProtocolRequestEnvelope<unknown>, requestOptions?: TransportRequestOptions) => Effect.Effect<unknown, unknown>;
+export declare const makeNodeApiHttpRequest: (options: NodeApiEffectTransportOptions) => NodeApiHttpRequest;
+export declare const makeNodeApiEffectTransport: (options: NodeApiEffectTransportOptions) => MaiaEffectTransport;
+export declare const createNodeApiEffectClient: (options: NodeApiEffectTransportOptions) => LocalNodeEffectClient;
+export {};
+//# sourceMappingURL=http.d.ts.map