opencode-oncall 0.1.0

package/dist/wechat/broker-state-store.d.ts

@@ -0,0 +1,335 @@
+import type { BrokerAckPayload, BrokerCommandStatus, BrokerToBridgeCommandType, BrokerToBridgeControlType, BridgeToBrokerEvent } from "./protocol.js";
+type UnknownRecord = Record<string, unknown>;
+export declare const BROKER_STATE_SCHEMA_MARKER_KIND = "wechat-broker-state-store";
+export declare const LEGACY_STATE_RESET_UPGRADE_CLOSE_REASON = "legacy-state-reset-awaiting-full-sync";
+export type BrokerStateSchemaMarker = {
+    kind?: string;
+    protocolVersion: number;
+    stateGeneration: string;
+    updatedAt: number;
+    upgradeCloseReason?: string;
+    legacyHandleClosures?: string[];
+};
+export type PrepareBrokerStateStoreForStartupInput = {
+    protocolVersion: number;
+    stateGeneration: string;
+    now?: () => number;
+};
+export type PrepareBrokerStateStoreForStartupResult = {
+    state: BrokerState;
+    recoveredFromLegacyState: boolean;
+    legacyHandleClosures: string[];
+};
+export type BrokerConnectionState = {
+    instanceID: string;
+    instanceIncarnation: string;
+    online: boolean;
+    lastEventSeq: number;
+    lastAckedEventSeq: number;
+    lastSentBrokerSeq: number;
+    lastObservedAt?: number;
+    connectedAt?: number;
+    disconnectedAt?: number;
+    disconnectReason?: string;
+};
+export type BrokerConnectionScope = {
+    instanceID: string;
+    instanceIncarnation: string;
+};
+export type BrokerActiveState = {
+    instances: Record<string, UnknownRecord>;
+    sessions: Record<string, UnknownRecord>;
+    questions: Record<string, UnknownRecord>;
+    permissions: Record<string, UnknownRecord>;
+    naturalStops: Record<string, UnknownRecord>;
+    retryErrors: Record<string, UnknownRecord>;
+};
+export type BrokerTerminalMetadata = {
+    reason: string;
+    replacementHandle?: string;
+    terminalResultSent?: boolean;
+    retainedUntil?: number;
+    handle?: string;
+    requestID?: string;
+    scopeKey?: string;
+    prompt?: unknown;
+    wechatAccountId?: string;
+    userId?: string;
+    createdAt?: number;
+    answeredAt?: number;
+    rejectedAt?: number;
+    expiredAt?: number;
+    cleanedAt?: number;
+};
+export type BrokerRetainedOccupancy = {
+    handle: string;
+    retainedUntil: number;
+};
+export type BrokerIndexedRequestRecord = {
+    kind: "question" | "permission";
+    requestID: string;
+    routeKey: string;
+    handle: string;
+    scopeKey?: string;
+    prompt?: unknown;
+    wechatAccountId: string;
+    userId: string;
+    status: "open" | "answered" | "rejected" | "expired" | "cleaned";
+    createdAt: number;
+    answeredAt?: number;
+    rejectedAt?: number;
+    expiredAt?: number;
+    cleanedAt?: number;
+    terminalReason?: "answered" | "handled" | "rejected" | "expired" | "replaced";
+    replacementHandle?: string;
+    terminalResultSent?: boolean;
+};
+export type BrokerDeliveryTokenState = {
+    wechatAccountId: string;
+    userId: string;
+    contextToken: string;
+    updatedAt: number;
+    source: "question" | "permission" | "message";
+    sourceRef?: string;
+    staleReason?: string;
+};
+export type BrokerRuntimeExpiredRequest = BrokerIndexedRequestRecord;
+export type BrokerRuntimeClosedNaturalStop = {
+    handle: string;
+    scopeKey?: string;
+    idempotencyKey?: string;
+    terminalReason: string;
+};
+export type BrokerRuntimeCleanupResult = {
+    cleanedRequests: BrokerIndexedRequestRecord[];
+    purgedRequests: BrokerIndexedRequestRecord[];
+};
+export type BrokerLegacyHandleKind = "question" | "permission" | "naturalStop";
+export type BrokerLegacyHandleClosure = {
+    kind: BrokerLegacyHandleKind;
+    handle: string;
+    reason: string;
+    message?: string;
+    replacementHandle?: string;
+    routeKey?: string;
+    retainedUntil?: number;
+};
+export type BrokerCommandRecord = {
+    commandId: string;
+    brokerSeq: number;
+    type: BrokerToBridgeCommandType;
+    target: UnknownRecord;
+    payload?: unknown;
+    status: BrokerCommandStatus;
+    acceptedAt?: number;
+    completedAt?: number;
+    failure?: UnknownRecord;
+    instanceID?: string;
+    instanceIncarnation?: string;
+    acceptedEventSeq?: number;
+    resultEventSeq?: number;
+};
+export type BrokerControlStatus = "inFlight" | "completed";
+export type BrokerControlRecord = {
+    controlId: string;
+    brokerSeq: number;
+    type: BrokerToBridgeControlType;
+    status: BrokerControlStatus;
+    instanceID: string;
+    instanceIncarnation: string;
+    fromEventSeq?: number;
+    toEventSeq?: number;
+    reason?: string;
+    completedEventSeq?: number;
+};
+export type BrokerFullSyncStage = {
+    controlId: string;
+    instanceID: string;
+    instanceIncarnation: string;
+    state: BrokerState;
+};
+export type BrokerFullSyncSnapshot = {
+    connections?: Record<string, Record<string, BrokerConnectionState>>;
+    active: BrokerActiveState;
+};
+export type BrokerState = {
+    connections: Record<string, Record<string, BrokerConnectionState>>;
+    active: BrokerActiveState;
+    terminalMetadata: Record<string, BrokerTerminalMetadata>;
+    retainedOccupancy: Record<string, BrokerRetainedOccupancy>;
+    legacyHandleClosures: Record<string, BrokerLegacyHandleClosure>;
+    requestIndex: Record<string, BrokerIndexedRequestRecord>;
+    deliveryTokens: Record<string, BrokerDeliveryTokenState>;
+    commandLedger: Record<string, BrokerCommandRecord>;
+    controlLedger: Record<string, BrokerControlRecord>;
+    fullSync: {
+        lastCompletedControlId?: string;
+        lastCompletedEventSeq?: number;
+        lastCompletedInstanceIncarnation?: string;
+        stagedByControlId: Record<string, BrokerFullSyncStage>;
+    };
+};
+export type UpsertBrokerCommandInput = {
+    commandId: string;
+    brokerSeq: number;
+    type: BrokerToBridgeCommandType;
+    status: "queued" | "delivered";
+    target: UnknownRecord;
+    payload?: unknown;
+    instanceID?: string;
+    instanceIncarnation?: string;
+};
+export type RequestBrokerReplayInput = {
+    controlId: string;
+    brokerSeq: number;
+    instanceID: string;
+    instanceIncarnation: string;
+    fromEventSeq: number;
+    toEventSeq: number;
+};
+export type MarkBrokerReplayCompletedInput = {
+    controlId: string;
+    completedEventSeq: number;
+};
+export type RequestBrokerFullSyncInput = {
+    controlId: string;
+    brokerSeq: number;
+    instanceID: string;
+    instanceIncarnation: string;
+    reason: string;
+};
+export type StageBrokerFullSyncEventInput = {
+    controlId: string;
+    event: BridgeToBrokerEvent;
+    context?: ApplyBridgeEventContext;
+};
+export type MarkBrokerFullSyncCompletedInput = {
+    controlId: string;
+    instanceID: string;
+    instanceIncarnation: string;
+    eventSeq: number;
+};
+export type MarkBrokerCommandAcceptedInput = {
+    commandId: string;
+    instanceID: string;
+    instanceIncarnation: string;
+    eventSeq: number;
+    acceptedAt?: number;
+};
+export type MarkBrokerCommandResultInput = {
+    commandId: string;
+    instanceID: string;
+    instanceIncarnation: string;
+    eventSeq: number;
+    status: "completed" | "failed";
+    completedAt?: number;
+    failure?: UnknownRecord;
+};
+export type UpsertRetryErrorSummaryInput = {
+    instanceID: string;
+    sessionID?: string;
+    action: string;
+    redactedSummary: string;
+    severityAdvice: string;
+    updatedAt?: number;
+    instanceIncarnation?: string;
+};
+export type MarkConnectionAckedEventSeqInput = BrokerAckPayload & {
+    instanceID: string;
+};
+export type MarkConnectionSentBrokerSeqInput = BrokerConnectionScope & {
+    brokerSeq: number;
+};
+export type ApplyBridgeEventContext = {
+    instanceID?: string;
+};
+export type BrokerAuthoritativeView = {
+    connections: Record<string, Record<string, BrokerConnectionState>>;
+    active: BrokerActiveState;
+    terminalMetadata: Record<string, BrokerTerminalMetadata>;
+    retainedOccupancy: Record<string, BrokerRetainedOccupancy>;
+    commandLedger: Record<string, BrokerCommandRecord>;
+    legacyHandleClosures: Record<string, BrokerLegacyHandleClosure>;
+};
+export type BrokerCommandActionInput = {
+    type: BrokerToBridgeCommandType;
+    target: UnknownRecord;
+    payload?: unknown;
+};
+export declare function persistBrokerStateStoreSnapshot(state: BrokerState): Promise<void>;
+export declare function loadBrokerStateStoreSnapshot(): Promise<BrokerState | undefined>;
+export declare function loadBrokerStateStoreForMutation(): Promise<BrokerState>;
+export declare function setBrokerStateMutationTarget(state: BrokerState | undefined): void;
+export declare function readBrokerStateSchemaMarker(): Promise<BrokerStateSchemaMarker | undefined>;
+export declare function writeBrokerStateSchemaMarker(input: BrokerStateSchemaMarker): Promise<BrokerStateSchemaMarker>;
+export declare function prepareBrokerStateStoreForStartup(input: PrepareBrokerStateStoreForStartupInput): Promise<PrepareBrokerStateStoreForStartupResult>;
+export declare function readBrokerStateUpgradeCloseReason(handle: string): Promise<string | undefined>;
+export declare function createEmptyBrokerState(options?: {
+    track?: boolean;
+}): BrokerState;
+export declare function writeLegacyHandleClosure(state: BrokerState, input: BrokerLegacyHandleClosure): BrokerLegacyHandleClosure;
+export declare function readLegacyHandleClosure(state: BrokerState | undefined, input: {
+    kind: BrokerLegacyHandleKind;
+    handle: string;
+}): BrokerLegacyHandleClosure | undefined;
+export declare function applyBridgeEvent<TPayload = unknown>(state: BrokerState, event: BridgeToBrokerEvent<TPayload>, context?: ApplyBridgeEventContext): BrokerState;
+export declare function applyFullSyncSnapshot(state: BrokerState, scope: BrokerConnectionScope, snapshot: BrokerFullSyncSnapshot): BrokerState;
+export declare function upsertBrokerCommand(state: BrokerState, input: UpsertBrokerCommandInput): BrokerCommandRecord;
+export declare function reconcileBrokerActiveRequestHandlesWithVisibleNotifications(state: BrokerState): Promise<BrokerState>;
+export declare function readBrokerControlRecord(state: BrokerState, controlId: string): BrokerControlRecord | undefined;
+export declare function upsertRetryErrorSummary(state: BrokerState, input: UpsertRetryErrorSummaryInput): UnknownRecord;
+export declare function upsertBrokerIndexedRequest(state: BrokerState, input: BrokerIndexedRequestRecord): BrokerIndexedRequestRecord;
+export declare function readBrokerIndexedRequest(input: {
+    kind: "question" | "permission";
+    routeKey: string;
+}, state?: BrokerState): Promise<BrokerIndexedRequestRecord | undefined>;
+export declare function upsertBrokerDeliveryToken(state: BrokerState, input: BrokerDeliveryTokenState): BrokerDeliveryTokenState;
+export declare function readBrokerDeliveryToken(input: {
+    wechatAccountId: string;
+    userId: string;
+}, state?: BrokerState): Promise<BrokerDeliveryTokenState | undefined>;
+export declare function expireBrokerIndexedRequestsForScope(state: BrokerState, input: {
+    scopeKey: string;
+    expiredAt: number;
+}): BrokerRuntimeExpiredRequest[];
+export declare function closeBrokerNaturalStopsForScope(state: BrokerState, input: {
+    scopeKey: string;
+    terminalReason: string;
+}): BrokerRuntimeClosedNaturalStop[];
+export declare function clearBrokerActiveScope(state: BrokerState, input: {
+    scopeKey: string;
+}): void;
+export declare function removeBrokerConnectionScope(state: BrokerState, input: BrokerConnectionScope): void;
+export declare function reconcileBrokerDisconnectedScopes(state: BrokerState, input: {
+    disconnectedAt: number;
+}): void;
+export declare function cleanupBrokerRuntimeTerminalRequests(state: BrokerState, input: {
+    now: number;
+    cleanAfterMs: number;
+    purgeRetentionMs: number;
+}): BrokerRuntimeCleanupResult;
+export declare function markBrokerConnectionObserved(state: BrokerState, input: BrokerConnectionScope & {
+    observedAt: number;
+    connectedAt?: number;
+}): BrokerConnectionState;
+export declare function markBrokerConnectionOffline(state: BrokerState, input: BrokerConnectionScope & {
+    disconnectedAt: number;
+    reason: string;
+}): BrokerConnectionState;
+export declare function listTimedOutBrokerConnectionScopes(state: BrokerState, input: {
+    now: number;
+    timeoutMs: number;
+}): BrokerConnectionScope[];
+export declare function readBrokerAuthoritativeView(state?: BrokerState): BrokerAuthoritativeView;
+export declare function readBrokerCommandStateByAction(input: BrokerCommandActionInput, state?: BrokerState): BrokerCommandRecord | undefined;
+export declare function readBrokerFullSyncStage(state: BrokerState, controlId: string): BrokerState | undefined;
+export declare function requestBrokerReplay(state: BrokerState, input: RequestBrokerReplayInput): BrokerControlRecord;
+export declare function markBrokerReplayCompleted(state: BrokerState, input: MarkBrokerReplayCompletedInput): BrokerControlRecord;
+export declare function requestBrokerFullSync(state: BrokerState, input: RequestBrokerFullSyncInput): BrokerControlRecord;
+export declare function stageBrokerFullSyncEvent(state: BrokerState, input: StageBrokerFullSyncEventInput): BrokerState;
+export declare function markBrokerFullSyncCompleted(state: BrokerState, input: MarkBrokerFullSyncCompletedInput): BrokerControlRecord;
+export declare function markBrokerCommandAccepted(state: BrokerState, input: MarkBrokerCommandAcceptedInput): BrokerCommandRecord;
+export declare function markBrokerCommandResult(state: BrokerState, input: MarkBrokerCommandResultInput): BrokerCommandRecord;
+export declare function markConnectionAckedEventSeq(state: BrokerState, input: MarkConnectionAckedEventSeqInput): BrokerConnectionState;
+export declare function markConnectionSentBrokerSeq(state: BrokerState, input: MarkConnectionSentBrokerSeqInput): BrokerConnectionState;
+export {};