@poolzin/pool-bot 2026.3.22 → 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/errors.js

@@ -1,13 +1,46 @@
+import { redactSensitiveText } from "../logging/redact.js";
 export function extractErrorCode(err) {
-    if (!err || typeof err !== "object")
+    if (!err || typeof err !== "object") {
         return undefined;
+    }
     const code = err.code;
-    if (typeof code === "string")
+    if (typeof code === "string") {
         return code;
-    if (typeof code === "number")
+    }
+    if (typeof code === "number") {
         return String(code);
+    }
     return undefined;
 }
+export function readErrorName(err) {
+    if (!err || typeof err !== "object") {
+        return "";
+    }
+    const name = err.name;
+    return typeof name === "string" ? name : "";
+}
+export function collectErrorGraphCandidates(err, resolveNested) {
+    const queue = [err];
+    const seen = new Set();
+    const candidates = [];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (current == null || seen.has(current)) {
+            continue;
+        }
+        seen.add(current);
+        candidates.push(current);
+        if (!current || typeof current !== "object" || !resolveNested) {
+            continue;
+        }
+        for (const nested of resolveNested(current)) {
+            if (nested != null && !seen.has(nested)) {
+                queue.push(nested);
+            }
+        }
+    }
+    return candidates;
+}
 /**
  * Type guard for NodeJS.ErrnoException (any error with a `code` property).
  */
@@ -21,27 +54,34 @@ export function hasErrnoCode(err, code) {
     return isErrno(err) && err.code === code;
 }
 export function formatErrorMessage(err) {
+    let formatted;
     if (err instanceof Error) {
-        return err.message || err.name || "Error";
+        formatted = err.message || err.name || "Error";
     }
-    if (typeof err === "string")
-        return err;
-    if (typeof err === "number" || typeof err === "boolean" || typeof err === "bigint") {
-        return String(err);
+    else if (typeof err === "string") {
+        formatted = err;
     }
-    try {
-        return JSON.stringify(err);
+    else if (typeof err === "number" || typeof err === "boolean" || typeof err === "bigint") {
+        formatted = String(err);
     }
-    catch {
-        return Object.prototype.toString.call(err);
+    else {
+        try {
+            formatted = JSON.stringify(err);
+        }
+        catch {
+            formatted = Object.prototype.toString.call(err);
+        }
     }
+    // Security: best-effort token redaction before returning/logging.
+    return redactSensitiveText(formatted);
 }
 export function formatUncaughtError(err) {
     if (extractErrorCode(err) === "INVALID_CONFIG") {
         return formatErrorMessage(err);
     }
     if (err instanceof Error) {
-        return err.stack ?? err.message ?? err.name;
+        const stack = err.stack ?? err.message ?? err.name;
+        return redactSensitiveText(stack);
     }
     return formatErrorMessage(err);
 }