doomain 0.1.18 → 0.1.20

package/dist/lib/point-domain.js

@@ -0,0 +1,212 @@
+import { resolve4, resolve6, resolveCname } from 'node:dns/promises';
+import { isIP } from 'node:net';
+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);
+    return withProviderRecordOptions(input.provider, {
+        name: input.recordName,
+        ttl: input.ttl ?? 300,
+        type: recordType,
+        value: recordType === 'CNAME' ? normalizeDomain(target) : 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,
+        conflicts,
+        desired: [record],
+        domain: resolved.target.fullDomain,
+        provider: resolved.provider,
+        providerName: provider.name,
+        recordName: resolved.target.recordName,
+        zoneDomain: resolved.target.zoneDomain,
+    };
+}
+function dnsTargetConflictError(warning) {
+    const account = warning.account === 'default' ? '' : ` --account ${warning.account}`;
+    const target = warning.desired[0]?.value ?? '<ip-or-hostname>';
+    return new DoomainError('DNS_TARGET_CONFLICT', `${warning.domain} already has DNS records that point somewhere else. Re-run with --force to overwrite them.`, {
+        ...warning,
+        recovery: 'Re-run with --force to overwrite conflicting DNS records, or confirm the DNS override in interactive mode.',
+        suggestedCommands: [
+            `doomain dns point ${warning.domain} --target ${target} --provider ${warning.provider}${account} --force --json`,
+        ],
+    });
+}
+function providerResolutionError(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 provider = input.provider ? ` --provider ${input.provider}` : '';
+    const account = input.account ? ` --account ${input.account}` : '';
+    const retry = `doomain dns point ${input.domain} --target ${input.target}${provider}${account} --json`;
+    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 validateTtl(provider, ttl) {
+    if (ttl === undefined)
+        return;
+    const { maxTtl, minTtl } = provider.capabilities;
+    if (!Number.isInteger(ttl) || ttl <= 0) {
+        throw new DoomainError('INVALID_INPUT', 'DNS record TTL must be a positive integer.');
+    }
+    if (minTtl !== undefined && maxTtl !== undefined && (ttl < minTtl || ttl > maxTtl)) {
+        throw new DoomainError('INVALID_INPUT', `${provider.name} requires a TTL between ${minTtl} and ${maxTtl} seconds.`);
+    }
+    if (minTtl !== undefined && ttl < minTtl) {
+        throw new DoomainError('INVALID_INPUT', `${provider.name} requires a TTL of at least ${minTtl} seconds.`);
+    }
+    if (maxTtl !== undefined && ttl > maxTtl) {
+        throw new DoomainError('INVALID_INPUT', `${provider.name} requires a TTL no greater than ${maxTtl} seconds.`);
+    }
+}
+export async function pointDomain(input, dependencies = defaultDependencies) {
+    let resolved;
+    try {
+        resolved = await dependencies.resolveTarget(input);
+    }
+    catch (error) {
+        if (error instanceof DoomainError)
+            throw providerResolutionError(error, input);
+        throw error;
+    }
+    const record = createPointRecord({
+        provider: resolved.provider,
+        recordName: resolved.target.recordName,
+        recordType: input.recordType,
+        target: input.target,
+        ttl: input.ttl,
+    });
+    const provider = await dependencies.createProvider(resolved.provider, { account: resolved.account });
+    validateTtl(provider, record.ttl);
+    if (!provider.capabilities.recordTypes.includes(record.type)) {
+        throw new DoomainError('PROVIDER_UNSUPPORTED_RECORD', `${provider.name} does not support ${record.type} records.`);
+    }
+    if (resolved.target.isApex && record.type === 'CNAME' && !provider.capabilities.supportsApexCname) {
+        throw new DoomainError('PROVIDER_UNSUPPORTED_RECORD', `${provider.name} does not support CNAME records at the zone apex. Use an A or AAAA target instead.`);
+    }
+    if (input.dryRun) {
+        return {
+            account: resolved.account,
+            accountInferred: resolved.accountInferred,
+            domain: resolved.target.fullDomain,
+            dryRun: true,
+            isDefaultAccount: resolved.isDefaultAccount,
+            provider: resolved.provider,
+            providerInferred: resolved.providerInferred,
+            propagated: false,
+            record,
+            skipped: [],
+            updated: false,
+            zoneDomain: resolved.target.zoneDomain,
+        };
+    }
+    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}.`);
+    input.progress?.(`Planning DNS change in ${provider.name}`);
+    let force = Boolean(input.force);
+    let plan = await provider.planChanges(zone, [record], { force });
+    if (!force && plan.conflicts.length > 0) {
+        const warning = conflictWarning(resolved, provider, record, plan.conflicts);
+        force = (await input.confirmDnsOverride?.(warning)) === true;
+        if (!force)
+            throw dnsTargetConflictError(warning);
+        plan = await provider.planChanges(zone, [record], { force: true });
+    }
+    input.progress?.(`Pointing ${resolved.target.fullDomain} to ${record.value}`);
+    const result = await provider.applyChanges(zone, plan, { force });
+    const shouldWait = input.wait ?? true;
+    const propagated = shouldWait
+        ? await waitForPropagation(record, resolved.target.zoneDomain, input.timeoutSeconds ?? 300, dependencies)
+        : false;
+    return {
+        account: resolved.account,
+        accountInferred: resolved.accountInferred,
+        domain: resolved.target.fullDomain,
+        dryRun: false,
+        isDefaultAccount: resolved.isDefaultAccount,
+        provider: resolved.provider,
+        providerInferred: resolved.providerInferred,
+        propagated,
+        record,
+        skipped: result.skipped,
+        updated: result.applied.length > 0,
+        zoneDomain: resolved.target.zoneDomain,
+    };
+}

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

@@ -1,7 +1,7 @@
 import { normalizeDomain } from '../../validate.js';
+import { ProviderError } from '../core/errors.js';
 import { createProviderHttpClient } from '../core/http.js';
 import { assertNoConflicts, planDnsChanges } from '../core/planner.js';
-import { ProviderError } from '../core/errors.js';
 const CLOUDFLARE_API_URL = 'https://api.cloudflare.com/client/v4';
 const capabilities = {
     defaultTtl: 3600,
@@ -60,7 +60,9 @@ function toCloudflareRecord(record, zone) {
         ttl: record.ttl ?? capabilities.defaultTtl,
         type: record.type,
         ...(record.priority === undefined ? {} : { priority: record.priority }),
-        ...(record.proxied === undefined || !['A', 'AAAA', 'CNAME'].includes(record.type) ? {} : { proxied: record.proxied }),
+        ...(record.proxied === undefined || !['A', 'AAAA', 'CNAME'].includes(record.type)
+            ? {}
+            : { proxied: record.proxied }),
     };
 }
 function toZone(zone) {
@@ -102,7 +104,7 @@ export class CloudflareProvider {
         const zones = [];
         for (let page = 1; page <= 100; page += 1) {
             const response = await this.request('/zones', {
-                query: { 'account.id': this.accountId, direction: 'asc', order: 'name', page, 'per_page': 50 },
+                query: { 'account.id': this.accountId, direction: 'asc', order: 'name', page, per_page: 50 },
             });
             for (const zone of response.result ?? []) {
                 const dnsZone = toZone(zone);
@@ -124,7 +126,7 @@ export class CloudflareProvider {
         const records = [];
         for (let page = 1; page <= 100; page += 1) {
             const response = await this.request(`/zones/${zone.id}/dns_records`, {
-                query: { page, 'per_page': 100 },
+                query: { page, per_page: 100 },
             });
             for (const record of response.result ?? []) {
                 const dnsRecord = toDnsRecord(record, zone);
@@ -138,7 +140,13 @@ export class CloudflareProvider {
         return records;
     }
     async planChanges(zone, desired, opts = {}) {
-        return planDnsChanges({ desired, existing: await this.listRecords(zone), force: opts.force, providerId: this.id, zone });
+        return planDnsChanges({
+            desired,
+            existing: await this.listRecords(zone),
+            force: opts.force,
+            providerId: this.id,
+            zone,
+        });
     }
     async applyChanges(zone, plan) {
         assertNoConflicts(this.id, plan);

package/dist/lib/providers/core/config.js

@@ -50,7 +50,8 @@ export function providerAccountHasCredentials(config, providerId, accountInput)
         return false;
     if (account !== DEFAULT_PROVIDER_ACCOUNT)
         return hasCredentials(current.accounts?.[account]?.credentials);
-    return hasCredentials(current.credentials) || Boolean(legacyCredential(config, providerId, 'apiKey') || legacyCredential(config, providerId, 'apiSecret'));
+    return (hasCredentials(current.credentials) ||
+        Boolean(legacyCredential(config, providerId, 'apiKey') || legacyCredential(config, providerId, 'apiSecret')));
 }
 export function withProviderAccountCredentials(current, accountInput, credentials) {
     const account = normalizeProviderAccount(accountInput);

package/dist/lib/providers/core/planner.js

@@ -5,6 +5,10 @@ function cleanDnsValue(value) {
 function sameRecord(a, b) {
     if (b.proxied !== undefined && a.proxied !== b.proxied)
         return false;
+    if (b.priority !== undefined && a.priority !== b.priority)
+        return false;
+    if (b.ttl !== undefined && a.ttl !== b.ttl)
+        return false;
     return a.type === b.type && a.name === b.name && cleanDnsValue(a.value) === cleanDnsValue(b.value);
 }
 function sameDnsValue(a, b) {
@@ -13,6 +17,11 @@ function sameDnsValue(a, b) {
 function sameSlot(a, b) {
     return a.type === b.type && a.name === b.name;
 }
+function recordOptionsDiffer(a, b) {
+    return ((b.proxied !== undefined && a.proxied !== b.proxied) ||
+        (b.priority !== undefined && a.priority !== b.priority) ||
+        (b.ttl !== undefined && a.ttl !== b.ttl));
+}
 function cnameSlotConflict(a, b) {
     return a.name === b.name && (a.type === 'CNAME' || b.type === 'CNAME');
 }
@@ -21,38 +30,31 @@ export function planDnsChanges(input) {
     const conflicts = [];
     for (const record of input.desired) {
         const exact = input.existing.find((existing) => sameRecord(existing, record));
-        if (exact) {
-            changes.push({ action: 'skip', existing: exact, reason: 'already_exists', record });
-            continue;
-        }
         const sameValue = input.existing.find((existing) => sameDnsValue(existing, record));
-        if (sameValue && record.proxied !== undefined && sameValue.proxied !== record.proxied) {
-            changes.push({ action: 'update', existing: sameValue, record });
+        if (record.type === 'TXT') {
+            changes.push(exact ? { action: 'skip', existing: exact, reason: 'already_exists', record } : { action: 'create', record });
             continue;
         }
-        if (record.type === 'TXT') {
-            changes.push({ action: 'create', record });
+        const sameTyped = input.existing.filter((existing) => sameSlot(existing, record) && !sameDnsValue(existing, record));
+        const cnameConflicts = input.existing.filter((existing) => cnameSlotConflict(existing, record) && !sameSlot(existing, record));
+        if (!input.force && (sameTyped.length > 0 || cnameConflicts.length > 0)) {
+            conflicts.push(...sameTyped.map((existing) => ({ existing, reason: 'same_type_record_exists', record })), ...cnameConflicts.map((existing) => ({ existing, reason: 'cname_slot_conflict', record })));
             continue;
         }
-        const sameTyped = input.existing.find((existing) => sameSlot(existing, record));
-        if (sameTyped) {
-            if (input.force)
-                changes.push({ action: 'update', existing: sameTyped, record });
-            else
-                conflicts.push({ existing: sameTyped, reason: 'same_type_record_exists', record });
+        if (exact) {
+            changes.push(...sameTyped.map((existing) => ({ action: 'delete', existing, reason: 'same_type_record_exists' })), ...cnameConflicts.map((existing) => ({ action: 'delete', existing, reason: 'cname_slot_conflict' })), { action: 'skip', existing: exact, reason: 'already_exists', record });
             continue;
         }
-        const cnameConflict = input.existing.find((existing) => cnameSlotConflict(existing, record));
-        if (cnameConflict) {
-            if (input.force) {
-                changes.push({ action: 'delete', existing: cnameConflict, reason: 'cname_slot_conflict' }, { action: 'create', record });
-            }
-            else {
-                conflicts.push({ existing: cnameConflict, reason: 'cname_slot_conflict', record });
-            }
+        if (sameValue && recordOptionsDiffer(sameValue, record)) {
+            changes.push(...sameTyped.map((existing) => ({ action: 'delete', existing, reason: 'same_type_record_exists' })), ...cnameConflicts.map((existing) => ({ action: 'delete', existing, reason: 'cname_slot_conflict' })), { action: 'update', existing: sameValue, record });
             continue;
         }
-        changes.push({ action: 'create', record });
+        const [replace, ...remainingSameTyped] = sameTyped;
+        changes.push(...(replace ? [{ action: 'update', existing: replace, record }] : []), ...remainingSameTyped.map((existing) => ({
+            action: 'delete',
+            existing,
+            reason: 'same_type_record_exists',
+        })), ...cnameConflicts.map((existing) => ({ action: 'delete', existing, reason: 'cname_slot_conflict' })), ...(replace ? [] : [{ action: 'create', record }]));
     }
     return { changes, conflicts, desired: input.desired, existing: input.existing, zone: input.zone };
 }

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

@@ -67,6 +67,28 @@ function toHostingerRecord(record) {
 function deleteFilter(record) {
     return { name: record.name, type: record.type };
 }
+function sameRecordSet(record, desired) {
+    return record.name === desired.name && record.type === desired.type;
+}
+function collapseRecordSetWrites(plan) {
+    let changes = plan.changes;
+    for (const desired of plan.desired) {
+        const existing = plan.existing.filter((record) => sameRecordSet(record, desired));
+        if (existing.length === 0)
+            continue;
+        const rewritesRecordSet = changes.some((change) => (change.action === 'delete' && sameRecordSet(change.existing, desired)) ||
+            (change.action === 'update' && sameRecordSet(change.record, desired)));
+        if (!rewritesRecordSet)
+            continue;
+        changes = changes.filter((change) => {
+            if (change.action === 'delete')
+                return !sameRecordSet(change.existing, desired);
+            return !sameRecordSet(change.record, desired);
+        });
+        changes.push({ action: 'update', existing: existing[0], record: desired });
+    }
+    return { ...plan, changes };
+}
 export class HostingerProvider {
     capabilities = capabilities;
     id = 'hostinger';
@@ -107,7 +129,14 @@ export class HostingerProvider {
         return records.flatMap((record) => toDnsRecords(record, zone));
     }
     async planChanges(zone, desired, opts = {}) {
-        return planDnsChanges({ desired, existing: await this.listRecords(zone), force: opts.force, providerId: this.id, zone });
+        const plan = planDnsChanges({
+            desired,
+            existing: await this.listRecords(zone),
+            force: opts.force,
+            providerId: this.id,
+            zone,
+        });
+        return collapseRecordSetWrites(plan);
     }
     async applyChanges(zone, plan) {
         assertNoConflicts(this.id, plan);

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

@@ -53,7 +53,10 @@ function providerCodeFromNamecheapError(message) {
     const lower = message.toLowerCase();
     if (lower.includes('clientip') || lower.includes('client ip') || lower.includes('whitelist'))
         return 'PROVIDER_PERMISSION_DENIED';
-    if (lower.includes('api key') || lower.includes('apiuser') || lower.includes('username') || lower.includes('authentication')) {
+    if (lower.includes('api key') ||
+        lower.includes('apiuser') ||
+        lower.includes('username') ||
+        lower.includes('authentication')) {
         return 'PROVIDER_AUTH_FAILED';
     }
     if (lower.includes('rate'))
@@ -176,7 +179,13 @@ export class NamecheapProvider {
         });
     }
     async planChanges(zone, desired, opts = {}) {
-        return planDnsChanges({ desired, existing: await this.listRecords(zone), force: opts.force, providerId: this.id, zone });
+        return planDnsChanges({
+            desired,
+            existing: await this.listRecords(zone),
+            force: opts.force,
+            providerId: this.id,
+            zone,
+        });
     }
     async applyChanges(zone, plan) {
         assertNoConflicts(this.id, plan);

package/dist/lib/providers/registry.js

@@ -5,7 +5,12 @@ import { createProviderContext } from './core/config.js';
 import { hostingerProviderDefinition } from './hostinger/index.js';
 import { namecheapProviderDefinition } from './namecheap/index.js';
 import { spaceshipProviderDefinition } from './spaceship/index.js';
-const definitions = [spaceshipProviderDefinition, namecheapProviderDefinition, cloudflareProviderDefinition, hostingerProviderDefinition];
+const definitions = [
+    spaceshipProviderDefinition,
+    namecheapProviderDefinition,
+    cloudflareProviderDefinition,
+    hostingerProviderDefinition,
+];
 export function listProviderDefinitions() {
     return definitions;
 }

package/dist/lib/providers/status.js

@@ -9,7 +9,9 @@ export async function listProviderStatuses(opts = {}) {
     const statuses = [];
     for (const definition of listProviderDefinitions()) {
         const accounts = listConfiguredProviderAccounts(config, definition);
-        const refs = accounts.length > 0 ? accounts : [{ account: DEFAULT_PROVIDER_ACCOUNT, isDefaultAccount: true, providerId: definition.id }];
+        const refs = accounts.length > 0
+            ? accounts
+            : [{ account: DEFAULT_PROVIDER_ACCOUNT, isDefaultAccount: true, providerId: definition.id }];
         for (const ref of refs) {
             const account = normalizeProviderAccount(ref.account);
             const configured = accounts.some((item) => item.account === account);

package/dist/lib/validate.js

@@ -1,7 +1,11 @@
 import { DoomainError } from './errors.js';
 const DOMAIN_LABEL = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
 export function normalizeDomain(input) {
-    const value = input.trim().toLowerCase().replace(/^https?:\/\//, '').replace(/\/$/, '');
+    const value = input
+        .trim()
+        .toLowerCase()
+        .replace(/^https?:\/\//, '')
+        .replace(/\/$/, '');
     const domain = value.split('/')[0];
     if (!domain || domain.length > 253) {
         throw new DoomainError('INVALID_INPUT', 'Domain is required.');
@@ -13,7 +17,10 @@ export function normalizeDomain(input) {
     return domain;
 }
 export function normalizeSubdomain(input) {
-    const subdomain = input.trim().toLowerCase().replace(/^\.+|\.+$/g, '');
+    const subdomain = input
+        .trim()
+        .toLowerCase()
+        .replace(/^\.+|\.+$/g, '');
     if (!subdomain || subdomain === '@') {
         throw new DoomainError('INVALID_INPUT', 'Subdomain is required unless --apex is used.');
     }

package/dist/lib/vercel.js

@@ -47,7 +47,8 @@ function findProjectDomainTarget(raw, domain) {
     const targets = Array.isArray(raw) ? raw : [raw];
     return targets.find((target) => target &&
         typeof target === 'object' &&
-        (isSameDomain(target.domain, domain) || isSameDomain(target.name, domain)));
+        (isSameDomain(target.domain, domain) ||
+            isSameDomain(target.name, domain)));
 }
 export function createVercelClient(config) {
     async function request(path, init = {}, opts = {}) {
@@ -177,7 +178,9 @@ export function createVercelClient(config) {
             return result.domains ?? [];
         },
         async removeDomainFromProject(project, domain) {
-            await request(`/v9/projects/${encodeURIComponent(project)}/domains/${encodeURIComponent(domain)}`, { method: 'DELETE' });
+            await request(`/v9/projects/${encodeURIComponent(project)}/domains/${encodeURIComponent(domain)}`, {
+                method: 'DELETE',
+            });
         },
         async verifyProjectDomain(project, domain) {
             return request(`/v9/projects/${encodeURIComponent(project)}/domains/${encodeURIComponent(domain)}/verify`, { method: 'POST' });

package/oclif.manifest.json

@@ -312,6 +312,113 @@
         "vercel.js"
       ]
     },
+    "dns:point": {
+      "aliases": [],
+      "args": {
+        "domain": {
+          "description": "Fully qualified domain to point.",
+          "name": "domain",
+          "required": true
+        }
+      },
+      "description": "Point a DNS name at an IP address or canonical hostname.",
+      "examples": [
+        "<%= config.bin %> <%= command.id %> app.example.com --target 203.0.113.10 --json",
+        "<%= config.bin %> <%= command.id %> app.example.com --target origin.example.net --dry-run --json",
+        "<%= config.bin %> <%= command.id %> example.com --target 203.0.113.10 --provider spaceship --account work --force --json"
+      ],
+      "flags": {
+        "account": {
+          "description": "DNS provider profile/account alias. Defaults to the provider default account.",
+          "name": "account",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "dry-run": {
+          "description": "Preview the DNS record without writing it.",
+          "name": "dry-run",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "force": {
+          "description": "Overwrite conflicting DNS records.",
+          "name": "force",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "json": {
+          "description": "Output a single JSON object and never prompt.",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "provider": {
+          "description": "DNS provider id. Inferred from the target domain when omitted.",
+          "name": "provider",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "target": {
+          "description": "IPv4, IPv6, or hostname target.",
+          "name": "target",
+          "required": true,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "timeout": {
+          "description": "DNS propagation wait timeout in seconds.",
+          "name": "timeout",
+          "default": 300,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "ttl": {
+          "description": "DNS record TTL in seconds.",
+          "name": "ttl",
+          "default": 300,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "type": {
+          "description": "Record type. Inferred from the target when omitted.",
+          "name": "type",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "options": [
+            "A",
+            "AAAA",
+            "CNAME"
+          ],
+          "type": "option"
+        },
+        "wait": {
+          "description": "Wait for public DNS propagation.",
+          "name": "wait",
+          "allowNo": true,
+          "type": "boolean"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "dns:point",
+      "pluginAlias": "doomain",
+      "pluginName": "doomain",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "dns",
+        "point.js"
+      ]
+    },
     "domains:find": {
       "aliases": [],
       "args": {
@@ -894,5 +1001,5 @@
       ]
     }
   },
-  "version": "0.1.18"
+  "version": "0.1.20"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "doomain",
-  "description": "Configure Vercel and Clerk production domains in seconds",
-  "version": "0.1.18",
+  "description": "Configure production domains and DNS records in seconds",
+  "version": "0.1.20",
   "author": "Crafter Station",
   "packageManager": "bun@1.3.13",
   "bin": {
@@ -64,6 +64,9 @@
       "domains": {
         "description": "Inspect DNS domains"
       },
+      "dns": {
+        "description": "Manage DNS records"
+      },
       "projects": {
         "description": "Inspect Vercel projects"
       },