@aria-cli/server 1.0.19

package/dist/session-history.d.ts

@@ -0,0 +1,28 @@
+import type { SessionHistoryLike } from "@aria-cli/aria";
+export interface RecoveryToolCall {
+    id: string;
+    name: string;
+    arguments?: Record<string, unknown>;
+    /** Gemini thought signature — must be replayed verbatim in conversation history */
+    thoughtSignature?: string;
+}
+export interface RecoverySessionMessage {
+    role: string;
+    content: string;
+    name?: string;
+    toolCallId?: string;
+    toolCalls?: RecoveryToolCall[];
+}
+export interface RecoverySessionSummary {
+    id: string;
+    messageCount: number;
+    arionName?: string;
+}
+export interface ServerSessionHistory extends SessionHistoryLike {
+    upsertSession(sessionId: string, messages: RecoverySessionMessage[], options?: {
+        completed?: boolean;
+        arionName?: string;
+    }): void;
+    getIncompleteSessionsWithMetadata?(limit: number): RecoverySessionSummary[];
+}
+export declare function createServerSessionHistory(filePath: string): ServerSessionHistory;

package/dist/shared-4jsvhy6g.js

@@ -0,0 +1 @@
+import{c as a,d as b,e as c,f as d,g as e,h as f,i as g,j as h}from"./index-zge0mhc0.js";import"./index-9xs3gn0p.js";export{g as normalizeEntrypointHistory,e as isAskUserAnswersExhaustedError,f as getToolResultHighlight,d as createAskUserHandler,c as createApprovalHandler,h as buildEntrypointRunOptions,b as AskUserAnswersExhaustedError,a as APPROVAL_PAUSE_SIGNAL};

package/dist/types.d.ts

@@ -0,0 +1,299 @@
+/**
+ * Fastify type augmentation for ARIA server decorations.
+ *
+ * Import this file (side-effect) in any route that accesses
+ * server.ariaMemoriaFactory, server.ariaRouter, or server.ariaBasePath.
+ */
+import type { RawRequestDefaultExpression } from "fastify";
+import type { MemoriaFactory, StoredPairRequest, NonceStore, PeerSigningKeyStore, TrustTier } from "@aria-cli/aria";
+import type { ModelRouter } from "@aria-cli/models";
+import type { AuthResolver } from "@aria-cli/auth";
+import type { ServerSessionHistory } from "./session-history.js";
+import type { AcceptInviteRequest, AcceptInviteResponse, AttachedClientAuth, AttachedClientView, DirectPairResponse, InvitePeerRequest, InvitePeerResult, MailboxRef, LegacyPeerRegistryStatus, MessageStoreRef, NetworkManagerRef, NodeId, OutboundMessage, PairRequestDecision, PairRequestResponse, PendingPairRequestView, RelayPendingRequest, PeerTransportId, PrincipalFingerprint, PeerViewEvent, RevocationOperatorConfirmation, ControlEndpointAdvertisement, RepairPeerRequest, RepairPeerResponse, RevokePeerRequest, RevokePeerResponse, ResumeRunRequest, RuntimeRunEvent, RunRequest, RunResult, RuntimeId, RuntimeDeliveryReceipt, RuntimeQueuedReceipt, RuntimeStatus, RuntimeBootstrapRecord, PersistedInboxEvent, SigningPublicKey, TransportEndpointAdvertisement } from "@aria-cli/tools";
+type DirectPairRequestContext = {
+    ip: string;
+    raw: RawRequestDefaultExpression;
+};
+type ServerNetworkManagerRef = Omit<NetworkManagerRef, "invite"> & {
+    invite(displayName?: string, options?: number | {
+        durationMs?: number;
+        nodeId?: NodeId;
+        caCert?: string;
+        controlEndpoint: ControlEndpointAdvertisement;
+        transportHostOverride?: string;
+    }): {
+        token: string;
+        psk: string;
+    };
+    completeJoin?(params: {
+        nodeId: NodeId;
+        principalFingerprint: PrincipalFingerprint;
+        peerPublicKey: PeerTransportId;
+        peerSigningKey: SigningPublicKey;
+        peerTransportEndpoint: TransportEndpointAdvertisement;
+        peerControlEndpoint: ControlEndpointAdvertisement;
+        displayNameSnapshot?: string;
+        inviteTokenNonce: string;
+    }): Promise<{
+        effectiveName: string;
+    }>;
+};
+declare module "fastify" {
+    interface FastifyInstance {
+        ariaMemoriaFactory?: MemoriaFactory;
+        ariaRouter?: ModelRouter;
+        ariaBasePath: string;
+        ariaSessionHistory?: ServerSessionHistory;
+        ariaRecoverCrashedSessions?: (signal?: AbortSignal) => Promise<void>;
+        ariaAuthResolver?: AuthResolver | null;
+        /** Canonical runtime identity for daemon-backed sends. */
+        ariaRuntimeId?: RuntimeId;
+        /** Durable node identity for runtime-owned local control routes. */
+        ariaNodeId?: NodeId;
+        /** Single-writer generation for durable runtime-owned identity mutations. */
+        ariaOwnerGeneration?: number;
+        config: {
+            port: number;
+            host: string;
+        };
+        /** MessageStore for inter-agent messaging — set by server startup when Memoria is available */
+        ariaMessageStore?: MessageStoreRef;
+        /** EventQueue for daemon event processing — append-only interface for incoming messages */
+        ariaEventQueue?: {
+            append(input: {
+                source: string;
+                content: string;
+                relevance: number;
+            }): void;
+        };
+        /** Durable peer signing key store — persists keys across restarts */
+        ariaPeerSigningKeyStore?: PeerSigningKeyStore;
+        /** NetworkManager for WireGuard peer management — set when mesh networking is active */
+        ariaNetworkManager?: ServerNetworkManagerRef;
+        /** Canonical runtime-owned outbox for localhost relay and attached clients. */
+        ariaRuntimeOutbox?: Pick<MailboxRef, "sendBestEffort" | "sendDurable">;
+        /** Runtime-owned run execution surface for attached local clients. */
+        ariaRunControl?: {
+            submitRun?(request: RunRequest, attachedClient?: {
+                clientId: string;
+            }): Promise<RunResult>;
+            resumeRun?(request: ResumeRunRequest, attachedClient?: {
+                clientId: string;
+            }): Promise<RunResult>;
+            streamRun?(request: RunRequest, signal?: AbortSignal, attachedClient?: {
+                clientId: string;
+            }): AsyncIterable<RuntimeRunEvent>;
+        };
+        /** Runtime-owned message delivery and inbox surface for attached local clients. */
+        ariaRuntimeMessageControl?: {
+            sendBestEffort(message: OutboundMessage): Promise<RuntimeQueuedReceipt>;
+            sendDurable(message: OutboundMessage): Promise<RuntimeDeliveryReceipt>;
+            listInbox(options?: {
+                limit?: number;
+                unreadOnly?: boolean;
+            }): Promise<PersistedInboxEvent[]>;
+            listDirectClientInbox?(options: {
+                clientId: string;
+                limit?: number;
+                unreadOnly?: boolean;
+            }): Promise<PersistedInboxEvent[]>;
+        };
+        /** Runtime-owned join completion surface for the control-plane route adapter. */
+        ariaJoinControl?: {
+            completeJoin(input: {
+                nodeId: NodeId;
+                principalFingerprint: PrincipalFingerprint;
+                peerPublicKey: PeerTransportId;
+                peerSigningKey: SigningPublicKey;
+                peerTransportEndpoint: TransportEndpointAdvertisement;
+                peerControlEndpoint: ControlEndpointAdvertisement;
+                displayNameSnapshot?: string;
+                inviteTokenNonce: string;
+            }): Promise<{
+                effectiveName: string;
+            }>;
+        };
+        /** Runtime-owned bootstrap authority surface. */
+        ariaRuntimeBootstrapControl?: {
+            getRuntimeBootstrap(): Promise<RuntimeBootstrapRecord>;
+        };
+        /** Runtime-owned status/admin surface for daemon lifecycle projections. */
+        ariaRuntimeLocalControl?: {
+            getRuntimeStatus(): Promise<RuntimeStatus>;
+        };
+        /** Runtime-owned attached-client directory and auth surface. */
+        ariaAttachedClientControl?: {
+            listAttachedClients(input: {
+                clientId: string;
+            }): Promise<AttachedClientView[]>;
+            countAttachedClients(): number;
+            authorizeAttachedClient(auth: AttachedClientAuth): boolean;
+        };
+        /** Runtime-owned peer discovery and local pairing helper surface. */
+        ariaPeerLocalControl?: {
+            listPeers(): Promise<PeerViewEvent[]>;
+            listNearbyPeers(): Promise<import("@aria-cli/tools").NearbyPeerView[]>;
+            createInvite(input: import("@aria-cli/tools").CreateInviteRequest): Promise<import("@aria-cli/tools").CreateInviteResponse>;
+            listPendingInvites(): Promise<import("@aria-cli/tools").PendingInviteView[]>;
+            acceptInviteToken(input: import("@aria-cli/tools").AcceptInviteTokenRequest): Promise<import("@aria-cli/tools").AcceptInviteTokenResponse>;
+            cancelInvite(input: import("@aria-cli/tools").CancelInviteRequest): Promise<import("@aria-cli/tools").CancelInviteResponse>;
+            invitePeer(input: InvitePeerRequest): Promise<InvitePeerResult>;
+            repairPeer(input: RepairPeerRequest): Promise<RepairPeerResponse>;
+        };
+        /** Runtime-owned public network peer-read surface for control-plane adapters. */
+        ariaNetworkReadControl?: {
+            listPeers(): Promise<Array<{
+                nodeId: NodeId;
+                transportPublicKey: PeerTransportId;
+                displayNameSnapshot?: string;
+                status: LegacyPeerRegistryStatus;
+                endpointHost: string | null;
+                endpointPort: number | null;
+                endpointRevision: number;
+                lastHandshake: number | null;
+                createdAt: number;
+                updatedAt: number;
+            }>>;
+            getPeerView(nodeId: NodeId): Promise<{
+                nodeId: NodeId;
+                transportPublicKey: PeerTransportId;
+                displayNameSnapshot?: string;
+                status: LegacyPeerRegistryStatus;
+                endpointHost: string | null;
+                endpointPort: number | null;
+                endpointRevision: number;
+                lastHandshake: number | null;
+                createdAt: number;
+                updatedAt: number;
+            } | undefined>;
+        };
+        /** Runtime-owned public network registration surface for control-plane adapters. */
+        ariaNetworkRegistrationControl?: {
+            registerPeer(input: {
+                nodeId: NodeId;
+                endpointHost?: string;
+                endpointPort?: number;
+                endpointRevision?: number;
+            }): Promise<{
+                registered: true;
+                nodeId: NodeId;
+                displayNameSnapshot?: string;
+                peerStatus: string;
+                lastSeen: number;
+                heartbeatUpdated: boolean;
+                endpointUpdated: boolean;
+                endpointRevision: number;
+            }>;
+        };
+        /** Runtime-owned pair control surface. */
+        ariaPairControl?: {
+            listPendingPairRequests(): Promise<PendingPairRequestView[]>;
+            ingestRelayedPairRequest(input: RelayPendingRequest): Promise<void>;
+            respondToPairRequest(input: PairRequestDecision): Promise<PairRequestResponse>;
+            acceptInvite(input: AcceptInviteRequest): Promise<AcceptInviteResponse>;
+            directPair(input: Record<string, unknown>, requestContext?: DirectPairRequestContext): Promise<DirectPairResponse>;
+        };
+        /** Runtime-owned peer revocation/admin surface. */
+        ariaNetworkAdminControl?: {
+            revokePeer(input: RevokePeerRequest & {
+                rateLimitFallbackKey?: string;
+            }): Promise<RevokePeerResponse>;
+        };
+        /** Durable pair request store — persists pair requests across restarts */
+        ariaDurablePairStore?: {
+            store(req: StoredPairRequest): void;
+            get(id: string): StoredPairRequest | undefined;
+            delete(id: string): void;
+            findAllActive(): StoredPairRequest[];
+            findPending(): StoredPairRequest[];
+            findRelayedForTargetNodeId(targetNodeId: NodeId): StoredPairRequest[];
+            cleanup(): void;
+        };
+        /** H2c: Revocation store for durable revocation events */
+        ariaRevocationStore?: {
+            revoke(event: {
+                nodeId: NodeId;
+                displayNameSnapshot?: string;
+                fingerprint: PrincipalFingerprint;
+                revokedAt: number;
+                localNodeId: NodeId;
+                operatorConfirmation: RevocationOperatorConfirmation;
+                reason?: string;
+                revocationGeneration?: number;
+            }): void;
+            isPeerRevoked(nodeId: NodeId): boolean;
+            read?(nodeId: NodeId): {
+                nodeId: NodeId;
+                displayNameSnapshot?: string;
+                fingerprint: PrincipalFingerprint;
+                revokedAt: number;
+                localNodeId: NodeId;
+                operatorConfirmation: RevocationOperatorConfirmation;
+                reason?: string;
+                revocationGeneration?: number;
+            } | null;
+            getPeerRevocationGeneration?(nodeId: NodeId): number | null;
+            clearRevocationForNodeId(nodeId: NodeId, expectedGeneration?: number): boolean;
+            list(): Array<{
+                nodeId: NodeId;
+                displayNameSnapshot?: string;
+                fingerprint: PrincipalFingerprint;
+                revokedAt: number;
+                localNodeId: NodeId;
+                operatorConfirmation: RevocationOperatorConfirmation;
+                reason?: string;
+                revocationGeneration?: number;
+            }>;
+        };
+        /** Relay cleanup callback — removes relay state for a revoked peer principal */
+        ariaRelayCleanup?: (nodeId: NodeId) => void;
+        /** Revocation broadcast callback — pushes revocation to WebSocket subscribers */
+        ariaRevocationBroadcast?: (revocation: {
+            nodeId: NodeId;
+            displayNameSnapshot?: string;
+            revokedAt: number;
+        }) => void;
+        /** Durable nonce store for mutation envelope replay protection */
+        ariaNonceStore?: NonceStore;
+        /** Peer trust tier store — tracks trust levels for known peers */
+        ariaPeerTrustStore?: {
+            get?(nodeId: NodeId): {
+                nodeId: NodeId;
+                displayName: string;
+                fingerprint?: PrincipalFingerprint;
+                tier: TrustTier;
+                promotedAt: number;
+                promotedBy: string;
+                reason?: string;
+            } | undefined;
+            getTier(nodeId: NodeId): TrustTier;
+            peerHasCapability(nodeId: NodeId, capability: string): boolean;
+            setTier(params: {
+                nodeId: NodeId;
+                displayName: string;
+                fingerprint?: PrincipalFingerprint;
+                tier: TrustTier;
+                promotedAt?: number;
+                promotedBy: string;
+                reason?: string;
+            }): void;
+            restore?(record: {
+                nodeId: NodeId;
+                displayName: string;
+                fingerprint?: PrincipalFingerprint;
+                tier: TrustTier;
+                promotedAt: number;
+                promotedBy: string;
+                reason?: string;
+            }): void;
+            delete?(nodeId: NodeId): boolean;
+        };
+        /** Invite consume ledger — prevents invite token replay */
+        ariaInviteConsumeLedger?: {
+            consume(nonce: string, issuer: string, audience: string): boolean;
+            isConsumed(nonce: string): boolean;
+            cleanup(maxAgeMs?: number): void;
+        };
+    }
+}
+export {};

package/dist/utils/rate-limiter.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Sliding-window per-key rate limiter.
+ *
+ * Tracks request timestamps per key in a bounded Map. When the map exceeds
+ * maxKeys, stale entries (those whose window has expired) are evicted.
+ */
+export declare class RateLimiter {
+    private readonly maxRequests;
+    private readonly windowMs;
+    private readonly maxKeys;
+    private readonly windows;
+    /**
+     * @param maxRequests Maximum requests allowed per window per key
+     * @param windowMs Time window in milliseconds
+     * @param maxKeys Maximum distinct keys to track (bounded memory). Default: 10000
+     */
+    constructor(maxRequests: number, windowMs: number, maxKeys?: number);
+    /**
+     * Check if a request from the given key is allowed.
+     * Returns true if allowed, false if rate-limited.
+     */
+    check(key: string): boolean;
+    /** Remove entries whose window has fully expired. */
+    private cleanup;
+}

package/dist/utils/sanitize-error.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Sanitize error messages for external consumption.
+ *
+ * Known client errors (4xx status codes) pass their message through;
+ * everything else is replaced with a generic "Internal server error"
+ * to avoid leaking implementation details.
+ */
+export declare function sanitizeError(error: unknown, logger?: {
+    error: (...args: unknown[]) => void;
+}): string;

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "@aria-cli/server",
+  "version": "1.0.19",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./runtime/host-supervisor": {
+      "types": "./dist/runtime/host-supervisor.d.ts",
+      "import": "./dist/runtime/host-supervisor.js"
+    },
+    "./runtime/local-control-api": {
+      "types": "./dist/runtime/local-control-api.d.ts",
+      "import": "./dist/runtime/local-control-api.js"
+    },
+    "./runtime/node-metadata": {
+      "types": "./dist/runtime/node-metadata.d.ts",
+      "import": "./dist/runtime/node-metadata.js"
+    },
+    "./runtime/node-store": {
+      "types": "./dist/runtime/node-store.d.ts",
+      "import": "./dist/runtime/node-store.js"
+    },
+    "./runtime/runtime-registry": {
+      "types": "./dist/runtime/runtime-registry.d.ts",
+      "import": "./dist/runtime/runtime-registry.js"
+    },
+    "./routes/pair": {
+      "types": "./dist/routes/pair.d.ts",
+      "import": "./dist/routes/pair.js"
+    },
+    "./daemon-launcher": {
+      "types": "./dist/daemon-launcher.d.ts",
+      "import": "./dist/daemon-launcher.js"
+    }
+  },
+  "scripts": {
+    "test": "vitest run --config vitest.config.ts",
+    "test:list": "tsx tests/print-default-test-lane.ts",
+    "test:watch": "vitest --config vitest.config.ts",
+    "test:integration": "vitest run --config vitest.integration.config.ts",
+    "test:e2e": "vitest run --config vitest.e2e.config.ts",
+    "test:real": "vitest run --config vitest.real.config.ts",
+    "test:lanes": "tsx tests/print-test-lane-manifest.ts",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts"
+  },
+  "dependencies": {
+    "@aria-cli/aria": "1.0.19",
+    "@aria-cli/auth": "1.0.19",
+    "@aria-cli/memoria": "1.0.19",
+    "@aria-cli/models": "1.0.19",
+    "@aria-cli/tools": "1.0.19",
+    "@aria-cli/types": "1.0.19",
+    "@aria-cli/wireguard": "1.0.19",
+    "@fastify/cors": "^11.0.1",
+    "@fastify/websocket": "^11.2.0",
+    "better-sqlite3": "^12.6.2",
+    "fastify": "^5.3.2",
+    "nanoid": "^5.1.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/ws": "^8.18.1",
+    "tsx": "^4.20.3",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18",
+    "ws": "^8.19.0"
+  },
+  "files": [
+    "dist/",
+    "!**/*.map",
+    "!**/*.tsbuildinfo"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}