opencode-oncall 0.1.0

package/dist/wechat/broker-client.d.ts

@@ -0,0 +1,23 @@
+import { type BrokerAckPayload, type BrokerEnvelope, type BrokerToBridgeCommand, type BrokerToBridgeControl, type BridgeToBrokerEvent, type HelloRegisterPayload, type RegisterAckPayload } from "./protocol.js";
+export type LiveRegisterResult = {
+    ack: RegisterAckPayload;
+    control?: BrokerToBridgeControl;
+    pendingCommands: BrokerToBridgeCommand[];
+};
+export type SendBridgeEventOptions = {
+    instanceID: string;
+    controlId?: string;
+};
+export type BrokerClientLiveHandlers = {
+    onBrokerControl?: (control: BrokerToBridgeControl) => Promise<void> | void;
+    onBrokerCommand?: (command: BrokerToBridgeCommand) => Promise<void> | void;
+};
+export type BrokerClientOptions = BrokerClientLiveHandlers;
+export type BrokerClient = {
+    ping: () => Promise<BrokerEnvelope>;
+    registerHello: (payload: HelloRegisterPayload) => Promise<LiveRegisterResult>;
+    sendBridgeEvent: (event: BridgeToBrokerEvent, options: SendBridgeEventOptions) => Promise<BrokerAckPayload>;
+    setLiveHandlers: (handlers: BrokerClientLiveHandlers) => void;
+    close: () => Promise<void>;
+};
+export declare function connect(endpoint: string, options?: BrokerClientOptions): Promise<BrokerClient>;

package/dist/wechat/broker-client.js

@@ -0,0 +1,274 @@
+import { createBrokerSocket } from "./broker-endpoint.js";
+import { createBridgeEventEnvelope, createHelloRegisterEnvelope, parseEnvelopeLine, serializeEnvelope, } from "./protocol.js";
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function isFiniteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value);
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null;
+}
+function isLiveBrokerCommandPayload(value) {
+    if (!isObject(value)) {
+        return false;
+    }
+    return isNonEmptyString(value.commandId)
+        && isFiniteNumber(value.brokerSeq)
+        && isNonEmptyString(value.type)
+        && "payload" in value;
+}
+function isLiveBrokerControlPayload(value) {
+    if (!isObject(value)) {
+        return false;
+    }
+    return isNonEmptyString(value.controlId)
+        && isFiniteNumber(value.brokerSeq)
+        && isNonEmptyString(value.type)
+        && "payload" in value;
+}
+function isResponseForRequest(response, requestId) {
+    if (response.id === requestId) {
+        return true;
+    }
+    if (response.id.endsWith(`-${requestId}`)) {
+        return true;
+    }
+    if (response.type === "error") {
+        const payload = response.payload;
+        return payload.requestId === requestId;
+    }
+    return false;
+}
+export async function connect(endpoint, options = {}) {
+    const socket = createBrokerSocket(endpoint);
+    let sequence = 0;
+    const pendingRequests = new Map();
+    let buffer = "";
+    let connected = false;
+    let closed = false;
+    let serverPushChain = Promise.resolve();
+    let liveHandlers = {
+        onBrokerControl: options.onBrokerControl,
+        onBrokerCommand: options.onBrokerCommand,
+    };
+    function enqueueServerPush(task) {
+        serverPushChain = serverPushChain
+            .then(() => task())
+            .catch(() => {
+            // swallow push handler failures to keep connection alive
+        });
+    }
+    function deletePendingRequest(requestId) {
+        const pending = pendingRequests.get(requestId);
+        if (!pending) {
+            return undefined;
+        }
+        pendingRequests.delete(requestId);
+        return pending;
+    }
+    function rejectPendingRequest(requestId, reason) {
+        deletePendingRequest(requestId)?.reject(reason);
+    }
+    function findPendingRequest(response) {
+        if (response.type === "error") {
+            const requestId = response.payload.requestId;
+            if (isNonEmptyString(requestId)) {
+                const pending = pendingRequests.get(requestId);
+                if (pending) {
+                    return [requestId, pending];
+                }
+            }
+        }
+        const direct = pendingRequests.get(response.id);
+        if (direct) {
+            return [response.id, direct];
+        }
+        for (const [requestId, pending] of pendingRequests.entries()) {
+            if (isResponseForRequest(response, requestId)) {
+                return [requestId, pending];
+            }
+        }
+        return null;
+    }
+    const connectedReady = new Promise((resolve, reject) => {
+        socket.once("connect", () => {
+            connected = true;
+            resolve();
+        });
+        socket.once("error", reject);
+    });
+    socket.on("data", (chunk) => {
+        buffer += chunk.toString("utf8");
+        const parsedFrames = [];
+        while (true) {
+            const newlineIndex = buffer.indexOf("\n");
+            if (newlineIndex === -1) {
+                break;
+            }
+            const frame = buffer.slice(0, newlineIndex + 1);
+            buffer = buffer.slice(newlineIndex + 1);
+            try {
+                parsedFrames.push(parseEnvelopeLine(frame));
+            }
+            catch (error) {
+                for (const requestId of [...pendingRequests.keys()]) {
+                    rejectPendingRequest(requestId, error);
+                }
+            }
+        }
+        if (parsedFrames.length === 0) {
+            return;
+        }
+        for (const parsed of parsedFrames) {
+            if (handleServerPush(parsed)) {
+                continue;
+            }
+            const matched = findPendingRequest(parsed);
+            if (!matched) {
+                continue;
+            }
+            const [requestId] = matched;
+            deletePendingRequest(requestId)?.resolve(parsed);
+        }
+    });
+    socket.on("error", (error) => {
+        for (const requestId of [...pendingRequests.keys()]) {
+            rejectPendingRequest(requestId, error);
+        }
+    });
+    socket.on("close", () => {
+        connected = false;
+        closed = true;
+        for (const requestId of [...pendingRequests.keys()]) {
+            rejectPendingRequest(requestId, new Error("broker connection closed"));
+        }
+    });
+    await connectedReady;
+    function nextRequestId(prefix) {
+        sequence += 1;
+        return `${prefix}-${Date.now()}-${sequence}`;
+    }
+    function handleBrokerControlPush(envelope) {
+        if (envelope.type !== "requestReplay" && envelope.type !== "requestFullSync") {
+            return false;
+        }
+        if (!liveHandlers.onBrokerControl || !isLiveBrokerControlPayload(envelope.payload)) {
+            return false;
+        }
+        const control = envelope.payload;
+        enqueueServerPush(() => liveHandlers.onBrokerControl?.(control));
+        return true;
+    }
+    function handleBrokerCommandPush(envelope) {
+        if (envelope.type !== "replyQuestion"
+            && envelope.type !== "replyPermission"
+            && envelope.type !== "replyNaturalStop") {
+            return false;
+        }
+        if (!liveHandlers.onBrokerCommand || !isLiveBrokerCommandPayload(envelope.payload)) {
+            return false;
+        }
+        const command = envelope.payload;
+        enqueueServerPush(() => liveHandlers.onBrokerCommand?.(command));
+        return true;
+    }
+    function handleServerPush(envelope) {
+        if (handleBrokerControlPush(envelope)) {
+            return true;
+        }
+        if (handleBrokerCommandPush(envelope)) {
+            return true;
+        }
+        return false;
+    }
+    async function send(envelope) {
+        if (!connected || closed) {
+            throw new Error("broker connection closed");
+        }
+        return new Promise((resolve, reject) => {
+            pendingRequests.set(envelope.id, { resolve, reject });
+            socket.write(serializeEnvelope(envelope));
+        });
+    }
+    return {
+        async ping() {
+            return send({
+                id: nextRequestId("ping"),
+                type: "ping",
+                payload: {},
+            });
+        },
+        async registerHello(payload) {
+            const hello = createHelloRegisterEnvelope(payload);
+            const response = await send({
+                id: nextRequestId("hello-register"),
+                type: "hello/register",
+                instanceID: hello.payload.instanceID,
+                payload: hello.payload,
+            });
+            if (response.type !== "registerAck" || !isObject(response.payload)) {
+                throw new Error("hello/register failed");
+            }
+            const ackPayload = response.payload;
+            return {
+                ack: {
+                    protocolVersion: ackPayload.protocolVersion,
+                    stateGeneration: ackPayload.stateGeneration,
+                    instanceIncarnation: ackPayload.instanceIncarnation,
+                    brokerSeq: ackPayload.brokerSeq,
+                    needReplay: ackPayload.needReplay,
+                    needFullSync: ackPayload.needFullSync,
+                },
+                ...(isLiveBrokerControlPayload(ackPayload.control) ? { control: ackPayload.control } : {}),
+                pendingCommands: Array.isArray(ackPayload.pendingCommands)
+                    ? ackPayload.pendingCommands.filter((command) => isLiveBrokerCommandPayload(command))
+                    : [],
+            };
+        },
+        async sendBridgeEvent(event, options) {
+            const bridgeEvent = createBridgeEventEnvelope(options.controlId ? { ...event, controlId: options.controlId } : event);
+            const response = await send({
+                id: nextRequestId(bridgeEvent.type),
+                type: bridgeEvent.type,
+                instanceID: options.instanceID,
+                payload: bridgeEvent,
+            });
+            if (response.type !== "ack" || !isObject(response.payload)) {
+                throw new Error(`bridge event ack failed: ${bridgeEvent.type}`);
+            }
+            return response.payload;
+        },
+        setLiveHandlers(handlers) {
+            liveHandlers = {
+                ...liveHandlers,
+                ...handlers,
+            };
+        },
+        async close() {
+            if (closed) {
+                return;
+            }
+            if (socket.destroyed) {
+                closed = true;
+                connected = false;
+                return;
+            }
+            const closePromise = new Promise((resolve) => {
+                socket.once("close", () => resolve());
+            });
+            socket.end();
+            await Promise.race([
+                closePromise,
+                new Promise((resolve) => {
+                    setTimeout(() => {
+                        if (!socket.destroyed) {
+                            socket.destroy();
+                        }
+                        resolve();
+                    }, 200);
+                }),
+            ]);
+        },
+    };
+}

package/dist/wechat/broker-endpoint.d.ts

@@ -0,0 +1,21 @@
+import net from "node:net";
+type BrokerEndpointOptions = {
+    platform?: NodeJS.Platform;
+    stateRoot?: string;
+    now?: () => number;
+    random?: () => number;
+};
+type ParsedBrokerEndpoint = {
+    kind: "tcp";
+    host: string;
+    port: number;
+} | {
+    kind: "path";
+    path: string;
+};
+export declare function isTcpBrokerEndpoint(endpoint: string): boolean;
+export declare function createDefaultBrokerEndpoint(options?: BrokerEndpointOptions): string;
+export declare function parseBrokerEndpoint(endpoint: string): ParsedBrokerEndpoint;
+export declare function createBrokerSocket(endpoint: string): net.Socket;
+export declare function listenOnBrokerEndpoint(server: net.Server, endpoint: string): Promise<string>;
+export {};

package/dist/wechat/broker-endpoint.js

@@ -0,0 +1,78 @@
+import net from "node:net";
+import path from "node:path";
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+export function isTcpBrokerEndpoint(endpoint) {
+    return endpoint.startsWith("tcp://");
+}
+export function createDefaultBrokerEndpoint(options = {}) {
+    const platform = options.platform ?? process.platform;
+    const stateRoot = options.stateRoot ?? ".";
+    const now = options.now ?? Date.now;
+    const random = options.random ?? Math.random;
+    const suffix = `${now()}-${random().toString(16).slice(2)}`;
+    if (platform === "win32") {
+        return "tcp://127.0.0.1:0";
+    }
+    return path.join(stateRoot, `broker-${suffix}.sock`);
+}
+export function parseBrokerEndpoint(endpoint) {
+    if (!isTcpBrokerEndpoint(endpoint)) {
+        return {
+            kind: "path",
+            path: endpoint,
+        };
+    }
+    const parsed = new URL(endpoint);
+    if (parsed.protocol !== "tcp:") {
+        throw new Error(`unsupported broker endpoint protocol: ${parsed.protocol}`);
+    }
+    if (!isNonEmptyString(parsed.hostname)) {
+        throw new Error("tcp broker endpoint host is required");
+    }
+    const port = Number(parsed.port);
+    if (!Number.isInteger(port) || port < 0 || port > 65535) {
+        throw new Error("tcp broker endpoint port is invalid");
+    }
+    return {
+        kind: "tcp",
+        host: parsed.hostname,
+        port,
+    };
+}
+export function createBrokerSocket(endpoint) {
+    const parsed = parseBrokerEndpoint(endpoint);
+    if (parsed.kind === "tcp") {
+        return net.createConnection({
+            host: parsed.host,
+            port: parsed.port,
+        });
+    }
+    return net.createConnection(parsed.path);
+}
+export async function listenOnBrokerEndpoint(server, endpoint) {
+    const parsed = parseBrokerEndpoint(endpoint);
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        if (parsed.kind === "tcp") {
+            server.listen({ host: parsed.host, port: parsed.port }, () => {
+                server.off("error", reject);
+                resolve();
+            });
+            return;
+        }
+        server.listen(parsed.path, () => {
+            server.off("error", reject);
+            resolve();
+        });
+    });
+    if (parsed.kind === "path") {
+        return parsed.path;
+    }
+    const address = server.address();
+    if (!address || typeof address === "string") {
+        throw new Error("tcp broker endpoint failed to resolve bound address");
+    }
+    return `tcp://${address.address}:${address.port}`;
+}

package/dist/wechat/broker-entry.d.ts

@@ -0,0 +1,123 @@
+import type { QuestionAnswer } from "@opencode-ai/sdk/v2";
+import { type BrokerMutationQueue, type RecoveryMutation } from "./broker-mutation-queue.js";
+import { type BrokerAuthoritativeView, type BrokerCommandActionInput, type BrokerCommandRecord } from "./broker-state-store.js";
+import type { WechatSlashCommand } from "./command-parser.js";
+import { markDeadLetterRecoveryFailed } from "./dead-letter-store.js";
+import { type WechatNotificationDeliveryFailureInput, type WechatNotificationSendInput } from "./notification-dispatcher.js";
+import { type WechatStatusRuntime, type WechatStatusRuntimeDiagnosticEvent } from "./wechat-status-runtime.js";
+type ReplyMutationResult = {
+    mutationId: string;
+    ok: boolean;
+    errorMessage?: string;
+};
+type Awaitable<T> = T | Promise<T>;
+type BrokerWechatStatusRuntimeLifecycle = {
+    start: () => Promise<void>;
+    close: () => Promise<void>;
+};
+type BrokerWechatStatusRuntimeLifecycleDeps = {
+    createStatusRuntime?: (deps: {
+        onSlashCommand: (input: {
+            command: import("./command-parser.js").WechatSlashCommand;
+        }) => Promise<string>;
+        onDiagnosticEvent: (event: WechatStatusRuntimeDiagnosticEvent) => void | Promise<void>;
+        drainOutboundMessages: (input?: {
+            sendMessage: (input: WechatNotificationSendInput) => Promise<void>;
+        }) => Promise<void>;
+    }) => WechatStatusRuntime;
+    createNotificationDispatcher?: (input: {
+        sendMessage: (input: WechatNotificationSendInput) => Promise<void>;
+        onDeliveryFailed?: (input: WechatNotificationDeliveryFailureInput) => Promise<void>;
+    }) => {
+        drainOutboundMessages: () => Promise<void>;
+    };
+    handleWechatSlashCommand?: (command: import("./command-parser.js").WechatSlashCommand) => Promise<string>;
+    sendReplyQuestionRpc?: (input: {
+        instanceID: string;
+        mutationId: string;
+        requestID: string;
+        answers: QuestionAnswer[];
+    }) => Promise<ReplyMutationResult>;
+    sendReplyPermissionRpc?: (input: {
+        instanceID: string;
+        mutationId: string;
+        requestID: string;
+        reply: "once" | "always" | "reject";
+        message?: string;
+    }) => Promise<ReplyMutationResult>;
+    sendReplyNaturalStopRpc?: (input: {
+        instanceID: string;
+        mutationId: string;
+        sessionID: string;
+        handle: string;
+        text: string;
+    }) => Promise<ReplyMutationResult>;
+    handleNotificationDeliveryFailure?: (input: {
+        instanceID: string;
+        wechatAccountId: string;
+        userId: string;
+        registrationEpoch?: string;
+    }) => Promise<void>;
+    onRuntimeError?: (error: unknown) => void;
+    onDiagnosticEvent?: (event: WechatStatusRuntimeDiagnosticEvent) => void | Promise<void>;
+    stateRoot?: string;
+};
+export declare function shouldEnableBrokerWechatStatusRuntime(env?: NodeJS.ProcessEnv): boolean;
+type BrokerWechatSlashHandlerClient = {
+    question?: {
+        reply?: (input: {
+            requestID: string;
+            directory?: string;
+            answers?: Array<QuestionAnswer>;
+        }) => Promise<unknown>;
+    };
+    permission?: {
+        reply?: (input: {
+            requestID: string;
+            directory?: string;
+            reply?: "once" | "always" | "reject";
+            message?: string;
+        }) => Promise<unknown>;
+    };
+};
+type PermissionMutationTestHooks = {
+    beforeFinalizePermission?: (request: {
+        readonly routeKey: string;
+        readonly handle: string;
+    }) => Promise<void> | void;
+};
+export declare function createBrokerWechatSlashCommandHandler(input: {
+    handleStatusCommand?: () => Promise<string>;
+    client?: BrokerWechatSlashHandlerClient;
+    readBrokerAuthoritativeView?: () => Awaitable<BrokerAuthoritativeView | undefined>;
+    readBrokerCommandStateByAction?: (input: BrokerCommandActionInput) => Awaitable<BrokerCommandRecord | undefined>;
+    sendReplyQuestionRpc?: (input: {
+        instanceID: string;
+        mutationId: string;
+        requestID: string;
+        answers: QuestionAnswer[];
+    }) => Promise<ReplyMutationResult>;
+    sendReplyPermissionRpc?: (input: {
+        instanceID: string;
+        mutationId: string;
+        requestID: string;
+        reply: "once" | "always" | "reject";
+        message?: string;
+    }) => Promise<ReplyMutationResult>;
+    sendReplyNaturalStopRpc?: (input: {
+        instanceID: string;
+        mutationId: string;
+        sessionID: string;
+        handle: string;
+        text: string;
+    }) => Promise<ReplyMutationResult>;
+    directory?: string;
+    mutationQueue?: BrokerMutationQueue;
+    markDeadLetterRecoveryFailedImpl?: typeof markDeadLetterRecoveryFailed;
+    permissionMutationTestHooks?: PermissionMutationTestHooks;
+    recoveryTestHooks?: {
+        afterReopenRequest?: (mutation: RecoveryMutation) => Promise<void> | void;
+    };
+}): (command: WechatSlashCommand) => Promise<string>;
+export declare function createBrokerWechatStatusRuntimeLifecycle(deps?: BrokerWechatStatusRuntimeLifecycleDeps): BrokerWechatStatusRuntimeLifecycle;
+export {};