@joe-broadhead/messaging 0.7.1 → 0.8.0

package/dist/lib/modules/ipc/client.js

@@ -1,6 +1,6 @@
 import net from "node:net";
 import { dirname } from "node:path";
-import { ErrorCode, IPC_METHODS, IPC_PROTOCOL, IpcEvent, IpcHello, LIMITS, MESSAGING_ERROR_RPC_CODE, MessagingError, VERSION, parseWire, } from "../core/index.js";
+import { ErrorCode, CONVERSATION_METHODS, IPC_METHODS, IPC_PROTOCOL, IpcEvent, IpcHello, LIMITS, MESSAGING_ERROR_RPC_CODE, MessagingError, VERSION, parseWire, } from "../core/index.js";
 import { encodeLine, LineDecoder } from "./framing.js";
 import { configuredDaemonUid, IS_WINDOWS, messagingHome, socketPath as defaultSocketPath } from "./paths.js";
 import { readPointer } from "./pipes.js";
@@ -153,6 +153,13 @@ export class MessagingClient {
         return this.isClosed;
     }
     call(method, params, options = {}) {
+        return this.callWith(method, params, IPC_METHODS[method].result, options);
+    }
+    /** The staged conversation contract. Use only with a server that opted into it, until cut-over. */
+    callConversation(method, params, options = {}) {
+        return this.callWith(method, params, CONVERSATION_METHODS[method].result, options);
+    }
+    callWith(method, params, result, options) {
         if (this.isClosed)
             return Promise.reject(new MessagingError("daemon_unavailable", "connection to the Messaging daemon is closed"));
         if (options.signal?.aborted)
@@ -168,6 +175,7 @@ export class MessagingClient {
             options.signal?.addEventListener("abort", onAbort, { once: true });
             this.pending.set(id, {
                 method,
+                result,
                 resolve: resolve,
                 reject,
                 cleanup: () => {
@@ -236,7 +244,7 @@ export class MessagingClient {
             this.settle(message.id, undefined, toError(message.error));
             return;
         }
-        const checked = IPC_METHODS[pending.method].result.safeParse(message.result);
+        const checked = pending.result.safeParse(message.result);
         if (!checked.success) {
             this.settle(message.id, undefined, new MessagingError("internal", `daemon returned an invalid result for ${pending.method}`));
             return;

package/dist/lib/modules/ipc/server.js

@@ -2,7 +2,7 @@ import { mkdirSync } from "node:fs";
 import { chmod, chown, rm, stat } from "node:fs/promises";
 import net from "node:net";
 import { dirname } from "node:path";
-import { AGENT_METHODS, IPC_METHODS, IPC_PROTOCOL, IpcEvent, VERSION, LIMITS, MESSAGING_ERROR_RPC_CODE, MessagingError, parseWire, } from "../core/index.js";
+import { AGENT_METHODS, CONVERSATION_METHODS, CONVERSATION_TIERS, IPC_METHODS, IPC_PROTOCOL, IpcEvent, VERSION, LIMITS, MESSAGING_ERROR_RPC_CODE, MessagingError, parseWire, } from "../core/index.js";
 import { encodeLine, LineDecoder, LineTooLongError } from "./framing.js";
 import { IS_WINDOWS, MAX_SOCKET_PATH_BYTES } from "./paths.js";
 import { newPipeName, readPointer, writePointer } from "./pipes.js";
@@ -29,6 +29,13 @@ function agentTierRefusal(method) {
  * `group` is refused there: Node cannot give a pipe to a group.
  */
 export async function createIpcServer(options) {
+    return createServer(options, false);
+}
+/** Used only by the test entry: never changes the real daemon's method table. */
+export async function createConversationIpcServerForTesting(options) {
+    return createServer({ ...options, handlers: options.handlers }, true);
+}
+async function createServer(options, conversations) {
     const path = options.socketPath;
     if (options.tier !== "agent" && options.tier !== "admin")
         throw new MessagingError("invalid_request", "an IPC server needs a tier: agent or admin");
@@ -100,14 +107,16 @@ export async function createIpcServer(options) {
         const { id, method } = request;
         if (id === undefined)
             return; // client notifications are not part of the API
-        const spec = Object.hasOwn(IPC_METHODS, method) ? IPC_METHODS[method] : undefined;
+        const methods = conversations ? CONVERSATION_METHODS : IPC_METHODS;
+        const spec = Object.hasOwn(methods, method) ? methods[method] : undefined;
         const handler = options.handlers[method];
-        if (!spec || (!handler && method !== "events.subscribe")) {
+        if (!spec || (!handler && (conversations || method !== "events.subscribe"))) {
             ctx.send({ jsonrpc: "2.0", id, error: { code: RPC.methodNotFound, message: `method not found: ${method}` } });
             return;
         }
         // The tier is checked before the params are read, so the agent socket tells nothing about the rest.
-        if (options.tier === "agent" && !AGENT_TIER.has(method)) {
+        const agentAllowed = conversations ? CONVERSATION_TIERS[method] === "agent" : AGENT_TIER.has(method);
+        if (options.tier === "agent" && !agentAllowed) {
             ctx.send({ jsonrpc: "2.0", id, error: toRpcError(new MessagingError("forbidden", agentTierRefusal(method))) });
             return;
         }
@@ -130,7 +139,7 @@ export async function createIpcServer(options) {
         try {
             const result = handler ? await handler(parsed.data, ctx, authority) : { ok: true };
             // Subscriptions start only once the handler has accepted the keys.
-            if (method === "events.subscribe")
+            if (!conversations && method === "events.subscribe")
                 for (const key of parsed.data.keys)
                     ctx.subscriptions.add(key);
             const checked = spec.result.safeParse(result);

package/dist/lib/modules/ipc/testing.js

@@ -1,10 +1,10 @@
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { IPC_METHODS, MessagingError } from "../core/index.js";
+import { CONVERSATION_METHODS, IPC_METHODS, MessagingError } from "../core/index.js";
 import { MessagingClient } from "./client.js";
 import { IS_WINDOWS, MAX_SOCKET_PATH_BYTES, socketPath as socketOf } from "./paths.js";
-import { createIpcServer } from "./server.js";
+import { createConversationIpcServerForTesting, createIpcServer } from "./server.js";
 import { newPipeName, readPointer, writePointer } from "./pipes.js";
 import { securePrivate } from "./windows-acl.js";
 /**
@@ -55,36 +55,30 @@ export function rawEndpoint(socketPath) {
 export function ulid(n) {
     return `01JC${String(n).padStart(22, "0")}`;
 }
-/** Polls `predicate` every 10 ms until it holds; throws after `timeoutMs`. */
-export async function until(predicate, timeoutMs = 3_000, what = "condition") {
-    const deadline = Date.now() + timeoutMs;
+/** Polls state with no notification; the enclosing test's timeout is the single bound. Legacy timeout and label are ignored. */
+export async function until(predicate, _timeoutMs, _what = "condition") {
     while (!predicate()) {
-        if (Date.now() > deadline)
-            throw new Error(`timed out waiting for ${what}`);
-        await new Promise((resolve) => setTimeout(resolve, 10));
+        await new Promise((resolve) => setTimeout(resolve, 10).unref());
     }
 }
 export async function recordingDaemon(options = {}) {
+    const conversationMode = "methods" in options && options.methods !== undefined;
+    if (conversationMode && options.methods !== CONVERSATION_METHODS)
+        throw new TypeError("recordingDaemon: unsupported method table");
     const owned = options.at === undefined;
     const dir = options.at?.dir ?? tempSocketPath(options.prefix).dir;
     const socketPath = socketOf(dir, "agent");
     const adminSocketPath = socketOf(dir, "admin");
     const handlers = { ...options.handlers };
     const calls = [];
-    const convSubscribers = new Set();
     const dispatch = {};
-    for (const method of Object.keys(IPC_METHODS)) {
+    for (const method of Object.keys(conversationMode ? CONVERSATION_METHODS : IPC_METHODS)) {
         dispatch[method] = async (params, ctx) => {
             calls.push({ method, params: structuredClone(params) });
             const handler = handlers[method];
             if (!handler)
                 throw new MessagingError("forbidden", `fake daemon: no handler for ${method}`);
-            const result = await handler(params, ctx);
-            if (method === "conv.subscribe") {
-                convSubscribers.add(ctx);
-                ctx.signal.addEventListener("abort", () => convSubscribers.delete(ctx));
-            }
-            return result;
+            return handler(params, ctx);
         };
     }
     let servers;
@@ -92,8 +86,9 @@ export async function recordingDaemon(options = {}) {
         if (servers)
             return;
         const version = options.version === undefined ? {} : { version: options.version };
-        const agent = await createIpcServer({ socketPath, tier: "agent", handlers: dispatch, ...version });
-        const admin = await createIpcServer({ socketPath: adminSocketPath, tier: "admin", handlers: dispatch, ...version }).catch(async (error) => {
+        const serve = conversationMode ? createConversationIpcServerForTesting : createIpcServer;
+        const agent = await serve({ socketPath, tier: "agent", handlers: dispatch, ...version });
+        const admin = await serve({ socketPath: adminSocketPath, tier: "admin", handlers: dispatch, ...version }).catch(async (error) => {
             await agent.close();
             throw error;
         });
@@ -116,17 +111,12 @@ export async function recordingDaemon(options = {}) {
         callsTo,
         last: (method) => callsTo(method).at(-1),
         handle: (method, handler) => {
-            ;
             handlers[method] = handler;
         },
         publish: (event) => {
             for (const server of servers ?? [])
                 server.publish(event);
         },
-        conv: (event) => {
-            for (const ctx of convSubscribers)
-                ctx.notify(event);
-        },
         connect: (tier = "agent") => MessagingClient.connect({ socketPath: tier === "agent" ? socketPath : adminSocketPath, connectTimeoutMs: 500 }),
         connections: () => (servers ?? []).reduce((sum, server) => sum + server.connections(), 0),
         start,