@ascendkit/cli 0.1.10

package/dist/commands/platform.js

@@ -0,0 +1,517 @@
+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";
+const DEFAULT_API_URL = "https://api.ascendkit.com";
+const DEFAULT_PORTAL_URL = "http://localhost:3000";
+const POLL_INTERVAL_MS = 2000;
+const DEVICE_CODE_EXPIRY_MS = 300_000; // 5 minutes
+const IGNORE_DIRS = new Set([".git", "node_modules", ".next", "dist", "build"]);
+const ASCENDKIT_ENV_KEYS = [
+    "NEXT_PUBLIC_ASCENDKIT_API_URL",
+    "ASCENDKIT_API_URL",
+    "NEXT_PUBLIC_ASCENDKIT_ENV_KEY",
+    "ASCENDKIT_ENV_KEY",
+    "ASCENDKIT_SECRET_KEY",
+    "ASCENDKIT_WEBHOOK_SECRET",
+];
+const ASCENDKIT_BLOCK_START = "# --- AscendKit Managed Environment Variables ---";
+const ASCENDKIT_BLOCK_END = "# --- End AscendKit Managed Environment Variables ---";
+async function promptYesNo(question, defaultYes) {
+    const suffix = defaultYes ? "[Y/n]" : "[y/N]";
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        console.log(`${question} ${suffix} (auto-selected: ${defaultYes ? "yes" : "no"})`);
+        return defaultYes;
+    }
+    const { createInterface } = await import("node:readline/promises");
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = (await rl.question(`${question} ${suffix} `)).trim().toLowerCase();
+        if (!answer)
+            return defaultYes;
+        return answer === "y" || answer === "yes";
+    }
+    finally {
+        rl.close();
+    }
+}
+async function promptLine(question) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY)
+        return "";
+    const { createInterface } = await import("node:readline/promises");
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        return (await rl.question(question)).trim();
+    }
+    finally {
+        rl.close();
+    }
+}
+async function promptChoice(question, options) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY)
+        return 0;
+    const { createInterface } = await import("node:readline/promises");
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        for (let i = 0; i < options.length; i++) {
+            console.log(`  ${i + 1}. ${options[i]}`);
+        }
+        const answer = (await rl.question(question)).trim();
+        const idx = parseInt(answer, 10) - 1;
+        if (isNaN(idx) || idx < 0 || idx >= options.length)
+            return 0;
+        return idx;
+    }
+    finally {
+        rl.close();
+    }
+}
+async function findEnvFiles(root) {
+    const examples = [];
+    const runtime = [];
+    async function walk(dir) {
+        const entries = await readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (IGNORE_DIRS.has(entry.name))
+                    continue;
+                await walk(fullPath);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            if (entry.name === ".env.example") {
+                examples.push(fullPath);
+            }
+            else if (entry.name === ".env" || entry.name === ".env.local") {
+                runtime.push(fullPath);
+            }
+        }
+    }
+    await walk(root);
+    examples.sort();
+    runtime.sort();
+    return { examples, runtime };
+}
+function readEnvValue(content, key) {
+    const match = content.match(new RegExp(`^\\s*${key}=(.*)$`, "m"));
+    if (!match)
+        return null;
+    return match[1] ?? "";
+}
+function buildAscendKitEnvBlock(values) {
+    return [
+        ASCENDKIT_BLOCK_START,
+        "# AscendKit API URL (used by SDK to reach the backend)",
+        `NEXT_PUBLIC_ASCENDKIT_API_URL=${values.NEXT_PUBLIC_ASCENDKIT_API_URL}`,
+        `ASCENDKIT_API_URL=${values.ASCENDKIT_API_URL}`,
+        "",
+        "# AscendKit public env key (safe for browser and server use)",
+        `NEXT_PUBLIC_ASCENDKIT_ENV_KEY=${values.NEXT_PUBLIC_ASCENDKIT_ENV_KEY}`,
+        `ASCENDKIT_ENV_KEY=${values.ASCENDKIT_ENV_KEY}`,
+        "",
+        "# AscendKit secret key (server-only; never expose to client/browser)",
+        `ASCENDKIT_SECRET_KEY=${values.ASCENDKIT_SECRET_KEY}`,
+        "",
+        "# Webhook signing secret (server-only)",
+        `ASCENDKIT_WEBHOOK_SECRET=${values.ASCENDKIT_WEBHOOK_SECRET}`,
+        ASCENDKIT_BLOCK_END,
+    ];
+}
+async function rewriteAscendKitEnvBlock(filePath, values) {
+    const original = await readFile(filePath, "utf8");
+    const lines = original.split(/\r?\n/);
+    const filtered = [];
+    let inManagedBlock = false;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed === ASCENDKIT_BLOCK_START) {
+            inManagedBlock = true;
+            continue;
+        }
+        if (trimmed === ASCENDKIT_BLOCK_END) {
+            inManagedBlock = false;
+            continue;
+        }
+        if (inManagedBlock)
+            continue;
+        const key = line.split("=")[0]?.trim();
+        if (ASCENDKIT_ENV_KEYS.includes(key))
+            continue;
+        filtered.push(line);
+    }
+    while (filtered.length > 0 && filtered[filtered.length - 1].trim() === "") {
+        filtered.pop();
+    }
+    if (filtered.length > 0)
+        filtered.push("");
+    filtered.push(...buildAscendKitEnvBlock(values));
+    const updated = `${filtered.join("\n").replace(/\n+$/, "")}\n`;
+    if (updated === original)
+        return false;
+    await writeFile(filePath, updated, "utf8");
+    return true;
+}
+async function updateEnvExampleFile(filePath) {
+    return rewriteAscendKitEnvBlock(filePath, {
+        NEXT_PUBLIC_ASCENDKIT_API_URL: "",
+        ASCENDKIT_API_URL: "",
+        NEXT_PUBLIC_ASCENDKIT_ENV_KEY: "",
+        ASCENDKIT_ENV_KEY: "",
+        ASCENDKIT_SECRET_KEY: "",
+        ASCENDKIT_WEBHOOK_SECRET: "",
+    });
+}
+async function updateRuntimeEnvFile(filePath, apiUrl, publicKey, secretKey, options) {
+    const original = await readFile(filePath, "utf8");
+    const preserveExistingKeys = options?.preserveExistingKeys ?? false;
+    const existingApiUrl = readEnvValue(original, "ASCENDKIT_API_URL");
+    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 resolvedPublicKey = preserveExistingKeys
+        ? (existingPublicKey && existingPublicKey.trim() ? existingPublicKey : publicKey)
+        : publicKey;
+    const resolvedSecretKey = preserveExistingKeys
+        ? (existingSecretKey && existingSecretKey.trim() ? existingSecretKey : secretKey)
+        : secretKey;
+    const resolvedWebhookSecret = options?.webhookSecret ?? existingWebhookSecret;
+    return rewriteAscendKitEnvBlock(filePath, {
+        NEXT_PUBLIC_ASCENDKIT_API_URL: resolvedApiUrl,
+        ASCENDKIT_API_URL: resolvedApiUrl,
+        NEXT_PUBLIC_ASCENDKIT_ENV_KEY: resolvedPublicKey,
+        ASCENDKIT_ENV_KEY: resolvedPublicKey,
+        ASCENDKIT_SECRET_KEY: resolvedSecretKey,
+        ASCENDKIT_WEBHOOK_SECRET: resolvedWebhookSecret,
+    });
+}
+function generateDeviceCode() {
+    const chars = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789"; // no I, O, 0, 1 for readability
+    let code = "";
+    for (let i = 0; i < 8; i++) {
+        if (i === 4)
+            code += "-";
+        code += chars[Math.floor(Math.random() * chars.length)];
+    }
+    return code;
+}
+async function apiRequest(apiUrl, method, path, body, token, publicKey) {
+    const headers = { "Content-Type": "application/json" };
+    if (token)
+        headers["Authorization"] = `Bearer ${token}`;
+    if (publicKey)
+        headers["X-AscendKit-Public-Key"] = publicKey;
+    const init = { method, headers };
+    if (body !== undefined)
+        init.body = JSON.stringify(body);
+    const response = await fetch(`${apiUrl}${path}`, init);
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`API error ${response.status}: ${text}`);
+    }
+    const json = await response.json();
+    return json.data;
+}
+async function openBrowser(url) {
+    const { execFile } = await import("node:child_process");
+    if (process.platform === "darwin") {
+        execFile("open", [url]);
+    }
+    else if (process.platform === "win32") {
+        // "start" is a cmd.exe built-in — invoke via cmd.exe with execFile.
+        // Escape cmd.exe metacharacters with ^ to prevent injection.
+        const safe = url.replace(/[&|<>^"]/g, "^$&");
+        execFile("cmd.exe", ["/c", "start", "", safe]);
+    }
+    else {
+        execFile("xdg-open", [url]);
+    }
+}
+export async function init(apiUrl, portalUrl) {
+    const api = apiUrl ?? DEFAULT_API_URL;
+    const portal = portalUrl ?? DEFAULT_PORTAL_URL;
+    const deviceCode = generateDeviceCode();
+    console.log(`\nDevice code: ${deviceCode}\n`);
+    // Register the device code with the backend
+    try {
+        await apiRequest(api, "POST", "/api/platform/cli/auth-request", {
+            deviceCode,
+            machineHostname: hostname(),
+            machinePlatform: `${osPlatform()} ${release()}`,
+        });
+    }
+    catch (err) {
+        throw new Error(`Failed to start login flow: ${err.message}`);
+    }
+    // Open browser
+    const authUrl = `${portal}/cli-auth?code=${deviceCode}`;
+    console.log(`Opening browser to: ${authUrl}`);
+    console.log("If the browser doesn't open, navigate to the URL above.\n");
+    openBrowser(authUrl);
+    console.log("Waiting for authorization...");
+    // Poll for approval
+    const deadline = Date.now() + DEVICE_CODE_EXPIRY_MS;
+    while (Date.now() < deadline) {
+        await new Promise(resolve => setTimeout(resolve, POLL_INTERVAL_MS));
+        try {
+            const result = await apiRequest(api, "GET", `/api/platform/cli/auth-status?code=${deviceCode}`);
+            if (result.status === "approved" && result.token) {
+                saveAuth({ token: result.token, apiUrl: api });
+                ensureGitignore();
+                console.log(`\nInitialized as ${result.email ?? "unknown"}`);
+                // Seed .env files with API URL and empty key placeholders
+                const cwd = process.cwd();
+                const discovered = await findEnvFiles(cwd);
+                if (discovered.examples.length > 0) {
+                    console.log(`\nFound ${discovered.examples.length} .env.example file(s).`);
+                    const updateExamples = await promptYesNo("Update with AscendKit env placeholders?", true);
+                    if (updateExamples) {
+                        for (const filePath of discovered.examples) {
+                            const changed = await updateEnvExampleFile(filePath);
+                            if (changed)
+                                console.log(`  Updated ${path.relative(cwd, filePath)}`);
+                        }
+                    }
+                }
+                if (discovered.runtime.length > 0) {
+                    console.log(`\nFound ${discovered.runtime.length} .env/.env.local file(s).`);
+                    const updateRuntime = await promptYesNo("Seed with AscendKit API URL?", true);
+                    if (updateRuntime) {
+                        for (const filePath of discovered.runtime) {
+                            const changed = await updateRuntimeEnvFile(filePath, api, "", "", {
+                                preserveExistingKeys: true,
+                            });
+                            if (changed)
+                                console.log(`  Updated ${path.relative(cwd, filePath)}`);
+                        }
+                    }
+                }
+                return;
+            }
+            if (result.status === "expired") {
+                throw new Error("Login request expired. Please try again.");
+            }
+        }
+        catch (err) {
+            if (err.message.includes("expired"))
+                throw err;
+            // Transient error, keep polling
+        }
+    }
+    throw new Error("Login request timed out. Please try again.");
+}
+export function logout() {
+    deleteAuth();
+    console.log("Logged out.");
+}
+function requireAuth() {
+    const auth = loadAuth();
+    if (!auth?.token) {
+        console.error("Not initialized. Run: ascendkit init");
+        process.exit(1);
+    }
+    return auth;
+}
+export async function listProjects() {
+    const auth = requireAuth();
+    return apiRequest(auth.apiUrl, "GET", "/api/platform/projects", undefined, auth.token);
+}
+export async function listEnvironments(projectId) {
+    const auth = requireAuth();
+    return apiRequest(auth.apiUrl, "GET", `/api/platform/projects/${projectId}/environments`, undefined, auth.token);
+}
+export async function useEnvironment(tier, projectId) {
+    const auth = requireAuth();
+    const envs = await apiRequest(auth.apiUrl, "GET", `/api/platform/projects/${projectId}/environments`, undefined, auth.token);
+    const env = envs.find(e => e.tier === tier);
+    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}`);
+}
+async function setupWebhook(auth, publicKey) {
+    // Never run webhook setup in non-interactive mode — selecting a webhook
+    // returns its secret, which would be printed to stdout/CI logs.
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        console.log("\nSkipping webhook setup (non-interactive mode). Run ascendkit set-env interactively or use the portal.");
+        return null;
+    }
+    console.log("\n--- Webhook Setup ---");
+    console.log("Webhooks are required for login/signup writebacks (user.created, user.login, etc.).");
+    let existingWebhooks = [];
+    try {
+        existingWebhooks = await apiRequest(auth.apiUrl, "GET", "/api/v1/webhooks", undefined, auth.token, publicKey);
+    }
+    catch {
+        console.error("Could not fetch existing webhooks. You can set up webhooks later in the portal.");
+        return null;
+    }
+    if (existingWebhooks.length > 0) {
+        console.log(`\nFound ${existingWebhooks.length} existing webhook(s):`);
+        const options = existingWebhooks.map(w => `${w.url} (${w.events.join(", ")})`);
+        options.push("Create a new webhook");
+        options.push("Skip webhook setup");
+        const choice = await promptChoice("\nWhich webhook to use? ", options);
+        if (choice === options.length - 1) {
+            // Skip
+            return null;
+        }
+        if (choice < existingWebhooks.length) {
+            // Reuse existing
+            const selected = existingWebhooks[choice];
+            console.log(`\nUsing webhook: ${selected.url}`);
+            return selected.secret;
+        }
+        // Fall through to create new
+    }
+    else {
+        const create = await promptYesNo("\nNo webhooks configured. Create one now?", true);
+        if (!create)
+            return null;
+    }
+    // Create new webhook
+    console.log("\nThe webhook URL is where AscendKit sends event notifications.");
+    console.log("Typically this is your backend or frontend /api/webhook/ascendkit endpoint.");
+    console.log("Example: http://localhost:3000/api/webhook/ascendkit");
+    const url = await promptLine("\nWebhook URL: ");
+    if (!url) {
+        console.log("No URL provided. Skipping webhook setup.");
+        return null;
+    }
+    try {
+        const created = await apiRequest(auth.apiUrl, "POST", "/api/v1/webhooks", { url, events: ["user.created"] }, auth.token, publicKey);
+        console.log(`\nWebhook created: ${created.url}`);
+        console.log(`  Events: ${created.events.join(", ")}`);
+        console.log(`  ID: ${created.id}`);
+        return created.secret;
+    }
+    catch (err) {
+        console.error(`Failed to create webhook: ${err.message}`);
+        return null;
+    }
+}
+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,
+    });
+    console.log(`  → Project: ${result.project.name}`);
+    console.log(`  → Environment: ${result.environment.name}`);
+    console.log(`  → Role: ${result.role}`);
+    const cwd = process.cwd();
+    const discovered = await findEnvFiles(cwd);
+    const updatedExamples = [];
+    const updatedRuntime = [];
+    console.log(`\nFound ${discovered.examples.length} .env.example file(s).`);
+    if (discovered.examples.length > 0) {
+        const updateExamples = await promptYesNo("Update with env placeholders?", true);
+        if (updateExamples) {
+            for (const filePath of discovered.examples) {
+                const changed = await updateEnvExampleFile(filePath);
+                if (changed)
+                    updatedExamples.push(path.relative(cwd, filePath));
+            }
+        }
+    }
+    console.log(`\nFound ${discovered.runtime.length} .env/.env.local file(s).`);
+    let runtimeConsent = false;
+    if (discovered.runtime.length > 0) {
+        runtimeConsent = await promptYesNo("Update with actual env and secret values?", false);
+        if (runtimeConsent) {
+            for (const filePath of discovered.runtime) {
+                const changed = await updateRuntimeEnvFile(filePath, auth.apiUrl, result.environment.publicKey, result.environment.secretKey ?? "");
+                if (changed)
+                    updatedRuntime.push(path.relative(cwd, filePath));
+            }
+        }
+    }
+    console.log("\nUpdated files:");
+    if (updatedExamples.length === 0 && updatedRuntime.length === 0) {
+        console.log("  (none)");
+    }
+    else {
+        for (const filePath of updatedExamples)
+            console.log(`  - ${filePath}`);
+        for (const filePath of updatedRuntime)
+            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 (runtimeConsent && discovered.runtime.length > 0) {
+            for (const filePath of discovered.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", {
+        email: params.email,
+        password: params.password,
+    });
+    client.configurePlatform(data.token);
+    return data;
+}
+export async function mcpListProjects(client) {
+    return client.platformRequest("GET", "/api/platform/projects");
+}
+export async function mcpCreateProject(client, params) {
+    return client.platformRequest("POST", "/api/platform/projects", {
+        name: params.name,
+        description: params.description ?? "",
+        enabledServices: params.enabledServices ?? [],
+    });
+}
+export async function mcpListEnvironments(client, projectId) {
+    return client.platformRequest("GET", `/api/platform/projects/${projectId}/environments`);
+}
+export async function mcpCreateEnvironment(client, params) {
+    return client.platformRequest("POST", `/api/platform/projects/${params.projectId}/environments`, { name: params.name, description: params.description ?? "", tier: params.tier });
+}

package/dist/commands/surveys.d.ts

@@ -0,0 +1,51 @@
+import { AscendKitClient } from "../api/client.js";
+export interface CreateSurveyParams {
+    name: string;
+    type?: "nps" | "csat" | "custom";
+    definition?: Record<string, unknown>;
+}
+export interface UpdateSurveyParams {
+    name?: string;
+    definition?: Record<string, unknown>;
+    status?: "draft" | "active" | "paused";
+}
+export declare function createSurvey(client: AscendKitClient, params: CreateSurveyParams): Promise<unknown>;
+export declare function listSurveys(client: AscendKitClient): Promise<unknown>;
+export declare function getSurvey(client: AscendKitClient, surveyId: string): Promise<unknown>;
+export declare function updateSurvey(client: AscendKitClient, surveyId: string, params: UpdateSurveyParams): Promise<unknown>;
+export declare function deleteSurvey(client: AscendKitClient, surveyId: string): Promise<unknown>;
+export declare function distributeSurvey(client: AscendKitClient, surveyId: string, userIds: string[]): Promise<unknown>;
+export declare function listInvitations(client: AscendKitClient, surveyId: string): Promise<unknown>;
+export declare function getAnalytics(client: AscendKitClient, surveyId: string): Promise<unknown>;
+export interface AddQuestionParams {
+    type: string;
+    title: string;
+    name?: string;
+    isRequired?: boolean;
+    choices?: string[];
+    rateMin?: number;
+    rateMax?: number;
+    minRateDescription?: string;
+    maxRateDescription?: string;
+    inputType?: string;
+    visibleIf?: string;
+    requiredIf?: string;
+    position?: number;
+}
+export interface EditQuestionParams {
+    title?: string;
+    isRequired?: boolean;
+    choices?: string[];
+    rateMin?: number;
+    rateMax?: number;
+    minRateDescription?: string;
+    maxRateDescription?: string;
+    inputType?: string;
+    visibleIf?: string;
+    requiredIf?: string;
+}
+export declare function listQuestions(client: AscendKitClient, surveyId: string): Promise<unknown>;
+export declare function addQuestion(client: AscendKitClient, surveyId: string, params: AddQuestionParams): Promise<unknown>;
+export declare function editQuestion(client: AscendKitClient, surveyId: string, questionName: string, params: EditQuestionParams): Promise<unknown>;
+export declare function removeQuestion(client: AscendKitClient, surveyId: string, questionName: string): Promise<unknown>;
+export declare function reorderQuestions(client: AscendKitClient, surveyId: string, order: string[]): Promise<unknown>;

package/dist/commands/surveys.js

@@ -0,0 +1,41 @@
+export async function createSurvey(client, params) {
+    return client.managedPost("/api/surveys", params);
+}
+export async function listSurveys(client) {
+    return client.get("/api/surveys");
+}
+export async function getSurvey(client, surveyId) {
+    return client.get(`/api/surveys/${surveyId}`);
+}
+export async function updateSurvey(client, surveyId, params) {
+    return client.managedPut(`/api/surveys/${surveyId}`, params);
+}
+export async function deleteSurvey(client, surveyId) {
+    return client.managedDelete(`/api/surveys/${surveyId}`);
+}
+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`);
+}
+export async function getAnalytics(client, surveyId) {
+    return client.get(`/api/surveys/${surveyId}/analytics`);
+}
+export async function listQuestions(client, surveyId) {
+    return client.get(`/api/surveys/${surveyId}/questions`);
+}
+export async function addQuestion(client, surveyId, params) {
+    return client.managedPost(`/api/surveys/${surveyId}/questions`, params);
+}
+export async function editQuestion(client, surveyId, questionName, params) {
+    return client.managedPut(`/api/surveys/${surveyId}/questions/${encodeURIComponent(questionName)}`, params);
+}
+export async function removeQuestion(client, surveyId, questionName) {
+    return client.managedDelete(`/api/surveys/${surveyId}/questions/${encodeURIComponent(questionName)}`);
+}
+export async function reorderQuestions(client, surveyId, order) {
+    return client.managedPut(`/api/surveys/${surveyId}/questions/reorder`, {
+        order,
+    });
+}

package/dist/commands/webhooks.d.ts

@@ -0,0 +1,16 @@
+import { AscendKitClient } from "../api/client.js";
+export interface CreateWebhookParams {
+    url: string;
+    events?: string[];
+}
+export interface UpdateWebhookParams {
+    url?: string;
+    events?: string[];
+    status?: "active" | "inactive";
+}
+export declare function createWebhook(client: AscendKitClient, params: CreateWebhookParams): Promise<unknown>;
+export declare function listWebhooks(client: AscendKitClient): Promise<unknown>;
+export declare function getWebhook(client: AscendKitClient, configId: string): Promise<unknown>;
+export declare function updateWebhook(client: AscendKitClient, configId: string, params: UpdateWebhookParams): Promise<unknown>;
+export declare function deleteWebhook(client: AscendKitClient, configId: string): Promise<unknown>;
+export declare function testWebhook(client: AscendKitClient, configId: string, eventType?: string): Promise<unknown>;

package/dist/commands/webhooks.js

@@ -0,0 +1,28 @@
+export async function createWebhook(client, params) {
+    return client.managedPost("/api/v1/webhooks", params);
+}
+export async function listWebhooks(client) {
+    return client.managedRequest("GET", "/api/v1/webhooks");
+}
+export async function getWebhook(client, configId) {
+    return client.managedRequest("GET", `/api/v1/webhooks/${configId}`);
+}
+export async function updateWebhook(client, configId, params) {
+    const body = {};
+    if (params.url !== undefined)
+        body.url = params.url;
+    if (params.events !== undefined)
+        body.events = params.events;
+    if (params.status !== undefined)
+        body.status = params.status;
+    return client.managedRequest("PATCH", `/api/v1/webhooks/${configId}`, body);
+}
+export async function deleteWebhook(client, configId) {
+    return client.managedDelete(`/api/v1/webhooks/${configId}`);
+}
+export async function testWebhook(client, configId, eventType) {
+    const body = {};
+    if (eventType !== undefined)
+        body.eventType = eventType;
+    return client.managedPost(`/api/v1/webhooks/${configId}/test`, body);
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};