doomain 0.1.0

package/dist/commands/providers/connect.js

@@ -0,0 +1,183 @@
+import { Args, Command, Flags } from '@oclif/core';
+import * as p from '@clack/prompts';
+import { getConfigPath, loadConfig, maskSecret, updateConfig } from '../../lib/config.js';
+import { jsonFlag } from '../../lib/flags.js';
+import { createOutput, outputError } from '../../lib/output.js';
+import { getProviderDefinition, listProviderDefinitions } from '../../lib/providers/registry.js';
+import { isProviderConfigured } from '../../lib/providers/status.js';
+function requireString(value, message) {
+    if (typeof value === 'string' && value.trim())
+        return value.trim();
+    throw new Error(message);
+}
+function parseCredentialFlags(values) {
+    const credentials = {};
+    for (const value of values ?? []) {
+        const index = value.indexOf('=');
+        if (index <= 0)
+            throw new Error(`Invalid --credential value "${value}". Use key=value.`);
+        credentials[value.slice(0, index)] = value.slice(index + 1);
+    }
+    return credentials;
+}
+function legacyFlagValue(flags, credential) {
+    const key = credential.key.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`);
+    const value = flags[key];
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+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);
+    }
+}
+function credentialInitialValue(credential, detectedPublicIp) {
+    if (credential.key !== 'clientIp')
+        return undefined;
+    return detectedPublicIp;
+}
+async function promptCredential(credential, detectedPublicIp) {
+    const initialValue = credential.secret ? undefined : credentialInitialValue(credential, detectedPublicIp);
+    const value = credential.secret
+        ? await p.password({ message: credential.label })
+        : await p.text({ message: credential.label, initialValue, placeholder: credential.placeholder ?? credential.hint });
+    if (p.isCancel(value)) {
+        p.cancel('Cancelled');
+        return null;
+    }
+    return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+async function promptProvider() {
+    const config = await loadConfig();
+    const selected = await p.select({
+        message: 'Choose DNS provider',
+        options: listProviderDefinitions().map((definition) => ({
+            hint: isProviderConfigured(definition, config) ? 'Connected' : 'Not connected',
+            label: definition.displayName,
+            value: definition.id,
+        })),
+    });
+    if (p.isCancel(selected)) {
+        p.cancel('Cancelled');
+        return null;
+    }
+    return getProviderDefinition(selected);
+}
+function usesClientIp(definition) {
+    return definition.credentials.some((credential) => credential.key === 'clientIp');
+}
+function showSetupGuide(definition, detectedPublicIp) {
+    if (!definition.setup?.notes?.length)
+        return;
+    const notes = [...definition.setup.notes];
+    if (detectedPublicIp)
+        notes.push(`Detected public IP: ${detectedPublicIp}`);
+    p.note(notes.join('\n'), `${definition.displayName} setup`);
+}
+export default class ProvidersConnect extends Command {
+    static args = {
+        provider: Args.string({ description: 'Provider id, for example spaceship.', required: false }),
+    };
+    static description = 'Save DNS provider credentials locally.';
+    static flags = {
+        'api-key': Flags.string({ description: 'Compatibility alias for Spaceship apiKey.' }),
+        'api-secret': Flags.string({ description: 'Compatibility alias for Spaceship apiSecret.' }),
+        credential: Flags.string({ char: 'c', description: 'Provider credential as key=value.', multiple: true }),
+        json: jsonFlag,
+        'no-verify': Flags.boolean({ description: 'Save credentials without verifying them first.' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ProvidersConnect);
+        const out = createOutput({ json: flags.json });
+        let spinner;
+        try {
+            if (!args.provider && out.json)
+                throw new Error('Missing provider. Pass a provider id, for example `namecheap`.');
+            const definition = args.provider ? getProviderDefinition(args.provider) : await promptProvider();
+            if (!definition)
+                return;
+            const passedCredentials = parseCredentialFlags(flags.credential);
+            const credentials = {};
+            const detectedPublicIp = !out.json && usesClientIp(definition) ? await fetchPublicIp() : undefined;
+            if (!out.json)
+                showSetupGuide(definition, detectedPublicIp);
+            for (const credential of definition.credentials) {
+                const value = process.env[credential.env] || passedCredentials[credential.key] || legacyFlagValue(flags, credential) || undefined;
+                if (value) {
+                    credentials[credential.key] = value;
+                    continue;
+                }
+                const initialValue = credentialInitialValue(credential, detectedPublicIp);
+                if (initialValue) {
+                    credentials[credential.key] = initialValue;
+                    continue;
+                }
+                if (out.json || credential.required === false)
+                    continue;
+                const prompted = await promptCredential(credential, detectedPublicIp);
+                if (prompted === null)
+                    return;
+                credentials[credential.key] = prompted;
+            }
+            for (const credential of definition.credentials) {
+                if (credential.required !== false) {
+                    credentials[credential.key] = requireString(credentials[credential.key], `Missing ${definition.displayName} ${credential.label}. Pass --credential ${credential.key}=... or set ${credential.env}.`);
+                }
+            }
+            let domainCount;
+            if (!flags['no-verify']) {
+                spinner = out.json ? undefined : out.spinner();
+                spinner?.start(`Verifying ${definition.displayName} credentials`);
+                const zones = await definition.create({ credentials, debug: process.env.DOOMAIN_DEBUG === '1' }).listZones();
+                domainCount = zones.length;
+                spinner?.stop(`Verified ${definition.displayName} credentials and found ${domainCount} domain${domainCount === 1 ? '' : 's'}`);
+                spinner = undefined;
+            }
+            let setDefault = true;
+            const currentConfig = await loadConfig();
+            if (!out.json && currentConfig.defaults?.provider && currentConfig.defaults.provider !== definition.id) {
+                const value = await p.confirm({
+                    initialValue: true,
+                    message: `Set ${definition.displayName} as the default DNS provider?`,
+                });
+                if (p.isCancel(value)) {
+                    p.cancel('Cancelled');
+                    return;
+                }
+                setDefault = value;
+            }
+            await updateConfig((config) => ({
+                ...config,
+                defaults: setDefault ? { ...config.defaults, provider: definition.id } : config.defaults,
+                providers: {
+                    ...config.providers,
+                    [definition.id]: { credentials },
+                },
+            }));
+            out.result({
+                configPath: getConfigPath(),
+                credentials: Object.fromEntries(Object.entries(credentials).map(([key, value]) => [key, maskSecret(value)])),
+                domainCount,
+                provider: definition.id,
+                verified: !flags['no-verify'],
+            });
+            out.success(`${definition.displayName} credentials saved to ${getConfigPath()}.`);
+        }
+        catch (error) {
+            spinner?.error('Provider connection failed');
+            outputError(out.json, error, 'MISSING_CREDENTIALS');
+            this.exit(1);
+        }
+    }
+}

package/dist/commands/providers/disconnect.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+export default class ProvidersDisconnect extends Command {
+    static aliases: string[];
+    static args: {
+        provider: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/providers/disconnect.js

@@ -0,0 +1,52 @@
+import { Args, Command } from '@oclif/core';
+import { getConfigPath, updateConfig } from '../../lib/config.js';
+import { jsonFlag } from '../../lib/flags.js';
+import { createOutput, outputError } from '../../lib/output.js';
+import { getProviderDefinition } from '../../lib/providers/registry.js';
+function envOverrides(definition) {
+    return definition.credentials.flatMap((credential) => (process.env[credential.env] ? [credential.env] : []));
+}
+export default class ProvidersDisconnect extends Command {
+    static aliases = ['providers logout'];
+    static args = {
+        provider: Args.string({ description: 'Provider id, for example namecheap.', required: true }),
+    };
+    static description = 'Remove saved DNS provider credentials locally.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> namecheap',
+        '<%= config.bin %> <%= command.id %> cloudflare --json',
+    ];
+    static flags = {
+        json: jsonFlag,
+    };
+    async run() {
+        const { args, flags } = await this.parse(ProvidersDisconnect);
+        const out = createOutput({ json: flags.json });
+        try {
+            const definition = getProviderDefinition(args.provider);
+            let removed = false;
+            await updateConfig((config) => {
+                const providers = { ...config.providers };
+                removed = providers[definition.id] !== undefined;
+                delete providers[definition.id];
+                const defaults = { ...config.defaults };
+                if (defaults.provider === definition.id)
+                    delete defaults.provider;
+                return {
+                    ...config,
+                    defaults: Object.keys(defaults).length > 0 ? defaults : undefined,
+                    providers: Object.keys(providers).length > 0 ? providers : undefined,
+                };
+            });
+            const overrides = envOverrides(definition);
+            out.result({ configPath: getConfigPath(), environmentOverrides: overrides, provider: definition.id, removed });
+            if (overrides.length > 0)
+                out.warn(`${definition.displayName} environment credentials are still set: ${overrides.join(', ')}.`);
+            out.success(removed ? `${definition.displayName} credentials removed from ${getConfigPath()}.` : `${definition.displayName} was not connected.`);
+        }
+        catch (error) {
+            outputError(out.json, error, 'PROVIDER_NOT_FOUND');
+            this.exit(1);
+        }
+    }
+}

package/dist/commands/providers/list.d.ts

@@ -0,0 +1,8 @@
+import { Command } from '@oclif/core';
+export default class ProvidersList extends Command {
+    static description: string;
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/providers/list.js

@@ -0,0 +1,25 @@
+import { Command } from '@oclif/core';
+import { jsonFlag } from '../../lib/flags.js';
+import { listProviderDefinitions } from '../../lib/providers/registry.js';
+import { createOutput } from '../../lib/output.js';
+export default class ProvidersList extends Command {
+    static description = 'List supported DNS providers.';
+    static flags = {
+        json: jsonFlag,
+    };
+    async run() {
+        const { flags } = await this.parse(ProvidersList);
+        const out = createOutput({ json: flags.json });
+        const providers = listProviderDefinitions().map((provider) => ({
+            capabilities: provider.capabilities,
+            credentials: provider.credentials,
+            docsUrl: provider.docsUrl,
+            id: provider.id,
+            displayName: provider.displayName,
+            name: provider.name,
+        }));
+        for (const provider of providers)
+            out.info(`${provider.id} - ${provider.displayName}`);
+        out.result({ providers });
+    }
+}

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

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class ProvidersStatus extends Command {
+    static description: string;
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'no-verify': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/providers/status.js

@@ -0,0 +1,31 @@
+import { Command, Flags } from '@oclif/core';
+import { jsonFlag } from '../../lib/flags.js';
+import { createOutput } from '../../lib/output.js';
+import { listProviderStatuses } from '../../lib/providers/status.js';
+function formatStatus(provider) {
+    if (!provider.configured)
+        return 'not connected';
+    if (provider.verified === undefined)
+        return 'configured';
+    if (!provider.verified)
+        return `failed: ${provider.error}`;
+    return `verified${provider.domainCount === undefined ? '' : `, ${provider.domainCount} domains`}`;
+}
+export default class ProvidersStatus extends Command {
+    static description = 'Show configured DNS providers and credential health.';
+    static flags = {
+        json: jsonFlag,
+        'no-verify': Flags.boolean({ description: 'Skip provider API calls and only show local configuration status.' }),
+    };
+    async run() {
+        const { flags } = await this.parse(ProvidersStatus);
+        const out = createOutput({ json: flags.json });
+        const spinner = out.json || flags['no-verify'] ? undefined : out.spinner();
+        spinner?.start('Checking DNS providers');
+        const providers = await listProviderStatuses({ verify: !flags['no-verify'] });
+        spinner?.stop('Checked DNS providers');
+        for (const provider of providers)
+            out.info(`${provider.displayName} (${provider.id}) - ${formatStatus(provider)}${provider.default ? ' [default]' : ''}`);
+        out.result({ providers });
+    }
+}

package/dist/commands/providers/verify.d.ts

@@ -0,0 +1,11 @@
+import { Command } from '@oclif/core';
+export default class ProvidersVerify extends Command {
+    static args: {
+        provider: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/providers/verify.js

@@ -0,0 +1,27 @@
+import { Args, Command } from '@oclif/core';
+import { jsonFlag } from '../../lib/flags.js';
+import { createOutput, outputError } from '../../lib/output.js';
+import { createProvider } from '../../lib/providers/registry.js';
+export default class ProvidersVerify extends Command {
+    static args = {
+        provider: Args.string({ description: 'Provider id, for example spaceship.', required: true }),
+    };
+    static description = 'Verify saved DNS provider credentials.';
+    static flags = {
+        json: jsonFlag,
+    };
+    async run() {
+        const { args, flags } = await this.parse(ProvidersVerify);
+        const out = createOutput({ json: flags.json });
+        try {
+            const provider = await createProvider(args.provider);
+            const health = await provider.verifyCredentials();
+            out.result({ health, provider: provider.id });
+            out.success(`${provider.name} credentials verified.`);
+        }
+        catch (error) {
+            outputError(out.json, error, 'PROVIDER_AUTH_FAILED');
+            this.exit(1);
+        }
+    }
+}

package/dist/commands/schema.d.ts

@@ -0,0 +1,11 @@
+import { Command } from '@oclif/core';
+export default class Schema extends Command {
+    static args: {
+        command: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/schema.js

@@ -0,0 +1,29 @@
+import { Args, Command } from '@oclif/core';
+import { getCommandSchema } from '../lib/command-schema.js';
+import { jsonFlag } from '../lib/flags.js';
+import { createOutput, outputError } from '../lib/output.js';
+export default class Schema extends Command {
+    static args = {
+        command: Args.string({ description: 'Command name to inspect, for example link.', required: false }),
+    };
+    static description = 'Print machine-readable command schemas for agents.';
+    static flags = {
+        json: jsonFlag,
+    };
+    async run() {
+        const { args, flags } = await this.parse(Schema);
+        const out = createOutput({ json: flags.json });
+        try {
+            const schema = getCommandSchema(args.command);
+            if (!schema)
+                throw new Error(`Unknown command schema: ${args.command}`);
+            if (!out.json)
+                out.info(JSON.stringify(schema, null, 2));
+            out.result(schema);
+        }
+        catch (error) {
+            outputError(out.json, error, 'INVALID_INPUT');
+            this.exit(1);
+        }
+    }
+}

package/dist/commands/verify.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/core';
+export default class Verify extends Command {
+    static description: string;
+    static flags: {
+        apex: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        domain: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        subdomain: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/verify.js

@@ -0,0 +1,36 @@
+import { Command } from '@oclif/core';
+import { apexFlag, domainFlag, jsonFlag, projectFlag, subdomainFlag } from '../lib/flags.js';
+import { detectLocalVercelProject } from '../lib/local-vercel.js';
+import { createOutput, outputError } from '../lib/output.js';
+import { resolveDomainTarget } from '../lib/validate.js';
+import { createVercelClient, resolveVercelConfig } from '../lib/vercel.js';
+export default class Verify extends Command {
+    static description = 'Ask Vercel to verify a project domain.';
+    static flags = {
+        apex: apexFlag,
+        domain: domainFlag,
+        json: jsonFlag,
+        project: projectFlag,
+        subdomain: subdomainFlag,
+    };
+    async run() {
+        const { flags } = await this.parse(Verify);
+        const out = createOutput({ json: flags.json });
+        try {
+            if (!flags.domain)
+                throw new Error('Missing --domain.');
+            const target = resolveDomainTarget({ domain: flags.domain, subdomain: flags.subdomain, apex: flags.apex });
+            const project = flags.project ?? detectLocalVercelProject()?.projectId;
+            if (!project)
+                throw new Error('Missing --project and no local .vercel/project.json was found.');
+            const vercel = createVercelClient(await resolveVercelConfig());
+            const result = await vercel.verifyProjectDomain(project, target.fullDomain);
+            out.result({ project, domain: target.fullDomain, vercel: result });
+            out.success(`Verification requested for ${target.fullDomain}.`);
+        }
+        catch (error) {
+            outputError(out.json, error, 'DOMAIN_VERIFY_FAILED');
+            this.exit(1);
+        }
+    }
+}

package/dist/commands/wizard.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class Wizard extends Command {
+    static description: string;
+    static hidden: boolean;
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}