@aria-cli/tools 1.0.19 → 1.0.33

package/dist-cjs/mcp/index.js

@@ -0,0 +1,31 @@
+"use strict";
+/**
+ * MCP (Model Context Protocol) Module
+ *
+ * Provides client implementation for connecting to MCP servers
+ * and discovering tools, resources, and prompts dynamically.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCPClient = exports.MCPServerConnection = exports.JSONRPCClient = void 0;
+__exportStar(require("./types.js"), exports);
+var jsonrpc_js_1 = require("./jsonrpc.js");
+Object.defineProperty(exports, "JSONRPCClient", { enumerable: true, get: function () { return jsonrpc_js_1.JSONRPCClient; } });
+var connection_js_1 = require("./connection.js");
+Object.defineProperty(exports, "MCPServerConnection", { enumerable: true, get: function () { return connection_js_1.MCPServerConnection; } });
+var client_js_1 = require("./client.js");
+Object.defineProperty(exports, "MCPClient", { enumerable: true, get: function () { return client_js_1.MCPClient; } });
+//# sourceMappingURL=index.js.map

package/dist-cjs/mcp/jsonrpc.js

@@ -0,0 +1,149 @@
+"use strict";
+/**
+ * JSON-RPC 2.0 Client for MCP
+ *
+ * Handles newline-delimited JSON over stdio streams.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONRPCClient = void 0;
+const events_1 = require("events");
+const crypto_1 = require("crypto");
+class JSONRPCClient extends events_1.EventEmitter {
+    stdin;
+    stdout;
+    pending = new Map();
+    buffer = "";
+    requestTimeout;
+    constructor(options = {}) {
+        super();
+        this.requestTimeout = options.timeout ?? 30000;
+    }
+    /**
+     * Connect to a process via stdio streams
+     */
+    connect(stdin, stdout) {
+        this.stdin = stdin;
+        this.stdout = stdout;
+        stdout.on("data", (chunk) => {
+            this.buffer += chunk.toString();
+            this.processBuffer();
+        });
+        stdout.on("error", (error) => {
+            this.emit("error", error);
+        });
+        stdout.on("end", () => {
+            this.emit("close");
+        });
+    }
+    processBuffer() {
+        let newlineIdx;
+        while ((newlineIdx = this.buffer.indexOf("\n")) !== -1) {
+            const line = this.buffer.slice(0, newlineIdx).trim();
+            this.buffer = this.buffer.slice(newlineIdx + 1);
+            if (line) {
+                try {
+                    this.handleMessage(JSON.parse(line));
+                }
+                catch (e) {
+                    this.emit("error", new Error(`Invalid JSON: ${line}`));
+                }
+            }
+        }
+    }
+    handleMessage(msg) {
+        // Ignore messages that aren't valid JSON-RPC 2.0
+        if (typeof msg !== "object" ||
+            msg === null ||
+            !("jsonrpc" in msg) ||
+            msg.jsonrpc !== "2.0")
+            return;
+        const rpcMsg = msg;
+        // Response to our request
+        if ("id" in rpcMsg && rpcMsg.id !== undefined) {
+            const response = rpcMsg;
+            const pending = this.pending.get(String(response.id));
+            if (pending) {
+                this.pending.delete(String(response.id));
+                clearTimeout(pending.timeout);
+                if (response.error) {
+                    pending.reject(new Error(`${response.error.code}: ${response.error.message}`));
+                }
+                else {
+                    pending.resolve(response.result);
+                }
+            }
+            return;
+        }
+        // Notification from server
+        if ("method" in rpcMsg) {
+            const notification = rpcMsg;
+            this.emit(notification.method, notification.params);
+            this.emit("notification", {
+                method: notification.method,
+                params: notification.params,
+            });
+        }
+    }
+    /**
+     * Send a request and wait for response
+     */
+    async request(method, params) {
+        if (!this.stdin) {
+            throw new Error("Not connected");
+        }
+        const id = (0, crypto_1.randomUUID)();
+        const message = {
+            jsonrpc: "2.0",
+            id,
+            method,
+            params,
+        };
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                if (this.pending.has(id)) {
+                    this.pending.delete(id);
+                    reject(new Error(`Request timeout: ${method}`));
+                }
+            }, this.requestTimeout);
+            this.pending.set(id, {
+                resolve: resolve,
+                reject,
+                timeout,
+            });
+            this.send(message);
+        });
+    }
+    /**
+     * Send a notification (no response expected)
+     */
+    notify(method, params) {
+        const message = {
+            jsonrpc: "2.0",
+            method,
+            params,
+        };
+        this.send(message);
+    }
+    send(message) {
+        if (!this.stdin) {
+            throw new Error("Not connected");
+        }
+        this.stdin.write(JSON.stringify(message) + "\n");
+    }
+    /**
+     * Close and cleanup
+     */
+    close() {
+        for (const [, pending] of this.pending) {
+            clearTimeout(pending.timeout);
+            pending.reject(new Error("Connection closed"));
+        }
+        this.pending.clear();
+        this.buffer = "";
+        this.stdin = undefined;
+        this.stdout?.removeAllListeners();
+        this.stdout = undefined;
+    }
+}
+exports.JSONRPCClient = JSONRPCClient;
+//# sourceMappingURL=jsonrpc.js.map

package/dist-cjs/mcp/types.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * MCP (Model Context Protocol) Types
+ *
+ * Protocol version: 2024-11-05
+ * https://modelcontextprotocol.io
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist-cjs/network-control-adapter.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toNetworkPeerView = toNetworkPeerView;
+exports.toNetworkStatusView = toNetworkStatusView;
+exports.toNetworkControlRef = toNetworkControlRef;
+const index_js_1 = require("./network-runtime/index.js");
+function toNetworkPeerView(peer) {
+    const parsedSigningPublicKey = index_js_1.SigningPublicKeySchema.safeParse(peer.signingPublicKey?.trim());
+    if (!parsedSigningPublicKey.success ||
+        typeof peer.nodeId !== "string" ||
+        peer.nodeId.length === 0) {
+        return null;
+    }
+    const signingPublicKey = parsedSigningPublicKey.data;
+    return {
+        nodeId: peer.nodeId,
+        transportPublicKey: peer.publicKey,
+        displayNameSnapshot: peer.name,
+        endpointHost: peer.endpointHost,
+        endpointPort: peer.endpointPort,
+        controlEndpoint: peer.controlEndpoint ?? null,
+        signingPublicKey,
+        status: peer.status,
+        membershipStatus: peer.membershipStatus ?? peer.status,
+        routeOwnership: peer.routeOwnership,
+        routeOwnerNodeId: peer.routeOwnerNodeId ?? null,
+        sessionState: peer.sessionState,
+        deliveryReadiness: peer.deliveryReadiness,
+        lastHandshake: peer.lastHandshake,
+        createdAt: peer.createdAt,
+        endpointRevision: peer.endpointRevision ?? 0,
+        updatedAt: peer.updatedAt ?? peer.createdAt,
+    };
+}
+function toNetworkStatusView(status) {
+    const parsedSigningPublicKey = index_js_1.SigningPublicKeySchema.safeParse(status.signingPublicKey?.trim());
+    const signingPublicKey = parsedSigningPublicKey.success
+        ? parsedSigningPublicKey.data
+        : null;
+    return {
+        configured: status.configured,
+        nodeId: status.nodeId,
+        principalFingerprint: status.principalFingerprint,
+        transportPublicKey: status.publicKey,
+        listenPort: status.listenPort,
+        externalEndpoint: status.externalEndpoint,
+        activePeers: status.activePeers,
+        totalPeers: status.totalPeers,
+        connectedPeers: status.connectedPeers,
+        handshakingPeers: status.handshakingPeers,
+        queueOnlyPeers: status.queueOnlyPeers,
+        supersededPeers: status.supersededPeers,
+        signingPublicKey,
+    };
+}
+function toNetworkControlRef(networkManager) {
+    if (!networkManager) {
+        return undefined;
+    }
+    return {
+        invite(displayName, options) {
+            return networkManager.invite(displayName, options);
+        },
+        revokePeer(nodeId) {
+            return networkManager.revokePeer(nodeId);
+        },
+        listPeers() {
+            return networkManager.listPeers().flatMap((peer) => {
+                const projected = toNetworkPeerView(peer);
+                return projected ? [projected] : [];
+            });
+        },
+        status() {
+            return toNetworkStatusView(networkManager.status());
+        },
+    };
+}
+//# sourceMappingURL=network-control-adapter.js.map

package/dist-cjs/network-runtime/address-types.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DurableSubmitResultSchema = exports.DurableDeliveryResultSchema = exports.DurableDeliveryHandleSchema = exports.LocalRuntimeSummarySchema = exports.NodeAdvertisementSchema = exports.ControlEndpointAdvertisementSchema = exports.InboxAddressSchema = exports.TransportEndpointAdvertisementSchema = exports.SigningPublicKeySchema = exports.LoopbackTlsIdentitySchema = exports.TlsCaFingerprintSchema = exports.PeerTransportIdSchema = exports.PrincipalFingerprintSchema = exports.ClientIdSchema = exports.RuntimeOwnerRecordSchema = exports.DeliveryLifecycleRevisionSchema = exports.OwnerGenerationSchema = exports.RevocationDecisionSchema = exports.RevocationOperatorConfirmationSchema = exports.RevocationGenerationSchema = exports.BindingGenerationSchema = exports.EndpointRevisionSchema = exports.PublicationRevisionSchema = exports.NodeMetadataSchema = exports.RuntimeIdSchema = exports.NodeIdSchema = void 0;
+const zod_1 = require("zod");
+const NonEmptyStringSchema = zod_1.z.string().trim().min(1);
+/**
+ * Stable durable identity for a node.
+ * Semantic rules are enforced by the runtime cutover plan; the contract layer
+ * starts by making the shape canonical everywhere.
+ */
+exports.NodeIdSchema = NonEmptyStringSchema.brand();
+/** One boot of a given node runtime. */
+exports.RuntimeIdSchema = NonEmptyStringSchema.brand();
+exports.NodeMetadataSchema = zod_1.z.object({
+    nodeId: exports.NodeIdSchema,
+    createdAt: NonEmptyStringSchema,
+    schemaVersion: zod_1.z.number().int().positive(),
+    migratedFromLegacy: zod_1.z.boolean(),
+});
+/** Monotonic publication revision for externally visible runtime advertisements. */
+exports.PublicationRevisionSchema = zod_1.z.number().int().nonnegative();
+/** Monotonic endpoint revision for register/discovery refreshes. */
+exports.EndpointRevisionSchema = zod_1.z.number().int().nonnegative();
+/** Monotonic generation for peer-binding continuity transitions. */
+exports.BindingGenerationSchema = zod_1.z.number().int().nonnegative();
+/** Monotonic generation for revocation precedence and continuity conflict checks. */
+exports.RevocationGenerationSchema = zod_1.z.number().int().nonnegative();
+/** How a local operator confirmed a revocation decision. */
+exports.RevocationOperatorConfirmationSchema = zod_1.z.enum([
+    "local_operator_confirmed",
+    "remote_capability_authenticated",
+]);
+/** Structured local authority record for a peer revocation decision. */
+exports.RevocationDecisionSchema = zod_1.z.object({
+    localNodeId: exports.NodeIdSchema,
+    targetNodeId: exports.NodeIdSchema,
+    revocationGeneration: exports.RevocationGenerationSchema,
+    operatorConfirmation: exports.RevocationOperatorConfirmationSchema,
+});
+/** Monotonic owner generation for runtime ownership records. */
+exports.OwnerGenerationSchema = zod_1.z.number().int().positive();
+/** Monotonic revision for durable delivery lifecycle state transitions. */
+exports.DeliveryLifecycleRevisionSchema = zod_1.z.number().int().nonnegative();
+exports.RuntimeOwnerRecordSchema = zod_1.z
+    .object({
+    schemaVersion: zod_1.z.number().int().positive(),
+    nodeId: exports.NodeIdSchema,
+    ariaHome: NonEmptyStringSchema,
+    runtimePid: zod_1.z.number().int().positive(),
+    runtimeId: exports.RuntimeIdSchema,
+    displayNameSnapshot: NonEmptyStringSchema.optional(),
+    runtimeSocket: NonEmptyStringSchema,
+    startedAt: NonEmptyStringSchema,
+    lastHeartbeat: NonEmptyStringSchema,
+    ownerGeneration: exports.OwnerGenerationSchema,
+})
+    .strict();
+/** One attached local client of the runtime. */
+exports.ClientIdSchema = NonEmptyStringSchema.brand();
+/** Durable principal fingerprint (SHA-256 hex of signing public key DER). Signing-key evidence only. */
+exports.PrincipalFingerprintSchema = NonEmptyStringSchema.brand();
+/** Transport public key / transport identity for a peer. */
+exports.PeerTransportIdSchema = NonEmptyStringSchema.brand();
+/** TLS CA certificate fingerprint (SHA-256 hex of CA cert DER). Certificate-authority evidence only — distinct from signing-key evidence. */
+exports.TlsCaFingerprintSchema = NonEmptyStringSchema.brand();
+/** Local-only loopback TLS SAN identity used for same-machine control attachment. */
+exports.LoopbackTlsIdentitySchema = NonEmptyStringSchema.brand();
+/** Base64-encoded signing public key material crossing runtime/shared boundaries. */
+exports.SigningPublicKeySchema = NonEmptyStringSchema.brand();
+/** Explicit network transport endpoint advertisement. */
+exports.TransportEndpointAdvertisementSchema = zod_1.z.object({
+    host: NonEmptyStringSchema,
+    port: zod_1.z.number().int().min(1).max(65535),
+});
+/**
+ * Runtime-owned local inbox addressing.
+ * Same-machine clients are local attachments, not mesh peers.
+ */
+exports.InboxAddressSchema = zod_1.z.discriminatedUnion("kind", [
+    zod_1.z.object({
+        kind: zod_1.z.literal("node"),
+        nodeId: exports.NodeIdSchema,
+    }),
+    zod_1.z.object({
+        kind: zod_1.z.literal("client"),
+        clientId: exports.ClientIdSchema,
+    }),
+]);
+/**
+ * Public control-plane endpoint advertisement used by peers for pinned,
+ * mutating requests.
+ */
+exports.ControlEndpointAdvertisementSchema = zod_1.z.object({
+    host: NonEmptyStringSchema,
+    port: zod_1.z.number().int().min(1).max(65535),
+    tlsCaFingerprint: exports.TlsCaFingerprintSchema,
+    tlsServerIdentity: exports.PrincipalFingerprintSchema,
+    protocolVersion: zod_1.z.number().int().positive(),
+    endpointRevision: exports.EndpointRevisionSchema.optional(),
+});
+/**
+ * Remote/public node advertisement. This deliberately excludes local-only
+ * runtime/session identity like RuntimeId.
+ */
+exports.NodeAdvertisementSchema = zod_1.z.object({
+    nodeId: exports.NodeIdSchema,
+    principalFingerprint: exports.PrincipalFingerprintSchema,
+    transportPublicKey: exports.PeerTransportIdSchema,
+    publicationRevision: exports.PublicationRevisionSchema.optional(),
+    controlEndpoint: exports.ControlEndpointAdvertisementSchema.optional(),
+    displayNameSnapshot: NonEmptyStringSchema.optional(),
+});
+/**
+ * Local-only runtime registry summary. This is not a remote/public mesh
+ * contract and may include RuntimeId.
+ */
+exports.LocalRuntimeSummarySchema = zod_1.z.object({
+    nodeId: exports.NodeIdSchema,
+    runtimeId: exports.RuntimeIdSchema,
+    lastHeartbeat: NonEmptyStringSchema.optional(),
+    controlEndpoint: exports.ControlEndpointAdvertisementSchema.optional(),
+    displayNameSnapshot: NonEmptyStringSchema.optional(),
+});
+// ── Durable Delivery Handle ────────────────────────────────────────
+/**
+ * Branded operation handle for durable delivery.
+ * Produced ONLY by `submitDurable()` — the caller never mints handles.
+ */
+exports.DurableDeliveryHandleSchema = NonEmptyStringSchema.brand();
+/**
+ * Terminal status types for a durable delivery operation.
+ */
+exports.DurableDeliveryResultSchema = zod_1.z.discriminatedUnion("status", [
+    zod_1.z.object({
+        status: zod_1.z.literal("pending"),
+        queuedAt: zod_1.z.string(),
+        nextAttemptAt: zod_1.z.string().optional(),
+        attemptCount: zod_1.z.number(),
+    }),
+    zod_1.z.object({
+        status: zod_1.z.literal("delivered"),
+        deliveredAt: zod_1.z.string(),
+    }),
+    zod_1.z.object({
+        status: zod_1.z.literal("expired"),
+        reason: zod_1.z.literal("ttl_exceeded"),
+        queuedAt: zod_1.z.string(),
+        expiredAt: zod_1.z.string(),
+    }),
+    zod_1.z.object({
+        status: zod_1.z.literal("rejected"),
+        reason: zod_1.z.enum(["recipient_revoked", "recipient_unknown", "envelope_invalid"]),
+    }),
+]);
+/**
+ * Submit result — returned immediately from `submitDurable()`.
+ */
+exports.DurableSubmitResultSchema = zod_1.z.discriminatedUnion("status", [
+    zod_1.z.object({
+        status: zod_1.z.literal("accepted"),
+        operationId: exports.DurableDeliveryHandleSchema,
+        queuedAt: zod_1.z.string(),
+    }),
+    zod_1.z.object({
+        status: zod_1.z.literal("rejected"),
+        reason: zod_1.z.enum(["recipient_revoked", "recipient_unknown", "envelope_invalid"]),
+    }),
+]);
+//# sourceMappingURL=address-types.js.map

package/dist-cjs/network-runtime/db-owner-fencing.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * Shared database-level ownership fencing for runtime-owned durable stores.
+ *
+ * All stores backed by the same SQLite database share one `owner_epoch` table.
+ * The runtime claims the epoch once at startup. Each store's write methods
+ * call `assertDbOwnership()` before durable mutations.
+ *
+ * A zombie runtime whose generation is stale gets StaleOwnerError on
+ * its next write — no external kill needed.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaleOwnerError = void 0;
+exports.ensureOwnerEpochTable = ensureOwnerEpochTable;
+exports.claimDbOwnerEpoch = claimDbOwnerEpoch;
+exports.assertDbOwnership = assertDbOwnership;
+class StaleOwnerError extends Error {
+    kind = "StaleOwnerError";
+    claimedGeneration;
+    currentGeneration;
+    constructor(claimed, current) {
+        super(`StaleOwnerError: runtime claims generation ${claimed} but store is at generation ${current}. ` +
+            `This runtime has been superseded and must shut down immediately.`);
+        this.name = "StaleOwnerError";
+        this.claimedGeneration = claimed;
+        this.currentGeneration = current;
+    }
+}
+exports.StaleOwnerError = StaleOwnerError;
+/**
+ * Ensure the owner_epoch table exists in the given database.
+ * Safe to call multiple times (idempotent).
+ */
+function ensureOwnerEpochTable(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS owner_epoch (
+      scope TEXT PRIMARY KEY DEFAULT 'runtime',
+      owner_generation INTEGER NOT NULL
+    )
+  `);
+}
+/**
+ * Atomically claim the owner epoch for this runtime.
+ * Throws StaleOwnerError if a newer generation already owns the database.
+ */
+function claimDbOwnerEpoch(db, generation) {
+    ensureOwnerEpochTable(db);
+    const result = db
+        .prepare(`INSERT INTO owner_epoch (scope, owner_generation) VALUES ('runtime', ?)
+       ON CONFLICT(scope) DO UPDATE SET owner_generation = excluded.owner_generation
+       WHERE excluded.owner_generation > owner_epoch.owner_generation`)
+        .run(generation);
+    if (result.changes === 0) {
+        const row = db
+            .prepare("SELECT owner_generation FROM owner_epoch WHERE scope = 'runtime'")
+            .get();
+        const current = row?.owner_generation ?? 0;
+        if (current > generation) {
+            throw new StaleOwnerError(generation, current);
+        }
+    }
+}
+/**
+ * Assert the calling runtime is still the current owner of this database.
+ * Must be called inside the same SQLite transaction as the write.
+ * Throws StaleOwnerError if superseded.
+ */
+function assertDbOwnership(db, generation) {
+    const row = db
+        .prepare("SELECT owner_generation FROM owner_epoch WHERE scope = 'runtime'")
+        .get();
+    const current = row?.owner_generation ?? 0;
+    if (current > generation) {
+        throw new StaleOwnerError(generation, current);
+    }
+}
+//# sourceMappingURL=db-owner-fencing.js.map