@ascendkit/cli 0.2.0 → 0.3.0

package/dist/commands/platform.js

@@ -1,7 +1,7 @@
 import { hostname, platform as osPlatform, release } from "node:os";
 import { readdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { loadAuth, saveAuth, deleteAuth, saveEnvContext, ensureGitignore } from "../utils/credentials.js";
+import { loadAuth, loadEnvContext, saveAuth, deleteAuth, saveEnvContext, ensureGitignore, } from "../utils/credentials.js";
 import { DEFAULT_API_URL, DEFAULT_PORTAL_URL } from "../constants.js";
 const POLL_INTERVAL_MS = 2000;
 const DEVICE_CODE_EXPIRY_MS = 300_000; // 5 minutes
@@ -16,6 +16,14 @@ const ASCENDKIT_ENV_KEYS = [
 ];
 const ASCENDKIT_BLOCK_START = "# --- AscendKit Managed Environment Variables ---";
 const ASCENDKIT_BLOCK_END = "# --- End AscendKit Managed Environment Variables ---";
+function normalizePromotionTier(targetTier) {
+    const normalized = targetTier.trim().toLowerCase();
+    if (normalized === "production")
+        return "prod";
+    if (normalized === "staging")
+        return "beta";
+    return normalized;
+}
 async function promptYesNo(question, defaultYes) {
     const suffix = defaultYes ? "[Y/n]" : "[y/N]";
     if (!process.stdin.isTTY || !process.stdout.isTTY) {
@@ -184,13 +192,14 @@ 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 incomingSecretKey = (secretKey ?? "").trim();
+    const resolvedApiUrl = apiUrl;
     const resolvedPublicKey = preserveExistingKeys
         ? (existingPublicKey && existingPublicKey.trim() ? existingPublicKey : publicKey)
         : publicKey;
     const resolvedSecretKey = preserveExistingKeys
-        ? (existingSecretKey && existingSecretKey.trim() ? existingSecretKey : secretKey)
-        : secretKey;
+        ? (existingSecretKey && existingSecretKey.trim() ? existingSecretKey : incomingSecretKey)
+        : (incomingSecretKey || existingSecretKey || "");
     const resolvedWebhookSecret = options?.webhookSecret ?? existingWebhookSecret;
     return rewriteAscendKitEnvBlock(filePath, {
         NEXT_PUBLIC_ASCENDKIT_API_URL: resolvedApiUrl,
@@ -201,6 +210,124 @@ async function updateRuntimeEnvFile(filePath, apiUrl, publicKey, secretKey, opti
         ASCENDKIT_WEBHOOK_SECRET: resolvedWebhookSecret,
     });
 }
+async function syncLocalEnvFiles(apiUrl, publicKey, secretKey) {
+    const cwd = process.cwd();
+    const folders = await findEnvFolders(cwd);
+    const updatedFiles = [];
+    for (const folder of folders) {
+        for (const filePath of folder.examples) {
+            const changed = await updateEnvExampleFile(filePath);
+            if (changed)
+                updatedFiles.push(path.relative(cwd, filePath));
+        }
+        for (const filePath of folder.runtime) {
+            const changed = await updateRuntimeEnvFile(filePath, apiUrl, publicKey, secretKey);
+            if (changed)
+                updatedFiles.push(path.relative(cwd, filePath));
+        }
+    }
+    return updatedFiles;
+}
+function saveActiveEnvironmentContext(result) {
+    saveEnvContext({
+        publicKey: result.environment.publicKey,
+        projectId: result.project.id,
+        projectName: result.project.name,
+        environmentId: result.environment.id,
+        environmentName: result.environment.name,
+        tier: result.environment.tier,
+    });
+}
+async function activateEnvironment(auth, result, options) {
+    const promptForFileUpdates = options?.promptForFileUpdates ?? true;
+    const shouldSetupWebhook = options?.setupWebhook ?? true;
+    const logOutput = options?.logOutput ?? true;
+    saveActiveEnvironmentContext(result);
+    if (logOutput) {
+        console.log(`  → Project: ${result.project.name}`);
+        console.log(`  → Environment: ${result.environment.name}`);
+        console.log(`  → Role: ${result.role}`);
+    }
+    const cwd = process.cwd();
+    const folders = await findEnvFolders(cwd);
+    const updatedFiles = [];
+    const consentedRuntimeFolders = [];
+    if (folders.length > 0) {
+        if (logOutput) {
+            console.log(`\nFound env files in ${folders.length} folder(s).`);
+        }
+        for (const folder of folders) {
+            let update = true;
+            if (promptForFileUpdates) {
+                const fileNames = [...folder.examples, ...folder.runtime]
+                    .map(f => path.basename(f)).join(", ");
+                update = await promptYesNo(`  ${folder.label} (${fileNames}) — update?`, true);
+            }
+            if (!update)
+                continue;
+            for (const filePath of folder.examples) {
+                const changed = await updateEnvExampleFile(filePath);
+                if (changed)
+                    updatedFiles.push(path.relative(cwd, filePath));
+            }
+            if (folder.runtime.length > 0) {
+                consentedRuntimeFolders.push(folder);
+                for (const filePath of folder.runtime) {
+                    const changed = await updateRuntimeEnvFile(filePath, auth.apiUrl, result.environment.publicKey, result.environment.secretKey);
+                    if (changed)
+                        updatedFiles.push(path.relative(cwd, filePath));
+                }
+            }
+        }
+    }
+    if (logOutput) {
+        console.log("\nUpdated files:");
+        if (updatedFiles.length === 0) {
+            console.log("  (none)");
+        }
+        else {
+            for (const filePath of updatedFiles)
+                console.log(`  - ${filePath}`);
+        }
+        if (!result.environment.secretKey) {
+            console.log("\nNote: your role does not have access to the environment secret key.");
+        }
+    }
+    if (!shouldSetupWebhook) {
+        return { updatedFiles, webhookSecret: null };
+    }
+    const webhookSecret = await setupWebhook(auth, result.environment.publicKey);
+    if (webhookSecret) {
+        if (consentedRuntimeFolders.length > 0) {
+            for (const folder of consentedRuntimeFolders) {
+                for (const filePath of folder.runtime) {
+                    await updateRuntimeEnvFile(filePath, auth.apiUrl, result.environment.publicKey, result.environment.secretKey, { preserveExistingKeys: true, webhookSecret });
+                }
+            }
+            if (logOutput) {
+                console.log("\nWebhook secret written to .env file(s).");
+            }
+        }
+        else if (logOutput) {
+            console.log(`\nAdd this to your environment:`);
+            console.log(`  ASCENDKIT_WEBHOOK_SECRET=${webhookSecret}`);
+        }
+    }
+    if (logOutput) {
+        const remainingSteps = [];
+        if (!webhookSecret) {
+            remainingSteps.push("Set up a webhook endpoint (run ascendkit set-env again, or use the portal).");
+        }
+        remainingSteps.push("Ensure frontend and backend are using keys from the same AscendKit environment.");
+        if (remainingSteps.length > 0) {
+            console.log("\nWhat you still need to do:");
+            for (let i = 0; i < remainingSteps.length; i++) {
+                console.log(`  ${i + 1}. ${remainingSteps[i]}`);
+            }
+        }
+    }
+    return { updatedFiles, webhookSecret };
+}
 function generateDeviceCode() {
     const chars = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789"; // no I, O, 0, 1 for readability
     let code = "";
@@ -223,6 +350,28 @@ async function apiRequest(apiUrl, method, path, body, token, publicKey) {
     const response = await fetch(`${apiUrl}${path}`, init);
     if (!response.ok) {
         const text = await response.text();
+        if (!text) {
+            throw new Error(`API error ${response.status}: ${response.statusText}`);
+        }
+        try {
+            const parsed = JSON.parse(text);
+            if (typeof parsed.error === "string") {
+                throw new Error(parsed.error);
+            }
+            if (typeof parsed.detail === "string") {
+                throw new Error(parsed.detail);
+            }
+            if (parsed.detail
+                && typeof parsed.detail === "object"
+                && typeof parsed.detail.message === "string") {
+                throw new Error(parsed.detail.message);
+            }
+        }
+        catch (error) {
+            if (error instanceof Error && error.message !== text) {
+                throw error;
+            }
+        }
         throw new Error(`API error ${response.status}: ${text}`);
     }
     const json = await response.json();
@@ -330,6 +479,14 @@ export async function listProjects() {
     const auth = requireAuth();
     return apiRequest(auth.apiUrl, "GET", "/api/platform/projects", undefined, auth.token);
 }
+export async function showProject(projectId) {
+    const projects = await listProjects();
+    const project = projects.find((item) => item.id === projectId);
+    if (!project) {
+        throw new Error(`Project ${projectId} not found.`);
+    }
+    return project;
+}
 export async function createProject(name, description, enabledServices) {
     const auth = requireAuth();
     return apiRequest(auth.apiUrl, "POST", "/api/platform/projects", {
@@ -349,26 +506,7 @@ export async function useEnvironment(tier, projectId) {
     if (!env) {
         throw new Error(`No ${tier} environment found for project ${projectId}. Available: ${envs.map(e => e.tier).join(", ")}`);
     }
-    // Fetch project name for echo-back
-    let projectName = projectId;
-    try {
-        const projects = await apiRequest(auth.apiUrl, "GET", "/api/platform/projects", undefined, auth.token);
-        const project = projects.find(p => p.id === projectId);
-        if (project)
-            projectName = project.name;
-    }
-    catch { /* non-critical */ }
-    saveEnvContext({
-        publicKey: env.publicKey,
-        projectId,
-        projectName,
-        environmentId: env.id,
-        environmentName: env.name,
-        tier: env.tier,
-    });
-    console.log(`Active environment: ${env.name} (${env.tier})`);
-    console.log(`Project: ${projectName}`);
-    console.log(`Public key: ${env.publicKey}`);
+    await setEnv(env.publicKey);
 }
 async function setupWebhook(auth, publicKey) {
     // Never run webhook setup in non-interactive mode — selecting a webhook
@@ -434,82 +572,11 @@ async function setupWebhook(auth, publicKey) {
 export async function setEnv(publicKey) {
     const auth = requireAuth();
     const result = await apiRequest(auth.apiUrl, "GET", `/api/platform/resolve-key?pk=${encodeURIComponent(publicKey)}`, undefined, auth.token);
-    saveEnvContext({
-        publicKey: result.environment.publicKey,
-        projectId: result.project.id,
-        projectName: result.project.name,
-        environmentId: result.environment.id,
-        environmentName: result.environment.name,
-        tier: result.environment.tier,
+    await activateEnvironment(auth, result, {
+        promptForFileUpdates: true,
+        setupWebhook: true,
+        logOutput: true,
     });
-    console.log(`  → Project: ${result.project.name}`);
-    console.log(`  → Environment: ${result.environment.name}`);
-    console.log(`  → Role: ${result.role}`);
-    const cwd = process.cwd();
-    const folders = await findEnvFolders(cwd);
-    const updatedFiles = [];
-    const consentedRuntimeFolders = [];
-    if (folders.length > 0) {
-        console.log(`\nFound env files in ${folders.length} folder(s).`);
-        for (const folder of folders) {
-            const fileNames = [...folder.examples, ...folder.runtime]
-                .map(f => path.basename(f)).join(", ");
-            const update = await promptYesNo(`  ${folder.label} (${fileNames}) — update?`, true);
-            if (!update)
-                continue;
-            for (const filePath of folder.examples) {
-                const changed = await updateEnvExampleFile(filePath);
-                if (changed)
-                    updatedFiles.push(path.relative(cwd, filePath));
-            }
-            if (folder.runtime.length > 0) {
-                consentedRuntimeFolders.push(folder);
-                for (const filePath of folder.runtime) {
-                    const changed = await updateRuntimeEnvFile(filePath, auth.apiUrl, result.environment.publicKey, result.environment.secretKey ?? "");
-                    if (changed)
-                        updatedFiles.push(path.relative(cwd, filePath));
-                }
-            }
-        }
-    }
-    console.log("\nUpdated files:");
-    if (updatedFiles.length === 0) {
-        console.log("  (none)");
-    }
-    else {
-        for (const filePath of updatedFiles)
-            console.log(`  - ${filePath}`);
-    }
-    if (!result.environment.secretKey) {
-        console.log("\nNote: your role does not have access to the environment secret key.");
-    }
-    // --- Webhook setup ---
-    const webhookSecret = await setupWebhook(auth, result.environment.publicKey);
-    if (webhookSecret) {
-        if (consentedRuntimeFolders.length > 0) {
-            for (const folder of consentedRuntimeFolders) {
-                for (const filePath of folder.runtime) {
-                    await updateRuntimeEnvFile(filePath, auth.apiUrl, result.environment.publicKey, result.environment.secretKey ?? "", { preserveExistingKeys: true, webhookSecret });
-                }
-            }
-            console.log("\nWebhook secret written to .env file(s).");
-        }
-        else {
-            console.log(`\nAdd this to your environment:`);
-            console.log(`  ASCENDKIT_WEBHOOK_SECRET=${webhookSecret}`);
-        }
-    }
-    const remainingSteps = [];
-    if (!webhookSecret) {
-        remainingSteps.push("Set up a webhook endpoint (run ascendkit set-env again, or use the portal).");
-    }
-    remainingSteps.push("Ensure frontend and backend are using keys from the same AscendKit environment.");
-    if (remainingSteps.length > 0) {
-        console.log("\nWhat you still need to do:");
-        for (let i = 0; i < remainingSteps.length; i++) {
-            console.log(`  ${i + 1}. ${remainingSteps[i]}`);
-        }
-    }
 }
 export async function mcpLogin(client, params) {
     const data = await client.publicRequest("POST", "/api/platform/auth/token", {
@@ -517,8 +584,20 @@ export async function mcpLogin(client, params) {
         password: params.password,
     });
     client.configurePlatform(data.token);
+    saveAuth({ token: data.token, apiUrl: client.currentApiUrl });
+    ensureGitignore();
     return data;
 }
+export async function mcpSetEnvironmentByPublicKey(client, publicKey) {
+    const result = await client.platformRequest("GET", `/api/platform/resolve-key?pk=${encodeURIComponent(publicKey)}`);
+    client.configure(result.environment.publicKey);
+    const { updatedFiles } = await activateEnvironment({ token: "__mcp__", apiUrl: client.currentApiUrl }, result, {
+        promptForFileUpdates: false,
+        setupWebhook: false,
+        logOutput: false,
+    });
+    return { ...result, updatedFiles };
+}
 export async function mcpListProjects(client) {
     return client.platformRequest("GET", "/api/platform/projects");
 }
@@ -546,7 +625,7 @@ export async function updateEnvironment(projectId, envId, name, description) {
 }
 export async function promoteEnvironment(environmentId, targetTier) {
     const auth = requireAuth();
-    return apiRequest(auth.apiUrl, "POST", `/api/platform/environments/${environmentId}/promote`, { targetTier, dryRun: false }, auth.token);
+    return apiRequest(auth.apiUrl, "POST", `/api/platform/environments/${environmentId}/promote`, { targetTier: normalizePromotionTier(targetTier), dryRun: false }, auth.token);
 }
 export async function mcpUpdateEnvironment(client, params) {
     const body = {};
@@ -557,5 +636,44 @@ export async function mcpUpdateEnvironment(client, params) {
     return client.platformRequest("PATCH", `/api/platform/projects/${params.projectId}/environments/${params.environmentId}`, body);
 }
 export async function mcpPromoteEnvironment(client, params) {
-    return client.platformRequest("POST", `/api/platform/environments/${params.environmentId}/promote`, { targetTier: params.targetTier, dryRun: false });
+    return client.platformRequest("POST", `/api/platform/environments/${params.environmentId}/promote`, { targetTier: normalizePromotionTier(params.targetTier), dryRun: false });
+}
+function resolveActiveEnvironmentIds(params) {
+    if (params?.projectId && params?.envId) {
+        return { projectId: params.projectId, envId: params.envId };
+    }
+    const ctx = loadEnvContext();
+    if (!ctx?.projectId || !ctx.environmentId) {
+        throw new Error("No active environment found. Use ascendkit_set_env or ascendkit set-env first.");
+    }
+    return {
+        projectId: params?.projectId ?? ctx.projectId,
+        envId: params?.envId ?? ctx.environmentId,
+    };
+}
+export async function mcpGetEnvironment(client, params) {
+    const target = resolveActiveEnvironmentIds(params);
+    const envs = await client.platformRequest("GET", `/api/platform/projects/${target.projectId}/environments`);
+    const env = envs.find((item) => item.id === target.envId);
+    if (!env) {
+        throw new Error(`Environment ${target.envId} not found in project ${target.projectId}.`);
+    }
+    return env;
+}
+export async function mcpUpdateEnvironmentVariables(client, params) {
+    const target = resolveActiveEnvironmentIds(params);
+    return client.platformRequest("PATCH", `/api/platform/projects/${target.projectId}/environments/${target.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/commands/surveys.js

@@ -2,10 +2,10 @@ export async function createSurvey(client, params) {
     return client.managedPost("/api/surveys", params);
 }
 export async function listSurveys(client) {
-    return client.get("/api/surveys");
+    return client.managedGet("/api/surveys");
 }
 export async function getSurvey(client, surveyId) {
-    return client.get(`/api/surveys/${surveyId}`);
+    return client.managedGet(`/api/surveys/${surveyId}`);
 }
 export async function updateSurvey(client, surveyId, params) {
     return client.managedPut(`/api/surveys/${surveyId}`, params);
@@ -17,13 +17,13 @@ export async function distributeSurvey(client, surveyId, userIds) {
     return client.managedPost(`/api/surveys/${surveyId}/distribute`, { userIds });
 }
 export async function listInvitations(client, surveyId) {
-    return client.get(`/api/surveys/${surveyId}/invitations`);
+    return client.managedGet(`/api/surveys/${surveyId}/invitations`);
 }
 export async function getAnalytics(client, surveyId) {
-    return client.get(`/api/surveys/${surveyId}/analytics`);
+    return client.managedGet(`/api/surveys/${surveyId}/analytics`);
 }
 export async function listQuestions(client, surveyId) {
-    return client.get(`/api/surveys/${surveyId}/questions`);
+    return client.managedGet(`/api/surveys/${surveyId}/questions`);
 }
 export async function addQuestion(client, surveyId, params) {
     return client.managedPost(`/api/surveys/${surveyId}/questions`, params);

package/dist/mcp.js

@@ -10,21 +10,51 @@ 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";
+import { loadAuth, loadEnvContext } from "./utils/credentials.js";
+import * as platformCommands from "./commands/platform.js";
+import { CLI_VERSION } from "./api/client.js";
 const client = new AscendKitClient({
     apiUrl: process.env.ASCENDKIT_API_URL ?? DEFAULT_API_URL,
 });
+const persistedAuth = loadAuth();
+if (persistedAuth?.token) {
+    client.configurePlatform(persistedAuth.token, persistedAuth.apiUrl);
+}
+const persistedEnv = loadEnvContext();
+if (persistedEnv?.publicKey) {
+    client.configure(persistedEnv.publicKey, persistedAuth?.apiUrl ?? process.env.ASCENDKIT_API_URL ?? DEFAULT_API_URL);
+}
 const server = new McpServer({
     name: "ascendkit",
-    version: "0.1.0",
+    version: CLI_VERSION,
 });
-server.tool("ascendkit_configure", "Configure AscendKit with your project's public key. Must be called before using any other AscendKit tools.", {
+server.tool("ascendkit_configure", "Configure AscendKit with your project's public key. If platform auth is available, this also persists the shared .ascendkit environment context used by both MCP and CLI.", {
     publicKey: z.string().describe("Your project's public key (pk_dev_..., pk_beta_..., or pk_prod_...)"),
     apiUrl: z.string().optional().describe("AscendKit API URL (default: https://api.ascendkit.dev)"),
 }, async (params) => {
     client.configure(params.publicKey, params.apiUrl);
+    if (client.platformConfigured) {
+        try {
+            const data = await platformCommands.mcpSetEnvironmentByPublicKey(client, params.publicKey);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Active environment: ${data.environment.name} (${data.environment.tier})\n` +
+                            `Project: ${data.project.name}\n` +
+                            `Public key: ${data.environment.publicKey}\n` +
+                            `Updated env files: ${Array.isArray(data.updatedFiles) && data.updatedFiles.length > 0 ? data.updatedFiles.join(", ") : "(none)"}`,
+                    }],
+            };
+        }
+        catch {
+            // Fall back to in-memory configure if resolve/persist fails.
+        }
+    }
     return {
-        content: [{ type: "text", text: `Configured for project ${params.publicKey}` }],
+        content: [{ type: "text", text: `Configured for environment ${params.publicKey}` }],
     };
 });
 registerPlatformTools(server, client);
@@ -34,6 +64,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

@@ -1,11 +1,25 @@
 import { z } from "zod";
 import * as auth from "../commands/auth.js";
+function formatAuthSettings(data) {
+    const providers = Array.isArray(data.providers) ? data.providers : [];
+    const features = data.features ?? {};
+    const lines = [
+        `Providers: ${providers.length > 0 ? providers.join(", ") : "none"}`,
+        `Email verification: ${features.emailVerification ? "on" : "off"}`,
+        `Waitlist: ${features.waitlist ? "on" : "off"}`,
+        `Password reset: ${features.passwordReset ? "on" : "off"}`,
+        `Require username: ${features.requireUsername ? "on" : "off"}`,
+    ];
+    if (data.sessionDuration)
+        lines.push(`Session: ${data.sessionDuration}`);
+    return lines.join("\n");
+}
 export function registerAuthTools(server, client) {
-    server.tool("auth_get_settings", "Get authentication settings for the current project (enabled providers, features, OAuth configs)", {}, async () => {
+    server.tool("auth_show", "Get authentication settings for the current project (enabled providers, features, OAuth configs)", {}, async () => {
         const data = await auth.getSettings(client);
-        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+        return { content: [{ type: "text", text: formatAuthSettings(data) }] };
     });
-    server.tool("auth_update_settings", "Update authentication settings: providers, features, session duration. Credentials and magic-link are mutually exclusive. Social-only login is valid. emailVerification, passwordReset, requireUsername only apply when credentials is active; waitlist applies to all modes.", {
+    server.tool("auth_update", "Update authentication settings: providers, features, session duration. Credentials and magic-link are mutually exclusive. Social-only login is valid. emailVerification, passwordReset, requireUsername only apply when credentials is active; waitlist applies to all modes.", {
         providers: z
             .array(z.string())
             .optional()
@@ -25,22 +39,48 @@ export function registerAuthTools(server, client) {
             .describe('Session duration, e.g. "7d", "24h"'),
     }, async (params) => {
         const data = await auth.updateSettings(client, params);
-        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+        return { content: [{ type: "text", text: formatAuthSettings(data) }] };
     });
-    server.tool("auth_update_providers", "Set which auth providers are enabled for the project. Credentials and magic-link are mutually exclusive. Social-only login (e.g. [\"google\"]) is valid. At least one provider required.", {
+    server.tool("auth_provider_set", "Set which auth providers are enabled for the project. Credentials and magic-link are mutually exclusive. Social-only login (e.g. [\"google\"]) is valid. At least one provider required.", {
         providers: z
             .array(z.string())
             .describe('List of provider names, e.g. ["credentials", "google", "github"]'),
     }, async (params) => {
         const data = await auth.updateProviders(client, params.providers);
-        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+        return { content: [{ type: "text", text: formatAuthSettings(data) }] };
+    });
+    server.tool("auth_provider_list", "List enabled auth providers for the current project.", {}, async () => {
+        const data = await auth.getSettings(client);
+        const providers = Array.isArray(data.providers) ? data.providers : [];
+        return {
+            content: [{ type: "text", text: providers.length > 0 ? providers.join("\n") : "No providers configured." }],
+        };
     });
-    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_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: [{
@@ -68,8 +108,26 @@ export function registerAuthTools(server, client) {
                 }],
         };
     });
-    server.tool("auth_list_users", "List all project users (end-users who signed up via the SDK)", {}, async () => {
+    server.tool("auth_user_list", "List all project users (end-users who signed up via the SDK)", {}, async () => {
         const data = await auth.listUsers(client);
         return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
     });
+    server.tool("auth_user_remove", "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_user_bulk_remove", "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_user_reactivate", "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;