doomain 0.1.0 → 0.1.1

package/dist/commands/link.js

@@ -1,4 +1,5 @@
 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 { linkDomain } from '../lib/link-domain.js';
 import { createOutput, outputError } from '../lib/output.js';
@@ -17,7 +18,7 @@ export default class Link extends Command {
         apex: apexFlag,
         domain: domainFlag,
         'dry-run': Flags.boolean({ description: 'Preview changes without writing to Vercel or DNS.' }),
-        force: Flags.boolean({ description: 'Overwrite conflicting DNS records.' }),
+        force: Flags.boolean({ description: 'Move existing Vercel aliases and overwrite conflicting DNS records.' }),
         json: jsonFlag,
         project: projectFlag,
         provider: providerFlag,
@@ -31,6 +32,9 @@ export default class Link extends Command {
         let spinner;
         const domain = flags.domain ?? args.domain;
         try {
+            if (!domain) {
+                throw new DoomainError('MISSING_ARGUMENT', 'Domain is required. Use `doomain link <domain>` or pass --domain.');
+            }
             if (flags['dry-run']) {
                 const result = await linkDomain({ ...flags, domain, dryRun: true, timeoutSeconds: flags.timeout });
                 out.result(result);

package/dist/commands/wizard.js

@@ -127,8 +127,9 @@ export default class Wizard extends Command {
             p.intro('Doomain');
             const config = await loadConfig();
             const providerDefinitions = listProviderDefinitions();
+            const localProject = detectLocalVercelProject();
             let vercelToken = process.env.VERCEL_TOKEN || config.vercel?.token;
-            let vercelTeamId = process.env.VERCEL_TEAM_ID || config.vercel?.teamId;
+            let vercelTeamId = process.env.VERCEL_TEAM_ID || localProject?.orgId || config.vercel?.teamId;
             const defaultProvider = process.env.DOOMAIN_PROVIDER || config.defaults?.provider;
             const defaultDomain = process.env.DOOMAIN_DOMAIN || config.defaults?.domain;
             if (!vercelToken) {
@@ -136,7 +137,6 @@ export default class Wizard extends Command {
                 if (!vercelToken)
                     return;
             }
-            const localProject = detectLocalVercelProject();
             const teamSpinner = p.spinner();
             let teams = [];
             if (process.env.VERCEL_TEAM_ID) {
@@ -164,34 +164,33 @@ export default class Wizard extends Command {
             const selectedTeam = teams.find((team) => team.id === vercelTeamId);
             const teamDisplay = vercelTeamId ? teamLabel(selectedTeam ?? { id: vercelTeamId, name: null, role: null, slug: vercelTeamId }) : 'Personal account';
             p.log.success(`Vercel account ready: ${teamDisplay}`);
-            const localProjectMatchesTeam = localProject && (vercelTeamId ? localProject.orgId === vercelTeamId : !localProject.orgId);
-            let project = localProjectMatchesTeam ? localProject.projectId : undefined;
-            let projectDisplay = project ? projectLabel({ id: project }) : '';
-            if (project) {
-                p.log.info(`Using linked Vercel project ${projectDisplay}.`);
-            }
-            else {
-                const spinner = p.spinner();
-                activeSpinner = spinner;
-                spinner.start('Loading Vercel projects');
-                const projects = await createVercelClient({ token: vercelToken, teamId: vercelTeamId }).listProjects();
-                spinner.stop(`Loaded ${projects.length} projects`);
-                activeSpinner = undefined;
-                if (projects.length === 0) {
-                    throw new DoomainError('PROJECT_NOT_FOUND', `No Vercel projects found in ${teamDisplay}.`);
-                }
-                const selected = await p.autocomplete({
-                    message: 'Select Vercel project',
-                    placeholder: 'Type to filter projects...',
-                    maxItems: 10,
-                    options: projects.map((item) => ({ label: projectLabel(item), value: item.id, hint: item.framework ?? undefined })),
-                });
-                const resolved = cancelIfNeeded(selected);
-                if (resolved === null)
-                    return;
-                project = resolved;
-                projectDisplay = projectLabel(projects.find((item) => item.id === project) ?? { id: project });
+            const projectSpinner = p.spinner();
+            activeSpinner = projectSpinner;
+            projectSpinner.start('Loading Vercel projects');
+            const projects = await createVercelClient({ token: vercelToken, teamId: vercelTeamId }).listProjects();
+            projectSpinner.stop(`Loaded ${projects.length} projects`);
+            activeSpinner = undefined;
+            if (projects.length === 0) {
+                throw new DoomainError('PROJECT_NOT_FOUND', `No Vercel projects found in ${teamDisplay}.`);
             }
+            const localProjectMatchesTeam = localProject && (vercelTeamId ? localProject.orgId === vercelTeamId : !localProject.orgId);
+            const initialProject = localProjectMatchesTeam && projects.some((item) => item.id === localProject.projectId) ? localProject.projectId : undefined;
+            const selected = await p.autocomplete({
+                message: 'Select Vercel project',
+                placeholder: 'Type to filter projects...',
+                maxItems: 10,
+                initialValue: initialProject,
+                options: projects.map((item) => ({
+                    label: projectLabel(item),
+                    value: item.id,
+                    hint: item.id === initialProject ? 'linked in .vercel' : (item.framework ?? undefined),
+                })),
+            });
+            const resolved = cancelIfNeeded(selected);
+            if (resolved === null)
+                return;
+            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 providerFailures = [];

package/dist/lib/errors.d.ts

@@ -1,4 +1,4 @@
-export type DoomainErrorCode = 'CONFIG_NOT_FOUND' | 'DOMAIN_LINK_FAILED' | 'DOMAIN_VERIFY_FAILED' | 'INVALID_INPUT' | 'MISSING_ARGUMENT' | 'MISSING_CREDENTIALS' | 'PROVIDER_API_ERROR' | 'PROVIDER_AUTH_FAILED' | 'PROVIDER_PERMISSION_DENIED' | 'PROVIDER_NOT_FOUND' | 'PROVIDER_RATE_LIMITED' | 'PROVIDER_RECORD_CONFLICT' | 'PROVIDER_UNSUPPORTED_RECORD' | 'PROVIDER_ZONE_AMBIGUOUS' | 'PROVIDER_ZONE_NOT_FOUND' | 'PROJECT_NOT_FOUND' | 'VERCEL_PROJECT_NOT_LINKED';
+export type DoomainErrorCode = 'CONFIG_NOT_FOUND' | 'DOMAIN_LINK_FAILED' | 'DOMAIN_ALREADY_ASSIGNED' | 'DOMAIN_VERIFY_FAILED' | 'INVALID_INPUT' | 'MISSING_ARGUMENT' | 'MISSING_CREDENTIALS' | 'PROVIDER_API_ERROR' | 'PROVIDER_AUTH_FAILED' | 'PROVIDER_PERMISSION_DENIED' | 'PROVIDER_NOT_FOUND' | 'PROVIDER_RATE_LIMITED' | 'PROVIDER_RECORD_CONFLICT' | 'PROVIDER_UNSUPPORTED_RECORD' | 'PROVIDER_ZONE_AMBIGUOUS' | 'PROVIDER_ZONE_NOT_FOUND' | 'PROJECT_NOT_FOUND' | 'VERCEL_PROJECT_NOT_LINKED';
 export declare class DoomainError extends Error {
     readonly code: DoomainErrorCode;
     readonly details?: unknown;

package/dist/lib/link-domain.js

@@ -304,7 +304,7 @@ export async function linkDomain(input) {
     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');
-    const addResult = await vercel.addDomainToProject(plan.project, plan.domain);
+    const addResult = await vercel.addDomainToProject(plan.project, plan.domain, { force: input.force });
     reportProgress(input, 'vercel:get-target', 'Reading Vercel DNS target');
     const cname = plan.isApex ? undefined : await vercel.getRecommendedCname(plan.domain);
     reportProgress(input, 'vercel:get-domain', 'Reading Vercel verification records');

package/dist/lib/vercel.d.ts

@@ -16,17 +16,33 @@ export interface VercelConfig {
     token: string;
     teamId?: string;
 }
+interface VercelProjectDomainOwner {
+    domain: Record<string, unknown> & {
+        name?: string;
+        projectId?: string;
+    };
+    project: VercelProject;
+}
 export declare function resolveVercelConfig(): Promise<VercelConfig>;
 export declare function createVercelClient(config: VercelConfig): {
     listTeams(): Promise<VercelTeam[]>;
     listProjects(search?: string): Promise<VercelProject[]>;
-    addDomainToProject(project: string, domain: string): Promise<{
+    addDomainToProject(project: string, domain: string, opts?: {
+        force?: boolean;
+    }): Promise<{
         alreadyAdded: boolean;
         raw?: unknown;
     }>;
+    findProjectDomainOwner(domain: string): Promise<VercelProjectDomainOwner | undefined>;
     getDomainConfig(domain: string): Promise<Record<string, unknown>>;
     getRecommendedCname(domain: string): Promise<string>;
     getProjectDomain(project: string, domain: string): Promise<Record<string, unknown>>;
+    listProjectDomains(project: string): Promise<Array<Record<string, unknown> & {
+        name?: string;
+        projectId?: string;
+    }>>;
+    removeDomainFromProject(project: string, domain: string): Promise<void>;
     verifyProjectDomain(project: string, domain: string): Promise<Record<string, unknown>>;
 };
 export type VercelClient = ReturnType<typeof createVercelClient>;
+export {};

package/dist/lib/vercel.js

@@ -21,12 +21,23 @@ function appendTeam(path, teamId) {
 function apiErrorMessage(status, body) {
     return body?.error?.message ?? `Vercel API error (${status}).`;
 }
-function isAlreadyAddedError(error) {
+function isDomainConflictError(error) {
     if (!(error instanceof DoomainError))
         return false;
     const details = error.details;
     const text = `${error.message} ${details?.error?.code ?? ''}`.toLowerCase();
-    return text.includes('already') || text.includes('conflict') || text.includes('domain_already');
+    return (text.includes('already') ||
+        text.includes('conflict') ||
+        text.includes('domain_already') ||
+        text.includes('already assigned') ||
+        text.includes('already in use'));
+}
+function isSameDomain(value, domain) {
+    return typeof value === 'string' && value.toLowerCase() === domain.toLowerCase();
+}
+function findAliasTarget(raw, domain) {
+    const targets = Array.isArray(raw) ? raw : [raw];
+    return targets.find((target) => target && typeof target === 'object' && isSameDomain(target.domain, domain));
 }
 export function createVercelClient(config) {
     async function request(path, init = {}, opts = {}) {
@@ -99,20 +110,44 @@ export function createVercelClient(config) {
             }
             return [...projectsById.values()].sort((a, b) => a.name.localeCompare(b.name));
         },
-        async addDomainToProject(project, domain) {
+        async addDomainToProject(project, domain, opts = {}) {
             try {
-                const raw = await request(`/v10/projects/${encodeURIComponent(project)}/domains`, {
+                const raw = await request(`/projects/${encodeURIComponent(project)}/alias`, {
                     method: 'POST',
-                    body: JSON.stringify({ name: domain }),
+                    body: JSON.stringify({ domain, target: 'PRODUCTION' }),
                 });
-                return { alreadyAdded: false, raw };
+                const aliasTarget = findAliasTarget(raw, domain);
+                if (!aliasTarget) {
+                    throw new DoomainError('DOMAIN_LINK_FAILED', `Vercel did not return ${domain} after adding it to project ${project}.`, raw);
+                }
+                return { alreadyAdded: false, raw: aliasTarget };
             }
             catch (error) {
-                if (isAlreadyAddedError(error))
-                    return { alreadyAdded: true, raw: error };
+                if (isDomainConflictError(error)) {
+                    const projectDomain = await this.getProjectDomain(project, domain).catch(() => undefined);
+                    if (projectDomain)
+                        return { alreadyAdded: true, raw: projectDomain };
+                    if (opts.force) {
+                        const owner = await this.findProjectDomainOwner(domain);
+                        if (owner && owner.project.id !== project) {
+                            await this.removeDomainFromProject(owner.project.id, domain);
+                            return this.addDomainToProject(project, domain);
+                        }
+                    }
+                    throw new DoomainError('DOMAIN_ALREADY_ASSIGNED', `Vercel reports ${domain} is already assigned to another project. Re-run with --force if you intend to move it to ${project}.`, error instanceof DoomainError ? error.details : undefined);
+                }
                 throw error;
             }
         },
+        async findProjectDomainOwner(domain) {
+            for (const project of await this.listProjects()) {
+                const domains = await this.listProjectDomains(project.id).catch(() => []);
+                const match = domains.find((item) => isSameDomain(item.name, domain));
+                if (match)
+                    return { domain: match, project };
+            }
+            return undefined;
+        },
         async getDomainConfig(domain) {
             return request(`/v6/domains/${encodeURIComponent(domain)}/config`);
         },
@@ -124,6 +159,13 @@ export function createVercelClient(config) {
         async getProjectDomain(project, domain) {
             return request(`/v9/projects/${encodeURIComponent(project)}/domains/${encodeURIComponent(domain)}`);
         },
+        async listProjectDomains(project) {
+            const result = await request(`/v9/projects/${encodeURIComponent(project)}/domains`);
+            return result.domains ?? [];
+        },
+        async removeDomainFromProject(project, domain) {
+            await request(`/projects/${encodeURIComponent(project)}/alias?domain=${encodeURIComponent(domain)}`, { method: 'DELETE' });
+        },
         async verifyProjectDomain(project, domain) {
             return request(`/v9/projects/${encodeURIComponent(project)}/domains/${encodeURIComponent(domain)}/verify`, { method: 'POST' });
         },

package/oclif.manifest.json

@@ -37,7 +37,7 @@
           "type": "boolean"
         },
         "force": {
-          "description": "Overwrite conflicting DNS records.",
+          "description": "Move existing Vercel aliases and overwrite conflicting DNS records.",
           "name": "force",
           "allowNo": false,
           "type": "boolean"
@@ -629,5 +629,5 @@
       ]
     }
   },
-  "version": "0.1.0"
+  "version": "0.1.1"
 }

package/package.json

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