@soederpop/luca 0.1.2 → 0.1.3

package/dist/node/features/dns.d.ts

@@ -0,0 +1,511 @@
+import { z } from 'zod';
+import { Feature } from '../feature.js';
+/** Supported DNS record types. */
+export type DnsRecordType = 'A' | 'AAAA' | 'CNAME' | 'MX' | 'NS' | 'TXT' | 'SOA' | 'PTR' | 'SRV' | 'CAA';
+export declare const DnsRecordSchema: z.ZodObject<{
+    name: z.ZodString;
+    ttl: z.ZodNumber;
+    class: z.ZodString;
+    type: z.ZodString;
+    value: z.ZodString;
+}, z.core.$strip>;
+export type DnsRecord = z.infer<typeof DnsRecordSchema>;
+export declare const MxRecordSchema: z.ZodObject<{
+    name: z.ZodString;
+    ttl: z.ZodNumber;
+    class: z.ZodString;
+    type: z.ZodString;
+    value: z.ZodString;
+    priority: z.ZodNumber;
+    exchange: z.ZodString;
+}, z.core.$strip>;
+export type MxRecord = z.infer<typeof MxRecordSchema>;
+export declare const SoaRecordSchema: z.ZodObject<{
+    name: z.ZodString;
+    ttl: z.ZodNumber;
+    class: z.ZodString;
+    type: z.ZodString;
+    value: z.ZodString;
+    mname: z.ZodString;
+    rname: z.ZodString;
+    serial: z.ZodNumber;
+    refresh: z.ZodNumber;
+    retry: z.ZodNumber;
+    expire: z.ZodNumber;
+    minimum: z.ZodNumber;
+}, z.core.$strip>;
+export type SoaRecord = z.infer<typeof SoaRecordSchema>;
+export declare const SrvRecordSchema: z.ZodObject<{
+    name: z.ZodString;
+    ttl: z.ZodNumber;
+    class: z.ZodString;
+    type: z.ZodString;
+    value: z.ZodString;
+    priority: z.ZodNumber;
+    weight: z.ZodNumber;
+    port: z.ZodNumber;
+    target: z.ZodString;
+}, z.core.$strip>;
+export type SrvRecord = z.infer<typeof SrvRecordSchema>;
+export declare const CaaRecordSchema: z.ZodObject<{
+    name: z.ZodString;
+    ttl: z.ZodNumber;
+    class: z.ZodString;
+    type: z.ZodString;
+    value: z.ZodString;
+    flags: z.ZodNumber;
+    tag: z.ZodString;
+    issuer: z.ZodString;
+}, z.core.$strip>;
+export type CaaRecord = z.infer<typeof CaaRecordSchema>;
+export declare const DnsQueryResultSchema: z.ZodObject<{
+    domain: z.ZodString;
+    type: z.ZodString;
+    server: z.ZodOptional<z.ZodString>;
+    records: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        ttl: z.ZodNumber;
+        class: z.ZodString;
+        type: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$strip>>;
+    queryTime: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type DnsQueryResult = z.infer<typeof DnsQueryResultSchema>;
+export declare const DnsOverviewSchema: z.ZodObject<{
+    domain: z.ZodString;
+    a: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        ttl: z.ZodNumber;
+        class: z.ZodString;
+        type: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$strip>>;
+    aaaa: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        ttl: z.ZodNumber;
+        class: z.ZodString;
+        type: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$strip>>;
+    cname: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        ttl: z.ZodNumber;
+        class: z.ZodString;
+        type: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$strip>>;
+    mx: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        ttl: z.ZodNumber;
+        class: z.ZodString;
+        type: z.ZodString;
+        value: z.ZodString;
+        priority: z.ZodNumber;
+        exchange: z.ZodString;
+    }, z.core.$strip>>;
+    ns: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        ttl: z.ZodNumber;
+        class: z.ZodString;
+        type: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$strip>>;
+    txt: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        ttl: z.ZodNumber;
+        class: z.ZodString;
+        type: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$strip>>;
+    soa: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        ttl: z.ZodNumber;
+        class: z.ZodString;
+        type: z.ZodString;
+        value: z.ZodString;
+        mname: z.ZodString;
+        rname: z.ZodString;
+        serial: z.ZodNumber;
+        refresh: z.ZodNumber;
+        retry: z.ZodNumber;
+        expire: z.ZodNumber;
+        minimum: z.ZodNumber;
+    }, z.core.$strip>>;
+    caa: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        ttl: z.ZodNumber;
+        class: z.ZodString;
+        type: z.ZodString;
+        value: z.ZodString;
+        flags: z.ZodNumber;
+        tag: z.ZodString;
+        issuer: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type DnsOverview = z.infer<typeof DnsOverviewSchema>;
+export declare const DnsStateSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    lastQuery: z.ZodOptional<z.ZodObject<{
+        domain: z.ZodString;
+        type: z.ZodString;
+        timestamp: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$loose>;
+export type DnsState = z.infer<typeof DnsStateSchema>;
+export declare const DnsOptionsSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    _cacheKey: z.ZodOptional<z.ZodString>;
+    cached: z.ZodOptional<z.ZodBoolean>;
+    enable: z.ZodOptional<z.ZodBoolean>;
+    server: z.ZodOptional<z.ZodString>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type DnsOptions = z.infer<typeof DnsOptionsSchema>;
+type QueryOptions = {
+    server?: string;
+    timeout?: number;
+    short?: boolean;
+};
+/**
+ * The Dns feature provides structured DNS lookups by wrapping the `dig` CLI.
+ *
+ * All query methods parse dig output into typed JSON objects, making it easy
+ * to explore and audit a domain's DNS configuration programmatically.
+ *
+ * @example
+ * ```typescript
+ * const dns = container.feature('dns')
+ *
+ * // Look up A records
+ * const result = await dns.resolve('example.com', 'A')
+ * console.log(result.records)
+ *
+ * // Get a full overview of all record types
+ * const overview = await dns.overview('example.com')
+ * console.log(overview.mx)  // mail servers
+ * console.log(overview.ns)  // nameservers
+ * console.log(overview.txt) // TXT records (SPF, DKIM, etc.)
+ *
+ * // Reverse lookup
+ * const ptr = await dns.reverse('8.8.8.8')
+ * console.log(ptr) // ['dns.google.']
+ * ```
+ *
+ * @extends Feature
+ */
+export declare class Dns extends Feature<DnsState, DnsOptions> {
+    static shortcut: "features.dns";
+    static description: string;
+    static stateSchema: z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        lastQuery: z.ZodOptional<z.ZodObject<{
+            domain: z.ZodString;
+            type: z.ZodString;
+            timestamp: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$loose>;
+    static optionsSchema: z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        _cacheKey: z.ZodOptional<z.ZodString>;
+        cached: z.ZodOptional<z.ZodBoolean>;
+        enable: z.ZodOptional<z.ZodBoolean>;
+        server: z.ZodOptional<z.ZodString>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    get initialState(): DnsState;
+    private _resolvedDigPath;
+    get proc(): import("./proc.js").ChildProcess;
+    /** Resolved path to the dig binary */
+    get digPath(): string;
+    /**
+     * Checks whether the `dig` binary is available on the system.
+     *
+     * @returns True if dig is installed and accessible
+     *
+     * @example
+     * ```typescript
+     * if (await dns.isAvailable()) {
+     *   const records = await dns.a('example.com')
+     * }
+     * ```
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * Resolves DNS records of a given type for a domain.
+     *
+     * This is the core query method. All convenience methods (a, aaaa, mx, etc.)
+     * delegate to this method.
+     *
+     * @param domain - The domain name to query
+     * @param type - The DNS record type to look up
+     * @param options - Optional query parameters
+     * @param options.server - DNS server to use (e.g. '8.8.8.8')
+     * @param options.timeout - Query timeout in seconds
+     * @param options.short - If true, returns only values (no TTL, class, etc.)
+     * @returns Parsed query result with typed records
+     *
+     * @example
+     * ```typescript
+     * const result = await dns.resolve('example.com', 'A')
+     * for (const record of result.records) {
+     *   console.log(`${record.name} -> ${record.value} (TTL: ${record.ttl}s)`)
+     * }
+     *
+     * // Query a specific DNS server
+     * const result = await dns.resolve('example.com', 'A', { server: '1.1.1.1' })
+     * ```
+     */
+    resolve(domain: string, type: DnsRecordType, options?: QueryOptions): Promise<DnsQueryResult>;
+    /**
+     * Looks up A (IPv4 address) records for a domain.
+     *
+     * @param domain - The domain name to query
+     * @param options - Optional query parameters
+     * @returns Array of A records
+     *
+     * @example
+     * ```typescript
+     * const records = await dns.a('google.com')
+     * // [{ name: 'google.com.', ttl: 300, class: 'IN', type: 'A', value: '142.250.x.x' }]
+     * ```
+     */
+    a(domain: string, options?: QueryOptions): Promise<DnsRecord[]>;
+    /**
+     * Looks up AAAA (IPv6 address) records for a domain.
+     *
+     * @param domain - The domain name to query
+     * @param options - Optional query parameters
+     * @returns Array of AAAA records
+     *
+     * @example
+     * ```typescript
+     * const records = await dns.aaaa('google.com')
+     * // [{ name: 'google.com.', ttl: 300, class: 'IN', type: 'AAAA', value: '2607:f8b0:...' }]
+     * ```
+     */
+    aaaa(domain: string, options?: QueryOptions): Promise<DnsRecord[]>;
+    /**
+     * Looks up CNAME (canonical name) records for a domain.
+     *
+     * @param domain - The domain name to query
+     * @param options - Optional query parameters
+     * @returns Array of CNAME records
+     *
+     * @example
+     * ```typescript
+     * const records = await dns.cname('www.github.com')
+     * // [{ name: 'www.github.com.', ttl: 3600, class: 'IN', type: 'CNAME', value: 'github.com.' }]
+     * ```
+     */
+    cname(domain: string, options?: QueryOptions): Promise<DnsRecord[]>;
+    /**
+     * Looks up MX (mail exchange) records for a domain.
+     *
+     * Returns enriched records with parsed priority and exchange fields.
+     *
+     * @param domain - The domain name to query
+     * @param options - Optional query parameters
+     * @returns Array of MX records with priority and exchange
+     *
+     * @example
+     * ```typescript
+     * const records = await dns.mx('google.com')
+     * // [{ name: 'google.com.', ttl: 300, type: 'MX', priority: 10, exchange: 'smtp.google.com.' }]
+     * ```
+     */
+    mx(domain: string, options?: QueryOptions): Promise<MxRecord[]>;
+    /**
+     * Looks up NS (nameserver) records for a domain.
+     *
+     * @param domain - The domain name to query
+     * @param options - Optional query parameters
+     * @returns Array of NS records
+     *
+     * @example
+     * ```typescript
+     * const records = await dns.ns('google.com')
+     * // [{ name: 'google.com.', ttl: 86400, type: 'NS', value: 'ns1.google.com.' }, ...]
+     * ```
+     */
+    ns(domain: string, options?: QueryOptions): Promise<DnsRecord[]>;
+    /**
+     * Looks up TXT records for a domain.
+     *
+     * TXT records often contain SPF policies, DKIM keys, domain verification tokens,
+     * and other metadata.
+     *
+     * @param domain - The domain name to query
+     * @param options - Optional query parameters
+     * @returns Array of TXT records
+     *
+     * @example
+     * ```typescript
+     * const records = await dns.txt('google.com')
+     * const spf = records.find(r => r.value.includes('v=spf1'))
+     * console.log(spf?.value) // 'v=spf1 include:_spf.google.com ~all'
+     * ```
+     */
+    txt(domain: string, options?: QueryOptions): Promise<DnsRecord[]>;
+    /**
+     * Looks up the SOA (Start of Authority) record for a domain.
+     *
+     * Returns enriched records with parsed SOA fields including primary nameserver,
+     * responsible party, serial number, and timing parameters.
+     *
+     * @param domain - The domain name to query
+     * @param options - Optional query parameters
+     * @returns Array of SOA records (typically one)
+     *
+     * @example
+     * ```typescript
+     * const records = await dns.soa('google.com')
+     * console.log(records[0].mname)  // 'ns1.google.com.'
+     * console.log(records[0].serial) // 879543655
+     * ```
+     */
+    soa(domain: string, options?: QueryOptions): Promise<SoaRecord[]>;
+    /**
+     * Looks up SRV (service) records for a domain.
+     *
+     * SRV records specify the location of services. The domain should include
+     * the service and protocol prefix (e.g. `_sip._tcp.example.com`).
+     *
+     * @param domain - The full SRV domain (e.g. `_sip._tcp.example.com`)
+     * @param options - Optional query parameters
+     * @returns Array of SRV records with priority, weight, port, and target
+     *
+     * @example
+     * ```typescript
+     * const records = await dns.srv('_sip._tcp.example.com')
+     * // [{ priority: 10, weight: 60, port: 5060, target: 'sip.example.com.' }]
+     * ```
+     */
+    srv(domain: string, options?: QueryOptions): Promise<SrvRecord[]>;
+    /**
+     * Looks up CAA (Certificate Authority Authorization) records for a domain.
+     *
+     * CAA records specify which certificate authorities are allowed to issue
+     * certificates for a domain.
+     *
+     * @param domain - The domain name to query
+     * @param options - Optional query parameters
+     * @returns Array of CAA records with flags, tag, and issuer
+     *
+     * @example
+     * ```typescript
+     * const records = await dns.caa('google.com')
+     * // [{ flags: 0, tag: 'issue', issuer: 'pki.goog' }]
+     * ```
+     */
+    caa(domain: string, options?: QueryOptions): Promise<CaaRecord[]>;
+    /**
+     * Performs a reverse DNS lookup for an IP address.
+     *
+     * Converts the IP to its in-addr.arpa form and queries for PTR records.
+     *
+     * @param ip - The IPv4 address to look up
+     * @param options - Optional query parameters
+     * @returns Array of hostnames (PTR record values)
+     *
+     * @example
+     * ```typescript
+     * const hostnames = await dns.reverse('8.8.8.8')
+     * // ['dns.google.']
+     * ```
+     */
+    reverse(ip: string, options?: QueryOptions): Promise<string[]>;
+    /**
+     * Retrieves a comprehensive DNS overview for a domain.
+     *
+     * Queries all common record types (A, AAAA, CNAME, MX, NS, TXT, SOA, CAA)
+     * in parallel and returns a consolidated view. This is the go-to method for
+     * exploring a domain's full DNS configuration.
+     *
+     * @param domain - The domain name to query
+     * @param options - Optional query parameters applied to all queries
+     * @returns Complete DNS overview with all record types
+     *
+     * @example
+     * ```typescript
+     * const overview = await dns.overview('example.com')
+     * console.log('IPs:', overview.a.map(r => r.value))
+     * console.log('Mail:', overview.mx.map(r => r.exchange))
+     * console.log('Nameservers:', overview.ns.map(r => r.value))
+     * console.log('TXT:', overview.txt.map(r => r.value))
+     * ```
+     */
+    overview(domain: string, options?: QueryOptions): Promise<DnsOverview>;
+    /**
+     * Compares DNS resolution between two nameservers for a given record type.
+     *
+     * Useful for verifying DNS propagation or checking for inconsistencies
+     * between authoritative and recursive resolvers.
+     *
+     * @param domain - The domain name to query
+     * @param type - The DNS record type to compare
+     * @param serverA - First DNS server (e.g. '8.8.8.8')
+     * @param serverB - Second DNS server (e.g. '1.1.1.1')
+     * @returns Object with results from both servers and whether they match
+     *
+     * @example
+     * ```typescript
+     * const diff = await dns.compare('example.com', 'A', '8.8.8.8', '1.1.1.1')
+     * console.log(diff.match)   // true if both return the same values
+     * console.log(diff.serverA) // records from 8.8.8.8
+     * console.log(diff.serverB) // records from 1.1.1.1
+     * ```
+     */
+    compare(domain: string, type: DnsRecordType, serverA: string, serverB: string): Promise<{
+        serverA: DnsQueryResult;
+        serverB: DnsQueryResult;
+        match: boolean;
+    }>;
+    /**
+     * Queries a domain's authoritative nameservers directly.
+     *
+     * First resolves the NS records, then queries each nameserver for the
+     * specified record type. Useful for bypassing caches and checking what
+     * the authoritative servers actually report.
+     *
+     * @param domain - The domain name to query
+     * @param type - The DNS record type to look up
+     * @returns Array of results, one per authoritative nameserver
+     *
+     * @example
+     * ```typescript
+     * const results = await dns.queryAuthoritative('example.com', 'A')
+     * for (const r of results) {
+     *   console.log(`${r.server}: ${r.records.map(rec => rec.value).join(', ')}`)
+     * }
+     * ```
+     */
+    queryAuthoritative(domain: string, type: DnsRecordType): Promise<DnsQueryResult[]>;
+    /**
+     * Checks whether a domain has a specific TXT record containing the given text.
+     *
+     * Useful for verifying domain ownership tokens, SPF records, DKIM entries, etc.
+     *
+     * @param domain - The domain name to query
+     * @param search - The text to search for in TXT record values
+     * @returns True if any TXT record contains the search string
+     *
+     * @example
+     * ```typescript
+     * // Check for SPF record
+     * const hasSPF = await dns.hasTxtRecord('google.com', 'v=spf1')
+     *
+     * // Check for domain verification
+     * const verified = await dns.hasTxtRecord('example.com', 'google-site-verification=')
+     * ```
+     */
+    hasTxtRecord(domain: string, search: string): Promise<boolean>;
+    /** Builds the dig CLI arguments for a query. */
+    private buildDigArgs;
+    /** Parses dig's answer section into structured records. */
+    private parseDigAnswer;
+    /** Extracts query time from dig's stats section. */
+    private parseQueryTime;
+}
+export default Dns;
+//# sourceMappingURL=dns.d.ts.map

package/dist/node/features/dns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dns.d.ts","sourceRoot":"","sources":["../../../src/node/features/dns.ts"],"names":[],"mappings":"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"}