@zapier/zapier-sdk-cli 0.59.0 → 0.59.2

package/dist/src/telemetry/events.d.ts

@@ -1,40 +0,0 @@
-/**
- * CLI-specific telemetry event definitions
- */
-import type { BaseEvent } from "@zapier/zapier-sdk";
-/**
- * Event emitted when a CLI command is executed
- */
-export interface CliCommandExecutedEvent extends BaseEvent {
-    system_name: string;
-    session_id?: string | null;
-    cli_version?: string | null;
-    cli_arguments?: (string | null)[] | null;
-    cli_primary_command?: string | null;
-    os_platform?: string | null;
-    os_release?: string | null;
-    os_architecture?: string | null;
-    platform_versions?: Record<string, string | null> | null;
-    selected_api?: string | null;
-    app_id?: number | null;
-    app_version_id?: number | null;
-    execution_duration_ms?: number | null;
-    success_flag: boolean;
-    exit_code?: number | null;
-    error_message?: string | null;
-    command_category?: string | null;
-    requires_auth?: boolean | null;
-    is_ci_environment?: boolean | null;
-    ci_platform?: string | null;
-    package_manager?: string | null;
-    made_network_requests?: boolean | null;
-    files_modified_count?: number | null;
-    files_created_count?: number | null;
-    files_processed_size_bytes?: number | null;
-    peak_memory_usage_bytes?: number | null;
-    cpu_time_ms?: number | null;
-    subprocess_count?: number | null;
-    stdin_is_tty?: boolean | null;
-    stdout_is_tty?: boolean | null;
-    agent?: string | null;
-}

package/dist/src/telemetry/events.js

@@ -1,4 +0,0 @@
-/**
- * CLI-specific telemetry event definitions
- */
-export {};

package/dist/src/types/sdk.d.ts

@@ -1,6 +0,0 @@
-import type { ZapierSdk } from "@zapier/zapier-sdk";
-import type { BuildManifestPluginProvides } from "../plugins/buildManifest";
-import type { FeedbackPluginProvides } from "../plugins/feedback";
-import type { GenerateAppTypesPluginProvides } from "../plugins/generateAppTypes";
-import type { SignupPluginProvides } from "../plugins/signup";
-export type ZapierSdkCli = ZapierSdk & BuildManifestPluginProvides & FeedbackPluginProvides & GenerateAppTypesPluginProvides & SignupPluginProvides;

package/dist/src/types/sdk.js

@@ -1 +0,0 @@
-export {};

package/dist/src/utils/api/client.d.ts

@@ -1,15 +0,0 @@
-export interface ApiResponse<T = unknown> {
-    data: T;
-    status: number;
-}
-export declare const createApiClient: () => {
-    post: <T = unknown>(url: string, data: Record<string, string>, options?: {
-        headers?: Record<string, string>;
-    }) => Promise<ApiResponse<T>>;
-};
-declare const api: {
-    post: <T = unknown>(url: string, data: Record<string, string>, options?: {
-        headers?: Record<string, string>;
-    }) => Promise<ApiResponse<T>>;
-};
-export default api;

package/dist/src/utils/api/client.js

@@ -1,27 +0,0 @@
-export const createApiClient = () => {
-    const post = async (url, data, options = {}) => {
-        const { headers = {} } = options;
-        const response = await fetch(url, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/x-www-form-urlencoded",
-                Connection: "close",
-                ...headers,
-            },
-            body: new URLSearchParams(data),
-        });
-        if (!response.ok) {
-            throw new Error(`${response.status} ${response.statusText}`);
-        }
-        const responseData = await response.json();
-        return {
-            data: responseData,
-            status: response.status,
-        };
-    };
-    return {
-        post,
-    };
-};
-const api = createApiClient();
-export default api;

package/dist/src/utils/approval-errors.d.ts

@@ -1 +0,0 @@
-export declare function getApprovalReason(error: unknown): string | undefined;

package/dist/src/utils/approval-errors.js

@@ -1,9 +0,0 @@
-import { ZapierApprovalError } from "@zapier/zapier-sdk";
-export function getApprovalReason(error) {
-    if (!(error instanceof ZapierApprovalError))
-        return undefined;
-    const { reason } = error;
-    return typeof reason === "string" && reason.trim().length > 0
-        ? reason.trim()
-        : undefined;
-}

package/dist/src/utils/approval-progress.d.ts

@@ -1,12 +0,0 @@
-export interface ApprovalProgressEvent {
-    type: string;
-    payload?: Record<string, unknown>;
-    timestamp?: number;
-}
-export interface ApprovalProgressRenderer {
-    onEvent(event: ApprovalProgressEvent): void;
-}
-export declare function createApprovalProgressRenderer({ enabled, onEvent, }: {
-    enabled: boolean;
-    onEvent?: (event: ApprovalProgressEvent) => void;
-}): ApprovalProgressRenderer;

package/dist/src/utils/approval-progress.js

@@ -1,179 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import React from "react";
-const FALLBACK_PANEL_WIDTH = 72;
-const MIN_PANEL_WIDTH = 36;
-const MAX_PANEL_WIDTH = 88;
-const MAX_VISIBLE_MESSAGES = 5;
-const SPINNER_INTERVAL_MS = 80;
-const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-let inkImportPromise;
-function loadInk() {
-    inkImportPromise ?? (inkImportPromise = import("ink"));
-    return inkImportPromise;
-}
-function createInitialState() {
-    return {
-        messages: [],
-        active: false,
-    };
-}
-function getPanelWidth() {
-    const terminalColumns = process.stderr.columns;
-    if (!terminalColumns)
-        return FALLBACK_PANEL_WIDTH;
-    return Math.min(Math.max(terminalColumns - 4, MIN_PANEL_WIDTH), MAX_PANEL_WIDTH);
-}
-function getPayloadString(event, key) {
-    const value = event.payload?.[key];
-    if (typeof value !== "string")
-        return undefined;
-    const trimmed = value.trim();
-    return trimmed.length > 0 ? trimmed : undefined;
-}
-function getApprovedVerdict(decision, reason) {
-    if (decision !== "approved")
-        return undefined;
-    return {
-        icon: "✓",
-        label: "Approved",
-        color: "green",
-        reason,
-    };
-}
-function Spinner({ text }) {
-    const [frameIndex, setFrameIndex] = React.useState(0);
-    const InkText = text;
-    React.useEffect(() => {
-        const timer = setInterval(() => {
-            setFrameIndex((index) => (index + 1) % SPINNER_FRAMES.length);
-        }, SPINNER_INTERVAL_MS);
-        return () => clearInterval(timer);
-    }, []);
-    return (_jsx(InkText, { color: "yellow", children: `${SPINNER_FRAMES[frameIndex]} Checking approval...` }));
-}
-function ApprovalProgressView({ state, box, text, }) {
-    if (!state.active)
-        return null;
-    const InkBox = box;
-    const InkText = text;
-    const recentMessages = state.messages.slice(-MAX_VISIBLE_MESSAGES);
-    const hasMessages = recentMessages.length > 0;
-    return (_jsxs(InkBox, { borderColor: "cyan", borderStyle: "round", flexDirection: "column", paddingX: 1, width: getPanelWidth(), children: [_jsx(InkText, { bold: true, color: "cyan", children: "Approval review" }), _jsxs(InkBox, { flexDirection: "column", marginTop: 1, children: [!state.verdict && _jsx(Spinner, { text: text }), recentMessages.map((message, index) => (_jsxs(InkBox, { flexDirection: "row", children: [_jsx(InkText, { color: "cyan", children: "> " }), _jsx(InkText, { dimColor: Boolean(state.verdict) || index < recentMessages.length - 1, wrap: "wrap", children: message })] }, `${index}-${message}`))), state.streamError && (_jsxs(InkBox, { flexDirection: "column", marginTop: hasMessages || !state.verdict ? 1 : 0, children: [_jsx(InkText, { bold: true, color: "red", children: "Approval stream error" }), _jsx(InkText, { wrap: "wrap", children: `  ${state.streamError}` })] })), state.verdict && (_jsxs(InkBox, { flexDirection: "column", marginTop: hasMessages || state.streamError ? 1 : 0, children: [_jsx(InkText, { bold: true, color: state.verdict.color, children: `${state.verdict.icon} ${state.verdict.label}` }), state.verdict.reason && (_jsx(InkText, { wrap: "wrap", children: `  ${state.verdict.reason}` }))] }))] })] }));
-}
-export function createApprovalProgressRenderer({ enabled, onEvent, }) {
-    let instance;
-    let currentState = createInitialState();
-    let renderQueue = Promise.resolve();
-    let renderGeneration = 0;
-    let renderEnabled = enabled;
-    let renderErrorReported = false;
-    function update(nextState, { complete = false } = {}) {
-        const generation = renderGeneration;
-        currentState = complete ? createInitialState() : nextState;
-        renderQueue = renderQueue
-            .then(async () => {
-            if (generation !== renderGeneration)
-                return;
-            const { Box, Text, render } = await loadInk();
-            if (generation !== renderGeneration)
-                return;
-            const element = (_jsx(ApprovalProgressView, { state: nextState, box: Box, text: Text }));
-            if (!instance) {
-                instance = render(element, {
-                    stdout: process.stderr,
-                    stderr: process.stderr,
-                });
-            }
-            else {
-                instance.rerender(element);
-            }
-            if (complete) {
-                instance.unmount();
-                instance = undefined;
-            }
-        })
-            .catch((error) => {
-            if (generation !== renderGeneration)
-                return;
-            renderEnabled = false;
-            currentState = createInitialState();
-            if (renderErrorReported)
-                return;
-            renderErrorReported = true;
-            const message = error instanceof Error ? error.message : String(error);
-            process.stderr.write(`Approval progress unavailable: ${message}\n`);
-        });
-    }
-    function dismiss() {
-        renderGeneration++;
-        currentState = createInitialState();
-        instance?.unmount();
-        instance = undefined;
-    }
-    return {
-        onEvent(event) {
-            onEvent?.(event);
-            if (!renderEnabled)
-                return;
-            if (event.type === "approval:required") {
-                if (event.payload?.mode !== "auto")
-                    return;
-                update({
-                    approvalId: getPayloadString(event, "approvalId"),
-                    messages: [],
-                    active: true,
-                });
-                return;
-            }
-            if (event.type === "approval:review_message") {
-                if (!currentState.active)
-                    return;
-                const message = getPayloadString(event, "message");
-                if (!message)
-                    return;
-                update({
-                    ...currentState,
-                    messages: [...currentState.messages, message],
-                });
-                return;
-            }
-            if (event.type === "approval:review_decision") {
-                if (!currentState.active)
-                    return;
-                const verdict = getApprovedVerdict(event.payload?.decision, getPayloadString(event, "reason"));
-                if (!verdict)
-                    return;
-                update({
-                    ...currentState,
-                    verdict,
-                }, { complete: true });
-                return;
-            }
-            if (event.type === "approval:review_stream_error") {
-                if (!currentState.active)
-                    return;
-                update({
-                    ...currentState,
-                    streamError: getPayloadString(event, "message") ??
-                        "Approval review stream failed",
-                });
-                return;
-            }
-            if (!currentState.active)
-                return;
-            if (event.type === "approval:approved") {
-                update({
-                    ...currentState,
-                    verdict: getApprovedVerdict("approved", getPayloadString(event, "reason")),
-                }, { complete: true });
-                return;
-            }
-            if (event.type === "approval:denied" ||
-                event.type === "approval:failed" ||
-                event.type === "approval:timeout" ||
-                event.type === "approval:error") {
-                dismiss();
-            }
-        },
-    };
-}

package/dist/src/utils/auth/account-auth.d.ts

@@ -1,33 +0,0 @@
-import { type ApiClient, type EventEmissionProvides, type ResolvedCredentials } from "@zapier/zapier-sdk";
-export type AccountAuthEntryPoint = "login" | "signup";
-export interface AccountAuthOptions {
-    name?: string;
-    timeout?: string;
-    useApprovals?: boolean;
-    nonInteractive?: boolean;
-    /** @deprecated Use `nonInteractive` instead. */
-    skipPrompts?: boolean;
-    headless?: boolean;
-}
-export interface AccountAuthCliContext {
-    session_id?: string | null;
-    selected_api?: string | null;
-    app_id?: number | null;
-    app_version_id?: number | null;
-    resolveCredentials: () => Promise<ResolvedCredentials | undefined>;
-    api: ApiClient;
-    options?: {
-        baseUrl?: string;
-        credentials?: unknown;
-    };
-}
-export type CliContext = AccountAuthCliContext;
-interface RunAccountAuthOptions<TOptions extends AccountAuthOptions> {
-    sdk: EventEmissionProvides & {
-        context: AccountAuthCliContext;
-    };
-    options: TOptions;
-    entryPoint: AccountAuthEntryPoint;
-}
-export declare function runAccountAuth<TOptions extends AccountAuthOptions>({ sdk, options, entryPoint, }: RunAccountAuthOptions<TOptions>): Promise<void>;
-export {};

package/dist/src/utils/auth/account-auth.js

@@ -1,302 +0,0 @@
-import { hostname } from "node:os";
-import inquirer from "inquirer";
-import { AuthMechanism, buildApplicationLifecycleEvent, getOrCreateApiClient, isCredentialsObject, } from "@zapier/zapier-sdk";
-import { revokeCredentials } from "../../login/credentials-revoke";
-import { credentialNameExists, deleteStoredClientCredentials, getActiveCredentials, resolveAvailableCredentialName, } from "../../login/credentials-store";
-import { clearLegacyJwtState, hasLegacyJwtConfig, } from "../../login/legacy-jwt";
-import { resolveCredentialsBaseUrl } from "../../plugins/auth/credentials-base-url";
-import { resolveNonInteractive } from "../non-interactive";
-import { ZapierCliUserCancellationError, ZapierCliValidationError, } from "../errors";
-import { EMPTY_POLICY, setupClientCredentials } from "./client-credentials";
-import { runLoginOauthFlow, runSignupOauthFlow, } from "./oauth-flow";
-import { toRedactedOauthError } from "./oauth-errors";
-const LEGACY_JWT_UPGRADE_PROMPT = "We're upgrading your login to client credentials for a simpler, more reliable experience and to support future security controls. Older Zapier SDK/CLI versions on this machine may stop working after the upgrade. Continue?";
-const SIGNUP_RECOVERY_MESSAGE = "Restart `zapier-sdk signup` to generate a fresh signup URL and try again.";
-const HEADLESS_SIGNUP_RECOVERY_MESSAGE = "Restart `zapier-sdk signup --headless` to generate a fresh signup URL and try again.";
-function getEntryPointLabel(entryPoint) {
-    return entryPoint === "signup" ? "Signup" : "Login";
-}
-function getActiveCredentialsAction(entryPoint) {
-    return entryPoint === "signup" ? "continue signup" : "log in again";
-}
-function getCredentialsPromptMessage(entryPoint) {
-    return entryPoint === "signup"
-        ? "Enter a name to identify these credentials:"
-        : "Enter a name to identify them:";
-}
-function getProfileMessage(entryPoint, email) {
-    return entryPoint === "signup"
-        ? `👤 Authenticated as ${email}`
-        : `👤 Logged in as ${email}`;
-}
-function defaultCredentialsName(email) {
-    return `${email}@${hostname()}`;
-}
-function validateCredentialsName(name) {
-    const trimmedName = name.trim();
-    if (!trimmedName)
-        throw new ZapierCliValidationError("Name cannot be empty");
-    return trimmedName;
-}
-async function promptCredentialsName({ email, promptMessage, }) {
-    const { credentialName } = await inquirer.prompt([
-        {
-            type: "input",
-            name: "credentialName",
-            message: promptMessage,
-            default: defaultCredentialsName(email),
-            validate: (input) => {
-                try {
-                    validateCredentialsName(input);
-                    return true;
-                }
-                catch (err) {
-                    return err instanceof Error ? err.message : String(err);
-                }
-            },
-        },
-    ]);
-    return validateCredentialsName(credentialName);
-}
-function resolveDefaultCredentialsName({ email, }) {
-    return validateCredentialsName(defaultCredentialsName(email));
-}
-async function resolveCredentialName({ email, interactive, baseUrl, entryPoint, }) {
-    if (interactive) {
-        return promptCredentialsName({
-            email,
-            promptMessage: getCredentialsPromptMessage(entryPoint),
-        });
-    }
-    // Non-interactive login can't prompt for a new name, so a default name that
-    // already exists locally would silently overwrite that credential. Suffix it
-    // instead.
-    const baseName = resolveDefaultCredentialsName({ email });
-    return resolveAvailableCredentialName({ baseName, baseUrl });
-}
-function toPkceCredentials(credentials) {
-    if (credentials &&
-        isCredentialsObject(credentials) &&
-        !("clientSecret" in credentials)) {
-        return {
-            type: "pkce",
-            clientId: credentials.clientId,
-            baseUrl: credentials.baseUrl,
-            scope: credentials.scope,
-        };
-    }
-    return undefined;
-}
-function parseTimeoutSeconds(timeout) {
-    if (timeout === undefined)
-        return 300;
-    const timeoutSeconds = Number(timeout);
-    if (!Number.isInteger(timeoutSeconds) || timeoutSeconds <= 0) {
-        throw new ZapierCliValidationError("Timeout must be a positive integer (seconds).");
-    }
-    return timeoutSeconds;
-}
-async function promptConfirm({ message, defaultValue, }) {
-    const { confirmed } = await inquirer.prompt([
-        { type: "confirm", name: "confirmed", message, default: defaultValue },
-    ]);
-    return confirmed;
-}
-function promptlessCredentialResetError(credentials) {
-    throw new ZapierCliValidationError(`Already logged in as "${credentials.name}". Run \`logout\` first or use an interactive terminal to re-authenticate.`);
-}
-function promptlessLegacyJwtUpgradeError() {
-    throw new ZapierCliValidationError("Legacy JWT login detected. Run `logout` first or use an interactive terminal to migrate to client credentials.");
-}
-async function clearExistingAuthState({ sdk, baseUrl, interactive, entryPoint, }) {
-    const activeCredentials = getActiveCredentials({ baseUrl });
-    const flowLabel = getEntryPointLabel(entryPoint);
-    if (activeCredentials) {
-        const confirmed = interactive
-            ? await promptConfirm({
-                defaultValue: false,
-                message: `You are already logged in as "${activeCredentials.name}".\n` +
-                    "Logging out will delete these credentials and may interrupt other Zapier SDK or CLI sessions using them.\n" +
-                    `Log out and ${getActiveCredentialsAction(entryPoint)}?`,
-            })
-            : promptlessCredentialResetError(activeCredentials);
-        if (!confirmed) {
-            console.log(`${flowLabel} cancelled.`);
-            return false;
-        }
-        try {
-            await revokeCredentials({
-                api: sdk.context.api,
-                credentials: activeCredentials,
-            });
-        }
-        catch {
-            if (!interactive) {
-                throw new ZapierCliValidationError(`${flowLabel} cleanup failed and cannot be reset without confirmation. Re-run with an interactive terminal.`);
-            }
-            const reset = await promptConfirm({
-                defaultValue: false,
-                message: `${flowLabel} cleanup failed. Reset local session state and continue?`,
-            });
-            if (!reset) {
-                console.log(`${flowLabel} cancelled.`);
-                return false;
-            }
-            await deleteStoredClientCredentials({
-                name: activeCredentials.name,
-                baseUrl: activeCredentials.baseUrl,
-            });
-        }
-    }
-    else if (hasLegacyJwtConfig()) {
-        const confirmed = interactive
-            ? await promptConfirm({
-                defaultValue: true,
-                message: LEGACY_JWT_UPGRADE_PROMPT,
-            })
-            : promptlessLegacyJwtUpgradeError();
-        if (!confirmed) {
-            console.log(`${flowLabel} cancelled.`);
-            return false;
-        }
-    }
-    return true;
-}
-async function getProfile(api) {
-    return api.get("/zapier/api/v4/profile/", {
-        authRequired: true,
-    });
-}
-async function saveClientCredentials({ api, name, credentialsBaseUrl, useApprovals, cleanupLogPrefix, }) {
-    const { clientId } = await setupClientCredentials({
-        api,
-        name,
-        credentialsBaseUrl,
-        ...(useApprovals && { policy: EMPTY_POLICY }),
-    });
-    try {
-        await clearLegacyJwtState();
-    }
-    catch (err) {
-        console.error(`[${cleanupLogPrefix}] Best-effort legacy JWT cleanup failed:`, err);
-    }
-    return { clientId };
-}
-function emitAccountAuthSuccess({ sdk, profile, clientId, }) {
-    sdk.context.eventEmission.emit("platform.sdk.ApplicationLifecycleEvent", buildApplicationLifecycleEvent({ lifecycle_event_type: "login_success" }, {
-        customuser_id: profile.user_id,
-        account_id: profile.roles[0]?.account_id ?? null,
-        client_id: clientId,
-        auth_mechanism: AuthMechanism.ClientCredentials,
-    }));
-}
-function emitSignupSuccess({ sdk, }) {
-    // `signup_success` tracks a valid signup OAuth callback being accepted.
-    // It does not mean a new Zapier account was created or local credentials were provisioned.
-    sdk.context.eventEmission.emit("platform.sdk.ApplicationLifecycleEvent", buildApplicationLifecycleEvent({ lifecycle_event_type: "signup_success" }));
-}
-async function runOauthWithRedaction(runOauth) {
-    try {
-        return await runOauth();
-    }
-    catch (error) {
-        if (error instanceof ZapierCliUserCancellationError)
-            throw error;
-        throw toRedactedOauthError(error);
-    }
-}
-async function runOauthForEntryPoint({ sdk, entryPoint, timeoutMs, pkceCredentials, baseUrl, headless, interactive, }) {
-    if (entryPoint === "signup") {
-        return runOauthWithRedaction(() => runSignupOauthFlow({
-            timeoutMs,
-            pkceCredentials,
-            baseUrl,
-            headless,
-            interactive,
-            recoveryMessage: headless
-                ? HEADLESS_SIGNUP_RECOVERY_MESSAGE
-                : SIGNUP_RECOVERY_MESSAGE,
-            onProgress: (event) => {
-                if (event.type === "callback_accepted") {
-                    emitSignupSuccess({ sdk });
-                }
-            },
-        }));
-    }
-    return runOauthWithRedaction(() => runLoginOauthFlow({ timeoutMs, pkceCredentials, baseUrl }));
-}
-export async function runAccountAuth({ sdk, options, entryPoint, }) {
-    const timeoutSeconds = parseTimeoutSeconds(options.timeout);
-    const interactive = !resolveNonInteractive(options);
-    const resolvedCredentials = await sdk.context.resolveCredentials();
-    const pkceCredentials = toPkceCredentials(resolvedCredentials);
-    const credentialsBaseUrl = await resolveCredentialsBaseUrl({
-        ...sdk.context,
-        resolvedCredentials,
-    });
-    // An explicitly-supplied name is validated and collision-checked up front,
-    // before we tear down the existing session or run OAuth. Otherwise a blank or
-    // already-taken name would only surface after revoking the active credential
-    // and completing the browser flow, leaving the user logged out for nothing.
-    // The name is trimmed but otherwise honored as given — never auto-suffixed —
-    // so a collision is rejected rather than silently overwriting an existing
-    // credential.
-    const providedName = options.name !== undefined
-        ? validateCredentialsName(options.name)
-        : undefined;
-    if (providedName !== undefined) {
-        const activeCredentials = getActiveCredentials({
-            baseUrl: credentialsBaseUrl,
-        });
-        // Re-login under the active credential's own name is a rotation, not a
-        // collision — clearExistingAuthState frees it below.
-        if (activeCredentials?.name !== providedName &&
-            credentialNameExists({ name: providedName, baseUrl: credentialsBaseUrl })) {
-            throw new ZapierCliValidationError(`A credential named "${providedName}" already exists. Choose a different --name.`);
-        }
-    }
-    if (!(await clearExistingAuthState({
-        sdk,
-        baseUrl: credentialsBaseUrl,
-        interactive,
-        entryPoint,
-    }))) {
-        return;
-    }
-    const { accessToken } = await runOauthForEntryPoint({
-        sdk,
-        entryPoint,
-        timeoutMs: timeoutSeconds * 1000,
-        pkceCredentials,
-        baseUrl: credentialsBaseUrl,
-        headless: options.headless === true,
-        interactive,
-    });
-    const scopedApi = getOrCreateApiClient({
-        credentials: accessToken,
-        baseUrl: credentialsBaseUrl,
-    });
-    const profile = await getProfile(scopedApi);
-    console.log(getProfileMessage(entryPoint, profile.email));
-    console.log("\nGenerating credentials so this machine can make authenticated requests on your behalf.");
-    const credentialName = providedName ??
-        (await resolveCredentialName({
-            email: profile.email,
-            interactive,
-            baseUrl: credentialsBaseUrl,
-            entryPoint,
-        }));
-    const useApprovals = options.useApprovals === true;
-    const { clientId } = await saveClientCredentials({
-        api: scopedApi,
-        name: credentialName,
-        credentialsBaseUrl,
-        useApprovals,
-        cleanupLogPrefix: entryPoint,
-    });
-    console.log(`✅ Credentials "${credentialName}" created and set as default. You are ready to use the Zapier SDK.`);
-    if (useApprovals) {
-        console.log("🔐 Approvals are enabled for these credentials.");
-    }
-    emitAccountAuthSuccess({ sdk, profile, clientId });
-}

package/dist/src/utils/auth/client-credentials.d.ts

@@ -1,26 +0,0 @@
-import type { Policy } from "@zapier/policy-schema";
-import type { ApiClient } from "@zapier/zapier-sdk";
-/**
- * The canonical empty approvals policy. Attaching this to a credential at
- * creation time tells the server that requests made with these credentials
- * are subject to approval. Server-side enforcement decides which specific
- * requests trigger the approval flow; the SDK only attaches the policy.
- */
-export declare const EMPTY_POLICY: Policy;
-export interface SetupClientCredentialsOptions {
-    api: ApiClient;
-    name: string;
-    credentialsBaseUrl?: string;
-    /** Optional policy document to attach to the new credential. */
-    policy?: Policy;
-}
-export interface SetupClientCredentialsResult {
-    clientId: string;
-}
-/**
- * Create a client credential server-side and persist it locally. If the
- * local store fails after the server-side credential is created, attempt
- * to roll back the orphan; if that rollback also fails, surface a
- * manual-fix message and re-throw the original store error.
- */
-export declare function setupClientCredentials({ api, name, credentialsBaseUrl, policy, }: SetupClientCredentialsOptions): Promise<SetupClientCredentialsResult>;