@aria-cli/cli 1.0.51 → 1.0.54

package/dist/local-control-bootstrap.js

@@ -1,26 +0,0 @@
-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

@@ -1,2 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,362 +0,0 @@
-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