doomain 0.1.0

package/dist/commands/wizard.js

@@ -0,0 +1,322 @@
+import { Command } from '@oclif/core';
+import * as p from '@clack/prompts';
+import { loadConfig, updateConfig } from '../lib/config.js';
+import { DoomainError } from '../lib/errors.js';
+import { jsonFlag } from '../lib/flags.js';
+import { createLinkPlan, linkDomain } from '../lib/link-domain.js';
+import { detectLocalVercelProject } from '../lib/local-vercel.js';
+import { createOutput, outputError } from '../lib/output.js';
+import { createProvider, getProviderDefinition, listProviderDefinitions } from '../lib/providers/registry.js';
+import { isProviderConfigured } from '../lib/providers/status.js';
+import { createVercelClient } from '../lib/vercel.js';
+const PERSONAL_ACCOUNT = '__personal__';
+function cancelIfNeeded(value) {
+    if (p.isCancel(value)) {
+        p.cancel('Cancelled');
+        return null;
+    }
+    return value;
+}
+async function promptRequired(message, opts = {}) {
+    const value = opts.password
+        ? await p.password({ message })
+        : await p.text({ message, placeholder: opts.placeholder, validate: (input) => (input?.trim() ? undefined : 'Required') });
+    const resolved = cancelIfNeeded(value);
+    return typeof resolved === 'string' ? resolved.trim() : null;
+}
+async function fetchPublicIp() {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 2000);
+    try {
+        const response = await fetch('https://api.ipify.org', { signal: controller.signal });
+        if (!response.ok)
+            return undefined;
+        const ip = (await response.text()).trim();
+        return ip || undefined;
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function credentialInitialValue(credential) {
+    if (credential.key !== 'clientIp')
+        return undefined;
+    return fetchPublicIp();
+}
+async function promptCredential(credential) {
+    const initialValue = credential.secret ? undefined : await credentialInitialValue(credential);
+    const value = credential.secret
+        ? await p.password({ message: credential.label })
+        : await p.text({ message: credential.label, initialValue, placeholder: credential.placeholder ?? credential.hint });
+    const resolved = cancelIfNeeded(value);
+    return typeof resolved === 'string' && resolved.trim() ? resolved.trim() : null;
+}
+async function promptProviderCredentials(definition) {
+    const credentials = {};
+    for (const credential of definition.credentials) {
+        if (credential.required === false)
+            continue;
+        const value = await promptCredential(credential);
+        if (!value)
+            return null;
+        credentials[credential.key] = value;
+    }
+    return credentials;
+}
+async function promptProviderDefinition(definitions, config) {
+    const selected = await p.select({
+        message: 'Choose DNS provider',
+        options: definitions.map((definition) => ({
+            hint: isProviderConfigured(definition, config) ? 'Connected' : 'Not connected',
+            label: definition.displayName,
+            value: definition.id,
+        })),
+    });
+    const selectedId = cancelIfNeeded(selected);
+    if (selectedId === null)
+        return null;
+    return getProviderDefinition(selectedId);
+}
+function showProviderSetup(definition) {
+    if (!definition.setup?.notes?.length)
+        return;
+    p.note(definition.setup.notes.join('\n'), `${definition.displayName} setup`);
+}
+async function listProviderDomainOptions(definition) {
+    const provider = await createProvider(definition.id);
+    const zones = await provider.listZones();
+    return zones.map((zone) => toProviderDomainOption(definition, zone));
+}
+function toProviderDomainOption(definition, zone) {
+    return {
+        domain: zone.name,
+        id: `${definition.id}:${zone.name}`,
+        providerId: definition.id,
+        providerName: definition.displayName,
+    };
+}
+function projectLabel(project) {
+    return project.name ? `${project.name} (${project.id})` : project.id;
+}
+function teamLabel(team) {
+    const name = team.name ?? team.slug;
+    return `${name} (${team.id})`;
+}
+function recordPreview(record, providerName) {
+    const name = record.name === '@' ? 'root' : record.name;
+    return `DNS: ${record.type} ${name} -> ${record.value} in ${providerName}`;
+}
+export default class Wizard extends Command {
+    static description = 'Interactive Vercel domain linker.';
+    static hidden = true;
+    static flags = {
+        json: jsonFlag,
+    };
+    async run() {
+        const { flags } = await this.parse(Wizard);
+        const out = createOutput({ json: flags.json });
+        let activeSpinner;
+        if (out.json) {
+            outputError(true, new DoomainError('MISSING_ARGUMENT', 'The root `doomain` command is interactive. Use `doomain link --json` for agents.'), 'MISSING_ARGUMENT');
+            this.exit(1);
+        }
+        try {
+            p.intro('Doomain');
+            const config = await loadConfig();
+            const providerDefinitions = listProviderDefinitions();
+            let vercelToken = process.env.VERCEL_TOKEN || config.vercel?.token;
+            let vercelTeamId = process.env.VERCEL_TEAM_ID || config.vercel?.teamId;
+            const defaultProvider = process.env.DOOMAIN_PROVIDER || config.defaults?.provider;
+            const defaultDomain = process.env.DOOMAIN_DOMAIN || config.defaults?.domain;
+            if (!vercelToken) {
+                vercelToken = (await promptRequired('Vercel token', { password: true })) ?? undefined;
+                if (!vercelToken)
+                    return;
+            }
+            const localProject = detectLocalVercelProject();
+            const teamSpinner = p.spinner();
+            let teams = [];
+            if (process.env.VERCEL_TEAM_ID) {
+                p.log.info(`Using Vercel team ${vercelTeamId} from VERCEL_TEAM_ID.`);
+            }
+            else {
+                activeSpinner = teamSpinner;
+                teamSpinner.start('Loading Vercel teams');
+                teams = await createVercelClient({ token: vercelToken }).listTeams();
+                teamSpinner.stop(`Loaded ${teams.length} Vercel team${teams.length === 1 ? '' : 's'}`);
+                activeSpinner = undefined;
+                const selected = await p.select({
+                    message: 'Select Vercel account/team',
+                    initialValue: vercelTeamId ?? localProject?.orgId ?? PERSONAL_ACCOUNT,
+                    options: [
+                        { label: 'Personal account', value: PERSONAL_ACCOUNT, hint: 'No team id' },
+                        ...teams.map((team) => ({ label: teamLabel(team), value: team.id, hint: team.role ?? team.slug })),
+                    ],
+                });
+                const resolved = cancelIfNeeded(selected);
+                if (resolved === null)
+                    return;
+                vercelTeamId = resolved === PERSONAL_ACCOUNT ? undefined : resolved;
+            }
+            const selectedTeam = teams.find((team) => team.id === vercelTeamId);
+            const teamDisplay = vercelTeamId ? teamLabel(selectedTeam ?? { id: vercelTeamId, name: null, role: null, slug: vercelTeamId }) : 'Personal account';
+            p.log.success(`Vercel account ready: ${teamDisplay}`);
+            const localProjectMatchesTeam = localProject && (vercelTeamId ? localProject.orgId === vercelTeamId : !localProject.orgId);
+            let project = localProjectMatchesTeam ? localProject.projectId : undefined;
+            let projectDisplay = project ? projectLabel({ id: project }) : '';
+            if (project) {
+                p.log.info(`Using linked Vercel project ${projectDisplay}.`);
+            }
+            else {
+                const spinner = p.spinner();
+                activeSpinner = spinner;
+                spinner.start('Loading Vercel projects');
+                const projects = await createVercelClient({ token: vercelToken, teamId: vercelTeamId }).listProjects();
+                spinner.stop(`Loaded ${projects.length} projects`);
+                activeSpinner = undefined;
+                if (projects.length === 0) {
+                    throw new DoomainError('PROJECT_NOT_FOUND', `No Vercel projects found in ${teamDisplay}.`);
+                }
+                const selected = await p.autocomplete({
+                    message: 'Select Vercel project',
+                    placeholder: 'Type to filter projects...',
+                    maxItems: 10,
+                    options: projects.map((item) => ({ label: projectLabel(item), value: item.id, hint: item.framework ?? undefined })),
+                });
+                const resolved = cancelIfNeeded(selected);
+                if (resolved === null)
+                    return;
+                project = resolved;
+                projectDisplay = projectLabel(projects.find((item) => item.id === project) ?? { id: project });
+            }
+            p.log.success(`Vercel ready: ${projectDisplay}`);
+            const configuredProviderDefinitions = providerDefinitions.filter((definition) => isProviderConfigured(definition, config));
+            const providerFailures = [];
+            const domainOptions = [];
+            if (configuredProviderDefinitions.length === 0) {
+                p.log.info('No DNS provider is configured yet. Connect one to continue.');
+                const selectedDefinition = await promptProviderDefinition(providerDefinitions, config);
+                if (!selectedDefinition)
+                    return;
+                showProviderSetup(selectedDefinition);
+                const credentials = await promptProviderCredentials(selectedDefinition);
+                if (!credentials)
+                    return;
+                const domainSpinner = p.spinner();
+                activeSpinner = domainSpinner;
+                domainSpinner.start(`Verifying ${selectedDefinition.displayName} credentials and loading domains`);
+                const provider = selectedDefinition.create({ credentials, debug: process.env.DOOMAIN_DEBUG === '1' });
+                const zones = await provider.listZones();
+                domainSpinner.stop(`Connected ${selectedDefinition.displayName} and loaded ${zones.length} domain${zones.length === 1 ? '' : 's'}`);
+                activeSpinner = undefined;
+                domainOptions.push(...zones.map((zone) => toProviderDomainOption(selectedDefinition, zone)));
+                await updateConfig((current) => ({
+                    ...current,
+                    defaults: { ...current.defaults, provider: selectedDefinition.id },
+                    providers: { ...current.providers, [selectedDefinition.id]: { credentials } },
+                    vercel: { token: vercelToken, teamId: vercelTeamId },
+                }));
+            }
+            else {
+                const domainSpinner = p.spinner();
+                activeSpinner = domainSpinner;
+                domainSpinner.start(`Loading domains from ${configuredProviderDefinitions.length} provider${configuredProviderDefinitions.length === 1 ? '' : 's'}`);
+                for (const definition of configuredProviderDefinitions) {
+                    try {
+                        domainOptions.push(...(await listProviderDomainOptions(definition)));
+                    }
+                    catch (error) {
+                        providerFailures.push(`${definition.displayName}: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                }
+                domainSpinner.stop(`Loaded ${domainOptions.length} domain${domainOptions.length === 1 ? '' : 's'}`);
+                activeSpinner = undefined;
+                for (const failure of providerFailures)
+                    p.log.warning(failure);
+                await updateConfig((current) => ({
+                    ...current,
+                    vercel: { token: vercelToken, teamId: vercelTeamId },
+                }));
+            }
+            if (domainOptions.length === 0) {
+                throw new DoomainError('CONFIG_NOT_FOUND', 'No domains found in configured DNS providers. Verify provider credentials and domain permissions.');
+            }
+            const providerNames = [...new Set(domainOptions.map((option) => option.providerName))].join(', ');
+            p.log.success(`DNS ready: ${providerNames} (${domainOptions.length} domains)`);
+            let selectedDomain = domainOptions[0];
+            if (domainOptions.length > 1) {
+                const initialValue = domainOptions.find((option) => option.providerId === defaultProvider && option.domain === defaultDomain)?.id ??
+                    domainOptions.find((option) => option.domain === defaultDomain)?.id;
+                const selectedDomainId = await p.autocomplete({
+                    message: 'Select domain',
+                    placeholder: 'Type to filter domains...',
+                    maxItems: 10,
+                    initialValue,
+                    options: domainOptions.map((option) => ({ label: option.domain, value: option.id, hint: option.providerName })),
+                });
+                const selectedId = cancelIfNeeded(selectedDomainId);
+                if (selectedId === null)
+                    return;
+                selectedDomain = domainOptions.find((option) => option.id === selectedId) ?? domainOptions[0];
+            }
+            p.log.info(`Using domain ${selectedDomain.domain} from ${selectedDomain.providerName}.`);
+            const domain = selectedDomain.domain;
+            await updateConfig((current) => ({
+                ...current,
+                defaults: { ...current.defaults, domain, provider: selectedDomain.providerId },
+            }));
+            const mode = await p.select({
+                message: 'What should Doomain add?',
+                options: [
+                    { label: `Subdomain under ${domain}`, value: 'subdomain' },
+                    { label: `Root domain (${domain})`, value: 'apex' },
+                ],
+            });
+            const resolvedMode = cancelIfNeeded(mode);
+            if (resolvedMode === null)
+                return;
+            let subdomain;
+            const apex = resolvedMode === 'apex';
+            if (!apex) {
+                subdomain = (await promptRequired('Subdomain', { placeholder: 'app' })) ?? undefined;
+                if (!subdomain)
+                    return;
+            }
+            const fullDomain = apex ? domain : `${subdomain}.${domain}`;
+            const preview = await createLinkPlan({ provider: selectedDomain.providerId, domain, subdomain, apex, project });
+            p.note([`Vercel: add ${preview.domain} to ${projectDisplay}`, ...preview.records.map((record) => recordPreview(record, selectedDomain.providerName))].join('\n'), 'Preview');
+            const confirmed = await p.confirm({
+                message: `Link ${fullDomain} via ${selectedDomain.providerName} to Vercel project ${projectDisplay}?`,
+                initialValue: true,
+            });
+            const shouldContinue = cancelIfNeeded(confirmed);
+            if (!shouldContinue)
+                return;
+            const spinner = p.spinner();
+            activeSpinner = spinner;
+            spinner.start('Adding domain to Vercel');
+            const result = await linkDomain({
+                provider: selectedDomain.providerId,
+                domain,
+                subdomain,
+                apex,
+                project,
+                progress: ({ message }) => spinner.message(message),
+                wait: true,
+            });
+            spinner.stop(result.vercel.verified ? 'Domain linked and verified' : 'Domain linked');
+            activeSpinner = undefined;
+            p.outro(result.vercel.verified
+                ? `${result.domain} is linked to ${projectDisplay}. SSL certificate provisioning may take a few minutes in Vercel.`
+                : `${result.domain} is linked to ${projectDisplay}.`);
+        }
+        catch (error) {
+            activeSpinner?.error('Operation failed');
+            outputError(false, error, 'DOMAIN_LINK_FAILED');
+            this.exit(1);
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/index.js

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/lib/command-schema.d.ts

@@ -0,0 +1,14 @@
+export interface CommandSchema {
+    name: string;
+    description: string;
+    examples: string[];
+    flags: Array<{
+        name: string;
+        type: 'boolean' | 'integer' | 'string';
+        description: string;
+        required?: boolean;
+        default?: unknown;
+    }>;
+}
+export declare const commandSchemas: CommandSchema[];
+export declare function getCommandSchema(name?: string): CommandSchema[] | CommandSchema | undefined;

package/dist/lib/command-schema.js

@@ -0,0 +1,99 @@
+export const commandSchemas = [
+    {
+        name: 'link',
+        description: 'Link a Vercel project to a domain and create DNS records.',
+        examples: [
+            'doomain link app.example.com --project my-app --json',
+            'doomain link --domain app.example.com --project my-app --json',
+            'doomain link --domain example.com --subdomain app --project my-app --json',
+            'doomain link --provider spaceship --domain example.com --apex --project my-app --dry-run --json',
+        ],
+        flags: [
+            { name: 'json', type: 'boolean', description: 'Output a single JSON object and never prompt.' },
+            { name: 'provider', type: 'string', description: 'DNS provider id. Inferred from the target domain when omitted.' },
+            { name: 'domain', type: 'string', description: 'Target domain or base zone, for example app.example.com or example.com.' },
+            { name: 'subdomain', type: 'string', description: 'Subdomain to add.' },
+            { name: 'apex', type: 'boolean', description: 'Use the root/apex domain.' },
+            { name: 'project', type: 'string', description: 'Vercel project id/name.' },
+            { name: 'dry-run', type: 'boolean', description: 'Preview changes without writing.' },
+            { name: 'force', type: 'boolean', description: 'Overwrite conflicting DNS records.' },
+            { name: 'wait', type: 'boolean', description: 'Wait for DNS and Vercel verification.', default: true },
+            { name: 'timeout', type: 'integer', description: 'Wait timeout in seconds.', default: 300 },
+        ],
+    },
+    {
+        name: 'providers connect',
+        description: 'Save DNS provider credentials locally after verifying them. Prompts for a provider when omitted.',
+        examples: [
+            'doomain providers connect',
+            'doomain providers connect spaceship --credential apiKey=key --credential apiSecret=secret --json',
+            'doomain providers connect namecheap --credential apiUser=user --credential apiKey=key --credential clientIp=127.0.0.1 --json',
+            'doomain providers connect cloudflare --credential apiToken=token --credential accountId=account_id --json',
+        ],
+        flags: [
+            { name: 'json', type: 'boolean', description: 'Output a single JSON object and never prompt.' },
+            { name: 'credential', type: 'string', description: 'Provider credential as key=value. Can be repeated.' },
+            { name: 'api-key', type: 'string', description: 'Spaceship API key.' },
+            { name: 'api-secret', type: 'string', description: 'Spaceship API secret.' },
+            { name: 'no-verify', type: 'boolean', description: 'Save credentials without verifying them first.' },
+        ],
+    },
+    {
+        name: 'providers add',
+        description: 'Alias for providers connect.',
+        examples: ['doomain providers add', 'doomain providers add namecheap'],
+        flags: [
+            { name: 'json', type: 'boolean', description: 'Output a single JSON object and never prompt.' },
+            { name: 'credential', type: 'string', description: 'Provider credential as key=value. Can be repeated.' },
+            { name: 'no-verify', type: 'boolean', description: 'Save credentials without verifying them first.' },
+        ],
+    },
+    {
+        name: 'providers status',
+        description: 'Show configured DNS providers and credential health.',
+        examples: ['doomain providers status', 'doomain providers status --no-verify --json'],
+        flags: [
+            { name: 'json', type: 'boolean', description: 'Output a single JSON object and never prompt.' },
+            { name: 'no-verify', type: 'boolean', description: 'Skip provider API calls.' },
+        ],
+    },
+    {
+        name: 'providers disconnect',
+        description: 'Remove saved DNS provider credentials locally.',
+        examples: ['doomain providers disconnect namecheap --json', 'doomain providers disconnect cloudflare --json'],
+        flags: [
+            { name: 'json', type: 'boolean', description: 'Output a single JSON object and never prompt.' },
+        ],
+    },
+    {
+        name: 'providers verify',
+        description: 'Verify saved DNS provider credentials.',
+        examples: ['doomain providers verify spaceship --json', 'doomain providers verify namecheap --json'],
+        flags: [
+            { name: 'json', type: 'boolean', description: 'Output a single JSON object and never prompt.' },
+        ],
+    },
+    {
+        name: 'auth vercel',
+        description: 'Save Vercel credentials locally.',
+        examples: ['doomain auth vercel --token token --team-id team_123 --json', 'doomain auth vercel'],
+        flags: [
+            { name: 'json', type: 'boolean', description: 'Output a single JSON object and never prompt.' },
+            { name: 'token', type: 'string', description: 'Vercel API token.' },
+            { name: 'team-id', type: 'string', description: 'Optional Vercel team id. Interactive mode can fetch and select it.' },
+        ],
+    },
+    {
+        name: 'auth logout vercel',
+        description: 'Remove saved Vercel credentials locally.',
+        examples: ['doomain auth logout vercel --json'],
+        flags: [
+            { name: 'json', type: 'boolean', description: 'Output a single JSON object and never prompt.' },
+        ],
+    },
+];
+export function getCommandSchema(name) {
+    if (!name)
+        return commandSchemas;
+    return commandSchemas.find((schema) => schema.name === name);
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,34 @@
+export declare function getConfigDir(): string;
+export declare function getConfigFile(): string;
+export declare const CONFIG_DIR: string;
+export declare const CONFIG_FILE: string;
+export interface VercelConfig {
+    token?: string;
+    teamId?: string;
+}
+export interface ProviderConfig {
+    credentials?: Record<string, string>;
+    settings?: Record<string, unknown>;
+}
+export interface SpaceshipProviderConfig extends ProviderConfig {
+    apiKey?: string;
+    apiSecret?: string;
+    domains?: string[];
+}
+export interface DoomainConfig {
+    vercel?: VercelConfig;
+    providers?: {
+        spaceship?: SpaceshipProviderConfig;
+        [provider: string]: ProviderConfig | SpaceshipProviderConfig | undefined;
+    };
+    defaults?: {
+        provider?: string;
+        domain?: string;
+    };
+}
+export declare function loadConfig(): Promise<DoomainConfig>;
+export declare function saveConfig(config: DoomainConfig): Promise<void>;
+export declare function updateConfig(updater: (config: DoomainConfig) => DoomainConfig): Promise<DoomainConfig>;
+export declare function clearConfig(): Promise<boolean>;
+export declare function getConfigPath(): string;
+export declare function maskSecret(value?: string): string | undefined;

package/dist/lib/config.js

@@ -0,0 +1,49 @@
+import { mkdir, readFile, unlink, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+export function getConfigDir() {
+    return process.env.DOOMAIN_CONFIG_DIR || join(homedir(), '.doomain');
+}
+export function getConfigFile() {
+    return process.env.DOOMAIN_CONFIG_FILE || join(getConfigDir(), 'config.json');
+}
+export const CONFIG_DIR = getConfigDir();
+export const CONFIG_FILE = getConfigFile();
+export async function loadConfig() {
+    try {
+        const data = await readFile(getConfigFile(), 'utf8');
+        return JSON.parse(data);
+    }
+    catch {
+        return {};
+    }
+}
+export async function saveConfig(config) {
+    const configFile = getConfigFile();
+    await mkdir(dirname(configFile), { recursive: true });
+    await writeFile(configFile, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
+}
+export async function updateConfig(updater) {
+    const next = updater(await loadConfig());
+    await saveConfig(next);
+    return next;
+}
+export async function clearConfig() {
+    try {
+        await unlink(getConfigFile());
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function getConfigPath() {
+    return getConfigFile();
+}
+export function maskSecret(value) {
+    if (!value)
+        return undefined;
+    if (value.length <= 8)
+        return '********';
+    return `${value.slice(0, 4)}...${value.slice(-4)}`;
+}

package/dist/lib/errors.d.ts

@@ -0,0 +1,7 @@
+export type DoomainErrorCode = 'CONFIG_NOT_FOUND' | 'DOMAIN_LINK_FAILED' | 'DOMAIN_VERIFY_FAILED' | 'INVALID_INPUT' | 'MISSING_ARGUMENT' | 'MISSING_CREDENTIALS' | 'PROVIDER_API_ERROR' | 'PROVIDER_AUTH_FAILED' | 'PROVIDER_PERMISSION_DENIED' | 'PROVIDER_NOT_FOUND' | 'PROVIDER_RATE_LIMITED' | 'PROVIDER_RECORD_CONFLICT' | 'PROVIDER_UNSUPPORTED_RECORD' | 'PROVIDER_ZONE_AMBIGUOUS' | 'PROVIDER_ZONE_NOT_FOUND' | 'PROJECT_NOT_FOUND' | 'VERCEL_PROJECT_NOT_LINKED';
+export declare class DoomainError extends Error {
+    readonly code: DoomainErrorCode;
+    readonly details?: unknown;
+    constructor(code: DoomainErrorCode, message: string, details?: unknown);
+}
+export declare function toDoomainError(error: unknown, fallbackCode: DoomainErrorCode): DoomainError;

package/dist/lib/errors.js

@@ -0,0 +1,17 @@
+export class DoomainError extends Error {
+    code;
+    details;
+    constructor(code, message, details) {
+        super(message);
+        this.name = 'DoomainError';
+        this.code = code;
+        this.details = details;
+    }
+}
+export function toDoomainError(error, fallbackCode) {
+    if (error instanceof DoomainError)
+        return error;
+    if (error instanceof Error)
+        return new DoomainError(fallbackCode, error.message);
+    return new DoomainError(fallbackCode, String(error));
+}

package/dist/lib/flags.d.ts

@@ -0,0 +1,6 @@
+export declare const jsonFlag: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+export declare const providerFlag: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+export declare const domainFlag: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+export declare const subdomainFlag: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+export declare const apexFlag: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+export declare const projectFlag: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;

package/dist/lib/flags.js

@@ -0,0 +1,10 @@
+import { Flags } from '@oclif/core';
+export const jsonFlag = Flags.boolean({ description: 'Output a single JSON object and never prompt.' });
+export const providerFlag = Flags.string({ description: 'DNS provider id. Inferred from the target domain when omitted.' });
+export const domainFlag = Flags.string({ description: 'Target domain or base zone, for example app.example.com or example.com.' });
+export const subdomainFlag = Flags.string({ description: 'Subdomain to add, for example app for app.example.com.' });
+export const apexFlag = Flags.boolean({ description: 'Use the root/apex domain instead of a subdomain.' });
+export const projectFlag = Flags.string({
+    char: 'p',
+    description: 'Vercel project id/name. Auto-detected from .vercel/project.json when omitted.',
+});

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

@@ -0,0 +1,47 @@
+import type { DnsRecordInput } from './providers/types.js';
+export interface LinkDomainInput {
+    provider?: string;
+    domain?: string;
+    subdomain?: string;
+    apex?: boolean;
+    project?: string;
+    dryRun?: boolean;
+    force?: boolean;
+    wait?: boolean;
+    timeoutSeconds?: number;
+    progress?: LinkDomainProgressCallback;
+}
+export type LinkDomainProgressStage = 'dns:apply' | 'dns:plan' | 'dns:resolve-zone' | 'dns:wait' | 'vercel:add-domain' | 'vercel:get-domain' | 'vercel:get-target' | 'vercel:verify';
+export interface LinkDomainProgress {
+    message: string;
+    stage: LinkDomainProgressStage;
+}
+export type LinkDomainProgressCallback = (progress: LinkDomainProgress) => void;
+export interface LinkDomainPlan {
+    provider: string;
+    providerInferred: boolean;
+    project: string;
+    recordName: string;
+    zoneDomain: string;
+    domain: string;
+    isApex: boolean;
+    records: DnsRecordInput[];
+    actions: string[];
+    localProjectDetected: boolean;
+}
+export interface LinkDomainResult extends LinkDomainPlan {
+    dryRun: boolean;
+    dns: {
+        updated: boolean;
+        propagated: boolean;
+        skipped: DnsRecordInput[];
+    };
+    vercel: {
+        added: boolean;
+        alreadyAdded: boolean;
+        verified: boolean;
+    };
+}
+export declare function verificationRecords(raw: unknown, zoneDomain: string): DnsRecordInput[];
+export declare function createLinkPlan(input: LinkDomainInput): Promise<LinkDomainPlan>;
+export declare function linkDomain(input: LinkDomainInput): Promise<LinkDomainResult>;