@ascendkit/cli 0.2.0 → 0.3.0

package/dist/commands/auth.d.ts

@@ -13,5 +13,9 @@ export declare function getSettings(client: AscendKitClient): Promise<unknown>;
 export declare function updateSettings(client: AscendKitClient, params: UpdateSettingsParams): Promise<unknown>;
 export declare function updateProviders(client: AscendKitClient, providers: string[]): Promise<unknown>;
 export declare function updateOAuthCredentials(client: AscendKitClient, provider: string, clientId: string, clientSecret: string, callbackUrl?: string): Promise<unknown>;
+export declare function deleteOAuthCredentials(client: AscendKitClient, provider: string): Promise<unknown>;
 export declare function getOAuthSetupUrl(portalUrl: string, provider: string, publicKey?: string): string;
 export declare function listUsers(client: AscendKitClient): Promise<unknown>;
+export declare function deleteUser(client: AscendKitClient, userId: string): Promise<unknown>;
+export declare function bulkDeleteUsers(client: AscendKitClient, userIds: string[]): Promise<unknown>;
+export declare function reactivateUser(client: AscendKitClient, userId: string): Promise<unknown>;

package/dist/commands/auth.js

@@ -20,6 +20,9 @@ export async function updateOAuthCredentials(client, provider, clientId, clientS
         body.callbackUrl = callbackUrl;
     return client.managedPut(`/api/auth/settings/oauth/${provider}`, body);
 }
+export async function deleteOAuthCredentials(client, provider) {
+    return client.managedDelete(`/api/auth/settings/oauth/${provider}`);
+}
 export function getOAuthSetupUrl(portalUrl, provider, publicKey) {
     const base = `${portalUrl}/settings/oauth/${provider}`;
     return publicKey ? `${base}?pk=${encodeURIComponent(publicKey)}` : base;
@@ -27,3 +30,12 @@ export function getOAuthSetupUrl(portalUrl, provider, publicKey) {
 export async function listUsers(client) {
     return client.managedRequest("GET", "/api/users");
 }
+export async function deleteUser(client, userId) {
+    return client.managedDelete(`/api/users/${userId}`);
+}
+export async function bulkDeleteUsers(client, userIds) {
+    return client.managedPost("/api/users/bulk-deactivate", { userIds });
+}
+export async function reactivateUser(client, userId) {
+    return client.managedPost(`/api/users/${userId}/reactivate`);
+}

package/dist/commands/campaigns.d.ts

@@ -0,0 +1,22 @@
+import { AscendKitClient } from "../api/client.js";
+export interface CreateCampaignParams {
+    name: string;
+    templateId: string;
+    audienceFilter: Record<string, unknown>;
+    scheduledAt?: string;
+    fromIdentityEmail?: string;
+}
+export interface UpdateCampaignParams {
+    name?: string;
+    templateId?: string;
+    audienceFilter?: Record<string, unknown>;
+    scheduledAt?: string;
+    fromIdentityEmail?: string;
+}
+export declare function createCampaign(client: AscendKitClient, params: CreateCampaignParams): Promise<unknown>;
+export declare function listCampaigns(client: AscendKitClient, status?: string, limit?: number): Promise<unknown>;
+export declare function getCampaign(client: AscendKitClient, campaignId: string): Promise<unknown>;
+export declare function updateCampaign(client: AscendKitClient, campaignId: string, params: UpdateCampaignParams): Promise<unknown>;
+export declare function deleteCampaign(client: AscendKitClient, campaignId: string): Promise<unknown>;
+export declare function previewAudience(client: AscendKitClient, audienceFilter: Record<string, unknown>): Promise<unknown>;
+export declare function getCampaignAnalytics(client: AscendKitClient, campaignId: string): Promise<unknown>;

package/dist/commands/campaigns.js

@@ -0,0 +1,25 @@
+export async function createCampaign(client, params) {
+    return client.managedPost("/api/v1/campaigns", params);
+}
+export async function listCampaigns(client, status, limit = 200) {
+    const params = new URLSearchParams();
+    if (status)
+        params.set("status", status);
+    params.set("limit", String(limit));
+    return client.managedGet(`/api/v1/campaigns?${params.toString()}`);
+}
+export async function getCampaign(client, campaignId) {
+    return client.managedGet(`/api/v1/campaigns/${campaignId}`);
+}
+export async function updateCampaign(client, campaignId, params) {
+    return client.managedPut(`/api/v1/campaigns/${campaignId}`, params);
+}
+export async function deleteCampaign(client, campaignId) {
+    return client.managedDelete(`/api/v1/campaigns/${campaignId}`);
+}
+export async function previewAudience(client, audienceFilter) {
+    return client.managedPost("/api/v1/campaigns/preview", { audienceFilter });
+}
+export async function getCampaignAnalytics(client, campaignId) {
+    return client.managedGet(`/api/v1/campaigns/${campaignId}/analytics`);
+}

package/dist/commands/content.js

@@ -9,10 +9,10 @@ export async function listTemplates(client, params) {
         searchParams.set("isSystem", String(params.isSystem));
     const qs = searchParams.toString();
     const path = qs ? `/api/content/templates?${qs}` : "/api/content/templates";
-    return client.get(path);
+    return client.managedGet(path);
 }
 export async function getTemplate(client, templateId) {
-    return client.get(`/api/content/templates/${templateId}`);
+    return client.managedGet(`/api/content/templates/${templateId}`);
 }
 export async function updateTemplate(client, templateId, params) {
     return client.managedPut(`/api/content/templates/${templateId}`, params);
@@ -21,8 +21,8 @@ export async function deleteTemplate(client, templateId) {
     return client.managedDelete(`/api/content/templates/${templateId}`);
 }
 export async function listVersions(client, templateId) {
-    return client.get(`/api/content/templates/${templateId}/versions`);
+    return client.managedGet(`/api/content/templates/${templateId}/versions`);
 }
 export async function getVersion(client, templateId, versionNumber) {
-    return client.get(`/api/content/templates/${templateId}/versions/${versionNumber}`);
+    return client.managedGet(`/api/content/templates/${templateId}/versions/${versionNumber}`);
 }

package/dist/commands/email.d.ts

@@ -23,15 +23,71 @@ export interface EmailSettings {
         value: string;
     }>;
     dnsProvider?: DnsProviderInfo;
+    identities?: EmailIdentity[];
+}
+export interface EmailIdentity {
+    email: string;
+    displayName: string;
+    verificationStatus: string;
+    isDefault: boolean;
+}
+export interface EmailIdentitiesResponse {
+    identities: EmailIdentity[];
+    active?: {
+        fromEmail?: string;
+        fromName?: string;
+    };
+}
+export interface DnsCheckRecord {
+    name: string;
+    type: string;
+    expectedValue: string;
+    found: boolean;
+    observedValue: string | null;
+    mismatch: boolean;
+    error: string | null;
+    checkedAt: string;
+}
+export interface DnsCheckResponse {
+    summary: {
+        total: number;
+        found: number;
+        notFound: number;
+        mismatch: number;
+        errored: number;
+    };
+    records: DnsCheckRecord[];
 }
 export declare function getSettings(client: AscendKitClient): Promise<EmailSettings>;
 export declare function updateSettings(client: AscendKitClient, params: UpdateEmailSettingsParams): Promise<EmailSettings>;
 export declare function setupDomain(client: AscendKitClient, domain: string): Promise<EmailSettings>;
-export declare function checkDomainStatus(client: AscendKitClient): Promise<unknown>;
+export declare function checkDomainStatus(client: AscendKitClient): Promise<{
+    domain?: string;
+    status?: string;
+    dnsRecords?: Array<{
+        type: string;
+        name: string;
+        value: string;
+    }>;
+    dnsProvider?: DnsProviderInfo;
+}>;
+export declare function checkDnsRecords(client: AscendKitClient): Promise<DnsCheckResponse>;
 export declare function getDnsProvider(client: AscendKitClient, domain?: string): Promise<DnsProviderInfo>;
 export declare function removeDomain(client: AscendKitClient): Promise<EmailSettings>;
-export declare function useDefaultIdentity(client: AscendKitClient): Promise<EmailSettings>;
-export declare function useCustomIdentity(client: AscendKitClient, domain: string, options?: {
-    fromEmail?: string;
-    fromName?: string;
-}): Promise<EmailSettings>;
+export declare function listIdentities(client: AscendKitClient): Promise<EmailIdentitiesResponse>;
+export declare function createIdentity(client: AscendKitClient, identity: {
+    email: string;
+    displayName?: string;
+}): Promise<EmailIdentitiesResponse>;
+export declare function resendIdentityVerification(client: AscendKitClient, email: string): Promise<EmailIdentitiesResponse>;
+export declare function setDefaultIdentity(client: AscendKitClient, identity: {
+    email: string;
+    displayName?: string;
+}): Promise<EmailIdentitiesResponse>;
+export declare function removeIdentity(client: AscendKitClient, email: string): Promise<EmailIdentitiesResponse>;
+export declare function sendTestEmail(client: AscendKitClient, request: {
+    to: string;
+    fromIdentityEmail?: string;
+}): Promise<{
+    message: string;
+}>;

package/dist/commands/email.js

@@ -1,5 +1,5 @@
 export async function getSettings(client) {
-    return client.get("/api/email/settings");
+    return client.managedGet("/api/email/settings");
 }
 export async function updateSettings(client, params) {
     const body = {};
@@ -13,27 +13,36 @@ export async function setupDomain(client, domain) {
     return client.managedPost("/api/email/settings/setup-domain", { domain });
 }
 export async function checkDomainStatus(client) {
-    return client.get("/api/email/settings/domain-status");
+    return client.managedGet("/api/email/settings/domain-status");
+}
+export async function checkDnsRecords(client) {
+    return client.managedGet("/api/email/settings/check-dns-records");
 }
 export async function getDnsProvider(client, domain) {
     const suffix = domain ? `?domain=${encodeURIComponent(domain)}` : "";
-    return client.get(`/api/email/settings/dns-provider${suffix}`);
+    return client.managedGet(`/api/email/settings/dns-provider${suffix}`);
 }
 export async function removeDomain(client) {
     return client.managedDelete("/api/email/settings/domain");
 }
-export async function useDefaultIdentity(client) {
-    await removeDomain(client);
-    return updateSettings(client, { fromEmail: "", fromName: "" });
-}
-export async function useCustomIdentity(client, domain, options) {
-    const configured = await setupDomain(client, domain);
-    if (options?.fromEmail !== undefined || options?.fromName !== undefined) {
-        await updateSettings(client, {
-            fromEmail: options.fromEmail,
-            fromName: options.fromName,
-        });
-        return getSettings(client);
-    }
-    return configured;
+export async function listIdentities(client) {
+    return client.managedGet("/api/email/settings/identities");
+}
+export async function createIdentity(client, identity) {
+    return client.managedPost("/api/email/settings/identities", {
+        email: identity.email,
+        displayName: identity.displayName ?? "",
+    });
+}
+export async function resendIdentityVerification(client, email) {
+    return client.managedPost(`/api/email/settings/identities/${encodeURIComponent(email)}/resend`, {});
+}
+export async function setDefaultIdentity(client, identity) {
+    return client.managedPost(`/api/email/settings/identities/${encodeURIComponent(identity.email)}/default`, { displayName: identity.displayName ?? "" });
+}
+export async function removeIdentity(client, email) {
+    return client.managedDelete(`/api/email/settings/identities/${encodeURIComponent(email)}`);
+}
+export async function sendTestEmail(client, request) {
+    return client.managedPost("/api/email/settings/send-test", request);
 }

package/dist/commands/import.d.ts

@@ -0,0 +1,75 @@
+import { AscendKitClient } from "../api/client.js";
+export interface ImportUserRecord {
+    sourceId: string;
+    email: string;
+    name?: string;
+    image?: string;
+    emailVerified?: boolean;
+    hadPassword?: boolean;
+    oauthProviders?: Array<{
+        providerId: string;
+        accountId: string;
+    }>;
+    metadata?: Record<string, unknown>;
+    tags?: string[];
+    createdAt?: string;
+    lastLoginAt?: string;
+}
+export interface ImportUsersPayload {
+    source: string;
+    users: ImportUserRecord[];
+    authSettings?: {
+        enabledProviders?: string[];
+        oauthClientIds?: Record<string, string>;
+    };
+    dryRun?: boolean;
+}
+export interface ImportResult {
+    imported: number;
+    duplicates: Array<{
+        email: string;
+        sourceId: string;
+    }>;
+    errors: Array<{
+        email: string;
+        sourceId: string;
+        reason: string;
+    }>;
+    warnings: string[];
+}
+export declare function importUsers(client: AscendKitClient, payload: ImportUsersPayload): Promise<ImportResult>;
+export declare function instantiateMigrationJourney(client: AscendKitClient, fromIdentityEmail?: string): Promise<unknown>;
+interface ClerkUser {
+    id: string;
+    email_addresses?: Array<{
+        id: string;
+        email_address: string;
+        verification?: {
+            status: string;
+        };
+    }>;
+    primary_email_address_id?: string;
+    first_name?: string;
+    last_name?: string;
+    image_url?: string;
+    password_enabled?: boolean;
+    external_accounts?: Array<{
+        id: string;
+        provider: string;
+        provider_user_id: string;
+    }>;
+    public_metadata?: Record<string, unknown>;
+    private_metadata?: Record<string, unknown>;
+    created_at?: number;
+    last_sign_in_at?: number;
+    last_active_at?: number;
+}
+export declare function transformClerkUser(clerk: ClerkUser): ImportUserRecord;
+export declare function fetchClerkUsers(apiKey: string, instanceUrl?: string): Promise<ClerkUser[]>;
+export interface ClerkDerivedSettings {
+    hasCredentials: boolean;
+    providers: string[];
+}
+export declare function deriveSettingsFromUsers(users: ImportUserRecord[]): ClerkDerivedSettings;
+export declare function parseClerkExport(filePath: string): ClerkUser[];
+export {};

package/dist/commands/import.js

@@ -0,0 +1,97 @@
+import { readFileSync } from "fs";
+export async function importUsers(client, payload) {
+    return client.managedPost("/api/import/users", payload);
+}
+export async function instantiateMigrationJourney(client, fromIdentityEmail) {
+    return client.managedPost("/api/import/instantiate-migration-journey", {
+        fromIdentityEmail: fromIdentityEmail ?? null,
+    });
+}
+function clerkProviderToAscendKit(provider) {
+    const map = {
+        oauth_google: "google",
+        oauth_github: "github",
+        oauth_linkedin: "linkedin",
+        oauth_linkedin_oidc: "linkedin",
+    };
+    return map[provider] ?? provider.replace(/^oauth_/, "");
+}
+export function transformClerkUser(clerk) {
+    const primaryEmail = clerk.email_addresses?.find((e) => e.id === clerk.primary_email_address_id);
+    const email = primaryEmail?.email_address ?? clerk.email_addresses?.[0]?.email_address ?? "";
+    const emailVerified = primaryEmail?.verification?.status === "verified";
+    const name = [clerk.first_name, clerk.last_name].filter(Boolean).join(" ") || undefined;
+    const oauthProviders = (clerk.external_accounts ?? []).map((ext) => ({
+        providerId: clerkProviderToAscendKit(ext.provider),
+        accountId: ext.provider_user_id,
+    }));
+    // Clerk timestamps are Unix ms
+    const createdAt = clerk.created_at
+        ? new Date(clerk.created_at).toISOString()
+        : undefined;
+    const lastLoginAt = clerk.last_sign_in_at
+        ? new Date(clerk.last_sign_in_at).toISOString()
+        : undefined;
+    return {
+        sourceId: clerk.id,
+        email,
+        name,
+        image: clerk.image_url || undefined,
+        emailVerified,
+        hadPassword: clerk.password_enabled ?? false,
+        oauthProviders,
+        metadata: clerk.public_metadata ?? undefined,
+        createdAt,
+        lastLoginAt,
+    };
+}
+export async function fetchClerkUsers(apiKey, instanceUrl) {
+    const baseUrl = instanceUrl ?? "https://api.clerk.com";
+    const allUsers = [];
+    let offset = 0;
+    const limit = 100;
+    while (true) {
+        const url = `${baseUrl}/v1/users?limit=${limit}&offset=${offset}`;
+        const response = await fetch(url, {
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`Clerk API error ${response.status}: ${text}`);
+        }
+        const users = (await response.json());
+        if (users.length === 0)
+            break;
+        allUsers.push(...users);
+        offset += users.length;
+        if (users.length < limit)
+            break;
+    }
+    return allUsers;
+}
+export function deriveSettingsFromUsers(users) {
+    let hasCredentials = false;
+    const providers = new Set();
+    for (const u of users) {
+        if (u.hadPassword)
+            hasCredentials = true;
+        for (const p of u.oauthProviders ?? []) {
+            providers.add(p.providerId);
+        }
+    }
+    return { hasCredentials, providers: [...providers].sort() };
+}
+export function parseClerkExport(filePath) {
+    const raw = readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed)) {
+        return parsed;
+    }
+    if (parsed.users && Array.isArray(parsed.users)) {
+        return parsed.users;
+    }
+    throw new Error("Unrecognized Clerk export format. Expected a JSON array of users or an object with a 'users' key.");
+}

package/dist/commands/journeys.d.ts

@@ -30,6 +30,7 @@ export declare function updateJourney(client: AscendKitClient, journeyId: string
 export declare function deleteJourney(client: AscendKitClient, journeyId: string): Promise<unknown>;
 export declare function activateJourney(client: AscendKitClient, journeyId: string): Promise<unknown>;
 export declare function pauseJourney(client: AscendKitClient, journeyId: string): Promise<unknown>;
+export declare function resumeJourney(client: AscendKitClient, journeyId: string): Promise<unknown>;
 export declare function archiveJourney(client: AscendKitClient, journeyId: string): Promise<unknown>;
 export declare function getJourneyAnalytics(client: AscendKitClient, journeyId: string): Promise<unknown>;
 export declare function getJourneyVisualization(client: AscendKitClient, journeyId: string): Promise<unknown>;
@@ -41,6 +42,7 @@ export interface AddNodeParams {
         surveySlug?: string;
         tagName?: string;
         stageName?: string;
+        fromIdentityEmail?: string;
     };
     terminal?: boolean;
 }
@@ -51,6 +53,7 @@ export interface EditNodeParams {
         surveySlug?: string;
         tagName?: string;
         stageName?: string;
+        fromIdentityEmail?: string;
     };
     terminal?: boolean;
 }

package/dist/commands/journeys.js

@@ -11,10 +11,10 @@ export async function listJourneys(client, opts) {
     if (opts?.offset != null)
         qs.set("offset", String(opts.offset));
     const query = qs.toString();
-    return client.get(`${BASE}${query ? `?${query}` : ""}`);
+    return client.managedGet(`${BASE}${query ? `?${query}` : ""}`);
 }
 export async function getJourney(client, journeyId) {
-    return client.get(`${BASE}/${journeyId}`);
+    return client.managedGet(`${BASE}/${journeyId}`);
 }
 export async function updateJourney(client, journeyId, params) {
     return client.managedRequest("PATCH", `${BASE}/${journeyId}`, params);
@@ -28,17 +28,20 @@ export async function activateJourney(client, journeyId) {
 export async function pauseJourney(client, journeyId) {
     return client.managedPost(`${BASE}/${journeyId}/pause`);
 }
+export async function resumeJourney(client, journeyId) {
+    return client.managedPost(`${BASE}/${journeyId}/resume`);
+}
 export async function archiveJourney(client, journeyId) {
     return client.managedPost(`${BASE}/${journeyId}/archive`);
 }
 export async function getJourneyAnalytics(client, journeyId) {
-    return client.get(`${BASE}/${journeyId}/analytics`);
+    return client.managedGet(`${BASE}/${journeyId}/analytics`);
 }
 export async function getJourneyVisualization(client, journeyId) {
-    return client.get(`${BASE}/${journeyId}/visualization`);
+    return client.managedGet(`${BASE}/${journeyId}/visualization`);
 }
 export async function listNodes(client, journeyId) {
-    return client.get(`${BASE}/${journeyId}/nodes`);
+    return client.managedGet(`${BASE}/${journeyId}/nodes`);
 }
 export async function addNode(client, journeyId, params) {
     return client.managedPost(`${BASE}/${journeyId}/nodes`, params);
@@ -56,7 +59,7 @@ export async function listTransitions(client, journeyId, opts) {
     if (opts?.to_node)
         qs.set("to_node", opts.to_node);
     const query = qs.toString();
-    return client.get(`${BASE}/${journeyId}/transitions${query ? `?${query}` : ""}`);
+    return client.managedGet(`${BASE}/${journeyId}/transitions${query ? `?${query}` : ""}`);
 }
 export async function addTransition(client, journeyId, params) {
     return client.managedPost(`${BASE}/${journeyId}/transitions`, params);

package/dist/commands/platform.d.ts

@@ -1,6 +1,7 @@
 export declare function init(apiUrl?: string, portalUrl?: string): Promise<void>;
 export declare function logout(): void;
 export declare function listProjects(): Promise<unknown>;
+export declare function showProject(projectId: string): Promise<Record<string, unknown>>;
 export declare function createProject(name: string, description?: string, enabledServices?: string[]): Promise<unknown>;
 export declare function listEnvironments(projectId: string): Promise<unknown>;
 export declare function useEnvironment(tier: string, projectId: string): Promise<void>;
@@ -30,6 +31,21 @@ export declare function mcpLogin(client: AscendKitClient, params: McpLoginParams
     };
     accountId: string;
 }>;
+export declare function mcpSetEnvironmentByPublicKey(client: AscendKitClient, publicKey: string): Promise<{
+    updatedFiles: string[];
+    environment: {
+        id: string;
+        name: string;
+        tier: string;
+        publicKey: string;
+        secretKey?: string | null;
+    };
+    project: {
+        id: string;
+        name: string;
+    };
+    role: string;
+}>;
 export declare function mcpListProjects(client: AscendKitClient): Promise<unknown>;
 export declare function mcpCreateProject(client: AscendKitClient, params: McpCreateProjectParams): Promise<unknown>;
 export declare function mcpListEnvironments(client: AscendKitClient, projectId: string): Promise<unknown>;
@@ -47,3 +63,15 @@ export declare function mcpPromoteEnvironment(client: AscendKitClient, params: {
     environmentId: string;
     targetTier: string;
 }): Promise<unknown>;
+export interface McpUpdateEnvironmentVariablesParams {
+    projectId?: string;
+    envId?: string;
+    variables: Record<string, string>;
+}
+export declare function mcpGetEnvironment(client: AscendKitClient, params: {
+    projectId?: string;
+    envId?: string;
+}): Promise<Record<string, unknown>>;
+export declare function mcpUpdateEnvironmentVariables(client: AscendKitClient, params: McpUpdateEnvironmentVariablesParams): Promise<unknown>;
+export declare function getEnvironment(projectId: string, envId: string): Promise<Record<string, unknown>>;
+export declare function updateEnvironmentVariables(projectId: string, envId: string, variables: Record<string, string>): Promise<unknown>;