notoken-core 1.6.0 → 1.8.0

package/dist/utils/dbQuery.js

@@ -0,0 +1,248 @@
+/**
+ * Natural language → SQL query builder.
+ *
+ * Translates phrases like:
+ *   "look at items and find sally"        → SELECT * FROM items WHERE ... LIKE '%sally%'
+ *   "show me all users"                   → SELECT * FROM users
+ *   "count orders"                        → SELECT COUNT(*) FROM orders
+ *   "show tables"                         → \dt (postgres) or SHOW TABLES (mysql)
+ *   "describe users table"                → \d users or DESCRIBE users
+ *   "find orders where total > 100"       → SELECT * FROM orders WHERE total > 100
+ */
+const c = {
+    reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m",
+    green: "\x1b[32m", yellow: "\x1b[33m", cyan: "\x1b[36m", red: "\x1b[31m",
+};
+/**
+ * Build a SQL query from natural language.
+ */
+export function buildQuery(rawText, fields, dbType = "postgres") {
+    const text = rawText.toLowerCase();
+    const table = fields.table ?? extractTable(text);
+    const search = fields.search ?? extractSearchTerm(text);
+    // "show tables" / "list tables"
+    if (text.match(/show\s+tables|list\s+tables|what\s+tables|which\s+tables/)) {
+        return dbType === "postgres"
+            ? { query: "\\dt", command: buildPsqlCmd(fields, "\\dt"), explanation: "List all tables" }
+            : { query: "SHOW TABLES;", command: buildMysqlCmd(fields, "SHOW TABLES;"), explanation: "List all tables" };
+    }
+    // "describe <table>" / "schema of <table>" / "columns in <table>"
+    const describeMatch = text.match(/describe\s+(\w+)|schema\s+(?:of\s+)?(\w+)|columns\s+(?:in\s+|of\s+)?(\w+)|structure\s+(?:of\s+)?(\w+)/);
+    if (describeMatch) {
+        const t = describeMatch[1] || describeMatch[2] || describeMatch[3] || describeMatch[4];
+        return dbType === "postgres"
+            ? { query: `\\d ${t}`, command: buildPsqlCmd(fields, `\\d ${t}`), explanation: `Describe table ${t}` }
+            : { query: `DESCRIBE ${t};`, command: buildMysqlCmd(fields, `DESCRIBE ${t};`), explanation: `Describe table ${t}` };
+    }
+    // "count <table>"
+    if (text.match(/count|how\s+many/)) {
+        if (table) {
+            const where = extractWhere(text, table);
+            const query = where
+                ? `SELECT COUNT(*) FROM ${table} WHERE ${where};`
+                : `SELECT COUNT(*) FROM ${table};`;
+            return {
+                query,
+                command: dbType === "postgres" ? buildPsqlCmd(fields, query) : buildMysqlCmd(fields, query),
+                explanation: `Count rows in ${table}${where ? ` where ${where}` : ""}`,
+            };
+        }
+    }
+    // Search query: "find sally in items" / "look at items find sally"
+    if (table && search) {
+        const query = `SELECT * FROM ${table} WHERE ${buildSearchWhere(search, table, dbType)} LIMIT 50;`;
+        return {
+            query,
+            command: dbType === "postgres" ? buildPsqlCmd(fields, query) : buildMysqlCmd(fields, query),
+            explanation: `Search ${table} for "${search}"`,
+        };
+    }
+    // Search with no table: "find sally" — search across all tables
+    if (search && !table) {
+        if (dbType === "postgres") {
+            // Build a script that searches all tables for the term
+            const query = buildSearchAllTablesPg(search);
+            return {
+                query,
+                command: buildPsqlCmd(fields, query),
+                explanation: `Search ALL tables for "${search}"`,
+            };
+        }
+        else {
+            const query = buildSearchAllTablesMysql(search, fields.database ?? "");
+            return {
+                query,
+                command: buildMysqlCmd(fields, query),
+                explanation: `Search ALL tables for "${search}"`,
+            };
+        }
+    }
+    // Simple select: "show me <table>" / "list <table>" / "all <table>"
+    if (table) {
+        const where = extractWhere(text, table);
+        const limit = extractLimit(text);
+        const query = where
+            ? `SELECT * FROM ${table} WHERE ${where} LIMIT ${limit};`
+            : `SELECT * FROM ${table} LIMIT ${limit};`;
+        return {
+            query,
+            command: dbType === "postgres" ? buildPsqlCmd(fields, query) : buildMysqlCmd(fields, query),
+            explanation: `Show rows from ${table}${where ? ` where ${where}` : ""}`,
+        };
+    }
+    // Fallback: raw query if it looks like SQL
+    if (text.match(/^(select|insert|update|delete|create|alter|drop)\s/i)) {
+        const query = rawText.trim().endsWith(";") ? rawText.trim() : rawText.trim() + ";";
+        return {
+            query,
+            command: dbType === "postgres" ? buildPsqlCmd(fields, query) : buildMysqlCmd(fields, query),
+            explanation: "Raw SQL query",
+        };
+    }
+    return {
+        query: "",
+        command: "",
+        explanation: "Could not build a query. Try: show tables, describe <table>, or select * from <table>",
+    };
+}
+// ─── Extractors ──────────────────────────────────────────────────────────────
+function extractTable(text) {
+    // "in <table>" / "from <table>" / "the <table> table" / "my <table>"
+    const patterns = [
+        /(?:from|in|at|into)\s+(?:the\s+)?(\w+)\s*(?:table)?/,
+        /(?:my|the|all)\s+(\w+)\s*(?:table)?/,
+        /(?:look\s+at|show|list|query|search|find\s+in)\s+(?:the\s+)?(?:my\s+)?(\w+)/,
+        /(\w+)\s+table/,
+    ];
+    for (const p of patterns) {
+        const match = text.match(p);
+        if (match) {
+            const t = match[1].toLowerCase();
+            // Filter out common non-table words
+            if (!["me", "all", "the", "my", "this", "that", "it", "and", "on", "to", "for", "with", "where", "tables", "database"].includes(t)) {
+                return t;
+            }
+        }
+    }
+    return null;
+}
+function extractSearchTerm(text) {
+    // "find <term>" / "has <term>" / "contains <term>" / "with <term>" / "named <term>"
+    const patterns = [
+        /(?:find|has|contains?|with|named|called|matching|like)\s+(?:the\s+)?['"]?(\w[\w\s]*?)['"]?\s*(?:in|$)/,
+        /(?:find|search\s+for|look\s+for)\s+['"]?(\w[\w\s]*?)['"]?\s*(?:in|from|$)/,
+        /(?:that\s+has|that\s+contains?)\s+['"]?(\w[\w\s]*?)['"]?/,
+        /(?:find\s+(?:the\s+)?(?:one\s+)?(?:that\s+)?(?:has\s+)?)?['"]?(\w+)['"]?\s*$/,
+    ];
+    for (const p of patterns) {
+        const match = text.match(p);
+        if (match) {
+            const term = match[1].trim();
+            if (term && !["it", "them", "the", "one", "that"].includes(term.toLowerCase())) {
+                return term;
+            }
+        }
+    }
+    return null;
+}
+function extractWhere(text, table) {
+    // "where <condition>" — pass through
+    const whereMatch = text.match(/where\s+(.+?)(?:\s+limit|\s*$)/);
+    if (whereMatch)
+        return whereMatch[1].trim();
+    return null;
+}
+function extractLimit(text) {
+    const match = text.match(/(?:limit|top|first|last)\s+(\d+)/);
+    if (match)
+        return parseInt(match[1]);
+    // "show me 20 users" / "10 orders"
+    const numMatch = text.match(/(?:show|list|get)\s+(?:me\s+)?(\d+)/);
+    if (numMatch)
+        return parseInt(numMatch[1]);
+    return 50;
+}
+function buildSearchWhere(search, table, dbType) {
+    const escaped = escapeSql(search);
+    if (dbType === "postgres") {
+        // Cast entire row to text and search — works across all columns
+        return `${table}::text ILIKE '%${escaped}%'`;
+    }
+    // MySQL: search common text column names
+    return `CONCAT_WS(' ', COALESCE(name,''), COALESCE(title,''), COALESCE(email,''), COALESCE(description,''), COALESCE(username,''), COALESCE(first_name,''), COALESCE(last_name,'')) LIKE '%${escaped}%'`;
+}
+/**
+ * Postgres: search all tables for a term.
+ * Casts each row to text and checks with ILIKE.
+ */
+function buildSearchAllTablesPg(search) {
+    const escaped = escapeSql(search);
+    // Use a DO block that iterates through all user tables
+    return `DO $$
+DECLARE
+  r RECORD;
+  tbl TEXT;
+  cnt INTEGER;
+BEGIN
+  FOR r IN SELECT tablename FROM pg_tables WHERE schemaname = 'public' LOOP
+    tbl := r.tablename;
+    EXECUTE format('SELECT COUNT(*) FROM %I WHERE %I::text ILIKE $1', tbl, tbl) INTO cnt USING '%${escaped}%';
+    IF cnt > 0 THEN
+      RAISE NOTICE 'Found % match(es) in table: %', cnt, tbl;
+    END IF;
+  END LOOP;
+END $$;`;
+}
+/**
+ * MySQL: search all tables for a term.
+ */
+function buildSearchAllTablesMysql(search, database) {
+    const escaped = escapeSql(search);
+    // MySQL approach: generate SELECT statements for each table
+    return `SELECT TABLE_NAME, COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = '${database || "DATABASE()"}' AND DATA_TYPE IN ('varchar','text','char','longtext','mediumtext') ORDER BY TABLE_NAME;`;
+}
+function escapeSql(val) {
+    return val.replace(/'/g, "''").replace(/\\/g, "\\\\");
+}
+// ─── Command builders ────────────────────────────────────────────────────────
+function buildPsqlCmd(fields, query) {
+    const db = fields.database ?? "";
+    const host = fields.host ?? "";
+    const user = fields.user ?? "";
+    const parts = ["psql"];
+    if (host)
+        parts.push(`-h ${host}`);
+    if (user)
+        parts.push(`-U ${user}`);
+    if (db)
+        parts.push(db);
+    parts.push(`-c ${JSON.stringify(query)}`);
+    return parts.join(" ");
+}
+function buildMysqlCmd(fields, query) {
+    const db = fields.database ?? "";
+    const host = fields.host ?? "";
+    const user = fields.user ?? "";
+    const parts = ["mysql"];
+    if (host)
+        parts.push(`-h ${host}`);
+    if (user)
+        parts.push(`-u ${user}`);
+    if (db)
+        parts.push(db);
+    parts.push(`-e ${JSON.stringify(query)}`);
+    return parts.join(" ");
+}
+/**
+ * Format query result for display — show the SQL, explain it, then run.
+ */
+export function formatQueryPlan(result) {
+    if (!result.query)
+        return result.explanation;
+    const lines = [];
+    lines.push(`\n${c.bold}${c.cyan}── Query Plan ──${c.reset}\n`);
+    lines.push(`  ${c.bold}SQL:${c.reset}  ${c.green}${result.query}${c.reset}`);
+    lines.push(`  ${c.dim}${result.explanation}${c.reset}`);
+    lines.push(`  ${c.dim}Command: ${result.command}${c.reset}`);
+    return lines.join("\n");
+}

package/dist/utils/devTools.d.ts

@@ -0,0 +1,35 @@
+export declare function formatJson(input: string): {
+    formatted: string;
+    valid: boolean;
+    error?: string;
+};
+export declare function validateJson(input: string): {
+    valid: boolean;
+    error?: string;
+    parsed?: unknown;
+};
+export declare function testRegex(pattern: string, testString: string, flags?: string): {
+    matches: RegExpMatchArray[];
+    count: number;
+    groups: Record<string, string>[];
+};
+export declare function encodeBase64(input: string): string;
+export declare function decodeBase64(input: string): string;
+export declare function encodeUrl(input: string): string;
+export declare function decodeUrl(input: string): string;
+type HashAlgo = "md5" | "sha1" | "sha256";
+export declare function hashString(input: string, algo?: HashAlgo): string;
+export declare function hashFile(filepath: string, algo?: HashAlgo): Promise<string>;
+export declare function generateUuid(): string;
+export declare function convertUnixTimestamp(ts: number | string): {
+    unix: number;
+    iso: string;
+    utc: string;
+    local: string;
+};
+export declare function diffStrings(a: string, b: string): {
+    added: string[];
+    removed: string[];
+    diff: string;
+};
+export {};

package/dist/utils/devTools.js

@@ -0,0 +1,95 @@
+/**
+ * Developer utility tools — JSON, regex, encoding, hashing, UUID, timestamps, diff.
+ */
+import { createHash, randomUUID } from "node:crypto";
+import { readFile } from "node:fs/promises";
+// ── JSON ──
+export function formatJson(input) {
+    try {
+        const parsed = JSON.parse(input);
+        return { formatted: JSON.stringify(parsed, null, 2), valid: true };
+    }
+    catch (e) {
+        return { formatted: input, valid: false, error: e.message };
+    }
+}
+export function validateJson(input) {
+    try {
+        const parsed = JSON.parse(input);
+        return { valid: true, parsed };
+    }
+    catch (e) {
+        return { valid: false, error: e.message };
+    }
+}
+// ── Regex ──
+export function testRegex(pattern, testString, flags = "g") {
+    const re = new RegExp(pattern, flags);
+    const matches = [];
+    const groups = [];
+    let m;
+    while ((m = re.exec(testString)) !== null) {
+        matches.push([...m]);
+        if (m.groups)
+            groups.push({ ...m.groups });
+        if (!re.global)
+            break;
+    }
+    return { matches, count: matches.length, groups };
+}
+// ── Base64 ──
+export function encodeBase64(input) {
+    return Buffer.from(input, "utf-8").toString("base64");
+}
+export function decodeBase64(input) {
+    return Buffer.from(input, "base64").toString("utf-8");
+}
+// ── URL Encoding ──
+export function encodeUrl(input) {
+    return encodeURIComponent(input);
+}
+export function decodeUrl(input) {
+    return decodeURIComponent(input);
+}
+export function hashString(input, algo = "sha256") {
+    return createHash(algo).update(input, "utf-8").digest("hex");
+}
+export async function hashFile(filepath, algo = "sha256") {
+    const buf = await readFile(filepath);
+    return createHash(algo).update(buf).digest("hex");
+}
+// ── UUID ──
+export function generateUuid() {
+    return randomUUID();
+}
+// ── Timestamps ──
+export function convertUnixTimestamp(ts) {
+    const num = typeof ts === "string" ? Number(ts) : ts;
+    // Auto-detect seconds vs milliseconds
+    const ms = num > 1e12 ? num : num * 1000;
+    const d = new Date(ms);
+    return {
+        unix: Math.floor(ms / 1000),
+        iso: d.toISOString(),
+        utc: d.toUTCString(),
+        local: d.toString(),
+    };
+}
+// ── Simple Word-Level Diff ──
+export function diffStrings(a, b) {
+    const wordsA = a.split(/\s+/).filter(Boolean);
+    const wordsB = b.split(/\s+/).filter(Boolean);
+    const setA = new Set(wordsA);
+    const setB = new Set(wordsB);
+    const removed = wordsA.filter((w) => !setB.has(w));
+    const added = wordsB.filter((w) => !setA.has(w));
+    // Build a simple inline diff display
+    const lines = [];
+    if (removed.length)
+        lines.push(`- ${removed.join(" ")}`);
+    if (added.length)
+        lines.push(`+ ${added.join(" ")}`);
+    if (!removed.length && !added.length)
+        lines.push("(no differences)");
+    return { added, removed, diff: lines.join("\n") };
+}

package/dist/utils/discordDiag.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Discord bot diagnostics, setup, and auto-fix.
+ *
+ * `diagnoseDiscord()` — runs full checklist and auto-fixes everything:
+ *   1. Token valid?
+ *   2. Bot in guilds? → auto-invite via patchright
+ *   3. Intents enabled in OpenClaw config? → auto-fix
+ *   4. DM/group policy correct? → auto-fix
+ *   5. OpenClaw version check
+ *   6. Restart gateway if config changed
+ *   7. Poll gateway connection up to 60s
+ *   8. If 4014 error → enable intents via patchright → restart → re-poll
+ *   9. Check channels
+ *  10. Auto-approve pairing codes
+ *  11. Send test message + verify response
+ *
+ * The full chain runs end-to-end without stopping.
+ * User only needs to handle captcha/MFA when patchright prompts.
+ */
+/**
+ * Live Discord connection monitor.
+ * Prints real-time status updates as the gateway connects to Discord.
+ * Auto-restarts if stuck, auto-waits through rate limits.
+ *
+ * Usage: "monitor discord" or "watch discord"
+ */
+export declare function monitorDiscord(maxMinutes?: number): Promise<string>;
+/**
+ * Full Discord diagnostic and auto-fix chain.
+ */
+export declare function diagnoseDiscord(): Promise<string>;
+/**
+ * Quick Discord status check.
+ */
+export declare function quickDiscordCheck(): Promise<string>;