doomain 0.1.10 → 0.1.12

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 { DEFAULT_PROVIDER_ACCOUNT, isDefaultProviderAccount, listConfiguredProviderAccounts, normalizeProviderAccount, providerAccountHasCredentials, withProviderAccountCredentials, } 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();
@@ -58,12 +58,40 @@ async function promptCredential(credential, detectedPublicIp) {
     }
     return typeof value === 'string' && value.trim() ? value.trim() : null;
 }
+function validateProviderAccount(value) {
+    try {
+        normalizeProviderAccount(value);
+        return undefined;
+    }
+    catch (error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+}
+async function promptProviderAccount() {
+    const value = await p.text({ message: 'Profile name', placeholder: DEFAULT_PROVIDER_ACCOUNT, validate: validateProviderAccount });
+    if (p.isCancel(value)) {
+        p.cancel('Cancelled');
+        return null;
+    }
+    return normalizeProviderAccount(value);
+}
+async function confirmProviderAccountOverwrite(definition, account) {
+    const value = await p.confirm({
+        initialValue: false,
+        message: `Profile "${account}" already exists for ${definition.displayName}. Overwrite it?`,
+    });
+    if (p.isCancel(value)) {
+        p.cancel('Cancelled');
+        return false;
+    }
+    return value;
+}
 async function promptProvider() {
     const config = await loadConfig();
     const selected = await p.select({
         message: 'Choose DNS provider',
         options: listProviderDefinitions().map((definition) => ({
-            hint: isProviderConfigured(definition, config) ? 'Connected' : 'Not connected',
+            hint: listConfiguredProviderAccounts(config, definition).length > 0 ? 'Connected' : 'Not connected',
             label: definition.displayName,
             value: definition.id,
         })),
@@ -91,6 +119,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 +136,16 @@ export default class ProvidersConnect extends Command {
             const definition = args.provider ? getProviderDefinition(args.provider) : await promptProvider();
             if (!definition)
                 return;
+            const account = flags.account ? normalizeProviderAccount(flags.account) : out.json ? DEFAULT_PROVIDER_ACCOUNT : await promptProviderAccount();
+            if (!account)
+                return;
+            const isDefaultAccount = isDefaultProviderAccount(account);
+            const currentConfig = await loadConfig();
+            if (!out.json && providerAccountHasCredentials(currentConfig, definition.id, account)) {
+                const overwrite = await confirmProviderAccountOverwrite(definition, account);
+                if (!overwrite)
+                    return;
+            }
             const passedCredentials = parseCredentialFlags(flags.credential);
             const credentials = {};
             const detectedPublicIp = !out.json && usesClientIp(definition) ? await fetchPublicIp() : undefined;
@@ -145,7 +184,6 @@ export default class ProvidersConnect extends Command {
                 spinner = undefined;
             }
             let setDefault = true;
-            const currentConfig = await loadConfig();
             if (!out.json && currentConfig.defaults?.provider && currentConfig.defaults.provider !== definition.id) {
                 const value = await p.confirm({
                     initialValue: true,
@@ -162,13 +200,16 @@ export default class ProvidersConnect extends Command {
                 defaults: setDefault ? { ...config.defaults, provider: definition.id } : config.defaults,
                 providers: {
                     ...config.providers,
-                    [definition.id]: { credentials },
+                    [definition.id]: withProviderAccountCredentials(config.providers?.[definition.id], 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, isDefaultProviderAccount, listConfiguredProviderAccounts, normalizeProviderAccount, providerAccountHasCredentials, withProviderAccountCredentials, } 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__';
@@ -26,6 +26,28 @@ async function promptRequired(message, opts = {}) {
     const resolved = cancelIfNeeded(value);
     return typeof resolved === 'string' ? resolved.trim() : null;
 }
+function validateProviderAccount(value) {
+    try {
+        normalizeProviderAccount(value);
+        return undefined;
+    }
+    catch (error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+}
+async function promptProviderAccount() {
+    const value = await p.text({ message: 'Profile name', placeholder: DEFAULT_PROVIDER_ACCOUNT, validate: validateProviderAccount });
+    const resolved = cancelIfNeeded(value);
+    return typeof resolved === 'string' ? normalizeProviderAccount(resolved) : null;
+}
+async function confirmProviderAccountOverwrite(definition, account) {
+    const value = await p.confirm({
+        initialValue: false,
+        message: `Profile "${account}" already exists for ${definition.displayName}. Overwrite it?`,
+    });
+    const resolved = cancelIfNeeded(value);
+    return resolved === true;
+}
 async function fetchPublicIp() {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), 2000);
@@ -72,7 +94,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 +109,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,15 +264,24 @@ 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)
                     return;
                 showProviderSetup(selectedDefinition);
+                const account = await promptProviderAccount();
+                if (!account)
+                    return;
+                if (providerAccountHasCredentials(config, selectedDefinition.id, account)) {
+                    const overwrite = await confirmProviderAccountOverwrite(selectedDefinition, account);
+                    if (!overwrite)
+                        return;
+                }
+                const providerAccount = { account, isDefaultAccount: isDefaultProviderAccount(account), providerId: selectedDefinition.id };
                 const credentials = await promptProviderCredentials(selectedDefinition);
                 if (!credentials)
                     return;
@@ -256,24 +292,28 @@ 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, providerAccount, zone)));
                 await updateConfig((current) => ({
                     ...current,
                     defaults: { ...current.defaults, provider: selectedDefinition.id },
-                    providers: { ...current.providers, [selectedDefinition.id]: { credentials } },
+                    providers: {
+                        ...current.providers,
+                        [selectedDefinition.id]: withProviderAccountCredentials(current.providers?.[selectedDefinition.id], account, credentials),
+                    },
                     vercel: { token: vercelToken, teamId: vercelTeamId },
                 }));
             }
             else {
                 const domainSpinner = p.spinner();
                 activeSpinner = domainSpinner;
-                domainSpinner.start(`Loading domains from ${configuredProviderDefinitions.length} provider${configuredProviderDefinitions.length === 1 ? '' : 's'}`);
-                for (const definition of configuredProviderDefinitions) {
+                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 +339,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 +370,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 +383,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 profile/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 profile/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 profile/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 profile/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 profile/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) {