@poolzin/pool-bot 2026.3.23 → 2026.3.24

package/dist/infra/backup.js

@@ -0,0 +1,328 @@
+/**
+ * Backup System for Pool Bot
+ *
+ * Creates and restores backups of sessions, config, and credentials.
+ * Implemented from scratch for Pool Bot architecture.
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+const BACKUP_DIR = path.join(process.cwd(), ".poolbot", "backups");
+const CONFIG_DIR = path.join(process.cwd(), ".poolbot");
+const SESSIONS_DIR = path.join(CONFIG_DIR, "sessions");
+const CREDENTIALS_DIR = path.join(CONFIG_DIR, "credentials");
+/**
+ * Create a backup of Pool Bot data
+ */
+export async function createBackup(options = {}) {
+    const startTime = Date.now();
+    const { includeSessions = true, includeConfig = true, includeCredentials = true, destinationDir = BACKUP_DIR, } = options;
+    try {
+        // Ensure backup directory exists
+        await fs.mkdir(destinationDir, { recursive: true });
+        // Create backup metadata
+        const metadata = {
+            version: "1.0",
+            createdAt: startTime,
+            poolBotVersion: process.env.npm_package_version || "unknown",
+            includesSessions: includeSessions,
+            includesConfig: includeConfig,
+            includesCredentials: includeCredentials,
+        };
+        // Create temporary directory for backup contents
+        const tempDir = path.join(destinationDir, `backup-${Date.now()}-temp`);
+        await fs.mkdir(tempDir, { recursive: true });
+        let totalSize = 0;
+        let sessionsBackedUp = 0;
+        // Backup sessions
+        if (includeSessions) {
+            const sessionsBackupDir = path.join(tempDir, "sessions");
+            await fs.mkdir(sessionsBackupDir, { recursive: true });
+            try {
+                const sessionFiles = await fs.readdir(SESSIONS_DIR);
+                for (const file of sessionFiles) {
+                    if (file.endsWith(".json")) {
+                        const srcPath = path.join(SESSIONS_DIR, file);
+                        const destPath = path.join(sessionsBackupDir, file);
+                        await fs.copyFile(srcPath, destPath);
+                        sessionsBackedUp++;
+                    }
+                }
+                metadata.sessionCount = sessionsBackedUp;
+            }
+            catch (error) {
+                if (error.code !== "ENOENT") {
+                    throw error;
+                }
+                // Sessions directory doesn't exist yet - that's ok
+                metadata.sessionCount = 0;
+            }
+        }
+        // Backup config
+        if (includeConfig) {
+            const configFiles = ["config.json", "poolbot.json"];
+            const configBackupDir = path.join(tempDir, "config");
+            await fs.mkdir(configBackupDir, { recursive: true });
+            for (const configFile of configFiles) {
+                const srcPath = path.join(CONFIG_DIR, configFile);
+                const destPath = path.join(configBackupDir, configFile);
+                try {
+                    await fs.copyFile(srcPath, destPath);
+                    const stats = await fs.stat(destPath);
+                    totalSize += stats.size;
+                    metadata.configSize = stats.size;
+                }
+                catch (error) {
+                    if (error.code !== "ENOENT") {
+                        throw error;
+                    }
+                }
+            }
+        }
+        // Backup credentials
+        if (includeCredentials) {
+            const credentialsBackupDir = path.join(tempDir, "credentials");
+            await fs.mkdir(credentialsBackupDir, { recursive: true });
+            try {
+                const credFiles = await fs.readdir(CREDENTIALS_DIR);
+                for (const file of credFiles) {
+                    const srcPath = path.join(CREDENTIALS_DIR, file);
+                    const destPath = path.join(credentialsBackupDir, file);
+                    await fs.copyFile(srcPath, destPath);
+                    const stats = await fs.stat(destPath);
+                    totalSize += stats.size;
+                    metadata.credentialsSize = (metadata.credentialsSize || 0) + stats.size;
+                }
+            }
+            catch (error) {
+                if (error.code !== "ENOENT") {
+                    throw error;
+                }
+                // Credentials directory doesn't exist yet - that's ok
+            }
+        }
+        // Write metadata
+        const metadataPath = path.join(tempDir, "metadata.json");
+        await fs.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
+        const metadataStats = await fs.stat(metadataPath);
+        totalSize += metadataStats.size;
+        // Create compressed archive
+        const timestamp = new Date(startTime).toISOString().replace(/[:.]/g, "-");
+        const backupFileName = `poolbot-backup-${timestamp}.tar.gz`;
+        const backupPath = path.join(destinationDir, backupFileName);
+        // For now, just copy the temp directory contents (simplified - not actually tar.gz)
+        // In production, you'd use a proper tar library
+        await fs.rename(tempDir, backupPath.replace(".tar.gz", ""));
+        const duration = Date.now() - startTime;
+        return {
+            success: true,
+            backupPath: backupPath.replace(".tar.gz", ""),
+            metadata,
+            sessionsBackedUp,
+            configBackedUp: includeConfig,
+            credentialsBackedUp: includeCredentials,
+            totalSize,
+            duration,
+        };
+    }
+    catch (error) {
+        const duration = Date.now() - startTime;
+        return {
+            success: false,
+            backupPath: "",
+            metadata: {
+                version: "1.0",
+                createdAt: startTime,
+                poolBotVersion: process.env.npm_package_version || "unknown",
+                includesSessions: false,
+                includesConfig: false,
+                includesCredentials: false,
+            },
+            totalSize: 0,
+            duration,
+            error: error.message,
+        };
+    }
+}
+/**
+ * Restore from a backup
+ */
+export async function restoreBackup(options) {
+    const startTime = Date.now();
+    const { backupPath, restoreSessions = true, restoreConfig = true, restoreCredentials = true, dryRun = false, } = options;
+    try {
+        // Verify backup exists
+        const backupDir = backupPath.endsWith(".tar.gz")
+            ? backupPath.replace(".tar.gz", "")
+            : backupPath;
+        const metadataPath = path.join(backupDir, "metadata.json");
+        try {
+            await fs.access(metadataPath);
+        }
+        catch {
+            throw new Error(`Invalid backup: metadata.json not found at ${metadataPath}`);
+        }
+        // Read metadata
+        const metadataContent = await fs.readFile(metadataPath, "utf-8");
+        const metadata = JSON.parse(metadataContent);
+        const report = {
+            success: true,
+            backupPath,
+            dryRun,
+            duration: 0,
+            sessionsRestored: 0,
+            configRestored: false,
+            credentialsRestored: false,
+        };
+        if (dryRun) {
+            // Just report what would be restored
+            if (restoreSessions && metadata.includesSessions) {
+                report.sessionsRestored = metadata.sessionCount || 0;
+            }
+            if (restoreConfig && metadata.includesConfig) {
+                report.configRestored = true;
+            }
+            if (restoreCredentials && metadata.includesCredentials) {
+                report.credentialsRestored = true;
+            }
+            report.duration = Date.now() - startTime;
+            return report;
+        }
+        // Restore sessions
+        if (restoreSessions && metadata.includesSessions) {
+            const sessionsBackupDir = path.join(backupDir, "sessions");
+            try {
+                await fs.mkdir(SESSIONS_DIR, { recursive: true });
+                const sessionFiles = await fs.readdir(sessionsBackupDir);
+                for (const file of sessionFiles) {
+                    if (file.endsWith(".json")) {
+                        const srcPath = path.join(sessionsBackupDir, file);
+                        const destPath = path.join(SESSIONS_DIR, file);
+                        await fs.copyFile(srcPath, destPath);
+                        report.sessionsRestored = (report.sessionsRestored || 0) + 1;
+                    }
+                }
+            }
+            catch (error) {
+                if (error.code !== "ENOENT") {
+                    throw error;
+                }
+            }
+        }
+        // Restore config
+        if (restoreConfig && metadata.includesConfig) {
+            const configBackupDir = path.join(backupDir, "config");
+            try {
+                const configFiles = await fs.readdir(configBackupDir);
+                for (const file of configFiles) {
+                    const srcPath = path.join(configBackupDir, file);
+                    const destPath = path.join(CONFIG_DIR, file);
+                    await fs.copyFile(srcPath, destPath);
+                    report.configRestored = true;
+                }
+            }
+            catch (error) {
+                if (error.code !== "ENOENT") {
+                    throw error;
+                }
+            }
+        }
+        // Restore credentials
+        if (restoreCredentials && metadata.includesCredentials) {
+            const credentialsBackupDir = path.join(backupDir, "credentials");
+            try {
+                await fs.mkdir(CREDENTIALS_DIR, { recursive: true });
+                const credFiles = await fs.readdir(credentialsBackupDir);
+                for (const file of credFiles) {
+                    const srcPath = path.join(credentialsBackupDir, file);
+                    const destPath = path.join(CREDENTIALS_DIR, file);
+                    await fs.copyFile(srcPath, destPath);
+                    report.credentialsRestored = true;
+                }
+            }
+            catch (error) {
+                if (error.code !== "ENOENT") {
+                    throw error;
+                }
+            }
+        }
+        report.duration = Date.now() - startTime;
+        return report;
+    }
+    catch (error) {
+        const duration = Date.now() - startTime;
+        return {
+            success: false,
+            backupPath,
+            dryRun,
+            duration,
+            error: error.message,
+        };
+    }
+}
+/**
+ * List available backups
+ */
+export async function listBackups(backupDir = BACKUP_DIR) {
+    try {
+        await fs.mkdir(backupDir, { recursive: true });
+        const entries = await fs.readdir(backupDir, { withFileTypes: true });
+        const backups = [];
+        for (const entry of entries) {
+            if (entry.isDirectory() && entry.name.startsWith("poolbot-backup-")) {
+                const metadataPath = path.join(backupDir, entry.name, "metadata.json");
+                try {
+                    const metadataContent = await fs.readFile(metadataPath, "utf-8");
+                    const metadata = JSON.parse(metadataContent);
+                    // Calculate total size
+                    let totalSize = 0;
+                    const backupPath = path.join(backupDir, entry.name);
+                    const files = await fs.readdir(backupPath, { recursive: true });
+                    for (const file of files) {
+                        const filePath = path.join(backupPath, file);
+                        try {
+                            const stats = await fs.stat(filePath);
+                            totalSize += stats.size;
+                        }
+                        catch {
+                            // File might have been deleted
+                        }
+                    }
+                    backups.push({
+                        path: backupPath,
+                        metadata,
+                        size: totalSize,
+                        createdAt: metadata.createdAt,
+                    });
+                }
+                catch {
+                    // Skip invalid backups
+                }
+            }
+        }
+        // Sort by creation date (newest first)
+        return backups.sort((a, b) => b.createdAt - a.createdAt);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Delete a backup
+ */
+export async function deleteBackup(backupPath) {
+    try {
+        // Check if path exists first
+        await fs.access(backupPath);
+        await fs.rm(backupPath, { recursive: true, force: true });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get backup directory
+ */
+export function getBackupDir() {
+    return BACKUP_DIR;
+}

package/dist/infra/channel-account-context.js

@@ -0,0 +1,173 @@
+/**
+ * Channel Account Context System
+ *
+ * Manage multiple accounts per channel with context switching.
+ * Implemented from scratch for Pool Bot architecture.
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+const ACCOUNTS_FILE = path.join(process.cwd(), ".poolbot", "channel-accounts.json");
+/**
+ * Load channel accounts from file
+ */
+export async function loadChannelAccounts() {
+    try {
+        const data = await fs.readFile(ACCOUNTS_FILE, "utf-8");
+        return JSON.parse(data);
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return { accounts: {}, activeAccounts: {} };
+        }
+        throw error;
+    }
+}
+/**
+ * Save channel accounts to file
+ */
+export async function saveChannelAccounts(store) {
+    await fs.mkdir(path.dirname(ACCOUNTS_FILE), { recursive: true });
+    await fs.writeFile(ACCOUNTS_FILE, JSON.stringify(store, null, 2));
+}
+/**
+ * Add a new channel account
+ */
+export async function addChannelAccount(params) {
+    const { channelId, channelType, accountName, credentials, metadata } = params;
+    const now = Date.now();
+    const accountId = `${channelType}-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+    const key = `${channelId}:${accountId}`;
+    const store = await loadChannelAccounts();
+    const account = {
+        id: accountId,
+        channelId,
+        channelType,
+        accountName,
+        credentials: credentials || {},
+        metadata: metadata || {},
+        isActive: false,
+        createdAt: now,
+        updatedAt: now,
+    };
+    store.accounts[key] = account;
+    await saveChannelAccounts(store);
+    return account;
+}
+/**
+ * Remove a channel account
+ */
+export async function removeChannelAccount(channelId, accountId) {
+    const key = `${channelId}:${accountId}`;
+    const store = await loadChannelAccounts();
+    if (!store.accounts[key]) {
+        return false;
+    }
+    delete store.accounts[key];
+    // Also remove from active accounts if set
+    if (store.activeAccounts[channelId] === accountId) {
+        delete store.activeAccounts[channelId];
+    }
+    await saveChannelAccounts(store);
+    return true;
+}
+/**
+ * Get a channel account
+ */
+export async function getChannelAccount(channelId, accountId) {
+    const key = `${channelId}:${accountId}`;
+    const store = await loadChannelAccounts();
+    return store.accounts[key];
+}
+/**
+ * Get all accounts for a channel
+ */
+export async function getChannelAccounts(channelId) {
+    const store = await loadChannelAccounts();
+    return Object.values(store.accounts).filter((account) => account.channelId === channelId);
+}
+/**
+ * Get active account for a channel
+ */
+export async function getActiveChannelAccount(channelId) {
+    const store = await loadChannelAccounts();
+    const activeAccountId = store.activeAccounts[channelId];
+    if (!activeAccountId) {
+        return undefined;
+    }
+    const key = `${channelId}:${activeAccountId}`;
+    return store.accounts[key];
+}
+/**
+ * Set active account for a channel
+ */
+export async function setActiveChannelAccount(channelId, accountId) {
+    const key = `${channelId}:${accountId}`;
+    const store = await loadChannelAccounts();
+    if (!store.accounts[key]) {
+        return false;
+    }
+    // Deactivate all accounts for this channel
+    Object.values(store.accounts).forEach((account) => {
+        if (account.channelId === channelId) {
+            account.isActive = false;
+            account.updatedAt = Date.now();
+        }
+    });
+    // Activate the selected account
+    store.accounts[key].isActive = true;
+    store.accounts[key].updatedAt = Date.now();
+    store.accounts[key].lastUsedAt = Date.now();
+    store.activeAccounts[channelId] = accountId;
+    await saveChannelAccounts(store);
+    return true;
+}
+/**
+ * Update channel account
+ */
+export async function updateChannelAccount(params) {
+    const { channelId, accountId, accountName, credentials, metadata } = params;
+    const key = `${channelId}:${accountId}`;
+    const store = await loadChannelAccounts();
+    if (!store.accounts[key]) {
+        return undefined;
+    }
+    const account = store.accounts[key];
+    if (accountName !== undefined) {
+        account.accountName = accountName;
+    }
+    if (credentials !== undefined) {
+        account.credentials = { ...account.credentials, ...credentials };
+    }
+    if (metadata !== undefined) {
+        account.metadata = { ...account.metadata, ...metadata };
+    }
+    account.updatedAt = Date.now();
+    store.accounts[key] = account;
+    await saveChannelAccounts(store);
+    return account;
+}
+/**
+ * List all channel accounts
+ */
+export async function listAllChannelAccounts() {
+    const store = await loadChannelAccounts();
+    return Object.values(store.accounts);
+}
+/**
+ * Get account usage statistics
+ */
+export async function getChannelAccountStats() {
+    const store = await loadChannelAccounts();
+    const accounts = Object.values(store.accounts);
+    const stats = {
+        totalAccounts: accounts.length,
+        channelsWithAccounts: new Set(accounts.map((a) => a.channelId)).size,
+        activeAccounts: accounts.filter((a) => a.isActive).length,
+        accountsByChannelType: {},
+    };
+    accounts.forEach((account) => {
+        stats.accountsByChannelType[account.channelType] =
+            (stats.accountsByChannelType[account.channelType] || 0) + 1;
+    });
+    return stats;
+}

package/dist/infra/session-cleanup.js

@@ -0,0 +1,143 @@
+/**
+ * Session Cleanup System
+ *
+ * Automatically cleans up old sessions based on disk budget.
+ * Implemented from scratch for Pool Bot architecture.
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+const DEFAULT_SESSIONS_DIR = path.join(process.cwd(), ".poolbot", "sessions");
+const DEFAULT_MAX_DISK_USAGE_MB = 1000; // 1GB
+const DEFAULT_MIN_SESSIONS_TO_KEEP = 5;
+/**
+ * Get all sessions with metadata
+ */
+export async function getSessions(sessionsDir = DEFAULT_SESSIONS_DIR) {
+    try {
+        await fs.mkdir(sessionsDir, { recursive: true });
+        const entries = await fs.readdir(sessionsDir, { withFileTypes: true });
+        const sessions = [];
+        for (const entry of entries) {
+            if (entry.isFile() && entry.name.endsWith(".json")) {
+                const sessionPath = path.join(sessionsDir, entry.name);
+                const stats = await fs.stat(sessionPath);
+                sessions.push({
+                    path: sessionPath,
+                    size: stats.size,
+                    createdAt: stats.birthtimeMs,
+                    modifiedAt: stats.mtimeMs,
+                });
+            }
+        }
+        // Sort by modified date (oldest first)
+        return sessions.sort((a, b) => a.modifiedAt - b.modifiedAt);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Calculate total disk usage
+ */
+export async function calculateDiskUsage(sessions) {
+    return sessions.reduce((total, session) => total + session.size, 0);
+}
+/**
+ * Cleanup old sessions to stay within disk budget
+ */
+export async function cleanupSessions(options = {}) {
+    const startTime = Date.now();
+    const { sessionsDir = DEFAULT_SESSIONS_DIR, maxDiskUsageMB = DEFAULT_MAX_DISK_USAGE_MB, minSessionsToKeep = DEFAULT_MIN_SESSIONS_TO_KEEP, dryRun = false, } = options;
+    try {
+        const maxDiskUsageBytes = maxDiskUsageMB * 1024 * 1024;
+        // Get all sessions
+        const sessions = await getSessions(sessionsDir);
+        let currentDiskUsage = await calculateDiskUsage(sessions);
+        const report = {
+            success: true,
+            sessionsDeleted: 0,
+            spaceFreedBytes: 0,
+            spaceFreedMB: 0,
+            sessionsRemaining: sessions.length,
+            currentDiskUsageBytes: currentDiskUsage,
+            currentDiskUsageMB: currentDiskUsage / (1024 * 1024),
+            dryRun,
+            duration: 0,
+        };
+        // If under budget, nothing to do
+        if (currentDiskUsage <= maxDiskUsageBytes) {
+            report.duration = Date.now() - startTime;
+            return report;
+        }
+        // Delete oldest sessions until under budget
+        const sessionsToDelete = [];
+        let spaceToFree = currentDiskUsage - maxDiskUsageBytes;
+        for (const session of sessions) {
+            // Don't delete if we're at minimum sessions
+            if (sessions.length - sessionsToDelete.length <= minSessionsToKeep) {
+                break;
+            }
+            sessionsToDelete.push(session);
+            spaceToFree -= session.size;
+            // Stop if we've freed enough space
+            if (spaceToFree <= 0) {
+                break;
+            }
+        }
+        // Delete sessions
+        let spaceFreed = 0;
+        for (const session of sessionsToDelete) {
+            if (dryRun) {
+                spaceFreed += session.size;
+            }
+            else {
+                try {
+                    await fs.unlink(session.path);
+                    spaceFreed += session.size;
+                }
+                catch (error) {
+                    console.error(`Failed to delete session ${session.path}:`, error.message);
+                }
+            }
+        }
+        report.sessionsDeleted = sessionsToDelete.length;
+        report.spaceFreedBytes = spaceFreed;
+        report.spaceFreedMB = spaceFreed / (1024 * 1024);
+        report.sessionsRemaining = sessions.length - sessionsToDelete.length;
+        report.currentDiskUsageBytes = currentDiskUsage - spaceFreed;
+        report.currentDiskUsageMB = (currentDiskUsage - spaceFreed) / (1024 * 1024);
+        report.duration = Date.now() - startTime;
+        return report;
+    }
+    catch (error) {
+        const duration = Date.now() - startTime;
+        return {
+            success: false,
+            sessionsDeleted: 0,
+            spaceFreedBytes: 0,
+            spaceFreedMB: 0,
+            sessionsRemaining: 0,
+            currentDiskUsageBytes: 0,
+            currentDiskUsageMB: 0,
+            dryRun,
+            duration,
+            error: error.message,
+        };
+    }
+}
+/**
+ * Get session cleanup status
+ */
+export async function getSessionCleanupStatus(options) {
+    const { sessionsDir = DEFAULT_SESSIONS_DIR, maxDiskUsageMB = DEFAULT_MAX_DISK_USAGE_MB } = options;
+    const sessions = await getSessions(sessionsDir);
+    const currentUsage = await calculateDiskUsage(sessions);
+    const maxUsageBytes = maxDiskUsageMB * 1024 * 1024;
+    return {
+        currentUsageMB: currentUsage / (1024 * 1024),
+        maxUsageMB: maxDiskUsageMB,
+        usagePercent: (currentUsage / maxUsageBytes) * 100,
+        sessionCount: sessions.length,
+        overBudget: currentUsage > maxUsageBytes,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poolzin/pool-bot",
-  "version": "2026.3.23",
+  "version": "2026.3.24",
   "description": "🎱 Pool Bot - AI assistant with PLCODE integrations",
   "keywords": [],
   "license": "MIT",