@zapier/zapier-sdk-cli 0.59.0 → 0.59.2

package/dist/src/generators/ast-generator.js

@@ -1,405 +0,0 @@
-import * as ts from "typescript";
-import { toSnakeCase, batch } from "@zapier/zapier-sdk";
-/**
- * AST-based TypeScript type generator using the TypeScript Compiler API
- */
-export class AstTypeGenerator {
-    constructor() {
-        this.factory = ts.factory;
-        this.printer = ts.createPrinter({
-            newLine: ts.NewLineKind.LineFeed,
-            removeComments: false,
-            omitTrailingSemicolon: false,
-        });
-    }
-    /**
-     * Generate TypeScript types using AST for a specific app
-     */
-    async generateTypes(options) {
-        const { app, connectionId, sdk } = options;
-        // Fetch all actions for the app using implementation_id for correct versioning
-        const actionsResult = await sdk.listActions({
-            appKey: app.implementation_id,
-        });
-        const actions = actionsResult.data;
-        // Fetch input fields for each action
-        const actionsWithFields = [];
-        // Fetch all input fields with concurrency limiting for better reliability
-        // Using batch() instead of Promise.allSettled() prevents overwhelming the API
-        // and triggering rate limits when apps have many actions
-        const inputFieldsTasks = actions.map((action) => () => sdk.listActionInputFields({
-            appKey: app.implementation_id,
-            actionKey: action.key,
-            actionType: action.action_type,
-            connectionId: connectionId,
-        }));
-        const results = await batch(inputFieldsTasks, {
-            concurrency: 50, // Limit to 50 concurrent requests
-            retry: true, // Automatically retry transient failures
-            timeoutMs: 180000, // 3 minute overall timeout
-            taskTimeoutMs: 30000, // 30 seconds per-task timeout (API calls shouldn't take longer)
-        });
-        const failedActions = [];
-        results.forEach((result, i) => {
-            const action = actions[i];
-            if (result.status === "fulfilled") {
-                actionsWithFields.push({
-                    ...action,
-                    inputFields: result.value.data,
-                    name: action.title || action.key,
-                });
-            }
-            else {
-                failedActions.push(`${action.key} (${action.action_type}): ${result.reason?.message || "Unknown error"}`);
-                actionsWithFields.push({
-                    ...action,
-                    inputFields: [],
-                    name: action.title || action.key,
-                    app_key: action.app_key || app.implementation_id,
-                    action_type: action.action_type || "write",
-                    title: action.title || action.key,
-                    type: "action",
-                    description: action.description || "",
-                });
-            }
-        });
-        if (failedActions.length > 0) {
-            console.warn(`Failed to fetch input fields for ${failedActions.length} action(s):`);
-            failedActions.forEach((failedAction) => {
-                console.warn(`  - ${failedAction}`);
-            });
-        }
-        // Generate TypeScript AST nodes
-        const sourceFile = this.createSourceFile(app, actionsWithFields);
-        // Print the AST to string
-        return this.printer.printFile(sourceFile);
-    }
-    createSourceFile(app, actions) {
-        const appName = this.getPreferredAppName(app);
-        const versionComment = ` * Generated for ${app.implementation_id}`;
-        const preferredKey = this.getPreferredProgrammaticKey(app);
-        const myVariableName = `my${appName}`;
-        // Create header comment
-        const headerComment = `Auto-generated TypeScript types for Zapier ${app.key} actions
-${versionComment.slice(3)}
-Generated on: ${new Date().toISOString()}
-
-This file automatically augments the base SDK types when present.
-No manual imports or type casting required.
-
-Usage:
-  import { createZapierSdk } from "@zapier/zapier-sdk";
-  
-  const zapier = createZapierSdk();
-  // Types are automatically available:
-  await zapier.apps.${preferredKey}.search.user_by_email({ connection: 123, inputs: { email } })
-
-  // Factory usage (pinned connection):
-  const ${myVariableName} = zapier.apps.${preferredKey}({ connection: 123 })
-  await ${myVariableName}.search.user_by_email({ inputs: { email } })`;
-        const statements = [
-            // Import the SDK to activate module augmentation
-            this.createImportStatement(["@zapier/zapier-sdk"]),
-            // Import types we'll use
-            this.createTypeImportStatement([
-                "ActionExecutionOptions",
-                "ActionExecutionResult",
-                "AppFactoryInput",
-                "ZapierFetchInitOptions",
-            ], "@zapier/zapier-sdk"),
-        ];
-        // Group actions by type
-        const actionsByType = this.groupActionsByType(actions);
-        // Generate input interfaces for each action
-        actions.forEach((action) => {
-            if (action.inputFields.length > 0) {
-                const inputInterface = this.createInputInterface(appName, action);
-                statements.push(inputInterface);
-            }
-        });
-        // Generate action type interfaces
-        Object.entries(actionsByType).forEach(([actionType, typeActions]) => {
-            const actionInterface = this.createActionInterface(appName, actionType, typeActions);
-            statements.push(actionInterface);
-        });
-        // Generate app proxy interface
-        const appProxyInterface = this.createAppProxyInterface(appName, actionsByType);
-        statements.push(appProxyInterface);
-        // Generate app factory interface
-        const appFactoryInterface = this.createAppFactoryInterface(appName);
-        statements.push(appFactoryInterface);
-        // Generate combined app type
-        const appWithFactoryType = this.createAppWithFactoryType(appName);
-        statements.push(appWithFactoryType);
-        // Generate module augmentation for automatic type integration
-        const allKeys = this.getAllKeys(app);
-        const moduleAugmentation = this.createModuleAugmentation(allKeys, appName);
-        statements.push(moduleAugmentation);
-        // Add empty export to make this a module
-        statements.push(this.factory.createExportDeclaration(undefined, false, this.factory.createNamedExports([])));
-        // Create source file
-        const sourceFile = ts.createSourceFile("generated.d.ts", "", ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
-        // Add the header comment and ESLint disable as leading trivia to the first statement
-        if (statements.length > 0) {
-            // Add ESLint disable comment
-            ts.addSyntheticLeadingComment(statements[0], ts.SyntaxKind.MultiLineCommentTrivia, " eslint-disable @typescript-eslint/naming-convention, @typescript-eslint/no-explicit-any ", true);
-            // Add header comment
-            ts.addSyntheticLeadingComment(statements[0], ts.SyntaxKind.MultiLineCommentTrivia, headerComment, true);
-        }
-        return this.factory.updateSourceFile(sourceFile, statements);
-    }
-    createImportStatement(imports, from) {
-        // Handle side-effect only import (no imports, just the module path)
-        if (imports.length === 1 && !from && imports[0].startsWith("@")) {
-            return this.factory.createImportDeclaration(undefined, undefined, this.factory.createStringLiteral(imports[0]), undefined);
-        }
-        const fromModule = from || imports[0];
-        const importNames = from ? imports : [];
-        return this.factory.createImportDeclaration(undefined, importNames.length > 0
-            ? this.factory.createImportClause(false, undefined, this.factory.createNamedImports(importNames.map((name) => this.factory.createImportSpecifier(false, undefined, this.factory.createIdentifier(name)))))
-            : undefined, this.factory.createStringLiteral(fromModule), undefined);
-    }
-    createTypeImportStatement(imports, from) {
-        return this.factory.createImportDeclaration(undefined, this.factory.createImportClause(true, // typeOnly: true
-        undefined, this.factory.createNamedImports(imports.map((name) => this.factory.createImportSpecifier(false, undefined, this.factory.createIdentifier(name))))), this.factory.createStringLiteral(from), undefined);
-    }
-    groupActionsByType(actions) {
-        return actions.reduce((acc, action) => {
-            if (!acc[action.action_type]) {
-                acc[action.action_type] = [];
-            }
-            acc[action.action_type].push(action);
-            return acc;
-        }, {});
-    }
-    createInputInterface(appName, action) {
-        const inputTypeName = `${appName}${this.capitalize(action.action_type)}${this.capitalize(this.sanitizeActionName(action.key))}Inputs`;
-        const properties = action.inputFields.map((field) => {
-            const fieldType = this.mapFieldTypeToTypeNode(field);
-            const isOptional = !field.is_required;
-            let property = this.factory.createPropertySignature(undefined, this.sanitizeFieldName(field.key), isOptional
-                ? this.factory.createToken(ts.SyntaxKind.QuestionToken)
-                : undefined, fieldType);
-            // Add JSDoc comment if description exists
-            if (field.description) {
-                property = ts.addSyntheticLeadingComment(property, ts.SyntaxKind.MultiLineCommentTrivia, `* ${this.escapeComment(field.description)} `, true);
-            }
-            return property;
-        });
-        return this.factory.createInterfaceDeclaration(undefined, inputTypeName, undefined, undefined, properties);
-    }
-    createActionInterface(appName, actionType, typeActions) {
-        const typeName = `${appName}${this.capitalize(actionType)}Actions`;
-        const methods = typeActions.map((action) => {
-            const actionName = this.sanitizeActionName(action.key);
-            let methodSignature;
-            if (action.inputFields.length > 0) {
-                // Generate type-safe action method signature
-                const inputTypeName = `${appName}${this.capitalize(action.action_type)}${this.capitalize(this.sanitizeActionName(action.key))}Inputs`;
-                const inputsType = this.factory.createTypeLiteralNode([
-                    this.factory.createPropertySignature(undefined, "inputs", undefined, this.factory.createTypeReferenceNode(inputTypeName)),
-                ]);
-                const omitType = this.factory.createTypeReferenceNode("Omit", [
-                    this.factory.createTypeReferenceNode("ActionExecutionOptions"),
-                    this.factory.createLiteralTypeNode(this.factory.createStringLiteral("inputs")),
-                ]);
-                const optionsType = this.factory.createIntersectionTypeNode([
-                    inputsType,
-                    omitType,
-                ]);
-                methodSignature = this.factory.createMethodSignature(undefined, actionName, undefined, undefined, [
-                    this.factory.createParameterDeclaration(undefined, undefined, "options", undefined, optionsType),
-                ], this.factory.createTypeReferenceNode("Promise", [
-                    this.factory.createTypeReferenceNode("ActionExecutionResult"),
-                ]));
-            }
-            else {
-                // No specific input fields available - use generic Record<string, any> for inputs
-                const genericInputsType = this.factory.createTypeLiteralNode([
-                    this.factory.createPropertySignature(undefined, "inputs", this.factory.createToken(ts.SyntaxKind.QuestionToken), this.factory.createTypeReferenceNode("Record", [
-                        this.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
-                        this.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
-                    ])),
-                ]);
-                const intersectionType = this.factory.createIntersectionTypeNode([
-                    genericInputsType,
-                    this.factory.createTypeReferenceNode("ActionExecutionOptions"),
-                ]);
-                methodSignature = this.factory.createMethodSignature(undefined, actionName, undefined, undefined, [
-                    this.factory.createParameterDeclaration(undefined, undefined, "options", this.factory.createToken(ts.SyntaxKind.QuestionToken), intersectionType),
-                ], this.factory.createTypeReferenceNode("Promise", [
-                    this.factory.createTypeReferenceNode("ActionExecutionResult"),
-                ]));
-            }
-            // Add JSDoc comment if description exists
-            if (action.description) {
-                methodSignature = ts.addSyntheticLeadingComment(methodSignature, ts.SyntaxKind.MultiLineCommentTrivia, `* ${this.escapeComment(action.description)} `, true);
-            }
-            return methodSignature;
-        });
-        return this.factory.createInterfaceDeclaration(undefined, typeName, undefined, undefined, methods);
-    }
-    createAppProxyInterface(appName, actionsByType) {
-        const properties = [
-            ...Object.keys(actionsByType).map((actionType) => this.factory.createPropertySignature(undefined, actionType, undefined, this.factory.createTypeReferenceNode(`${appName}${this.capitalize(actionType)}Actions`))),
-            // Always include fetch method for authenticated HTTP requests
-            this.createFetchMethodProperty(),
-        ];
-        return this.factory.createInterfaceDeclaration(undefined, `${appName}AppProxy`, undefined, undefined, properties);
-    }
-    createFetchMethodProperty() {
-        let property = this.factory.createPropertySignature(undefined, "fetch", undefined, this.factory.createFunctionTypeNode(undefined, [
-            this.factory.createParameterDeclaration(undefined, undefined, "url", undefined, this.factory.createUnionTypeNode([
-                this.factory.createTypeReferenceNode("string"),
-                this.factory.createTypeReferenceNode("URL"),
-            ])),
-            this.factory.createParameterDeclaration(undefined, undefined, "init", this.factory.createToken(ts.SyntaxKind.QuestionToken), this.factory.createTypeReferenceNode("ZapierFetchInitOptions")),
-        ], this.factory.createTypeReferenceNode("Promise", [
-            this.factory.createTypeReferenceNode("Response"),
-        ])));
-        // Add JSDoc comment
-        property = ts.addSyntheticLeadingComment(property, ts.SyntaxKind.MultiLineCommentTrivia, "* Make authenticated HTTP requests through Zapier's Relay service ", true);
-        return property;
-    }
-    createAppFactoryInterface(appName) {
-        const callSignature = this.factory.createCallSignature(undefined, [
-            this.factory.createParameterDeclaration(undefined, undefined, "options", undefined, this.factory.createTypeReferenceNode("AppFactoryInput")),
-        ], this.factory.createTypeReferenceNode(`${appName}AppProxy`));
-        return this.factory.createInterfaceDeclaration(undefined, `${appName}AppFactory`, undefined, undefined, [callSignature]);
-    }
-    createAppWithFactoryType(appName) {
-        return this.factory.createTypeAliasDeclaration(undefined, `${appName}AppWithFactory`, undefined, this.factory.createIntersectionTypeNode([
-            this.factory.createTypeReferenceNode(`${appName}AppFactory`),
-            this.factory.createTypeReferenceNode(`${appName}AppProxy`),
-        ]));
-    }
-    createModuleAugmentation(appKeys, appName) {
-        // Create: declare module "@zapier/zapier-sdk" { interface ZapierSdkApps { [appKey]: AppWithFactory } }
-        // This creates a new interface that we can merge with ZapierSdk
-        // Create properties for all keys (main key + other_keys)
-        const properties = appKeys.map((appKey) => this.factory.createPropertySignature(undefined, this.createPropertyName(appKey), undefined, this.factory.createTypeReferenceNode(`${appName}AppWithFactory`)));
-        return this.factory.createModuleDeclaration([this.factory.createToken(ts.SyntaxKind.DeclareKeyword)], this.factory.createStringLiteral("@zapier/zapier-sdk"), this.factory.createModuleBlock([
-            this.factory.createInterfaceDeclaration(undefined, "ZapierSdkApps", undefined, undefined, properties),
-        ]));
-    }
-    mapFieldTypeToTypeNode(field) {
-        // TODO: Handle choices when needed - choices are handled separately through listInputFieldChoices
-        // Map Zapier field types to TypeScript types
-        // Handle the new enum types from InputFieldItem.value_type
-        switch (field.value_type?.toLowerCase()) {
-            case "string":
-            case "text":
-            case "email":
-            case "url":
-            case "password":
-            case "datetime":
-            case "date":
-            case "file":
-                return this.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword);
-            case "integer":
-            case "number":
-                return this.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
-            case "boolean":
-                return this.factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword);
-            case "array":
-                return this.factory.createArrayTypeNode(this.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword));
-            case "object":
-                return this.factory.createTypeReferenceNode("Record", [
-                    this.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
-                    this.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
-                ]);
-            default:
-                // Default to string | number | boolean for unknown types
-                return this.factory.createUnionTypeNode([
-                    this.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
-                    this.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
-                    this.factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword),
-                ]);
-        }
-    }
-    capitalize(str) {
-        return str.charAt(0).toUpperCase() + str.slice(1).replace(/[-_]/g, "");
-    }
-    sanitizeActionName(actionKey) {
-        // Ensure the action name is a valid TypeScript identifier
-        let sanitized = actionKey.replace(/[^a-zA-Z0-9_$]/g, "_");
-        // If it starts with a number, prepend an underscore
-        if (/^[0-9]/.test(sanitized)) {
-            sanitized = "_" + sanitized;
-        }
-        return sanitized;
-    }
-    sanitizeFieldName(fieldKey) {
-        // Ensure the field name is a valid TypeScript identifier
-        let sanitized = fieldKey.replace(/[^a-zA-Z0-9_$]/g, "_");
-        // If it starts with a number, prepend an underscore
-        if (/^[0-9]/.test(sanitized)) {
-            sanitized = "_" + sanitized;
-        }
-        return sanitized;
-    }
-    escapeComment(comment) {
-        // Escape comment text to prevent breaking the JSDoc comment
-        return comment.replace(/\*\//g, "*\\/").replace(/\r?\n/g, " ");
-    }
-    createPropertyName(name) {
-        // Check if the name is a valid JavaScript identifier
-        if (this.isValidIdentifier(name)) {
-            return this.factory.createIdentifier(name);
-        }
-        else {
-            // Use string literal for invalid identifiers (e.g., contains dashes)
-            return this.factory.createStringLiteral(name);
-        }
-    }
-    isValidIdentifier(name) {
-        // JavaScript identifier rules: must start with letter, $, or _,
-        // followed by letters, digits, $, or _
-        return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
-    }
-    getPreferredProgrammaticKey(app) {
-        // If we have a slug, convert it to snake_case as the preferred programmatic key
-        if (app.slug) {
-            const snakeCaseSlug = toSnakeCase(app.slug);
-            if (this.isValidIdentifier(snakeCaseSlug)) {
-                return snakeCaseSlug;
-            }
-        }
-        // Otherwise, use the main key if it's a valid identifier
-        if (this.isValidIdentifier(app.key)) {
-            return app.key;
-        }
-        // Fallback: sanitize the key to make it a valid identifier
-        return this.sanitizeToIdentifier(app.key);
-    }
-    getPreferredAppName(app) {
-        const preferredKey = this.getPreferredProgrammaticKey(app);
-        // If it's snake_case, convert to PascalCase
-        if (preferredKey.includes("_")) {
-            return preferredKey
-                .split("_")
-                .map((word) => this.capitalize(word.toLowerCase()))
-                .join("");
-        }
-        // Otherwise, capitalize first letter for PascalCase
-        return this.capitalize(preferredKey);
-    }
-    sanitizeToIdentifier(name) {
-        // Convert any string to a valid JavaScript identifier
-        let sanitized = name.replace(/[^a-zA-Z0-9_$]/g, "_");
-        // If it starts with a number, prepend an underscore
-        if (/^[0-9]/.test(sanitized)) {
-            sanitized = "_" + sanitized;
-        }
-        return sanitized;
-    }
-    getAllKeys(app) {
-        // Return all possible keys for this app
-        const allKeys = new Set([app.key]);
-        if (app.slug) {
-            allKeys.add(app.slug);
-            allKeys.add(toSnakeCase(app.slug));
-        }
-        return Array.from(allKeys);
-    }
-}

package/dist/src/index.d.ts

@@ -1,5 +0,0 @@
-export { createZapierCliSdk, type ZapierCliSdkOptions } from "./sdk";
-export type { CliEventContext, CliCommandExecutedEventData, } from "./telemetry/builders";
-export { buildCliCommandExecutedEvent } from "./telemetry/builders";
-export type { CliCommandExecutedEvent } from "./telemetry/events";
-export { RESERVED_CLI_OPTIONS, SHARED_COMMAND_CLI_OPTIONS, ReservedCliParameter, getReservedCliOption, } from "./utils/cli-options";

package/dist/src/index.js

@@ -1,5 +0,0 @@
-// Main exports for the CLI package
-export { createZapierCliSdk } from "./sdk";
-export { buildCliCommandExecutedEvent } from "./telemetry/builders";
-// All CLI functionality is now schema-driven via generateCLICommands
-export { RESERVED_CLI_OPTIONS, SHARED_COMMAND_CLI_OPTIONS, ReservedCliParameter, getReservedCliOption, } from "./utils/cli-options";

package/dist/src/login/config.d.ts

@@ -1,4 +0,0 @@
-import Conf from "conf";
-export declare const DEFAULT_AUTH_BASE_URL = "https://zapier.com";
-export declare function getConfig(): Conf;
-export declare function resetConfig(): void;

package/dist/src/login/config.js

@@ -1,21 +0,0 @@
-import Conf from "conf";
-import { existsSync } from "fs";
-export const DEFAULT_AUTH_BASE_URL = "https://zapier.com";
-let config = null;
-export function getConfig() {
-    if (!config) {
-        // Conf does not create the file until the first set() call.
-        config = new Conf({ projectName: "zapier-sdk-cli" });
-        // If the config file already exists but has no cache mode marker, an older
-        // SDK version created it. Set the marker to "config" so the login flow will
-        // prompt the user to upgrade to keychain cache. Otherwise, stamp "keychain"
-        // so that any future writes to the config don't leave it unmarked.
-        if (!config.has("login_storage_mode")) {
-            config.set("login_storage_mode", existsSync(config.path) ? "config" : "keychain");
-        }
-    }
-    return config;
-}
-export function resetConfig() {
-    config = null;
-}

package/dist/src/login/credentials-revoke.d.ts

@@ -1,14 +0,0 @@
-import { type ApiClient } from "@zapier/zapier-sdk";
-import { type CredentialsEntry } from "./credentials-store";
-export type LogoutEventEmitter = (event: {
-    type: string;
-    payload: Record<string, unknown>;
-    timestamp: number;
-}) => void;
-export declare function emitAuthLogout(onEvent: LogoutEventEmitter | undefined): void;
-export declare function revokeCredentials({ api, credentials, onEvent, alwaysClearLocalState, }: {
-    api: ApiClient;
-    credentials: CredentialsEntry;
-    onEvent?: LogoutEventEmitter;
-    alwaysClearLocalState?: boolean;
-}): Promise<void>;

package/dist/src/login/credentials-revoke.js

@@ -1,95 +0,0 @@
-import { invalidateCachedToken, isPermanentHttpError, } from "@zapier/zapier-sdk";
-import { clearLegacyJwtState } from "./legacy-jwt";
-import { deleteStoredClientCredentials, } from "./credentials-store";
-import { withRetry } from "../utils/retry";
-export function emitAuthLogout(onEvent) {
-    onEvent?.({
-        type: "auth_logout",
-        payload: { message: "Logged out successfully", operation: "logout" },
-        timestamp: Date.now(),
-    });
-}
-function getStatusCode(err) {
-    if (typeof err === "object" && err !== null && "statusCode" in err) {
-        return err.statusCode;
-    }
-    return undefined;
-}
-const REVOKE_WARNING_TAIL = "Local state will be cleared, but the credential may still be active. " +
-    "Verify or revoke via `list-client-credentials` or `delete-client-credentials`.";
-// Shown only when `logout` tears down local state after the server *rejected*
-// revocation (a permanent 4xx). Retrying won't help, and `list-`/`delete-client-
-// credentials` would hit the same refusal until the user re-authenticates — so we
-// send them through `login`, which restores the ability to manage credentials.
-const REVOKE_REJECTED_WARNING = "Could not revoke the credential on the server: the request was rejected " +
-    "(your current credentials may lack permission to revoke it). Local state has " +
-    "been cleared, but the credential may still be active on the server — run " +
-    "`login` to re-authenticate, then `delete-client-credentials` to remove it.";
-// Re-login flows pass no emitter so credential rotation stays silent.
-export async function revokeCredentials({ api, credentials, onEvent, alwaysClearLocalState = false, }) {
-    try {
-        await withRetry({
-            // Permanent errors (403/400) won't change on retry — fail fast instead of
-            // burning the backoff budget. The outer catch then rethrows (re-login) or
-            // swallows and clears local state (logout) per `alwaysClearLocalState`.
-            shouldRetry: (err) => !isPermanentHttpError(err),
-            action: async () => {
-                try {
-                    await api.delete(`/api/v0/client-credentials/${credentials.clientId}`, undefined, { authRequired: true, requiredScopes: ["credentials"] });
-                }
-                catch (err) {
-                    const status = getStatusCode(err);
-                    if (status === 404)
-                        return;
-                    if (status === 401) {
-                        console.warn("Could not revoke credentials on the server (unauthorized). " +
-                            REVOKE_WARNING_TAIL);
-                        return;
-                    }
-                    throw err;
-                }
-            },
-        });
-    }
-    catch (err) {
-        // Re-login leaves `alwaysClearLocalState` false because it wants the throw:
-        // any revoke failure (permanent OR transient) must surface so it can confirm
-        // before replacing creds (see `account-auth.ts`). Only `logout` sets the flag
-        // — it is teardown, so it swallows the failure and clears local state rather
-        // than strand the user behind a revoke they can never complete.
-        if (!alwaysClearLocalState)
-            throw err;
-        if (isPermanentHttpError(err)) {
-            // A permanent client rejection (4xx except the 401/404 the action handles
-            // above — e.g. a 403 when the token lacks the `credentials` scope) is the
-            // server's definitive "you may not revoke this". Retrying won't help, and
-            // there's no dashboard fallback; `delete-client-credentials` needs the same
-            // refused `credentials` scope, so the message routes the user through `login`
-            // (which restores that scope) first, then `delete-client-credentials`.
-            console.warn(REVOKE_REJECTED_WARNING);
-        }
-        else {
-            // Transient 5xx/429, a network failure, or an auth-resolution throw that
-            // never built the request (e.g. a missing keychain secret): revocation never
-            // reached a verdict, so a later `delete-client-credentials` could still
-            // succeed once things recover.
-            console.warn("Could not revoke credentials on the server. " + REVOKE_WARNING_TAIL);
-        }
-    }
-    try {
-        await deleteStoredClientCredentials({
-            name: credentials.name,
-            baseUrl: credentials.baseUrl,
-        });
-    }
-    catch (err) {
-        console.warn("[revokeCredentials] Local store cleanup failed:", err);
-    }
-    await clearLegacyJwtState();
-    await invalidateCachedToken({
-        clientId: credentials.clientId,
-        scopes: credentials.scopes,
-        baseUrl: credentials.baseUrl,
-    });
-    emitAuthLogout(onEvent);
-}

package/dist/src/login/credentials-store.d.ts

@@ -1,60 +0,0 @@
-import type { ClientCredentialsObject } from "@zapier/zapier-sdk";
-import { z } from "zod";
-declare const CredentialsEntrySchema: z.ZodObject<{
-    name: z.ZodString;
-    clientId: z.ZodString;
-    createdAt: z.ZodNumber;
-    scopes: z.ZodArray<z.ZodString>;
-    baseUrl: z.ZodString;
-}, z.core.$strip>;
-export type CredentialsEntry = z.infer<typeof CredentialsEntrySchema>;
-export declare function getActiveCredentials(options?: {
-    baseUrl?: string;
-}): CredentialsEntry | undefined;
-/**
- * Pick the first credential name not already present in `taken`. Returns
- * `baseName` if it is free, otherwise appends an incrementing `-1`, `-2`, …
- * suffix to the literal base — a base ending in a digit is left intact, so
- * `acme-1` collides into `acme-1-1`. Storing a credential under a name that
- * already exists locally silently replaces that entry (and deletes its
- * keychain secret), so non-interactive login uses this to avoid clobbering a
- * dormant credential of the same name.
- */
-export declare function firstAvailableCredentialName({ baseName, taken, }: {
-    baseName: string;
-    taken: ReadonlySet<string>;
-}): string;
-/**
- * Resolve a locally-unique credential name for the given baseUrl. Local
- * credentials are keyed by (name, baseUrl), so name collisions — and the
- * suffixing that avoids them — are scoped per baseUrl.
- */
-export declare function resolveAvailableCredentialName({ baseName, baseUrl, }: {
-    baseName: string;
-    baseUrl?: string;
-}): string;
-/**
- * Whether a credential with this exact (name, baseUrl) is already stored
- * locally. Used to reject an explicitly-supplied login name that would
- * otherwise silently overwrite a dormant credential of the same name.
- */
-export declare function credentialNameExists({ name, baseUrl, }: {
-    name: string;
-    baseUrl?: string;
-}): boolean;
-export declare function storeClientCredentials({ name, clientId, clientSecret, scopes, baseUrl, }: {
-    name: string;
-    clientId: string;
-    clientSecret: string;
-    scopes: string[];
-    baseUrl?: string;
-}): Promise<void>;
-export declare function getStoredClientCredentials(options?: {
-    name?: string;
-    baseUrl?: string;
-}): Promise<ClientCredentialsObject | undefined>;
-export declare function deleteStoredClientCredentials({ name, baseUrl, }: {
-    name: string;
-    baseUrl?: string;
-}): Promise<void>;
-export {};