@zapier/zapier-sdk-cli 0.6.3 → 0.6.5

package/dist/package.json

@@ -0,0 +1,67 @@
+{
+    "name": "@zapier/zapier-sdk-cli",
+    "version": "0.6.5",
+    "description": "Command line interface for Zapier SDK",
+    "main": "dist/index.cjs",
+    "module": "dist/index.mjs",
+    "types": "dist/index.d.ts",
+    "exports": {
+        ".": {
+            "require": {
+                "types": "./dist/index.d.ts",
+                "default": "./dist/index.cjs"
+            },
+            "import": {
+                "types": "./dist/index.d.mts",
+                "default": "./dist/index.mjs"
+            }
+        }
+    },
+    "bin": {
+        "zapier-sdk": "./bin/zapier-sdk.mjs"
+    },
+    "scripts": {
+        "test": "vitest",
+        "build": "tsup",
+        "clean": "rm -rf dist",
+        "rebuild": "pnpm clean && pnpm build",
+        "dev": "tsx src/cli.ts",
+        "typecheck": "tsc --project tsconfig.build.json --noEmit",
+        "prepublishOnly": "node ../../scripts/check-version.js"
+    },
+    "keywords": [
+        "zapier",
+        "cli",
+        "sdk"
+    ],
+    "author": "",
+    "license": "ISC",
+    "publishConfig": {
+        "access": "restricted"
+    },
+    "dependencies": {
+        "@zapier/zapier-sdk": "workspace:*",
+        "@zapier/zapier-sdk-cli-login": "workspace:*",
+        "@zapier/zapier-sdk-mcp": "workspace:*",
+        "chalk": "^5.3.0",
+        "cli-table3": "^0.6.5",
+        "commander": "^12.0.0",
+        "esbuild": "^0.25.5",
+        "express": "^5.1.0",
+        "inquirer": "^12.6.3",
+        "jsonwebtoken": "^9.0.2",
+        "open": "^10.2.0",
+        "ora": "^8.2.0",
+        "pkce-challenge": "^5.0.0",
+        "zod": "^3.25.67"
+    },
+    "devDependencies": {
+        "@types/express": "^5.0.3",
+        "@types/inquirer": "^9.0.8",
+        "@types/jsonwebtoken": "^9.0.10",
+        "@types/node": "^24.0.1",
+        "tsup": "^8.5.0",
+        "typescript": "^5.8.3",
+        "vitest": "^3.2.3"
+    }
+}

package/dist/src/cli.js

@@ -1,28 +1,22 @@
 #!/usr/bin/env node
 import { Command } from "commander";
-import { createZapierSdk } from "@zapier/zapier-sdk";
 import { generateCliCommands } from "./utils/cli-generator";
-import { createLoginCommand, createLogoutCommand, createConfigPathCommand, createGenerateTypesCommand, createBundleCodeCommand, createMcpCommand, } from "./commands/index";
+import { createZapierCliSdk } from "./sdk";
+import packageJson from "../package.json" with { type: "json" };
 const program = new Command();
 program
     .name("zapier-sdk")
     .description("CLI for Zapier SDK")
-    .version("1.0.0")
+    .version(packageJson.version, "-v, --version", "display version number")
     .option("--debug", "Enable debug logging");
 // Check for debug flag early
 const isDebugMode = process.env.DEBUG === "true" || process.argv.includes("--debug");
-// Create SDK instance - automatically handles token resolution
-const sdk = createZapierSdk({
+// Create CLI SDK instance with all plugins
+const sdk = createZapierCliSdk({
     debug: isDebugMode,
 });
-// Add auth commands before generating SDK commands
-program.addCommand(createLoginCommand());
-program.addCommand(createLogoutCommand());
-// Generate CLI commands from SDK schemas
+// Auth commands now handled by plugins
+// Generate CLI commands from SDK schemas (including CLI plugins)
 generateCliCommands(program, sdk);
-// Add build-time commands (CLI-specific, not from SDK)
-program.addCommand(createGenerateTypesCommand());
-program.addCommand(createBundleCodeCommand());
-program.addCommand(createConfigPathCommand());
-program.addCommand(createMcpCommand());
+// MCP command now handled by plugin
 program.parse();

package/dist/src/index.d.ts

@@ -0,0 +1 @@
+export { createZapierCliSdk, type ZapierCliSdkOptions } from "./sdk";

package/dist/src/index.js

@@ -1,3 +1,3 @@
-"use strict";
 // Main exports for the CLI package
+export { createZapierCliSdk } from "./sdk";
 // All CLI functionality is now schema-driven via generateCLICommands

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

@@ -0,0 +1,15 @@
+import type { Plugin } from "@zapier/zapier-sdk";
+import { BundleCodeSchema, type BundleCodeOptions } from "./schemas";
+export interface BundleCodePluginProvides {
+    bundleCode: (options: BundleCodeOptions) => Promise<string>;
+    context: {
+        meta: {
+            bundleCode: {
+                inputSchema: typeof BundleCodeSchema;
+            };
+        };
+    };
+}
+export declare const bundleCodePlugin: Plugin<{}, // requires no existing SDK methods
+{}, // requires no context
+BundleCodePluginProvides>;

package/dist/src/{commands/bundle-code → plugins/bundleCode}/index.js

@@ -1,6 +1,24 @@
+import { BundleCodeSchema } from "./schemas";
+import { createFunction } from "@zapier/zapier-sdk";
 import { buildSync } from "esbuild";
 import * as fs from "fs";
 import * as path from "path";
+export const bundleCodePlugin = () => {
+    const bundleCodeWithSdk = createFunction(async function bundleCodeWithSdk(options) {
+        return await bundleCode(options);
+    }, BundleCodeSchema);
+    return {
+        bundleCode: bundleCodeWithSdk,
+        context: {
+            meta: {
+                bundleCode: {
+                    categories: ["utility"],
+                    inputSchema: BundleCodeSchema,
+                },
+            },
+        },
+    };
+};
 class ZapierBundleError extends Error {
     constructor(message, details, originalError) {
         super(message);
@@ -13,7 +31,7 @@ class ZapierBundleError extends Error {
 /**
  * Bundle TypeScript code into executable JavaScript (CLI version)
  */
-export async function bundleCode(options) {
+async function bundleCode(options) {
     const { input, output, target = "es2020", cjs = false, minify = false, string: returnString = false, } = options;
     // Resolve input path
     const resolvedInput = path.resolve(process.cwd(), input);

package/dist/src/{commands/bundle-code → plugins/bundleCode}/schemas.d.ts

@@ -2,17 +2,17 @@ import { z } from "zod";
 export declare const BundleCodeSchema: z.ZodObject<{
     input: z.ZodString;
     output: z.ZodOptional<z.ZodString>;
-    string: z.ZodDefault<z.ZodBoolean>;
-    minify: z.ZodDefault<z.ZodBoolean>;
-    target: z.ZodDefault<z.ZodString>;
-    cjs: z.ZodDefault<z.ZodBoolean>;
+    string: z.ZodOptional<z.ZodBoolean>;
+    minify: z.ZodOptional<z.ZodBoolean>;
+    target: z.ZodOptional<z.ZodString>;
+    cjs: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
-    string: boolean;
     input: string;
-    minify: boolean;
-    target: string;
-    cjs: boolean;
+    string?: boolean | undefined;
     output?: string | undefined;
+    minify?: boolean | undefined;
+    target?: string | undefined;
+    cjs?: boolean | undefined;
 }, {
     input: string;
     string?: boolean | undefined;

package/dist/src/{commands/bundle-code → plugins/bundleCode}/schemas.js

@@ -7,13 +7,13 @@ export const BundleCodeSchema = z
     output: OutputPropertySchema.optional().describe("Output file path (defaults to input with .js extension)"),
     string: z
         .boolean()
-        .default(false)
+        .optional()
         .describe("Return bundled code as string instead of writing to file"),
-    minify: z.boolean().default(false).describe("Minify the bundled output"),
-    target: z.string().default("es2017").describe("ECMAScript target version"),
+    minify: z.boolean().optional().describe("Minify the bundled output"),
+    target: z.string().optional().describe("ECMAScript target version"),
     cjs: z
         .boolean()
-        .default(false)
+        .optional()
         .describe("Output CommonJS format instead of ESM"),
 })
     .describe("Bundle TypeScript code into executable JavaScript");

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

@@ -0,0 +1,21 @@
+import type { Plugin, GetSdkType, ListActionsPluginProvides, ListInputFieldsPluginProvides, ManifestPluginProvides } from "@zapier/zapier-sdk";
+import { GenerateTypesSchema, type GenerateTypesOptions } from "./schemas";
+export interface GenerateTypesPluginProvides {
+    generateTypes: (options: GenerateTypesOptions) => Promise<string>;
+    context: {
+        meta: {
+            generateTypes: {
+                inputSchema: typeof GenerateTypesSchema;
+            };
+        };
+    };
+}
+export declare const generateTypesPlugin: Plugin<GetSdkType<ListActionsPluginProvides & ListInputFieldsPluginProvides & ManifestPluginProvides>, // requires these SDK methods
+{}, // requires no context
+GenerateTypesPluginProvides>;
+/**
+ * Generate TypeScript types for a specific app (CLI version)
+ */
+export declare function generateTypes(options: GenerateTypesOptions & {
+    sdk: GetSdkType<ListActionsPluginProvides & ListInputFieldsPluginProvides & ManifestPluginProvides>;
+}): Promise<string>;

package/dist/src/{commands/generate-types → plugins/generateTypes}/index.js

@@ -1,5 +1,23 @@
+import { GenerateTypesSchema } from "./schemas";
+import { createFunction } from "@zapier/zapier-sdk";
 import * as fs from "fs";
 import * as path from "path";
+export const generateTypesPlugin = ({ sdk }) => {
+    const generateTypesWithSdk = createFunction(async function generateTypesWithSdk(options) {
+        return await generateTypes({ ...options, sdk });
+    }, GenerateTypesSchema);
+    return {
+        generateTypes: generateTypesWithSdk,
+        context: {
+            meta: {
+                generateTypes: {
+                    categories: ["utility"],
+                    inputSchema: GenerateTypesSchema,
+                },
+            },
+        },
+    };
+};
 /**
  * Generate the fetch method signature for app proxies
  */

package/dist/src/{commands/generate-types → plugins/generateTypes}/schemas.d.ts

@@ -3,11 +3,9 @@ export declare const GenerateTypesSchema: z.ZodObject<{
     appKey: z.ZodString;
     authenticationId: z.ZodOptional<z.ZodNumber>;
     output: z.ZodOptional<z.ZodString>;
-    debug: z.ZodDefault<z.ZodBoolean>;
     lockFilePath: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     appKey: string;
-    debug: boolean;
     authenticationId?: number | undefined;
     output?: string | undefined;
     lockFilePath?: string | undefined;
@@ -15,7 +13,6 @@ export declare const GenerateTypesSchema: z.ZodObject<{
     appKey: string;
     authenticationId?: number | undefined;
     output?: string | undefined;
-    debug?: boolean | undefined;
     lockFilePath?: string | undefined;
 }>;
 export type GenerateTypesOptions = z.infer<typeof GenerateTypesSchema>;

package/dist/src/{commands/generate-types → plugins/generateTypes}/schemas.js

@@ -1,12 +1,11 @@
 import { z } from "zod";
-import { AppKeyPropertySchema, AuthenticationIdPropertySchema, OutputPropertySchema, DebugPropertySchema, } from "@zapier/zapier-sdk";
+import { AppKeyPropertySchema, AuthenticationIdPropertySchema, OutputPropertySchema, } from "@zapier/zapier-sdk";
 // Generate types schema - mirrors the original from SDK but for CLI use
 export const GenerateTypesSchema = z
     .object({
     appKey: AppKeyPropertySchema.describe("App key to generate SDK code for"),
     authenticationId: AuthenticationIdPropertySchema.optional(),
     output: OutputPropertySchema.optional().describe("Output file path (defaults to generated/<appKey>.ts)"),
-    debug: DebugPropertySchema.describe("Enable debug logging during generation"),
     lockFilePath: z
         .string()
         .optional()

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

@@ -0,0 +1,15 @@
+import type { Plugin } from "@zapier/zapier-sdk";
+import { GetConfigPathSchema, type GetConfigPathOptions } from "./schemas";
+export interface GetConfigPathPluginProvides {
+    getConfigPath: (options?: GetConfigPathOptions) => Promise<string>;
+    context: {
+        meta: {
+            getConfigPath: {
+                inputSchema: typeof GetConfigPathSchema;
+            };
+        };
+    };
+}
+export declare const getConfigPathPlugin: Plugin<{}, // requires no existing SDK methods
+{}, // requires no context
+GetConfigPathPluginProvides>;

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

@@ -0,0 +1,19 @@
+import { GetConfigPathSchema } from "./schemas";
+import { createFunction } from "@zapier/zapier-sdk";
+import { getConfigPath } from "@zapier/zapier-sdk-cli-login";
+export const getConfigPathPlugin = () => {
+    const getConfigPathWithSdk = createFunction(async function getConfigPathWithSdk(_options) {
+        return getConfigPath();
+    }, GetConfigPathSchema);
+    return {
+        getConfigPath: getConfigPathWithSdk,
+        context: {
+            meta: {
+                getConfigPath: {
+                    categories: ["utility"],
+                    inputSchema: GetConfigPathSchema,
+                },
+            },
+        },
+    };
+};

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

@@ -0,0 +1,3 @@
+import { z } from "zod";
+export declare const GetConfigPathSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export type GetConfigPathOptions = z.infer<typeof GetConfigPathSchema>;

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

@@ -0,0 +1,5 @@
+import { z } from "zod";
+// Get config path schema - simple command with no parameters
+export const GetConfigPathSchema = z
+    .object({})
+    .describe("Show the path to the configuration file");

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

@@ -0,0 +1,6 @@
+export { loginPlugin } from "./login";
+export { logoutPlugin } from "./logout";
+export { mcpPlugin } from "./mcp";
+export { generateTypesPlugin } from "./generateTypes";
+export { bundleCodePlugin } from "./bundleCode";
+export { getConfigPathPlugin } from "./getConfigPath";

package/dist/src/plugins/index.js

@@ -0,0 +1,6 @@
+export { loginPlugin } from "./login";
+export { logoutPlugin } from "./logout";
+export { mcpPlugin } from "./mcp";
+export { generateTypesPlugin } from "./generateTypes";
+export { bundleCodePlugin } from "./bundleCode";
+export { getConfigPathPlugin } from "./getConfigPath";

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

@@ -0,0 +1,15 @@
+import type { Plugin } from "@zapier/zapier-sdk";
+import { LoginSchema, type LoginOptions } from "./schemas";
+interface LoginPluginProvides {
+    login: (options: LoginOptions) => Promise<void>;
+    context: {
+        meta: {
+            login: {
+                inputSchema: typeof LoginSchema;
+                categories: string[];
+            };
+        };
+    };
+}
+export declare const loginPlugin: Plugin<{}, {}, LoginPluginProvides>;
+export type { LoginPluginProvides };

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

@@ -0,0 +1,26 @@
+import { createFunction } from "@zapier/zapier-sdk";
+import login from "../../utils/auth/login";
+import { getLoggedInUser } from "@zapier/zapier-sdk-cli-login";
+import { LoginSchema } from "./schemas";
+const loginWithSdk = createFunction(async function loginWithSdk(options) {
+    const timeoutSeconds = options.timeout ? parseInt(options.timeout, 10) : 300;
+    if (isNaN(timeoutSeconds) || timeoutSeconds <= 0) {
+        throw new Error("Timeout must be a positive number");
+    }
+    await login(timeoutSeconds * 1000); // Convert to milliseconds
+    const user = await getLoggedInUser();
+    console.log(`✅ Successfully logged in as ${user.email}`);
+    // Force immediate exit to prevent hanging (especially in development with tsx)
+    setTimeout(() => process.exit(0), 100);
+}, LoginSchema);
+export const loginPlugin = () => ({
+    login: loginWithSdk,
+    context: {
+        meta: {
+            login: {
+                categories: ["account"],
+                inputSchema: LoginSchema,
+            },
+        },
+    },
+});

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

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export declare const LoginSchema: z.ZodObject<{
+    timeout: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    timeout?: string | undefined;
+}, {
+    timeout?: string | undefined;
+}>;
+export type LoginOptions = z.infer<typeof LoginSchema>;

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

@@ -0,0 +1,10 @@
+import { z } from "zod";
+// Login schema
+export const LoginSchema = z
+    .object({
+    timeout: z
+        .string()
+        .optional()
+        .describe("Login timeout in seconds (default: 300)"),
+})
+    .describe("Log in to Zapier to access your account");

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

@@ -0,0 +1,15 @@
+import type { Plugin } from "@zapier/zapier-sdk";
+import { LogoutSchema, type LogoutOptions } from "./schemas";
+interface LogoutPluginProvides {
+    logout: (options: LogoutOptions) => Promise<void>;
+    context: {
+        meta: {
+            logout: {
+                inputSchema: typeof LogoutSchema;
+                categories: string[];
+            };
+        };
+    };
+}
+export declare const logoutPlugin: Plugin<{}, {}, LogoutPluginProvides>;
+export type { LogoutPluginProvides };

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

@@ -0,0 +1,18 @@
+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();
+    console.log("✅ Successfully logged out");
+}, LogoutSchema);
+export const logoutPlugin = () => ({
+    logout: logoutWithSdk,
+    context: {
+        meta: {
+            logout: {
+                categories: ["account"],
+                inputSchema: LogoutSchema,
+            },
+        },
+    },
+});

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

@@ -0,0 +1,3 @@
+import { z } from "zod";
+export declare const LogoutSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export type LogoutOptions = z.infer<typeof LogoutSchema>;

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

@@ -0,0 +1,5 @@
+import { z } from "zod";
+// Logout schema (no parameters needed)
+export const LogoutSchema = z
+    .object({})
+    .describe("Log out of your Zapier account");

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

@@ -0,0 +1,15 @@
+import type { Plugin } from "@zapier/zapier-sdk";
+import { McpSchema, type McpOptions } from "./schemas";
+interface McpPluginProvides {
+    mcp: (options: McpOptions) => Promise<void>;
+    context: {
+        meta: {
+            mcp: {
+                inputSchema: typeof McpSchema;
+                categories: string[];
+            };
+        };
+    };
+}
+export declare const mcpPlugin: Plugin<{}, {}, McpPluginProvides>;
+export type { McpPluginProvides };

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

@@ -0,0 +1,24 @@
+import { createFunction } from "@zapier/zapier-sdk";
+import { startMcpServerAsProcess } from "@zapier/zapier-sdk-mcp";
+import { McpSchema } from "./schemas";
+export const mcpPlugin = ({ context }) => {
+    const mcpWithSdk = createFunction(async function mcpWithSdk(options) {
+        // Pass through the SDK's debug option to the MCP server
+        const mcpOptions = {
+            ...options,
+            debug: context.options.debug,
+        };
+        return await startMcpServerAsProcess(mcpOptions);
+    }, McpSchema);
+    return {
+        mcp: mcpWithSdk,
+        context: {
+            meta: {
+                mcp: {
+                    categories: ["utility"],
+                    inputSchema: McpSchema,
+                },
+            },
+        },
+    };
+};

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

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export declare const McpSchema: z.ZodObject<{
+    port: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    port?: string | undefined;
+}, {
+    port?: string | undefined;
+}>;
+export type McpOptions = z.infer<typeof McpSchema>;

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

@@ -0,0 +1,10 @@
+import { z } from "zod";
+// MCP server schema
+export const McpSchema = z
+    .object({
+    port: z
+        .string()
+        .optional()
+        .describe("Port to listen on (for future HTTP transport)"),
+})
+    .describe("Start MCP server for Zapier SDK");

package/dist/src/sdk.d.ts

@@ -0,0 +1,9 @@
+import { type ZapierSdk } from "@zapier/zapier-sdk";
+export interface ZapierCliSdkOptions {
+    debug?: boolean;
+}
+/**
+ * Create a Zapier SDK instance configured specifically for the CLI
+ * Includes all CLI-specific plugins in addition to the standard SDK functionality
+ */
+export declare function createZapierCliSdk(options?: ZapierCliSdkOptions): ZapierSdk;

package/dist/src/sdk.js

@@ -0,0 +1,22 @@
+import { createZapierSdkWithoutRegistry, registryPlugin, } from "@zapier/zapier-sdk";
+import { loginPlugin, logoutPlugin, mcpPlugin, generateTypesPlugin, bundleCodePlugin, getConfigPathPlugin, } from "./plugins/index";
+/**
+ * Create a Zapier SDK instance configured specifically for the CLI
+ * Includes all CLI-specific plugins in addition to the standard SDK functionality
+ */
+export function createZapierCliSdk(options = {}) {
+    // Create SDK instance without registry
+    let sdk = createZapierSdkWithoutRegistry({
+        debug: options.debug,
+    });
+    // Add CLI-specific plugins before registry
+    sdk = sdk.addPlugin(generateTypesPlugin);
+    sdk = sdk.addPlugin(bundleCodePlugin);
+    sdk = sdk.addPlugin(getConfigPathPlugin);
+    sdk = sdk.addPlugin(mcpPlugin);
+    sdk = sdk.addPlugin(loginPlugin);
+    sdk = sdk.addPlugin(logoutPlugin);
+    // Add registry plugin to finalize SDK
+    const finalSdk = sdk.addPlugin(registryPlugin);
+    return finalSdk;
+}

package/dist/src/utils/cli-generator.js

@@ -9,6 +9,10 @@ import inquirer from "inquirer";
 // JSON Formatting
 // ============================================================================
 function formatJsonOutput(data) {
+    // Don't print anything for undefined results (commands that just perform actions)
+    if (data === undefined) {
+        return;
+    }
     // Show success message for action results
     if (data &&
         typeof data === "object" &&
@@ -199,9 +203,9 @@ function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk) {
                 hasPaginationParams &&
                 !shouldUseJson &&
                 !hasUserSpecifiedMaxItems) {
-                // Get the async iterator directly from the SDK method call
+                // Get the async iterable directly from the SDK method call (don't await it! that breaks the next page behavior)
                 const sdkObj = sdk;
-                const sdkIterator = await sdkObj[sdkMethodName](resolvedParams);
+                const sdkIterator = sdkObj[sdkMethodName](resolvedParams);
                 await handlePaginatedListWithAsyncIteration(sdkMethodName, sdkIterator, schema);
             }
             else {
@@ -387,10 +391,10 @@ async function handlePaginatedListWithAsyncIteration(sdkMethodName, sdkResult, s
             }
             // Format and display items using schema
             if (schema) {
-                formatItemsFromSchema(schema, items);
+                formatItemsFromSchema(schema, items, totalShown);
             }
             else {
-                formatItemsGeneric(items);
+                formatItemsGeneric(items, totalShown);
             }
             totalShown += items.length;
             console.log(chalk.green(`\n✅ Showing ${totalShown} ${itemName} (page ${pageCount})`));
@@ -424,10 +428,10 @@ async function handlePaginatedListWithAsyncIteration(sdkMethodName, sdkResult, s
                 return;
             }
             if (schema) {
-                formatItemsFromSchema(schema, items);
+                formatItemsFromSchema(schema, items, 0);
             }
             else {
-                formatItemsGeneric(items);
+                formatItemsGeneric(items, 0);
             }
             console.log(chalk.green(`\n✅ Showing ${items.length} ${itemName}`));
         }
@@ -472,12 +476,12 @@ function formatNonPaginatedResults(result, requestedMaxItems, userSpecifiedMaxIt
         console.log(chalk.gray(`\n📄 All available ${itemName} shown`));
     }
 }
-function formatItemsGeneric(items) {
+function formatItemsGeneric(items, startingNumber = 0) {
     // Fallback formatting for items without schema metadata
     items.forEach((item, index) => {
         const itemObj = item;
         const name = itemObj?.name || itemObj?.key || itemObj?.id || "Item";
-        console.log(`${chalk.gray(`${index + 1}.`)} ${chalk.cyan(String(name))}`);
+        console.log(`${chalk.gray(`${startingNumber + index + 1}.`)} ${chalk.cyan(String(name))}`);
         if (itemObj?.description) {
             console.log(`   ${chalk.dim(String(itemObj.description))}`);
         }

package/dist/src/utils/schema-formatter.d.ts

@@ -1,2 +1,2 @@
 import { z } from "zod";
-export declare function formatItemsFromSchema(inputSchema: z.ZodType, items: unknown[]): void;
+export declare function formatItemsFromSchema(inputSchema: z.ZodType, items: unknown[], startingNumber?: number): void;