@aria-cli/cli 1.0.49 → 1.0.51

package/dist/local-control-bootstrap.js

@@ -0,0 +1,26 @@
+import { RuntimeBootstrapRecordSchema } from "@aria-cli/tools";
+export function selectBootstrapTlsIdentity(bootstrap) {
+    return bootstrap.tls.loopbackIdentity;
+}
+function isAttachableBootstrapPhase(phase) {
+    return phase === "control_ready" || phase === "network_ready" || phase === "mesh_ready";
+}
+export function assertAttachableRuntimeBootstrap(expectedNodeId, bootstrap) {
+    if (bootstrap.nodeId !== expectedNodeId) {
+        throw new Error(`[local-control-client] Runtime bootstrap node mismatch for ${expectedNodeId}: received ${bootstrap.nodeId}`);
+    }
+    if (!isAttachableBootstrapPhase(bootstrap.phase)) {
+        throw new Error(`[local-control-client] Runtime bootstrap for ${expectedNodeId} is not attachable (phase=${bootstrap.phase})`);
+    }
+    return bootstrap;
+}
+export async function loadControlReadyRuntimeBootstrap(bootstrapSource) {
+    const bootstrap = RuntimeBootstrapRecordSchema.parse(typeof bootstrapSource === "function" ? await bootstrapSource() : bootstrapSource);
+    if (bootstrap.phase !== "control_ready" &&
+        bootstrap.phase !== "network_ready" &&
+        bootstrap.phase !== "mesh_ready") {
+        throw new Error(`Runtime bootstrap is not control-ready: ${bootstrap.phase}${bootstrap.degradedReason ? ` (${bootstrap.degradedReason})` : ""}`);
+    }
+    return bootstrap;
+}
+//# sourceMappingURL=local-control-bootstrap.js.map

package/dist/local-control-client.js

@@ -0,0 +1,2 @@
+export { attachExistingLocalControlClient, attachLocalControlClient, createResilientAttachedClient, requestRuntimeSocketLease, resolveLocalControlClient, resolveLocalControlClientSync, } from "./attached-local-control-client.js";
+//# sourceMappingURL=local-control-client.js.map

package/dist/local-control-error-reporting.js

@@ -0,0 +1,34 @@
+import { getAriaDir } from "./config.js";
+let trustedLocalControlErrorHandler;
+async function getTrustedLocalControlErrorHandler() {
+    const ariaDir = getAriaDir();
+    if (trustedLocalControlErrorHandler?.ariaDir === ariaDir) {
+        return trustedLocalControlErrorHandler.handler;
+    }
+    const { CentralErrorHandler } = await import("@aria-cli/aria/error-handler");
+    const handler = new CentralErrorHandler({ ariaDir });
+    trustedLocalControlErrorHandler = { ariaDir, handler };
+    return handler;
+}
+export async function reportTrustedLocalControlFailure(error, context) {
+    const handler = await getTrustedLocalControlErrorHandler();
+    await handler.report(error, {
+        workingDir: process.cwd(),
+        providerState: {
+            lastProvider: "trusted-local-control",
+            lastModel: context.endpoint,
+            ...(typeof context.responseStatus === "number"
+                ? { lastStatusCode: context.responseStatus }
+                : {}),
+        },
+        configSnapshot: {
+            transport: context.transport,
+            endpoint: context.endpoint,
+            ...(typeof context.responseStatus === "number"
+                ? { responseStatus: context.responseStatus }
+                : {}),
+            payload: context.payload,
+        },
+    });
+}
+//# sourceMappingURL=local-control-error-reporting.js.map

package/dist/local-control-http-client.js

@@ -0,0 +1,362 @@
+import { tlsFetch } from "@aria-cli/aria/server-discovery";
+import { log } from "@aria-cli/types";
+import { createTrustedRuntimeError, LOCAL_HTTP_CLIENT_ID_HEADER, LOCAL_HTTP_CLIENT_PROOF_HEADER, DirectPairRequestSchema, DirectPairResponseSchema, InboxAddressSchema, InboxListRequestSchema, InvitePeerRequestSchema, InvitePeerResultSchema, NearbyPeerViewSchema, OutboundMessageSchema, PairRequestDecisionSchema, PairRequestResponseSchema, PendingInviteViewSchema, PendingPairRequestViewSchema, PeerViewEventSchema, PersistedInboxEventSchema, RepairPeerRequestSchema, RepairPeerResponseSchema, RevokePeerRequestSchema, RevokePeerResponseSchema, ResumeRunRequestSchema, RunRequestSchema, RunResultSchema, RuntimeBootstrapRecordSchema, RuntimeDeliveryReceiptSchema, RuntimeQueuedReceiptSchema, RuntimeStatusSchema, AcceptInviteRequestSchema, AcceptInviteResponseSchema, AcceptInviteTokenRequestSchema, AcceptInviteTokenResponseSchema, CancelInviteRequestSchema, CancelInviteResponseSchema, CreateInviteRequestSchema, CreateInviteResponseSchema, } from "@aria-cli/tools";
+import { createPollingSubscription } from "./polling-subscription.js";
+import { loadControlReadyRuntimeBootstrap, selectBootstrapTlsIdentity, } from "./local-control-bootstrap.js";
+import { reportTrustedLocalControlFailure } from "./local-control-error-reporting.js";
+async function fetchLocalJson(endpoint, options) {
+    const bootstrap = await loadControlReadyRuntimeBootstrap(options.bootstrap);
+    const headers = {};
+    if (options.body) {
+        headers["Content-Type"] = "application/json";
+    }
+    if (options.attachedClientId) {
+        headers[LOCAL_HTTP_CLIENT_ID_HEADER] = options.attachedClientId;
+    }
+    if (options.attachedClientAuthToken) {
+        headers[LOCAL_HTTP_CLIENT_PROOF_HEADER] = options.attachedClientAuthToken;
+    }
+    const response = await tlsFetch(`https://127.0.0.1:${bootstrap.controlEndpoint.port}${endpoint}`, {
+        method: options.method,
+        body: options.body,
+        signal: options.signal,
+        headers: Object.keys(headers).length > 0 ? headers : undefined,
+        ca: bootstrap.tls.caCertPem,
+        expectedTlsIdentity: selectBootstrapTlsIdentity(bootstrap),
+    });
+    const payload = (await response.json());
+    if (!response.ok) {
+        const trustedError = createTrustedRuntimeError(payload.error ?? `HTTP ${response.status}`, payload.diagnostic);
+        // Propagate the reason sub-code for stale-lease detection
+        if (payload.reason) {
+            trustedError.reason = payload.reason;
+        }
+        await reportTrustedLocalControlFailure(trustedError, {
+            endpoint,
+            responseStatus: response.status,
+            payload,
+            transport: "https",
+        });
+        throw trustedError;
+    }
+    if (!options.parse) {
+        return payload;
+    }
+    try {
+        return options.parse(payload);
+    }
+    catch (error) {
+        const wrappedError = new Error(`[local-control-client] Invalid trusted local-control response for ${endpoint}: ${error instanceof Error ? error.message : String(error)}`, {
+            cause: error instanceof Error ? error : undefined,
+        });
+        log.error("[local-control-client] Invalid trusted local-control response", {
+            endpoint,
+            status: response.status,
+            payload,
+        }, error);
+        await reportTrustedLocalControlFailure(wrappedError, {
+            endpoint,
+            responseStatus: response.status,
+            payload,
+            transport: "https",
+        });
+        throw wrappedError;
+    }
+}
+function parsePersistedInboxEvent(message) {
+    return PersistedInboxEventSchema.parse({
+        id: message.id,
+        senderNodeId: message.sender_id,
+        senderDisplayNameSnapshot: message.sender_name,
+        senderType: message.sender_type,
+        inboxAddress: InboxAddressSchema.parse({
+            kind: message.inbox_address_kind,
+            ...(message.inbox_address_kind === "client"
+                ? {
+                    clientId: message.inbox_address_id,
+                }
+                : {
+                    nodeId: message.inbox_address_id,
+                }),
+        }),
+        type: message.type,
+        content: message.content,
+        priority: message.priority,
+        createdAt: message.created_at,
+        correlationId: message.correlation_id,
+        replyTo: message.reply_to,
+    });
+}
+function filterInboxByCursor(messages, request) {
+    return messages.filter((message) => typeof request?.cursor?.afterCreatedAt === "number"
+        ? message.createdAt >= request.cursor.afterCreatedAt
+        : true);
+}
+function createOneShotHandle(resultPromise) {
+    return {
+        runId: `run-local-${Date.now()}`,
+        wait: () => resultPromise,
+    };
+}
+export function createLocalControlClient(options) {
+    const pollIntervalMs = options.pollIntervalMs ?? 1_000;
+    const listInbox = async (request) => {
+        const parsedRequest = InboxListRequestSchema.optional().parse(request);
+        const limit = parsedRequest?.limit ?? 100;
+        const unreadOnly = parsedRequest?.unreadOnly ?? false;
+        const payload = await fetchLocalJson(`/api/v1/messages?limit=${limit}&unread=${unreadOnly ? "true" : "false"}`, {
+            bootstrap: options.bootstrap,
+            attachedClientId: options.attachedClientId,
+            attachedClientAuthToken: options.attachedClientAuthToken,
+        });
+        return filterInboxByCursor((payload.messages ?? []).map(parsePersistedInboxEvent), parsedRequest);
+    };
+    return {
+        async submitRun(request) {
+            const payload = RunRequestSchema.parse(request);
+            return createOneShotHandle(fetchLocalJson("/api/v1/run", {
+                method: "POST",
+                body: JSON.stringify(payload),
+                bootstrap: options.bootstrap,
+                attachedClientId: options.attachedClientId,
+                attachedClientAuthToken: options.attachedClientAuthToken,
+                parse: (raw) => RunResultSchema.parse(raw),
+            }));
+        },
+        async resumeRun(request) {
+            const payload = ResumeRunRequestSchema.parse(request);
+            return fetchLocalJson("/api/v1/resume", {
+                method: "POST",
+                body: JSON.stringify(payload),
+                bootstrap: options.bootstrap,
+                attachedClientId: options.attachedClientId,
+                attachedClientAuthToken: options.attachedClientAuthToken,
+                parse: (raw) => RunResultSchema.parse(raw),
+            });
+        },
+        async *streamRun(_request, _signal) {
+            throw new Error("Local control stream surface is only available through attached runtime sockets");
+        },
+        async *subscribeRuntimeEvents(_cursor) {
+            throw new Error("Local control runtime event surface is only available through attached runtime sockets");
+        },
+        async sendBestEffort(message) {
+            const payload = OutboundMessageSchema.parse(message);
+            return fetchLocalJson("/api/v1/message/relay", {
+                method: "POST",
+                body: JSON.stringify({
+                    deliveryMode: "best_effort",
+                    ...(payload.to ? { to: payload.to } : {}),
+                    ...(payload.content ? { content: payload.content } : {}),
+                    ...(payload.type ? { type: payload.type } : {}),
+                    ...(typeof payload.priority === "number" ? { priority: payload.priority } : {}),
+                    ...(payload.correlationId ? { correlationId: payload.correlationId } : {}),
+                    ...(payload.metadata ? { metadata: payload.metadata } : {}),
+                    _rawMessage: payload.rawMessage,
+                }),
+                bootstrap: options.bootstrap,
+                attachedClientId: options.attachedClientId,
+                attachedClientAuthToken: options.attachedClientAuthToken,
+                parse: (raw) => RuntimeQueuedReceiptSchema.parse(raw),
+            });
+        },
+        async sendDurable(message) {
+            const payload = OutboundMessageSchema.parse(message);
+            return fetchLocalJson("/api/v1/message/relay", {
+                method: "POST",
+                body: JSON.stringify({
+                    deliveryMode: "durable",
+                    ...(payload.to ? { to: payload.to } : {}),
+                    ...(payload.content ? { content: payload.content } : {}),
+                    ...(payload.type ? { type: payload.type } : {}),
+                    ...(typeof payload.priority === "number" ? { priority: payload.priority } : {}),
+                    ...(payload.correlationId ? { correlationId: payload.correlationId } : {}),
+                    ...(payload.metadata ? { metadata: payload.metadata } : {}),
+                    _rawMessage: payload.rawMessage,
+                }),
+                bootstrap: options.bootstrap,
+                attachedClientId: options.attachedClientId,
+                attachedClientAuthToken: options.attachedClientAuthToken,
+                parse: (raw) => RuntimeDeliveryReceiptSchema.parse(raw),
+            });
+        },
+        listInbox,
+        subscribeInbox(cursor) {
+            return createPollingSubscription(() => listInbox({ limit: 100, unreadOnly: false }), {
+                pollIntervalMs,
+                initialAfterCreatedAt: cursor?.afterCreatedAt ?? 0,
+                getIdentityKey: (message) => message.id,
+                getCursor: (message) => message.createdAt,
+            });
+        },
+        async listPeers() {
+            const payload = await fetchLocalJson("/api/v1/local-control/peers", {
+                bootstrap: options.bootstrap,
+                attachedClientId: options.attachedClientId,
+                attachedClientAuthToken: options.attachedClientAuthToken,
+            });
+            return (payload.peers ?? []).map((peer) => PeerViewEventSchema.parse(peer));
+        },
+        async listNearbyPeers() {
+            const payload = await fetchLocalJson("/api/v1/local-control/nearby-peers", {
+                bootstrap: options.bootstrap,
+                attachedClientId: options.attachedClientId,
+                attachedClientAuthToken: options.attachedClientAuthToken,
+            });
+            return (payload.peers ?? []).map((peer) => NearbyPeerViewSchema.parse(peer));
+        },
+        subscribePeers() {
+            return createPollingSubscription(async () => {
+                const payload = await fetchLocalJson("/api/v1/local-control/peers", {
+                    bootstrap: options.bootstrap,
+                    attachedClientId: options.attachedClientId,
+                    attachedClientAuthToken: options.attachedClientAuthToken,
+                });
+                return (payload.peers ?? []).map((peer) => PeerViewEventSchema.parse(peer));
+            }, {
+                pollIntervalMs,
+                getIdentityKey: (peer) => peer.nodeId,
+                getVersionKey: (peer) => [
+                    peer.updatedAt,
+                    peer.endpointRevision,
+                    peer.identityState,
+                    peer.transportState,
+                    peer.lastSeenAt ?? "",
+                    peer.transportPublicKey,
+                    peer.displayNameSnapshot ?? "",
+                ].join("|"),
+            });
+        },
+        async getRuntimeStatus() {
+            return fetchLocalJson("/api/v1/local-control/runtime-status", {
+                bootstrap: options.bootstrap,
+                attachedClientId: options.attachedClientId,
+                attachedClientAuthToken: options.attachedClientAuthToken,
+                parse: (raw) => RuntimeStatusSchema.parse(raw),
+            });
+        },
+        async getRuntimeBootstrap() {
+            return fetchLocalJson("/api/v1/runtime/bootstrap", {
+                bootstrap: options.bootstrap,
+                parse: (raw) => RuntimeBootstrapRecordSchema.parse(raw),
+            });
+        },
+        async listPendingPairRequests() {
+            const payload = await fetchLocalJson("/api/v1/local-control/pending-pair-requests", {
+                bootstrap: options.bootstrap,
+                attachedClientId: options.attachedClientId,
+                attachedClientAuthToken: options.attachedClientAuthToken,
+            });
+            return (payload.requests ?? []).map((request) => PendingPairRequestViewSchema.parse(request));
+        },
+        async respondToPairRequest(input) {
+            return fetchLocalJson("/api/v1/local-control/respond-pair-request", {
+                method: "POST",
+                body: JSON.stringify(PairRequestDecisionSchema.parse(input)),
+                bootstrap: options.bootstrap,
+                attachedClientId: options.attachedClientId,
+                attachedClientAuthToken: options.attachedClientAuthToken,
+                parse: (raw) => PairRequestResponseSchema.parse(raw),
+            });
+        },
+        async createInvite(input) {
+            return fetchLocalJson("/api/v1/local-control/invites", {
+                method: "POST",
+                body: JSON.stringify(CreateInviteRequestSchema.parse(input)),
+                bootstrap: options.bootstrap,
+                attachedClientId: options.attachedClientId,
+                attachedClientAuthToken: options.attachedClientAuthToken,
+                parse: (raw) => CreateInviteResponseSchema.parse(raw),
+            });
+        },
+        async listPendingInvites() {
+            const payload = await fetchLocalJson("/api/v1/local-control/invites", {
+                bootstrap: options.bootstrap,
+                attachedClientId: options.attachedClientId,
+                attachedClientAuthToken: options.attachedClientAuthToken,
+            });
+            return (payload.invites ?? []).map((invite) => PendingInviteViewSchema.parse(invite));
+        },
+        async acceptInviteToken(input) {
+            return fetchLocalJson("/api/v1/local-control/accept-invite-token", {
+                method: "POST",
+                body: JSON.stringify(AcceptInviteTokenRequestSchema.parse(input)),
+                bootstrap: options.bootstrap,
+                attachedClientId: options.attachedClientId,
+                attachedClientAuthToken: options.attachedClientAuthToken,
+                parse: (raw) => AcceptInviteTokenResponseSchema.parse(raw),
+            });
+        },
+        async cancelInvite(input) {
+            return fetchLocalJson("/api/v1/local-control/cancel-invite", {
+                method: "POST",
+                body: JSON.stringify(CancelInviteRequestSchema.parse(input)),
+                bootstrap: options.bootstrap,
+                attachedClientId: options.attachedClientId,
+                attachedClientAuthToken: options.attachedClientAuthToken,
+                parse: (raw) => CancelInviteResponseSchema.parse(raw),
+            });
+        },
+        async invitePeer(input) {
+            return fetchLocalJson("/api/v1/local-control/peer-invite", {
+                method: "POST",
+                body: JSON.stringify(InvitePeerRequestSchema.parse(input)),
+                bootstrap: options.bootstrap,
+                attachedClientId: options.attachedClientId,
+                attachedClientAuthToken: options.attachedClientAuthToken,
+                parse: (raw) => InvitePeerResultSchema.parse(raw),
+            });
+        },
+        async acceptInvite(input) {
+            return fetchLocalJson("/api/v1/local-control/accept-invite", {
+                method: "POST",
+                body: JSON.stringify(AcceptInviteRequestSchema.parse(input)),
+                bootstrap: options.bootstrap,
+                attachedClientId: options.attachedClientId,
+                attachedClientAuthToken: options.attachedClientAuthToken,
+                parse: (raw) => AcceptInviteResponseSchema.parse(raw),
+            });
+        },
+        async directPair(input) {
+            return fetchLocalJson("/api/v1/local-control/direct-pair", {
+                method: "POST",
+                body: JSON.stringify(DirectPairRequestSchema.parse(input)),
+                bootstrap: options.bootstrap,
+                attachedClientId: options.attachedClientId,
+                attachedClientAuthToken: options.attachedClientAuthToken,
+                parse: (raw) => DirectPairResponseSchema.parse(raw),
+            });
+        },
+        async revokePeer(input) {
+            return fetchLocalJson("/api/v1/local-control/revoke-peer", {
+                method: "POST",
+                body: JSON.stringify(RevokePeerRequestSchema.parse(input)),
+                bootstrap: options.bootstrap,
+                attachedClientId: options.attachedClientId,
+                attachedClientAuthToken: options.attachedClientAuthToken,
+                parse: (raw) => RevokePeerResponseSchema.parse(raw),
+            });
+        },
+        async repairPeer(input) {
+            return fetchLocalJson("/api/v1/local-control/repair-peer", {
+                method: "POST",
+                body: JSON.stringify(RepairPeerRequestSchema.parse(input)),
+                bootstrap: options.bootstrap,
+                attachedClientId: options.attachedClientId,
+                attachedClientAuthToken: options.attachedClientAuthToken,
+                parse: (raw) => RepairPeerResponseSchema.parse(raw),
+            });
+        },
+        async appendSessionMessages(_sessionId, _messages) {
+            // HTTP bootstrap clients do not own the attached IPC session writer surface.
+        },
+        async markSessionCompleted(_sessionId) {
+            // HTTP bootstrap clients do not own the attached IPC session writer surface.
+        },
+        async replaceSessionMessages(_sessionId, _messages) {
+            // HTTP bootstrap clients do not own the attached IPC session writer surface.
+        },
+    };
+}
+export { assertAttachableRuntimeBootstrap, } from "./local-control-bootstrap.js";
+//# sourceMappingURL=local-control-http-client.js.map