error-ux-cli 1.0.0 → 1.1.1

package/lib/dashboard.mjs

@@ -74,7 +74,7 @@ function LiveStatus() {
     return e(Text, {color: 'yellow'}, statuses[tick % statuses.length]);
 }
 
-function IntroPanel({done}) {
+function IntroPanel({done, name}) {
     return e(
         Box,
         {borderStyle: 'round', width: 68, paddingX: 1, marginBottom: 1},
@@ -83,8 +83,8 @@ function IntroPanel({done}) {
             Box,
             {flexDirection: 'column', justifyContent: 'center'},
             done
-                ? e(Text, {bold: true, color: 'green'}, 'Welcome Aniruth')
-                : e(AnimatedText, {text: 'Welcome Aniruth', speed: 1}),
+                ? e(Text, {bold: true, color: 'green'}, `Welcome ${name}`)
+                : e(AnimatedText, {text: `Welcome ${name}`, speed: 1}),
             e(Text, {dimColor: true}, 'terminal cockpit online'),
             e(LiveStatus),
             e(LoadingBar, {width: 24})
@@ -115,7 +115,7 @@ function Dashboard({data}) {
     return e(
         Box,
         {flexDirection: 'column'},
-        e(IntroPanel, {done: stage > 0}),
+        e(IntroPanel, {done: stage > 0, name: data.username}),
         stage >= 1 && e(
             Box,
             {borderStyle: 'double', width: 68, marginBottom: 1},

package/lib/dbExplorer.mjs

@@ -0,0 +1,284 @@
+import React, { useState, useEffect, useMemo } from 'react';
+import { Box, Text, render, useApp, useInput } from 'ink';
+import pg from './pgClient.js';
+
+const e = React.createElement;
+
+// --- Components ---
+
+function Header({ config, level, context, isQueryMode }) {
+    let path = 'DB';
+    if (level >= 1) path += ` > ${context.db}`;
+    if (level >= 2) path += ` > ${context.schema}`;
+    if (level >= 3) path += ` > ${context.table}`;
+    if (isQueryMode) path += ' > CUSTOM QUERY';
+
+    return e(
+        Box,
+        { borderStyle: 'double', borderColor: 'magenta', paddingX: 1, marginBottom: 1 },
+        e(Text, { color: 'cyan', bold: true }, ' \u26A1 PG GOD-MODE EXPLORER '),
+        e(Text, { color: 'white' }, ` [${path}] `)
+    );
+}
+
+function Pane({ title, width, children, active, color = 'cyan' }) {
+    return e(
+        Box,
+        {
+            flexDirection: 'column',
+            borderStyle: 'double',
+            borderColor: active ? 'magenta' : 'gray',
+            width,
+            height: 20,
+            paddingX: 1,
+            marginRight: 1
+        },
+        e(Text, { bold: true, color: active ? 'magenta' : color }, title),
+        e(Box, { flexDirection: 'column', marginTop: 1 }, children)
+    );
+}
+
+function ColumnRow({ column, selected }) {
+    const primaryIcon = column.is_primary ? '🔑 ' : '   ';
+    return e(
+        Box,
+        null,
+        e(Text, { color: selected ? 'magenta' : 'white' }, primaryIcon),
+        e(Box, { width: 15 }, e(Text, { color: selected ? 'magenta' : 'white' }, column.column_name)),
+        e(Box, { width: 12 }, e(Text, { dimColor: true }, column.data_type)),
+        e(Text, { dimColor: true }, column.is_nullable === 'YES' ? 'null' : 'not null')
+    );
+}
+
+// --- Main Explorer ---
+
+function Explorer({ credentials }) {
+    const { exit } = useApp();
+    const [level, setLevel] = useState(0); // 0: DB, 1: Schema, 2: Table
+    const [context, setContext] = useState({ db: '', schema: '', table: '' });
+    const [items, setItems] = useState([]);
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [search, setSearch] = useState('');
+    const [metadata, setMetadata] = useState([]);
+    const [preview, setPreview] = useState([]);
+    const [error, setError] = useState(null);
+    const [isQueryMode, setIsQueryMode] = useState(false);
+    const [customQuery, setCustomQuery] = useState('');
+    const [queryResult, setQueryResult] = useState(null);
+
+    // Filtered items based on search
+    const filteredItems = useMemo(() => {
+        if (!search) return items;
+        return items.filter(item => item.toLowerCase().includes(search.toLowerCase()));
+    }, [items, search]);
+
+    // Fetch Level Data
+    useEffect(() => {
+        if (isQueryMode) return;
+        const fetchData = async () => {
+            try {
+                setError(null);
+                setSearch('');
+                setSelectedIndex(0);
+
+                if (level === 0) {
+                    const dbs = await pg.listDatabases(credentials);
+                    setItems(dbs);
+                } else if (level === 1) {
+                    const schemas = await pg.listSchemas({ ...credentials, database: context.db });
+                    setItems(schemas);
+                } else if (level === 2) {
+                    const tables = await pg.listTables({ ...credentials, database: context.db }, context.schema);
+                    setItems(tables);
+                }
+            } catch (err) {
+                setError(err.message);
+            }
+        };
+        fetchData();
+    }, [level, context.db, context.schema, credentials, isQueryMode]);
+
+    // Fetch Table Metadata/Preview
+    useEffect(() => {
+        if (isQueryMode) return;
+        if (level === 2 && filteredItems[selectedIndex]) {
+            const tableName = filteredItems[selectedIndex];
+            const fetchTableDetails = async () => {
+                try {
+                    const meta = await pg.getTableMetadata({ ...credentials, database: context.db }, context.schema, tableName);
+                    setMetadata(meta);
+                    const data = await pg.getTablePreview({ ...credentials, database: context.db }, context.schema, tableName);
+                    setPreview(data);
+                } catch (err) {
+                    setMetadata([]);
+                    setPreview([]);
+                }
+            };
+            fetchTableDetails();
+        } else {
+            setMetadata([]);
+            setPreview([]);
+        }
+    }, [level, selectedIndex, filteredItems, context.db, context.schema, credentials, isQueryMode]);
+
+    // Keyboard Input
+    useInput((input, key) => {
+        if (isQueryMode) {
+            if (key.escape) {
+                setIsQueryMode(false);
+                setCustomQuery('');
+                return;
+            }
+            if (key.return) {
+                const runQuery = async () => {
+                    try {
+                        const res = await pg.manualQuery({ ...credentials, database: context.db || 'postgres' }, customQuery);
+                        setQueryResult(res);
+                        setError(null);
+                    } catch (err) {
+                        setError(err.message);
+                        setQueryResult(null);
+                    }
+                };
+                runQuery();
+                return;
+            }
+            if (key.backspace) {
+                setCustomQuery(prev => prev.slice(0, -1));
+                return;
+            }
+            if (input) {
+                setCustomQuery(prev => prev + input);
+                return;
+            }
+            return;
+        }
+
+        if (key.escape) {
+            if (level > 0) setLevel(level - 1);
+            else exit();
+        }
+
+        if (key.upArrow) setSelectedIndex(prev => Math.max(0, prev - 1));
+        if (key.downArrow) setSelectedIndex(prev => Math.min(filteredItems.length - 1, prev + 1));
+
+        if (key.return) {
+            const selected = filteredItems[selectedIndex];
+            if (!selected) return;
+
+            if (level === 0) {
+                setContext(prev => ({ ...prev, db: selected }));
+                setLevel(1);
+            } else if (level === 1) {
+                setContext(prev => ({ ...prev, schema: selected }));
+                setLevel(2);
+            }
+        }
+
+        // Toggle Query Mode
+        if (input.toLowerCase() === 's') {
+            setIsQueryMode(true);
+            return;
+        }
+
+        if (!key.ctrl && !key.meta && input.length === 1 && /^[a-z0-9_]$/i.test(input)) {
+            setSearch(prev => prev + input);
+            setSelectedIndex(0);
+        }
+        if (key.backspace) {
+            setSearch(prev => prev.slice(0, -1));
+            setSelectedIndex(0);
+        }
+    });
+
+    const listTitle = level === 0 ? 'Databases' : level === 1 ? 'Schemas' : 'Tables';
+
+    return e(
+        Box,
+        { flexDirection: 'column' },
+        e(Header, { config: credentials, level, context, isQueryMode }),
+
+        e(
+            Box,
+            { flexDirection: 'row' },
+            // Navigator or Query Box
+            isQueryMode ? e(
+                Pane,
+                { title: '[ SQL CONSOLE ]', width: 80, active: true },
+                e(Text, { color: 'yellow' }, 'Query: ' + customQuery + '_'),
+                e(Text, { dimColor: true, marginTop: 1 }, 'Press [Enter] to Execute | [Esc] to Exit'),
+                queryResult && e(
+                    Box,
+                    { flexDirection: 'column', marginTop: 1 },
+                    e(Text, { color: 'cyan' }, 'Result (First 5 Rows):'),
+                    e(Text, null, JSON.stringify(queryResult.slice(0, 5), null, 2).slice(0, 500))
+                )
+            ) : e(
+                React.Fragment,
+                null,
+                e(
+                    Pane,
+                    { title: `[ ${listTitle} ]`, width: 35, active: true },
+                    search && e(Text, { color: 'yellow' }, `Search: ${search}`),
+                    (() => {
+                        const visibleCount = 15;
+                        const startIndex = Math.max(0, Math.min(selectedIndex - Math.floor(visibleCount / 2), Math.max(0, filteredItems.length - visibleCount)));
+                        const visibleItems = filteredItems.slice(startIndex, startIndex + visibleCount);
+
+                        return [
+                            startIndex > 0 && e(Text, { dimColor: true, alignSelf: 'center' }, '^ more ^'),
+                            ...visibleItems.map((item, i) => {
+                                const actualIndex = startIndex + i;
+                                const isSelected = actualIndex === selectedIndex;
+                                return e(Text, { key: item, color: isSelected ? 'magenta' : 'white', wrap: 'truncate-end' },
+                                    isSelected ? `\u25B6 ${item}` : `  ${item}`);
+                            }),
+                            (startIndex + visibleCount < filteredItems.length) && e(Text, { dimColor: true, alignSelf: 'center' }, 'v more v')
+                        ];
+                    })(),
+                    filteredItems.length === 0 && e(Text, { dimColor: true }, ' No entries ')
+                ),
+
+                // Schema Detail
+                level === 2 && e(
+                    Pane,
+                    { title: '[ Table Schema ]', width: 50, active: false, color: 'cyan' },
+                    ...metadata.slice(0, 15).map((col, i) => e(ColumnRow, { key: i, column: col }))
+                ),
+
+                // Help Message
+                level < 2 && e(
+                    Pane,
+                    { title: '[ Help ]', width: 50, active: false, color: 'gray' },
+                    e(Text, null, 'Use \u2191\u2193 to navigate'),
+                    e(Text, null, 'Press [Enter] to select'),
+                    e(Text, null, 'Type to filter entities'),
+                    e(Text, { color: 'cyan' }, 'Press [s] for Custom SQL'),
+                    e(Text, null, 'Press [Esc] to go back')
+                )
+            )
+        ),
+
+        // Data Preview
+        !isQueryMode && level === 2 && e(
+            Box,
+            {
+                borderStyle: 'double',
+                borderColor: 'gray',
+                width: 86,
+                paddingX: 1,
+                marginTop: 1,
+                flexDirection: 'column'
+            },
+            e(Text, { bold: true, color: 'yellow' }, '[ Data Preview (Top 5 Rows) ]'),
+            preview.length > 0 ? e(Text, null, JSON.stringify(preview[0]).slice(0, 80) + '...') : e(Text, { dimColor: true }, 'No data or table empty')
+        ),
+
+        error && e(Text, { color: 'red', bold: true }, `\n\u26A0 DATABASE ERROR: ${error}`)
+    );
+}
+
+export async function renderExplorer(credentials) {
+    const instance = render(e(Explorer, { credentials }));
+    await instance.waitUntilExit();
+}

package/lib/git.js

@@ -1,6 +1,80 @@
 const { execSync } = require('child_process');
 const fs = require('fs/promises');
 const path = require('path');
+const https = require('https');
+
+/**
+ * Syncs vault data with a private GitHub Gist.
+ * @param {string} token GitHub PAT (standard user PAT)
+ * @param {string} gistId The ID of the Secret Gist
+ * @param {string} data Encrypted JSON blob (required for PUSH)
+ * @param {string} action 'push' or 'pull'
+ * @returns {Promise<string|null>}
+ */
+async function gistSync(token, gistId, data, action = 'pull') {
+    return new Promise((resolve, reject) => {
+        const options = {
+            hostname: 'api.github.com',
+            path: `/gists/${gistId}`,
+            method: action === 'push' ? 'PATCH' : 'GET',
+            headers: {
+                'Authorization': `Bearer ${token}`,
+                'User-Agent': 'error-ux-cli',
+                'Accept': 'application/vnd.github+json',
+                'X-GitHub-Api-Version': '2022-11-28'
+            }
+        };
+
+        if (action === 'push') {
+            options.headers['Content-Type'] = 'application/json';
+        }
+
+        const req = https.request(options, (res) => {
+            let body = '';
+            res.on('data', (d) => body += d);
+            res.on('end', () => {
+                if (res.statusCode >= 400) {
+                    const maskedId = gistId ? `...${gistId.slice(-4)}` : 'MISSING';
+                    return reject(new Error(`GitHub Error: ${res.statusCode} (ID: ${maskedId}) - ${body}`));
+                }
+                
+                try {
+                    const result = JSON.parse(body);
+                    if (action === 'pull') {
+                        // We assume the data is in a file named 'vault.json' or similar.
+                        // We'll just take the first file's content.
+                        const files = result.files || {};
+                        const fileName = Object.keys(files)[0];
+                        if (fileName) {
+                            resolve(files[fileName].content);
+                        } else {
+                            resolve(null);
+                        }
+                    } else {
+                        resolve(body);
+                    }
+                } catch (e) {
+                    reject(e);
+                }
+            });
+        });
+
+        req.on('error', (e) => reject(e));
+
+        if (action === 'push' && data) {
+            const payload = JSON.stringify({
+                files: {
+                    'vault.json': {
+                        content: data
+                    }
+                }
+            });
+            req.write(payload);
+        }
+
+        req.end();
+    });
+}
 
 function runGit(command) {
     try {
@@ -90,8 +164,17 @@ async function getNextBranchVersion(name) {
 async function branchExists(name) {
     const branch = sanitizeBranchName(name);
     try {
+        // Check local branches and current remote branches
         const output = runGit(`git branch -a --list ${quoteShellArg(branch)} ${quoteShellArg(`remotes/origin/${branch}`)}`);
-        return Boolean(String(output || '').trim());
+        if (Boolean(String(output || '').trim())) return true;
+
+        // Force a remote check if possible
+        try {
+            const remoteOutput = runGit(`git ls-remote --heads origin ${quoteShellArg(branch)}`);
+            return Boolean(String(remoteOutput || '').trim());
+        } catch (e) {
+            return false;
+        }
     } catch (error) {
         return false;
     }
@@ -190,8 +273,7 @@ async function getPushContext(args, savedRepos, rl) {
     }
 
     if (!targetRepo || !targetRepo.url) {
-        console.error('Error: No target repository configured.');
-        return null;
+        targetRepo = { name: 'origin', url: null };
     }
 
     return {
@@ -210,7 +292,12 @@ async function automatedPush(targetRepo, message, branchBase) {
     if (!currentRemote) {
         await setRemoteUrl(targetRepo.url, false);
     } else if (currentRemote !== targetRepo.url) {
-        await setRemoteUrl(targetRepo.url, true);
+        // If it exists but differs, update it
+        try {
+            await setRemoteUrl(targetRepo.url, true);
+        } catch (e) {
+            // If it somehow fails, try to force it or just ignore if it's already there
+        }
     }
 
     const branch = sanitizeBranchName(branchBase);
@@ -257,6 +344,7 @@ module.exports = {
     getNextBranchVersion,
     getRemoteUrl,
     getRepoRoot,
+    gistSync,
     initRepo,
     isGitRepo,
     runGit,

package/lib/pgClient.js

@@ -0,0 +1,102 @@
+const { Pool } = require('pg');
+
+/**
+ * Creates a connection pool for a specific database.
+ */
+function createPool(config) {
+    return new Pool({
+        host: config.host || 'localhost',
+        port: config.port || 5432,
+        user: config.user,
+        password: config.password,
+        database: config.database,
+        ssl: config.useSsl ? { rejectUnauthorized: false } : false,
+        connectionTimeoutMillis: 5000
+    });
+}
+
+/**
+ * Runs a query and handles the pool lifecycle for one-off tasks.
+ */
+async function query(config, sql, params = []) {
+    const pool = createPool(config);
+    try {
+        const res = await pool.query(sql, params);
+        return res.rows;
+    } finally {
+        await pool.end();
+    }
+}
+
+async function testConnection(config) {
+    return query(config, 'SELECT 1');
+}
+
+async function listDatabases(config) {
+    const rows = await query(config, 'SELECT datname FROM pg_database WHERE datistemplate = false ORDER BY datname ASC');
+    return rows.map(r => r.datname);
+}
+
+async function listSchemas(config) {
+    const rows = await query(config, "SELECT schema_name FROM information_schema.schemata WHERE schema_name NOT IN ('information_schema', 'pg_catalog') ORDER BY schema_name ASC");
+    return rows.map(r => r.schema_name);
+}
+
+async function listTables(config, schema = 'public') {
+    const rows = await query(config, "SELECT table_name FROM information_schema.tables WHERE table_schema = $1 AND table_type = 'BASE TABLE' ORDER BY table_name ASC", [schema]);
+    return rows.map(r => r.table_name);
+}
+
+async function getTableMetadata(config, schema, table) {
+    const sql = `
+        SELECT 
+            column_name, 
+            data_type, 
+            is_nullable, 
+            column_default,
+            (
+                SELECT 'YES'
+                FROM information_schema.key_column_usage kcu
+                JOIN information_schema.table_constraints tc ON kcu.constraint_name = tc.constraint_name
+                WHERE kcu.table_name = c.table_name 
+                AND kcu.column_name = c.column_name 
+                AND tc.constraint_type = 'PRIMARY KEY'
+            ) as is_primary
+        FROM information_schema.columns c
+        WHERE table_schema = $1 AND table_name = $2
+        ORDER BY ordinal_position ASC
+    `;
+    return query(config, sql, [schema, table]);
+}
+
+async function getTablePreview(config, schema, table, limit = 5) {
+    // Note: We use double quotes for schema/table names to handle mixed case/special chars safely
+    const sql = `SELECT * FROM "${schema}"."${table}" LIMIT ${limit}`;
+    return query(config, sql);
+}
+
+async function searchColumns(config, columnName) {
+    const sql = `
+        SELECT table_schema, table_name 
+        FROM information_schema.columns 
+        WHERE column_name ILIKE $1
+        AND table_schema NOT IN ('information_schema', 'pg_catalog')
+        ORDER BY table_schema, table_name
+    `;
+    return query(config, `%${columnName}%`);
+}
+
+async function manualQuery(config, sql) {
+    return query(config, sql);
+}
+
+module.exports = {
+    testConnection,
+    listDatabases,
+    listSchemas,
+    listTables,
+    getTableMetadata,
+    getTablePreview,
+    searchColumns,
+    manualQuery
+};

package/lib/plugins.js

@@ -0,0 +1,94 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const PLUGIN_DIR = path.join(os.homedir(), '.error-ux', 'plugins');
+
+function ensurePluginDir() {
+    if (!fs.existsSync(PLUGIN_DIR)) {
+        fs.mkdirSync(PLUGIN_DIR, { recursive: true });
+    }
+}
+
+/**
+ * Scans the plugin directory and loads valid JS plugins.
+ * Only called for Admin users.
+ */
+function loadPlugins() {
+    ensurePluginDir();
+    const plugins = {};
+    const files = fs.readdirSync(PLUGIN_DIR);
+
+    for (const file of files) {
+        if (file.endsWith('.js') && !file.startsWith('.')) {
+            try {
+                const pluginPath = path.join(PLUGIN_DIR, file);
+                // Clear cache to allow reloading if needed
+                delete require.cache[require.resolve(pluginPath)];
+                const plugin = require(pluginPath);
+
+                if (plugin.name && typeof plugin.run === 'function') {
+                    plugins[plugin.name.toLowerCase()] = {
+                        name: plugin.name,
+                        description: plugin.description || 'No description provided.',
+                        run: plugin.run
+                    };
+                }
+            } catch (err) {
+                console.error(`Failed to load plugin "${file}": ${err.message}`);
+            }
+        }
+    }
+    return plugins;
+}
+
+/**
+ * Returns an object containing the source code of all .js plugins.
+ * Used for Cloud Sync.
+ */
+function getAllPluginSource() {
+    ensurePluginDir();
+    const source = {};
+    const files = fs.readdirSync(PLUGIN_DIR);
+    for (const file of files) {
+        if (file.endsWith('.js')) {
+            const content = fs.readFileSync(path.join(PLUGIN_DIR, file), 'utf8');
+            source[file] = content;
+        }
+    }
+    return source;
+}
+
+/**
+ * Saves or updates a plugin file.
+ */
+function savePlugin(filename, content) {
+    ensurePluginDir();
+    const target = path.join(PLUGIN_DIR, filename);
+    fs.writeFileSync(target, content, 'utf8');
+}
+
+/**
+ * Deletes a plugin by name.
+ */
+function deletePlugin(name) {
+    const filename = name.endsWith('.js') ? name : `${name}.js`;
+    const target = path.join(PLUGIN_DIR, filename);
+    if (fs.existsSync(target)) {
+        fs.unlinkSync(target);
+        return true;
+    }
+    return false;
+}
+
+function getPluginDir() {
+    return PLUGIN_DIR;
+}
+
+module.exports = {
+    loadPlugins,
+    getPluginDir,
+    getAllPluginSource,
+    savePlugin,
+    deletePlugin
+};