doomain 0.1.16 → 0.1.18

package/README.md

@@ -337,6 +337,7 @@ Useful agent-safe commands:
 doomain link app.example.com --project my-app --json
 doomain providers list --json
 doomain providers status --no-verify --json
+doomain domains find hacktheandes.com --json
 doomain domains list --provider cloudflare --domain example.com --json
 doomain projects list --search my-app --json
 doomain clerk domains add example.com --app app_123 --json
@@ -351,6 +352,19 @@ doomain schema --json
 doomain schema "providers connect" --json
 ```
 
+## Programmatic API
+
+Use `findDomainProvider` to perform the same discovery from TypeScript or JavaScript:
+
+```ts
+import {findDomainProvider} from 'doomain'
+
+const match = await findDomainProvider({domain: 'api.hacktheandes.com'})
+console.log(match.provider, match.account, match.zoneDomain)
+```
+
+The API checks configured provider accounts, tolerates failures from individual providers, and returns the longest matching DNS zone. Pass `provider` or `account` to constrain the search. When a provider cannot be checked, `complete` is `false` and `warnings` identifies the affected provider account.
+
 ## Command Reference
 
 Run `doomain help <command>` for oclif-generated help.
@@ -497,6 +511,18 @@ doomain providers logout namecheap --json
 
 Environment variables for that provider still override local config after disconnect.
 
+### `doomain domains find [domain]`
+
+Finds the configured DNS provider account with the longest matching zone. It checks all configured accounts and continues when an individual provider fails, so one expired credential does not hide a match from another provider.
+
+```bash
+doomain domains find hacktheandes.com --json
+doomain domains find api.example.com --json
+doomain domains find --domain example.com --provider spaceship --account personal --json
+```
+
+Successful JSON includes the provider, account, matching zone, and relative DNS record name. Check `complete` and `warnings` before treating the result as exhaustive; for example, an expired token may prevent one provider from participating in discovery.
+
 ### `doomain domains list`
 
 Lists DNS zones and records.

package/bin/dev.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env -S node --loader ts-node/esm --disable-warning=ExperimentalWarning
 
-import {execute} from '@oclif/core'
+import { execute } from '@oclif/core'
 
-await execute({development: true, dir: import.meta.url})
+await execute({ development: true, dir: import.meta.url })

package/bin/run.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
-import {execute} from '@oclif/core'
+import { execute } from '@oclif/core'
 
 const args = process.argv.slice(2)
 const routedArgs = args.length === 0 || (args.length === 1 && args[0] === '--json') ? ['wizard', ...args] : args
 
-await execute({args: routedArgs, dir: import.meta.url})
+await execute({ args: routedArgs, dir: import.meta.url })

package/dist/commands/domains/find.d.ts

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

package/dist/commands/domains/find.js

@@ -0,0 +1,43 @@
+import { Args, Command } from '@oclif/core';
+import { findDomainProvider } from '../../lib/domain-provider.js';
+import { DoomainError } from '../../lib/errors.js';
+import { accountFlag, domainFlag, jsonFlag, providerFlag } from '../../lib/flags.js';
+import { createOutput, outputError } from '../../lib/output.js';
+export default class DomainsFind extends Command {
+    static args = {
+        domain: Args.string({ description: 'Domain whose DNS provider should be found.', required: false }),
+    };
+    static description = 'Find the configured DNS provider and account for a domain.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> example.com --json',
+        '<%= config.bin %> <%= command.id %> api.example.com --json',
+        '<%= config.bin %> <%= command.id %> --domain example.com --provider spaceship --json',
+    ];
+    static flags = {
+        account: accountFlag,
+        domain: domainFlag,
+        json: jsonFlag,
+        provider: providerFlag,
+    };
+    async run() {
+        const { args, flags } = await this.parse(DomainsFind);
+        const out = createOutput({ json: flags.json });
+        try {
+            const domain = flags.domain ?? args.domain;
+            if (!domain)
+                throw new DoomainError('MISSING_ARGUMENT', 'Domain is required. Pass it as an argument or use --domain.');
+            const result = await findDomainProvider({ account: flags.account, domain, provider: flags.provider });
+            const account = result.isDefaultAccount ? result.provider : `${result.provider}/${result.account}`;
+            out.info(`${result.domain} is managed by ${account} in DNS zone ${result.zoneDomain}.`);
+            for (const warning of result.warnings) {
+                const warningAccount = warning.isDefaultAccount ? warning.provider : `${warning.provider}/${warning.account}`;
+                out.warn(`${warningAccount} could not be checked: ${warning.error.message}`);
+            }
+            out.result(result);
+        }
+        catch (error) {
+            outputError(out.json, error, 'DOMAIN_PROVIDER_DISCOVERY_FAILED');
+            this.exit(1);
+        }
+    }
+}

package/dist/index.d.ts

@@ -1 +1,2 @@
 export { run } from '@oclif/core';
+export { findDomainProvider, type DomainProviderResult, type FindDomainProviderInput, type ProviderSearchWarning, } from './lib/domain-provider.js';

package/dist/index.js

@@ -1 +1,2 @@
 export { run } from '@oclif/core';
+export { findDomainProvider, } from './lib/domain-provider.js';

package/dist/lib/clerk-domain.js

@@ -1,6 +1,7 @@
 import { createClerkPlatformClient, resolveClerkPlatformConfig } from './clerk.js';
+import { resolveProviderTarget } from './domain-provider.js';
 import { DoomainError } from './errors.js';
-import { resolveProviderTarget, withProviderRecordOptions } from './link-domain.js';
+import { withProviderRecordOptions } from './link-domain.js';
 import { createProvider } from './providers/registry.js';
 import { normalizeDomain } from './validate.js';
 function relativeRecordName(host, zoneDomain) {

package/dist/lib/command-schema.js

@@ -195,6 +195,23 @@ export const commandSchemas = [
             { name: 'json', type: 'boolean', description: 'Output a single JSON object and never prompt.' },
         ],
     },
+    {
+        name: 'domains find',
+        description: 'Find the configured DNS provider and account for a domain.',
+        examples: [
+            'doomain domains find hacktheandes.com --json',
+            'doomain domains find api.example.com --json',
+            'doomain domains find --domain example.com --provider spaceship --account work --json',
+        ],
+        agentHint: 'Use this command when you need to identify who manages DNS for a domain. It checks all configured provider accounts, tolerates individual provider failures, and selects the longest matching DNS zone. Inspect complete and warnings before treating the result as exhaustive.',
+        safeForAgents: true,
+        flags: [
+            { name: 'json', type: 'boolean', description: 'Output a single JSON object and never prompt.' },
+            { name: 'domain', type: 'string', description: 'Domain to find. May also be passed as the positional argument.' },
+            { name: 'provider', type: 'string', description: 'Limit discovery to one DNS provider id.' },
+            { name: 'account', type: 'string', description: 'Limit discovery to one DNS provider profile/account alias.' },
+        ],
+    },
     {
         name: 'domains list',
         description: 'List DNS zones and records for a provider.',

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

@@ -0,0 +1,53 @@
+import { type DoomainErrorCode } from './errors.js';
+export interface FindDomainProviderInput {
+    account?: string;
+    domain: string;
+    provider?: string;
+}
+export interface ProviderSearchWarning {
+    account: string;
+    error: {
+        code?: DoomainErrorCode;
+        message: string;
+    };
+    isDefaultAccount: boolean;
+    provider: string;
+    providerName: string;
+}
+export interface DomainProviderResult {
+    account: string;
+    accountInferred: boolean;
+    complete: boolean;
+    domain: string;
+    isApex: boolean;
+    isDefaultAccount: boolean;
+    provider: string;
+    providerInferred: boolean;
+    recordName: string;
+    warnings: ProviderSearchWarning[];
+    zoneDomain: string;
+}
+export interface ResolveProviderTargetInput extends FindDomainProviderInput {
+    apex?: boolean;
+    subdomain?: string;
+}
+export interface ResolveProviderTargetOptions {
+    tolerateProviderAccountErrors?: boolean;
+}
+export interface ResolvedDnsTarget {
+    account: string;
+    accountInferred: boolean;
+    isDefaultAccount: boolean;
+    provider: string;
+    providerInferred: boolean;
+    target: {
+        fullDomain: string;
+        isApex: boolean;
+        recordName: string;
+        zoneDomain: string;
+    };
+    warnings: ProviderSearchWarning[];
+}
+export declare function resolveProviderTarget(input: ResolveProviderTargetInput, options?: ResolveProviderTargetOptions): Promise<ResolvedDnsTarget>;
+/** Find the configured DNS provider account with the longest zone match for a domain. */
+export declare function findDomainProvider(input: FindDomainProviderInput): Promise<DomainProviderResult>;

package/dist/lib/domain-provider.js

@@ -0,0 +1,230 @@
+import { loadConfig } from './config.js';
+import { DoomainError } from './errors.js';
+import { DEFAULT_PROVIDER_ACCOUNT, isDefaultProviderAccount, listConfiguredProviderAccounts, normalizeProviderAccount, } from './providers/core/config.js';
+import { createProvider, getProviderDefinition, listProviderDefinitions } from './providers/registry.js';
+import { listProviderStatuses } from './providers/status.js';
+import { normalizeDomain, normalizeSubdomain } from './validate.js';
+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) => ({
+        account: candidate.account,
+        isDefaultAccount: candidate.isDefaultAccount,
+        provider: candidate.provider,
+        providerName: candidate.providerName,
+        zoneDomain: candidate.zone.name,
+    }));
+}
+function defaultAccountRef(providerId) {
+    return { account: DEFAULT_PROVIDER_ACCOUNT, isDefaultAccount: true, providerId };
+}
+function explicitAccountRef(providerId, account) {
+    const normalized = normalizeProviderAccount(account);
+    return { account: normalized, isDefaultAccount: isDefaultProviderAccount(normalized), providerId };
+}
+function searchError(error) {
+    return {
+        ...(error instanceof DoomainError ? { code: error.code } : {}),
+        message: error instanceof Error ? error.message : String(error),
+    };
+}
+async function loadProviderZones(definition, account) {
+    const provider = await createProvider(definition.id, { account: account.account });
+    const zones = await provider.listZones();
+    return {
+        candidates: zones.map((zone) => ({
+            account: account.account,
+            isDefaultAccount: account.isDefaultAccount,
+            provider: definition.id,
+            providerName: definition.displayName,
+            zone,
+        })),
+        search: {
+            account: account.account,
+            displayName: definition.displayName,
+            id: definition.id,
+            isDefaultAccount: account.isDefaultAccount,
+            zones: zones.map((zone) => zone.name),
+        },
+    };
+}
+async function loadProviderZonesSafely(definition, account) {
+    try {
+        return await loadProviderZones(definition, account);
+    }
+    catch (error) {
+        return {
+            candidates: [],
+            search: {
+                account: account.account,
+                displayName: definition.displayName,
+                error: searchError(error),
+                id: definition.id,
+                isDefaultAccount: account.isDefaultAccount,
+                zones: [],
+            },
+        };
+    }
+}
+async function providerConnectionDetails() {
+    return (await listProviderStatuses({ verify: false })).map((provider) => ({
+        configured: provider.configured,
+        account: provider.account,
+        default: provider.default,
+        displayName: provider.displayName,
+        docsUrl: provider.docsUrl,
+        id: provider.id,
+        isDefaultAccount: provider.isDefaultAccount,
+    }));
+}
+function searchWarnings(searches) {
+    return searches.flatMap((search) => search.error
+        ? [
+            {
+                account: search.account,
+                error: search.error,
+                isDefaultAccount: search.isDefaultAccount,
+                provider: search.id,
+                providerName: search.displayName,
+            },
+        ]
+        : []);
+}
+async function loadConfiguredProviderZones(providerId, accountInput, tolerateProviderAccountErrors = false) {
+    const config = await loadConfig();
+    const account = accountInput ? normalizeProviderAccount(accountInput) : undefined;
+    if (providerId) {
+        const definition = getProviderDefinition(providerId);
+        const accounts = account ? [explicitAccountRef(definition.id, account)] : listConfiguredProviderAccounts(config, definition);
+        const selectedAccounts = accounts.length > 0 ? accounts : [defaultAccountRef(definition.id)];
+        const tolerateAccountErrors = tolerateProviderAccountErrors && !account && selectedAccounts.length > 1;
+        const results = await Promise.all(selectedAccounts.map((ref) => tolerateAccountErrors ? loadProviderZonesSafely(definition, ref) : loadProviderZones(definition, ref)));
+        return {
+            accountInferred: account === undefined,
+            candidates: results.flatMap((result) => result.candidates),
+            providerInferred: false,
+            searched: results.map((result) => result.search),
+        };
+    }
+    const providerAccounts = listProviderDefinitions().flatMap((definition) => listConfiguredProviderAccounts(config, definition)
+        .filter((ref) => !account || ref.account === account)
+        .map((ref) => ({ definition, ref })));
+    if (providerAccounts.length === 0) {
+        const message = account
+            ? `No DNS provider account named ${account} is configured. Run \`doomain providers connect <provider> --account ${account}\` first.`
+            : 'No DNS provider is configured. Run `doomain providers connect` first.';
+        throw new DoomainError('CONFIG_NOT_FOUND', message, {
+            account,
+            configuredProviders: await providerConnectionDetails(),
+            recovery: 'Connect the DNS provider that owns this domain, then retry `doomain link <domain> --json`.',
+            suggestedCommands: account
+                ? [`doomain providers connect <provider> --account ${account}`, 'doomain link <domain> --json']
+                : ['doomain providers connect', 'doomain link <domain> --json'],
+        });
+    }
+    const results = await Promise.all(providerAccounts.map(({ definition, ref }) => loadProviderZonesSafely(definition, ref)));
+    return {
+        accountInferred: account === undefined,
+        candidates: results.flatMap((result) => result.candidates),
+        providerInferred: true,
+        searched: results.map((result) => result.search),
+    };
+}
+export async function resolveProviderTarget(input, options = {}) {
+    const requested = resolveRequestedDomain(input);
+    const zones = await loadConfiguredProviderZones(input.provider, input.account, options.tolerateProviderAccountErrors);
+    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 account = input.account ? normalizeProviderAccount(input.account) : undefined;
+        const providerMessage = input.provider
+            ? `${getProviderDefinition(input.provider).displayName}${account ? ` account ${account}` : ''} 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, {
+            account,
+            configuredProviders: await providerConnectionDetails(),
+            domain: requested.fullDomain,
+            recovery: 'Retry with --provider <id> --account <alias> only if another configured provider account owns this zone. Otherwise connect the DNS provider account that owns this domain.',
+            searchedZones: zones.searched,
+            suggestedCommands: [`doomain link ${requested.fullDomain} --provider <id> --account <alias> --json`, 'doomain providers connect'],
+        });
+    }
+    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.account === candidate.account && item.zone.name === candidate.zone.name) === index);
+    if (uniqueBestMatches.length > 1) {
+        throw new DoomainError('PROVIDER_ZONE_AMBIGUOUS', `Multiple DNS provider accounts have a matching DNS zone for ${requested.fullDomain}. Pass --provider and --account to choose one.`, { candidates: candidateDetails(uniqueBestMatches), domain: requested.fullDomain });
+    }
+    const selected = uniqueBestMatches[0];
+    return {
+        account: selected.account,
+        accountInferred: zones.accountInferred,
+        isDefaultAccount: selected.isDefaultAccount,
+        provider: selected.provider,
+        providerInferred: zones.providerInferred,
+        target: targetFromZone(requested.fullDomain, selected.zone.name),
+        warnings: searchWarnings(zones.searched),
+    };
+}
+function discoveryError(error, domain) {
+    if (error.code !== 'CONFIG_NOT_FOUND' && error.code !== 'PROVIDER_ZONE_NOT_FOUND')
+        return error;
+    const details = error.details && typeof error.details === 'object' ? error.details : {};
+    return new DoomainError(error.code, error.message, {
+        ...details,
+        recovery: `Connect or repair the DNS provider account that owns this domain, then retry \`doomain domains find ${domain} --json\`.`,
+        suggestedCommands: ['doomain providers connect', `doomain domains find ${domain} --json`],
+    });
+}
+/** Find the configured DNS provider account with the longest zone match for a domain. */
+export async function findDomainProvider(input) {
+    try {
+        const resolved = await resolveProviderTarget(input, { tolerateProviderAccountErrors: true });
+        return {
+            account: resolved.account,
+            accountInferred: resolved.accountInferred,
+            complete: resolved.warnings.length === 0,
+            domain: resolved.target.fullDomain,
+            isApex: resolved.target.isApex,
+            isDefaultAccount: resolved.isDefaultAccount,
+            provider: resolved.provider,
+            providerInferred: resolved.providerInferred,
+            recordName: resolved.target.recordName,
+            warnings: resolved.warnings,
+            zoneDomain: resolved.target.zoneDomain,
+        };
+    }
+    catch (error) {
+        if (error instanceof DoomainError)
+            throw discoveryError(error, input.domain);
+        throw error;
+    }
+}

package/dist/lib/errors.d.ts

@@ -1,4 +1,4 @@
-export type DoomainErrorCode = 'CONFIG_NOT_FOUND' | 'CLERK_AUTH_FAILED' | 'CLERK_PRODUCTION_EXISTS' | 'DNS_TARGET_CONFLICT' | 'DOMAIN_LINK_FAILED' | 'DOMAIN_ALREADY_ASSIGNED' | '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_AUTH_FAILED' | 'VERCEL_PROJECT_NOT_LINKED';
+export type DoomainErrorCode = 'CONFIG_NOT_FOUND' | 'CLERK_AUTH_FAILED' | 'CLERK_PRODUCTION_EXISTS' | 'DNS_TARGET_CONFLICT' | 'DOMAIN_LINK_FAILED' | 'DOMAIN_PROVIDER_DISCOVERY_FAILED' | 'DOMAIN_ALREADY_ASSIGNED' | '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_AUTH_FAILED' | 'VERCEL_PROJECT_NOT_LINKED';
 export declare class DoomainError extends Error {
     readonly code: DoomainErrorCode;
     readonly details?: unknown;

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

@@ -59,20 +59,6 @@ export interface LinkDomainResult extends LinkDomainPlan {
         verified: boolean;
     };
 }
-export interface ResolvedDnsTarget {
-    provider: string;
-    providerInferred: boolean;
-    account: string;
-    accountInferred: boolean;
-    isDefaultAccount: boolean;
-    target: {
-        fullDomain: string;
-        isApex: boolean;
-        recordName: string;
-        zoneDomain: string;
-    };
-}
-export declare function resolveProviderTarget(input: Pick<LinkDomainInput, 'account' | 'apex' | 'domain' | 'provider' | 'subdomain'>): Promise<ResolvedDnsTarget>;
 export declare function withProviderRecordOptions(provider: string, record: DnsRecordInput): DnsRecordInput;
 export declare function verificationRecords(raw: unknown, zoneDomain: string): DnsRecordInput[];
 export declare function createLinkPlan(input: LinkDomainInput): Promise<LinkDomainPlan>;

package/dist/lib/link-domain.js

@@ -2,12 +2,10 @@ import { resolve4, resolveCname, resolveTxt } from 'node:dns/promises';
 import { existsSync, readFileSync } from 'node:fs';
 import { dirname, join, parse } from 'node:path';
 import { loadConfig } from './config.js';
+import { resolveProviderTarget } from './domain-provider.js';
 import { DoomainError } from './errors.js';
 import { detectLocalVercelProject } from './local-vercel.js';
-import { DEFAULT_PROVIDER_ACCOUNT, isDefaultProviderAccount, listConfiguredProviderAccounts, normalizeProviderAccount, } from './providers/core/config.js';
-import { createProvider, getProviderDefinition, listProviderDefinitions } from './providers/registry.js';
-import { listProviderStatuses } from './providers/status.js';
-import { normalizeDomain, normalizeSubdomain } from './validate.js';
+import { createProvider } from './providers/registry.js';
 import { createVercelClient, resolveVercelConfig, VERCEL_APEX_A_RECORD, VERCEL_CNAME_RECORD } from './vercel.js';
 function cleanDnsValue(value) {
     return value.toLowerCase().replace(/\.$/, '');
@@ -116,178 +114,6 @@ async function resolveZone(provider, zoneDomain) {
     }
     return zone;
 }
-async function providerConnectionDetails() {
-    return (await listProviderStatuses({ verify: false })).map((provider) => ({
-        configured: provider.configured,
-        account: provider.account,
-        default: provider.default,
-        displayName: provider.displayName,
-        docsUrl: provider.docsUrl,
-        id: provider.id,
-        isDefaultAccount: provider.isDefaultAccount,
-    }));
-}
-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) => ({
-        account: candidate.account,
-        isDefaultAccount: candidate.isDefaultAccount,
-        provider: candidate.provider,
-        providerName: candidate.providerName,
-        zoneDomain: candidate.zone.name,
-    }));
-}
-function defaultAccountRef(providerId) {
-    return { account: DEFAULT_PROVIDER_ACCOUNT, isDefaultAccount: true, providerId };
-}
-function explicitAccountRef(providerId, account) {
-    const normalized = normalizeProviderAccount(account);
-    return { account: normalized, isDefaultAccount: isDefaultProviderAccount(normalized), providerId };
-}
-async function loadProviderZones(definition, account) {
-    const provider = await createProvider(definition.id, { account: account.account });
-    const zones = await provider.listZones();
-    return {
-        candidates: zones.map((zone) => ({
-            account: account.account,
-            isDefaultAccount: account.isDefaultAccount,
-            provider: definition.id,
-            providerName: definition.displayName,
-            zone,
-        })),
-        search: {
-            account: account.account,
-            displayName: definition.displayName,
-            id: definition.id,
-            isDefaultAccount: account.isDefaultAccount,
-            zones: zones.map((zone) => zone.name),
-        },
-    };
-}
-async function loadConfiguredProviderZones(providerId, accountInput) {
-    const config = await loadConfig();
-    const account = accountInput ? normalizeProviderAccount(accountInput) : undefined;
-    if (providerId) {
-        const definition = getProviderDefinition(providerId);
-        const accounts = account ? [explicitAccountRef(definition.id, account)] : listConfiguredProviderAccounts(config, definition);
-        const selectedAccounts = accounts.length > 0 ? accounts : [defaultAccountRef(definition.id)];
-        const results = await Promise.all(selectedAccounts.map((ref) => loadProviderZones(definition, ref)));
-        return {
-            accountInferred: account === undefined,
-            candidates: results.flatMap((result) => result.candidates),
-            providerInferred: false,
-            searched: results.map((result) => result.search),
-        };
-    }
-    const providerAccounts = listProviderDefinitions().flatMap((definition) => listConfiguredProviderAccounts(config, definition)
-        .filter((ref) => !account || ref.account === account)
-        .map((ref) => ({ definition, ref })));
-    if (providerAccounts.length === 0) {
-        const message = account
-            ? `No DNS provider account named ${account} is configured. Run \`doomain providers connect <provider> --account ${account}\` first.`
-            : 'No DNS provider is configured. Run `doomain providers connect` first.';
-        throw new DoomainError('CONFIG_NOT_FOUND', message, {
-            account,
-            configuredProviders: await providerConnectionDetails(),
-            recovery: 'Connect the DNS provider that owns this domain, then retry `doomain link <domain> --json`.',
-            suggestedCommands: account
-                ? [`doomain providers connect <provider> --account ${account}`, 'doomain link <domain> --json']
-                : ['doomain providers connect', 'doomain link <domain> --json'],
-        });
-    }
-    const results = await Promise.all(providerAccounts.map(async ({ definition, ref }) => {
-        try {
-            return await loadProviderZones(definition, ref);
-        }
-        catch (error) {
-            return {
-                candidates: [],
-                search: {
-                    account: ref.account,
-                    displayName: definition.displayName,
-                    error: error instanceof Error ? error.message : String(error),
-                    id: definition.id,
-                    isDefaultAccount: ref.isDefaultAccount,
-                    zones: [],
-                },
-            };
-        }
-    }));
-    return {
-        accountInferred: account === undefined,
-        candidates: results.flatMap((result) => result.candidates),
-        providerInferred: true,
-        searched: results.map((result) => result.search),
-    };
-}
-export async function resolveProviderTarget(input) {
-    const requested = resolveRequestedDomain({
-        apex: input.apex,
-        domain: await resolveConfiguredDomain(input.domain),
-        subdomain: input.subdomain,
-    });
-    const zones = await loadConfiguredProviderZones(input.provider, input.account);
-    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 account = input.account ? normalizeProviderAccount(input.account) : undefined;
-        const providerMessage = input.provider
-            ? `${getProviderDefinition(input.provider).displayName}${account ? ` account ${account}` : ''} 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, {
-            account,
-            configuredProviders: await providerConnectionDetails(),
-            domain: requested.fullDomain,
-            recovery: 'Retry with --provider <id> --account <alias> only if another configured provider account owns this zone. Otherwise connect the DNS provider account that owns this domain.',
-            searchedZones: zones.searched,
-            suggestedCommands: [`doomain link ${requested.fullDomain} --provider <id> --account <alias> --json`, 'doomain providers connect'],
-        });
-    }
-    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.account === candidate.account && item.zone.name === candidate.zone.name) === index);
-    if (uniqueBestMatches.length > 1) {
-        throw new DoomainError('PROVIDER_ZONE_AMBIGUOUS', `Multiple DNS provider accounts have a matching DNS zone for ${requested.fullDomain}. Pass --provider and --account to choose one.`, { candidates: candidateDetails(uniqueBestMatches), domain: requested.fullDomain });
-    }
-    const selected = uniqueBestMatches[0];
-    return {
-        account: selected.account,
-        accountInferred: zones.accountInferred,
-        isDefaultAccount: selected.isDefaultAccount,
-        provider: selected.provider,
-        providerInferred: zones.providerInferred,
-        target: targetFromZone(requested.fullDomain, selected.zone.name),
-    };
-}
 export function withProviderRecordOptions(provider, record) {
     if (provider !== 'cloudflare' || !['A', 'AAAA', 'CNAME'].includes(record.type))
         return record;

package/oclif.manifest.json

@@ -312,6 +312,66 @@
         "vercel.js"
       ]
     },
+    "domains:find": {
+      "aliases": [],
+      "args": {
+        "domain": {
+          "description": "Domain whose DNS provider should be found.",
+          "name": "domain",
+          "required": false
+        }
+      },
+      "description": "Find the configured DNS provider and account for a domain.",
+      "examples": [
+        "<%= config.bin %> <%= command.id %> example.com --json",
+        "<%= config.bin %> <%= command.id %> api.example.com --json",
+        "<%= config.bin %> <%= command.id %> --domain example.com --provider spaceship --json"
+      ],
+      "flags": {
+        "account": {
+          "description": "DNS provider profile/account alias. Defaults to the provider default account.",
+          "name": "account",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "domain": {
+          "description": "Target domain or base zone, for example app.example.com or example.com.",
+          "name": "domain",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "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"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "domains:find",
+      "pluginAlias": "doomain",
+      "pluginName": "doomain",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "domains",
+        "find.js"
+      ]
+    },
     "domains:list": {
       "aliases": [],
       "args": {},
@@ -834,5 +894,5 @@
       ]
     }
   },
-  "version": "0.1.16"
+  "version": "0.1.18"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "doomain",
   "description": "Configure Vercel and Clerk production domains in seconds",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "author": "Crafter Station",
   "packageManager": "bun@1.3.13",
   "bin": {
@@ -21,6 +21,7 @@
     "@types/mocha": "^10",
     "@types/node": "^18",
     "chai": "^4",
+    "husky": "^9.1.7",
     "mocha": "^11",
     "oclif": "^4",
     "shx": "^0.3.3",
@@ -82,6 +83,7 @@
     "lint": "biome lint .",
     "postpack": "shx rm -f oclif.manifest.json",
     "posttest": "bun run lint",
+    "prepare": "husky",
     "prepack": "oclif manifest && oclif readme",
     "test": "mocha --forbid-only \"test/**/*.test.ts\"",
     "version": "oclif readme && git add README.md"