@ascendkit/cli 0.1.10

package/dist/commands/auth.d.ts

@@ -0,0 +1,17 @@
+import { AscendKitClient } from "../api/client.js";
+export interface UpdateSettingsParams {
+    providers?: string[];
+    features?: {
+        emailVerification?: boolean;
+        waitlist?: boolean;
+        passwordReset?: boolean;
+        requireUsername?: boolean;
+    };
+    sessionDuration?: string;
+}
+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 getOAuthSetupUrl(portalUrl: string, provider: string, publicKey?: string): string;
+export declare function listUsers(client: AscendKitClient): Promise<unknown>;

package/dist/commands/auth.js

@@ -0,0 +1,29 @@
+export async function getSettings(client) {
+    return client.get("/api/auth/settings");
+}
+export async function updateSettings(client, params) {
+    const body = {};
+    if (params.providers !== undefined)
+        body.providers = params.providers;
+    if (params.features !== undefined)
+        body.features = params.features;
+    if (params.sessionDuration !== undefined)
+        body.sessionDuration = params.sessionDuration;
+    return client.managedPut("/api/auth/settings", body);
+}
+export async function updateProviders(client, providers) {
+    return client.managedPut("/api/auth/settings/providers", { providers });
+}
+export async function updateOAuthCredentials(client, provider, clientId, clientSecret, callbackUrl) {
+    const body = { clientId, clientSecret };
+    if (callbackUrl)
+        body.callbackUrl = callbackUrl;
+    return client.managedPut(`/api/auth/settings/oauth/${provider}`, body);
+}
+export function getOAuthSetupUrl(portalUrl, provider, publicKey) {
+    const base = `${portalUrl}/settings/oauth/${provider}`;
+    return publicKey ? `${base}?pk=${encodeURIComponent(publicKey)}` : base;
+}
+export async function listUsers(client) {
+    return client.managedRequest("GET", "/api/users");
+}

package/dist/commands/content.d.ts

@@ -0,0 +1,25 @@
+import { AscendKitClient } from "../api/client.js";
+export interface CreateTemplateParams {
+    name: string;
+    subject: string;
+    bodyHtml: string;
+    bodyText: string;
+    slug?: string;
+    description?: string;
+}
+export interface UpdateTemplateParams {
+    subject?: string;
+    bodyHtml?: string;
+    bodyText?: string;
+    changeNote?: string;
+}
+export declare function createTemplate(client: AscendKitClient, params: CreateTemplateParams): Promise<unknown>;
+export declare function listTemplates(client: AscendKitClient, params?: {
+    query?: string;
+    isSystem?: boolean;
+}): Promise<unknown>;
+export declare function getTemplate(client: AscendKitClient, templateId: string): Promise<unknown>;
+export declare function updateTemplate(client: AscendKitClient, templateId: string, params: UpdateTemplateParams): Promise<unknown>;
+export declare function deleteTemplate(client: AscendKitClient, templateId: string): Promise<unknown>;
+export declare function listVersions(client: AscendKitClient, templateId: string): Promise<unknown>;
+export declare function getVersion(client: AscendKitClient, templateId: string, versionNumber: number): Promise<unknown>;

package/dist/commands/content.js

@@ -0,0 +1,28 @@
+export async function createTemplate(client, params) {
+    return client.managedPost("/api/content/templates", params);
+}
+export async function listTemplates(client, params) {
+    const searchParams = new URLSearchParams();
+    if (params?.query)
+        searchParams.set("q", params.query);
+    if (params?.isSystem !== undefined)
+        searchParams.set("isSystem", String(params.isSystem));
+    const qs = searchParams.toString();
+    const path = qs ? `/api/content/templates?${qs}` : "/api/content/templates";
+    return client.get(path);
+}
+export async function getTemplate(client, templateId) {
+    return client.get(`/api/content/templates/${templateId}`);
+}
+export async function updateTemplate(client, templateId, params) {
+    return client.managedPut(`/api/content/templates/${templateId}`, params);
+}
+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`);
+}
+export async function getVersion(client, templateId, versionNumber) {
+    return client.get(`/api/content/templates/${templateId}/versions/${versionNumber}`);
+}

package/dist/commands/email.d.ts

@@ -0,0 +1,37 @@
+import { AscendKitClient } from "../api/client.js";
+export interface UpdateEmailSettingsParams {
+    fromEmail?: string;
+    fromName?: string;
+}
+export interface DnsProviderInfo {
+    id?: string;
+    name?: string;
+    confidence?: string;
+    portalUrl?: string;
+    assistantSetupUrl?: string;
+    supportsOneClick?: boolean;
+    nameservers?: string[];
+}
+export interface EmailSettings {
+    fromEmail?: string;
+    fromName?: string;
+    domain?: string;
+    verificationStatus?: string;
+    dnsRecords?: Array<{
+        type: string;
+        name: string;
+        value: string;
+    }>;
+    dnsProvider?: DnsProviderInfo;
+}
+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 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>;

package/dist/commands/email.js

@@ -0,0 +1,39 @@
+export async function getSettings(client) {
+    return client.get("/api/email/settings");
+}
+export async function updateSettings(client, params) {
+    const body = {};
+    if (params.fromEmail !== undefined)
+        body.fromEmail = params.fromEmail;
+    if (params.fromName !== undefined)
+        body.fromName = params.fromName;
+    return client.managedPut("/api/email/settings", body);
+}
+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");
+}
+export async function getDnsProvider(client, domain) {
+    const suffix = domain ? `?domain=${encodeURIComponent(domain)}` : "";
+    return client.get(`/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;
+}

package/dist/commands/journeys.d.ts

@@ -0,0 +1,86 @@
+import { AscendKitClient } from "../api/client.js";
+export interface JourneyCreateParams {
+    name: string;
+    description?: string;
+    entryEvent: string;
+    entryNode: string;
+    entryConditions?: Record<string, unknown>;
+    reEntryPolicy?: "skip" | "restart";
+    nodes?: Record<string, unknown>;
+    transitions?: Array<Record<string, unknown>>;
+}
+export interface JourneyUpdateParams {
+    name?: string;
+    description?: string;
+    entryEvent?: string;
+    entryNode?: string;
+    entryConditions?: Record<string, unknown>;
+    reEntryPolicy?: "skip" | "restart";
+    nodes?: Record<string, unknown>;
+    transitions?: Array<Record<string, unknown>>;
+}
+export declare function createJourney(client: AscendKitClient, params: JourneyCreateParams): Promise<unknown>;
+export declare function listJourneys(client: AscendKitClient, opts?: {
+    status?: string;
+    limit?: number;
+    offset?: number;
+}): Promise<unknown>;
+export declare function getJourney(client: AscendKitClient, journeyId: string): Promise<unknown>;
+export declare function updateJourney(client: AscendKitClient, journeyId: string, params: JourneyUpdateParams): Promise<unknown>;
+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 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>;
+export interface AddNodeParams {
+    name: string;
+    action?: {
+        type: string;
+        templateSlug?: string;
+        surveySlug?: string;
+        tagName?: string;
+        stageName?: string;
+    };
+    terminal?: boolean;
+}
+export interface EditNodeParams {
+    action?: {
+        type: string;
+        templateSlug?: string;
+        surveySlug?: string;
+        tagName?: string;
+        stageName?: string;
+    };
+    terminal?: boolean;
+}
+export declare function listNodes(client: AscendKitClient, journeyId: string): Promise<unknown>;
+export declare function addNode(client: AscendKitClient, journeyId: string, params: AddNodeParams): Promise<unknown>;
+export declare function editNode(client: AscendKitClient, journeyId: string, nodeName: string, params: EditNodeParams): Promise<unknown>;
+export declare function removeNode(client: AscendKitClient, journeyId: string, nodeName: string): Promise<unknown>;
+export interface AddTransitionParams {
+    from: string;
+    to: string;
+    trigger: {
+        type: string;
+        event?: string;
+        delay?: string;
+    };
+    priority?: number;
+    name?: string;
+}
+export interface EditTransitionParams {
+    trigger?: {
+        type: string;
+        event?: string;
+        delay?: string;
+    };
+    priority?: number;
+}
+export declare function listTransitions(client: AscendKitClient, journeyId: string, opts?: {
+    from_node?: string;
+    to_node?: string;
+}): Promise<unknown>;
+export declare function addTransition(client: AscendKitClient, journeyId: string, params: AddTransitionParams): Promise<unknown>;
+export declare function editTransition(client: AscendKitClient, journeyId: string, transitionName: string, params: EditTransitionParams): Promise<unknown>;
+export declare function removeTransition(client: AscendKitClient, journeyId: string, transitionName: string): Promise<unknown>;

package/dist/commands/journeys.js

@@ -0,0 +1,69 @@
+const BASE = "/api/v1/journeys";
+export async function createJourney(client, params) {
+    return client.managedPost(BASE, params);
+}
+export async function listJourneys(client, opts) {
+    const qs = new URLSearchParams();
+    if (opts?.status)
+        qs.set("status", opts.status);
+    if (opts?.limit != null)
+        qs.set("limit", String(opts.limit));
+    if (opts?.offset != null)
+        qs.set("offset", String(opts.offset));
+    const query = qs.toString();
+    return client.get(`${BASE}${query ? `?${query}` : ""}`);
+}
+export async function getJourney(client, journeyId) {
+    return client.get(`${BASE}/${journeyId}`);
+}
+export async function updateJourney(client, journeyId, params) {
+    return client.managedRequest("PATCH", `${BASE}/${journeyId}`, params);
+}
+export async function deleteJourney(client, journeyId) {
+    return client.managedDelete(`${BASE}/${journeyId}`);
+}
+export async function activateJourney(client, journeyId) {
+    return client.managedPost(`${BASE}/${journeyId}/activate`);
+}
+export async function pauseJourney(client, journeyId) {
+    return client.managedPost(`${BASE}/${journeyId}/pause`);
+}
+export async function archiveJourney(client, journeyId) {
+    return client.managedPost(`${BASE}/${journeyId}/archive`);
+}
+export async function getJourneyAnalytics(client, journeyId) {
+    return client.get(`${BASE}/${journeyId}/analytics`);
+}
+export async function getJourneyVisualization(client, journeyId) {
+    return client.get(`${BASE}/${journeyId}/visualization`);
+}
+export async function listNodes(client, journeyId) {
+    return client.get(`${BASE}/${journeyId}/nodes`);
+}
+export async function addNode(client, journeyId, params) {
+    return client.managedPost(`${BASE}/${journeyId}/nodes`, params);
+}
+export async function editNode(client, journeyId, nodeName, params) {
+    return client.managedRequest("PATCH", `${BASE}/${journeyId}/nodes/${encodeURIComponent(nodeName)}`, params);
+}
+export async function removeNode(client, journeyId, nodeName) {
+    return client.managedDelete(`${BASE}/${journeyId}/nodes/${encodeURIComponent(nodeName)}`);
+}
+export async function listTransitions(client, journeyId, opts) {
+    const qs = new URLSearchParams();
+    if (opts?.from_node)
+        qs.set("from_node", opts.from_node);
+    if (opts?.to_node)
+        qs.set("to_node", opts.to_node);
+    const query = qs.toString();
+    return client.get(`${BASE}/${journeyId}/transitions${query ? `?${query}` : ""}`);
+}
+export async function addTransition(client, journeyId, params) {
+    return client.managedPost(`${BASE}/${journeyId}/transitions`, params);
+}
+export async function editTransition(client, journeyId, transitionName, params) {
+    return client.managedRequest("PATCH", `${BASE}/${journeyId}/transitions/${encodeURIComponent(transitionName)}`, params);
+}
+export async function removeTransition(client, journeyId, transitionName) {
+    return client.managedDelete(`${BASE}/${journeyId}/transitions/${encodeURIComponent(transitionName)}`);
+}

package/dist/commands/platform.d.ts

@@ -0,0 +1,35 @@
+export declare function init(apiUrl?: string, portalUrl?: string): Promise<void>;
+export declare function logout(): void;
+export declare function listProjects(): Promise<unknown>;
+export declare function listEnvironments(projectId: string): Promise<unknown>;
+export declare function useEnvironment(tier: string, projectId: string): Promise<void>;
+export declare function setEnv(publicKey: string): Promise<void>;
+import { AscendKitClient } from "../api/client.js";
+export interface McpLoginParams {
+    email: string;
+    password: string;
+}
+export interface McpCreateProjectParams {
+    name: string;
+    description?: string;
+    enabledServices?: string[];
+}
+export interface McpCreateEnvironmentParams {
+    projectId: string;
+    name: string;
+    description?: string;
+    tier: string;
+}
+export declare function mcpLogin(client: AscendKitClient, params: McpLoginParams): Promise<{
+    token: string;
+    user: {
+        id: string;
+        email: string;
+        name: string;
+    };
+    accountId: 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>;
+export declare function mcpCreateEnvironment(client: AscendKitClient, params: McpCreateEnvironmentParams): Promise<unknown>;