doomain 0.1.20 → 0.1.22

package/dist/lib/point-domain.js

@@ -1,87 +1,27 @@
-import { resolve4, resolve6, resolveCname } from 'node:dns/promises';
-import { isIP } from 'node:net';
+import { waitForDnsPropagation } from './dns-propagation.js';
+import { reconcileDesiredRecord } from './dns-reconciliation.js';
+import { inferAddressRecordType, normalizeAddressRecordTarget } from './dns-records.js';
 import { resolveProviderTarget } from './domain-provider.js';
 import { DoomainError } from './errors.js';
 import { withProviderRecordOptions } from './link-domain.js';
 import { createProvider } from './providers/registry.js';
-import { normalizeDomain } from './validate.js';
 const defaultDependencies = {
     createProvider,
     resolveTarget: resolveProviderTarget,
 };
-function cleanTarget(value) {
-    return value.trim().replace(/\.$/, '');
-}
-function inferredRecordType(target) {
-    const version = isIP(target);
-    if (version === 4)
-        return 'A';
-    if (version === 6)
-        return 'AAAA';
-    return 'CNAME';
-}
-function validateTarget(recordType, target) {
-    const version = isIP(target);
-    if (recordType === 'A' && version !== 4)
-        throw new DoomainError('INVALID_INPUT', 'A records require an IPv4 target.');
-    if (recordType === 'AAAA' && version !== 6)
-        throw new DoomainError('INVALID_INPUT', 'AAAA records require an IPv6 target.');
-    if (recordType === 'CNAME' && version !== 0)
-        throw new DoomainError('INVALID_INPUT', 'CNAME records require a hostname target.');
-}
 export function createPointRecord(input) {
-    const target = cleanTarget(input.target);
-    if (!target)
-        throw new DoomainError('MISSING_ARGUMENT', 'A DNS target is required.');
-    const recordType = input.recordType ?? inferredRecordType(target);
-    validateTarget(recordType, target);
+    const recordType = input.recordType ?? inferAddressRecordType(input.target.trim());
+    const target = normalizeAddressRecordTarget(recordType, input.target);
     return withProviderRecordOptions(input.provider, {
         name: input.recordName,
         ttl: input.ttl ?? 300,
         type: recordType,
-        value: recordType === 'CNAME' ? normalizeDomain(target) : target,
+        value: target,
     });
 }
 function recordFqdn(record, zoneDomain) {
     return record.name === '@' ? zoneDomain : `${record.name}.${zoneDomain}`;
 }
-function cleanDnsValue(value) {
-    return value.toLowerCase().replace(/\.$/, '');
-}
-function normalizeIpv6(value) {
-    return new URL(`http://[${value}]`).hostname.slice(1, -1);
-}
-async function isPropagated(record, zoneDomain, dependencies) {
-    const fqdn = recordFqdn(record, zoneDomain);
-    try {
-        if (record.type === 'A')
-            return (await (dependencies.resolve4 ?? resolve4)(fqdn)).includes(record.value);
-        if (record.type === 'AAAA') {
-            const expected = normalizeIpv6(record.value);
-            return (await (dependencies.resolve6 ?? resolve6)(fqdn)).some((value) => normalizeIpv6(value) === expected);
-        }
-        if (record.type === 'CNAME') {
-            return (await (dependencies.resolveCname ?? resolveCname)(fqdn))
-                .map(cleanDnsValue)
-                .includes(cleanDnsValue(record.value));
-        }
-    }
-    catch {
-        return false;
-    }
-    return false;
-}
-async function waitForPropagation(record, zoneDomain, timeoutSeconds, dependencies) {
-    const deadline = Date.now() + timeoutSeconds * 1000;
-    while (true) {
-        if (await isPropagated(record, zoneDomain, dependencies))
-            return true;
-        const remaining = deadline - Date.now();
-        if (remaining <= 0)
-            return false;
-        await new Promise((resolve) => setTimeout(resolve, Math.min(5000, remaining)));
-    }
-}
 function conflictWarning(resolved, provider, record, conflicts) {
     return {
         account: resolved.account,
@@ -170,6 +110,14 @@ export async function pointDomain(input, dependencies = defaultDependencies) {
             provider: resolved.provider,
             providerInferred: resolved.providerInferred,
             propagated: false,
+            propagation: {
+                elapsedMs: 0,
+                expected: record.value,
+                observations: [],
+                status: 'not_checked',
+            },
+            reconciled: false,
+            reconciliationAttempts: 0,
             record,
             skipped: [],
             updated: false,
@@ -191,10 +139,25 @@ export async function pointDomain(input, dependencies = defaultDependencies) {
     }
     input.progress?.(`Pointing ${resolved.target.fullDomain} to ${record.value}`);
     const result = await provider.applyChanges(zone, plan, { force });
+    const reconciliation = await reconcileDesiredRecord({
+        desired: record,
+        progress: input.progress,
+        provider,
+        timeoutMs: (input.reconcileTimeoutSeconds ?? 30) * 1000,
+        zone,
+    });
     const shouldWait = input.wait ?? true;
-    const propagated = shouldWait
-        ? await waitForPropagation(record, resolved.target.zoneDomain, input.timeoutSeconds ?? 300, dependencies)
-        : false;
+    const propagation = shouldWait
+        ? await waitForDnsPropagation({
+            fqdn: recordFqdn(record, resolved.target.zoneDomain),
+            observe: dependencies.observeDns,
+            record,
+            timeoutSeconds: input.timeoutSeconds ?? 300,
+        })
+        : { elapsedMs: 0, expected: record.value, observations: [], status: 'not_checked' };
+    const propagated = propagation.status === 'propagated' ||
+        propagation.status === 'local_or_vpn_cache_stale' ||
+        propagation.status === 'system_resolver_unavailable';
     return {
         account: resolved.account,
         accountInferred: resolved.accountInferred,
@@ -204,9 +167,12 @@ export async function pointDomain(input, dependencies = defaultDependencies) {
         provider: resolved.provider,
         providerInferred: resolved.providerInferred,
         propagated,
+        propagation,
+        reconciled: reconciliation.reconciled,
+        reconciliationAttempts: reconciliation.attempts,
         record,
         skipped: result.skipped,
-        updated: result.applied.length > 0,
+        updated: result.applied.length > 0 || reconciliation.appliedChanges > 0,
         zoneDomain: resolved.target.zoneDomain,
     };
 }

package/dist/lib/providers/hostinger/index.d.ts

@@ -19,5 +19,6 @@ export declare class HostingerProvider implements DnsProvider {
     upsertRecord(zone: DnsZone, record: DnsRecordInput): Promise<DnsRecord>;
     deleteRecord(zone: DnsZone, record: DnsRecord): Promise<void>;
     private putRecords;
+    private putHostingerRecordSets;
 }
 export declare const hostingerProviderDefinition: DnsProviderDefinition;

package/dist/lib/providers/hostinger/index.js

@@ -47,7 +47,7 @@ function toDnsRecords(record, zone) {
             return [];
         return [
             {
-                metadata: { hostinger: { ...record, records: [item] } },
+                metadata: { hostinger: record },
                 name,
                 ttl: record.ttl,
                 type,
@@ -56,12 +56,13 @@ function toDnsRecords(record, zone) {
         ];
     });
 }
-function toHostingerRecord(record) {
+function toHostingerRecordSet(records) {
+    const first = records[0];
     return {
-        name: record.name,
-        records: [{ content: record.value }],
-        ttl: record.ttl ?? capabilities.defaultTtl,
-        type: record.type,
+        name: first.name,
+        records: records.map((record) => ({ content: record.value })),
+        ttl: first.ttl ?? capabilities.defaultTtl,
+        type: first.type,
     };
 }
 function deleteFilter(record) {
@@ -142,15 +143,40 @@ export class HostingerProvider {
         assertNoConflicts(this.id, plan);
         const applied = [];
         const skipped = [];
+        const deletionSets = new Map();
+        for (const change of plan.changes) {
+            if (change.action !== 'delete')
+                continue;
+            const key = `${change.existing.type}\0${change.existing.name}`;
+            const records = deletionSets.get(key) ?? [];
+            records.push(change.existing);
+            deletionSets.set(key, records);
+        }
+        for (const deleted of deletionSets.values()) {
+            const sample = deleted[0];
+            const source = sample.metadata?.hostinger;
+            const deletedValues = new Set(deleted.map((record) => record.value));
+            const sourceRecords = source?.records?.filter((record) => record.is_disabled || !record.content || !deletedValues.has(record.content));
+            if (source && sourceRecords && sourceRecords.length > 0) {
+                await this.putHostingerRecordSets(zone, [{ ...source, records: sourceRecords }], true);
+            }
+            else {
+                const remaining = plan.existing.filter((record) => sameRecordSet(record, sample) && !deleted.includes(record));
+                if (remaining.length > 0)
+                    await this.putRecords(zone, remaining, true);
+                else
+                    await this.deleteRecord(zone, sample);
+            }
+            applied.push(...plan.changes.filter((change) => change.action === 'delete' && deleted.includes(change.existing)));
+        }
         for (const change of plan.changes) {
             if (change.action === 'skip') {
                 skipped.push(change.record);
                 continue;
             }
             if (change.action === 'delete')
-                await this.deleteRecord(zone, change.existing);
-            else
-                await this.putRecords(zone, [change.record], change.action === 'update');
+                continue;
+            await this.putRecords(zone, [change.record], change.action === 'update');
             applied.push(change);
         }
         return { applied, skipped };
@@ -166,8 +192,18 @@ export class HostingerProvider {
         });
     }
     async putRecords(zone, records, overwrite) {
+        const recordSets = new Map();
+        for (const record of records) {
+            const key = `${record.type}\0${record.name}`;
+            const values = recordSets.get(key) ?? [];
+            values.push(record);
+            recordSets.set(key, values);
+        }
+        await this.putHostingerRecordSets(zone, [...recordSets.values()].map(toHostingerRecordSet), overwrite);
+    }
+    async putHostingerRecordSets(zone, recordSets, overwrite) {
         await this.http.request(`/api/dns/v1/zones/${encodeURIComponent(zone.name)}`, {
-            body: { overwrite, zone: records.map(toHostingerRecord) },
+            body: { overwrite, zone: recordSets },
             method: 'PUT',
         });
     }

package/dist/lib/providers/spaceship/index.js

@@ -1,7 +1,7 @@
 import { normalizeDomain } from '../../validate.js';
 import { createProviderHttpClient } from '../core/http.js';
 import { paginateBySkip } from '../core/pagination.js';
-import { applyDnsChanges, planDnsChanges } from '../core/planner.js';
+import { assertNoConflicts, planDnsChanges } from '../core/planner.js';
 const SPACESHIP_API_URL = 'https://spaceship.dev/api/v1';
 const capabilities = {
     defaultTtl: 3600,
@@ -108,12 +108,21 @@ export class SpaceshipProvider {
         });
     }
     async applyChanges(zone, plan) {
-        return applyDnsChanges({
-            deleteRecord: (record) => this.deleteRecord(zone, record),
-            plan,
-            providerId: this.id,
-            upsertRecord: (record) => this.upsertRecord(zone, record),
-        });
+        assertNoConflicts(this.id, plan);
+        const skipped = plan.changes.flatMap((change) => (change.action === 'skip' ? [change.record] : []));
+        const applied = plan.changes.filter((change) => change.action !== 'skip');
+        // Spaceship records do not have stable ids. Delete every old value before creating
+        // replacements so an API that processes accepted writes out of order cannot leave
+        // two address records in the same slot without the reconciler noticing and retrying.
+        for (const change of applied) {
+            if (change.action === 'delete' || change.action === 'update')
+                await this.deleteRecord(zone, change.existing);
+        }
+        for (const change of applied) {
+            if (change.action === 'create' || change.action === 'update')
+                await this.upsertRecord(zone, change.record);
+        }
+        return { applied, skipped };
     }
     async upsertRecord(zone, record) {
         await this.http.request(`/dns/records/${zone.name}`, {

package/dist/lib/providers/status.d.ts

@@ -2,7 +2,9 @@ import { type DoomainConfig } from '../config.js';
 import type { DnsProviderDefinition } from './types.js';
 export interface ProviderStatus {
     account: string;
+    accountLabel: string;
     configured: boolean;
+    /** @deprecated Use isPreferredProvider. */
     default: boolean;
     displayName: string;
     docsUrl?: string;
@@ -10,6 +12,7 @@ export interface ProviderStatus {
     error?: string;
     id: string;
     isDefaultAccount: boolean;
+    isPreferredProvider: boolean;
     verified?: boolean;
 }
 export declare function isProviderConfigured(definition: DnsProviderDefinition, config: DoomainConfig, opts?: {

package/dist/lib/providers/status.js

@@ -17,12 +17,14 @@ export async function listProviderStatuses(opts = {}) {
             const configured = accounts.some((item) => item.account === account);
             const status = {
                 account,
+                accountLabel: ref.isDefaultAccount ? `${definition.id}/default` : `${definition.id}/${account}`,
                 configured,
                 default: config.defaults?.provider === definition.id,
                 displayName: definition.displayName,
                 docsUrl: definition.docsUrl,
                 id: definition.id,
                 isDefaultAccount: ref.isDefaultAccount,
+                isPreferredProvider: config.defaults?.provider === definition.id,
             };
             if (configured && opts.verify) {
                 try {

package/dist/lib/remove-domain.d.ts

@@ -0,0 +1,38 @@
+import { type DnsRecordSelector } from './dns-records.js';
+import { type ResolvedDnsTarget } from './domain-provider.js';
+import type { DnsProvider, DnsRecord, DnsRecordType } from './providers/types.js';
+export interface RemoveDomainInput {
+    account?: string;
+    allMatching?: boolean;
+    domain: string;
+    dryRun?: boolean;
+    provider?: string;
+    recordType: DnsRecordType;
+    reconcileTimeoutSeconds?: number;
+    value?: string;
+    confirmMultiple?: (records: DnsRecord[]) => Promise<boolean>;
+    progress?: (message: string) => void;
+}
+export interface RemoveDomainResult {
+    account: string;
+    accountInferred: boolean;
+    domain: string;
+    dryRun: boolean;
+    isDefaultAccount: boolean;
+    matched: DnsRecord[];
+    provider: string;
+    providerInferred: boolean;
+    reconciled: boolean;
+    reconciliationAttempts: number;
+    removed: number;
+    selector: DnsRecordSelector;
+    zoneDomain: string;
+}
+interface RemoveDomainDependencies {
+    createProvider: (provider: string, opts: {
+        account?: string;
+    }) => Promise<DnsProvider>;
+    resolveTarget: (input: Pick<RemoveDomainInput, 'account' | 'domain' | 'provider'>) => Promise<ResolvedDnsTarget>;
+}
+export declare function removeDomain(input: RemoveDomainInput, dependencies?: RemoveDomainDependencies): Promise<RemoveDomainResult>;
+export {};

package/dist/lib/remove-domain.js

@@ -0,0 +1,125 @@
+import { reconcileRecordRemoval } from './dns-reconciliation.js';
+import { recordMatchesSelector } from './dns-records.js';
+import { resolveProviderTarget } from './domain-provider.js';
+import { DoomainError } from './errors.js';
+import { createProvider } from './providers/registry.js';
+const defaultDependencies = { createProvider, resolveTarget: resolveProviderTarget };
+function quoteCommandArgument(value) {
+    return /^[a-zA-Z0-9_./:@+-]+$/.test(value) ? value : `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+function removalCommand(input, options) {
+    const arguments_ = ['doomain', 'dns', 'remove', quoteCommandArgument(input.domain)];
+    if (input.provider)
+        arguments_.push('--provider', quoteCommandArgument(input.provider));
+    if (input.account)
+        arguments_.push('--account', quoteCommandArgument(input.account));
+    arguments_.push('--type', input.recordType);
+    if (input.value !== undefined)
+        arguments_.push('--value', quoteCommandArgument(input.value));
+    if (options?.allMatching ?? input.allMatching)
+        arguments_.push('--all-matching');
+    if (options?.dryRun ?? input.dryRun)
+        arguments_.push('--dry-run');
+    arguments_.push('--json');
+    return arguments_.join(' ');
+}
+function removalResolutionError(error, input) {
+    if (error.code !== 'CONFIG_NOT_FOUND' && error.code !== 'PROVIDER_ZONE_NOT_FOUND')
+        return error;
+    const details = error.details && typeof error.details === 'object' ? error.details : {};
+    const retry = removalCommand(input);
+    return new DoomainError(error.code, error.message, {
+        ...details,
+        recovery: `Connect or repair the DNS provider account that owns this domain, then retry \`${retry}\`.`,
+        suggestedCommands: ['doomain providers connect', retry],
+    });
+}
+function ambiguousDeletionError(input, records) {
+    return new DoomainError('DNS_DELETE_AMBIGUOUS', `${records.length} DNS records match this deletion. Pass --all-matching to delete all of them.`, {
+        matched: records,
+        recovery: 'Narrow the deletion with --value, or explicitly approve all matching records with --all-matching.',
+        suggestedCommands: [removalCommand(input, { allMatching: true, dryRun: true })],
+    });
+}
+export async function removeDomain(input, dependencies = defaultDependencies) {
+    if (!input.allMatching && input.value === undefined) {
+        throw new DoomainError('INVALID_INPUT', 'An exact --value is required unless --all-matching is passed.', {
+            recovery: 'Pass --value <expected-value>, or preview --all-matching with --dry-run.',
+        });
+    }
+    let resolved;
+    try {
+        resolved = await dependencies.resolveTarget(input);
+    }
+    catch (error) {
+        if (error instanceof DoomainError)
+            throw removalResolutionError(error, input);
+        throw error;
+    }
+    const provider = await dependencies.createProvider(resolved.provider, { account: resolved.account });
+    if (!provider.capabilities.recordTypes.includes(input.recordType)) {
+        throw new DoomainError('PROVIDER_UNSUPPORTED_RECORD', `${provider.name} does not support ${input.recordType} records.`);
+    }
+    const zone = await provider.getZone(resolved.target.zoneDomain);
+    if (!zone) {
+        throw new DoomainError('PROVIDER_ZONE_NOT_FOUND', `${provider.name} does not have a DNS zone for ${resolved.target.zoneDomain}.`);
+    }
+    const selector = {
+        name: resolved.target.recordName,
+        type: input.recordType,
+        ...(input.value === undefined ? {} : { value: input.value }),
+    };
+    const existing = await provider.listRecords(zone);
+    const matched = existing.filter((record) => recordMatchesSelector(record, selector));
+    if (matched.length > 1 && !input.allMatching) {
+        const confirmed = (await input.confirmMultiple?.(matched)) === true;
+        if (!confirmed)
+            throw ambiguousDeletionError(input, matched);
+    }
+    const base = {
+        account: resolved.account,
+        accountInferred: resolved.accountInferred,
+        domain: resolved.target.fullDomain,
+        isDefaultAccount: resolved.isDefaultAccount,
+        matched,
+        provider: resolved.provider,
+        providerInferred: resolved.providerInferred,
+        selector,
+        zoneDomain: resolved.target.zoneDomain,
+    };
+    if (input.dryRun) {
+        return {
+            ...base,
+            dryRun: true,
+            reconciled: false,
+            reconciliationAttempts: 0,
+            removed: 0,
+        };
+    }
+    if (matched.length === 0) {
+        return { ...base, dryRun: false, reconciled: true, reconciliationAttempts: 1, removed: 0 };
+    }
+    input.progress?.(`Deleting ${matched.length} DNS record${matched.length === 1 ? '' : 's'}`);
+    const plan = {
+        changes: matched.map((record) => ({ action: 'delete', existing: record })),
+        conflicts: [],
+        desired: [],
+        existing,
+        zone,
+    };
+    await provider.applyChanges(zone, plan, { force: true });
+    const reconciliation = await reconcileRecordRemoval({
+        progress: input.progress,
+        provider,
+        selector,
+        timeoutMs: (input.reconcileTimeoutSeconds ?? 30) * 1000,
+        zone,
+    });
+    return {
+        ...base,
+        dryRun: false,
+        reconciled: reconciliation.reconciled,
+        reconciliationAttempts: reconciliation.attempts,
+        removed: matched.length,
+    };
+}

package/dist/lib/self-update.d.ts

@@ -0,0 +1,27 @@
+interface ProcessResult {
+    exitCode: number | null;
+    stderr: string;
+    stdout: string;
+}
+interface ProcessOptions {
+    env: NodeJS.ProcessEnv;
+    shell: boolean;
+}
+type ProcessRunner = (command: string, args: string[], options: ProcessOptions) => Promise<ProcessResult>;
+export interface SelfUpdateResult {
+    package: string;
+    packageSpec: string;
+    packageManager: 'npm';
+}
+export interface SelfUpdateOptions {
+    cacheRoot?: string;
+    platform?: NodeJS.Platform;
+    runner?: ProcessRunner;
+}
+export declare function npmInstallCommand(cacheDirectory: string, platform?: NodeJS.Platform, environment?: NodeJS.ProcessEnv): {
+    args: string[];
+    command: string;
+    options: ProcessOptions;
+};
+export declare function installLatestVersion(options?: SelfUpdateOptions): Promise<SelfUpdateResult>;
+export {};

package/dist/lib/self-update.js

@@ -0,0 +1,63 @@
+import { spawn } from 'node:child_process';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { DoomainError } from './errors.js';
+function runProcess(command, args, options) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            ...options,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            windowsHide: true,
+        });
+        let stderr = '';
+        let stdout = '';
+        child.stderr.setEncoding('utf8');
+        child.stderr.on('data', (chunk) => {
+            stderr += chunk;
+        });
+        child.stdout.setEncoding('utf8');
+        child.stdout.on('data', (chunk) => {
+            stdout += chunk;
+        });
+        child.once('error', reject);
+        child.once('close', (exitCode) => resolve({ exitCode, stderr, stdout }));
+    });
+}
+export function npmInstallCommand(cacheDirectory, platform = process.platform, environment = process.env) {
+    const env = Object.fromEntries(Object.entries(environment).filter(([key]) => key.toLowerCase() !== 'npm_config_cache'));
+    env.npm_config_cache = cacheDirectory;
+    return {
+        command: 'npm',
+        args: ['install', '--global', 'doomain@latest', '--prefer-online', '--offline=false'],
+        options: {
+            env,
+            shell: platform === 'win32',
+        },
+    };
+}
+export async function installLatestVersion(options = {}) {
+    const cacheDirectory = await mkdtemp(join(options.cacheRoot ?? tmpdir(), 'doomain-npm-cache-'));
+    try {
+        const invocation = npmInstallCommand(cacheDirectory, options.platform);
+        const result = await (options.runner ?? runProcess)(invocation.command, invocation.args, invocation.options);
+        if (result.exitCode !== 0) {
+            const reason = result.stderr.trim() || result.stdout.trim() || `npm exited with code ${result.exitCode ?? 'unknown'}`;
+            throw new DoomainError('SELF_UPDATE_FAILED', `Unable to update doomain: ${reason}`);
+        }
+        return {
+            package: 'doomain',
+            packageSpec: 'doomain@latest',
+            packageManager: 'npm',
+        };
+    }
+    catch (error) {
+        if (error instanceof DoomainError)
+            throw error;
+        const message = error instanceof Error ? error.message : String(error);
+        throw new DoomainError('SELF_UPDATE_FAILED', `Unable to update doomain: ${message}`);
+    }
+    finally {
+        await rm(cacheDirectory, { force: true, recursive: true }).catch(() => undefined);
+    }
+}