@ascendkit/cli 0.1.11 → 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,10 +34,12 @@ 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
-  env              List, switch, and promote environments
+  env              List, switch, update, and promote environments
   verify           Check all services in the active environment
 
 Run "ascendkit help <section>" for detailed command usage.
@@ -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,12 +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 promote <env-id> --target <tier>`,
+  env update <env-id> --project <project-id> [--name <name>] [--description <desc>]
+  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:
@@ -291,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);
@@ -354,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) {
@@ -411,9 +612,104 @@ async function runEnv(action, rest) {
             }
             break;
         }
+        case "update": {
+            const envId = rest[0];
+            if (!envId || !flags.project) {
+                console.error("Usage: ascendkit env update <env-id> --project <project-id> [--name <name>] [--description <desc>]");
+                process.exit(1);
+            }
+            const name = flags.name;
+            const description = flags.description;
+            if (!name && description === undefined) {
+                console.error("Provide at least --name or --description to update.");
+                process.exit(1);
+            }
+            try {
+                const result = await platform.updateEnvironment(flags.project, envId, name, description);
+                console.log("Environment updated:");
+                console.log(JSON.stringify(result, 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 */ }
+                }
+                console.error(message);
+                process.exit(1);
+            }
+            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|promote");
+            console.error("Usage: ascendkit env list|use|update|promote|set-var|unset-var|list-vars");
             process.exit(1);
     }
 }
@@ -436,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));
@@ -924,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));
@@ -937,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));
@@ -1053,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>");
@@ -1084,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>;