opencode-oncall 0.1.0

package/dist/wechat/notification-types.d.ts

@@ -0,0 +1,37 @@
+import type { RequestPromptSummary } from "./question-interaction.js";
+import type { RequestTerminalReason } from "./request-store.js";
+export type SessionReplyTarget = {
+    instanceID: string;
+    sessionID: string;
+};
+export type NaturalStopTerminalReason = "replied" | "continued" | "expired";
+export type NotificationKind = "question" | "permission" | "sessionError" | "requestTerminal" | "naturalStop";
+export type NotificationStatus = "pending" | "sent" | "resolved" | "failed" | "suppressed";
+export type NotificationRecord = {
+    idempotencyKey: string;
+    kind: NotificationKind;
+    wechatAccountId: string;
+    userId: string;
+    registrationEpoch?: string;
+    createdAt: number;
+    status: NotificationStatus;
+    routeKey?: string;
+    handle?: string;
+    scopeKey?: string;
+    prompt?: RequestPromptSummary;
+    sessionID?: string;
+    action?: string;
+    redactedSummary?: string;
+    severityAdvice?: string;
+    source?: "retryError";
+    replyTarget?: SessionReplyTarget;
+    naturalStopTerminalReason?: NaturalStopTerminalReason;
+    requestKind?: "question" | "permission";
+    terminalReason?: RequestTerminalReason;
+    replacementHandle?: string;
+    sentAt?: number;
+    resolvedAt?: number;
+    failedAt?: number;
+    suppressedAt?: number;
+    failureReason?: string;
+};

package/dist/wechat/notification-types.js

@@ -0,0 +1 @@
+export {};

package/dist/wechat/openclaw-account-adapter.d.ts

@@ -0,0 +1,30 @@
+export type OpenClawWeixinAccountHelpers = {
+    listAccountIds: () => Promise<string[]>;
+    resolveAccount: (accountId: string) => Promise<unknown>;
+    describeAccount: (accountIdOrInput: string | {
+        accountId: string;
+    }) => Promise<unknown>;
+};
+export type OpenClawLatestAccountState = {
+    accountId: string;
+    token: string;
+    baseUrl: string;
+    getUpdatesBuf?: string;
+    userId?: string;
+    savedAt?: number;
+    boundAt?: number;
+};
+export type OpenClawMenuAccount = {
+    accountId: string;
+    name?: string;
+    enabled: boolean;
+    configured: boolean;
+    userId?: string;
+    boundAt?: number;
+};
+type BuildOpenClawMenuAccountInput = {
+    latestAccountState: OpenClawLatestAccountState | null;
+    accountHelpers: OpenClawWeixinAccountHelpers;
+};
+export declare function buildOpenClawMenuAccount(input: BuildOpenClawMenuAccountInput): Promise<OpenClawMenuAccount | null>;
+export {};

package/dist/wechat/openclaw-account-adapter.js

@@ -0,0 +1,60 @@
+function asObject(value) {
+    return value && typeof value === "object" ? value : {};
+}
+function firstNonEmptyString(...values) {
+    for (const value of values) {
+        if (typeof value === "string" && value.trim().length > 0) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function toBoolean(value) {
+    if (typeof value === "boolean") {
+        return value;
+    }
+    return undefined;
+}
+async function tryDescribeAccount(accountHelpers, accountId) {
+    try {
+        const byString = await accountHelpers.describeAccount(accountId);
+        if (byString !== undefined) {
+            return byString;
+        }
+    }
+    catch {
+        // fallback to object input
+    }
+    try {
+        return await accountHelpers.describeAccount({ accountId });
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function buildOpenClawMenuAccount(input) {
+    const fallbackAccountId = firstNonEmptyString(input.latestAccountState?.accountId);
+    const accountIds = await input.accountHelpers.listAccountIds();
+    const accountId = firstNonEmptyString(fallbackAccountId, accountIds.at(-1));
+    if (!accountId) {
+        return null;
+    }
+    const resolvedRaw = asObject(await input.accountHelpers.resolveAccount(accountId));
+    const describedRaw = asObject(await tryDescribeAccount(input.accountHelpers, accountId));
+    const enabled = toBoolean(resolvedRaw.enabled) ?? toBoolean(describedRaw.enabled) ?? false;
+    const configured = toBoolean(describedRaw.configured) ?? toBoolean(resolvedRaw.configured) ?? false;
+    const userId = firstNonEmptyString(input.latestAccountState?.userId, resolvedRaw.userId, describedRaw.userId);
+    const boundAt = [
+        input.latestAccountState?.boundAt,
+        resolvedRaw.boundAt,
+        describedRaw.boundAt,
+    ].find((value) => typeof value === "number" && Number.isFinite(value));
+    return {
+        accountId,
+        name: firstNonEmptyString(resolvedRaw.name, describedRaw.name),
+        enabled,
+        configured,
+        userId,
+        boundAt,
+    };
+}

package/dist/wechat/operator-store.d.ts

@@ -0,0 +1,9 @@
+export type OperatorBinding = {
+    wechatAccountId: string;
+    userId: string;
+    boundAt: number;
+};
+export declare function readOperatorBinding(): Promise<OperatorBinding | undefined>;
+export declare function bindOperator(input: OperatorBinding): Promise<OperatorBinding>;
+export declare function rebindOperator(input: OperatorBinding): Promise<OperatorBinding>;
+export declare function resetOperatorBinding(): Promise<void>;

package/dist/wechat/operator-store.js

@@ -0,0 +1,69 @@
+import path from "node:path";
+import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { WECHAT_FILE_MODE, ensureWechatStateLayout, operatorStatePath } from "./state-paths.js";
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function isValidBinding(input) {
+    return (isNonEmptyString(input.wechatAccountId) &&
+        isNonEmptyString(input.userId) &&
+        typeof input.boundAt === "number" &&
+        Number.isFinite(input.boundAt));
+}
+function toBinding(input) {
+    return {
+        wechatAccountId: input.wechatAccountId,
+        userId: input.userId,
+        boundAt: input.boundAt,
+    };
+}
+export async function readOperatorBinding() {
+    try {
+        const raw = await readFile(operatorStatePath(), "utf8");
+        const parsed = JSON.parse(raw);
+        if (!isValidBinding(parsed)) {
+            throw new Error("invalid operator binding format");
+        }
+        return toBinding(parsed);
+    }
+    catch (error) {
+        const issue = error;
+        if (issue.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+}
+export async function bindOperator(input) {
+    const next = toBinding(input);
+    if (!isValidBinding(next)) {
+        throw new Error("invalid operator binding format");
+    }
+    const existing = await readOperatorBinding();
+    if (existing && (existing.userId !== next.userId || existing.wechatAccountId !== next.wechatAccountId)) {
+        throw new Error("operator already bound to another user");
+    }
+    await ensureWechatStateLayout();
+    await mkdir(path.dirname(operatorStatePath()), { recursive: true });
+    await writeFile(operatorStatePath(), JSON.stringify(next, null, 2), { mode: WECHAT_FILE_MODE });
+    return next;
+}
+export async function rebindOperator(input) {
+    const next = toBinding(input);
+    if (!isValidBinding(next)) {
+        throw new Error("invalid operator binding format");
+    }
+    await ensureWechatStateLayout();
+    await mkdir(path.dirname(operatorStatePath()), { recursive: true });
+    await writeFile(operatorStatePath(), JSON.stringify(next, null, 2), { mode: WECHAT_FILE_MODE });
+    return next;
+}
+export async function resetOperatorBinding() {
+    try {
+        await unlink(operatorStatePath());
+    }
+    catch (error) {
+        const issue = error;
+        if (issue.code !== "ENOENT")
+            throw error;
+    }
+}

package/dist/wechat/protocol.d.ts

@@ -0,0 +1,150 @@
+import type { RequestPromptSummary } from "./question-interaction.js";
+export type BrokerCommandStatus = "queued" | "delivered" | "accepted" | "completed" | "failed";
+export type BrokerToBridgeCommandType = "replyQuestion" | "replyPermission" | "replyNaturalStop";
+export type BrokerToBridgeControlType = "requestReplay" | "requestFullSync";
+export type BridgeToBrokerEventType = "instanceOnline" | "instanceOffline" | "sessionSnapshotChanged" | "questionOpened" | "questionUpdated" | "questionClosed" | "permissionOpened" | "permissionUpdated" | "permissionClosed" | "naturalStopOpened" | "naturalStopClosed" | "retryErrorUpdated" | "commandAccepted" | "commandResult" | "fullSyncCompleted";
+export type BrokerToBridgeCommand<TPayload = unknown> = {
+    brokerSeq: number;
+    commandId: string;
+    type: BrokerToBridgeCommandType;
+    payload: TPayload;
+};
+export type BrokerToBridgeControl<TPayload = unknown> = {
+    brokerSeq: number;
+    controlId: string;
+    type: BrokerToBridgeControlType;
+    payload: TPayload;
+};
+export type BridgeToBrokerEvent<TPayload = unknown> = {
+    eventSeq: number;
+    instanceIncarnation: string;
+    type: BridgeToBrokerEventType;
+    payload: TPayload;
+    controlId?: string;
+};
+export type HelloRegisterPayload = {
+    protocolVersion: number;
+    stateGeneration: string;
+    instanceID: string;
+    instanceIncarnation: string;
+    lastSeenBrokerSeq?: number;
+    lastSentEventSeq?: number;
+};
+export type RegisterAckPayload = {
+    protocolVersion: number;
+    stateGeneration: string;
+    instanceIncarnation: string;
+    brokerSeq: number;
+    needReplay: boolean;
+    needFullSync: boolean;
+};
+export type BrokerAckPayload = {
+    ackedEventSeq: number;
+    instanceIncarnation: string;
+};
+export type HelloRegisterEnvelope = {
+    type: "hello/register";
+    payload: HelloRegisterPayload;
+};
+export type RegisterAckEnvelope = {
+    type: "registerAck";
+    payload: RegisterAckPayload;
+};
+export type BrokerAckEnvelope = {
+    type: "ack";
+    payload: BrokerAckPayload;
+};
+export type BrokerImplementedMessageType = "hello/register" | "registerAck" | "ack" | "ping" | "pong" | "error";
+export type BrokerFutureMessageType = BrokerToBridgeControlType | BridgeToBrokerEventType | "replyQuestion" | "replyNaturalStop" | "rejectQuestion" | "replyPermission";
+export type LegacyRemovedBrokerMessageType = "collectStatus" | "registerInstance" | "heartbeat" | "statusSnapshot" | "syncWechatNotifications" | "replyQuestionResult" | "replyNaturalStopResult" | "replyPermissionResult" | "showFallbackToast";
+export type BrokerMessageType = BrokerImplementedMessageType | BrokerFutureMessageType | LegacyRemovedBrokerMessageType;
+export declare const SHOW_FALLBACK_TOAST_DELIVERY_FAILED_REASON = "deliveryFailed";
+export type ShowFallbackToastPayload = {
+    wechatAccountId: string;
+    userId: string;
+    message: string;
+    reason: typeof SHOW_FALLBACK_TOAST_DELIVERY_FAILED_REASON;
+    registrationEpoch: string;
+};
+export type ReplyMutationResult = {
+    mutationId: string;
+    ok: boolean;
+    errorMessage?: string;
+};
+export type ReplyQuestionPayload = {
+    mutationId: string;
+    requestID: string;
+    answers: unknown[];
+};
+export type ReplyPermissionPayload = {
+    mutationId: string;
+    requestID: string;
+    reply: "once" | "always" | "reject";
+    message?: string;
+};
+export type ReplyNaturalStopPayload = {
+    mutationId: string;
+    sessionID: string;
+    text: string;
+};
+export type SessionReplyTarget = {
+    instanceID: string;
+    sessionID: string;
+};
+export type WechatNotificationCandidate = {
+    idempotencyKey: string;
+    kind: "question" | "permission";
+    requestID: string;
+    createdAt: number;
+    routeKey: string;
+    handle: string;
+    scopeKey?: string;
+    wechatAccountId?: string;
+    userId?: string;
+    prompt?: RequestPromptSummary;
+} | {
+    idempotencyKey: string;
+    kind: "sessionError";
+    createdAt: number;
+    sessionID: string;
+    action: string;
+    redactedSummary: string;
+    severityAdvice: string;
+} | {
+    idempotencyKey: string;
+    kind: "naturalStop";
+    createdAt: number;
+    sessionID: string;
+    handle: string;
+    replyTarget: SessionReplyTarget;
+    redactedSummary: string;
+    severityAdvice: string;
+};
+export type SyncWechatNotificationsPayload = {
+    candidates: WechatNotificationCandidate[];
+};
+export type BrokerErrorCode = "unauthorized" | "invalidMessage" | "notImplemented" | "brokerUnavailable";
+type EnvelopeBase = {
+    id: string;
+    type: BrokerMessageType;
+    instanceID?: string;
+    sessionToken?: string;
+};
+export type BrokerEnvelope<TPayload = unknown> = EnvelopeBase & {
+    payload: TPayload;
+};
+export type ErrorPayload = {
+    code: BrokerErrorCode;
+    message: string;
+    requestId: string;
+};
+export declare function createBrokerCommandEnvelope<TPayload = unknown>(envelope: BrokerToBridgeCommand<TPayload>): BrokerToBridgeCommand<TPayload>;
+export declare function createBrokerControlEnvelope<TPayload = unknown>(envelope: BrokerToBridgeControl<TPayload>): BrokerToBridgeControl<TPayload>;
+export declare function createBridgeEventEnvelope<TPayload = unknown>(envelope: BridgeToBrokerEvent<TPayload>): BridgeToBrokerEvent<TPayload>;
+export declare function createHelloRegisterEnvelope(payload: HelloRegisterPayload): HelloRegisterEnvelope;
+export declare function createRegisterAckEnvelope(payload: RegisterAckPayload): RegisterAckEnvelope;
+export declare function createBrokerAckEnvelope(payload: BrokerAckPayload): BrokerAckEnvelope;
+export declare function serializeEnvelope<TPayload = unknown>(envelope: BrokerEnvelope<TPayload>): string;
+export declare function parseEnvelopeLine(line: string): BrokerEnvelope;
+export declare function createErrorEnvelope(code: BrokerErrorCode, message: string, requestId: string): BrokerEnvelope<ErrorPayload>;
+export {};

package/dist/wechat/protocol.js

@@ -0,0 +1,197 @@
+export const SHOW_FALLBACK_TOAST_DELIVERY_FAILED_REASON = "deliveryFailed";
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function isSafeInteger(value) {
+    return typeof value === "number" && Number.isSafeInteger(value);
+}
+function assertNonNegativeInteger(value, fieldName) {
+    if (!isSafeInteger(value) || value < 0) {
+        throw new Error(`invalid ${fieldName}`);
+    }
+}
+function assertCommandType(value) {
+    if (value !== "replyQuestion" && value !== "replyPermission" && value !== "replyNaturalStop") {
+        throw new Error("invalid broker command type");
+    }
+}
+function assertControlType(value) {
+    if (value !== "requestReplay" && value !== "requestFullSync") {
+        throw new Error("invalid broker control type");
+    }
+}
+function assertBridgeEventType(value) {
+    if (value !== "instanceOnline"
+        && value !== "instanceOffline"
+        && value !== "sessionSnapshotChanged"
+        && value !== "questionOpened"
+        && value !== "questionUpdated"
+        && value !== "questionClosed"
+        && value !== "permissionOpened"
+        && value !== "permissionUpdated"
+        && value !== "permissionClosed"
+        && value !== "naturalStopOpened"
+        && value !== "naturalStopClosed"
+        && value !== "retryErrorUpdated"
+        && value !== "commandAccepted"
+        && value !== "commandResult"
+        && value !== "fullSyncCompleted") {
+        throw new Error("invalid bridge event type");
+    }
+}
+export function createBrokerCommandEnvelope(envelope) {
+    assertNonNegativeInteger(envelope.brokerSeq, "brokerSeq");
+    if (!isNonEmptyString(envelope.commandId)) {
+        throw new Error("invalid commandId");
+    }
+    assertCommandType(envelope.type);
+    return { ...envelope };
+}
+export function createBrokerControlEnvelope(envelope) {
+    assertNonNegativeInteger(envelope.brokerSeq, "brokerSeq");
+    if (!isNonEmptyString(envelope.controlId)) {
+        throw new Error("invalid controlId");
+    }
+    assertControlType(envelope.type);
+    return { ...envelope };
+}
+export function createBridgeEventEnvelope(envelope) {
+    assertNonNegativeInteger(envelope.eventSeq, "eventSeq");
+    if (!isNonEmptyString(envelope.instanceIncarnation)) {
+        throw new Error("invalid instanceIncarnation");
+    }
+    assertBridgeEventType(envelope.type);
+    if (envelope.type === "fullSyncCompleted" && !isNonEmptyString(envelope.controlId)) {
+        throw new Error("invalid controlId");
+    }
+    return { ...envelope };
+}
+export function createHelloRegisterEnvelope(payload) {
+    assertNonNegativeInteger(payload.protocolVersion, "protocolVersion");
+    if (!isNonEmptyString(payload.stateGeneration)
+        || !isNonEmptyString(payload.instanceID)
+        || !isNonEmptyString(payload.instanceIncarnation)) {
+        throw new Error("invalid hello/register payload");
+    }
+    if (payload.lastSeenBrokerSeq !== undefined) {
+        assertNonNegativeInteger(payload.lastSeenBrokerSeq, "lastSeenBrokerSeq");
+    }
+    if (payload.lastSentEventSeq !== undefined) {
+        assertNonNegativeInteger(payload.lastSentEventSeq, "lastSentEventSeq");
+    }
+    return {
+        type: "hello/register",
+        payload: { ...payload },
+    };
+}
+export function createRegisterAckEnvelope(payload) {
+    assertNonNegativeInteger(payload.protocolVersion, "protocolVersion");
+    assertNonNegativeInteger(payload.brokerSeq, "brokerSeq");
+    if (!isNonEmptyString(payload.stateGeneration)
+        || !isNonEmptyString(payload.instanceIncarnation)
+        || typeof payload.needReplay !== "boolean"
+        || typeof payload.needFullSync !== "boolean") {
+        throw new Error("invalid registerAck payload");
+    }
+    return {
+        type: "registerAck",
+        payload: { ...payload },
+    };
+}
+export function createBrokerAckEnvelope(payload) {
+    assertNonNegativeInteger(payload.ackedEventSeq, "ackedEventSeq");
+    if (!isNonEmptyString(payload.instanceIncarnation)) {
+        throw new Error("invalid ack payload");
+    }
+    return {
+        type: "ack",
+        payload: { ...payload },
+    };
+}
+function isMessageType(value) {
+    return (value === "hello/register" ||
+        value === "registerAck" ||
+        value === "ack" ||
+        value === "ping" ||
+        value === "pong" ||
+        value === "error" ||
+        value === "requestReplay" ||
+        value === "requestFullSync" ||
+        value === "instanceOnline" ||
+        value === "instanceOffline" ||
+        value === "sessionSnapshotChanged" ||
+        value === "questionOpened" ||
+        value === "questionUpdated" ||
+        value === "questionClosed" ||
+        value === "permissionOpened" ||
+        value === "permissionUpdated" ||
+        value === "permissionClosed" ||
+        value === "naturalStopOpened" ||
+        value === "naturalStopClosed" ||
+        value === "retryErrorUpdated" ||
+        value === "commandAccepted" ||
+        value === "commandResult" ||
+        value === "fullSyncCompleted" ||
+        value === "replyQuestion" ||
+        value === "replyNaturalStop" ||
+        value === "rejectQuestion" ||
+        value === "replyPermission");
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null;
+}
+function assertValidEnvelope(envelope) {
+    if (!isObject(envelope)) {
+        throw new Error("invalid message envelope");
+    }
+    if (!isNonEmptyString(envelope.id) || !isMessageType(envelope.type)) {
+        throw new Error("invalid message envelope");
+    }
+    if (!("payload" in envelope)) {
+        throw new Error("invalid message envelope");
+    }
+    if (envelope.instanceID !== undefined && !isNonEmptyString(envelope.instanceID)) {
+        throw new Error("invalid message envelope");
+    }
+    if (envelope.sessionToken !== undefined && !isNonEmptyString(envelope.sessionToken)) {
+        throw new Error("invalid message envelope");
+    }
+}
+export function serializeEnvelope(envelope) {
+    assertValidEnvelope(envelope);
+    return `${JSON.stringify(envelope)}\n`;
+}
+export function parseEnvelopeLine(line) {
+    if (typeof line !== "string" || line.length === 0) {
+        throw new Error("invalid message line");
+    }
+    if (!line.endsWith("\n")) {
+        throw new Error("invalid message line");
+    }
+    const body = line.slice(0, -1);
+    if (body.length === 0 || body.includes("\n") || body.includes("\r")) {
+        throw new Error("invalid message line");
+    }
+    try {
+        const parsed = JSON.parse(body);
+        assertValidEnvelope(parsed);
+        return parsed;
+    }
+    catch {
+        throw new Error("invalid message line");
+    }
+}
+export function createErrorEnvelope(code, message, requestId) {
+    if (!isNonEmptyString(message) || !isNonEmptyString(requestId)) {
+        throw new Error("invalid error envelope");
+    }
+    return {
+        id: `err-${requestId}`,
+        type: "error",
+        payload: {
+            code,
+            message,
+            requestId,
+        },
+    };
+}

package/dist/wechat/question-interaction.d.ts

@@ -0,0 +1,24 @@
+import type { PermissionRequest, QuestionRequest } from "@opencode-ai/sdk/v2";
+export type QuestionPromptMode = "text" | "single" | "multiple";
+export type QuestionPromptSummary = {
+    title?: string;
+    body?: string;
+    mode: QuestionPromptMode;
+    custom?: boolean;
+    options?: Array<{
+        index: number;
+        label: string;
+        value: string;
+        description?: string;
+    }>;
+};
+export type PermissionPromptSummary = {
+    title?: string;
+    type?: string;
+    description?: string;
+};
+export type RequestPromptSummary = QuestionPromptSummary | PermissionPromptSummary;
+export declare function normalizeRequestPromptSummary(kind: "question" | "permission", input: unknown): RequestPromptSummary | undefined;
+export declare function extractQuestionPromptSummary(question: QuestionRequest): QuestionPromptSummary | undefined;
+export declare function extractPermissionPromptSummary(permission: PermissionRequest): PermissionPromptSummary | undefined;
+export declare function buildQuestionAnswersFromReply(prompt: QuestionPromptSummary | undefined, rawText: string): Array<Array<string>>;