doomain 0.1.0

package/dist/lib/link-domain.js

@@ -0,0 +1,336 @@
+import { resolve4, resolveCname, resolveTxt } from 'node:dns/promises';
+import { loadConfig } from './config.js';
+import { DoomainError } from './errors.js';
+import { detectLocalVercelProject } from './local-vercel.js';
+import { createProvider, getProviderDefinition, listProviderDefinitions } from './providers/registry.js';
+import { isProviderConfigured } from './providers/status.js';
+import { normalizeDomain, normalizeSubdomain } from './validate.js';
+import { createVercelClient, resolveVercelConfig, VERCEL_APEX_A_RECORD, VERCEL_CNAME_RECORD } from './vercel.js';
+function cleanDnsValue(value) {
+    return value.toLowerCase().replace(/\.$/, '');
+}
+function recordFqdn(record, zoneDomain) {
+    return record.name === '@' ? zoneDomain : `${record.name}.${zoneDomain}`;
+}
+async function resolveConfiguredDomain(domain) {
+    const config = await loadConfig();
+    const resolved = domain ?? process.env.DOOMAIN_DOMAIN ?? config.defaults?.domain;
+    if (!resolved)
+        throw new DoomainError('MISSING_ARGUMENT', 'Domain is required. Use --domain or set a default domain.');
+    return resolved;
+}
+function resolveProject(project) {
+    if (project)
+        return { project, localProjectDetected: false };
+    const localProject = detectLocalVercelProject();
+    if (localProject)
+        return { project: localProject.projectId, localProjectDetected: true };
+    throw new DoomainError('VERCEL_PROJECT_NOT_LINKED', 'No linked Vercel project found. Run inside a Vercel project or pass --project.');
+}
+async function resolveZone(provider, zoneDomain) {
+    const zone = await provider.getZone(zoneDomain);
+    if (!zone) {
+        throw new DoomainError('PROVIDER_ZONE_NOT_FOUND', `${provider.name} does not have a DNS zone for ${zoneDomain}.`);
+    }
+    return zone;
+}
+function resolveRequestedDomain(opts) {
+    if (opts.apex && opts.subdomain) {
+        throw new DoomainError('INVALID_INPUT', 'Use either --apex or --subdomain, not both.');
+    }
+    const domain = normalizeDomain(opts.domain);
+    if (opts.apex)
+        return { forceExactZone: true, fullDomain: domain };
+    if (!opts.subdomain)
+        return { forceExactZone: false, fullDomain: domain };
+    return { forceExactZone: false, fullDomain: `${normalizeSubdomain(opts.subdomain)}.${domain}` };
+}
+function zoneMatchesDomain(fullDomain, zoneDomain, forceExactZone) {
+    if (fullDomain === zoneDomain)
+        return true;
+    if (forceExactZone)
+        return false;
+    return fullDomain.endsWith(`.${zoneDomain}`);
+}
+function targetFromZone(fullDomain, zoneDomain) {
+    if (fullDomain === zoneDomain) {
+        return { fullDomain, isApex: true, recordName: '@', zoneDomain };
+    }
+    return {
+        fullDomain,
+        isApex: false,
+        recordName: fullDomain.slice(0, -(zoneDomain.length + 1)),
+        zoneDomain,
+    };
+}
+function candidateDetails(candidates) {
+    return candidates.map((candidate) => ({
+        provider: candidate.provider,
+        providerName: candidate.providerName,
+        zoneDomain: candidate.zone.name,
+    }));
+}
+async function loadProviderZones(definition) {
+    const provider = await createProvider(definition.id);
+    const zones = await provider.listZones();
+    return {
+        candidates: zones.map((zone) => ({ provider: definition.id, providerName: definition.displayName, zone })),
+        search: { displayName: definition.displayName, id: definition.id, zones: zones.map((zone) => zone.name) },
+    };
+}
+async function loadConfiguredProviderZones(providerId) {
+    if (providerId) {
+        const definition = getProviderDefinition(providerId);
+        const result = await loadProviderZones(definition);
+        return { candidates: result.candidates, providerInferred: false, searched: [result.search] };
+    }
+    const config = await loadConfig();
+    const definitions = listProviderDefinitions().filter((definition) => isProviderConfigured(definition, config));
+    if (definitions.length === 0) {
+        throw new DoomainError('CONFIG_NOT_FOUND', 'No DNS provider is configured. Run `doomain providers connect` first.');
+    }
+    const results = await Promise.all(definitions.map(async (definition) => {
+        try {
+            return await loadProviderZones(definition);
+        }
+        catch (error) {
+            return {
+                candidates: [],
+                search: {
+                    displayName: definition.displayName,
+                    error: error instanceof Error ? error.message : String(error),
+                    id: definition.id,
+                    zones: [],
+                },
+            };
+        }
+    }));
+    return {
+        candidates: results.flatMap((result) => result.candidates),
+        providerInferred: true,
+        searched: results.map((result) => result.search),
+    };
+}
+async function resolveProviderTarget(input) {
+    const requested = resolveRequestedDomain({
+        apex: input.apex,
+        domain: await resolveConfiguredDomain(input.domain),
+        subdomain: input.subdomain,
+    });
+    const zones = await loadConfiguredProviderZones(input.provider);
+    const matches = zones.candidates
+        .filter((candidate) => zoneMatchesDomain(requested.fullDomain, candidate.zone.name, requested.forceExactZone))
+        .sort((a, b) => b.zone.name.length - a.zone.name.length);
+    if (matches.length === 0) {
+        const providerMessage = input.provider
+            ? `${getProviderDefinition(input.provider).displayName} does not have a matching DNS zone for ${requested.fullDomain}.`
+            : `No configured DNS provider has a matching DNS zone for ${requested.fullDomain}.`;
+        throw new DoomainError('PROVIDER_ZONE_NOT_FOUND', providerMessage, { domain: requested.fullDomain, providers: zones.searched });
+    }
+    const bestLength = matches[0].zone.name.length;
+    const bestMatches = matches.filter((candidate) => candidate.zone.name.length === bestLength);
+    const uniqueBestMatches = bestMatches.filter((candidate, index, candidates) => candidates.findIndex((item) => item.provider === candidate.provider && item.zone.name === candidate.zone.name) === index);
+    if (uniqueBestMatches.length > 1) {
+        throw new DoomainError('PROVIDER_ZONE_AMBIGUOUS', `Multiple DNS providers have a matching DNS zone for ${requested.fullDomain}. Pass --provider to choose one.`, { candidates: candidateDetails(uniqueBestMatches), domain: requested.fullDomain });
+    }
+    const selected = uniqueBestMatches[0];
+    return {
+        provider: selected.provider,
+        providerInferred: zones.providerInferred,
+        target: targetFromZone(requested.fullDomain, selected.zone.name),
+    };
+}
+function withProviderRecordOptions(provider, record) {
+    if (provider !== 'cloudflare' || !['A', 'AAAA', 'CNAME'].includes(record.type))
+        return record;
+    return { ...record, proxied: false };
+}
+function planBaseRecord(opts) {
+    const record = opts.isApex
+        ? { type: 'A', name: '@', value: VERCEL_APEX_A_RECORD, ttl: 3600 }
+        : { type: 'CNAME', name: opts.recordName, value: opts.cname ?? VERCEL_CNAME_RECORD, ttl: 3600 };
+    return withProviderRecordOptions(opts.provider, record);
+}
+function planVerificationRecords(provider, raw, zoneDomain) {
+    return verificationRecords(raw, zoneDomain).map((record) => withProviderRecordOptions(provider, record));
+}
+function cleanVerificationName(name, zoneDomain) {
+    const cleaned = name.trim().toLowerCase().replace(/\.$/, '');
+    const zone = zoneDomain.toLowerCase().replace(/\.$/, '');
+    if (cleaned === zone)
+        return '@';
+    if (cleaned.endsWith(`.${zone}`))
+        return cleaned.slice(0, -(zone.length + 1)) || '@';
+    return cleaned;
+}
+function collectVerificationRecords(raw, seen = new Set()) {
+    if (!raw || typeof raw !== 'object' || seen.has(raw))
+        return [];
+    seen.add(raw);
+    if (Array.isArray(raw))
+        return raw.flatMap((item) => collectVerificationRecords(item, seen));
+    const object = raw;
+    const verification = object.verification;
+    const records = Array.isArray(verification) ? verification : [];
+    const nested = Object.entries(object).flatMap(([key, value]) => (key === 'verification' ? [] : collectVerificationRecords(value, seen)));
+    return [...records, ...nested];
+}
+function uniqueRecords(records) {
+    const seen = new Set();
+    const unique = [];
+    for (const record of records) {
+        const key = `${record.type}:${record.name}:${record.value}:${record.proxied ?? ''}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        unique.push(record);
+    }
+    return unique;
+}
+export function verificationRecords(raw, zoneDomain) {
+    const verification = collectVerificationRecords(raw);
+    return verification.flatMap((record) => {
+        if (record.type !== 'TXT' || !record.value)
+            return [];
+        const name = record.domain ?? record.name;
+        if (!name)
+            return [];
+        return [{ type: 'TXT', name: cleanVerificationName(name, zoneDomain), value: record.value, ttl: 3600 }];
+    });
+}
+async function wait(milliseconds) {
+    await new Promise((resolve) => {
+        setTimeout(resolve, milliseconds);
+    });
+}
+async function isRecordPropagated(record, zoneDomain) {
+    const fqdn = recordFqdn(record, zoneDomain);
+    try {
+        if (record.type === 'A') {
+            const values = await resolve4(fqdn);
+            return values.includes(record.value);
+        }
+        if (record.type === 'CNAME') {
+            const values = await resolveCname(fqdn);
+            return values.map(cleanDnsValue).includes(cleanDnsValue(record.value));
+        }
+        if (record.type === 'TXT') {
+            const values = (await resolveTxt(fqdn)).map((chunks) => chunks.join(''));
+            return values.includes(record.value);
+        }
+    }
+    catch {
+        return false;
+    }
+    return false;
+}
+function errorMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    return String(error);
+}
+async function areRecordsPropagated(records, zoneDomain) {
+    const results = await Promise.all(records.map((record) => isRecordPropagated(record, zoneDomain)));
+    return results.every(Boolean);
+}
+async function waitForVercelDomainReady(opts) {
+    const vercel = createVercelClient(await resolveVercelConfig());
+    const timeoutSeconds = opts.input.timeoutSeconds ?? 300;
+    const startedAt = Date.now();
+    const deadline = Date.now() + timeoutSeconds * 1000;
+    let lastError;
+    let propagated = false;
+    let attempt = 1;
+    while (Date.now() <= deadline) {
+        const elapsedSeconds = Math.round((Date.now() - startedAt) / 1000);
+        reportProgress(opts.input, 'vercel:verify', `Verifying domain in Vercel (attempt ${attempt}, ${elapsedSeconds}s elapsed)`);
+        try {
+            const current = await vercel.getProjectDomain(opts.project, opts.domain);
+            if (current.verified === true)
+                return { propagated: true, verified: true };
+            const result = await vercel.verifyProjectDomain(opts.project, opts.domain);
+            if (result.verified !== false)
+                return { propagated: true, verified: true };
+        }
+        catch (error) {
+            // Vercel returns an error while DNS is still propagating.
+            lastError = error;
+        }
+        propagated = await areRecordsPropagated(opts.records, opts.zoneDomain);
+        reportProgress(opts.input, 'dns:wait', propagated
+            ? 'DNS is visible publicly; Vercel verification is still pending'
+            : 'DNS records were saved; public DNS is still catching up');
+        attempt += 1;
+        await wait(5000);
+    }
+    if (lastError) {
+        throw new DoomainError('DOMAIN_VERIFY_FAILED', `Vercel did not verify ${opts.domain} within ${timeoutSeconds} seconds. Last Vercel response: ${errorMessage(lastError)}`);
+    }
+    return { propagated, verified: false };
+}
+function reportProgress(input, stage, message) {
+    input.progress?.({ message, stage });
+}
+export async function createLinkPlan(input) {
+    const project = resolveProject(input.project);
+    const resolved = await resolveProviderTarget(input);
+    const { provider, providerInferred, target } = resolved;
+    const record = planBaseRecord({ isApex: target.isApex, provider, recordName: target.recordName });
+    return {
+        provider,
+        providerInferred,
+        project: project.project,
+        recordName: target.recordName,
+        zoneDomain: target.zoneDomain,
+        domain: target.fullDomain,
+        isApex: target.isApex,
+        records: [record],
+        localProjectDetected: project.localProjectDetected,
+        actions: ['vercel:addProjectDomain', 'dns:upsertRecord', 'dns:waitPropagation', 'vercel:verifyProjectDomain'],
+    };
+}
+export async function linkDomain(input) {
+    const plan = await createLinkPlan(input);
+    if (input.dryRun) {
+        return {
+            ...plan,
+            dryRun: true,
+            dns: { updated: false, propagated: false, skipped: [] },
+            vercel: { added: false, alreadyAdded: false, verified: false },
+        };
+    }
+    const vercel = createVercelClient(await resolveVercelConfig());
+    const provider = await createProvider(plan.provider);
+    reportProgress(input, 'dns:resolve-zone', `Finding ${provider.name} DNS zone`);
+    const zone = await resolveZone(provider, plan.zoneDomain);
+    reportProgress(input, 'vercel:add-domain', 'Adding domain to Vercel');
+    const addResult = await vercel.addDomainToProject(plan.project, plan.domain);
+    reportProgress(input, 'vercel:get-target', 'Reading Vercel DNS target');
+    const cname = plan.isApex ? undefined : await vercel.getRecommendedCname(plan.domain);
+    reportProgress(input, 'vercel:get-domain', 'Reading Vercel verification records');
+    const projectDomain = await vercel.getProjectDomain(plan.project, plan.domain);
+    const baseRecord = planBaseRecord({ isApex: plan.isApex, provider: plan.provider, recordName: plan.recordName, cname });
+    const verificationDnsRecords = uniqueRecords([
+        ...planVerificationRecords(plan.provider, addResult.raw, plan.zoneDomain),
+        ...planVerificationRecords(plan.provider, projectDomain, plan.zoneDomain),
+    ]);
+    const records = [baseRecord, ...verificationDnsRecords];
+    reportProgress(input, 'dns:plan', `Reading ${provider.name} DNS records`);
+    const dnsPlan = await provider.planChanges(zone, records, { force: input.force });
+    reportProgress(input, 'dns:apply', `Updating DNS records in ${provider.name}`);
+    const dnsResult = await provider.applyChanges(zone, dnsPlan, { force: input.force });
+    const shouldWait = input.wait ?? true;
+    if (shouldWait) {
+        reportProgress(input, 'dns:wait', verificationDnsRecords.length > 0 ? 'DNS records saved; asking Vercel to verify ownership' : 'DNS records saved; asking Vercel to verify');
+    }
+    const waitResult = shouldWait
+        ? await waitForVercelDomainReady({ domain: plan.domain, input, project: plan.project, records, zoneDomain: plan.zoneDomain })
+        : { propagated: false, verified: false };
+    return {
+        ...plan,
+        records,
+        dryRun: false,
+        dns: { updated: dnsResult.applied.length > 0, propagated: waitResult.propagated, skipped: dnsResult.skipped },
+        vercel: { added: !addResult.alreadyAdded, alreadyAdded: addResult.alreadyAdded, verified: waitResult.verified },
+    };
+}

package/dist/lib/local-vercel.d.ts

@@ -0,0 +1,6 @@
+export interface LocalVercelProject {
+    projectId: string;
+    orgId?: string;
+    root: string;
+}
+export declare function detectLocalVercelProject(start?: string): LocalVercelProject | null;

package/dist/lib/local-vercel.js

@@ -0,0 +1,27 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join, parse } from 'node:path';
+export function detectLocalVercelProject(start = process.cwd()) {
+    let current = start;
+    const root = parse(start).root;
+    while (true) {
+        const projectPath = join(current, '.vercel', 'project.json');
+        if (existsSync(projectPath)) {
+            try {
+                const data = JSON.parse(readFileSync(projectPath, 'utf8'));
+                if (data.projectId) {
+                    return {
+                        projectId: data.projectId,
+                        orgId: data.orgId,
+                        root: current,
+                    };
+                }
+            }
+            catch {
+                return null;
+            }
+        }
+        if (current === root)
+            return null;
+        current = dirname(current);
+    }
+}

package/dist/lib/output.d.ts

@@ -0,0 +1,36 @@
+import { type DoomainErrorCode } from './errors.js';
+export interface JsonSuccess<T> {
+    ok: true;
+    data: T;
+}
+export interface JsonFailure {
+    ok: false;
+    error: {
+        code: DoomainErrorCode;
+        message: string;
+        details?: unknown;
+    };
+}
+export type JsonEnvelope<T> = JsonSuccess<T> | JsonFailure;
+export interface OutputContext {
+    readonly json: boolean;
+    info(message: string): void;
+    success(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    intro(message: string): void;
+    outro(message: string): void;
+    spinner(): {
+        error(message?: string): void;
+        message(message?: string): void;
+        start(message: string): void;
+        stop(message?: string): void;
+    };
+    result<T>(data: T): void;
+}
+export declare function shouldUseJson(flag?: boolean): boolean;
+export declare function writeJson<T>(data: JsonEnvelope<T>): void;
+export declare function createOutput(opts?: {
+    json?: boolean;
+}): OutputContext;
+export declare function outputError(json: boolean, error: unknown, fallbackCode: DoomainErrorCode): void;

package/dist/lib/output.js

@@ -0,0 +1,51 @@
+import * as p from '@clack/prompts';
+import { DoomainError, toDoomainError } from './errors.js';
+const noop = () => { };
+export function shouldUseJson(flag) {
+    return Boolean(flag) || !process.stdout.isTTY;
+}
+export function writeJson(data) {
+    process.stdout.write(`${JSON.stringify(data)}\n`);
+}
+export function createOutput(opts = {}) {
+    const json = shouldUseJson(opts.json);
+    if (json) {
+        return {
+            json: true,
+            info: noop,
+            success: noop,
+            warn: noop,
+            error: noop,
+            intro: noop,
+            outro: noop,
+            spinner: () => ({ error: noop, message: noop, start: noop, stop: noop }),
+            result: (data) => writeJson({ ok: true, data }),
+        };
+    }
+    return {
+        json: false,
+        info: (message) => p.log.info(message),
+        success: (message) => p.log.success(message),
+        warn: (message) => p.log.warning(message),
+        error: (message) => p.log.error(message),
+        intro: (message) => p.intro(message),
+        outro: (message) => p.outro(message),
+        spinner: () => p.spinner(),
+        result: noop,
+    };
+}
+export function outputError(json, error, fallbackCode) {
+    const doomainError = error instanceof DoomainError ? error : toDoomainError(error, fallbackCode);
+    if (json) {
+        writeJson({
+            ok: false,
+            error: {
+                code: doomainError.code,
+                message: doomainError.message,
+                ...(doomainError.details === undefined ? {} : { details: doomainError.details }),
+            },
+        });
+        return;
+    }
+    p.log.error(doomainError.message);
+}

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

@@ -0,0 +1,26 @@
+import type { DnsChange, DnsChangePlan, DnsProvider, DnsProviderDefinition, DnsRecord, DnsRecordInput, DnsZone, ProviderCapabilities, ProviderContext, ProviderHealth } from '../types.js';
+export declare class CloudflareProvider implements DnsProvider {
+    readonly capabilities: ProviderCapabilities;
+    readonly id = "cloudflare";
+    readonly name = "Cloudflare";
+    private readonly accountId;
+    private readonly http;
+    constructor(context: ProviderContext);
+    verifyCredentials(): Promise<ProviderHealth>;
+    listZones(): Promise<DnsZone[]>;
+    getZone(domain: string): Promise<DnsZone | null>;
+    listRecords(zone: DnsZone): Promise<DnsRecord[]>;
+    planChanges(zone: DnsZone, desired: DnsRecordInput[], opts?: {
+        force?: boolean;
+    }): Promise<DnsChangePlan>;
+    applyChanges(zone: DnsZone, plan: DnsChangePlan): Promise<{
+        applied: DnsChange[];
+        skipped: DnsRecordInput[];
+    }>;
+    upsertRecord(zone: DnsZone, record: DnsRecordInput): Promise<DnsRecord>;
+    deleteRecord(zone: DnsZone, record: DnsRecord): Promise<void>;
+    private createRecord;
+    private updateRecord;
+    private request;
+}
+export declare const cloudflareProviderDefinition: DnsProviderDefinition;