doomain 0.1.23 → 0.1.24

package/dist/commands/wizard.js

@@ -1,6 +1,8 @@
 import * as p from '@clack/prompts';
 import { Command } from '@oclif/core';
+import { Effect } from 'effect';
 import { loadConfig, maskSecret, updateConfig } from '../lib/config.js';
+import { runDoomainEffect } from '../lib/effect.js';
 import { DoomainError } from '../lib/errors.js';
 import { jsonFlag } from '../lib/flags.js';
 import { createLinkPlan, linkDomain } from '../lib/link-domain.js';
@@ -8,6 +10,7 @@ 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 { fetchPublicIp } from '../lib/public-ip.js';
 import { createVercelClient } from '../lib/vercel.js';
 import { listGlobalVercelTokens } from '../lib/vercel-auth.js';
 const PERSONAL_ACCOUNT = '__personal__';
@@ -56,42 +59,28 @@ async function confirmProviderAccountOverwrite(definition, account) {
     const resolved = cancelIfNeeded(value);
     return resolved === true;
 }
-async function fetchPublicIp() {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 2000);
-    try {
-        const response = await fetch('https://api.ipify.org', { signal: controller.signal });
-        if (!response.ok)
-            return undefined;
-        const ip = (await response.text()).trim();
-        return ip || undefined;
-    }
-    catch {
-        return undefined;
-    }
-    finally {
-        clearTimeout(timeout);
-    }
-}
-async function credentialInitialValue(credential) {
+function credentialInitialValue(credential, detectedPublicIp) {
     if (credential.key !== 'clientIp')
         return undefined;
-    return fetchPublicIp();
+    return detectedPublicIp;
 }
-async function promptCredential(credential) {
-    const initialValue = credential.secret ? undefined : await credentialInitialValue(credential);
+function usesClientIp(definition) {
+    return definition.credentials.some((credential) => credential.key === 'clientIp');
+}
+async function promptCredential(credential, detectedPublicIp) {
+    const initialValue = credential.secret ? undefined : credentialInitialValue(credential, detectedPublicIp);
     const value = credential.secret
         ? await p.password({ message: credential.label })
         : await p.text({ message: credential.label, initialValue, placeholder: credential.placeholder ?? credential.hint });
     const resolved = cancelIfNeeded(value);
     return typeof resolved === 'string' && resolved.trim() ? resolved.trim() : null;
 }
-async function promptProviderCredentials(definition) {
+async function promptProviderCredentials(definition, detectedPublicIp) {
     const credentials = {};
     for (const credential of definition.credentials) {
         if (credential.required === false)
             continue;
-        const value = await promptCredential(credential);
+        const value = await promptCredential(credential, detectedPublicIp);
         if (!value)
             return null;
         credentials[credential.key] = value;
@@ -117,10 +106,15 @@ function showProviderSetup(definition) {
         return;
     p.note(definition.setup.notes.join('\n'), `${definition.displayName} setup`);
 }
-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, account, zone));
+function listProviderDomainOptions(definition, account) {
+    return Effect.gen(function* () {
+        const provider = yield* createProvider(definition.id, {
+            account: account.account,
+            transportErrorCode: 'DOMAIN_LINK_FAILED',
+        });
+        const zones = yield* provider.listZones();
+        return zones.map((zone) => toProviderDomainOption(definition, account, zone));
+    });
 }
 function toProviderDomainOption(definition, account, zone) {
     return {
@@ -211,7 +205,7 @@ export default class Wizard extends Command {
         }
         try {
             p.intro('Doomain');
-            const config = await loadConfig();
+            const config = await runDoomainEffect(loadConfig());
             const providerDefinitions = listProviderDefinitions();
             const localProject = detectLocalVercelProject();
             let vercelToken = config.vercel?.token;
@@ -220,7 +214,7 @@ export default class Wizard extends Command {
             const defaultDomain = process.env.DOOMAIN_DOMAIN || config.defaults?.domain;
             let globalVercelTokens = [];
             if (!vercelToken) {
-                globalVercelTokens = await listGlobalVercelTokens();
+                globalVercelTokens = await runDoomainEffect(listGlobalVercelTokens());
                 vercelToken = (await promptVercelToken(globalVercelTokens)) ?? undefined;
                 if (!vercelToken)
                     return;
@@ -235,7 +229,7 @@ export default class Wizard extends Command {
                     else {
                         activeSpinner = teamSpinner;
                         teamSpinner.start('Loading Vercel teams');
-                        teams = await createVercelClient({ token: vercelToken }).listTeams();
+                        teams = await runDoomainEffect(createVercelClient({ token: vercelToken }).listTeams());
                         teamSpinner.stop(`Loaded ${teams.length} Vercel team${teams.length === 1 ? '' : 's'}`);
                         activeSpinner = undefined;
                         const selected = await p.select({
@@ -260,7 +254,7 @@ export default class Wizard extends Command {
                     activeSpinner = undefined;
                     p.log.warning(error instanceof Error ? error.message : String(error));
                     if (globalVercelTokens.length === 0)
-                        globalVercelTokens = await listGlobalVercelTokens();
+                        globalVercelTokens = await runDoomainEffect(listGlobalVercelTokens());
                     globalVercelTokens = globalVercelTokens.filter((token) => token.token !== vercelToken);
                     vercelToken = (await promptVercelToken(globalVercelTokens)) ?? undefined;
                     if (!vercelToken)
@@ -275,7 +269,7 @@ export default class Wizard extends Command {
             const projectSpinner = p.spinner();
             activeSpinner = projectSpinner;
             projectSpinner.start('Loading Vercel projects');
-            const projects = await createVercelClient({ token: vercelToken, teamId: vercelTeamId }).listProjects();
+            const projects = await runDoomainEffect(createVercelClient({ token: vercelToken, teamId: vercelTeamId }).listProjects());
             projectSpinner.stop(`Loaded ${projects.length} projects`);
             activeSpinner = undefined;
             if (projects.length === 0) {
@@ -324,18 +318,23 @@ export default class Wizard extends Command {
                     isDefaultAccount: isDefaultProviderAccount(account),
                     providerId: selectedDefinition.id,
                 };
-                const credentials = await promptProviderCredentials(selectedDefinition);
+                const detectedPublicIp = usesClientIp(selectedDefinition) ? await runDoomainEffect(fetchPublicIp()) : undefined;
+                const credentials = await promptProviderCredentials(selectedDefinition, detectedPublicIp);
                 if (!credentials)
                     return;
                 const domainSpinner = p.spinner();
                 activeSpinner = domainSpinner;
                 domainSpinner.start(`Verifying ${selectedDefinition.displayName} credentials and loading domains`);
-                const provider = selectedDefinition.create({ credentials, debug: process.env.DOOMAIN_DEBUG === '1' });
-                const zones = await provider.listZones();
+                const provider = selectedDefinition.create({
+                    credentials,
+                    debug: process.env.DOOMAIN_DEBUG === '1',
+                    transportErrorCode: 'DOMAIN_LINK_FAILED',
+                });
+                const zones = await runDoomainEffect(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, providerAccount, zone)));
-                await updateConfig((current) => ({
+                await runDoomainEffect(updateConfig((current) => ({
                     ...current,
                     defaults: { ...current.defaults, provider: selectedDefinition.id },
                     providers: {
@@ -343,7 +342,7 @@ export default class Wizard extends Command {
                         [selectedDefinition.id]: withProviderAccountCredentials(current.providers?.[selectedDefinition.id], account, credentials),
                     },
                     vercel: { token: vercelToken, teamId: vercelTeamId },
-                }));
+                }), 'DOMAIN_LINK_FAILED'));
             }
             else {
                 const domainSpinner = p.spinner();
@@ -351,7 +350,7 @@ export default class Wizard extends Command {
                 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, account)));
+                        domainOptions.push(...(await runDoomainEffect(listProviderDomainOptions(definition, account))));
                     }
                     catch (error) {
                         const label = account.isDefaultAccount
@@ -364,10 +363,10 @@ export default class Wizard extends Command {
                 activeSpinner = undefined;
                 for (const failure of providerFailures)
                     p.log.warning(failure);
-                await updateConfig((current) => ({
+                await runDoomainEffect(updateConfig((current) => ({
                     ...current,
                     vercel: { token: vercelToken, teamId: vercelTeamId },
-                }));
+                }), 'DOMAIN_LINK_FAILED'));
             }
             if (domainOptions.length === 0) {
                 throw new DoomainError('CONFIG_NOT_FOUND', 'No domains found in configured DNS providers. Verify provider credentials and domain permissions.');
@@ -396,10 +395,10 @@ export default class Wizard extends Command {
             }
             p.log.info(`Using domain ${selectedDomain.domain} from ${providerAccountLabel(selectedDomain)}.`);
             const domain = selectedDomain.domain;
-            await updateConfig((current) => ({
+            await runDoomainEffect(updateConfig((current) => ({
                 ...current,
                 defaults: { ...current.defaults, domain, provider: selectedDomain.providerId },
-            }));
+            }), 'DOMAIN_LINK_FAILED'));
             const mode = await p.select({
                 message: 'What should Doomain add?',
                 options: [
@@ -418,14 +417,14 @@ export default class Wizard extends Command {
                     return;
             }
             const fullDomain = apex ? domain : `${subdomain}.${domain}`;
-            const preview = await createLinkPlan({
+            const preview = await runDoomainEffect(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))),
@@ -440,7 +439,7 @@ export default class Wizard extends Command {
             const spinner = p.spinner();
             activeSpinner = spinner;
             spinner.start('Adding domain to Vercel');
-            const result = await linkDomain({
+            const result = await runDoomainEffect(linkDomain({
                 account: selectedDomain.account,
                 provider: selectedDomain.providerId,
                 domain,
@@ -463,7 +462,7 @@ export default class Wizard extends Command {
                 },
                 progress: ({ message }) => spinner.message(message),
                 wait: true,
-            });
+            }));
             spinner.stop(result.vercel.verified ? 'Domain linked and verified' : 'Domain linked');
             activeSpinner = undefined;
             p.outro(result.vercel.verified

package/dist/index.d.ts

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

package/dist/index.js

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

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

@@ -1,4 +1,5 @@
 import { type ClerkDomainStatus } from './clerk.js';
+import { type DoomainEffect } from './effect.js';
 import { type DnsOverrideWarning } from './link-domain.js';
 import type { DnsRecordInput } from './providers/types.js';
 export interface AddClerkDomainInput {
@@ -36,4 +37,4 @@ export interface AddClerkDomainResult {
     zoneDomain: string;
     nextSteps: string[];
 }
-export declare function addClerkProductionDomain(input: AddClerkDomainInput): Promise<AddClerkDomainResult>;
+export declare function addClerkProductionDomain(input: AddClerkDomainInput): DoomainEffect<AddClerkDomainResult>;

package/dist/lib/clerk-domain.js

@@ -1,5 +1,7 @@
+import { Effect } from 'effect';
 import { createClerkPlatformClient, resolveClerkPlatformConfig } from './clerk.js';
 import { resolveProviderTarget } from './domain-provider.js';
+import { tryPromise, trySync } from './effect.js';
 import { DoomainError } from './errors.js';
 import { withProviderRecordOptions } from './link-domain.js';
 import { createProvider } from './providers/registry.js';
@@ -39,125 +41,135 @@ function dnsConflictError(warning, productionInstanceId) {
 function statusComplete(check) {
     return check?.required === false || check?.status === 'complete';
 }
-async function waitForStatus(client, app, domainId, timeoutSeconds, progress) {
-    await client.triggerDomainDnsCheck(app, domainId).catch((error) => {
-        const conflict = error instanceof DoomainError && JSON.stringify(error.details).toLowerCase().includes('conflict');
-        if (!conflict)
-            throw error;
+function waitForStatus(client, app, domainId, timeoutSeconds, progress) {
+    return Effect.gen(function* () {
+        const trigger = yield* client.triggerDomainDnsCheck(app, domainId).pipe(Effect.either);
+        if (trigger._tag === 'Left') {
+            const conflict = JSON.stringify(trigger.left.details).toLowerCase().includes('conflict');
+            if (!conflict)
+                return yield* Effect.fail(trigger.left);
+        }
+        const deadline = Date.now() + timeoutSeconds * 1000;
+        let status = { status: 'incomplete' };
+        let attempt = 1;
+        while (Date.now() <= deadline) {
+            progress?.(`Checking Clerk DNS, SSL, and email DNS status (attempt ${attempt})`);
+            status = yield* client.getDomainStatus(app, domainId);
+            if (status.status === 'complete')
+                return status;
+            attempt += 1;
+            if (Date.now() > deadline)
+                break;
+            yield* Effect.sleep(5000);
+        }
+        return status;
     });
-    const deadline = Date.now() + timeoutSeconds * 1000;
-    let status = { status: 'incomplete' };
-    let attempt = 1;
-    while (Date.now() <= deadline) {
-        progress?.(`Checking Clerk DNS, SSL, and email DNS status (attempt ${attempt})`);
-        status = await client.getDomainStatus(app, domainId);
-        if (status.status === 'complete')
-            return status;
-        attempt += 1;
-        if (Date.now() > deadline)
-            break;
-        await new Promise((resolve) => setTimeout(resolve, 5000));
-    }
-    return status;
 }
-export async function addClerkProductionDomain(input) {
-    const domain = normalizeDomain(input.domain ?? '');
-    const config = await resolveClerkPlatformConfig(input.app);
-    const client = createClerkPlatformClient(config);
-    input.progress?.('Checking Clerk application');
-    const application = await client.fetchApplication(config.appId);
-    const production = application.instances.find((instance) => instance.environment_type === 'production');
-    if (production)
-        throw productionExistsError(config.appId, production.instance_id);
-    const development = application.instances.find((instance) => instance.environment_type === 'development');
-    if (!development)
-        throw new DoomainError('PROJECT_NOT_FOUND', `Clerk application ${config.appId} does not have a development instance to clone.`);
-    input.progress?.('Finding the DNS provider and zone');
-    const resolved = await resolveProviderTarget({ account: input.account, domain, provider: input.provider });
-    const provider = await createProvider(resolved.provider, { account: resolved.account });
-    const zone = await provider.getZone(resolved.target.zoneDomain);
-    if (!zone)
-        throw new DoomainError('PROVIDER_ZONE_NOT_FOUND', `${provider.name} does not have a DNS zone for ${resolved.target.zoneDomain}.`);
-    const nextSteps = [
-        `clerk link --app ${config.appId}`,
-        `clerk env pull --app ${config.appId} --instance prod`,
-        'clerk deploy',
-        'clerk deploy status',
-    ];
-    if (input.dryRun) {
+export function addClerkProductionDomain(input) {
+    return Effect.gen(function* () {
+        const domain = yield* trySync(() => normalizeDomain(input.domain ?? ''), 'INVALID_INPUT');
+        const config = yield* resolveClerkPlatformConfig(input.app);
+        const client = createClerkPlatformClient(config);
+        input.progress?.('Checking Clerk application');
+        const application = yield* client.fetchApplication(config.appId);
+        const production = application.instances.find((instance) => instance.environment_type === 'production');
+        if (production)
+            return yield* Effect.fail(productionExistsError(config.appId, production.instance_id));
+        const development = application.instances.find((instance) => instance.environment_type === 'development');
+        if (!development)
+            return yield* Effect.fail(new DoomainError('PROJECT_NOT_FOUND', `Clerk application ${config.appId} does not have a development instance to clone.`));
+        input.progress?.('Finding the DNS provider and zone');
+        const resolved = yield* resolveProviderTarget({ account: input.account, domain, provider: input.provider }, { transportErrorCode: 'DOMAIN_LINK_FAILED' });
+        const provider = yield* createProvider(resolved.provider, {
+            account: resolved.account,
+            transportErrorCode: 'DOMAIN_LINK_FAILED',
+        });
+        const zone = yield* provider.getZone(resolved.target.zoneDomain);
+        if (!zone)
+            return yield* Effect.fail(new DoomainError('PROVIDER_ZONE_NOT_FOUND', `${provider.name} does not have a DNS zone for ${resolved.target.zoneDomain}.`));
+        const nextSteps = [
+            `clerk link --app ${config.appId}`,
+            `clerk env pull --app ${config.appId} --instance prod`,
+            'clerk deploy',
+            'clerk deploy status',
+        ];
+        if (input.dryRun) {
+            return {
+                account: resolved.account,
+                app: config.appId,
+                clerk: { productionInstanceCreated: false, verified: false },
+                dns: { propagated: false, skipped: [], updated: false },
+                domain,
+                dryRun: true,
+                isDefaultAccount: resolved.isDefaultAccount,
+                nextSteps,
+                provider: resolved.provider,
+                records: [],
+                zoneDomain: resolved.target.zoneDomain,
+            };
+        }
+        input.progress?.('Creating Clerk production instance and primary domain');
+        const created = yield* client.createProductionInstance(config.appId, domain, development.instance_id);
+        const clerkDomain = created.active_domain;
+        if (!clerkDomain) {
+            return yield* Effect.fail(new DoomainError('DOMAIN_LINK_FAILED', 'Clerk created the production instance but did not return its primary domain.', {
+                productionInstanceId: created.id,
+            }));
+        }
+        const records = yield* trySync(() => recordsFromTargets(resolved.provider, resolved.target.zoneDomain, clerkDomain.cname_targets ?? []), 'INVALID_INPUT');
+        if (records.length === 0) {
+            return yield* Effect.fail(new DoomainError('DOMAIN_LINK_FAILED', 'Clerk created the production instance but did not return any DNS records.', {
+                domainId: clerkDomain.id,
+                productionInstanceId: created.id,
+            }));
+        }
+        input.progress?.(`Checking existing DNS records in ${provider.name}`);
+        let forceDns = Boolean(input.force);
+        let dnsPlan = yield* provider.planChanges(zone, records, { force: forceDns });
+        if (!forceDns && dnsPlan.conflicts.length > 0) {
+            const warning = {
+                account: resolved.account,
+                conflicts: dnsPlan.conflicts,
+                desired: records,
+                domain,
+                provider: resolved.provider,
+                providerName: provider.name,
+                recordName: records[0]?.name ?? '@',
+                zoneDomain: resolved.target.zoneDomain,
+            };
+            forceDns = input.confirmDnsOverride
+                ? yield* tryPromise(() => input.confirmDnsOverride?.(warning) ?? Promise.resolve(false), 'DOMAIN_LINK_FAILED')
+                : false;
+            if (!forceDns)
+                return yield* Effect.fail(dnsConflictError(warning, created.id));
+            dnsPlan = yield* provider.planChanges(zone, records, { force: true });
+        }
+        input.progress?.(`Creating Clerk DNS records in ${provider.name}`);
+        const dnsResult = yield* provider.applyChanges(zone, dnsPlan, { force: forceDns });
+        const shouldWait = input.wait ?? true;
+        const status = shouldWait
+            ? yield* waitForStatus(client, config.appId, clerkDomain.id, input.timeoutSeconds ?? 300, input.progress)
+            : undefined;
+        const verified = status?.status === 'complete';
+        const propagated = Boolean(status && statusComplete(status.dns) && statusComplete(status.mail));
         return {
             account: resolved.account,
             app: config.appId,
-            clerk: { productionInstanceCreated: false, verified: false },
-            dns: { propagated: false, skipped: [], updated: false },
+            clerk: {
+                domainId: clerkDomain.id,
+                productionInstanceCreated: true,
+                productionInstanceId: created.id,
+                status,
+                verified,
+            },
+            dns: { propagated, skipped: dnsResult.skipped, updated: dnsResult.applied.length > 0 },
             domain,
-            dryRun: true,
+            dryRun: false,
             isDefaultAccount: resolved.isDefaultAccount,
             nextSteps,
             provider: resolved.provider,
-            records: [],
+            records,
             zoneDomain: resolved.target.zoneDomain,
         };
-    }
-    input.progress?.('Creating Clerk production instance and primary domain');
-    const created = await client.createProductionInstance(config.appId, domain, development.instance_id);
-    const clerkDomain = created.active_domain;
-    if (!clerkDomain) {
-        throw new DoomainError('DOMAIN_LINK_FAILED', 'Clerk created the production instance but did not return its primary domain.', {
-            productionInstanceId: created.id,
-        });
-    }
-    const records = recordsFromTargets(resolved.provider, resolved.target.zoneDomain, clerkDomain.cname_targets ?? []);
-    if (records.length === 0) {
-        throw new DoomainError('DOMAIN_LINK_FAILED', 'Clerk created the production instance but did not return any DNS records.', {
-            domainId: clerkDomain.id,
-            productionInstanceId: created.id,
-        });
-    }
-    input.progress?.(`Checking existing DNS records in ${provider.name}`);
-    let forceDns = Boolean(input.force);
-    let dnsPlan = await provider.planChanges(zone, records, { force: forceDns });
-    if (!forceDns && dnsPlan.conflicts.length > 0) {
-        const warning = {
-            account: resolved.account,
-            conflicts: dnsPlan.conflicts,
-            desired: records,
-            domain,
-            provider: resolved.provider,
-            providerName: provider.name,
-            recordName: records[0]?.name ?? '@',
-            zoneDomain: resolved.target.zoneDomain,
-        };
-        forceDns = (await input.confirmDnsOverride?.(warning)) === true;
-        if (!forceDns)
-            throw dnsConflictError(warning, created.id);
-        dnsPlan = await provider.planChanges(zone, records, { force: true });
-    }
-    input.progress?.(`Creating Clerk DNS records in ${provider.name}`);
-    const dnsResult = await provider.applyChanges(zone, dnsPlan, { force: forceDns });
-    const shouldWait = input.wait ?? true;
-    const status = shouldWait
-        ? await waitForStatus(client, config.appId, clerkDomain.id, input.timeoutSeconds ?? 300, input.progress)
-        : undefined;
-    const verified = status?.status === 'complete';
-    const propagated = Boolean(status && statusComplete(status.dns) && statusComplete(status.mail));
-    return {
-        account: resolved.account,
-        app: config.appId,
-        clerk: {
-            domainId: clerkDomain.id,
-            productionInstanceCreated: true,
-            productionInstanceId: created.id,
-            status,
-            verified,
-        },
-        dns: { propagated, skipped: dnsResult.skipped, updated: dnsResult.applied.length > 0 },
-        domain,
-        dryRun: false,
-        isDefaultAccount: resolved.isDefaultAccount,
-        nextSteps,
-        provider: resolved.provider,
-        records,
-        zoneDomain: resolved.target.zoneDomain,
-    };
+    });
 }

package/dist/lib/clerk.d.ts

@@ -1,3 +1,5 @@
+import type { DoomainEffect } from './effect.js';
+import { type DoomainErrorCode } from './errors.js';
 export interface ClerkPlatformConfig {
     appId: string;
     platformApiKey: string;
@@ -44,13 +46,15 @@ export interface ClerkDomainStatus {
     };
     status: string;
 }
-export declare function resolveClerkPlatformConfig(appId?: string): Promise<ClerkPlatformConfig>;
+export declare function resolveClerkPlatformConfig(appId?: string): DoomainEffect<ClerkPlatformConfig>;
 export declare function createClerkPlatformClient(config: {
     platformApiKey: string;
+}, opts?: {
+    transportErrorCode?: DoomainErrorCode;
 }): {
-    fetchApplication(appId: string): Promise<ClerkApplication>;
-    createProductionInstance(appId: string, domain: string, developmentInstanceId: string): Promise<ClerkProductionInstance>;
-    getDomainStatus(appId: string, domainId: string): Promise<ClerkDomainStatus>;
-    triggerDomainDnsCheck(appId: string, domainId: string): Promise<ClerkDomainStatus>;
+    fetchApplication(appId: string): DoomainEffect<ClerkApplication>;
+    createProductionInstance(appId: string, domain: string, developmentInstanceId: string): DoomainEffect<ClerkProductionInstance>;
+    getDomainStatus(appId: string, domainId: string): DoomainEffect<ClerkDomainStatus>;
+    triggerDomainDnsCheck(appId: string, domainId: string): DoomainEffect<ClerkDomainStatus>;
 };
 export type ClerkPlatformClient = ReturnType<typeof createClerkPlatformClient>;

package/dist/lib/clerk.js

@@ -1,20 +1,23 @@
+import { Effect } from 'effect';
 import { loadConfig } from './config.js';
-import { DoomainError } from './errors.js';
+import { DoomainError, toDoomainError } from './errors.js';
 const CLERK_API_URL = 'https://api.clerk.com';
-export async function resolveClerkPlatformConfig(appId) {
-    const config = await loadConfig();
-    const platformApiKey = process.env.CLERK_PLATFORM_API_KEY || config.clerk?.platformApiKey;
-    const resolvedAppId = appId || process.env.CLERK_APPLICATION_ID || config.clerk?.appId;
-    if (!platformApiKey) {
-        throw new DoomainError('MISSING_CREDENTIALS', 'Missing Clerk Platform API key. Run `doomain auth clerk`, set CLERK_PLATFORM_API_KEY, or pass saved credentials.');
-    }
-    if (!platformApiKey.startsWith('ak_')) {
-        throw new DoomainError('INVALID_INPUT', 'Clerk Platform API keys must start with ak_.');
-    }
-    if (!resolvedAppId) {
-        throw new DoomainError('MISSING_ARGUMENT', 'Clerk application is required. Pass --app, set CLERK_APPLICATION_ID, or save it with `doomain auth clerk`.');
-    }
-    return { appId: resolvedAppId, platformApiKey };
+export function resolveClerkPlatformConfig(appId) {
+    return Effect.gen(function* () {
+        const config = yield* loadConfig();
+        const platformApiKey = process.env.CLERK_PLATFORM_API_KEY || config.clerk?.platformApiKey;
+        const resolvedAppId = appId || process.env.CLERK_APPLICATION_ID || config.clerk?.appId;
+        if (!platformApiKey) {
+            return yield* Effect.fail(new DoomainError('MISSING_CREDENTIALS', 'Missing Clerk Platform API key. Run `doomain auth clerk`, set CLERK_PLATFORM_API_KEY, or pass saved credentials.'));
+        }
+        if (!platformApiKey.startsWith('ak_')) {
+            return yield* Effect.fail(new DoomainError('INVALID_INPUT', 'Clerk Platform API keys must start with ak_.'));
+        }
+        if (!resolvedAppId) {
+            return yield* Effect.fail(new DoomainError('MISSING_ARGUMENT', 'Clerk application is required. Pass --app, set CLERK_APPLICATION_ID, or save it with `doomain auth clerk`.'));
+        }
+        return { appId: resolvedAppId, platformApiKey };
+    });
 }
 function apiErrorMessage(status, body) {
     return (body?.errors?.[0]?.long_message ??
@@ -26,28 +29,34 @@ function apiErrorMessage(status, body) {
 function apiErrorCode(body) {
     return body?.errors?.[0]?.code ?? body?.error?.code ?? body?.code;
 }
-export function createClerkPlatformClient(config) {
-    async function request(path, init = {}) {
-        const response = await fetch(`${CLERK_API_URL}${path}`, {
-            ...init,
-            headers: {
-                Accept: 'application/json',
-                Authorization: `Bearer ${config.platformApiKey}`,
-                ...(init.body ? { 'Content-Type': 'application/json' } : {}),
-                ...(init.headers ?? {}),
-            },
-        });
-        if (!response.ok) {
-            const body = (await response.json().catch(() => undefined));
-            if (response.status === 401 || response.status === 403) {
-                throw new DoomainError('CLERK_AUTH_FAILED', `Clerk Platform API authorization failed. Check CLERK_PLATFORM_API_KEY and its application access. ${apiErrorMessage(response.status, body)}`, body);
-            }
-            if (response.status === 409 && apiErrorCode(body) === 'production_instance_exists') {
-                throw new DoomainError('CLERK_PRODUCTION_EXISTS', 'This Clerk application already has a production instance. Configure domain changes manually in Clerk; Doomain will not modify it.', body);
+export function createClerkPlatformClient(config, opts = {}) {
+    function request(path, init = {}) {
+        return Effect.gen(function* () {
+            const response = yield* Effect.tryPromise({
+                try: (signal) => fetch(`${CLERK_API_URL}${path}`, {
+                    ...init,
+                    headers: {
+                        Accept: 'application/json',
+                        Authorization: `Bearer ${config.platformApiKey}`,
+                        ...(init.body ? { 'Content-Type': 'application/json' } : {}),
+                        ...(init.headers ?? {}),
+                    },
+                    signal: init.signal ?? signal,
+                }),
+                catch: (cause) => toDoomainError(cause, opts.transportErrorCode ?? 'DOMAIN_LINK_FAILED'),
+            });
+            if (!response.ok) {
+                const body = yield* Effect.tryPromise(() => response.json()).pipe(Effect.catchAll(() => Effect.succeed(undefined)));
+                if (response.status === 401 || response.status === 403) {
+                    return yield* Effect.fail(new DoomainError('CLERK_AUTH_FAILED', `Clerk Platform API authorization failed. Check CLERK_PLATFORM_API_KEY and its application access. ${apiErrorMessage(response.status, body)}`, body));
+                }
+                if (response.status === 409 && apiErrorCode(body) === 'production_instance_exists') {
+                    return yield* Effect.fail(new DoomainError('CLERK_PRODUCTION_EXISTS', 'This Clerk application already has a production instance. Configure domain changes manually in Clerk; Doomain will not modify it.', body));
+                }
+                return yield* Effect.fail(new DoomainError('DOMAIN_LINK_FAILED', apiErrorMessage(response.status, body), body));
             }
-            throw new DoomainError('DOMAIN_LINK_FAILED', apiErrorMessage(response.status, body), body);
-        }
-        return (await response.json());
+            return (yield* Effect.tryPromise(() => response.json()).pipe(Effect.mapError((cause) => toDoomainError(cause, opts.transportErrorCode ?? 'DOMAIN_LINK_FAILED'))));
+        });
     }
     return {
         fetchApplication(appId) {