@gloablehive/celphone-wechat-plugin 1.0.0

package/dist/src/cache/manager.js

@@ -0,0 +1,271 @@
+/**
+ * Cache Manager - Main cache management
+ *
+ * Ties together all cache modules:
+ * - Writer (file operations)
+ * - Indexer (MEMORY.md)
+ * - Extractor (AI summary)
+ * - Compactor (4-layer compression)
+ * - Syncer (cloud sync)
+ * - SAAS Connector (offline fallback)
+ * - Message Queue (offline retry)
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { DEFAULT_COMPACT_CONFIG } from './types.js';
+import { DEFAULT_EXTRACTOR_CONFIG } from './extractor.js';
+import { getAccountCachePath } from './types.js';
+// Import all modules
+import * as writer from './writer.js';
+import * as indexer from './indexer.js';
+import * as extractor from './extractor.js';
+import * as compactor from './compactor.js';
+import { CloudSyncer, createSyncer } from './syncer.js';
+import { SAASConnector, createSAASConnector } from './saas-connector.js';
+import { MessageQueue, createMessageQueue } from './message-queue.js';
+/**
+ * Cache Manager class
+ */
+export class CacheManager {
+    basePath;
+    accounts;
+    compactConfig;
+    extractorConfig;
+    syncer = null;
+    saasConnector = null;
+    messageQueue = null;
+    messageCounts = new Map();
+    lastExtractionCounts = new Map();
+    constructor(options) {
+        this.basePath = options.basePath;
+        this.accounts = options.accounts;
+        this.compactConfig = { ...DEFAULT_COMPACT_CONFIG, ...options.compactConfig };
+        this.extractorConfig = { ...DEFAULT_EXTRACTOR_CONFIG, ...options.extractorConfig };
+    }
+    /**
+     * Initialize cache manager
+     */
+    async init() {
+        // Ensure base directories exist
+        await fs.mkdir(this.basePath, { recursive: true });
+        // Initialize for each account
+        for (const account of this.accounts) {
+            const accountPath = getAccountCachePath(this.basePath, account.accountId);
+            await fs.mkdir(path.join(accountPath, 'friends'), { recursive: true });
+            await fs.mkdir(path.join(accountPath, 'chatrooms'), { recursive: true });
+            await fs.mkdir(path.join(accountPath, 'profiles'), { recursive: true });
+            await fs.mkdir(path.join(accountPath, 'logs'), { recursive: true });
+        }
+        // Initialize cloud syncer
+        if (this.accounts.length > 0) {
+            this.syncer = createSyncer({
+                databaseUrl: '',
+                syncMode: 'interval',
+                syncIntervalMs: 5 * 60 * 1000, // 5 minutes
+                lastSyncTimestamp: 0,
+                ...this.options?.syncConfig,
+            }, path.join(this.basePath, 'sync-logs'));
+        }
+        // Initialize SAAS connector
+        if (this.options?.saasConfig?.apiBaseUrl) {
+            this.saasConnector = createSAASConnector(this.options.saasConfig);
+            this.saasConnector.startHealthCheck();
+        }
+        // Initialize message queue
+        this.messageQueue = createMessageQueue(path.join(this.basePath, 'message-queue'));
+        await this.messageQueue.init();
+        // Rebuild indexes
+        await indexer.rebuildAllIndexes(this.basePath, this.accounts);
+        console.log('[CacheManager] Initialized for', this.accounts.length, 'accounts');
+    }
+    /**
+     * Handle incoming message
+     */
+    async onMessage(message) {
+        const key = `${message.accountId}:${message.conversationId}`;
+        // Update message count
+        const count = this.messageCounts.get(key) || 0;
+        this.messageCounts.set(key, count + 1);
+        // Write to conversation file
+        await writer.ensureConversationDir(this.basePath, message.accountId, message.conversationType, message.conversationId);
+        const conversationPath = writer.getConversationFilePath(this.basePath, message.accountId, message.conversationType, message.conversationId, new Date(message.timestamp));
+        const exists = await writer.conversationFileExists(conversationPath);
+        if (!exists) {
+            await writer.createConversationFile(conversationPath, message.conversationId, message.accountId, '', message.conversationType);
+        }
+        await writer.appendMessageToConversation(conversationPath, message);
+        // Check for AI extraction
+        await this.checkExtraction(message);
+        // Check for compaction
+        await this.checkCompaction(message);
+        // Queue for sync
+        if (this.messageQueue) {
+            await this.messageQueue.enqueue(message);
+        }
+        // Try to sync to SAAS if online
+        if (this.saasConnector?.isOnline()) {
+            try {
+                await this.saasConnector.syncMessage(message);
+            }
+            catch (error) {
+                console.error('[CacheManager] SAAS sync error:', error);
+            }
+        }
+        // Rebuild index for account
+        const account = this.accounts.find(a => a.accountId === message.accountId);
+        if (account) {
+            await indexer.rebuildAccountIndex(this.basePath, account);
+        }
+    }
+    /**
+     * Check if extraction should run
+     */
+    async checkExtraction(message) {
+        const key = `${message.accountId}:${message.conversationId}`;
+        const messageCount = this.messageCounts.get(key) || 0;
+        const lastExtraction = this.lastExtractionCounts.get(key) || 0;
+        if (extractor.shouldExtract(this.extractorConfig, messageCount - lastExtraction, 0)) {
+            // Would run extraction via LLM
+            console.log('[CacheManager] Should extract for', key);
+            // Update last extraction count
+            this.lastExtractionCounts.set(key, messageCount);
+        }
+    }
+    /**
+     * Check if compaction should run
+     */
+    async checkCompaction(message) {
+        const conversationPath = writer.getConversationFilePath(this.basePath, message.accountId, message.conversationType, message.conversationId, new Date(message.timestamp));
+        const tokenEstimate = await compactor.estimateConversationTokens(conversationPath);
+        await compactor.runCompaction(this.compactConfig, conversationPath, tokenEstimate);
+    }
+    // ========== Profile Operations ==========
+    /**
+     * Get user profile (with offline fallback)
+     */
+    async getProfile(accountId, wechatId) {
+        const profilePath = writer.getProfileFilePath(this.basePath, accountId, wechatId);
+        // Try local first
+        let profile = await writer.readProfile(profilePath);
+        // If online and no local profile, try SAAS
+        if (!profile && this.saasConnector?.isOnline()) {
+            try {
+                const saasProfile = await this.saasConnector.queryUserProfile(wechatId);
+                if (saasProfile) {
+                    // Cache locally
+                    await writer.writeProfile(profilePath, saasProfile);
+                    return saasProfile;
+                }
+            }
+            catch {
+                // Fallback to local
+            }
+        }
+        return profile;
+    }
+    /**
+     * Update user profile
+     */
+    async updateProfile(accountId, wechatId, updates) {
+        const profilePath = writer.getProfileFilePath(this.basePath, accountId, wechatId);
+        await writer.updateProfileFields(profilePath, {
+            ...updates,
+            accountId,
+            wechatId,
+        });
+        // Rebuild index
+        const account = this.accounts.find(a => a.accountId === accountId);
+        if (account) {
+            await indexer.rebuildAccountIndex(this.basePath, account);
+        }
+    }
+    // ========== Session Memory ==========
+    /**
+     * Write session memory
+     */
+    async writeSessionMemory(accountId, conversationId, session) {
+        const sessionPath = writer.getSessionMemoryPath(this.basePath, accountId, conversationId);
+        await writer.writeSessionMemory(sessionPath, session);
+    }
+    /**
+     * Read session memory
+     */
+    async readSessionMemory(accountId, conversationId) {
+        const sessionPath = writer.getSessionMemoryPath(this.basePath, accountId, conversationId);
+        return await writer.readSessionMemory(sessionPath);
+    }
+    // ========== SAAS Operations ==========
+    /**
+     * Get SAAS connection status
+     */
+    getConnectionStatus() {
+        return this.saasConnector?.getConnectionStatus();
+    }
+    /**
+     * Check if SAAS is online
+     */
+    isSAASOnline() {
+        return this.saasConnector?.isOnline() ?? false;
+    }
+    /**
+     * Get offline message
+     */
+    getOfflineMessage() {
+        return this.saasConnector?.getOfflineMessage() ?? '服务暂时不可用';
+    }
+    // ========== Sync Operations ==========
+    /**
+     * Run sync
+     */
+    async runSync() {
+        if (!this.syncer || !this.syncer.shouldSync())
+            return;
+        await this.syncer.syncIncremental();
+    }
+    /**
+     * Process message queue
+     */
+    async processQueue() {
+        if (!this.messageQueue || !this.saasConnector?.isOnline())
+            return;
+        const pending = this.messageQueue.getPending();
+        for (const queued of pending) {
+            try {
+                await this.saasConnector.syncMessage(queued.message);
+                await this.messageQueue.markAsSynced(queued.id);
+            }
+            catch (error) {
+                await this.messageQueue.markAsFailed(queued.id, error.message);
+            }
+        }
+    }
+    // ========== Index Operations ==========
+    /**
+     * Rebuild all indexes
+     */
+    async rebuildIndexes() {
+        await indexer.rebuildAllIndexes(this.basePath, this.accounts);
+    }
+    // ========== Cleanup ==========
+    /**
+     * Shutdown cache manager
+     */
+    async shutdown() {
+        this.saasConnector?.stopHealthCheck();
+        // Process remaining queue
+        await this.processQueue();
+        console.log('[CacheManager] Shutdown complete');
+    }
+    // Private options storage
+    options;
+}
+/**
+ * Create cache manager instance
+ */
+export function createCacheManager(options) {
+    const manager = new CacheManager(options);
+    manager['options'] = options;
+    return manager;
+}
+export { writer, indexer, extractor, compactor };
+export { CloudSyncer, SAASConnector, MessageQueue };

package/dist/src/cache/message-queue.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Message Queue - Offline message retry
+ *
+ * Store messages locally when offline, retry when back online
+ */
+import { QueuedMessage, WeChatMessage } from './types.js';
+/**
+ * Message Queue class
+ */
+export declare class MessageQueue {
+    private queuePath;
+    private queue;
+    constructor(queuePath: string);
+    /**
+     * Initialize queue (load from disk)
+     */
+    init(): Promise<void>;
+    /**
+     * Enqueue a message for sync
+     */
+    enqueue(message: WeChatMessage): Promise<string>;
+    /**
+     * Get pending messages
+     */
+    getPending(): QueuedMessage[];
+    /**
+     * Mark message as synced
+     */
+    markAsSynced(id: string): Promise<void>;
+    /**
+     * Mark message as failed
+     */
+    markAsFailed(id: string, error: string): Promise<void>;
+    /**
+     * Get queue statistics
+     */
+    getStats(): {
+        pending: number;
+        synced: number;
+        failed: number;
+        total: number;
+    };
+    /**
+     * Persist queue item to disk
+     */
+    private persist;
+    /**
+     * Delete queue item from disk
+     */
+    private delete;
+    /**
+     * Clean up old synced messages
+     */
+    cleanup(maxAge?: number): Promise<number>;
+}
+/**
+ * Create message queue instance
+ */
+export declare function createMessageQueue(queuePath: string): MessageQueue;

package/dist/src/cache/message-queue.js

@@ -0,0 +1,147 @@
+/**
+ * Message Queue - Offline message retry
+ *
+ * Store messages locally when offline, retry when back online
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+const ENCODING = 'utf-8';
+/**
+ * Message Queue class
+ */
+export class MessageQueue {
+    queuePath;
+    queue;
+    constructor(queuePath) {
+        this.queuePath = queuePath;
+        this.queue = new Map();
+    }
+    /**
+     * Initialize queue (load from disk)
+     */
+    async init() {
+        try {
+            const files = await fs.readdir(this.queuePath);
+            for (const file of files) {
+                if (!file.endsWith('.json'))
+                    continue;
+                const content = await fs.readFile(path.join(this.queuePath, file), ENCODING);
+                const queued = JSON.parse(content);
+                this.queue.set(queued.id, queued);
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                console.error('[MessageQueue] Init error:', error);
+            }
+        }
+    }
+    /**
+     * Enqueue a message for sync
+     */
+    async enqueue(message) {
+        const id = `msg-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+        const queued = {
+            id,
+            message,
+            retryCount: 0,
+            createdAt: Date.now(),
+            status: 'pending',
+        };
+        this.queue.set(id, queued);
+        await this.persist(queued);
+        return id;
+    }
+    /**
+     * Get pending messages
+     */
+    getPending() {
+        return Array.from(this.queue.values())
+            .filter(m => m.status === 'pending' || m.status === 'failed')
+            .filter(m => m.retryCount < 5) // Max 5 retries
+            .sort((a, b) => a.createdAt - b.createdAt);
+    }
+    /**
+     * Mark message as synced
+     */
+    async markAsSynced(id) {
+        const queued = this.queue.get(id);
+        if (!queued)
+            return;
+        queued.status = 'synced';
+        this.queue.set(id, queued);
+        // Update file
+        await this.persist(queued);
+        // Delete file after some time (optional)
+        // await this.delete(id);
+    }
+    /**
+     * Mark message as failed
+     */
+    async markAsFailed(id, error) {
+        const queued = this.queue.get(id);
+        if (!queued)
+            return;
+        queued.status = 'failed';
+        queued.retryCount++;
+        queued.lastRetryAt = Date.now();
+        queued.error = error;
+        this.queue.set(id, queued);
+        await this.persist(queued);
+    }
+    /**
+     * Get queue statistics
+     */
+    getStats() {
+        const pending = Array.from(this.queue.values()).filter(m => m.status === 'pending').length;
+        const synced = Array.from(this.queue.values()).filter(m => m.status === 'synced').length;
+        const failed = Array.from(this.queue.values()).filter(m => m.status === 'failed').length;
+        return {
+            pending,
+            synced,
+            failed,
+            total: this.queue.size,
+        };
+    }
+    /**
+     * Persist queue item to disk
+     */
+    async persist(queued) {
+        await fs.mkdir(this.queuePath, { recursive: true });
+        await fs.writeFile(path.join(this.queuePath, `${queued.id}.json`), JSON.stringify(queued, null, 2), ENCODING);
+    }
+    /**
+     * Delete queue item from disk
+     */
+    async delete(id) {
+        try {
+            await fs.unlink(path.join(this.queuePath, `${id}.json`));
+            this.queue.delete(id);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                console.error('[MessageQueue] Delete error:', error);
+            }
+        }
+    }
+    /**
+     * Clean up old synced messages
+     */
+    async cleanup(maxAge = 24 * 60 * 60 * 1000) {
+        const cutoff = Date.now() - maxAge;
+        let cleaned = 0;
+        for (const [id, queued] of this.queue.entries()) {
+            if (queued.status === 'synced' && queued.createdAt < cutoff) {
+                await this.delete(id);
+                cleaned++;
+            }
+        }
+        return cleaned;
+    }
+}
+/**
+ * Create message queue instance
+ */
+export function createMessageQueue(queuePath) {
+    return new MessageQueue(queuePath);
+}

package/dist/src/cache/saas-connector.d.ts

@@ -0,0 +1,94 @@
+/**
+ * SAAS Connector - SAAS communication + offline fallback
+ *
+ * Features:
+ * - Health check for SAAS connectivity
+ * - Online/offline status tracking
+ * - Fallback to local cache when offline
+ * - Offline timeout alerts
+ * - Message queue for offline storage
+ */
+import type { SAASConfig, ConnectionStatus } from './types.js';
+import { DEFAULT_SAAS_CONFIG, UserProfile, WeChatMessage } from './types.js';
+type StatusChangeCallback = (status: ConnectionStatus) => void;
+type OfflineTimeoutCallback = () => void;
+/**
+ * SAAS Connector class
+ */
+export declare class SAASConnector {
+    private config;
+    private status;
+    private statusCallbacks;
+    private offlineTimeoutCallbacks;
+    private healthCheckInterval;
+    constructor(config?: Partial<SAASConfig>);
+    /**
+     * Start health check loop
+     */
+    startHealthCheck(intervalMs?: number): void;
+    /**
+     * Stop health check
+     */
+    stopHealthCheck(): void;
+    /**
+     * Check SAAS health status
+     */
+    checkHealth(): Promise<boolean>;
+    /**
+     * Get current connection status
+     */
+    getConnectionStatus(): ConnectionStatus;
+    /**
+     * Check if online
+     */
+    isOnline(): boolean;
+    /**
+     * Query user profile from SAAS
+     */
+    queryUserProfile(userId: string): Promise<UserProfile | null>;
+    /**
+     * Query order from SAAS
+     */
+    queryOrder(orderId: string): Promise<any>;
+    /**
+     * Sync message to SAAS
+     */
+    syncMessage(msg: WeChatMessage): Promise<void>;
+    /**
+     * Query user profile from local cache (fallback)
+     */
+    queryUserProfileOffline(userId: string, localCacheGetter: (userId: string) => Promise<UserProfile | null>): Promise<UserProfile | null>;
+    /**
+     * Query order from local cache (fallback)
+     */
+    queryOrderOffline(orderId: string, localCacheGetter: (orderId: string) => Promise<any | null>): Promise<any | null>;
+    /**
+     * Get offline message for user
+     */
+    getOfflineMessage(): string;
+    /**
+     * Register status change callback
+     */
+    onStatusChange(callback: StatusChangeCallback): void;
+    /**
+     * Register offline timeout callback
+     */
+    onOfflineTimeout(callback: OfflineTimeoutCallback): void;
+    /**
+     * Notify status change
+     */
+    private notifyStatusChange;
+    /**
+     * Notify offline timeout
+     */
+    private notifyOfflineTimeout;
+    /**
+     * Update config
+     */
+    updateConfig(config: Partial<SAASConfig>): void;
+}
+/**
+ * Create SAAS connector instance
+ */
+export declare function createSAASConnector(config?: Partial<SAASConfig>): SAASConnector;
+export { SAASConfig, ConnectionStatus, DEFAULT_SAAS_CONFIG };