doomain 0.1.9 → 0.1.11

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

@@ -2,6 +2,7 @@ import { Command } from '@oclif/core';
 export default class DomainsList extends Command {
     static description: 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>;

package/dist/commands/domains/list.js

@@ -1,8 +1,9 @@
 import { Command } from '@oclif/core';
 import { loadConfig } from '../../lib/config.js';
-import { domainFlag, jsonFlag, providerFlag } from '../../lib/flags.js';
+import { accountFlag, domainFlag, jsonFlag, providerFlag } from '../../lib/flags.js';
 import { createOutput, outputError } from '../../lib/output.js';
-import { createProvider } from '../../lib/providers/registry.js';
+import { DEFAULT_PROVIDER_ACCOUNT, isDefaultProviderAccount, listConfiguredProviderAccounts, normalizeProviderAccount, } from '../../lib/providers/core/config.js';
+import { createProvider, getProviderDefinition } from '../../lib/providers/registry.js';
 import { normalizeDomain } from '../../lib/validate.js';
 async function resolveZones(provider, domain) {
     if (!domain)
@@ -16,6 +17,7 @@ async function resolveZones(provider, domain) {
 export default class DomainsList extends Command {
     static description = 'List DNS zones and records for a provider.';
     static flags = {
+        account: accountFlag,
         domain: domainFlag,
         json: jsonFlag,
         provider: providerFlag,
@@ -25,17 +27,37 @@ export default class DomainsList extends Command {
         const out = createOutput({ json: flags.json });
         try {
             const config = await loadConfig();
-            const provider = await createProvider(flags.provider ?? process.env.DOOMAIN_PROVIDER ?? config.defaults?.provider ?? 'spaceship');
-            const zones = await resolveZones(provider, flags.domain);
+            const providerId = flags.provider ?? process.env.DOOMAIN_PROVIDER ?? config.defaults?.provider ?? 'spaceship';
+            const definition = getProviderDefinition(providerId);
+            const account = flags.account ? normalizeProviderAccount(flags.account) : undefined;
+            const accounts = account
+                ? [{ account, isDefaultAccount: isDefaultProviderAccount(account), providerId: definition.id }]
+                : listConfiguredProviderAccounts(config, definition);
+            const selectedAccounts = accounts.length > 0 ? accounts : [{ account: DEFAULT_PROVIDER_ACCOUNT, isDefaultAccount: true, providerId: definition.id }];
             const results = [];
-            for (const zone of zones) {
-                const records = await provider.listRecords(zone);
-                results.push({ zone, records });
-                out.info(`${zone.name} (${records.length} records)`);
-                for (const record of records)
-                    out.info(`  ${record.type} ${record.name} -> ${record.value}`);
+            for (const selectedAccount of selectedAccounts) {
+                const provider = await createProvider(definition.id, { account: selectedAccount.account });
+                const zones = await resolveZones(provider, flags.domain);
+                for (const zone of zones) {
+                    const records = await provider.listRecords(zone);
+                    results.push({
+                        account: selectedAccount.account,
+                        isDefaultAccount: selectedAccount.isDefaultAccount,
+                        provider: provider.id,
+                        records,
+                        zone,
+                    });
+                    const accountLabel = selectedAccount.isDefaultAccount ? provider.id : `${provider.id}/${selectedAccount.account}`;
+                    out.info(`${zone.name} (${records.length} records) via ${accountLabel}`);
+                    for (const record of records)
+                        out.info(`  ${record.type} ${record.name} -> ${record.value}`);
+                }
             }
-            out.result({ provider: provider.id, zones: results });
+            out.result({
+                ...(selectedAccounts.length === 1 ? { account: selectedAccounts[0].account, isDefaultAccount: selectedAccounts[0].isDefaultAccount } : {}),
+                provider: definition.id,
+                zones: results,
+            });
         }
         catch (error) {
             outputError(out.json, error, 'DOMAIN_LINK_FAILED');

package/dist/commands/link.d.ts

@@ -6,6 +6,7 @@ export default class Link extends Command {
         domain: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     static flags: {
+        account: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         apex: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         domain: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;

package/dist/commands/link.js

@@ -1,6 +1,6 @@
 import { Args, Command, Flags } from '@oclif/core';
 import { DoomainError } from '../lib/errors.js';
-import { apexFlag, domainFlag, jsonFlag, projectFlag, providerFlag, subdomainFlag } from '../lib/flags.js';
+import { accountFlag, apexFlag, domainFlag, jsonFlag, projectFlag, providerFlag, subdomainFlag } from '../lib/flags.js';
 import { linkDomain } from '../lib/link-domain.js';
 import { createOutput, outputError } from '../lib/output.js';
 export default class Link extends Command {
@@ -11,11 +11,13 @@ export default class Link extends Command {
         '<%= config.bin %> <%= command.id %> --domain app.example.com --project my-app --json',
         '<%= config.bin %> <%= command.id %> --domain example.com --subdomain app --project my-app',
         '<%= config.bin %> <%= command.id %> --provider spaceship --domain example.com --apex --project my-app --json',
+        '<%= config.bin %> <%= command.id %> app.example.com --provider spaceship --account work --project my-app --json',
     ];
     static args = {
         domain: Args.string({ description: 'Target domain to link, for example app.example.com.', required: false }),
     };
     static flags = {
+        account: accountFlag,
         apex: apexFlag,
         domain: domainFlag,
         'dry-run': Flags.boolean({ description: 'Preview changes without writing to Vercel or DNS.' }),

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

@@ -5,6 +5,7 @@ export default class ProvidersConnect extends Command {
     };
     static description: string;
     static flags: {
+        account: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'api-key': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'api-secret': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         credential: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;

package/dist/commands/providers/connect.js

@@ -1,10 +1,10 @@
 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 { accountFlag, jsonFlag } from '../../lib/flags.js';
 import { createOutput, outputError } from '../../lib/output.js';
+import { isDefaultProviderAccount, listConfiguredProviderAccounts, normalizeProviderAccount } from '../../lib/providers/core/config.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();
@@ -63,7 +63,7 @@ async function promptProvider() {
     const selected = await p.select({
         message: 'Choose DNS provider',
         options: listProviderDefinitions().map((definition) => ({
-            hint: isProviderConfigured(definition, config) ? 'Connected' : 'Not connected',
+            hint: listConfiguredProviderAccounts(config, definition).length > 0 ? 'Connected' : 'Not connected',
             label: definition.displayName,
             value: definition.id,
         })),
@@ -91,6 +91,7 @@ export default class ProvidersConnect extends Command {
     };
     static description = 'Save DNS provider credentials locally.';
     static flags = {
+        account: accountFlag,
         '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 }),
@@ -107,6 +108,8 @@ export default class ProvidersConnect extends Command {
             const definition = args.provider ? getProviderDefinition(args.provider) : await promptProvider();
             if (!definition)
                 return;
+            const account = normalizeProviderAccount(flags.account);
+            const isDefaultAccount = isDefaultProviderAccount(account);
             const passedCredentials = parseCredentialFlags(flags.credential);
             const credentials = {};
             const detectedPublicIp = !out.json && usesClientIp(definition) ? await fetchPublicIp() : undefined;
@@ -162,13 +165,24 @@ export default class ProvidersConnect extends Command {
                 defaults: setDefault ? { ...config.defaults, provider: definition.id } : config.defaults,
                 providers: {
                     ...config.providers,
-                    [definition.id]: { credentials },
+                    [definition.id]: isDefaultAccount
+                        ? { ...config.providers?.[definition.id], credentials }
+                        : {
+                            ...config.providers?.[definition.id],
+                            accounts: {
+                                ...config.providers?.[definition.id]?.accounts,
+                                [account]: { credentials },
+                            },
+                        },
                 },
             }));
             out.result({
+                account,
                 configPath: getConfigPath(),
                 credentials: Object.fromEntries(Object.entries(credentials).map(([key, value]) => [key, maskSecret(value)])),
+                defaultAccount: isDefaultAccount,
                 domainCount,
+                isDefaultAccount,
                 provider: definition.id,
                 verified: !flags['no-verify'],
             });

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

@@ -7,6 +7,7 @@ export default class ProvidersDisconnect extends Command {
     static description: string;
     static examples: string[];
     static flags: {
+        account: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;

package/dist/commands/providers/disconnect.js

@@ -1,7 +1,8 @@
 import { Args, Command } from '@oclif/core';
 import { getConfigPath, updateConfig } from '../../lib/config.js';
-import { jsonFlag } from '../../lib/flags.js';
+import { accountFlag, jsonFlag } from '../../lib/flags.js';
 import { createOutput, outputError } from '../../lib/output.js';
+import { isDefaultProviderAccount, normalizeProviderAccount } from '../../lib/providers/core/config.js';
 import { getProviderDefinition } from '../../lib/providers/registry.js';
 function envOverrides(definition) {
     return definition.credentials.flatMap((credential) => (process.env[credential.env] ? [credential.env] : []));
@@ -17,6 +18,7 @@ export default class ProvidersDisconnect extends Command {
         '<%= config.bin %> <%= command.id %> cloudflare --json',
     ];
     static flags = {
+        account: accountFlag,
         json: jsonFlag,
     };
     async run() {
@@ -24,13 +26,41 @@ export default class ProvidersDisconnect extends Command {
         const out = createOutput({ json: flags.json });
         try {
             const definition = getProviderDefinition(args.provider);
+            const account = flags.account ? normalizeProviderAccount(flags.account) : undefined;
             let removed = false;
             await updateConfig((config) => {
                 const providers = { ...config.providers };
-                removed = providers[definition.id] !== undefined;
-                delete providers[definition.id];
+                const provider = providers[definition.id];
+                if (!account) {
+                    removed = provider !== undefined;
+                    delete providers[definition.id];
+                }
+                else if (provider) {
+                    const nextProvider = { ...provider };
+                    if (isDefaultProviderAccount(account)) {
+                        removed = nextProvider.credentials !== undefined || (definition.id === 'spaceship' && ('apiKey' in nextProvider || 'apiSecret' in nextProvider));
+                        delete nextProvider.credentials;
+                        if (definition.id === 'spaceship') {
+                            delete nextProvider.apiKey;
+                            delete nextProvider.apiSecret;
+                            delete nextProvider.domains;
+                        }
+                    }
+                    else {
+                        const accounts = { ...nextProvider.accounts };
+                        removed = accounts[account] !== undefined;
+                        delete accounts[account];
+                        nextProvider.accounts = Object.keys(accounts).length > 0 ? accounts : undefined;
+                    }
+                    if (nextProvider.credentials || nextProvider.settings || (nextProvider.accounts && Object.keys(nextProvider.accounts).length > 0)) {
+                        providers[definition.id] = nextProvider;
+                    }
+                    else {
+                        delete providers[definition.id];
+                    }
+                }
                 const defaults = { ...config.defaults };
-                if (defaults.provider === definition.id)
+                if (defaults.provider === definition.id && providers[definition.id] === undefined)
                     delete defaults.provider;
                 return {
                     ...config,
@@ -39,7 +69,7 @@ export default class ProvidersDisconnect extends Command {
                 };
             });
             const overrides = envOverrides(definition);
-            out.result({ configPath: getConfigPath(), environmentOverrides: overrides, provider: definition.id, removed });
+            out.result({ account, 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.`);

package/dist/commands/providers/status.js

@@ -24,8 +24,10 @@ export default class ProvidersStatus extends Command {
         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]' : ''}`);
+        for (const provider of providers) {
+            const account = provider.isDefaultAccount ? provider.id : `${provider.id}/${provider.account}`;
+            out.info(`${provider.displayName} (${account}) - ${formatStatus(provider)}${provider.default ? ' [default]' : ''}`);
+        }
         out.result({ providers });
     }
 }

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

@@ -5,6 +5,7 @@ export default class ProvidersVerify extends Command {
     };
     static description: string;
     static flags: {
+        account: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;

package/dist/commands/providers/verify.js

@@ -1,6 +1,7 @@
 import { Args, Command } from '@oclif/core';
-import { jsonFlag } from '../../lib/flags.js';
+import { accountFlag, jsonFlag } from '../../lib/flags.js';
 import { createOutput, outputError } from '../../lib/output.js';
+import { isDefaultProviderAccount, normalizeProviderAccount } from '../../lib/providers/core/config.js';
 import { createProvider } from '../../lib/providers/registry.js';
 export default class ProvidersVerify extends Command {
     static args = {
@@ -8,15 +9,17 @@ export default class ProvidersVerify extends Command {
     };
     static description = 'Verify saved DNS provider credentials.';
     static flags = {
+        account: accountFlag,
         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 account = normalizeProviderAccount(flags.account);
+            const provider = await createProvider(args.provider, { account });
             const health = await provider.verifyCredentials();
-            out.result({ health, provider: provider.id });
+            out.result({ account, health, isDefaultAccount: isDefaultProviderAccount(account), provider: provider.id });
             out.success(`${provider.name} credentials verified.`);
         }
         catch (error) {

package/dist/commands/wizard.js

@@ -6,8 +6,8 @@ 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 { DEFAULT_PROVIDER_ACCOUNT, listConfiguredProviderAccounts } from '../lib/providers/core/config.js';
 import { createProvider, getProviderDefinition, listProviderDefinitions } from '../lib/providers/registry.js';
-import { isProviderConfigured } from '../lib/providers/status.js';
 import { listGlobalVercelTokens } from '../lib/vercel-auth.js';
 import { createVercelClient } from '../lib/vercel.js';
 const PERSONAL_ACCOUNT = '__personal__';
@@ -72,7 +72,7 @@ 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',
+            hint: listConfiguredProviderAccounts(config, definition).length > 0 ? 'Connected' : 'Not connected',
             label: definition.displayName,
             value: definition.id,
         })),
@@ -87,19 +87,24 @@ function showProviderSetup(definition) {
         return;
     p.note(definition.setup.notes.join('\n'), `${definition.displayName} setup`);
 }
-async function listProviderDomainOptions(definition) {
-    const provider = await createProvider(definition.id);
+async function listProviderDomainOptions(definition, account) {
+    const provider = await createProvider(definition.id, { account: account.account });
     const zones = await provider.listZones();
-    return zones.map((zone) => toProviderDomainOption(definition, zone));
+    return zones.map((zone) => toProviderDomainOption(definition, account, zone));
 }
-function toProviderDomainOption(definition, zone) {
+function toProviderDomainOption(definition, account, zone) {
     return {
+        account: account.account,
         domain: zone.name,
-        id: `${definition.id}:${zone.name}`,
+        id: `${definition.id}:${account.account}:${zone.name}`,
+        isDefaultAccount: account.isDefaultAccount,
         providerId: definition.id,
         providerName: definition.displayName,
     };
 }
+function providerAccountLabel(option) {
+    return option.isDefaultAccount ? option.providerName : `${option.providerName}/${option.account}`;
+}
 function projectLabel(project) {
     return project.name ? `${project.name} (${project.id})` : project.id;
 }
@@ -237,10 +242,10 @@ export default class Wizard extends Command {
             const project = resolved;
             const 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 configuredProviderAccounts = providerDefinitions.flatMap((definition) => listConfiguredProviderAccounts(config, definition).map((account) => ({ account, definition })));
             const providerFailures = [];
             const domainOptions = [];
-            if (configuredProviderDefinitions.length === 0) {
+            if (configuredProviderAccounts.length === 0) {
                 p.log.info('No DNS provider is configured yet. Connect one to continue.');
                 const selectedDefinition = await promptProviderDefinition(providerDefinitions, config);
                 if (!selectedDefinition)
@@ -256,7 +261,7 @@ export default class Wizard extends Command {
                 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)));
+                domainOptions.push(...zones.map((zone) => toProviderDomainOption(selectedDefinition, { account: DEFAULT_PROVIDER_ACCOUNT, isDefaultAccount: true, providerId: selectedDefinition.id }, zone)));
                 await updateConfig((current) => ({
                     ...current,
                     defaults: { ...current.defaults, provider: selectedDefinition.id },
@@ -267,13 +272,14 @@ export default class Wizard extends Command {
             else {
                 const domainSpinner = p.spinner();
                 activeSpinner = domainSpinner;
-                domainSpinner.start(`Loading domains from ${configuredProviderDefinitions.length} provider${configuredProviderDefinitions.length === 1 ? '' : 's'}`);
-                for (const definition of configuredProviderDefinitions) {
+                domainSpinner.start(`Loading domains from ${configuredProviderAccounts.length} provider account${configuredProviderAccounts.length === 1 ? '' : 's'}`);
+                for (const { account, definition } of configuredProviderAccounts) {
                     try {
-                        domainOptions.push(...(await listProviderDomainOptions(definition)));
+                        domainOptions.push(...(await listProviderDomainOptions(definition, account)));
                     }
                     catch (error) {
-                        providerFailures.push(`${definition.displayName}: ${error instanceof Error ? error.message : String(error)}`);
+                        const label = account.isDefaultAccount ? definition.displayName : `${definition.displayName}/${account.account}`;
+                        providerFailures.push(`${label}: ${error instanceof Error ? error.message : String(error)}`);
                     }
                 }
                 domainSpinner.stop(`Loaded ${domainOptions.length} domain${domainOptions.length === 1 ? '' : 's'}`);
@@ -299,14 +305,14 @@ export default class Wizard extends Command {
                     placeholder: 'Type to filter domains...',
                     maxItems: 10,
                     initialValue,
-                    options: domainOptions.map((option) => ({ label: option.domain, value: option.id, hint: option.providerName })),
+                    options: domainOptions.map((option) => ({ label: option.domain, value: option.id, hint: providerAccountLabel(option) })),
                 });
                 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}.`);
+            p.log.info(`Using domain ${selectedDomain.domain} from ${providerAccountLabel(selectedDomain)}.`);
             const domain = selectedDomain.domain;
             await updateConfig((current) => ({
                 ...current,
@@ -330,8 +336,8 @@ export default class Wizard extends Command {
                     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 preview = await createLinkPlan({ account: selectedDomain.account, provider: selectedDomain.providerId, domain, subdomain, apex, project });
+            p.note([`Vercel: add ${preview.domain} to ${projectDisplay}`, ...preview.records.map((record) => recordPreview(record, providerAccountLabel(selectedDomain)))].join('\n'), 'Preview');
             const confirmed = await p.confirm({
                 message: `Link ${fullDomain} via ${selectedDomain.providerName} to Vercel project ${projectDisplay}?`,
                 initialValue: true,
@@ -343,6 +349,7 @@ export default class Wizard extends Command {
             activeSpinner = spinner;
             spinner.start('Adding domain to Vercel');
             const result = await linkDomain({
+                account: selectedDomain.account,
                 provider: selectedDomain.providerId,
                 domain,
                 subdomain,

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

@@ -1,5 +1,5 @@
 import { type ProviderStatus } from './providers/status.js';
-export type ProviderConnectionStatus = Pick<ProviderStatus, 'configured' | 'default' | 'displayName' | 'docsUrl' | 'id'>;
+export type ProviderConnectionStatus = Pick<ProviderStatus, 'account' | 'configured' | 'default' | 'displayName' | 'docsUrl' | 'id' | 'isDefaultAccount'>;
 export interface CommandSchema {
     name: string;
     description: string;

package/dist/lib/command-schema.js

@@ -9,6 +9,7 @@ export const commandSchemas = [
             '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',
+            'doomain link app.example.com --provider spaceship --account work --project my-app --json',
         ],
         agentHint: 'For agent use, try `doomain link <domain> --json` first. Do not inspect project files, run provider status, or use --dry-run unless the user explicitly asks for a preview. The command infers project/provider and returns structured recovery errors when inference fails.',
         agentInstructions: [
@@ -25,6 +26,7 @@ export const commandSchemas = [
         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: 'account', type: 'string', description: 'DNS provider account alias. Defaults to the provider default account.' },
             { 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.' },
@@ -41,12 +43,14 @@ export const commandSchemas = [
         examples: [
             'doomain providers connect',
             'doomain providers connect spaceship --credential apiKey=key --credential apiSecret=secret --json',
+            'doomain providers connect spaceship --account work --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',
             'doomain providers connect hostinger --credential apiToken=token --json',
         ],
         flags: [
             { name: 'json', type: 'boolean', description: 'Output a single JSON object and never prompt.' },
+            { name: 'account', type: 'string', description: 'DNS provider account alias. Defaults to the provider default account.' },
             { 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.' },
@@ -56,9 +60,10 @@ export const commandSchemas = [
     {
         name: 'providers add',
         description: 'Alias for providers connect.',
-        examples: ['doomain providers add', 'doomain providers add namecheap'],
+        examples: ['doomain providers add', 'doomain providers add namecheap', 'doomain providers add spaceship --account work'],
         flags: [
             { name: 'json', type: 'boolean', description: 'Output a single JSON object and never prompt.' },
+            { name: 'account', type: 'string', description: 'DNS provider account alias. Defaults to the provider default account.' },
             { 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.' },
         ],
@@ -75,17 +80,29 @@ export const commandSchemas = [
     {
         name: 'providers disconnect',
         description: 'Remove saved DNS provider credentials locally.',
-        examples: ['doomain providers disconnect namecheap --json', 'doomain providers disconnect cloudflare --json', 'doomain providers disconnect hostinger --json'],
+        examples: [
+            'doomain providers disconnect namecheap --json',
+            'doomain providers disconnect cloudflare --json',
+            'doomain providers disconnect spaceship --account work --json',
+            'doomain providers disconnect hostinger --json',
+        ],
         flags: [
             { name: 'json', type: 'boolean', description: 'Output a single JSON object and never prompt.' },
+            { name: 'account', type: 'string', description: 'DNS provider account alias. Omit to remove all accounts for the provider.' },
         ],
     },
     {
         name: 'providers verify',
         description: 'Verify saved DNS provider credentials.',
-        examples: ['doomain providers verify spaceship --json', 'doomain providers verify namecheap --json', 'doomain providers verify hostinger --json'],
+        examples: [
+            'doomain providers verify spaceship --json',
+            'doomain providers verify spaceship --account work --json',
+            'doomain providers verify namecheap --json',
+            'doomain providers verify hostinger --json',
+        ],
         flags: [
             { name: 'json', type: 'boolean', description: 'Output a single JSON object and never prompt.' },
+            { name: 'account', type: 'string', description: 'DNS provider account alias. Defaults to the provider default account.' },
         ],
     },
     {
@@ -114,11 +131,13 @@ export function getCommandSchema(name) {
 }
 async function configuredProviders() {
     return (await listProviderStatuses({ verify: false })).map((provider) => ({
+        account: provider.account,
         configured: provider.configured,
         default: provider.default,
         displayName: provider.displayName,
         docsUrl: provider.docsUrl,
         id: provider.id,
+        isDefaultAccount: provider.isDefaultAccount,
     }));
 }
 function withProviderConnections(schema, providers) {

package/dist/lib/config.d.ts

@@ -6,10 +6,13 @@ export interface VercelConfig {
     token?: string;
     teamId?: string;
 }
-export interface ProviderConfig {
+export interface ProviderAccountConfig {
     credentials?: Record<string, string>;
     settings?: Record<string, unknown>;
 }
+export interface ProviderConfig extends ProviderAccountConfig {
+    accounts?: Record<string, ProviderAccountConfig | undefined>;
+}
 export interface SpaceshipProviderConfig extends ProviderConfig {
     apiKey?: string;
     apiSecret?: string;

package/dist/lib/flags.d.ts

@@ -1,5 +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 accountFlag: 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>;

package/dist/lib/flags.js

@@ -1,6 +1,7 @@
 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 accountFlag = Flags.string({ description: 'DNS provider account alias. Defaults to the provider default account.' });
 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.' });

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

@@ -1,6 +1,7 @@
 import type { DnsRecordInput } from './providers/types.js';
 export interface LinkDomainInput {
     provider?: string;
+    account?: string;
     domain?: string;
     subdomain?: string;
     apex?: boolean;
@@ -21,6 +22,9 @@ export type LinkDomainProgressCallback = (progress: LinkDomainProgress) => void;
 export interface LinkDomainPlan {
     provider: string;
     providerInferred: boolean;
+    account: string;
+    accountInferred: boolean;
+    isDefaultAccount: boolean;
     project: string;
     projectSource: LinkDomainProjectSource;
     recordName: string;

package/dist/lib/link-domain.js

@@ -4,8 +4,9 @@ import { dirname, join, parse } from 'node:path';
 import { loadConfig } from './config.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 { isProviderConfigured, listProviderStatuses } from './providers/status.js';
+import { listProviderStatuses } 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) {
@@ -118,10 +119,12 @@ async function resolveZone(provider, zoneDomain) {
 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) {
@@ -155,51 +158,91 @@ function targetFromZone(fullDomain, zoneDomain) {
 }
 function candidateDetails(candidates) {
     return candidates.map((candidate) => ({
+        account: candidate.account,
+        isDefaultAccount: candidate.isDefaultAccount,
         provider: candidate.provider,
         providerName: candidate.providerName,
         zoneDomain: candidate.zone.name,
     }));
 }
-async function loadProviderZones(definition) {
-    const provider = await createProvider(definition.id);
+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) => ({ provider: definition.id, providerName: definition.displayName, zone })),
-        search: { displayName: definition.displayName, id: definition.id, zones: zones.map((zone) => zone.name) },
+        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) {
+async function loadConfiguredProviderZones(providerId, accountInput) {
+    const config = await loadConfig();
+    const account = accountInput ? normalizeProviderAccount(accountInput) : undefined;
     if (providerId) {
         const definition = getProviderDefinition(providerId);
-        const result = await loadProviderZones(definition);
-        return { candidates: result.candidates, providerInferred: false, searched: [result.search] };
+        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 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 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: ['doomain providers connect', '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(definitions.map(async (definition) => {
+    const results = await Promise.all(providerAccounts.map(async ({ definition, ref }) => {
         try {
-            return await loadProviderZones(definition);
+            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),
@@ -211,30 +254,35 @@ async function resolveProviderTarget(input) {
         domain: await resolveConfiguredDomain(input.domain),
         subdomain: input.subdomain,
     });
-    const zones = await loadConfiguredProviderZones(input.provider);
+    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} does not have a matching DNS zone for ${requested.fullDomain}.`
+            ? `${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> only if another configured provider owns this zone. Otherwise connect the DNS provider that owns this domain.',
+            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> --json`, 'doomain providers connect'],
+            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.zone.name === candidate.zone.name) === index);
+    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 providers have a matching DNS zone for ${requested.fullDomain}. Pass --provider to choose one.`, { candidates: candidateDetails(uniqueBestMatches), domain: requested.fullDomain });
+        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),
@@ -414,9 +462,12 @@ function reportProgress(input, stage, message) {
 export async function createLinkPlan(input) {
     const project = await resolveProject(input.project);
     const resolved = await resolveProviderTarget(input);
-    const { provider, providerInferred, target } = resolved;
+    const { account, accountInferred, isDefaultAccount, provider, providerInferred, target } = resolved;
     const record = planBaseRecord({ isApex: target.isApex, provider, recordName: target.recordName });
     return {
+        account,
+        accountInferred,
+        isDefaultAccount,
         provider,
         providerInferred,
         project: project.project,
@@ -441,7 +492,7 @@ export async function linkDomain(input) {
         };
     }
     const vercel = createVercelClient(await resolveVercelConfig());
-    const provider = await createProvider(plan.provider);
+    const provider = await createProvider(plan.provider, { account: plan.account });
     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');

package/dist/lib/providers/core/config.d.ts

@@ -1,5 +1,18 @@
 import { type DoomainConfig } from '../../config.js';
 import type { CredentialDefinition, DnsProviderDefinition, ProviderContext } from './types.js';
-export declare function getProviderCredentials(config: DoomainConfig, providerId: string): Record<string, string>;
-export declare function getProviderCredential(config: DoomainConfig, providerId: string, credential: CredentialDefinition): string | undefined;
-export declare function createProviderContext(definition: DnsProviderDefinition): Promise<ProviderContext>;
+export declare const DEFAULT_PROVIDER_ACCOUNT = "default";
+export interface ProviderAccountRef {
+    account: string;
+    isDefaultAccount: boolean;
+    providerId: string;
+}
+export interface ProviderAccountOptions {
+    account?: string;
+}
+export declare function normalizeProviderAccount(account?: string): string;
+export declare function isDefaultProviderAccount(account?: string): boolean;
+export declare function getProviderCredentials(config: DoomainConfig, providerId: string, opts?: ProviderAccountOptions): Record<string, string>;
+export declare function getProviderCredential(config: DoomainConfig, providerId: string, credential: CredentialDefinition, opts?: ProviderAccountOptions): string | undefined;
+export declare function isProviderAccountConfigured(definition: DnsProviderDefinition, config: DoomainConfig, opts?: ProviderAccountOptions): boolean;
+export declare function listConfiguredProviderAccounts(config: DoomainConfig, definition: DnsProviderDefinition): ProviderAccountRef[];
+export declare function createProviderContext(definition: DnsProviderDefinition, opts?: ProviderAccountOptions): Promise<ProviderContext>;

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

@@ -1,5 +1,19 @@
 import { loadConfig } from '../../config.js';
 import { DoomainError } from '../../errors.js';
+import { ensureProviderAccount } from '../../validate.js';
+export const DEFAULT_PROVIDER_ACCOUNT = 'default';
+export function normalizeProviderAccount(account) {
+    if (!account?.trim())
+        return DEFAULT_PROVIDER_ACCOUNT;
+    return ensureProviderAccount(account);
+}
+export function isDefaultProviderAccount(account) {
+    return normalizeProviderAccount(account) === DEFAULT_PROVIDER_ACCOUNT;
+}
+function providerConfig(config, providerId) {
+    const value = config.providers?.[providerId];
+    return value && typeof value === 'object' ? value : undefined;
+}
 function legacyCredential(config, providerId, key) {
     if (providerId !== 'spaceship')
         return undefined;
@@ -8,25 +22,53 @@ function legacyCredential(config, providerId, key) {
         return undefined;
     return legacy[key];
 }
-export function getProviderCredentials(config, providerId) {
-    const providerConfig = config.providers?.[providerId];
-    const credentials = providerConfig && typeof providerConfig === 'object' && 'credentials' in providerConfig
-        ? (providerConfig.credentials ?? {})
-        : {};
-    return { ...credentials };
+function credentialFromSavedConfig(config, providerId, account, key) {
+    const credentials = getProviderCredentials(config, providerId, { account });
+    if (credentials[key])
+        return credentials[key];
+    if (account === DEFAULT_PROVIDER_ACCOUNT)
+        return legacyCredential(config, providerId, key);
+    return undefined;
+}
+export function getProviderCredentials(config, providerId, opts = {}) {
+    const account = normalizeProviderAccount(opts.account);
+    const current = providerConfig(config, providerId);
+    const credentials = account === DEFAULT_PROVIDER_ACCOUNT ? current?.credentials : current?.accounts?.[account]?.credentials;
+    return { ...(credentials ?? {}) };
 }
-export function getProviderCredential(config, providerId, credential) {
-    return process.env[credential.env] || getProviderCredentials(config, providerId)[credential.key] || legacyCredential(config, providerId, credential.key);
+export function getProviderCredential(config, providerId, credential, opts = {}) {
+    const account = normalizeProviderAccount(opts.account);
+    return process.env[credential.env] || credentialFromSavedConfig(config, providerId, account, credential.key);
+}
+export function isProviderAccountConfigured(definition, config, opts = {}) {
+    return definition.credentials.every((credential) => credential.required === false || Boolean(getProviderCredential(config, definition.id, credential, opts)));
+}
+export function listConfiguredProviderAccounts(config, definition) {
+    const accounts = [];
+    if (isProviderAccountConfigured(definition, config, { account: DEFAULT_PROVIDER_ACCOUNT })) {
+        accounts.push({ account: DEFAULT_PROVIDER_ACCOUNT, isDefaultAccount: true, providerId: definition.id });
+    }
+    for (const account of Object.keys(providerConfig(config, definition.id)?.accounts ?? {}).sort()) {
+        const normalized = normalizeProviderAccount(account);
+        if (normalized === DEFAULT_PROVIDER_ACCOUNT)
+            continue;
+        if (!isProviderAccountConfigured(definition, config, { account: normalized }))
+            continue;
+        accounts.push({ account: normalized, isDefaultAccount: false, providerId: definition.id });
+    }
+    return accounts;
 }
-export async function createProviderContext(definition) {
+export async function createProviderContext(definition, opts = {}) {
     const config = await loadConfig();
     const credentials = {};
+    const account = normalizeProviderAccount(opts.account);
     for (const credential of definition.credentials) {
-        const value = getProviderCredential(config, definition.id, credential);
+        const value = getProviderCredential(config, definition.id, credential, { account });
         if (value)
             credentials[credential.key] = value;
         else if (credential.required !== false) {
-            throw new DoomainError('MISSING_CREDENTIALS', `Missing ${definition.displayName} ${credential.label}. Run \`doomain providers connect ${definition.id}\` or set ${credential.env}.`);
+            const accountHint = account === DEFAULT_PROVIDER_ACCOUNT ? '' : ` for account ${account}`;
+            throw new DoomainError('MISSING_CREDENTIALS', `Missing ${definition.displayName} ${credential.label}${accountHint}. Run \`doomain providers connect ${definition.id}${account === DEFAULT_PROVIDER_ACCOUNT ? '' : ` --account ${account}`}\` or set ${credential.env}.`, { account, provider: definition.id });
         }
     }
     return { credentials, debug: process.env.DOOMAIN_DEBUG === '1' };

package/dist/lib/providers/registry.d.ts

@@ -1,4 +1,6 @@
 import type { DnsProvider, DnsProviderDefinition } from './types.js';
 export declare function listProviderDefinitions(): DnsProviderDefinition[];
 export declare function getProviderDefinition(id: string): DnsProviderDefinition;
-export declare function createProvider(id: string): Promise<DnsProvider>;
+export declare function createProvider(id: string, opts?: {
+    account?: string;
+}): Promise<DnsProvider>;

package/dist/lib/providers/registry.js

@@ -16,7 +16,7 @@ export function getProviderDefinition(id) {
         throw new DoomainError('PROVIDER_NOT_FOUND', `Unsupported DNS provider: ${id}`);
     return definition;
 }
-export async function createProvider(id) {
+export async function createProvider(id, opts = {}) {
     const definition = getProviderDefinition(id);
-    return definition.create(await createProviderContext(definition));
+    return definition.create(await createProviderContext(definition, opts));
 }

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

@@ -1,6 +1,7 @@
 import { type DoomainConfig } from '../config.js';
 import type { DnsProviderDefinition } from './types.js';
 export interface ProviderStatus {
+    account: string;
     configured: boolean;
     default: boolean;
     displayName: string;
@@ -8,9 +9,12 @@ export interface ProviderStatus {
     domainCount?: number;
     error?: string;
     id: string;
+    isDefaultAccount: boolean;
     verified?: boolean;
 }
-export declare function isProviderConfigured(definition: DnsProviderDefinition, config: DoomainConfig): boolean;
+export declare function isProviderConfigured(definition: DnsProviderDefinition, config: DoomainConfig, opts?: {
+    account?: string;
+}): boolean;
 export declare function listProviderStatuses(opts?: {
     verify?: boolean;
 }): Promise<ProviderStatus[]>;

package/dist/lib/providers/status.js

@@ -1,33 +1,40 @@
 import { loadConfig } from '../config.js';
-import { getProviderCredential } from './core/config.js';
+import { DEFAULT_PROVIDER_ACCOUNT, isProviderAccountConfigured, listConfiguredProviderAccounts, normalizeProviderAccount, } from './core/config.js';
 import { createProvider, listProviderDefinitions } from './registry.js';
-export function isProviderConfigured(definition, config) {
-    return definition.credentials.every((credential) => credential.required === false || Boolean(getProviderCredential(config, definition.id, credential)));
+export function isProviderConfigured(definition, config, opts = {}) {
+    return isProviderAccountConfigured(definition, config, opts);
 }
 export async function listProviderStatuses(opts = {}) {
     const config = await loadConfig();
     const statuses = [];
     for (const definition of listProviderDefinitions()) {
-        const configured = isProviderConfigured(definition, config);
-        const status = {
-            configured,
-            default: config.defaults?.provider === definition.id,
-            displayName: definition.displayName,
-            docsUrl: definition.docsUrl,
-            id: definition.id,
-        };
-        if (configured && opts.verify) {
-            try {
-                const zones = await (await createProvider(definition.id)).listZones();
-                status.domainCount = zones.length;
-                status.verified = true;
-            }
-            catch (error) {
-                status.error = error instanceof Error ? error.message : String(error);
-                status.verified = false;
+        const accounts = listConfiguredProviderAccounts(config, definition);
+        const refs = accounts.length > 0 ? accounts : [{ account: DEFAULT_PROVIDER_ACCOUNT, isDefaultAccount: true, providerId: definition.id }];
+        for (const ref of refs) {
+            const account = normalizeProviderAccount(ref.account);
+            const configured = accounts.some((item) => item.account === account);
+            const status = {
+                account,
+                configured,
+                default: config.defaults?.provider === definition.id,
+                displayName: definition.displayName,
+                docsUrl: definition.docsUrl,
+                id: definition.id,
+                isDefaultAccount: ref.isDefaultAccount,
+            };
+            if (configured && opts.verify) {
+                try {
+                    const zones = await (await createProvider(definition.id, { account })).listZones();
+                    status.domainCount = zones.length;
+                    status.verified = true;
+                }
+                catch (error) {
+                    status.error = error instanceof Error ? error.message : String(error);
+                    status.verified = false;
+                }
             }
+            statuses.push(status);
         }
-        statuses.push(status);
     }
     return statuses;
 }

package/dist/lib/validate.d.ts

@@ -12,4 +12,5 @@ export declare function resolveDomainTarget(opts: {
     apex?: boolean;
 }): DomainTarget;
 export declare function ensureProviderId(value: string): string;
+export declare function ensureProviderAccount(value: string): string;
 export declare function ensureProject(value?: string): string;

package/dist/lib/validate.js

@@ -54,6 +54,13 @@ export function ensureProviderId(value) {
     }
     return provider;
 }
+export function ensureProviderAccount(value) {
+    const account = value.trim().toLowerCase();
+    if (!/^[a-z0-9][a-z0-9-]*$/.test(account)) {
+        throw new DoomainError('INVALID_INPUT', `Invalid provider account alias: ${value}`);
+    }
+    return account;
+}
 export function ensureProject(value) {
     const project = value?.trim();
     if (!project)

package/oclif.manifest.json

@@ -15,9 +15,17 @@
         "<%= config.bin %> <%= command.id %> app.example.com --project my-app --json",
         "<%= config.bin %> <%= command.id %> --domain app.example.com --project my-app --json",
         "<%= config.bin %> <%= command.id %> --domain example.com --subdomain app --project my-app",
-        "<%= config.bin %> <%= command.id %> --provider spaceship --domain example.com --apex --project my-app --json"
+        "<%= config.bin %> <%= command.id %> --provider spaceship --domain example.com --apex --project my-app --json",
+        "<%= config.bin %> <%= command.id %> app.example.com --provider spaceship --account work --project my-app --json"
       ],
       "flags": {
+        "account": {
+          "description": "DNS provider account alias. Defaults to the provider default account.",
+          "name": "account",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
         "apex": {
           "description": "Use the root/apex domain instead of a subdomain.",
           "name": "apex",
@@ -264,6 +272,13 @@
       "args": {},
       "description": "List DNS zones and records for a provider.",
       "flags": {
+        "account": {
+          "description": "DNS provider 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",
@@ -301,6 +316,41 @@
         "list.js"
       ]
     },
+    "projects:list": {
+      "aliases": [],
+      "args": {},
+      "description": "List Vercel projects.",
+      "flags": {
+        "json": {
+          "description": "Output a single JSON object and never prompt.",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "search": {
+          "description": "Filter projects by search term.",
+          "name": "search",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "projects:list",
+      "pluginAlias": "doomain",
+      "pluginName": "doomain",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "projects",
+        "list.js"
+      ]
+    },
     "providers:add": {
       "aliases": [],
       "args": {
@@ -312,6 +362,13 @@
       },
       "description": "Save DNS provider credentials locally.",
       "flags": {
+        "account": {
+          "description": "DNS provider account alias. Defaults to the provider default account.",
+          "name": "account",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
         "api-key": {
           "description": "Compatibility alias for Spaceship apiKey.",
           "name": "api-key",
@@ -374,6 +431,13 @@
       },
       "description": "Save DNS provider credentials locally.",
       "flags": {
+        "account": {
+          "description": "DNS provider account alias. Defaults to the provider default account.",
+          "name": "account",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
         "api-key": {
           "description": "Compatibility alias for Spaceship apiKey.",
           "name": "api-key",
@@ -442,6 +506,13 @@
         "<%= config.bin %> <%= command.id %> cloudflare --json"
       ],
       "flags": {
+        "account": {
+          "description": "DNS provider account alias. Defaults to the provider default account.",
+          "name": "account",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
         "json": {
           "description": "Output a single JSON object and never prompt.",
           "name": "json",
@@ -538,6 +609,13 @@
       },
       "description": "Verify saved DNS provider credentials.",
       "flags": {
+        "account": {
+          "description": "DNS provider account alias. Defaults to the provider default account.",
+          "name": "account",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
         "json": {
           "description": "Output a single JSON object and never prompt.",
           "name": "json",
@@ -561,41 +639,6 @@
         "verify.js"
       ]
     },
-    "projects:list": {
-      "aliases": [],
-      "args": {},
-      "description": "List Vercel projects.",
-      "flags": {
-        "json": {
-          "description": "Output a single JSON object and never prompt.",
-          "name": "json",
-          "allowNo": false,
-          "type": "boolean"
-        },
-        "search": {
-          "description": "Filter projects by search term.",
-          "name": "search",
-          "hasDynamicHelp": false,
-          "multiple": false,
-          "type": "option"
-        }
-      },
-      "hasDynamicHelp": false,
-      "hiddenAliases": [],
-      "id": "projects:list",
-      "pluginAlias": "doomain",
-      "pluginName": "doomain",
-      "pluginType": "core",
-      "strict": true,
-      "enableJsonFlag": false,
-      "isESM": true,
-      "relativePath": [
-        "dist",
-        "commands",
-        "projects",
-        "list.js"
-      ]
-    },
     "auth:logout:vercel": {
       "aliases": [],
       "args": {},
@@ -630,5 +673,5 @@
       ]
     }
   },
-  "version": "0.1.9"
+  "version": "0.1.11"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "doomain",
   "description": "Link your vercel project and domain in seconds",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "author": "Crafter Station",
   "packageManager": "bun@1.3.13",
   "bin": {