notoken-core 1.0.0

package/dist/parsers/apacheParser.js

@@ -0,0 +1,152 @@
+/**
+ * Apache config parser.
+ *
+ * Parses httpd.conf / apache2.conf and vhost configs.
+ * Handles: <VirtualHost>, <Directory>, <Location>, directives.
+ */
+/**
+ * Parse Apache config content.
+ */
+export function parseApache(content) {
+    const lines = content.split("\n");
+    const { directives, blocks } = parseApacheBlock(lines, 0, lines.length);
+    const vhosts = extractVHosts(blocks);
+    return { directives, blocks, vhosts };
+}
+function parseApacheBlock(lines, start, end) {
+    const directives = [];
+    const blocks = [];
+    let i = start;
+    while (i < end) {
+        const line = lines[i].trim();
+        if (!line || line.startsWith("#")) {
+            i++;
+            continue;
+        }
+        // Block opening: <VirtualHost *:80>, <Directory /var/www>
+        const openMatch = line.match(/^<(\w+)\s*(.*?)>$/);
+        if (openMatch) {
+            const tag = openMatch[1];
+            const args = openMatch[2] ?? "";
+            const closeTag = `</${tag}>`;
+            // Find matching closing tag
+            let j = i + 1;
+            let depth = 1;
+            while (j < end && depth > 0) {
+                const l = lines[j].trim();
+                if (l.match(new RegExp(`^<${tag}\\b`)))
+                    depth++;
+                if (l === closeTag || l.toLowerCase() === closeTag.toLowerCase())
+                    depth--;
+                if (depth > 0)
+                    j++;
+            }
+            const inner = parseApacheBlock(lines, i + 1, j);
+            blocks.push({
+                tag,
+                args,
+                directives: inner.directives,
+                blocks: inner.blocks,
+                line: i + 1,
+            });
+            i = j + 1;
+            continue;
+        }
+        // Closing tag (handled by the block parser above)
+        if (line.startsWith("</")) {
+            i++;
+            continue;
+        }
+        // Directive: ServerName example.com
+        const parts = line.match(/^(\S+)\s+(.*)/);
+        if (parts) {
+            directives.push({ name: parts[1], value: parts[2], line: i + 1 });
+        }
+        else {
+            directives.push({ name: line, value: "", line: i + 1 });
+        }
+        i++;
+    }
+    return { directives, blocks };
+}
+function extractVHosts(blocks) {
+    return blocks
+        .filter((b) => b.tag.toLowerCase() === "virtualhost")
+        .map((block) => {
+        const vhost = {
+            address: block.args,
+            serverAlias: [],
+            ssl: false,
+            locations: [],
+            directories: [],
+        };
+        for (const d of block.directives) {
+            switch (d.name.toLowerCase()) {
+                case "servername":
+                    vhost.serverName = d.value;
+                    break;
+                case "serveralias":
+                    vhost.serverAlias.push(...d.value.split(/\s+/));
+                    break;
+                case "documentroot":
+                    vhost.documentRoot = d.value;
+                    break;
+                case "errorlog":
+                    vhost.errorLog = d.value;
+                    break;
+                case "customlog":
+                    vhost.customLog = d.value.split(/\s+/)[0];
+                    break;
+                case "sslengine":
+                    vhost.ssl = d.value.toLowerCase() === "on";
+                    break;
+                case "sslcertificatefile":
+                    vhost.sslCertificate = d.value;
+                    vhost.ssl = true;
+                    break;
+                case "sslcertificatekeyfile":
+                    vhost.sslCertificateKey = d.value;
+                    break;
+            }
+        }
+        for (const sub of block.blocks) {
+            const tag = sub.tag.toLowerCase();
+            if (tag === "location") {
+                vhost.locations.push({ path: sub.args, directives: sub.directives });
+            }
+            if (tag === "directory") {
+                vhost.directories.push({ path: sub.args, directives: sub.directives });
+            }
+        }
+        return vhost;
+    });
+}
+/**
+ * Format an Apache config summary for display.
+ */
+export function formatApacheSummary(config) {
+    const c = { reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m", cyan: "\x1b[36m", green: "\x1b[32m", yellow: "\x1b[33m" };
+    const lines = [];
+    lines.push(`${c.bold}Apache Config Summary${c.reset}`);
+    lines.push(`  ${config.vhosts.length} VirtualHost(s)\n`);
+    for (const vh of config.vhosts) {
+        const sslLabel = vh.ssl ? ` ${c.green}[SSL]${c.reset}` : "";
+        lines.push(`  ${c.cyan}<VirtualHost ${vh.address}>${c.reset}${sslLabel}`);
+        if (vh.serverName)
+            lines.push(`    ServerName: ${c.bold}${vh.serverName}${c.reset}`);
+        if (vh.serverAlias.length)
+            lines.push(`    ServerAlias: ${vh.serverAlias.join(", ")}`);
+        if (vh.documentRoot)
+            lines.push(`    DocumentRoot: ${vh.documentRoot}`);
+        if (vh.errorLog)
+            lines.push(`    ErrorLog: ${vh.errorLog}`);
+        for (const loc of vh.locations) {
+            lines.push(`    ${c.dim}<Location ${loc.path}>${c.reset}`);
+        }
+        for (const dir of vh.directories) {
+            lines.push(`    ${c.dim}<Directory ${dir.path}>${c.reset}`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}

package/dist/parsers/bindParser.d.ts

@@ -0,0 +1,40 @@
+/**
+ * BIND zone file parser.
+ *
+ * Parses DNS zone files and extracts:
+ * - SOA record (primary NS, admin, serial, timers)
+ * - A, AAAA, CNAME, MX, NS, TXT, SRV, PTR records
+ * - $TTL, $ORIGIN directives
+ */
+export interface DnsRecord {
+    name: string;
+    ttl?: number;
+    class: string;
+    type: string;
+    data: string;
+    priority?: number;
+    line: number;
+}
+export interface SoaRecord {
+    primaryNS: string;
+    adminEmail: string;
+    serial: number;
+    refresh: number;
+    retry: number;
+    expire: number;
+    minimum: number;
+}
+export interface ZoneFile {
+    origin?: string;
+    defaultTTL?: number;
+    soa?: SoaRecord;
+    records: DnsRecord[];
+}
+/**
+ * Parse a BIND zone file.
+ */
+export declare function parseZoneFile(content: string): ZoneFile;
+/**
+ * Format a zone file summary for display.
+ */
+export declare function formatZoneSummary(zone: ZoneFile): string;

package/dist/parsers/bindParser.js

@@ -0,0 +1,189 @@
+/**
+ * BIND zone file parser.
+ *
+ * Parses DNS zone files and extracts:
+ * - SOA record (primary NS, admin, serial, timers)
+ * - A, AAAA, CNAME, MX, NS, TXT, SRV, PTR records
+ * - $TTL, $ORIGIN directives
+ */
+/**
+ * Parse a BIND zone file.
+ */
+export function parseZoneFile(content) {
+    const lines = content.split("\n");
+    const zone = { records: [] };
+    let currentName = "@";
+    let inSOA = false;
+    let soaBuffer = "";
+    for (let i = 0; i < lines.length; i++) {
+        let line = lines[i];
+        // Strip comments
+        const commentIdx = line.indexOf(";");
+        if (commentIdx !== -1)
+            line = line.slice(0, commentIdx);
+        line = line.trimEnd();
+        if (!line.trim())
+            continue;
+        // $ORIGIN directive
+        const originMatch = line.match(/^\$ORIGIN\s+(\S+)/i);
+        if (originMatch) {
+            zone.origin = originMatch[1];
+            continue;
+        }
+        // $TTL directive
+        const ttlMatch = line.match(/^\$TTL\s+(\S+)/i);
+        if (ttlMatch) {
+            zone.defaultTTL = parseTTL(ttlMatch[1]);
+            continue;
+        }
+        // SOA record (may span multiple lines)
+        if (line.toUpperCase().includes("SOA") && !inSOA) {
+            inSOA = true;
+            soaBuffer = line;
+            if (line.includes(")")) {
+                zone.soa = parseSOA(soaBuffer) ?? undefined;
+                inSOA = false;
+                soaBuffer = "";
+            }
+            continue;
+        }
+        if (inSOA) {
+            soaBuffer += " " + line.trim();
+            if (line.includes(")")) {
+                zone.soa = parseSOA(soaBuffer) ?? undefined;
+                inSOA = false;
+                soaBuffer = "";
+            }
+            continue;
+        }
+        // Regular records
+        const record = parseRecord(line, currentName, i + 1);
+        if (record) {
+            if (record.name !== "")
+                currentName = record.name;
+            else
+                record.name = currentName;
+            zone.records.push(record);
+        }
+    }
+    return zone;
+}
+function parseRecord(line, currentName, lineNum) {
+    const parts = line.trim().split(/\s+/);
+    if (parts.length < 2)
+        return null;
+    let idx = 0;
+    let name = "";
+    let ttl;
+    let cls = "IN";
+    let type = "";
+    let data = "";
+    // First token: name or empty (continuation of previous name)
+    if (line.match(/^\s/)) {
+        name = "";
+        idx = 0;
+    }
+    else {
+        name = parts[0];
+        idx = 1;
+    }
+    // Optional TTL (number)
+    if (idx < parts.length && /^\d+[smhdwSMHDW]?$/.test(parts[idx])) {
+        ttl = parseTTL(parts[idx]);
+        idx++;
+    }
+    // Optional class (IN, CH, HS)
+    if (idx < parts.length && /^(IN|CH|HS)$/i.test(parts[idx])) {
+        cls = parts[idx].toUpperCase();
+        idx++;
+    }
+    // Type
+    if (idx < parts.length) {
+        type = parts[idx].toUpperCase();
+        idx++;
+    }
+    if (!type || type === "SOA")
+        return null;
+    // Data (rest of line)
+    data = parts.slice(idx).join(" ");
+    // Extract priority for MX and SRV
+    let priority;
+    if ((type === "MX" || type === "SRV") && /^\d+/.test(data)) {
+        const pMatch = data.match(/^(\d+)\s+(.*)/);
+        if (pMatch) {
+            priority = Number(pMatch[1]);
+            data = pMatch[2];
+        }
+    }
+    return { name: name || currentName, ttl, class: cls, type, data, priority, line: lineNum };
+}
+function parseSOA(raw) {
+    // Extract the parenthesized section
+    const parts = raw.replace(/[()]/g, " ").split(/\s+/).filter(Boolean);
+    // Find SOA keyword position
+    const soaIdx = parts.findIndex((p) => p.toUpperCase() === "SOA");
+    if (soaIdx === -1)
+        return null;
+    const afterSOA = parts.slice(soaIdx + 1);
+    if (afterSOA.length < 7)
+        return null;
+    return {
+        primaryNS: afterSOA[0],
+        adminEmail: afterSOA[1],
+        serial: Number(afterSOA[2]) || 0,
+        refresh: parseTTL(afterSOA[3]),
+        retry: parseTTL(afterSOA[4]),
+        expire: parseTTL(afterSOA[5]),
+        minimum: parseTTL(afterSOA[6]),
+    };
+}
+function parseTTL(value) {
+    const num = parseInt(value, 10);
+    if (isNaN(num))
+        return 0;
+    const suffix = value.slice(String(num).length).toLowerCase();
+    switch (suffix) {
+        case "s": return num;
+        case "m": return num * 60;
+        case "h": return num * 3600;
+        case "d": return num * 86400;
+        case "w": return num * 604800;
+        default: return num;
+    }
+}
+/**
+ * Format a zone file summary for display.
+ */
+export function formatZoneSummary(zone) {
+    const c = { reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m", cyan: "\x1b[36m" };
+    const lines = [];
+    lines.push(`${c.bold}DNS Zone File${c.reset}`);
+    if (zone.origin)
+        lines.push(`  Origin: ${zone.origin}`);
+    if (zone.defaultTTL)
+        lines.push(`  Default TTL: ${zone.defaultTTL}s`);
+    if (zone.soa) {
+        lines.push(`\n  ${c.cyan}SOA:${c.reset}`);
+        lines.push(`    Primary NS: ${zone.soa.primaryNS}`);
+        lines.push(`    Admin: ${zone.soa.adminEmail}`);
+        lines.push(`    Serial: ${zone.soa.serial}`);
+    }
+    // Group by type
+    const byType = new Map();
+    for (const r of zone.records) {
+        const list = byType.get(r.type) ?? [];
+        list.push(r);
+        byType.set(r.type, list);
+    }
+    for (const [type, records] of byType) {
+        lines.push(`\n  ${c.cyan}${type} records (${records.length}):${c.reset}`);
+        for (const r of records.slice(0, 20)) {
+            const pri = r.priority !== undefined ? ` [pri=${r.priority}]` : "";
+            const ttl = r.ttl !== undefined ? ` TTL=${r.ttl}` : "";
+            lines.push(`    ${r.name.padEnd(20)} → ${r.data}${pri}${c.dim}${ttl}${c.reset}`);
+        }
+        if (records.length > 20)
+            lines.push(`    ${c.dim}... and ${records.length - 20} more${c.reset}`);
+    }
+    return lines.join("\n");
+}

package/dist/parsers/envFile.d.ts

@@ -0,0 +1,39 @@
+/**
+ * .env file parser and writer.
+ *
+ * Reads KEY=VALUE pairs, detects secrets, supports comments.
+ */
+export interface EnvEntry {
+    key: string;
+    value: string;
+    comment?: string;
+    isSecret: boolean;
+    line: number;
+}
+/**
+ * Parse .env file content into entries.
+ */
+export declare function parseEnvFile(content: string): EnvEntry[];
+/**
+ * Get the value of a specific key.
+ */
+export declare function getEnvValue(entries: EnvEntry[], key: string): string | undefined;
+/**
+ * Set or update a key in env entries. Returns new content string.
+ */
+export declare function setEnvValue(content: string, key: string, value: string, comment?: string): string;
+/**
+ * Read, modify, and write back an .env file.
+ */
+export declare function updateEnvFile(filePath: string, key: string, value: string, comment?: string): void;
+/**
+ * Generate a smart variable name based on purpose and topic.
+ *
+ * Examples:
+ *   ("database", "password", "staging") → DB_STAGING_PASSWORD
+ *   ("api", "key", "prod")             → API_PROD_KEY
+ *   ("redis", "url", undefined)        → REDIS_URL
+ *   ("smtp", "password", "prod")       → SMTP_PROD_PASSWORD
+ *   ("aws", "secret", "production")    → AWS_PROD_SECRET
+ */
+export declare function generateEnvName(topic: string, purpose: string, environment?: string): string;

package/dist/parsers/envFile.js

@@ -0,0 +1,128 @@
+/**
+ * .env file parser and writer.
+ *
+ * Reads KEY=VALUE pairs, detects secrets, supports comments.
+ */
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+// Keys that likely contain secrets
+const SECRET_KEY_PATTERNS = [
+    /password/i, /passwd/i, /secret/i, /token/i, /api[_-]?key/i,
+    /private[_-]?key/i, /auth/i, /credential/i, /access[_-]?key/i,
+    /connection[_-]?string/i, /db[_-]?pass/i,
+];
+/**
+ * Parse .env file content into entries.
+ */
+export function parseEnvFile(content) {
+    const entries = [];
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (!line || line.startsWith("#"))
+            continue;
+        const match = line.match(/^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
+        if (!match)
+            continue;
+        const key = match[1];
+        let value = match[2];
+        // Strip surrounding quotes
+        if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        // Strip inline comment
+        let comment;
+        const commentMatch = value.match(/\s+#\s*(.*)$/);
+        if (commentMatch && !value.startsWith('"')) {
+            comment = commentMatch[1];
+            value = value.slice(0, value.indexOf(commentMatch[0]));
+        }
+        const isSecret = SECRET_KEY_PATTERNS.some((p) => p.test(key));
+        entries.push({ key, value, comment, isSecret, line: i + 1 });
+    }
+    return entries;
+}
+/**
+ * Get the value of a specific key.
+ */
+export function getEnvValue(entries, key) {
+    return entries.find((e) => e.key === key)?.value;
+}
+/**
+ * Set or update a key in env entries. Returns new content string.
+ */
+export function setEnvValue(content, key, value, comment) {
+    const lines = content.split("\n");
+    const pattern = new RegExp(`^${key}=`);
+    const newLine = comment ? `${key}=${value} # ${comment}` : `${key}=${value}`;
+    for (let i = 0; i < lines.length; i++) {
+        if (pattern.test(lines[i].trim())) {
+            lines[i] = newLine;
+            return lines.join("\n");
+        }
+    }
+    // Key not found — append
+    lines.push(newLine);
+    return lines.join("\n");
+}
+/**
+ * Read, modify, and write back an .env file.
+ */
+export function updateEnvFile(filePath, key, value, comment) {
+    const content = existsSync(filePath) ? readFileSync(filePath, "utf-8") : "";
+    const updated = setEnvValue(content, key, value, comment);
+    writeFileSync(filePath, updated);
+}
+/**
+ * Generate a smart variable name based on purpose and topic.
+ *
+ * Examples:
+ *   ("database", "password", "staging") → DB_STAGING_PASSWORD
+ *   ("api", "key", "prod")             → API_PROD_KEY
+ *   ("redis", "url", undefined)        → REDIS_URL
+ *   ("smtp", "password", "prod")       → SMTP_PROD_PASSWORD
+ *   ("aws", "secret", "production")    → AWS_PROD_SECRET
+ */
+export function generateEnvName(topic, purpose, environment) {
+    const parts = [];
+    // Topic aliases
+    const topicMap = {
+        database: "DB", db: "DB", postgres: "DB", postgresql: "DB", mysql: "DB", mongo: "DB",
+        redis: "REDIS", cache: "REDIS",
+        api: "API", rest: "API",
+        smtp: "SMTP", email: "SMTP", mail: "SMTP",
+        aws: "AWS", s3: "AWS_S3", gcp: "GCP", azure: "AZURE",
+        jwt: "JWT", auth: "AUTH", oauth: "OAUTH",
+        stripe: "STRIPE", twilio: "TWILIO", sendgrid: "SENDGRID",
+        github: "GITHUB", gitlab: "GITLAB",
+        docker: "DOCKER", k8s: "K8S", kubernetes: "K8S",
+        sentry: "SENTRY", datadog: "DATADOG",
+        app: "APP", server: "SERVER", node: "NODE",
+    };
+    parts.push(topicMap[topic.toLowerCase()] ?? topic.toUpperCase().replace(/[^A-Z0-9]/g, "_"));
+    // Environment in the middle
+    if (environment) {
+        const envMap = {
+            production: "PROD", prod: "PROD",
+            staging: "STAGING", stage: "STAGING",
+            development: "DEV", dev: "DEV",
+            test: "TEST", local: "LOCAL",
+        };
+        parts.push(envMap[environment.toLowerCase()] ?? environment.toUpperCase());
+    }
+    // Purpose aliases
+    const purposeMap = {
+        password: "PASSWORD", pass: "PASSWORD", passwd: "PASSWORD",
+        key: "KEY", apikey: "KEY", "api-key": "KEY", "api_key": "KEY",
+        secret: "SECRET", "secret-key": "SECRET_KEY",
+        token: "TOKEN", "access-token": "ACCESS_TOKEN",
+        url: "URL", uri: "URL", endpoint: "URL", host: "HOST",
+        port: "PORT",
+        user: "USER", username: "USER",
+        name: "NAME",
+        connection: "CONNECTION_STRING", "connection-string": "CONNECTION_STRING",
+        region: "REGION",
+        bucket: "BUCKET",
+    };
+    parts.push(purposeMap[purpose.toLowerCase()] ?? purpose.toUpperCase().replace(/[^A-Z0-9]/g, "_"));
+    return parts.join("_");
+}

package/dist/parsers/fileFinder.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Smart file finder.
+ *
+ * When a user asks about a specific file or config, searches known locations
+ * by file type, service, and name. Works locally or remotely via SSH.
+ *
+ * Reads locations from config/file-hints.json so users can extend it.
+ */
+export interface FileLocation {
+    path: string;
+    description: string;
+}
+/**
+ * Known file locations by category.
+ * These are the standard/common paths on Linux systems.
+ */
+export declare const KNOWN_LOCATIONS: Record<string, FileLocation[]>;
+/**
+ * Find files for a given query (service name, file type, or filename).
+ * Reads from config/file-hints.json.
+ */
+export declare function findKnownLocations(query: string): FileLocation[];
+/**
+ * Get the recommended parser type for a service.
+ */
+export declare function getParserForService(service: string): string;
+/**
+ * Search for a file on a remote server.
+ */
+export declare function searchRemoteFile(query: string, environment: string, execution?: "remote" | "local"): Promise<string[]>;