@zapier/zapier-sdk-cli 0.55.4 → 0.55.6

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

@@ -74,6 +74,15 @@ export function resolveAvailableCredentialName({ baseName, baseUrl, }) {
         .map((e) => e.name));
     return firstAvailableCredentialName({ baseName, taken });
 }
+/**
+ * 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 function credentialNameExists({ name, baseUrl, }) {
+    const resolvedBaseUrl = normalizeBaseUrl(baseUrl);
+    return readRegistry().some((e) => e.name === name && e.baseUrl === resolvedBaseUrl);
+}
 export async function storeClientCredentials({ name, clientId, clientSecret, scopes, baseUrl, }) {
     if (!name || typeof name !== "string") {
         throw new Error("storeClientCredentials: name is required");

package/dist/src/plugins/login/index.d.ts

@@ -9,6 +9,7 @@ export declare const loginPlugin: (sdk: {
     };
 }) => {
     login: (options?: {
+        name?: string | undefined;
         timeout?: string | undefined;
         useApprovals?: boolean | undefined;
         nonInteractive?: boolean | undefined;

package/dist/src/plugins/login/schemas.d.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
 export declare const LoginSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
     timeout: z.ZodOptional<z.ZodString>;
     useApprovals: z.ZodOptional<z.ZodBoolean>;
     nonInteractive: z.ZodOptional<z.ZodBoolean>;

package/dist/src/plugins/login/schemas.js

@@ -2,6 +2,10 @@ import { z } from "zod";
 // Login schema
 export const LoginSchema = z
     .object({
+    name: z
+        .string()
+        .optional()
+        .describe("Name to identify these credentials (defaults to <email>@<hostname>). Provide this to set a custom name without the interactive prompt."),
     timeout: z
         .string()
         .optional()

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

@@ -1,6 +1,7 @@
 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;

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

@@ -2,7 +2,7 @@ import { hostname } from "node:os";
 import inquirer from "inquirer";
 import { buildApplicationLifecycleEvent, getOrCreateApiClient, isCredentialsObject, } from "@zapier/zapier-sdk";
 import { revokeCredentials } from "../../login/credentials-revoke";
-import { deleteStoredClientCredentials, getActiveCredentials, resolveAvailableCredentialName, } from "../../login/credentials-store";
+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";
@@ -61,6 +61,19 @@ async function promptCredentialsName({ email, promptMessage, }) {
 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) &&
@@ -218,6 +231,27 @@ export async function runAccountAuth({ sdk, options, entryPoint, }) {
         ...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,
@@ -242,18 +276,13 @@ export async function runAccountAuth({ sdk, options, entryPoint, }) {
     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 baseName = interactive
-        ? await promptCredentialsName({
+    const credentialName = providedName ??
+        (await resolveCredentialName({
             email: profile.email,
-            promptMessage: getCredentialsPromptMessage(entryPoint),
-        })
-        : resolveDefaultCredentialsName({ email: profile.email });
-    // 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. Interactive callers chose the name themselves, so leave it as-is.
-    const credentialName = interactive
-        ? baseName
-        : resolveAvailableCredentialName({ baseName, baseUrl: credentialsBaseUrl });
+            interactive,
+            baseUrl: credentialsBaseUrl,
+            entryPoint,
+        }));
     const useApprovals = options.useApprovals === true;
     await saveClientCredentials({
         api: scopedApi,