@ascendkit/cli 0.2.6 → 0.3.0

package/dist/commands/content.js

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

package/dist/commands/email.d.ts

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

package/dist/commands/email.js

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

package/dist/commands/journeys.d.ts

@@ -30,6 +30,7 @@ export declare function updateJourney(client: AscendKitClient, journeyId: string
 export declare function deleteJourney(client: AscendKitClient, journeyId: string): Promise<unknown>;
 export declare function activateJourney(client: AscendKitClient, journeyId: string): Promise<unknown>;
 export declare function pauseJourney(client: AscendKitClient, journeyId: string): Promise<unknown>;
+export declare function resumeJourney(client: AscendKitClient, journeyId: string): Promise<unknown>;
 export declare function archiveJourney(client: AscendKitClient, journeyId: string): Promise<unknown>;
 export declare function getJourneyAnalytics(client: AscendKitClient, journeyId: string): Promise<unknown>;
 export declare function getJourneyVisualization(client: AscendKitClient, journeyId: string): Promise<unknown>;

package/dist/commands/journeys.js

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

package/dist/commands/platform.d.ts

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

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 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,10 +636,33 @@ 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) {
-    return client.platformRequest("PATCH", `/api/platform/projects/${params.projectId}/environments/${params.envId}`, { variables: params.variables });
+    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();