@ascendkit/cli 0.2.0 → 0.2.6

package/dist/api/client.d.ts

@@ -32,6 +32,7 @@ export declare class AscendKitClient {
     delete<T = unknown>(path: string): Promise<T>;
     /** Write operation requiring both public key and platform auth. */
     managedRequest<T = unknown>(method: string, path: string, body?: unknown): Promise<T>;
+    managedGet<T = unknown>(path: string): Promise<T>;
     managedPut<T = unknown>(path: string, body?: unknown): Promise<T>;
     managedPost<T = unknown>(path: string, body?: unknown): Promise<T>;
     managedDelete<T = unknown>(path: string): Promise<T>;

package/dist/api/client.js

@@ -179,6 +179,9 @@ export class AscendKitClient {
         const json = (await response.json());
         return json.data;
     }
+    managedGet(path) {
+        return this.managedRequest("GET", path);
+    }
     managedPut(path, body) {
         return this.managedRequest("PUT", path, body);
     }

package/dist/cli.js

@@ -11,6 +11,8 @@ import * as platform from "./commands/platform.js";
 import * as journeys from "./commands/journeys.js";
 import * as email from "./commands/email.js";
 import * as webhooks from "./commands/webhooks.js";
+import * as campaigns from "./commands/campaigns.js";
+import * as importCmd from "./commands/import.js";
 import { parseDelay } from "./utils/duration.js";
 const require = createRequire(import.meta.url);
 const { version: CLI_VERSION } = require("../package.json");
@@ -32,6 +34,8 @@ Services:
   journey          Lifecycle journeys, nodes, transitions
   email            Email settings, domain verification, DNS
   webhook          Webhook endpoints and testing
+  campaign         Email campaigns, scheduling, analytics
+  import           Import users from external auth providers
 
 Project Management:
   projects         List and create projects
@@ -89,8 +93,8 @@ Commands:
   journey archive <journey-id>
   journey analytics <journey-id>
   journey list-nodes <journey-id>
-  journey add-node <journey-id> --name <node-name> [--action <json>] [--terminal <true|false>]
-  journey edit-node <journey-id> <node-name> [--action <json>] [--terminal <true|false>]
+  journey add-node <journey-id> --name <node-name> [--action <json>] [--email-id <email>] [--terminal <true|false>]
+  journey edit-node <journey-id> <node-name> [--action <json>] [--email-id <email>] [--terminal <true|false>]
   journey remove-node <journey-id> <node-name>
   journey list-transitions <journey-id> [--from <node-name>] [--to <node-name>]
   journey add-transition <journey-id> --from <node-name> --to <node-name> --trigger <json> [--priority <n>] [--name <transition-name>]
@@ -117,13 +121,54 @@ Commands:
   webhook update <webhook-id> [--url <url>] [--events <e1,e2,...>] [--status <active|inactive>]
   webhook delete <webhook-id>
   webhook test <webhook-id> [--event <event-type>]`,
+    campaign: `Usage: ascendkit campaign <command>
+
+Commands:
+  campaign create --name <name> --template <template-id> --audience <json> [--scheduled-at <datetime>]
+  campaign list [--status <draft|scheduled|sending|sent|failed|cancelled>]
+  campaign show <campaign-id>
+  campaign update <campaign-id> [--name <name>] [--template <template-id>] [--audience <json>] [--scheduled-at <datetime>]
+  campaign preview <campaign-id>
+  campaign schedule <campaign-id> --at <datetime>
+  campaign cancel <campaign-id>
+  campaign analytics <campaign-id>
+
+Notes:
+  - --audience is a JSON filter object, e.g. '{"tags":{"$in":["premium"]}}'
+  - --scheduled-at / --at accepts ISO 8601 datetime, e.g. 2026-03-15T10:00:00Z
+  - cancel deletes a draft/failed campaign or cancels a scheduled/sending campaign`,
     env: `Usage: ascendkit env <command>
 
 Commands:
   env list --project <project-id>
   env use <tier> --project <project-id>
   env update <env-id> --project <project-id> [--name <name>] [--description <desc>]
-  env promote <env-id> --target <tier>`,
+  env promote <env-id> --target <tier>
+  env set-var <key> <value>
+  env unset-var <key>
+  env list-vars`,
+    import: `Usage: ascendkit import <source> [options]
+
+Sources:
+  clerk            Import users from Clerk
+
+Commands:
+  import clerk --api-key <key> [options]
+  import clerk --file <path> [options]
+  import create-migration-journey [--from-identity <email>]
+
+Options:
+  --api-key <key>        Clerk secret API key (fetches users from Clerk API)
+  --file <path>          Path to Clerk dashboard export (JSON)
+  --instance-url <url>   Custom Clerk API URL (default: https://api.clerk.com)
+  --execute              Run the import for real (default is dry-run preview)
+  --users                Import users (included by default; use to select only users)
+  --settings             Import auth settings / OAuth providers (included by default)
+  --from-identity <email>  Email identity for migration journey emails
+
+By default, import runs in dry-run mode and includes both users and settings.
+Pass --execute to apply changes. Pass --users or --settings alone to select
+only that phase (e.g. --users --execute imports only users, not settings).`,
     projects: `Usage: ascendkit projects <command>
 
 Commands:
@@ -292,7 +337,11 @@ async function run() {
                     process.exit(1);
                 }
                 try {
-                    output(await platform.createProject(flags.name, flags.description, flags.services?.split(",")));
+                    const proj = await platform.createProject(flags.name, flags.description, flags.services?.split(","));
+                    const env = proj.environment;
+                    console.log(`Project created: ${proj.id}`);
+                    if (env)
+                        console.log(`Environment:     ${env.publicKey}`);
                 }
                 catch (err) {
                     let message = err instanceof Error ? err.message : String(err);
@@ -355,12 +404,163 @@ async function run() {
         case "webhook":
             await runWebhook(client, action, args.slice(2));
             break;
+        case "campaign":
+            await runCampaign(client, action, args.slice(2));
+            break;
+        case "import":
+            await runImport(client, action, args.slice(2));
+            break;
         default:
             console.error(`Unknown command: ${domain}`);
             console.error('Run "ascendkit --help" for usage');
             process.exit(1);
     }
 }
+async function runImport(client, source, rest) {
+    const flags = parseFlags(rest);
+    if (source === "create-migration-journey") {
+        const result = await importCmd.instantiateMigrationJourney(client, flags["from-identity"]);
+        output(result);
+        console.log("\nNext steps:");
+        console.log("  ascendkit journey list    — review created journeys");
+        console.log("  ascendkit templates list  — review migration email templates");
+        console.log("  ascendkit journey activate <journey-id>  — activate when ready");
+        return;
+    }
+    if (source !== "clerk") {
+        console.error(`Unsupported import source: ${source}`);
+        console.error("Supported sources: clerk");
+        console.error('Run "ascendkit help import" for usage');
+        process.exit(1);
+    }
+    const execute = flags.execute === "true" || flags.execute === "";
+    const dryRun = !execute;
+    const hasUsers = flags.users !== undefined;
+    const hasSettings = flags.settings !== undefined;
+    // If neither --users nor --settings is passed, both default to true.
+    // If either is passed, only the specified phases run.
+    const importUsers = (!hasUsers && !hasSettings) || hasUsers;
+    const importSettings = (!hasUsers && !hasSettings) || hasSettings;
+    const apiKey = flags["api-key"];
+    const filePath = flags.file;
+    if (!apiKey && !filePath) {
+        console.error("Usage: ascendkit import clerk --api-key <key> | --file <path> [--execute]");
+        process.exit(1);
+    }
+    let clerkUsers = [];
+    if (filePath) {
+        console.log(`Reading Clerk export from ${filePath}...`);
+        const rawUsers = importCmd.parseClerkExport(filePath);
+        clerkUsers = rawUsers.map(importCmd.transformClerkUser);
+        console.log(`Parsed ${clerkUsers.length} users from file.`);
+    }
+    else {
+        console.log("Fetching users from Clerk API...");
+        const rawUsers = await importCmd.fetchClerkUsers(apiKey, flags["instance-url"]);
+        clerkUsers = rawUsers.map(importCmd.transformClerkUser);
+        console.log(`Fetched ${clerkUsers.length} users from Clerk.`);
+    }
+    if (clerkUsers.length === 0 && importUsers) {
+        console.log("No users to import.");
+        return;
+    }
+    if (dryRun) {
+        console.log("\n--- DRY RUN (pass --execute to apply changes) ---");
+    }
+    // Batch in chunks of 500 (backend max)
+    const batchSize = 500;
+    let totalImported = 0;
+    const allDuplicates = [];
+    const allErrors = [];
+    const allWarnings = [];
+    if (importUsers) {
+        for (let i = 0; i < clerkUsers.length; i += batchSize) {
+            const batch = clerkUsers.slice(i, i + batchSize);
+            const batchNum = Math.floor(i / batchSize) + 1;
+            const totalBatches = Math.ceil(clerkUsers.length / batchSize);
+            if (totalBatches > 1) {
+                console.log(`\nBatch ${batchNum}/${totalBatches} (${batch.length} users)...`);
+            }
+            const result = await importCmd.importUsers(client, {
+                source: "clerk",
+                users: batch,
+                dryRun,
+            });
+            totalImported += result.imported;
+            allDuplicates.push(...result.duplicates);
+            allErrors.push(...result.errors);
+            allWarnings.push(...result.warnings);
+        }
+    }
+    else {
+        console.log("Skipping user import (--settings only).");
+    }
+    if (importSettings) {
+        const derived = importCmd.deriveSettingsFromUsers(clerkUsers);
+        // --providers override lets the user pick exactly which SSO to enable
+        const providerOverride = flags.providers;
+        const ssoProviders = providerOverride
+            ? providerOverride.split(",").map((s) => s.trim()).filter(Boolean)
+            : derived.providers;
+        const providers = [];
+        if (derived.hasCredentials)
+            providers.push("credentials");
+        providers.push(...ssoProviders);
+        console.log("\nAuth settings from user data:");
+        console.log(`  Credentials (email/password): ${derived.hasCredentials ? "yes" : "no"}`);
+        console.log(`  SSO providers: ${ssoProviders.length > 0 ? ssoProviders.join(", ") : "none"}`);
+        if (providerOverride) {
+            console.log(`  (overridden via --providers)`);
+        }
+        if (providers.length > 0) {
+            const settingsPayload = {
+                source: "clerk",
+                users: [],
+                authSettings: { enabledProviders: providers },
+                dryRun,
+            };
+            const settingsResult = await importCmd.importUsers(client, settingsPayload);
+            allWarnings.push(...settingsResult.warnings);
+            if (!dryRun) {
+                console.log(`\nAuth settings applied: ${providers.join(", ")}`);
+                console.log("Configure OAuth secrets in the portal under Auth → OAuth settings.");
+            }
+            else {
+                console.log(`\nWill enable: ${providers.join(", ")}`);
+                console.log("Use --providers linkedin to pick specific SSO providers.");
+            }
+        }
+    }
+    else {
+        console.log("Skipping auth settings import (--users only).");
+    }
+    console.log(`\n--- Import Summary ---`);
+    if (importUsers) {
+        console.log(`Imported:    ${totalImported}`);
+        if (allDuplicates.length > 0) {
+            console.log(`Duplicates:  ${allDuplicates.length}`);
+        }
+    }
+    if (allErrors.length > 0) {
+        console.log(`Errors:      ${allErrors.length}`);
+        for (const err of allErrors.slice(0, 10)) {
+            console.log(`  - ${err.email}: ${err.reason}`);
+        }
+        if (allErrors.length > 10) {
+            console.log(`  ... and ${allErrors.length - 10} more`);
+        }
+    }
+    for (const warning of allWarnings) {
+        console.log(`Warning: ${warning}`);
+    }
+    if (dryRun) {
+        console.log("\nThis was a dry run. Pass --execute to apply changes.");
+    }
+    else if (totalImported > 0) {
+        console.log("\nTo set up migration emails, run:\n" +
+            "  ascendkit import create-migration-journey");
+    }
+}
 async function runEnv(action, rest) {
     const flags = parseFlags(rest);
     switch (action) {
@@ -447,9 +647,69 @@ async function runEnv(action, rest) {
             }
             break;
         }
+        case "set-var": {
+            const key = rest[0];
+            const value = rest[1];
+            if (!key || value === undefined) {
+                console.error("Usage: ascendkit env set-var <key> <value>");
+                process.exit(1);
+            }
+            const ctx = loadEnvContext();
+            if (!ctx) {
+                console.error("No environment set. Run: ascendkit env use <tier> --project <project-id>");
+                process.exit(1);
+            }
+            const current = await platform.getEnvironment(ctx.projectId, ctx.environmentId);
+            const vars = { ...(current.variables ?? {}) };
+            vars[key] = value;
+            await platform.updateEnvironmentVariables(ctx.projectId, ctx.environmentId, vars);
+            console.log(`Set ${key}=${value}`);
+            break;
+        }
+        case "unset-var": {
+            const key = rest[0];
+            if (!key) {
+                console.error("Usage: ascendkit env unset-var <key>");
+                process.exit(1);
+            }
+            const ctx = loadEnvContext();
+            if (!ctx) {
+                console.error("No environment set. Run: ascendkit env use <tier> --project <project-id>");
+                process.exit(1);
+            }
+            const current = await platform.getEnvironment(ctx.projectId, ctx.environmentId);
+            const vars = { ...(current.variables ?? {}) };
+            if (!(key in vars)) {
+                console.error(`Variable "${key}" not found.`);
+                process.exit(1);
+            }
+            delete vars[key];
+            await platform.updateEnvironmentVariables(ctx.projectId, ctx.environmentId, vars);
+            console.log(`Unset ${key}`);
+            break;
+        }
+        case "list-vars": {
+            const ctx = loadEnvContext();
+            if (!ctx) {
+                console.error("No environment set. Run: ascendkit env use <tier> --project <project-id>");
+                process.exit(1);
+            }
+            const current = await platform.getEnvironment(ctx.projectId, ctx.environmentId);
+            const vars = current.variables ?? {};
+            const entries = Object.entries(vars);
+            if (entries.length === 0) {
+                console.log("No variables set.");
+            }
+            else {
+                for (const [k, v] of entries) {
+                    console.log(`${k}=${v || "(empty)"}`);
+                }
+            }
+            break;
+        }
         default:
             console.error(`Unknown env command: ${action}`);
-            console.error("Usage: ascendkit env list|use|update|promote");
+            console.error("Usage: ascendkit env list|use|update|promote|set-var|unset-var|list-vars");
             process.exit(1);
     }
 }
@@ -472,7 +732,14 @@ async function runAuth(client, action, rest) {
                 }
                 if (flags["session-duration"])
                     params.sessionDuration = flags["session-duration"];
-                output(await auth.updateSettings(client, params));
+                const s = await auth.updateSettings(client, params);
+                console.log(`Providers:  ${Array.isArray(s.providers) ? s.providers.join(", ") : "none"}`);
+                const f = s.features ?? {};
+                const enabled = Object.entries(f).filter(([, v]) => v).map(([k]) => k);
+                if (enabled.length)
+                    console.log(`Features:   ${enabled.join(", ")}`);
+                if (s.sessionDuration)
+                    console.log(`Session:    ${s.sessionDuration}`);
             }
             else {
                 output(await auth.getSettings(client));
@@ -960,12 +1227,19 @@ async function runJourney(client, action, rest) {
             break;
         case "add-node": {
             if (!rest[0] || !flags.name) {
-                console.error("Usage: ascendkit journey add-node <journey-id> --name <node-name> [--action <json>] [--terminal <true|false>]");
+                console.error("Usage: ascendkit journey add-node <journey-id> --name <node-name> [--action <json>] [--email-id <email>] [--terminal <true|false>]");
                 process.exit(1);
             }
             const params = { name: flags.name };
             if (flags.action)
                 params.action = JSON.parse(flags.action);
+            if (flags["email-id"]) {
+                if (!params.action || params.action.type !== "send_email") {
+                    console.error("--email-id requires a send_email action (use --action '{\"type\": \"send_email\", \"templateSlug\": \"...\"}')");
+                    process.exit(1);
+                }
+                params.action.fromIdentityEmail = flags["email-id"];
+            }
             if (flags.terminal)
                 params.terminal = flags.terminal === "true";
             output(await journeys.addNode(client, rest[0], params));
@@ -973,12 +1247,28 @@ async function runJourney(client, action, rest) {
         }
         case "edit-node": {
             if (!rest[0] || !rest[1]) {
-                console.error("Usage: ascendkit journey edit-node <journey-id> <node-name> [--action <json>] [--terminal <true|false>]");
+                console.error("Usage: ascendkit journey edit-node <journey-id> <node-name> [--action <json>] [--email-id <email>] [--terminal <true|false>]");
                 process.exit(1);
             }
             const params = {};
             if (flags.action)
                 params.action = JSON.parse(flags.action);
+            if (flags["email-id"]) {
+                if (!params.action) {
+                    const nodesData = await journeys.listNodes(client, rest[0]);
+                    const current = nodesData.nodes?.find((n) => n.name === rest[1]);
+                    if (!current?.action || current.action.type !== "send_email") {
+                        console.error("--email-id can only be set on send_email nodes");
+                        process.exit(1);
+                    }
+                    params.action = current.action;
+                }
+                else if (params.action.type !== "send_email") {
+                    console.error("--email-id requires a send_email action");
+                    process.exit(1);
+                }
+                params.action.fromIdentityEmail = flags["email-id"];
+            }
             if (flags.terminal)
                 params.terminal = flags.terminal === "true";
             output(await journeys.editNode(client, rest[0], rest[1], params));
@@ -1089,17 +1379,22 @@ async function runWebhook(client, action, rest) {
             }
             output(await webhooks.getWebhook(client, rest[0]));
             break;
-        case "update":
+        case "update": {
             if (!rest[0]) {
                 console.error("Usage: ascendkit webhook update <webhook-id> [--flags]");
                 process.exit(1);
             }
-            output(await webhooks.updateWebhook(client, rest[0], {
+            const updated = await webhooks.updateWebhook(client, rest[0], {
                 url: flags.url,
                 events: flags.events ? flags.events.split(",") : undefined,
                 status: flags.status,
-            }));
+            });
+            console.log(`Updated: ${updated.id}`);
+            console.log(`URL:     ${updated.url}`);
+            console.log(`Status:  ${updated.status}`);
+            console.log(`Events:  ${Array.isArray(updated.events) ? updated.events.join(", ") : updated.events}`);
             break;
+        }
         case "delete":
             if (!rest[0]) {
                 console.error("Usage: ascendkit webhook delete <webhook-id>");
@@ -1120,6 +1415,115 @@ async function runWebhook(client, action, rest) {
             process.exit(1);
     }
 }
+async function runCampaign(client, action, rest) {
+    const flags = parseFlags(rest);
+    if (!action) {
+        console.log(HELP_SECTION.campaign);
+        return;
+    }
+    switch (action) {
+        case "create":
+            if (!flags.name || !flags.template || !flags.audience) {
+                console.error("Usage: ascendkit campaign create --name <name> --template <template-id> --audience <json> [--scheduled-at <datetime>]");
+                process.exit(1);
+            }
+            let createFilter;
+            try {
+                createFilter = JSON.parse(flags.audience);
+            }
+            catch {
+                console.error("Invalid JSON for --audience flag. Provide a valid JSON object.");
+                process.exit(1);
+            }
+            output(await campaigns.createCampaign(client, {
+                name: flags.name,
+                templateId: flags.template,
+                audienceFilter: createFilter,
+                scheduledAt: flags["scheduled-at"],
+            }));
+            break;
+        case "list": {
+            const items = await campaigns.listCampaigns(client, flags.status);
+            table(items, [
+                { key: "id", label: "ID" },
+                { key: "name", label: "Name", width: 30 },
+                { key: "status", label: "Status" },
+                { key: "scheduledAt", label: "Scheduled", width: 22 },
+                { key: "templateId", label: "Template" },
+            ]);
+            break;
+        }
+        case "show":
+        case "get":
+            if (!rest[0]) {
+                console.error("Usage: ascendkit campaign show <campaign-id>");
+                process.exit(1);
+            }
+            output(await campaigns.getCampaign(client, rest[0]));
+            break;
+        case "update":
+            if (!rest[0]) {
+                console.error("Usage: ascendkit campaign update <campaign-id> [--flags]");
+                process.exit(1);
+            }
+            let updateFilter;
+            if (flags.audience) {
+                try {
+                    updateFilter = JSON.parse(flags.audience);
+                }
+                catch {
+                    console.error("Invalid JSON for --audience flag. Provide a valid JSON object.");
+                    process.exit(1);
+                }
+            }
+            output(await campaigns.updateCampaign(client, rest[0], {
+                name: flags.name,
+                templateId: flags.template,
+                audienceFilter: updateFilter,
+                scheduledAt: flags["scheduled-at"],
+            }));
+            break;
+        case "preview":
+            if (!rest[0]) {
+                console.error("Usage: ascendkit campaign preview <campaign-id>");
+                process.exit(1);
+            }
+            {
+                const detail = await campaigns.getCampaign(client, rest[0]);
+                if (!detail?.audienceFilter) {
+                    console.error("Campaign has no audience filter set.");
+                    process.exit(1);
+                }
+                output(await campaigns.previewAudience(client, detail.audienceFilter));
+            }
+            break;
+        case "schedule":
+            if (!rest[0] || !flags.at) {
+                console.error("Usage: ascendkit campaign schedule <campaign-id> --at <datetime>");
+                process.exit(1);
+            }
+            output(await campaigns.updateCampaign(client, rest[0], { scheduledAt: flags.at }));
+            break;
+        case "cancel":
+            if (!rest[0]) {
+                console.error("Usage: ascendkit campaign cancel <campaign-id>");
+                process.exit(1);
+            }
+            output(await campaigns.deleteCampaign(client, rest[0]));
+            break;
+        case "analytics":
+            if (!rest[0]) {
+                console.error("Usage: ascendkit campaign analytics <campaign-id>");
+                process.exit(1);
+            }
+            output(await campaigns.getCampaignAnalytics(client, rest[0]));
+            break;
+        default:
+            console.error(`Unknown campaign command: ${action}`);
+            console.error('Run "ascendkit campaign --help" for usage');
+            process.exit(1);
+    }
+}
 async function runEmail(client, action, rest) {
     const flags = parseFlags(rest);
     switch (action) {

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/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

@@ -41,6 +41,7 @@ export interface AddNodeParams {
         surveySlug?: string;
         tagName?: string;
         stageName?: string;
+        fromIdentityEmail?: string;
     };
     terminal?: boolean;
 }
@@ -51,6 +52,7 @@ export interface EditNodeParams {
         surveySlug?: string;
         tagName?: string;
         stageName?: string;
+        fromIdentityEmail?: string;
     };
     terminal?: boolean;
 }

package/dist/commands/platform.d.ts

@@ -47,3 +47,11 @@ 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 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>;

package/dist/commands/platform.js

@@ -184,7 +184,7 @@ async function updateRuntimeEnvFile(filePath, apiUrl, publicKey, secretKey, opti
     const existingPublicKey = readEnvValue(original, "ASCENDKIT_ENV_KEY");
     const existingSecretKey = readEnvValue(original, "ASCENDKIT_SECRET_KEY");
     const existingWebhookSecret = readEnvValue(original, "ASCENDKIT_WEBHOOK_SECRET") ?? "";
-    const resolvedApiUrl = existingApiUrl ?? apiUrl;
+    const resolvedApiUrl = apiUrl;
     const resolvedPublicKey = preserveExistingKeys
         ? (existingPublicKey && existingPublicKey.trim() ? existingPublicKey : publicKey)
         : publicKey;
@@ -559,3 +559,19 @@ export async function mcpUpdateEnvironment(client, params) {
 export async function mcpPromoteEnvironment(client, params) {
     return client.platformRequest("POST", `/api/platform/environments/${params.environmentId}/promote`, { targetTier: params.targetTier, dryRun: false });
 }
+export async function mcpUpdateEnvironmentVariables(client, params) {
+    return client.platformRequest("PATCH", `/api/platform/projects/${params.projectId}/environments/${params.envId}`, { variables: params.variables });
+}
+export async function getEnvironment(projectId, envId) {
+    const auth = requireAuth();
+    const envs = await apiRequest(auth.apiUrl, "GET", `/api/platform/projects/${projectId}/environments`, undefined, auth.token);
+    const env = envs.find(e => e.id === envId);
+    if (!env) {
+        throw new Error(`Environment ${envId} not found in project ${projectId}.`);
+    }
+    return env;
+}
+export async function updateEnvironmentVariables(projectId, envId, variables) {
+    const auth = requireAuth();
+    return apiRequest(auth.apiUrl, "PATCH", `/api/platform/projects/${projectId}/environments/${envId}`, { variables }, auth.token);
+}

package/dist/mcp.js

@@ -10,6 +10,8 @@ import { registerPlatformTools } from "./tools/platform.js";
 import { registerEmailTools } from "./tools/email.js";
 import { registerJourneyTools } from "./tools/journeys.js";
 import { registerWebhookTools } from "./tools/webhooks.js";
+import { registerCampaignTools } from "./tools/campaigns.js";
+import { registerImportTools } from "./tools/import.js";
 import { DEFAULT_API_URL } from "./constants.js";
 const client = new AscendKitClient({
     apiUrl: process.env.ASCENDKIT_API_URL ?? DEFAULT_API_URL,
@@ -34,6 +36,8 @@ registerSurveyTools(server, client);
 registerEmailTools(server, client);
 registerJourneyTools(server, client);
 registerWebhookTools(server, client);
+registerCampaignTools(server, client);
+registerImportTools(server, client);
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/dist/tools/auth.js

@@ -35,12 +35,31 @@ export function registerAuthTools(server, client) {
         const data = await auth.updateProviders(client, params.providers);
         return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
     });
-    server.tool("auth_setup_oauth", "Configure OAuth credentials for a provider. Pass clientId and clientSecret to set credentials directly, or omit them to get a portal URL for browser-based entry. Note: credentials in tool args may appear in logs — use the portal URL for sensitive environments.", {
+    server.tool("auth_setup_oauth", "Configure OAuth credentials for a provider. Pass clientId and clientSecret for custom credentials, or useProxy to revert to AscendKit managed credentials. Omit all to get a portal URL for browser-based entry.", {
         provider: z.string().describe('OAuth provider name, e.g. "google", "github"'),
         clientId: z.string().optional().describe("OAuth client ID (to set credentials directly)"),
         clientSecret: z.string().optional().describe("OAuth client secret (to set credentials directly)"),
         callbackUrl: z.string().optional().describe("Auth callback URL for this provider"),
+        useProxy: z.boolean().optional().describe("Clear custom credentials and use AscendKit managed proxy credentials"),
     }, async (params) => {
+        if (params.useProxy && (params.clientId || params.clientSecret)) {
+            return {
+                content: [{
+                        type: "text",
+                        text: "Cannot use useProxy with custom credentials. Either set useProxy to clear credentials, or provide clientId and clientSecret.",
+                    }],
+                isError: true,
+            };
+        }
+        if (params.useProxy) {
+            const data = await auth.deleteOAuthCredentials(client, params.provider);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Cleared custom OAuth credentials for ${params.provider}. Now using AscendKit managed proxy credentials.\n\n${JSON.stringify(data, null, 2)}`,
+                    }],
+            };
+        }
         if ((params.clientId && !params.clientSecret) || (!params.clientId && params.clientSecret)) {
             return {
                 content: [{
@@ -72,4 +91,22 @@ export function registerAuthTools(server, client) {
         const data = await auth.listUsers(client);
         return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
     });
+    server.tool("auth_delete_user", "Deactivate a user (soft delete). The user record is preserved but marked inactive.", {
+        userId: z.string().describe("User ID (usr_ prefixed)"),
+    }, async (params) => {
+        const data = await auth.deleteUser(client, params.userId);
+        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    });
+    server.tool("auth_bulk_delete_users", "Bulk deactivate users (soft delete). All specified users are marked inactive.", {
+        userIds: z.array(z.string()).min(1).max(100).describe("Array of user IDs (usr_ prefixed)"),
+    }, async (params) => {
+        const data = await auth.bulkDeleteUsers(client, params.userIds);
+        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    });
+    server.tool("auth_reactivate_user", "Reactivate a previously deactivated user.", {
+        userId: z.string().describe("User ID (usr_ prefixed)"),
+    }, async (params) => {
+        const data = await auth.reactivateUser(client, params.userId);
+        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    });
 }

package/dist/tools/campaigns.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { AscendKitClient } from "../api/client.js";
+export declare function registerCampaignTools(server: McpServer, client: AscendKitClient): void;

package/dist/tools/campaigns.js

@@ -0,0 +1,78 @@
+import { z } from "zod";
+import * as campaigns from "../commands/campaigns.js";
+export function registerCampaignTools(server, client) {
+    server.tool("campaign_create", "Create a new email campaign targeting users that match an audience filter. Campaigns start as drafts; set scheduledAt to schedule for future delivery. Campaign lifecycle: create → preview audience → schedule → sending → sent.", {
+        name: z.string().describe("Campaign name, e.g. 'March Newsletter'"),
+        templateId: z.string().describe("Email template ID (tpl_ prefixed) to use for the campaign"),
+        audienceFilter: z
+            .record(z.unknown())
+            .describe("Filter object to select target users (e.g. { tags: { $in: ['premium'] } }). Allowed fields: createdAt, emailVerified, lastLoginAt, tags, stage, name, email, waitlistStatus, metadata.*"),
+        scheduledAt: z
+            .string()
+            .optional()
+            .describe("ISO 8601 datetime to schedule sending (omit to keep as draft)"),
+        fromIdentityEmail: z
+            .string()
+            .optional()
+            .describe("Verified email identity to use as sender. Falls back to environment default."),
+    }, async (params) => {
+        const data = await campaigns.createCampaign(client, params);
+        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    });
+    server.tool("campaign_list", "List campaigns for the current project. Optionally filter by status: draft, scheduled, sending, sent, failed, or cancelled.", {
+        status: z
+            .enum(["draft", "scheduled", "sending", "sent", "failed", "cancelled"])
+            .optional()
+            .describe("Filter by campaign status"),
+    }, async (params) => {
+        const data = await campaigns.listCampaigns(client, params.status);
+        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    });
+    server.tool("campaign_get", "Get full details of a campaign including its status, template, audience filter, and schedule.", {
+        campaignId: z.string().describe("Campaign ID (cmp_ prefixed)"),
+    }, async (params) => {
+        const data = await campaigns.getCampaign(client, params.campaignId);
+        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    });
+    server.tool("campaign_update", "Update a draft, scheduled, or failed campaign. You can change the name, template, audience filter, or schedule. Only provided fields are updated.", {
+        campaignId: z.string().describe("Campaign ID (cmp_ prefixed)"),
+        name: z.string().optional().describe("New campaign name"),
+        templateId: z.string().optional().describe("New email template ID (tpl_ prefixed)"),
+        audienceFilter: z
+            .record(z.unknown())
+            .optional()
+            .describe("New audience filter object"),
+        scheduledAt: z
+            .string()
+            .optional()
+            .describe("New scheduled send time (ISO 8601 datetime)"),
+        fromIdentityEmail: z
+            .string()
+            .optional()
+            .describe("Verified email identity to use as sender. Falls back to environment default."),
+    }, async (params) => {
+        const { campaignId, ...rest } = params;
+        const data = await campaigns.updateCampaign(client, campaignId, rest);
+        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    });
+    server.tool("campaign_delete", "Delete a draft or failed campaign, or cancel a scheduled/sending campaign. Sent campaigns cannot be deleted.", {
+        campaignId: z.string().describe("Campaign ID (cmp_ prefixed)"),
+    }, async (params) => {
+        const data = await campaigns.deleteCampaign(client, params.campaignId);
+        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    });
+    server.tool("campaign_preview_audience", "Preview how many users match an audience filter before creating or updating a campaign. Returns the count and a sample of matching users.", {
+        audienceFilter: z
+            .record(z.unknown())
+            .describe("Filter object to preview (e.g. { tags: { $in: ['premium'] } }). Allowed fields: createdAt, emailVerified, lastLoginAt, tags, stage, name, email, waitlistStatus, metadata.*"),
+    }, async (params) => {
+        const data = await campaigns.previewAudience(client, params.audienceFilter);
+        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    });
+    server.tool("campaign_analytics", "Get campaign performance analytics: delivery stats (sent, failed, bounced), engagement metrics (opened, clicked), and calculated rates.", {
+        campaignId: z.string().describe("Campaign ID (cmp_ prefixed)"),
+    }, async (params) => {
+        const data = await campaigns.getCampaignAnalytics(client, params.campaignId);
+        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    });
+}

package/dist/tools/import.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { AscendKitClient } from "../api/client.js";
+export declare function registerImportTools(server: McpServer, client: AscendKitClient): void;

package/dist/tools/import.js

@@ -0,0 +1,116 @@
+import { z } from "zod";
+import * as importCmd from "../commands/import.js";
+export function registerImportTools(server, client) {
+    server.tool("auth_import_clerk", "Import users from Clerk into the current AscendKit environment. Fetches all users from the Clerk API, transforms them to AscendKit format, and pushes them to the import endpoint. Tags users by auth type: import:needs-password-reset or import:social-only. Defaults to dry-run — pass execute=true to apply changes.", {
+        clerkApiKey: z
+            .string()
+            .describe("Clerk secret API key (sk_live_... or sk_test_...)"),
+        clerkInstanceUrl: z
+            .string()
+            .optional()
+            .describe("Custom Clerk API URL (default: https://api.clerk.com)"),
+        execute: z
+            .boolean()
+            .optional()
+            .describe("Set to true to apply changes. Default is dry-run (preview only)."),
+        importUsers: z
+            .boolean()
+            .optional()
+            .describe("Import users (default: true)"),
+        importSettings: z
+            .boolean()
+            .optional()
+            .describe("Import auth settings — OAuth provider config (default: true)"),
+    }, async (params) => {
+        try {
+            const dryRun = !(params.execute ?? false);
+            const shouldImportUsers = params.importUsers ?? true;
+            const shouldImportSettings = params.importSettings ?? true;
+            const rawUsers = await importCmd.fetchClerkUsers(params.clerkApiKey, params.clerkInstanceUrl);
+            const users = rawUsers.map(importCmd.transformClerkUser);
+            if (users.length === 0) {
+                return {
+                    content: [{ type: "text", text: "No users found in Clerk." }],
+                };
+            }
+            let totalImported = 0;
+            let totalDuplicates = 0;
+            const allErrors = [];
+            const allWarnings = [];
+            // Import users in batches of 500
+            if (shouldImportUsers) {
+                const batchSize = 500;
+                for (let i = 0; i < users.length; i += batchSize) {
+                    const batch = users.slice(i, i + batchSize);
+                    const result = await importCmd.importUsers(client, {
+                        source: "clerk",
+                        users: batch,
+                        dryRun,
+                    });
+                    totalImported += result.imported;
+                    totalDuplicates += result.duplicates.length;
+                    allErrors.push(...result.errors);
+                    allWarnings.push(...result.warnings);
+                }
+            }
+            // Import auth settings (OAuth provider config)
+            if (shouldImportSettings) {
+                const providers = new Set();
+                for (const u of users) {
+                    for (const p of u.oauthProviders ?? []) {
+                        providers.add(p.providerId);
+                    }
+                }
+                if (providers.size > 0) {
+                    const settingsResult = await importCmd.importUsers(client, {
+                        source: "clerk",
+                        users: [],
+                        authSettings: { enabledProviders: [...providers] },
+                        dryRun,
+                    });
+                    allWarnings.push(...settingsResult.warnings);
+                }
+            }
+            const summary = {
+                fetched: users.length,
+                dryRun,
+                importUsers: shouldImportUsers,
+                importSettings: shouldImportSettings,
+            };
+            if (shouldImportUsers) {
+                summary.imported = totalImported;
+                summary.duplicates = totalDuplicates;
+            }
+            if (allErrors.length > 0)
+                summary.errors = allErrors;
+            if (allWarnings.length > 0)
+                summary.warnings = allWarnings;
+            let text = JSON.stringify(summary, null, 2);
+            if (dryRun) {
+                text += "\n\nThis was a dry run. Pass execute=true to apply changes.";
+            }
+            else if (totalImported > 0) {
+                text += "\n\nTo set up migration emails, use the journey_create_migration tool.";
+            }
+            return { content: [{ type: "text", text }] };
+        }
+        catch (err) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Import failed: ${err instanceof Error ? err.message : String(err)}`,
+                    }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("journey_create_migration", "Create pre-built migration email templates and draft journeys for notifying imported users. Creates 5 email templates (announcement, go-live, reminder, password reset, password reset reminder) and 2 journeys: announcement cadence (all users, Day 0/3/7) and password reset cadence (credential users, Day 1/4). Idempotent — skips already-existing templates/journeys.", {
+        fromIdentityEmail: z
+            .string()
+            .optional()
+            .describe("Verified email identity to use as sender for migration emails"),
+    }, async (params) => {
+        const data = await importCmd.instantiateMigrationJourney(client, params.fromIdentityEmail);
+        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    });
+}

package/dist/tools/journeys.js

@@ -14,7 +14,7 @@ export function registerJourneyTools(server, client) {
         nodes: z
             .record(z.record(z.unknown()))
             .optional()
-            .describe("Map of node names to definitions. Each node has 'action' ({type, templateSlug?, surveySlug?, tagName?, stageName?}) and optional 'terminal' (boolean). If omitted, the entry node is auto-created as a 'none' action placeholder."),
+            .describe("Map of node names to definitions. Each node has 'action' ({type, templateSlug?, surveySlug?, tagName?, stageName?, variables?}) and optional 'terminal' (boolean). If omitted, the entry node is auto-created as a 'none' action placeholder."),
         transitions: z
             .array(z.record(z.unknown()))
             .optional()
@@ -138,6 +138,8 @@ export function registerJourneyTools(server, client) {
             surveySlug: z.string().optional().describe("Survey slug to include in email (for send_email)"),
             tagName: z.string().optional().describe("Tag to add (for tag_user)"),
             stageName: z.string().optional().describe("Stage to set (for advance_stage)"),
+            fromIdentityEmail: z.string().optional().describe("Verified email identity to use when this node sends email"),
+            variables: z.record(z.string()).optional().describe("Custom template variables for this node's email (e.g. {loginUrl: 'https://...', resetUrl: 'https://...'})"),
         })
             .optional()
             .describe("Action to execute when a user enters this node. Defaults to {type: 'none'}."),
@@ -161,6 +163,8 @@ export function registerJourneyTools(server, client) {
             surveySlug: z.string().optional().describe("Survey slug to include in email"),
             tagName: z.string().optional().describe("Tag to add"),
             stageName: z.string().optional().describe("Stage to set"),
+            fromIdentityEmail: z.string().optional().describe("Verified email identity to use when this node sends email"),
+            variables: z.record(z.string()).optional().describe("Custom template variables for this node's email (e.g. {loginUrl: 'https://...', resetUrl: 'https://...'})"),
         })
             .optional()
             .describe("New action definition (replaces the entire action)"),

package/dist/tools/platform.js

@@ -172,4 +172,34 @@ export function registerPlatformTools(server, client) {
             };
         }
     });
+    server.tool("platform_update_environment_variables", "Set environment variables for a project environment. Pass the full variables dict — it replaces all existing variables.", {
+        projectId: z.string().describe("Project ID (prj_ prefixed)"),
+        envId: z.string().describe("Environment ID (env_ prefixed)"),
+        variables: z.record(z.string()).describe("Key-value map of environment variables"),
+    }, async (params) => {
+        try {
+            const data = await platform.mcpUpdateEnvironmentVariables(client, params);
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (err) {
+            let message = err instanceof Error ? err.message : String(err);
+            const jsonMatch = message.match(/\{.*\}/s);
+            if (jsonMatch) {
+                try {
+                    const parsed = JSON.parse(jsonMatch[0]);
+                    if (parsed.error)
+                        message = parsed.error;
+                    else if (parsed.detail)
+                        message = parsed.detail;
+                }
+                catch { /* use raw message */ }
+            }
+            return {
+                content: [{ type: "text", text: message }],
+                isError: true,
+            };
+        }
+    });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ascendkit/cli",
-  "version": "0.2.0",
+  "version": "0.2.6",
   "description": "AscendKit CLI and MCP server",
   "author": "ascendkit.dev",
   "license": "MIT",