infrawise 0.1.0 → 0.2.0

package/dist/adapters/dynamodb.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractDynamoMetadata = extractDynamoMetadata;
+exports.validateDynamoAccess = validateDynamoAccess;
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const credential_providers_1 = require("@aws-sdk/credential-providers");
+const core_1 = require("../core");
+function createDynamoClient(config) {
+    const region = config.aws?.region ?? 'us-east-1';
+    const profile = config.aws?.profile;
+    const clientConfig = { region };
+    if (profile) {
+        clientConfig.credentials = (0, credential_providers_1.fromIni)({ profile });
+    }
+    return new client_dynamodb_1.DynamoDBClient(clientConfig);
+}
+function parseTableDescription(desc) {
+    const tableName = desc.TableName ?? 'unknown';
+    const partitionKey = desc.KeySchema?.find((k) => k.KeyType === 'HASH')?.AttributeName;
+    const sortKey = desc.KeySchema?.find((k) => k.KeyType === 'RANGE')?.AttributeName;
+    const indexes = [];
+    // Global secondary indexes
+    if (desc.GlobalSecondaryIndexes) {
+        for (const gsi of desc.GlobalSecondaryIndexes) {
+            if (gsi.IndexName)
+                indexes.push(gsi.IndexName);
+        }
+    }
+    // Local secondary indexes
+    if (desc.LocalSecondaryIndexes) {
+        for (const lsi of desc.LocalSecondaryIndexes) {
+            if (lsi.IndexName)
+                indexes.push(lsi.IndexName);
+        }
+    }
+    return { tableName, partitionKey, sortKey, indexes };
+}
+async function listAllTables(client) {
+    const tableNames = [];
+    let lastEvaluatedTableName;
+    do {
+        const command = new client_dynamodb_1.ListTablesCommand({
+            ExclusiveStartTableName: lastEvaluatedTableName,
+            Limit: 100,
+        });
+        const response = await client.send(command);
+        if (response.TableNames) {
+            tableNames.push(...response.TableNames);
+        }
+        lastEvaluatedTableName = response.LastEvaluatedTableName;
+    } while (lastEvaluatedTableName);
+    return tableNames;
+}
+async function extractDynamoMetadata(config) {
+    const client = createDynamoClient(config);
+    const includeTables = config.dynamodb?.includeTables;
+    let tableNames;
+    try {
+        const allTables = await listAllTables(client);
+        if (includeTables && includeTables.length > 0) {
+            tableNames = allTables.filter((name) => includeTables.includes(name));
+            core_1.logger.debug(`Filtered to ${tableNames.length} tables from config`);
+        }
+        else {
+            tableNames = allTables;
+        }
+        core_1.logger.debug(`Found ${tableNames.length} DynamoDB table(s)`);
+    }
+    catch (err) {
+        throw new core_1.DynamoDBError(err instanceof Error ? err.message : 'Failed to list DynamoDB tables');
+    }
+    const results = [];
+    for (const tableName of tableNames) {
+        try {
+            const command = new client_dynamodb_1.DescribeTableCommand({ TableName: tableName });
+            const response = await client.send(command);
+            if (response.Table) {
+                results.push(parseTableDescription(response.Table));
+                core_1.logger.debug(`Described table: ${tableName}`);
+            }
+        }
+        catch (err) {
+            core_1.logger.warn(`Failed to describe table ${tableName}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    return results;
+}
+async function validateDynamoAccess(config) {
+    const client = createDynamoClient(config);
+    try {
+        await client.send(new client_dynamodb_1.ListTablesCommand({ Limit: 1 }));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/adapters/logs.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractLogsSummary = extractLogsSummary;
+exports.validateLogsAccess = validateLogsAccess;
+const client_cloudwatch_logs_1 = require("@aws-sdk/client-cloudwatch-logs");
+const credential_providers_1 = require("@aws-sdk/credential-providers");
+const core_1 = require("../core");
+// Hard caps to prevent context bloat
+const MAX_LOG_GROUPS = 50;
+const MAX_EVENTS_PER_GROUP = 50;
+function clientConfig(cfg) {
+    const region = cfg.region ?? 'us-east-1';
+    return cfg.profile
+        ? { region, credentials: (0, credential_providers_1.fromIni)({ profile: cfg.profile }) }
+        : { region };
+}
+// Strip UUIDs, timestamps, numbers → group similar messages by pattern
+function toPattern(message) {
+    return message
+        .slice(0, 200)
+        .replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, '<UUID>')
+        .replace(/\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(\.\d+)?Z?/g, '<TIMESTAMP>')
+        .replace(/\b\d{5,}\b/g, '<NUM>')
+        .replace(/\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/g, '<IP>')
+        .replace(/Bearer\s+\S+/gi, 'Bearer <TOKEN>')
+        .trim();
+}
+function topPatterns(messages, limit = 5) {
+    const counts = {};
+    for (const msg of messages) {
+        const p = toPattern(msg);
+        counts[p] = (counts[p] ?? 0) + 1;
+    }
+    return Object.entries(counts)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, limit)
+        .map(([pattern, count]) => ({ pattern, count }));
+}
+async function extractLogsSummary(cfg = {}) {
+    const client = new client_cloudwatch_logs_1.CloudWatchLogsClient(clientConfig(cfg));
+    const windowMs = (cfg.windowHours ?? 24) * 60 * 60 * 1000;
+    const startTime = Date.now() - windowMs;
+    const summaries = [];
+    // Discover log groups
+    const logGroups = [];
+    try {
+        const prefixes = cfg.logGroupPrefixes?.length ? cfg.logGroupPrefixes : [undefined];
+        for (const prefix of prefixes) {
+            let nextToken;
+            do {
+                const res = await client.send(new client_cloudwatch_logs_1.DescribeLogGroupsCommand({
+                    nextToken,
+                    limit: Math.min(50, MAX_LOG_GROUPS - logGroups.length),
+                    ...(prefix ? { logGroupNamePrefix: prefix } : {}),
+                }));
+                for (const lg of res.logGroups ?? []) {
+                    logGroups.push({ name: lg.logGroupName ?? '', retentionDays: lg.retentionInDays });
+                }
+                nextToken = res.nextToken;
+                if (logGroups.length >= MAX_LOG_GROUPS)
+                    break;
+            } while (nextToken);
+            if (logGroups.length >= MAX_LOG_GROUPS)
+                break;
+        }
+    }
+    catch (err) {
+        core_1.logger.warn(`CloudWatch Logs discovery failed: ${err instanceof Error ? err.message : String(err)}`);
+        return summaries;
+    }
+    // Sample errors from each group — patterns only, never raw messages for unrelated groups
+    for (const lg of logGroups) {
+        const errorMessages = [];
+        const warnMessages = [];
+        let lastErrorTime;
+        for (const filterPattern of ['ERROR', 'Exception', 'WARN']) {
+            if (errorMessages.length + warnMessages.length >= MAX_EVENTS_PER_GROUP)
+                break;
+            try {
+                const res = await client.send(new client_cloudwatch_logs_1.FilterLogEventsCommand({
+                    logGroupName: lg.name,
+                    filterPattern,
+                    startTime,
+                    limit: 25,
+                }));
+                for (const event of res.events ?? []) {
+                    const msg = event.message ?? '';
+                    if (filterPattern === 'WARN') {
+                        warnMessages.push(msg);
+                    }
+                    else {
+                        errorMessages.push(msg);
+                        if (event.timestamp) {
+                            const ts = new Date(event.timestamp).toISOString();
+                            if (!lastErrorTime || ts > lastErrorTime)
+                                lastErrorTime = ts;
+                        }
+                    }
+                }
+            }
+            catch {
+                // Filter pattern may not match; continue
+            }
+        }
+        summaries.push({
+            logGroupName: lg.name,
+            retentionDays: lg.retentionDays,
+            errorCount: errorMessages.length,
+            warnCount: warnMessages.length,
+            topErrorPatterns: topPatterns(errorMessages),
+            lastErrorTime,
+        });
+    }
+    core_1.logger.debug(`CloudWatch Logs: sampled ${summaries.length} log group(s)`);
+    return summaries;
+}
+async function validateLogsAccess(cfg = {}) {
+    await new client_cloudwatch_logs_1.CloudWatchLogsClient(clientConfig(cfg)).send(new client_cloudwatch_logs_1.DescribeLogGroupsCommand({ limit: 1 }));
+}

package/dist/adapters/mongodb.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoConnectionError = void 0;
+exports.extractMongoMetadata = extractMongoMetadata;
+exports.validateMongoAccess = validateMongoAccess;
+const mongodb_1 = require("mongodb");
+const core_1 = require("../core");
+const SYSTEM_DATABASES = new Set(['admin', 'local', 'config']);
+class MongoConnectionError extends core_1.InfrawiseError {
+    constructor(details) {
+        super('Unable to connect to MongoDB.\n\nPossible reasons:\n- invalid connection string\n- port 27017 not accessible\n- wrong credentials\n\nRun: infrawise doctor', undefined, undefined);
+        this.name = 'MongoConnectionError';
+        if (details) {
+            this.message = `Unable to connect to MongoDB.\n\nPossible reasons:\n- invalid connection string\n- port 27017 not accessible\n- wrong credentials\n\nRun: infrawise doctor\n\nDetail: ${details}`;
+        }
+    }
+}
+exports.MongoConnectionError = MongoConnectionError;
+async function extractMongoMetadata(connectionString, databases) {
+    const client = new mongodb_1.MongoClient(connectionString, {
+        serverSelectionTimeoutMS: 5000,
+        connectTimeoutMS: 5000,
+    });
+    try {
+        await client.connect();
+        // Determine which databases to introspect
+        let dbNames;
+        if (databases && databases.length > 0) {
+            dbNames = databases;
+        }
+        else {
+            const adminDb = client.db('admin');
+            const dbList = await adminDb.admin().listDatabases();
+            dbNames = dbList.databases
+                .map((d) => d.name)
+                .filter((name) => !SYSTEM_DATABASES.has(name));
+        }
+        core_1.logger.debug(`Introspecting ${dbNames.length} MongoDB database(s)`);
+        const results = [];
+        for (const dbName of dbNames) {
+            const db = client.db(dbName);
+            let collectionNames;
+            try {
+                const collections = await db.listCollections().toArray();
+                collectionNames = collections.map((c) => c.name);
+            }
+            catch (err) {
+                core_1.logger.warn(`Skipping database "${dbName}": ${err instanceof Error ? err.message : String(err)}`);
+                continue;
+            }
+            for (const collName of collectionNames) {
+                const collection = db.collection(collName);
+                let rawIndexes = [];
+                try {
+                    rawIndexes = (await collection.indexes());
+                }
+                catch {
+                    rawIndexes = [];
+                }
+                let estimatedCount = 0;
+                try {
+                    estimatedCount = await collection.estimatedDocumentCount();
+                }
+                catch {
+                    estimatedCount = 0;
+                }
+                const indexes = rawIndexes.map((idx) => ({
+                    name: String(idx['name'] ?? ''),
+                    keys: (idx['key'] ?? {}),
+                    unique: Boolean(idx['unique']),
+                    sparse: Boolean(idx['sparse']),
+                }));
+                results.push({
+                    database: dbName,
+                    collection: collName,
+                    indexes,
+                    estimatedCount,
+                });
+            }
+        }
+        core_1.logger.debug(`Found ${results.length} MongoDB collection(s)`);
+        return results;
+    }
+    catch (err) {
+        if (err instanceof MongoConnectionError)
+            throw err;
+        throw new MongoConnectionError(err instanceof Error ? err.message : String(err));
+    }
+    finally {
+        await client.close().catch(() => undefined);
+    }
+}
+async function validateMongoAccess(connectionString) {
+    const client = new mongodb_1.MongoClient(connectionString, {
+        serverSelectionTimeoutMS: 5000,
+        connectTimeoutMS: 5000,
+    });
+    try {
+        await client.connect();
+        await client.db('admin').command({ ping: 1 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        await client.close().catch(() => undefined);
+    }
+}

package/dist/adapters/mysql.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MySQLConnectionError = void 0;
+exports.extractMySQLMetadata = extractMySQLMetadata;
+exports.validateMySQLAccess = validateMySQLAccess;
+const promise_1 = __importDefault(require("mysql2/promise"));
+const core_1 = require("../core");
+const SYSTEM_SCHEMAS = new Set(['information_schema', 'performance_schema', 'mysql', 'sys']);
+class MySQLConnectionError extends core_1.InfrawiseError {
+    constructor(details) {
+        super('Unable to connect to MySQL.\n\nPossible reasons:\n- invalid connection string\n- port 3306 not accessible\n- wrong credentials\n\nRun: infrawise doctor', undefined, undefined);
+        this.name = 'MySQLConnectionError';
+        if (details) {
+            this.message = `Unable to connect to MySQL.\n\nPossible reasons:\n- invalid connection string\n- port 3306 not accessible\n- wrong credentials\n\nRun: infrawise doctor\n\nDetail: ${details}`;
+        }
+    }
+}
+exports.MySQLConnectionError = MySQLConnectionError;
+async function extractMySQLMetadata(connectionString) {
+    let connection;
+    try {
+        connection = await promise_1.default.createConnection(connectionString);
+        // Get all user tables
+        const [tableRows] = await connection.execute(`
+      SELECT TABLE_SCHEMA, TABLE_NAME, ENGINE
+      FROM information_schema.tables
+      WHERE TABLE_TYPE = 'BASE TABLE'
+        AND TABLE_SCHEMA NOT IN (${[...SYSTEM_SCHEMAS].map(() => '?').join(', ')})
+      ORDER BY TABLE_SCHEMA, TABLE_NAME
+    `, [...SYSTEM_SCHEMAS]);
+        core_1.logger.debug(`Found ${tableRows.length} MySQL table(s)`);
+        // Get all columns
+        const [columnRows] = await connection.execute(`
+      SELECT TABLE_SCHEMA, TABLE_NAME, COLUMN_NAME
+      FROM information_schema.columns
+      WHERE TABLE_SCHEMA NOT IN (${[...SYSTEM_SCHEMAS].map(() => '?').join(', ')})
+      ORDER BY TABLE_SCHEMA, TABLE_NAME, ORDINAL_POSITION
+    `, [...SYSTEM_SCHEMAS]);
+        // Get all indexes
+        const [indexRows] = await connection.execute(`
+      SELECT TABLE_SCHEMA, TABLE_NAME, INDEX_NAME
+      FROM information_schema.statistics
+      WHERE TABLE_SCHEMA NOT IN (${[...SYSTEM_SCHEMAS].map(() => '?').join(', ')})
+      GROUP BY TABLE_SCHEMA, TABLE_NAME, INDEX_NAME
+      ORDER BY TABLE_SCHEMA, TABLE_NAME, INDEX_NAME
+    `, [...SYSTEM_SCHEMAS]);
+        // Get primary keys
+        const [pkRows] = await connection.execute(`
+      SELECT TABLE_SCHEMA, TABLE_NAME, COLUMN_NAME
+      FROM information_schema.key_column_usage
+      WHERE CONSTRAINT_NAME = 'PRIMARY'
+        AND TABLE_SCHEMA NOT IN (${[...SYSTEM_SCHEMAS].map(() => '?').join(', ')})
+      ORDER BY TABLE_SCHEMA, TABLE_NAME, ORDINAL_POSITION
+    `, [...SYSTEM_SCHEMAS]);
+        // Build lookup maps
+        const columnMap = new Map();
+        for (const row of columnRows) {
+            const key = `${row['TABLE_SCHEMA']}.${row['TABLE_NAME']}`;
+            let cols = columnMap.get(key);
+            if (!cols) {
+                cols = [];
+                columnMap.set(key, cols);
+            }
+            cols.push(row['COLUMN_NAME']);
+        }
+        const indexMap = new Map();
+        for (const row of indexRows) {
+            const key = `${row['TABLE_SCHEMA']}.${row['TABLE_NAME']}`;
+            let idxs = indexMap.get(key);
+            if (!idxs) {
+                idxs = [];
+                indexMap.set(key, idxs);
+            }
+            const idxName = row['INDEX_NAME'];
+            if (!idxs.includes(idxName))
+                idxs.push(idxName);
+        }
+        const pkMap = new Map();
+        for (const row of pkRows) {
+            const key = `${row['TABLE_SCHEMA']}.${row['TABLE_NAME']}`;
+            let pks = pkMap.get(key);
+            if (!pks) {
+                pks = [];
+                pkMap.set(key, pks);
+            }
+            pks.push(row['COLUMN_NAME']);
+        }
+        // Assemble results
+        const results = [];
+        for (const row of tableRows) {
+            const schema = row['TABLE_SCHEMA'];
+            const table = row['TABLE_NAME'];
+            const engine = row['ENGINE'] ?? 'InnoDB';
+            const key = `${schema}.${table}`;
+            results.push({
+                schema,
+                table,
+                columns: columnMap.get(key) ?? [],
+                indexes: indexMap.get(key) ?? [],
+                primaryKeys: pkMap.get(key) ?? [],
+                engine,
+            });
+        }
+        return results;
+    }
+    catch (err) {
+        if (err instanceof MySQLConnectionError)
+            throw err;
+        throw new MySQLConnectionError(err instanceof Error ? err.message : String(err));
+    }
+    finally {
+        if (connection) {
+            await connection.end().catch(() => undefined);
+        }
+    }
+}
+async function validateMySQLAccess(connectionString) {
+    let connection;
+    try {
+        connection = await promise_1.default.createConnection(connectionString);
+        await connection.execute('SELECT 1');
+        return true;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        if (connection) {
+            await connection.end().catch(() => undefined);
+        }
+    }
+}

package/dist/adapters/postgres.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractPostgresMetadata = extractPostgresMetadata;
+exports.validatePostgresAccess = validatePostgresAccess;
+const pg_1 = require("pg");
+const core_1 = require("../core");
+async function extractPostgresMetadata(connectionString) {
+    const pool = new pg_1.Pool({
+        connectionString,
+        max: 1,
+        idleTimeoutMillis: 10000,
+        connectionTimeoutMillis: 5000,
+    });
+    try {
+        // Test connection
+        const client = await pool.connect();
+        try {
+            // Get all user tables
+            const tablesResult = await client.query(`
+        SELECT table_schema, table_name
+        FROM information_schema.tables
+        WHERE table_type = 'BASE TABLE'
+          AND table_schema NOT IN ('pg_catalog', 'information_schema')
+        ORDER BY table_schema, table_name
+      `);
+            core_1.logger.debug(`Found ${tablesResult.rows.length} PostgreSQL table(s)`);
+            // Get all columns
+            const columnsResult = await client.query(`
+        SELECT table_schema, table_name, column_name
+        FROM information_schema.columns
+        WHERE table_schema NOT IN ('pg_catalog', 'information_schema')
+        ORDER BY table_schema, table_name, ordinal_position
+      `);
+            // Get all indexes
+            const indexesResult = await client.query(`
+        SELECT schemaname, tablename, indexname
+        FROM pg_indexes
+        WHERE schemaname NOT IN ('pg_catalog', 'information_schema')
+        ORDER BY schemaname, tablename, indexname
+      `);
+            // Get primary keys
+            const primaryKeysResult = await client.query(`
+        SELECT
+          tc.table_schema,
+          tc.table_name,
+          kcu.column_name
+        FROM information_schema.table_constraints tc
+        JOIN information_schema.key_column_usage kcu
+          ON tc.constraint_name = kcu.constraint_name
+          AND tc.table_schema = kcu.table_schema
+        WHERE tc.constraint_type = 'PRIMARY KEY'
+          AND tc.table_schema NOT IN ('pg_catalog', 'information_schema')
+        ORDER BY tc.table_schema, tc.table_name
+      `);
+            // Build maps for columns, indexes, primary keys
+            const columnMap = new Map();
+            for (const row of columnsResult.rows) {
+                const key = `${row.table_schema}.${row.table_name}`;
+                let cols = columnMap.get(key);
+                if (!cols) {
+                    cols = [];
+                    columnMap.set(key, cols);
+                }
+                cols.push(row.column_name);
+            }
+            const indexMap = new Map();
+            for (const row of indexesResult.rows) {
+                const key = `${row.schemaname}.${row.tablename}`;
+                let idxs = indexMap.get(key);
+                if (!idxs) {
+                    idxs = [];
+                    indexMap.set(key, idxs);
+                }
+                idxs.push(row.indexname);
+            }
+            const pkMap = new Map();
+            for (const row of primaryKeysResult.rows) {
+                const key = `${row.table_schema}.${row.table_name}`;
+                let pks = pkMap.get(key);
+                if (!pks) {
+                    pks = [];
+                    pkMap.set(key, pks);
+                }
+                pks.push(row.column_name);
+            }
+            // Assemble results
+            const results = [];
+            for (const table of tablesResult.rows) {
+                const key = `${table.table_schema}.${table.table_name}`;
+                results.push({
+                    schema: table.table_schema,
+                    table: table.table_name,
+                    columns: columnMap.get(key) ?? [],
+                    indexes: indexMap.get(key) ?? [],
+                    primaryKeys: pkMap.get(key) ?? [],
+                });
+            }
+            return results;
+        }
+        finally {
+            client.release();
+        }
+    }
+    catch (err) {
+        if (err instanceof core_1.PostgresConnectionError)
+            throw err;
+        throw new core_1.PostgresConnectionError(err instanceof Error ? err.message : 'Unknown error connecting to PostgreSQL');
+    }
+    finally {
+        await pool.end();
+    }
+}
+async function validatePostgresAccess(connectionString) {
+    const pool = new pg_1.Pool({
+        connectionString,
+        max: 1,
+        connectionTimeoutMillis: 5000,
+    });
+    try {
+        const client = await pool.connect();
+        await client.query('SELECT 1');
+        client.release();
+        return true;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        await pool.end();
+    }
+}