opencode-collaboration 0.2.3

package/dist/listener.js

@@ -0,0 +1,335 @@
+/**
+ * Per-instance inbox HTTP listener (127.0.0.1 only, bearer-token auth).
+ * Peers POST messages here instead of touching the opencode server directly,
+ * so inbound gating (accept/hold/refuse) and queueing stay under our control.
+ */
+import { chmod, lstat, mkdir, rm } from "node:fs/promises";
+import { createServer } from "node:http";
+import { connect } from "node:net";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+const MAX_HOPS = 4;
+const peerFromSchema = z
+    .object({
+    instanceId: z.string().min(1),
+    name: z.string().min(1),
+    directory: z.string().min(1),
+})
+    .passthrough();
+const inboundMessageV1Schema = z
+    .object({
+    id: z.string().min(1),
+    from: peerFromSchema,
+    text: z.string(),
+    via: z.array(z.string()).max(MAX_HOPS),
+    sentAt: z.number().finite(),
+})
+    .passthrough();
+const inboundMessageV2Schema = z
+    .object({
+    version: z.literal(2),
+    messageId: z.string().min(1),
+    fromEndpointId: z.string().min(1),
+    toEndpointId: z.string().min(1),
+    from: peerFromSchema,
+    text: z.string(),
+    via: z.array(z.string()).max(MAX_HOPS),
+    sentAt: z.number().finite(),
+})
+    .passthrough();
+const acknowledgementV2Schema = z.object({
+    version: z.literal(2),
+    messageId: z.string().min(1),
+    fromEndpointId: z.string().min(1),
+    toEndpointId: z.string().min(1),
+    status: z.enum(["delivered", "refused", "expired", "dropped", "duplicate"]),
+    acknowledgedAt: z.number().finite(),
+}).passthrough();
+function statusToHttp(status) {
+    switch (status) {
+        case "refused":
+            return 403;
+        case "full":
+            return 429;
+        default:
+            return 202;
+    }
+}
+function parseMessage(body) {
+    if (typeof body === "object" && body !== null && "version" in body && body.version === 2) {
+        const parsed = inboundMessageV2Schema.safeParse(body);
+        if (!parsed.success)
+            return null;
+        const message = parsed.data;
+        return {
+            message: {
+                id: message.messageId,
+                from: {
+                    instanceId: message.fromEndpointId,
+                    name: message.from.name,
+                    directory: message.from.directory,
+                },
+                text: message.text,
+                via: message.via,
+                sentAt: message.sentAt,
+            },
+            route: { version: 2, toEndpointId: message.toEndpointId },
+        };
+    }
+    const parsed = inboundMessageV1Schema.safeParse(body);
+    return parsed.success ? { message: parsed.data, route: { version: 1 } } : null;
+}
+export function defaultRuntimeDirectory(env = process.env, uid = typeof process.getuid === "function" ? process.getuid() : 0) {
+    return env.XDG_RUNTIME_DIR
+        ? join(env.XDG_RUNTIME_DIR, "opencode-collaboration")
+        : join(tmpdir(), `ocp-${uid}`);
+}
+export function InboxListener(opts) {
+    let primaryServer = null;
+    let compatibilityServer = null;
+    let ownedSocketPath = null;
+    let lifecycle = "new";
+    function authorized(authHeader) {
+        return authHeader === `Bearer ${opts.token}`;
+    }
+    async function handle(req, res) {
+        const send = (code, body) => {
+            res.writeHead(code, { "content-type": "application/json" });
+            res.end(JSON.stringify(body));
+        };
+        if (!authorized(req.headers.authorization)) {
+            send(401, { error: "unauthorized" });
+            return;
+        }
+        if (req.method === "GET" && req.url === "/health") {
+            send(200, { ok: true });
+            return;
+        }
+        if (req.method !== "POST" || (req.url !== "/message" && req.url !== "/ack")) {
+            send(404, { error: "not found" });
+            return;
+        }
+        const chunks = [];
+        let size = 0;
+        for await (const chunk of req) {
+            size += chunk.length;
+            if (size > opts.maxBodyBytes) {
+                send(413, { error: "message too large" });
+                req.destroy();
+                return;
+            }
+            chunks.push(chunk);
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+        }
+        catch {
+            send(400, { error: "invalid json" });
+            return;
+        }
+        if (req.url === "/ack") {
+            const ack = acknowledgementV2Schema.safeParse(parsed);
+            if (!ack.success) {
+                send(400, { error: "invalid acknowledgement shape" });
+                return;
+            }
+            await opts.onAcknowledgement?.(ack.data);
+            send(202, { status: "accepted" });
+            return;
+        }
+        const envelope = parseMessage(parsed);
+        if (!envelope) {
+            send(400, { error: "invalid message shape" });
+            return;
+        }
+        const msg = envelope.message;
+        if (Buffer.byteLength(msg.text, "utf8") > (opts.maxMessageBytes ?? 8192)) {
+            send(413, { error: "message too large" });
+            return;
+        }
+        if (Math.abs(Date.now() - msg.sentAt) > (opts.maxMessageAgeMs ?? 300_000)) {
+            send(400, { error: "stale message" });
+            return;
+        }
+        try {
+            const endpointId = await opts.resolveEndpoint?.(envelope.route);
+            if (opts.resolveEndpoint && !endpointId) {
+                send(404, { error: "endpoint not found" });
+                return;
+            }
+            const status = await opts.onMessage(msg, endpointId ?? envelope.route.toEndpointId);
+            send(statusToHttp(status), { status });
+        }
+        catch (err) {
+            await opts.logger("error", "onMessage handler failed", { error: String(err) });
+            send(500, { error: "internal error" });
+        }
+    }
+    function listenerServer() {
+        return createServer((req, res) => {
+            handle(req, res).catch((err) => {
+                void opts.logger("error", "listener error", { error: String(err) });
+                if (!res.headersSent)
+                    res.writeHead(500).end();
+                else
+                    res.end();
+            });
+        });
+    }
+    function listenUnix(server, socketPath) {
+        return new Promise((resolve, reject) => {
+            const onError = (err) => {
+                server.off("listening", onListening);
+                reject(err);
+            };
+            const onListening = () => {
+                server.off("error", onError);
+                resolve();
+            };
+            server.once("error", onError);
+            server.once("listening", onListening);
+            server.listen(socketPath);
+        });
+    }
+    function listenTcp(server) {
+        return new Promise((resolve, reject) => {
+            const onError = (err) => {
+                server.off("listening", onListening);
+                reject(err);
+            };
+            const onListening = () => {
+                server.off("error", onError);
+                resolve(server.address().port);
+            };
+            server.once("error", onError);
+            server.once("listening", onListening);
+            server.listen(0, "127.0.0.1");
+        });
+    }
+    function closeServer(server) {
+        return new Promise((resolve, reject) => {
+            if (!server?.listening) {
+                resolve();
+                return;
+            }
+            server.close((err) => err ? reject(err) : resolve());
+        });
+    }
+    function liveUnixSocket(socketPath) {
+        return new Promise((resolve, reject) => {
+            const socket = connect({ path: socketPath });
+            let settled = false;
+            const finish = (result, err) => {
+                if (settled)
+                    return;
+                settled = true;
+                socket.destroy();
+                if (err)
+                    reject(err);
+                else
+                    resolve(result);
+            };
+            socket.once("connect", () => finish(true));
+            socket.once("error", (err) => {
+                if (err.code === "ECONNREFUSED" || err.code === "ENOENT")
+                    finish(false);
+                else
+                    finish(false, err);
+            });
+            socket.setTimeout(500, () => finish(true));
+        });
+    }
+    async function prepareUnixSocket(socketPath) {
+        try {
+            const info = await lstat(socketPath);
+            if (!info.isSocket())
+                throw new Error(`runtime socket path collision: ${socketPath}`);
+            if (await liveUnixSocket(socketPath))
+                throw new Error(`runtime socket already in use: ${socketPath}`);
+            await rm(socketPath);
+        }
+        catch (err) {
+            if (err.code !== "ENOENT")
+                throw err;
+        }
+    }
+    return {
+        async start() {
+            if (lifecycle !== "new")
+                throw new Error(`listener cannot start while ${lifecycle}`);
+            lifecycle = "starting";
+            const platform = opts.platform ?? (opts.processId ? process.platform : "win32");
+            if (platform === "win32") {
+                primaryServer = listenerServer();
+                try {
+                    const port = await listenTcp(primaryServer);
+                    lifecycle = "running";
+                    const url = `http://127.0.0.1:${port}`;
+                    return {
+                        port,
+                        url,
+                        compatibilityUrl: url,
+                        address: { type: "tcp", host: "127.0.0.1", port },
+                    };
+                }
+                catch (err) {
+                    await closeServer(primaryServer).catch(() => { });
+                    primaryServer = null;
+                    lifecycle = "stopped";
+                    throw err;
+                }
+            }
+            const directory = opts.runtimeDir ?? defaultRuntimeDirectory();
+            const socketPath = join(directory, `${opts.processId ?? process.pid}.sock`);
+            let boundUnixSocket = false;
+            try {
+                await mkdir(directory, { recursive: true, mode: 0o700 });
+                await chmod(directory, 0o700);
+                await prepareUnixSocket(socketPath);
+                primaryServer = listenerServer();
+                await listenUnix(primaryServer, socketPath);
+                boundUnixSocket = true;
+                ownedSocketPath = socketPath;
+                await chmod(socketPath, 0o600);
+                compatibilityServer = listenerServer();
+                const compatibilityPort = await listenTcp(compatibilityServer);
+                lifecycle = "running";
+                return {
+                    port: compatibilityPort,
+                    url: `http+unix://${encodeURIComponent(socketPath)}`,
+                    compatibilityUrl: `http://127.0.0.1:${compatibilityPort}`,
+                    address: { type: "unix", path: socketPath },
+                };
+            }
+            catch (err) {
+                await Promise.all([
+                    closeServer(compatibilityServer).catch(() => { }),
+                    closeServer(primaryServer).catch(() => { }),
+                ]);
+                compatibilityServer = null;
+                primaryServer = null;
+                if (boundUnixSocket)
+                    await rm(socketPath, { force: true }).catch(() => { });
+                ownedSocketPath = null;
+                lifecycle = "stopped";
+                throw err;
+            }
+        },
+        async stop() {
+            if (lifecycle === "stopped")
+                return;
+            lifecycle = "stopping";
+            const unixPath = ownedSocketPath;
+            const servers = [compatibilityServer, primaryServer];
+            compatibilityServer = null;
+            primaryServer = null;
+            ownedSocketPath = null;
+            await Promise.all(servers.map((server) => closeServer(server)));
+            if (unixPath)
+                await rm(unixPath, { force: true });
+            lifecycle = "stopped";
+        },
+    };
+}

package/dist/outbox.d.ts

@@ -0,0 +1,12 @@
+import type { OutboxRecord, PeerAcknowledgementV2, PeerMessageV2, ReceiveStatus } from "./types.js";
+export interface OutboxInstance {
+    recordPending: (message: PeerMessageV2, toName: string) => Promise<OutboxRecord>;
+    recordReceipt: (messageId: string, fromEndpointId: string, status: ReceiveStatus) => Promise<OutboxRecord | null>;
+    recordFailure: (messageId: string, fromEndpointId: string, error: string) => Promise<OutboxRecord | null>;
+    applyAcknowledgement: (ack: PeerAcknowledgementV2) => Promise<boolean>;
+    get: (fromEndpointId: string, messageId: string) => OutboxRecord | null;
+    list: (fromEndpointId: string) => OutboxRecord[];
+}
+export declare function Outbox(opts: {
+    storageDir: string;
+}): OutboxInstance;

package/dist/outbox.js

@@ -0,0 +1,110 @@
+import { randomBytes } from "node:crypto";
+import { chmodSync, closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, writeSync } from "node:fs";
+import { dirname, join } from "node:path";
+function safe(value) {
+    return value.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+export function Outbox(opts) {
+    const root = join(opts.storageDir, "outbox");
+    function ensure(directory) {
+        mkdirSync(directory, { recursive: true, mode: 0o700 });
+        chmodSync(directory, 0o700);
+    }
+    function pathFor(endpointId, messageId) {
+        return join(root, safe(endpointId), `${safe(messageId)}.json`);
+    }
+    function read(endpointId, messageId) {
+        try {
+            const value = JSON.parse(readFileSync(pathFor(endpointId, messageId), "utf8"));
+            return value.version === 1 && value.messageId === messageId && value.fromEndpointId === endpointId ? value : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    function persist(record) {
+        const target = pathFor(record.fromEndpointId, record.messageId);
+        const directory = dirname(target);
+        ensure(root);
+        ensure(directory);
+        const temp = join(directory, `.${process.pid}.${randomBytes(8).toString("hex")}.tmp`);
+        const fd = openSync(temp, "wx", 0o600);
+        try {
+            writeSync(fd, JSON.stringify(record));
+            fsyncSync(fd);
+        }
+        finally {
+            closeSync(fd);
+        }
+        chmodSync(temp, 0o600);
+        renameSync(temp, target);
+        if (process.platform !== "win32") {
+            const dirFd = openSync(directory, "r");
+            try {
+                fsyncSync(dirFd);
+            }
+            finally {
+                closeSync(dirFd);
+            }
+        }
+    }
+    function update(endpointId, messageId, values) {
+        const current = read(endpointId, messageId);
+        if (!current)
+            return null;
+        const next = { ...current, ...values, updatedAt: Date.now() };
+        persist(next);
+        return next;
+    }
+    return {
+        async recordPending(message, toName) {
+            const existing = read(message.fromEndpointId, message.messageId);
+            if (existing)
+                return existing;
+            const record = {
+                version: 1,
+                messageId: message.messageId,
+                fromEndpointId: message.fromEndpointId,
+                toEndpointId: message.toEndpointId,
+                toName,
+                text: message.text,
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+            };
+            persist(record);
+            return record;
+        },
+        async recordReceipt(messageId, fromEndpointId, status) {
+            return update(fromEndpointId, messageId, { receiptStatus: status, error: undefined });
+        },
+        async recordFailure(messageId, fromEndpointId, error) {
+            return update(fromEndpointId, messageId, { error });
+        },
+        async applyAcknowledgement(ack) {
+            const record = read(ack.fromEndpointId, ack.messageId);
+            if (!record || record.toEndpointId !== ack.toEndpointId)
+                return false;
+            update(ack.fromEndpointId, ack.messageId, {
+                finalStatus: ack.status,
+                acknowledgedAt: ack.acknowledgedAt,
+                error: undefined,
+            });
+            return true;
+        },
+        get: read,
+        list(fromEndpointId) {
+            const directory = join(root, safe(fromEndpointId));
+            if (!existsSync(directory))
+                return [];
+            return readdirSync(directory).filter((file) => file.endsWith(".json")).flatMap((file) => {
+                try {
+                    const record = JSON.parse(readFileSync(join(directory, file), "utf8"));
+                    return record.version === 1 && record.fromEndpointId === fromEndpointId ? [record] : [];
+                }
+                catch {
+                    return [];
+                }
+            }).sort((a, b) => b.createdAt - a.createdAt || b.messageId.localeCompare(a.messageId));
+        },
+    };
+}

package/dist/permissions.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Auto-resolve permission requests that originate from a peer-triggered
+ * turn, modeled after Claude Code's per-source permission modes.
+ *
+ * A turn counts as peer-triggered when the user message that started it was
+ * injected by this plugin — detectable via the `peerMessage: true` metadata
+ * stamped on the injected part (see delivery.ts). Permission requests point
+ * at the *assistant* message holding the tool call, so the lookup walks up
+ * via parentID to the originating user message before checking its parts.
+ *
+ * Mechanism: opencode 1.18 does not invoke the plugin SDK's `permission.ask`
+ * hook, but it publishes permission request events on the bus and exposes a
+ * reply endpoint — the same pair the TUI uses. The plugin listens for
+ * `permission.v2.asked` (and the legacy `permission.asked`) and replies
+ * "once" (allow) or "reject" (deny) when the requesting turn is
+ * peer-triggered. Local user turns get no reply and fall through to
+ * opencode's normal prompt flow untouched.
+ */
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { Logger, PeerPermissionMode } from "./types.js";
+type Client = PluginInput["client"];
+export interface PeerPermissionsOptions {
+    client: Client;
+    /** Read dynamically so a future config reload could change behavior. */
+    mode: () => PeerPermissionMode;
+    directory: string;
+    logger: Logger;
+}
+export interface PeerPermissionsInstance {
+    /** Feed every bus event here; only permission requests are acted on. */
+    handleEvent: (event: {
+        type?: string;
+        properties?: Record<string, unknown>;
+    }) => Promise<void>;
+}
+/**
+ * Requests in these categories always remain under OpenCode's native policy/UI.
+ *
+ * This is a best-effort denylist, not a security boundary: it matches on the
+ * flattened event text, so a determined peer message can phrase a request to
+ * avoid these patterns (e.g. `npm config set` never names `.npmrc`). Treat
+ * `peerPermissions: "allow"` as fully trusting your peers; use "ask" for
+ * anything sensitive.
+ */
+export declare function isProtectedPermission(props: Record<string, unknown>): boolean;
+export declare function PeerPermissions(opts: PeerPermissionsOptions): PeerPermissionsInstance;
+export {};