@zapier/zapier-sdk-cli 0.32.4 → 0.34.1

package/dist/src/plugins/init/display.d.ts

@@ -0,0 +1,9 @@
+import type { DisplayHooks, RunnableSetupStep, SetupStepId } from "./types";
+import type { PackageManager } from "../../utils/package-manager-detector";
+export declare function createConsoleDisplayHooks(): DisplayHooks;
+export declare function displaySummaryAndNextSteps({ projectName, steps, completedSetupStepIds, packageManager, }: {
+    projectName: string;
+    steps: RunnableSetupStep[];
+    completedSetupStepIds: SetupStepId[];
+    packageManager: PackageManager;
+}): void;

package/dist/src/plugins/init/display.js

@@ -0,0 +1,72 @@
+import chalk from "chalk";
+import { buildNextSteps } from "./steps";
+import { getPackageManagerCommands } from "./utils";
+export function createConsoleDisplayHooks() {
+    return {
+        onItemComplete: (message) => console.log("   " + chalk.green("✓") + "  " + chalk.dim(message)),
+        onWarn: (message) => console.warn(chalk.yellow("!") + "  " + message),
+        onStepStart: ({ description, stepNumber, totalSteps, command, skipPrompts, }) => {
+            const progressMessage = `${description}...`;
+            const stepCounter = chalk.dim(`${stepNumber}/${totalSteps}`);
+            if (skipPrompts) {
+                console.log("\n" +
+                    chalk.bold(`❯  ${progressMessage}`) +
+                    "  " +
+                    stepCounter +
+                    "\n");
+            }
+            else {
+                console.log(chalk.dim("→") + "  " + progressMessage + "  " + stepCounter);
+            }
+            if (command) {
+                console.log("   " + chalk.cyan(`$ ${command}`));
+            }
+        },
+        onStepSuccess: ({ stepNumber, totalSteps }) => console.log("\n" +
+            chalk.green("✓") +
+            "  " +
+            chalk.dim(`Step ${stepNumber}/${totalSteps} complete`) +
+            "\n"),
+        onStepError: ({ description, command, err }) => {
+            const detail = err instanceof Error && err.message
+                ? `\n   ${chalk.dim(err.message)}`
+                : "";
+            const hint = command
+                ? `\n   ${chalk.dim("run manually:")} ${chalk.cyan(`$ ${command}`)}`
+                : "";
+            console.error(`\n${chalk.red("✖")}  ${chalk.bold(description)}${chalk.dim(" failed")}${detail}${hint}`);
+        },
+    };
+}
+export function displaySummaryAndNextSteps({ projectName, steps, completedSetupStepIds, packageManager, }) {
+    const formatStatus = (complete) => ({
+        icon: complete ? chalk.green("✓") : chalk.yellow("!"),
+        text: complete
+            ? chalk.green("Setup complete")
+            : chalk.yellow("Setup interrupted"),
+    });
+    const formatNextStep = (step, i) => "   " + chalk.dim(`${i + 1}.`) + "  " + chalk.bold(step.description);
+    const formatCommand = (cmd) => "       " + chalk.cyan(`$ ${cmd}`);
+    const formatCompletedStep = (step) => "   " + chalk.green("✓") + "  " + step.description;
+    const { execCmd } = getPackageManagerCommands({ packageManager });
+    const leftoverSteps = steps.filter((s) => !completedSetupStepIds.includes(s.id));
+    const isComplete = leftoverSteps.length === 0;
+    const status = formatStatus(isComplete);
+    console.log("\n" + chalk.bold("❯  Summary") + "\n");
+    console.log("   " + chalk.dim("Project") + "   " + chalk.bold(projectName));
+    console.log("   " + chalk.dim("Status") + "    " + status.icon + "  " + status.text);
+    const completedSteps = steps.filter((s) => completedSetupStepIds.includes(s.id));
+    if (completedSteps.length > 0) {
+        console.log();
+        for (const step of completedSteps)
+            console.log(formatCompletedStep(step));
+    }
+    const nextSteps = buildNextSteps({ projectName, leftoverSteps, execCmd });
+    console.log("\n" + chalk.bold("❯  Next Steps") + "\n");
+    nextSteps.forEach((step, i) => {
+        console.log(formatNextStep(step, i));
+        if (step.command)
+            console.log(formatCommand(step.command));
+        console.log();
+    });
+}

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

@@ -0,0 +1,16 @@
+import type { Plugin } from "@zapier/zapier-sdk";
+import { InitSchema, type InitOptions } from "./schemas";
+export { toProjectName } from "./utils";
+interface InitPluginProvides {
+    init: (options: InitOptions) => Promise<void>;
+    context: {
+        meta: {
+            init: {
+                inputSchema: typeof InitSchema;
+                categories: string[];
+            };
+        };
+    };
+}
+export declare const initPlugin: Plugin<{}, {}, InitPluginProvides>;
+export type { InitPluginProvides };

package/dist/src/plugins/init/index.js

@@ -0,0 +1,61 @@
+import { createFunction } from "@zapier/zapier-sdk";
+import { InitSchema } from "./schemas";
+import { detectPackageManager } from "../../utils/package-manager-detector";
+import { validateInitOptions, withInterruptCleanup } from "./utils";
+import { getInitSteps, runStep } from "./steps";
+import { createConsoleDisplayHooks, displaySummaryAndNextSteps, } from "./display";
+import { ZapierCliExitError } from "../../utils/errors";
+export { toProjectName } from "./utils";
+export const initPlugin = () => {
+    const init = createFunction(async function init(options) {
+        const { projectName: rawName, skipPrompts = false } = options;
+        const cwd = process.cwd();
+        const { projectName, projectDir } = validateInitOptions({ rawName, cwd });
+        const displayHooks = createConsoleDisplayHooks();
+        const packageManagerInfo = detectPackageManager(cwd);
+        if (packageManagerInfo.name === "unknown") {
+            displayHooks.onWarn("Could not detect package manager, defaulting to npm.");
+        }
+        const packageManager = packageManagerInfo.name === "unknown" ? "npm" : packageManagerInfo.name;
+        const steps = getInitSteps({
+            projectDir,
+            projectName,
+            packageManager,
+            displayHooks,
+        });
+        const completedSetupStepIds = [];
+        for (let i = 0; i < steps.length; i++) {
+            const step = steps[i];
+            const succeeded = await withInterruptCleanup(step.cleanup, () => runStep({
+                step,
+                stepNumber: i + 1,
+                totalSteps: steps.length,
+                skipPrompts,
+                displayHooks,
+            }));
+            if (!succeeded)
+                break;
+            completedSetupStepIds.push(step.id);
+        }
+        if (completedSetupStepIds.length === 0) {
+            throw new ZapierCliExitError("Project setup failed — no steps completed.");
+        }
+        displaySummaryAndNextSteps({
+            projectName,
+            steps,
+            completedSetupStepIds,
+            packageManager,
+        });
+    }, InitSchema);
+    return {
+        init,
+        context: {
+            meta: {
+                init: {
+                    categories: ["utility"],
+                    inputSchema: InitSchema,
+                },
+            },
+        },
+    };
+};

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

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare const TEMPLATES: readonly ["basic"];
+export type TemplateName = (typeof TEMPLATES)[number];
+export declare const InitSchema: z.ZodObject<{
+    projectName: z.ZodString;
+    skipPrompts: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type InitOptions = z.infer<typeof InitSchema>;

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

@@ -0,0 +1,14 @@
+import { z } from "zod";
+export const TEMPLATES = ["basic"];
+export const InitSchema = z
+    .object({
+    projectName: z
+        .string()
+        .min(1)
+        .describe("Name of the project directory to create"),
+    skipPrompts: z
+        .boolean()
+        .optional()
+        .describe("Skip all interactive prompts and accept all defaults"),
+})
+    .describe("Create a new Zapier SDK project in a new directory with starter files");

package/dist/src/plugins/init/steps.d.ts

@@ -0,0 +1,39 @@
+import { type TemplateName } from "./schemas";
+import { type PackageManager } from "../../utils/package-manager-detector";
+import type { DisplayHooks, SetupStep, SetupStepId, RunnableSetupStep } from "./types";
+export type { DisplayHooks, SetupStep, SetupStepId, RunnableSetupStep };
+export declare function getTemplateDir({ template, }?: {
+    template?: TemplateName;
+}): string;
+export declare function scaffoldFiles({ projectDir, templatesDir, variables, displayHooks, }: {
+    projectDir: string;
+    templatesDir: string;
+    variables?: Record<string, unknown>;
+    displayHooks?: DisplayHooks;
+}): void;
+export declare function scaffoldProject({ projectDir, projectName, packageManager, template, displayHooks, }: {
+    projectDir: string;
+    projectName: string;
+    packageManager: PackageManager;
+    template?: TemplateName;
+    displayHooks?: DisplayHooks;
+}): void;
+export declare function runStep({ step, stepNumber, totalSteps, skipPrompts, displayHooks, }: {
+    step: RunnableSetupStep;
+    stepNumber: number;
+    totalSteps: number;
+    skipPrompts: boolean;
+    displayHooks?: DisplayHooks;
+}): Promise<boolean>;
+export declare function getInitSteps({ projectDir, projectName, packageManager, template, displayHooks, }: {
+    projectDir: string;
+    projectName: string;
+    packageManager: PackageManager;
+    template?: TemplateName;
+    displayHooks?: DisplayHooks;
+}): RunnableSetupStep[];
+export declare function buildNextSteps({ projectName, leftoverSteps, execCmd, }: {
+    projectName: string;
+    leftoverSteps: RunnableSetupStep[];
+    execCmd: string;
+}): SetupStep[];

package/dist/src/plugins/init/steps.js

@@ -0,0 +1,141 @@
+import { existsSync, mkdirSync, writeFileSync, readdirSync, copyFileSync, } from "fs";
+import { join, dirname, relative } from "path";
+import { promptYesNo, createExec, getPackageManagerCommands, getDirentParentPath, buildTemplateVariables, cleanupProject, createProjectDir, isTemplateFile, getDestRelPath, renderTemplate, } from "./utils";
+import { TEMPLATES } from "./schemas";
+import { TEMPLATES_DIR } from "../../paths";
+const DEFAULT_TEMPLATE = "basic";
+export function getTemplateDir({ template = DEFAULT_TEMPLATE, } = {}) {
+    const dirPath = join(TEMPLATES_DIR, template);
+    if (!existsSync(dirPath)) {
+        throw new Error(`Template "${template}" not found at ${dirPath}. Available templates: ${TEMPLATES.join(", ")}`);
+    }
+    return dirPath;
+}
+export function scaffoldFiles({ projectDir, templatesDir, variables = {}, displayHooks, }) {
+    const entries = readdirSync(templatesDir, {
+        withFileTypes: true,
+        recursive: true,
+    });
+    const files = entries.filter((e) => e.isFile());
+    if (files.length === 0) {
+        throw new Error(`Template directory "${templatesDir}" contains no files.`);
+    }
+    for (const entry of files) {
+        const srcPath = join(getDirentParentPath(entry), entry.name);
+        const relPath = relative(templatesDir, srcPath);
+        const isTemplate = isTemplateFile(entry.name);
+        const destRelPath = getDestRelPath(relPath, isTemplate);
+        const destPath = join(projectDir, destRelPath);
+        mkdirSync(dirname(destPath), { recursive: true });
+        if (isTemplate) {
+            writeFileSync(destPath, renderTemplate(srcPath, variables));
+        }
+        else {
+            copyFileSync(srcPath, destPath);
+        }
+        displayHooks?.onItemComplete?.(destRelPath);
+    }
+}
+export function scaffoldProject({ projectDir, projectName, packageManager, template, displayHooks, }) {
+    const variables = buildTemplateVariables({ projectName, packageManager });
+    const templatesDir = getTemplateDir({ template });
+    createProjectDir({ projectDir, projectName });
+    scaffoldFiles({ projectDir, templatesDir, variables, displayHooks });
+}
+export async function runStep({ step, stepNumber, totalSteps, skipPrompts, displayHooks, }) {
+    if (step.askConfirmation) {
+        const should = await promptYesNo({
+            message: step.description,
+            defaultValue: true,
+            skipPrompts,
+        });
+        if (!should)
+            return false;
+    }
+    displayHooks?.onStepStart({
+        description: step.description,
+        stepNumber,
+        totalSteps,
+        command: step.command,
+        skipPrompts,
+    });
+    try {
+        await step.run();
+        displayHooks?.onStepSuccess({ stepNumber, totalSteps });
+        return true;
+    }
+    catch (err) {
+        step.cleanup?.();
+        displayHooks?.onStepError({
+            description: step.description,
+            command: step.command,
+            err,
+        });
+        return false;
+    }
+}
+export function getInitSteps({ projectDir, projectName, packageManager, template, displayHooks, }) {
+    if (template !== undefined &&
+        !TEMPLATES.includes(template)) {
+        throw new Error(`Unknown template "${template}". Available templates: ${TEMPLATES.join(", ")}`);
+    }
+    const { installCmd, execCmd, devCmd } = getPackageManagerCommands({
+        packageManager,
+    });
+    const exec = createExec({ cwd: projectDir });
+    return [
+        {
+            id: "scaffold",
+            description: "Scaffold project files",
+            cleanup: () => cleanupProject({ projectDir }),
+            run: () => scaffoldProject({
+                projectDir,
+                projectName,
+                packageManager,
+                template,
+                displayHooks,
+            }),
+        },
+        {
+            id: "install-deps",
+            description: "Install dependencies",
+            askConfirmation: true,
+            command: installCmd,
+            run: () => exec(installCmd),
+        },
+        {
+            id: "login",
+            description: "Log in to Zapier",
+            askConfirmation: true,
+            command: `${execCmd} zapier-sdk login`,
+            run: () => exec(`${execCmd} zapier-sdk login`),
+        },
+        {
+            id: "run",
+            description: "Run your app",
+            askConfirmation: true,
+            command: devCmd,
+            run: () => exec(devCmd),
+        },
+    ];
+}
+export function buildNextSteps({ projectName, leftoverSteps, execCmd, }) {
+    return [
+        {
+            description: "Change into your project directory",
+            command: `cd ${projectName}`,
+        },
+        ...leftoverSteps.map(({ description, command }) => ({
+            description,
+            command,
+        })),
+        {
+            description: "Search for an app to integrate",
+            command: `${execCmd} zapier-sdk list-apps --search "<app name>"`,
+        },
+        {
+            description: "Add an app and generate TypeScript types",
+            command: `${execCmd} zapier-sdk add <app-key>`,
+        },
+    ];
+}

package/dist/src/plugins/init/types.d.ts

@@ -0,0 +1,31 @@
+export interface DisplayHooks {
+    onItemComplete: (message: string) => void;
+    onWarn: (message: string) => void;
+    onStepStart: (params: {
+        description: string;
+        stepNumber: number;
+        totalSteps: number;
+        command?: string;
+        skipPrompts: boolean;
+    }) => void;
+    onStepSuccess: (params: {
+        stepNumber: number;
+        totalSteps: number;
+    }) => void;
+    onStepError: (params: {
+        description: string;
+        command?: string;
+        err: unknown;
+    }) => void;
+}
+export interface SetupStep {
+    description: string;
+    command?: string;
+}
+export type SetupStepId = "scaffold" | "install-deps" | "login" | "run";
+export interface RunnableSetupStep extends SetupStep {
+    id: SetupStepId;
+    askConfirmation?: boolean;
+    cleanup?: () => void;
+    run: () => void | Promise<void>;
+}

package/dist/src/plugins/init/types.js

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

package/dist/src/plugins/init/utils.d.ts

@@ -0,0 +1,48 @@
+import type { Dirent } from "fs";
+import { type PackageManager } from "../../utils/package-manager-detector";
+export declare function getDirentParentPath(entry: Dirent): string;
+export declare function toProjectName(name: string): string;
+export declare function validateInitOptions({ rawName, cwd, }: {
+    rawName: string;
+    cwd: string;
+}): {
+    projectName: string;
+    projectDir: string;
+};
+export declare function createExec({ cwd }: {
+    cwd: string;
+}): (cmd: string) => void;
+export declare function promptYesNo({ message, defaultValue, skipPrompts, }: {
+    message: string;
+    defaultValue: boolean;
+    skipPrompts: boolean;
+}): Promise<boolean>;
+export declare function getPackageManagerCommands({ packageManager, }: {
+    packageManager: PackageManager;
+}): {
+    installCmd: string;
+    devCmd: string;
+    devScript: string;
+    execCmd: string;
+};
+export declare function isTemplateFile(name: string): boolean;
+export declare function getDestRelPath(relPath: string, isTemplate: boolean): string;
+export declare function renderTemplate(srcPath: string, variables: Record<string, unknown>): string;
+export declare function buildTemplateVariables({ projectName, packageManager, }: {
+    projectName: string;
+    packageManager: PackageManager;
+}): Record<string, unknown>;
+export declare function cleanupProject({ projectDir }: {
+    projectDir: string;
+}): void;
+/**
+ * Registers a cleanup callback that fires if the process receives SIGINT while
+ * `fn` is running. The listener is always removed once `fn` settles, preventing
+ * listener leaks across steps. The SIGINT is re-raised after cleanup so the
+ * shell receives a proper signal-terminated exit code (130) rather than exit(1).
+ */
+export declare function withInterruptCleanup(cleanup: (() => void) | undefined, fn: () => Promise<boolean>): Promise<boolean>;
+export declare function createProjectDir({ projectDir, projectName, }: {
+    projectDir: string;
+    projectName: string;
+}): void;

package/dist/src/plugins/init/utils.js

@@ -0,0 +1,135 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync } from "fs";
+import { execSync } from "child_process";
+import { extname, join } from "path";
+import chalk from "chalk";
+import Handlebars from "handlebars";
+import inquirer from "inquirer";
+// Node 20 added `parentPath`; Node 18 used `path` for the same purpose.
+export function getDirentParentPath(entry) {
+    const e = entry;
+    const parent = e.parentPath ?? e.path;
+    if (!parent)
+        throw new Error("readdirSync entry missing parentPath/path — unsupported Node version");
+    return parent;
+}
+export function toProjectName(name) {
+    // Essentially converts to kebab-case
+    return (name
+        .toLowerCase()
+        // Replace anything that isn't a letter, digit, or hyphen with a hyphen.
+        // Hyphens are kept as-is since they're valid in npm package names.
+        .replace(/[^a-z0-9-]/g, "-")
+        .replace(/-+/g, "-") // collapse consecutive hyphens produced by the step above
+        .replace(/^-|-$/g, "")); // strip any leading/trailing hyphens
+}
+export function validateInitOptions({ rawName, cwd, }) {
+    const projectName = toProjectName(rawName);
+    if (!projectName) {
+        throw new Error(`"${rawName}" results in an empty project name. Provide a name with at least one letter or number.`);
+    }
+    const projectDir = join(cwd, projectName);
+    if (existsSync(projectDir)) {
+        const contents = readdirSync(projectDir);
+        if (contents.length > 0) {
+            throw new Error(`Directory "${projectName}" already exists and is not empty. Choose a different name.`);
+        }
+    }
+    return { projectName, projectDir };
+}
+// shell is required on Windows where npx/npm/pnpm/yarn are .cmd files
+// that execSync cannot locate without a shell.
+export function createExec({ cwd }) {
+    return (cmd) => execSync(cmd, {
+        cwd,
+        stdio: "inherit",
+        shell: process.platform === "win32" ? "cmd.exe" : "/bin/sh",
+    });
+}
+export async function promptYesNo({ message, defaultValue, skipPrompts, }) {
+    if (skipPrompts)
+        return defaultValue;
+    const { answer } = await inquirer.prompt([
+        { type: "confirm", name: "answer", message, default: defaultValue },
+    ]);
+    return answer;
+}
+export function getPackageManagerCommands({ packageManager, }) {
+    return {
+        installCmd: `${packageManager} install`,
+        devCmd: packageManager === "yarn" ? "yarn dev" : `${packageManager} run dev`,
+        devScript: packageManager === "bun" ? "bun src/index.ts" : "tsx src/index.ts",
+        execCmd: {
+            npm: "npx",
+            yarn: "yarn dlx",
+            pnpm: "pnpm dlx",
+            bun: "bunx",
+        }[packageManager],
+    };
+}
+export function isTemplateFile(name) {
+    return extname(name) === ".hbs";
+}
+export function getDestRelPath(relPath, isTemplate) {
+    return isTemplate ? relPath.slice(0, -extname(relPath).length) : relPath;
+}
+export function renderTemplate(srcPath, variables) {
+    const source = readFileSync(srcPath, "utf-8");
+    // Without this, Handlebars HTML-encodes output (& → &), which corrupts JSON and TypeScript files.
+    const template = Handlebars.compile(source, { noEscape: true });
+    return template(variables);
+}
+export function buildTemplateVariables({ projectName, packageManager, }) {
+    const { execCmd, devScript, devCmd } = getPackageManagerCommands({
+        packageManager,
+    });
+    return {
+        projectName,
+        execCmd,
+        devScript,
+        devCmd,
+        includeTsx: packageManager !== "bun",
+    };
+}
+export function cleanupProject({ projectDir }) {
+    console.log("\n" + chalk.yellow("!") + "  Cleaning up...");
+    rmSync(projectDir, { recursive: true, force: true });
+}
+/**
+ * Registers a cleanup callback that fires if the process receives SIGINT while
+ * `fn` is running. The listener is always removed once `fn` settles, preventing
+ * listener leaks across steps. The SIGINT is re-raised after cleanup so the
+ * shell receives a proper signal-terminated exit code (130) rather than exit(1).
+ */
+export async function withInterruptCleanup(cleanup, fn) {
+    if (!cleanup)
+        return fn();
+    const handler = () => {
+        cleanup();
+        process.removeListener("SIGINT", handler);
+        process.kill(process.pid, "SIGINT");
+    };
+    process.on("SIGINT", handler);
+    try {
+        return await fn();
+    }
+    finally {
+        process.removeListener("SIGINT", handler);
+    }
+}
+export function createProjectDir({ projectDir, projectName, }) {
+    try {
+        mkdirSync(projectDir, { recursive: true });
+    }
+    catch (err) {
+        if (err instanceof Error) {
+            const code = err.code;
+            if (code === "EACCES") {
+                throw new Error(`Permission denied creating "${projectName}". Check directory permissions.`);
+            }
+            if (code === "ENOSPC") {
+                throw new Error("No space left on device.");
+            }
+        }
+        throw err;
+    }
+}

package/dist/src/plugins/logout/index.js

@@ -2,7 +2,7 @@ import { createFunction } from "@zapier/zapier-sdk";
 import { logout } from "@zapier/zapier-sdk-cli-login";
 import { LogoutSchema } from "./schemas";
 const logoutWithSdk = createFunction(async function logoutWithSdk(_options) {
-    logout();
+    await logout();
     console.log("✅ Successfully logged out");
 }, LogoutSchema);
 export const logoutPlugin = () => ({

package/dist/src/sdk.js

@@ -1,5 +1,7 @@
-import { createZapierSdkWithoutRegistry, registryPlugin, } from "@zapier/zapier-sdk";
-import { loginPlugin, logoutPlugin, mcpPlugin, bundleCodePlugin, getLoginConfigPathPlugin, addPlugin, generateAppTypesPlugin, buildManifestPlugin, feedbackPlugin, curlPlugin, cliOverridesPlugin, } from "./plugins/index";
+import * as cliLogin from "@zapier/zapier-sdk-cli-login";
+import { createZapierSdkWithoutRegistry, injectCliLogin, registryPlugin, } from "@zapier/zapier-sdk";
+import { loginPlugin, logoutPlugin, mcpPlugin, bundleCodePlugin, getLoginConfigPathPlugin, addPlugin, generateAppTypesPlugin, buildManifestPlugin, feedbackPlugin, curlPlugin, cliOverridesPlugin, initPlugin, } from "./plugins/index";
+injectCliLogin(cliLogin);
 /**
  * Create a Zapier SDK instance configured specifically for the CLI
  * Includes all CLI-specific plugins in addition to the standard SDK functionality
@@ -19,6 +21,7 @@ export function createZapierCliSdk(options = {}) {
         .addPlugin(addPlugin)
         .addPlugin(feedbackPlugin)
         .addPlugin(curlPlugin)
+        .addPlugin(initPlugin)
         .addPlugin(mcpPlugin)
         .addPlugin(loginPlugin)
         .addPlugin(logoutPlugin)

package/dist/src/utils/auth/login.js

@@ -7,7 +7,8 @@ import { spinPromise } from "../spinner";
 import log from "../log";
 import api from "../api/client";
 import getCallablePromise from "../getCallablePromise";
-import { updateLogin, logout, getPkceLoginConfig, } from "@zapier/zapier-sdk-cli-login";
+import inquirer from "inquirer";
+import { updateLogin, logout, getPkceLoginConfig, getLoginStorageMode, getConfigPath, } from "@zapier/zapier-sdk-cli-login";
 import { ZapierCliUserCancellationError } from "../errors";
 const findAvailablePort = () => {
     return new Promise((resolve, reject) => {
@@ -58,8 +59,7 @@ const login = async ({ timeoutMs = LOGIN_TIMEOUT_MS, credentials, }) => {
         credentials,
     });
     const scope = ensureOfflineAccess(credentials?.scope || "internal credentials");
-    // Force logout
-    logout();
+    await logout();
     // Find an available port
     const availablePort = await findAvailablePort();
     const redirectUri = `http://localhost:${availablePort}/oauth`;
@@ -147,7 +147,36 @@ const login = async ({ timeoutMs = LOGIN_TIMEOUT_MS, credentials, }) => {
             "Content-Type": "application/x-www-form-urlencoded",
         },
     });
-    updateLogin(data);
+    let targetStorage;
+    if (getLoginStorageMode() === "config") {
+        const { upgrade } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "upgrade",
+                message: "Would you like to upgrade to system keychain storage? " +
+                    "This is recommended to securely store your credentials. " +
+                    "However, note that older SDK/CLI versions will NOT be able to read these credentials, " +
+                    "so you will want to upgrade them to the latest version.",
+                default: true,
+            },
+        ]);
+        targetStorage = upgrade ? "keychain" : "config";
+    }
+    else {
+        targetStorage = "keychain";
+    }
+    try {
+        await updateLogin(data, { storage: targetStorage });
+    }
+    catch (err) {
+        if (targetStorage === "keychain") {
+            log.warn(`Could not store credentials in system keychain. Storing in plaintext at ${getConfigPath()}.`);
+            await updateLogin(data, { storage: "config" });
+        }
+        else {
+            throw err;
+        }
+    }
     log.info("Token exchange completed successfully");
     return data.access_token;
 };