opencode-oncall 0.1.0

package/dist/wechat/session-digest.d.ts

@@ -0,0 +1,50 @@
+import type { Message, Part, PermissionRequest, QuestionRequest, Session, SessionStatus, Todo } from "@opencode-ai/sdk/v2";
+type SessionState = "busy" | "idle" | "retry" | "unknown";
+type SessionMessages = Array<{
+    info: Message;
+    parts: Part[];
+}>;
+export type SessionDigestHighlight = {
+    kind: "question" | "permission" | "running-tool" | "completed-tool" | "todo" | "status";
+    text: string;
+};
+export type SessionDigestTodoItem = {
+    status: "pending" | "in_progress" | "completed" | "cancelled";
+    content: string;
+};
+export type SessionDigest = {
+    sessionID: string;
+    parentID?: string;
+    title: string;
+    directory: string;
+    updatedAt: number;
+    status: SessionState;
+    pendingQuestionCount: number;
+    pendingPermissionCount: number;
+    todoSummary: {
+        total: number;
+        inProgress: number;
+        completed: number;
+    };
+    unavailable?: Array<"messages" | "todo">;
+    highlights: SessionDigestHighlight[];
+    todoItems?: SessionDigestTodoItem[];
+    questionHighlights?: string[];
+};
+export type BuildSessionDigestInput = {
+    session: Pick<Session, "id" | "title" | "directory" | "time"> & {
+        parentID?: string;
+    };
+    statusBySession: Record<string, SessionStatus | undefined>;
+    questionsBySession: Map<string, QuestionRequest[]>;
+    permissionsBySession: Map<string, PermissionRequest[]>;
+    todos?: Todo[];
+    messages?: SessionMessages;
+    unavailable?: Array<"messages" | "todo">;
+};
+export declare function groupQuestionsBySession(questions?: QuestionRequest[]): Map<string, QuestionRequest[]>;
+export declare function groupPermissionsBySession(permissions?: PermissionRequest[]): Map<string, PermissionRequest[]>;
+export declare function buildSessionDigest(input: BuildSessionDigestInput): SessionDigest;
+type RecentSessionLike = Pick<Session, "time">;
+export declare function pickRecentSessions<TSession extends RecentSessionLike>(sessions: TSession[], limit?: number): TSession[];
+export {};

package/dist/wechat/session-digest.js

@@ -0,0 +1,167 @@
+function asSessionState(status) {
+    if (!status) {
+        return "unknown";
+    }
+    return status.type;
+}
+function toUpdatedAt(session) {
+    const updated = session.time?.updated;
+    if (typeof updated === "number" && Number.isFinite(updated)) {
+        return updated;
+    }
+    return 0;
+}
+function collectToolSlices(messages) {
+    const runningTools = [];
+    let latestCompletedTool;
+    for (const message of messages) {
+        const parts = Array.isArray(message.parts) ? message.parts : [];
+        for (const part of parts) {
+            if (part.type !== "tool") {
+                continue;
+            }
+            const toolName = part.tool;
+            const status = part.state?.status;
+            if (status === "pending" || status === "running") {
+                if (!runningTools.includes(toolName)) {
+                    runningTools.push(toolName);
+                }
+                continue;
+            }
+            if (status === "completed") {
+                latestCompletedTool = toolName;
+            }
+        }
+    }
+    return {
+        runningText: runningTools.length > 0 ? `running tool: ${runningTools.join(", ")}` : undefined,
+        completedText: latestCompletedTool ? `completed tool: ${latestCompletedTool}` : undefined,
+    };
+}
+function summarizeTodos(todos) {
+    let inProgress = 0;
+    let completed = 0;
+    for (const todo of todos) {
+        if (todo.status === "in_progress") {
+            inProgress += 1;
+        }
+        if (todo.status === "completed") {
+            completed += 1;
+        }
+    }
+    return {
+        total: todos.length,
+        inProgress,
+        completed,
+    };
+}
+function normalizeTodoStatus(status) {
+    return status === "pending" || status === "in_progress" || status === "completed" || status === "cancelled"
+        ? status
+        : null;
+}
+function pushIfDefined(highlights, kind, text) {
+    if (!text) {
+        return;
+    }
+    highlights.push({ kind, text });
+}
+function summarizeQuestionHighlight(question) {
+    const first = Array.isArray(question.questions) ? question.questions[0] : undefined;
+    if (first && typeof first.question === "string" && first.question.trim().length > 0) {
+        return `问题：${first.question.trim()}`;
+    }
+    const fallback = question.text;
+    if (typeof fallback === "string" && fallback.trim().length > 0) {
+        return `问题：${fallback.trim()}`;
+    }
+    return undefined;
+}
+export function groupQuestionsBySession(questions = []) {
+    const grouped = new Map();
+    for (const question of questions) {
+        const sessionID = question.sessionID;
+        if (sessionID.length === 0) {
+            continue;
+        }
+        const list = grouped.get(sessionID) ?? [];
+        list.push(question);
+        grouped.set(sessionID, list);
+    }
+    return grouped;
+}
+export function groupPermissionsBySession(permissions = []) {
+    const grouped = new Map();
+    for (const permission of permissions) {
+        const sessionID = permission.sessionID;
+        if (sessionID.length === 0) {
+            continue;
+        }
+        const list = grouped.get(sessionID) ?? [];
+        list.push(permission);
+        grouped.set(sessionID, list);
+    }
+    return grouped;
+}
+export function buildSessionDigest(input) {
+    const sessionID = input.session.id;
+    const questions = input.questionsBySession.get(sessionID) ?? [];
+    const permissions = input.permissionsBySession.get(sessionID) ?? [];
+    const todos = input.todos ?? [];
+    const messages = input.messages ?? [];
+    const todoSummary = summarizeTodos(todos);
+    const toolSlices = collectToolSlices(messages);
+    const status = asSessionState(input.statusBySession[sessionID]);
+    const highlights = [];
+    const todoItems = todos
+        .map((todo) => {
+        const status = normalizeTodoStatus(todo.status);
+        return {
+            status,
+            content: typeof todo.content === "string" ? todo.content.trim() : "",
+        };
+    })
+        .filter((item) => item.status !== null && item.content.length > 0);
+    const questionHighlights = questions
+        .map((question) => summarizeQuestionHighlight(question))
+        .filter((item) => typeof item === "string" && item.length > 0);
+    if (permissions.length > 0) {
+        highlights.push({ kind: "permission", text: `pending permission: ${permissions.length}` });
+    }
+    if (questions.length > 0) {
+        highlights.push({ kind: "question", text: `pending question: ${questions.length}` });
+    }
+    pushIfDefined(highlights, "running-tool", toolSlices.runningText);
+    pushIfDefined(highlights, "completed-tool", toolSlices.completedText);
+    if (todoSummary.total > 0) {
+        highlights.push({
+            kind: "todo",
+            text: `todo: ${todoSummary.inProgress} in progress, ${todoSummary.completed} completed, ${todoSummary.total} total`,
+        });
+    }
+    highlights.push({ kind: "status", text: `status: ${status}` });
+    const unavailable = (input.unavailable ?? []).filter((item) => item === "messages" || item === "todo");
+    return {
+        sessionID,
+        ...(typeof input.session.parentID === "string" && input.session.parentID.trim().length > 0
+            ? { parentID: input.session.parentID.trim() }
+            : {}),
+        title: input.session.title ?? "",
+        directory: input.session.directory ?? "",
+        updatedAt: toUpdatedAt(input.session),
+        status,
+        pendingQuestionCount: questions.length,
+        pendingPermissionCount: permissions.length,
+        todoSummary,
+        unavailable: unavailable.length > 0 ? unavailable : undefined,
+        highlights,
+        ...(todoItems.length > 0 ? { todoItems } : {}),
+        ...(questionHighlights.length > 0 ? { questionHighlights } : {}),
+    };
+}
+export function pickRecentSessions(sessions, limit = 3) {
+    const safeLimit = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 3;
+    return [...sessions]
+        .sort((a, b) => toUpdatedAt(b) - toUpdatedAt(a))
+        .slice(0, safeLimit);
+}

package/dist/wechat/state-paths.d.ts

@@ -0,0 +1,26 @@
+export declare const WECHAT_DIR_MODE = 448;
+export declare const WECHAT_FILE_MODE = 384;
+export type WechatRequestKind = "question" | "permission";
+export declare function wechatStateRoot(): string;
+export declare function brokerStatePath(): string;
+export declare function brokerStateStorePath(): string;
+export declare function brokerStateSchemaPath(): string;
+export declare function wechatStatusRuntimeDiagnosticsPath(stateRoot?: string): string;
+export declare function brokerStartupDiagnosticsPath(stateRoot?: string): string;
+export declare function wechatBrokerDiagnosticsPath(stateRoot?: string): string;
+export declare function wechatBridgeDiagnosticsPath(stateRoot?: string): string;
+export declare function launchLockPath(): string;
+export declare function operatorStatePath(): string;
+export declare function instancesDir(): string;
+export declare function instanceStatePath(instanceID: string): string;
+export declare function tokensDir(): string;
+export declare function tokenStatePath(wechatAccountId: string, userId: string): string;
+export declare function latestAccountStatePath(stateRoot?: string): string;
+export declare function notificationsDir(): string;
+export declare function notificationStatePath(idempotencyKey: string): string;
+export declare function requestKindDir(kind: WechatRequestKind): string;
+export declare function requestStatePath(kind: WechatRequestKind, routeKey: string): string;
+export declare function wechatDeadLetterRoot(stateRoot?: string): string;
+export declare function wechatDeadLetterKindDir(kind: WechatRequestKind, stateRoot?: string): string;
+export declare function wechatDeadLetterPath(kind: WechatRequestKind, routeKey: string, stateRoot?: string): string;
+export declare function ensureWechatStateLayout(): Promise<void>;

package/dist/wechat/state-paths.js

@@ -0,0 +1,92 @@
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+import { wechatBridgeDiagnosticsPath as defaultWechatBridgeDiagnosticsPath, wechatStatusRuntimeDiagnosticsPath as defaultWechatStatusRuntimeDiagnosticsPath, opencodeWechatConfigDir, wechatBrokerStateStorePath, wechatDeadLetterDir, wechatInstancesDir, wechatLatestAccountPath, wechatNotificationsDir, wechatOperatorPath, wechatRequestsDir, wechatTokensDir, } from "../store-paths.js";
+export const WECHAT_DIR_MODE = 0o700;
+export const WECHAT_FILE_MODE = 0o600;
+export function wechatStateRoot() {
+    const override = process.env.WECHAT_STATE_ROOT_OVERRIDE;
+    if (typeof override === "string" && override.trim().length > 0) {
+        return override;
+    }
+    return opencodeWechatConfigDir();
+}
+function usesDefaultStateRoot(stateRoot = wechatStateRoot()) {
+    return stateRoot === opencodeWechatConfigDir();
+}
+export function brokerStatePath() {
+    return path.join(wechatStateRoot(), "broker.json");
+}
+export function brokerStateStorePath() {
+    return usesDefaultStateRoot() ? wechatBrokerStateStorePath() : path.join(wechatStateRoot(), "broker-state-store.json");
+}
+export function brokerStateSchemaPath() {
+    return path.join(wechatStateRoot(), "broker-state-store.schema.json");
+}
+export function wechatStatusRuntimeDiagnosticsPath(stateRoot = wechatStateRoot()) {
+    return usesDefaultStateRoot(stateRoot) ? defaultWechatStatusRuntimeDiagnosticsPath() : path.join(stateRoot, "wechat-status-runtime.diagnostics.jsonl");
+}
+export function brokerStartupDiagnosticsPath(stateRoot = wechatStateRoot()) {
+    return path.join(stateRoot, "broker-startup.diagnostics.log");
+}
+export function wechatBrokerDiagnosticsPath(stateRoot = wechatStateRoot()) {
+    return path.join(stateRoot, "wechat-broker.diagnostics.jsonl");
+}
+export function wechatBridgeDiagnosticsPath(stateRoot = wechatStateRoot()) {
+    return usesDefaultStateRoot(stateRoot) ? defaultWechatBridgeDiagnosticsPath() : path.join(stateRoot, "wechat-bridge.diagnostics.jsonl");
+}
+export function launchLockPath() {
+    return path.join(wechatStateRoot(), "launch.lock");
+}
+export function operatorStatePath() {
+    return usesDefaultStateRoot() ? wechatOperatorPath() : path.join(wechatStateRoot(), "operator.json");
+}
+export function instancesDir() {
+    return usesDefaultStateRoot() ? wechatInstancesDir() : path.join(wechatStateRoot(), "instances");
+}
+export function instanceStatePath(instanceID) {
+    return path.join(instancesDir(), `${instanceID}.json`);
+}
+export function tokensDir() {
+    return usesDefaultStateRoot() ? wechatTokensDir() : path.join(wechatStateRoot(), "tokens");
+}
+export function tokenStatePath(wechatAccountId, userId) {
+    return path.join(tokensDir(), wechatAccountId, `${userId}.json`);
+}
+export function latestAccountStatePath(stateRoot = wechatStateRoot()) {
+    return usesDefaultStateRoot(stateRoot) ? wechatLatestAccountPath() : path.join(stateRoot, "latest-account.json");
+}
+export function notificationsDir() {
+    return usesDefaultStateRoot() ? wechatNotificationsDir() : path.join(wechatStateRoot(), "notifications");
+}
+export function notificationStatePath(idempotencyKey) {
+    return path.join(notificationsDir(), `${idempotencyKey}.json`);
+}
+export function requestKindDir(kind) {
+    const requestsRoot = usesDefaultStateRoot() ? wechatRequestsDir() : path.join(wechatStateRoot(), "requests");
+    return path.join(requestsRoot, kind);
+}
+export function requestStatePath(kind, routeKey) {
+    return path.join(requestKindDir(kind), `${routeKey}.json`);
+}
+export function wechatDeadLetterRoot(stateRoot = wechatStateRoot()) {
+    return usesDefaultStateRoot(stateRoot) ? wechatDeadLetterDir() : path.join(stateRoot, "dead-letter");
+}
+export function wechatDeadLetterKindDir(kind, stateRoot = wechatStateRoot()) {
+    return path.join(wechatDeadLetterRoot(stateRoot), kind);
+}
+export function wechatDeadLetterPath(kind, routeKey, stateRoot = wechatStateRoot()) {
+    return path.join(wechatDeadLetterKindDir(kind, stateRoot), `${routeKey}.json`);
+}
+async function ensureDir(dirPath) {
+    await mkdir(dirPath, { recursive: true, mode: WECHAT_DIR_MODE });
+}
+export async function ensureWechatStateLayout() {
+    await ensureDir(wechatStateRoot());
+    await ensureDir(tokensDir());
+    await ensureDir(notificationsDir());
+    await ensureDir(instancesDir());
+    await ensureDir(wechatDeadLetterKindDir("question"));
+    await ensureDir(wechatDeadLetterKindDir("permission"));
+    await ensureDir(requestKindDir("question"));
+    await ensureDir(requestKindDir("permission"));
+}

package/dist/wechat/status-format.d.ts

@@ -0,0 +1,26 @@
+import type { BrokerAuthoritativeView } from "./broker-state-store.js";
+export type AggregatedStatusInstance = {
+    instanceID: string;
+    status: "ok";
+    snapshot: unknown;
+} | {
+    instanceID: string;
+    status: "timeout/unreachable";
+};
+type ActiveQuestionTodoItem = {
+    handle: string;
+    summary: string;
+    instanceID?: string;
+    createdAt?: number;
+};
+export type AggregatedStatusReplyInput = {
+    requestId: string;
+    instances: AggregatedStatusInstance[];
+    activeQuestions?: ActiveQuestionTodoItem[];
+};
+export declare function formatInstanceStatusSnapshot(snapshotInput: unknown): string;
+export declare function formatAggregatedStatusReply(input: AggregatedStatusReplyInput): string;
+export declare function buildAggregatedStatusInstancesFromBrokerView(view: BrokerAuthoritativeView | undefined): AggregatedStatusInstance[];
+export declare function formatAggregatedStatusReplyFromBrokerView(view: BrokerAuthoritativeView | undefined): string;
+export declare function formatTodoReplyFromBrokerView(view: BrokerAuthoritativeView | undefined): string;
+export {};