opencode-collaboration 0.2.3

package/dist/session-runtime.js

@@ -0,0 +1,355 @@
+import { Delivery } from "./delivery.js";
+import { gateMessage } from "./gating.js";
+import { createSessionMessageQueue, hasSpoolRecords, migrateWorkspaceSpool, stableSessionEndpointId, } from "./queue.js";
+import { SessionTracker } from "./session-tracker.js";
+function responseData(response) {
+    return response?.data;
+}
+function normalizeStatus(status) {
+    const type = status?.type;
+    return type === "busy" || type === "retry" ? type : "idle";
+}
+export function SessionRuntime(opts) {
+    const endpoints = new Map();
+    const pendingOperations = new Set();
+    let lifecycle = "running";
+    let stopPromise = null;
+    let readyPromise = null;
+    let markReady = () => { };
+    function whileRunning(fallback, operation) {
+        if (lifecycle !== "running")
+            return Promise.resolve(fallback);
+        const pending = operation();
+        pendingOperations.add(pending);
+        void pending.finally(() => pendingOperations.delete(pending)).catch(() => { });
+        return pending;
+    }
+    function compatibilityEndpoint(candidates = [...endpoints.values()]) {
+        const roots = candidates.filter((candidate) => !candidate.session.parentID);
+        return (roots.length > 0 ? roots : candidates).slice().sort((a, b) => b.updatedAt - a.updatedAt ||
+            b.session.time.created - a.session.time.created ||
+            b.session.id.localeCompare(a.session.id))[0] ?? null;
+    }
+    async function upsert(session, status) {
+        const current = endpoints.get(session.id);
+        if (current) {
+            current.session = session;
+            current.updatedAt = Math.max(current.updatedAt, session.time.updated);
+            if (status)
+                setStatus(current, status);
+            return current;
+        }
+        const queue = createSessionMessageQueue({ config: opts.config, sessionId: session.id, logger: opts.logger });
+        await queue.loadHeld();
+        const tracker = SessionTracker();
+        tracker.noteIdle(session.id);
+        const endpoint = {
+            session,
+            endpointId: stableSessionEndpointId(session.id),
+            status: status ?? "idle",
+            updatedAt: session.time.updated,
+            queue,
+            tracker,
+            delivery: undefined,
+        };
+        if (endpoint.status !== "idle")
+            tracker.noteBusy(session.id);
+        endpoint.delivery = Delivery({
+            client: opts.client,
+            tracker,
+            queue,
+            directory: session.directory || opts.directory,
+            logger: opts.logger,
+            immediate: true,
+        });
+        endpoints.set(session.id, endpoint);
+        return endpoint;
+    }
+    function setStatus(endpoint, status) {
+        endpoint.status = status;
+        endpoint.updatedAt = Math.max(endpoint.updatedAt, Date.now());
+        if (status === "idle")
+            endpoint.tracker.noteIdle(endpoint.session.id);
+        else
+            endpoint.tracker.noteBusy(endpoint.session.id);
+    }
+    async function loadChildren(root, statuses = {}) {
+        const seen = new Set();
+        const pending = [root];
+        while (pending.length > 0) {
+            const parent = pending.shift();
+            if (seen.has(parent.id))
+                continue;
+            seen.add(parent.id);
+            try {
+                const response = await opts.client.session.children({
+                    path: { id: parent.id },
+                    query: { directory: parent.directory || opts.directory },
+                });
+                for (const child of responseData(response) ?? []) {
+                    const childStatus = Object.prototype.hasOwnProperty.call(statuses, child.id)
+                        ? normalizeStatus(statuses[child.id])
+                        : undefined;
+                    await upsert(child, childStatus);
+                    pending.push(child);
+                }
+            }
+            catch (err) {
+                await opts.logger("debug", "failed to list session children", {
+                    error: String(err),
+                    sessionId: parent.id,
+                });
+            }
+        }
+    }
+    async function findSession(sessionId) {
+        const known = endpoints.get(sessionId);
+        if (known)
+            return known;
+        try {
+            const response = await opts.client.session.get({
+                path: { id: sessionId },
+                query: { directory: opts.directory },
+            });
+            const session = responseData(response);
+            return session ? upsert(session) : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    return {
+        initialize() {
+            if (!readyPromise) {
+                readyPromise = new Promise((resolve) => {
+                    markReady = resolve;
+                });
+            }
+            return whileRunning(undefined, async () => {
+                const [listedResponse, statusResponse] = await Promise.all([
+                    opts.client.session.list({ query: { directory: opts.directory } }),
+                    opts.client.session.status({ query: { directory: opts.directory } }),
+                ]);
+                const sessions = responseData(listedResponse) ?? [];
+                const statuses = responseData(statusResponse) ?? {};
+                const migrationTarget = (sessions.filter((candidate) => !candidate.parentID).length > 0
+                    ? sessions.filter((candidate) => !candidate.parentID)
+                    : sessions).slice().sort((a, b) => b.time.updated - a.time.updated || b.time.created - a.time.created || b.id.localeCompare(a.id))[0];
+                if (migrationTarget) {
+                    await migrateWorkspaceSpool({
+                        config: opts.config,
+                        directory: opts.directory,
+                        targetSessionId: migrationTarget.id,
+                        logger: opts.logger,
+                    });
+                }
+                // Adopt only sessions that are alive IN THIS PROCESS:
+                //  - non-idle in the status snapshot (a real server keeps only
+                //    busy/retry entries there, children included), or
+                //  - holding undelivered peer state in their durable spool (restart
+                //    recovery; done/ records alone do not count).
+                // Historical sessions from session.list() stay unpublished until real
+                // activity arrives via events, chat.message, or commands.
+                const listed = new Map(sessions.map((candidate) => [candidate.id, candidate]));
+                for (const [sessionId, raw] of Object.entries(statuses)) {
+                    const status = normalizeStatus(raw);
+                    if (status === "idle")
+                        continue;
+                    let session = listed.get(sessionId);
+                    if (!session) {
+                        // busy child of an idle/historical root: not in the root list
+                        try {
+                            const response = await opts.client.session.get({
+                                path: { id: sessionId },
+                                query: { directory: opts.directory },
+                            });
+                            session = responseData(response);
+                        }
+                        catch {
+                            session = undefined;
+                        }
+                    }
+                    if (session)
+                        await upsert(session, status);
+                }
+                for (const session of sessions) {
+                    if (endpoints.has(session.id))
+                        continue;
+                    if (hasSpoolRecords(opts.config, session.id)) {
+                        const endpoint = await upsert(session, normalizeStatus(statuses[session.id]));
+                        // Restart recovery: deliver what the previous run could not.
+                        await endpoint.delivery.flush();
+                    }
+                }
+                // No startup child traversal: busy children are already covered by the
+                // flat status snapshot, and anything else becomes visible through
+                // session.created/updated events. Traversing children of adopted
+                // roots would re-adopt idle historical subagent sessions.
+            }).finally(() => markReady());
+        },
+        whenReady() {
+            // Ready means "the first discovery pass has settled". Never rejects;
+            // callers should bound their wait if a hang would be a problem.
+            if (!readyPromise) {
+                readyPromise = new Promise((resolve) => {
+                    markReady = resolve;
+                });
+            }
+            return readyPromise;
+        },
+        stop() {
+            if (stopPromise)
+                return stopPromise;
+            lifecycle = "stopping";
+            markReady(); // release whenReady waiters; no discovery will happen now
+            stopPromise = (async () => {
+                await Promise.allSettled([...pendingOperations]);
+                lifecycle = "stopped";
+            })();
+            return stopPromise;
+        },
+        registryEndpoints() {
+            return [...endpoints.values()].map((endpoint) => ({
+                endpointId: endpoint.endpointId,
+                sessionId: endpoint.session.id,
+                ...(endpoint.session.parentID ? { parentSessionId: endpoint.session.parentID } : {}),
+                title: endpoint.session.title,
+                name: opts.name(),
+                directory: endpoint.session.directory || opts.directory,
+                status: endpoint.status,
+                startedAt: endpoint.session.time.created,
+                updatedAt: endpoint.updatedAt,
+                queuedCount: endpoint.queue.size(),
+            }));
+        },
+        // Endpoints actually written to the shared registry. Only the process's
+        // representative session (most recently active) plus any busy/queued
+        // sessions are announced. Idle historical sessions that opencode replays
+        // at startup stay internal: they remain reachable by an exact endpoint ID
+        // a peer already knows, but they are not flooded into the registry under
+        // the process name (which made name-based routing ambiguous and could
+        // deliver a message into a background session the user cannot see).
+        publishableEndpoints() {
+            const all = [...endpoints.values()];
+            const representative = compatibilityEndpoint(all);
+            return all
+                .filter((endpoint) => endpoint === representative ||
+                endpoint.status !== "idle" ||
+                endpoint.queue.size() > 0)
+                .map((endpoint) => ({
+                endpointId: endpoint.endpointId,
+                sessionId: endpoint.session.id,
+                ...(endpoint.session.parentID ? { parentSessionId: endpoint.session.parentID } : {}),
+                title: endpoint.session.title,
+                name: opts.name(),
+                directory: endpoint.session.directory || opts.directory,
+                status: endpoint.status,
+                startedAt: endpoint.session.time.created,
+                updatedAt: endpoint.updatedAt,
+                queuedCount: endpoint.queue.size(),
+            }));
+        },
+        compatibilityEndpointId() {
+            return compatibilityEndpoint()?.endpointId ?? null;
+        },
+        hasEndpoint(endpointId) {
+            return [...endpoints.values()].some((endpoint) => endpoint.endpointId === endpointId);
+        },
+        endpointIdForSession(sessionId) {
+            return endpoints.get(sessionId)?.endpointId ?? null;
+        },
+        receive(message, endpointId, policy) {
+            return whileRunning("dropped", async () => {
+                const endpoint = [...endpoints.values()].find((candidate) => candidate.endpointId === endpointId);
+                if (!endpoint)
+                    return "dropped";
+                const existing = endpoint.queue.existingStatus(message);
+                if (existing)
+                    return existing;
+                if (endpoint.queue.isDebounced(message))
+                    return "duplicate";
+                const decision = gateMessage(policy, message, endpoint.session.directory || opts.directory);
+                if (decision === "refuse")
+                    return (await endpoint.queue.refuse(message)).status;
+                if (decision === "hold") {
+                    if (!(await endpoint.queue.hold(message)))
+                        return "full";
+                    void endpoint.delivery.notice(`📥 Held message from "${message.from.name}" — /peers-inbox to review`);
+                    return "held";
+                }
+                if (!endpoint.queue.enqueue(message))
+                    return endpoint.queue.existingStatus(message) ?? "full";
+                await endpoint.delivery.flush();
+                return endpoint.queue.existingStatus(message) ?? "queued";
+            });
+        },
+        handleEvent(event) {
+            return whileRunning(false, async () => {
+                const properties = event.properties ?? {};
+                const info = properties.info;
+                if (event.type === "session.created" || event.type === "session.updated") {
+                    if (!info?.id)
+                        return false;
+                    await upsert(info);
+                    if (event.type === "session.created")
+                        await loadChildren(info);
+                    return true;
+                }
+                if (event.type === "session.deleted") {
+                    if (!info?.id)
+                        return false;
+                    const deleted = new Set([info.id]);
+                    let changed = true;
+                    while (changed) {
+                        changed = false;
+                        for (const endpoint of endpoints.values()) {
+                            if (endpoint.session.parentID && deleted.has(endpoint.session.parentID) && !deleted.has(endpoint.session.id)) {
+                                deleted.add(endpoint.session.id);
+                                changed = true;
+                            }
+                        }
+                    }
+                    for (const sessionId of deleted)
+                        endpoints.delete(sessionId);
+                    return true;
+                }
+                if (event.type === "session.status" || event.type === "session.idle") {
+                    const sessionId = properties.sessionID;
+                    if (!sessionId)
+                        return false;
+                    const endpoint = await findSession(sessionId);
+                    if (!endpoint)
+                        return false;
+                    setStatus(endpoint, event.type === "session.idle" ? "idle" : normalizeStatus(properties.status));
+                    return true;
+                }
+                return false;
+            });
+        },
+        noteActivity(sessionId) {
+            return whileRunning(undefined, async () => {
+                const endpoint = await findSession(sessionId);
+                if (endpoint)
+                    setStatus(endpoint, "busy");
+            });
+        },
+        queueForSession(sessionId) {
+            return endpoints.get(sessionId)?.queue ?? null;
+        },
+        deliveryForSession(sessionId) {
+            return endpoints.get(sessionId)?.delivery ?? null;
+        },
+        sweep() {
+            return whileRunning(undefined, async () => {
+                for (const endpoint of endpoints.values()) {
+                    await endpoint.queue.expireHeld();
+                    await endpoint.delivery.flush();
+                }
+            });
+        },
+        pendingAcknowledgements() {
+            return [...endpoints.values()].flatMap((endpoint) => endpoint.queue.pendingAcknowledgements()
+                .map((acknowledgement) => ({ queue: endpoint.queue, acknowledgement })));
+        },
+    };
+}

package/dist/session-tracker.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Tracks the "active" session of this opencode server instance and whether
+ * it is idle. opencode plugins are per-server, not per-session, so the
+ * active session is a heuristic: the session that most recently produced
+ * user activity.
+ */
+export interface SessionTrackerInstance {
+    activeSessionId: () => string | null;
+    activeSessionTitle: () => string | null;
+    isIdle: () => boolean;
+    noteUserActivity: (sessionId: string, title?: string | null) => void;
+    noteIdle: (sessionId?: string) => void;
+    noteBusy: (sessionId?: string) => void;
+    noteDeleted: (sessionId: string) => void;
+}
+export declare function SessionTracker(): SessionTrackerInstance;

package/dist/session-tracker.js

@@ -0,0 +1,39 @@
+/**
+ * Tracks the "active" session of this opencode server instance and whether
+ * it is idle. opencode plugins are per-server, not per-session, so the
+ * active session is a heuristic: the session that most recently produced
+ * user activity.
+ */
+export function SessionTracker() {
+    let activeId = null;
+    let activeTitle = null;
+    let idle = true;
+    return {
+        activeSessionId: () => activeId,
+        activeSessionTitle: () => activeTitle,
+        isIdle: () => idle,
+        noteUserActivity(sessionId, title) {
+            activeId = sessionId;
+            if (title)
+                activeTitle = title;
+            idle = false;
+        },
+        noteIdle(sessionId) {
+            if (!sessionId || sessionId === activeId)
+                idle = true;
+            if (!activeId && sessionId)
+                activeId = sessionId;
+        },
+        noteBusy(sessionId) {
+            if (!sessionId || sessionId === activeId)
+                idle = false;
+        },
+        noteDeleted(sessionId) {
+            if (activeId === sessionId) {
+                activeId = null;
+                activeTitle = null;
+                idle = true;
+            }
+        },
+    };
+}

package/dist/tools/peers-tools.d.ts

@@ -0,0 +1,26 @@
+/**
+ * LLM-callable tools:
+ *   - list_agents:  discover same-machine opencode peers
+ *   - send_message: send a plain-text message to a peer
+ */
+import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+import type { ListedPeer, RegistryInstance } from "../registry.js";
+import type { Sender } from "../sender.js";
+import type { RateLimiter } from "../queue.js";
+import type { OutboxInstance } from "../outbox.js";
+export interface ToolsDeps {
+    registry: RegistryInstance;
+    sender: ReturnType<typeof Sender>;
+    sendLimit: ReturnType<typeof RateLimiter>;
+    maxMessageBytes: number;
+    selfName: () => string;
+    selfInstanceId: string;
+    endpointForSession?: (sessionId: string) => {
+        endpointId: string;
+        name: string;
+        directory: string;
+    } | null;
+    outbox?: Pick<OutboxInstance, "get" | "list">;
+}
+export declare function formatPeerList(peers: ListedPeer[], selfName: string, selfId: string): string;
+export declare function buildPeerTools(deps: ToolsDeps): Record<string, ToolDefinition>;

package/dist/tools/peers-tools.js

@@ -0,0 +1,173 @@
+/**
+ * LLM-callable tools:
+ *   - list_agents:  discover same-machine opencode peers
+ *   - send_message: send a plain-text message to a peer
+ */
+import { tool } from "@opencode-ai/plugin/tool";
+import { z } from "zod";
+import { collapseToProcesses, sortPeers } from "../format.js";
+function entryId(entry) {
+    return entry.version === 2 ? entry.endpointId : entry.instanceId;
+}
+function isEndpointShaped(target) {
+    return /^(?:session|workspace)-[A-Za-z0-9][A-Za-z0-9_-]*$/.test(target);
+}
+export function formatPeerList(peers, selfName, selfId) {
+    const online = sortPeers(collapseToProcesses(peers.filter((p) => p.alive)));
+    const offline = sortPeers(collapseToProcesses(peers.filter((p) => !p.alive)));
+    const lines = [];
+    if (online.length === 0) {
+        lines.push("No peers online.");
+    }
+    else {
+        lines.push(`${online.length} peer(s) online:`);
+        for (const p of online) {
+            const e = p.entry;
+            const id = entryId(e);
+            const session = e.activeSessionId
+                ? `session ${e.activeSessionTitle ? `"${e.activeSessionTitle}" ` : ""}(${e.activeSessionId})`
+                : "(no active session)";
+            lines.push(`- "${e.name}" (id ${id}) — ${e.directory} — ${session} — inbound: ${e.inboundPolicy}`);
+        }
+    }
+    if (offline.length > 0) {
+        lines.push(`${offline.length} peer(s) stale/offline (hidden from targeting):`);
+        for (const p of offline) {
+            lines.push(`- "${p.entry.name}" (id ${entryId(p.entry)}) — ${p.staleReason}`);
+        }
+    }
+    lines.push(`You are "${selfName}" (id ${selfId}).`);
+    return lines.join("\n");
+}
+export function buildPeerTools(deps) {
+    return {
+        peer_message_status: tool({
+            description: "Query the durable receipt and final ACK status of a peer message sent by this session.",
+            args: {
+                message_id: z.string().describe("Message ID returned by send_message"),
+            },
+            async execute(args, context) {
+                const self = deps.endpointForSession?.(context.sessionID);
+                if (!self)
+                    return `Error: sender session "${context.sessionID}" is not registered.`;
+                const record = deps.outbox?.get(self.endpointId, args.message_id);
+                if (!record)
+                    return `Peer message "${args.message_id}" was not found in this session's outbox.`;
+                const receipt = record.receiptStatus ? `receipt: ${record.receiptStatus}` : "no transport receipt";
+                const final = record.finalStatus ? `final: ${record.finalStatus}` : "awaiting final ACK";
+                return `Message ${record.messageId} to "${record.toName}" — ${receipt}; ${final}${record.error ? `; error: ${record.error}` : ""}.`;
+            },
+        }),
+        list_agents: tool({
+            description: "List other opencode session endpoints on this machine that you can exchange plain-text messages with. Shows each endpoint's name, id, directory, session and inbound policy.",
+            args: {
+                include_offline: z
+                    .boolean()
+                    .optional()
+                    .describe("Also list stale/offline registry entries (default false)"),
+            },
+            async execute(args, context) {
+                let peers;
+                try {
+                    peers = await deps.registry.list();
+                }
+                catch (err) {
+                    return `Failed to read peer registry: ${String(err)}`;
+                }
+                const self = deps.endpointForSession?.(context.sessionID);
+                const selfId = self?.endpointId ?? deps.selfInstanceId;
+                const shown = (args.include_offline ? peers : peers.filter((p) => p.alive))
+                    .filter((peer) => entryId(peer.entry) !== selfId);
+                return formatPeerList(shown, self?.name ?? deps.selfName(), selfId);
+            },
+        }),
+        send_message: tool({
+            description: "Send a plain-text message immediately to an exact opencode session on this machine, including while it is busy. Text only — no files or conversation history. Resolve the target with list_agents first if unsure.",
+            args: {
+                to: z.string().describe("Peer name or instanceId (see list_agents)"),
+                message: z.string().describe("Plain-text message body"),
+            },
+            async execute(args, context) {
+                const text = args.message;
+                if (!text.trim())
+                    return "Error: message must not be empty.";
+                if (Buffer.byteLength(text, "utf8") > deps.maxMessageBytes) {
+                    return `Error: message exceeds ${deps.maxMessageBytes} bytes.`;
+                }
+                const self = deps.endpointForSession?.(context.sessionID);
+                if (deps.endpointForSession && !self) {
+                    return `Error: sender session "${context.sessionID}" is not registered.`;
+                }
+                const selfId = self?.endpointId ?? deps.selfInstanceId;
+                const listed = await deps.registry.list();
+                const target = args.to.trim();
+                const knownExact = listed.find((peer) => entryId(peer.entry) === target);
+                if (knownExact) {
+                    if (entryId(knownExact.entry) === selfId) {
+                        return `Error: cannot send a peer message to your own endpoint "${target}" in the same session.`;
+                    }
+                    if (!knownExact.alive) {
+                        return `Error: endpoint "${target}" appears offline (${knownExact.staleReason}).`;
+                    }
+                }
+                else if (isEndpointShaped(target)) {
+                    return `Error: unknown endpoint ID "${target}".`;
+                }
+                const peers = listed.filter((p) => p.alive && entryId(p.entry) !== selfId);
+                let matches = knownExact ? [knownExact] : peers.filter((p) => p.entry.name === target);
+                if (matches.length === 0) {
+                    const stale = listed.find((p) => !p.alive && p.entry.name === target);
+                    if (stale) {
+                        return `Error: peer "${target}" appears offline (${stale.staleReason}).`;
+                    }
+                    const names = peers.map((p) => `"${p.entry.name}"`).join(", ") || "(none)";
+                    return `Error: no peer named "${target}". Online peers: ${names}`;
+                }
+                if (matches.length > 1) {
+                    // A single process publishes one endpoint per session (its current
+                    // session plus any busy/queued ones), all sharing the process name.
+                    // Collapse same-name endpoints to one representative per process
+                    // (the most recently active session) so addressing by name lands on
+                    // the session the user is actually working in. Only a genuine
+                    // cross-process name clash is ambiguous.
+                    const perProcess = collapseToProcesses(matches);
+                    if (perProcess.length > 1) {
+                        const candidates = perProcess
+                            .map((p) => `"${p.entry.name}" (id ${entryId(p.entry)})`)
+                            .join(", ");
+                        return `Error: "${target}" is ambiguous across processes: ${candidates}. Use an endpoint ID.`;
+                    }
+                    matches = perProcess;
+                }
+                const peer = matches[0].entry;
+                if (!deps.sendLimit(entryId(peer))) {
+                    return `Error: outbound rate limit reached for "${peer.name}"; try again in a minute.`;
+                }
+                const result = await deps.sender.send(peer, text, self ? {
+                    instanceId: self.endpointId,
+                    name: self.name,
+                    directory: self.directory,
+                } : undefined);
+                if (!result.ok)
+                    return `Error: ${result.error}`;
+                const tracking = result.messageId ? ` Tracking ID: ${result.messageId}.` : "";
+                switch (result.status) {
+                    case "delivered":
+                        return `Message delivered to "${peer.name}".${tracking}`;
+                    case "duplicate":
+                        return `Message was already received by "${peer.name}".`;
+                    case "queued":
+                        return `Message queued for "${peer.name}" (their session is busy); awaiting final delivery ACK.${tracking}`;
+                    case "held":
+                        return `"${peer.name}" reviews inbound messages manually; your message awaits their approval.${tracking}`;
+                    case "refused":
+                        return `Error: "${peer.name}" refuses inbound messages.`;
+                    case "full":
+                        return `Error: "${peer.name}" queue is full; try again later.`;
+                    default:
+                        return `Error: unexpected status from "${peer.name}".`;
+                }
+            },
+        }),
+    };
+}

package/dist/transport.d.ts

@@ -0,0 +1,20 @@
+import type { InboundMessage, LocalTransportAddress, PeerAcknowledgementV2, PeerMessageV2, ReceiveStatus } from "./types.js";
+export interface TransportTarget {
+    transport: LocalTransportAddress;
+    inboxToken: string;
+}
+export interface TransportResponse {
+    http: number;
+    status?: ReceiveStatus;
+}
+export interface Transport {
+    discover: () => Promise<TransportTarget[]>;
+    send: (target: TransportTarget, message: InboundMessage | PeerMessageV2) => Promise<TransportResponse>;
+    ack: (target: TransportTarget, acknowledgement: PeerAcknowledgementV2) => Promise<void>;
+    close: () => Promise<void>;
+}
+export interface LocalTransportOptions {
+    discover?: () => Promise<TransportTarget[]>;
+    timeoutMs?: number;
+}
+export declare function LocalTransport(opts?: LocalTransportOptions): Transport;

package/dist/transport.js

@@ -0,0 +1,46 @@
+import { request } from "node:http";
+export function LocalTransport(opts = {}) {
+    const timeoutMs = opts.timeoutMs ?? 3_000;
+    function post(target, path, body) {
+        return new Promise((resolve, reject) => {
+            const address = target.transport;
+            const req = request({
+                ...(address.type === "unix"
+                    ? { socketPath: address.path, path }
+                    : { hostname: address.host, port: address.port, path }),
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    authorization: `Bearer ${target.inboxToken}`,
+                },
+                timeout: timeoutMs,
+            }, (res) => {
+                const chunks = [];
+                res.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+                res.on("end", () => {
+                    let status;
+                    try {
+                        status = JSON.parse(Buffer.concat(chunks).toString("utf8")).status;
+                    }
+                    catch {
+                        // The HTTP status still carries the transport outcome.
+                    }
+                    resolve({ http: res.statusCode ?? 500, ...(status ? { status } : {}) });
+                });
+            });
+            req.on("timeout", () => req.destroy(new Error("local transport timed out")));
+            req.on("error", reject);
+            req.end(JSON.stringify(body));
+        });
+    }
+    return {
+        discover: opts.discover ?? (async () => []),
+        send: (target, message) => post(target, "/message", message),
+        async ack(target, acknowledgement) {
+            const response = await post(target, "/ack", acknowledgement);
+            if (response.http !== 202)
+                throw new Error(`acknowledgement failed with HTTP ${response.http}`);
+        },
+        async close() { },
+    };
+}