feique 1.3.3 → 1.4.0

package/dist/bridge/service.d.ts

@@ -1,42 +1,60 @@
-import type { BridgeConfig } from '../config/schema.js';
+import type { BridgeConfig, ProjectConfig } from '../config/schema.js';
 import type { IncomingCardActionContext, IncomingMessageContext } from './types.js';
 import { SessionStore } from '../state/session-store.js';
 import type { Logger } from '../logging.js';
-import { FeishuClient } from '../feishu/client.js';
+import { FeishuClient, type FeishuMessageResponse } from '../feishu/client.js';
+import { TaskQueue } from './task-queue.js';
 import { AuditLog } from '../state/audit-log.js';
 import type { MetricsRegistry } from '../observability/metrics.js';
 import { IdempotencyStore } from '../state/idempotency-store.js';
 import { RunStateStore, type RunState } from '../state/run-state-store.js';
 import { MemoryStore } from '../state/memory-store.js';
+import type { MemoryContext } from '../memory/retrieve.js';
 import { CodexSessionIndex } from '../codex/session-index.js';
-import { ConfigHistoryStore } from '../state/config-history-store.js';
+import type { Backend, BackendName } from '../backend/types.js';
+import { type FailoverInfo } from '../backend/factory.js';
+import { ConfigHistoryStore, type ConfigSnapshot } from '../state/config-history-store.js';
 import { HandoffStore } from '../state/handoff-store.js';
 import { TrustStore } from '../state/trust-store.js';
+export interface ActiveRunHandle {
+    runId: string;
+    controller: AbortController;
+    pid?: number;
+    cancelReason?: 'user' | 'timeout' | 'recovery';
+}
 interface RuntimeControl {
     configPath?: string;
     restart?: () => Promise<void>;
 }
+interface RunReplyTarget {
+    messageId?: string;
+    mode: BridgeConfig['service']['reply_mode'];
+}
 export declare class FeiqueService {
-    private config;
-    private readonly feishuClient;
-    private readonly sessionStore;
-    private readonly auditLog;
-    private readonly logger;
-    private readonly metrics?;
+    config: BridgeConfig;
+    readonly feishuClient: FeishuClient;
+    readonly sessionStore: SessionStore;
+    readonly auditLog: AuditLog;
+    readonly logger: Logger;
+    readonly metrics?: MetricsRegistry | undefined;
     private readonly idempotencyStore;
-    private readonly runStateStore;
-    private readonly memoryStore;
-    private readonly codexSessionIndex;
-    private readonly runtimeControl?;
-    private readonly adminAuditLog;
-    private readonly configHistoryStore;
-    private readonly handoffStore;
-    private readonly trustStore;
-    private readonly queue;
-    private readonly projectRootQueue;
-    private readonly activeRuns;
-    private readonly runReplyTargets;
+    readonly runStateStore: RunStateStore;
+    readonly memoryStore: MemoryStore;
+    readonly codexSessionIndex: CodexSessionIndex;
+    readonly runtimeControl?: RuntimeControl | undefined;
+    readonly adminAuditLog: AuditLog;
+    readonly configHistoryStore: ConfigHistoryStore;
+    readonly handoffStore: HandoffStore;
+    readonly trustStore: TrustStore;
+    readonly queue: TaskQueue;
+    readonly projectRootQueue: TaskQueue;
+    readonly activeRuns: Map<string, ActiveRunHandle>;
+    readonly runReplyTargets: Map<string, RunReplyTarget>;
     private readonly chatRateWindows;
+    /** Dedupe admin notifications for backend failover: one alert per (from→to) direction per process lifetime. */
+    private readonly failoverNotified;
+    /** Dedupe rejected-chat notifications: one reply + one admin alert per chat_id per process lifetime. */
+    private readonly rejectedChatNotified;
     private maintenanceTimer?;
     private digestTimer?;
     private configWatcher?;
@@ -45,15 +63,6 @@ export declare class FeiqueService {
     private currentMessageContext?;
     constructor(config: BridgeConfig, feishuClient: FeishuClient, sessionStore: SessionStore, auditLog: AuditLog, logger: Logger, metrics?: MetricsRegistry | undefined, idempotencyStore?: IdempotencyStore, runStateStore?: RunStateStore, memoryStore?: MemoryStore, codexSessionIndex?: CodexSessionIndex, runtimeControl?: RuntimeControl | undefined, adminAuditLog?: AuditLog, configHistoryStore?: ConfigHistoryStore, handoffStore?: HandoffStore, trustStore?: TrustStore);
     recoverRuntimeState(): Promise<RunState[]>;
-    /**
-     * Reload config from disk with validation, diff, and admin notification.
-     *
-     * Flow:
-     * 1. Parse new config — if invalid, reject and notify admin with error
-     * 2. Diff against current config — identify what changed
-     * 3. Apply new config to memory
-     * 4. Notify admin chat(s) with change summary
-     */
     reloadConfig(configPath: string): Promise<{
         ok: boolean;
         error?: string;
@@ -97,14 +106,13 @@ export declare class FeiqueService {
     private handleInsightsCommand;
     private handleTrustCommand;
     private handleDigestCommand;
-    private checkAndSendAlerts;
+    checkAndSendAlerts(completedRun: RunState): Promise<void>;
     private handleGapsCommand;
     private handleTimelineCommand;
     private handleAdminCommand;
     private handleSessionAdoptCommand;
     private handleBackendCommand;
     private handleMemoryCommand;
-    private renderMemoryFilterLines;
     private handleKnowledgeCommand;
     private handleDocCommand;
     private handleTaskCommand;
@@ -114,21 +122,15 @@ export declare class FeiqueService {
     private buildStatusText;
     private buildDetailedStatusText;
     private buildStatusCardFromConversation;
-    private buildBridgePrompt;
+    buildBridgePrompt(projectAlias: string, project: ProjectConfig, incomingMessage: IncomingMessageContext, userPrompt: string, memoryContext: MemoryContext): Promise<string>;
     private requireProject;
     private resolveProjectAlias;
     private resolveProjectContext;
     private getSelectionConversationKey;
     private getSelectionScope;
     private shouldRequireMention;
-    private resolveMemoryTarget;
-    private buildMemoryExpiresAt;
     private cancelActiveRun;
     private scheduleProjectExecution;
-    private prepareQueuedExecution;
-    private buildAcknowledgedRunReply;
-    private buildQueuedStatusDetail;
-    private buildRunStatusSummary;
     private isAdminChat;
     private buildAdminStatusText;
     private buildAdminListText;
@@ -143,43 +145,89 @@ export declare class FeiqueService {
     private canObserveRuns;
     private canRestartService;
     private canMutateRuntimeConfig;
-    private canReadConfigHistory;
     private canAccessAdminCommand;
     private commandRequiresWritableConfig;
     private handleAdminConfigCommand;
-    private snapshotConfigForAdminMutation;
-    private appendAdminAudit;
-    private reloadRuntimeConfigFromDisk;
-    private parseProjectPatch;
+    snapshotConfigForAdminMutation(context: IncomingMessageContext, action: string, summary?: string): Promise<ConfigSnapshot>;
+    appendAdminAudit(event: {
+        type: string;
+        [key: string]: unknown;
+    }): Promise<void>;
+    reloadRuntimeConfigFromDisk(configPath: string): Promise<void>;
     private resolveProjectDownloadDir;
-    private resolveProjectTempDir;
-    private resolveProjectCacheDir;
-    private appendProjectAuditEvent;
-    private notifyProjectChats;
-    private listManagedAuditTargets;
+    resolveProjectTempDir(projectAlias: string, project: ProjectConfig): string;
+    resolveProjectCacheDir(projectAlias: string, project: ProjectConfig): string;
+    appendProjectAuditEvent(projectAlias: string, project: ProjectConfig, event: {
+        type: string;
+        [key: string]: unknown;
+    }): Promise<void>;
+    notifyProjectChats(projectAlias: string, text: string): Promise<void>;
     private checkAndConsumeChatRateLimit;
     private applyAdminListValues;
-    private resolveProjectRoot;
-    private resolveBackendByName;
-    private enforceSessionHistoryLimit;
-    private sendTextReply;
+    resolveBackendByName(projectAlias: string, sessionOverride?: BackendName): Backend;
+    /**
+     * Called when resolveProjectBackendWithFailover returns a non-null failover.
+     * Responsibilities:
+     *   - Log a warning with structured context
+     *   - Emit an audit event
+     *   - Notify admin chats (deduped by from→to direction for the process lifetime)
+     *   - Send a user-visible notice into the current chat so the user knows
+     *     why their run is on a different backend than expected
+     */
+    handleBackendFailover(chatId: string, projectAlias: string, runId: string, info: FailoverInfo): Promise<void>;
+    /**
+     * Called by the transport layer when an incoming chat is rejected by the
+     * allowlist (`feishu.allowed_chat_ids` / `allowed_group_ids`).
+     *
+     * Replaces the previous "silent drop" behavior with a pairing-style
+     * experience: tell the user what their chat_id is so an admin can add it,
+     * notify admins that a new chat is knocking, and record the rejection in
+     * the audit log. Deduped per chat_id for the process lifetime so repeated
+     * attempts from the same unauthorized chat do not spam either side.
+     *
+     * This is best-effort: any send failure is swallowed. We never want a
+     * rejection flow to throw out of the transport dispatcher.
+     */
+    handleRejectedChat(chatId: string, chatType: 'p2p' | 'group' | 'unknown'): Promise<void>;
+    enforceSessionHistoryLimit(conversationKey: string, projectAlias: string): Promise<void>;
+    sendTextReply(chatId: string, body: string, replyToMessageId?: string, originalText?: string, presentation?: {
+        status?: string;
+        phase?: string;
+        projectAlias?: string;
+    }, mentionActor?: {
+        chat_type?: string;
+        actor_id?: string;
+        actor_name?: string;
+    }): Promise<FeishuMessageResponse>;
     private sendCardReply;
     private sendRunLifecycleReply;
     private buildInitialRunLifecycleReply;
     private sendInitialRunLifecycleReply;
     private rememberRunReplyTarget;
-    private updateRunStartedReply;
-    private updateRunProgressReply;
-    private sendOrUpdateRunOutcome;
+    updateRunStartedReply(chatId: string, projectAlias: string, runId: string, backendLabel?: string): Promise<void>;
+    updateRunProgressReply(input: {
+        chatId: string;
+        projectAlias: string;
+        prompt: string;
+        sessionKey: string;
+        replyToMessageId?: string;
+    }, runId: string, progress: string, backendLabel?: string): Promise<void>;
+    sendOrUpdateRunOutcome(input: {
+        input: {
+            chatId: string;
+            projectAlias: string;
+            sessionKey: string;
+            prompt: string;
+            replyToMessageId?: string;
+        };
+        runId: string;
+        title: string;
+        body: string;
+        runStatus: 'success' | 'failure' | 'cancelled';
+        runPhase?: string;
+        cardSummary: string;
+        sessionId?: string;
+    }): Promise<void>;
     private updateRunLifecycleReply;
-    private formatQuotedReply;
-    private buildReplyTitle;
-    private sanitizeUserVisibleReply;
-    private supportsInteractiveCardActions;
-    private resolveRunLifecycleReplyMode;
-    private buildRunLifecycleCard;
-    private stripLifecycleMetadata;
 }
-export declare function buildQueueKey(conversationKey: string, projectAlias: string): string;
-export declare function buildProjectRootQueueKey(projectRoot: string): string;
-export {};
+export { buildQueueKey, buildProjectRootQueueKey } from './service-utils.js';