add file input and destructive command confirmation

Author: gmethvin

COMMANDS.md

@@ -1572,3 +1572,11 @@ Remove a key by ID or name
 iterable keys delete <name-or-id>
 ```
 
+### keys validate
+
+Test the API connection
+
+```
+iterable keys validate
+```
+

README.md

@@ -116,6 +116,8 @@ See the [full command reference](COMMANDS.md) for all 109 commands with paramete
 | `--output <format>` | Output format: `json`, `pretty`, `table` |
 | `--columns <cols>` | Comma-separated columns for table output |
 | `--json <data>` | Pass raw JSON (use `-` for stdin) |
+| `--file <path>` | Read JSON input from a file |
+| `--force, -f` | Skip confirmation prompts for destructive commands |
 
 ## Output Formats
 
@@ -157,6 +159,7 @@ iterable keys activate <name>       # Switch active key
 iterable keys deactivate            # Deactivate current key
 iterable keys update <name>         # Update an existing key
 iterable keys delete <name>         # Remove a key
+iterable keys validate              # Test the API connection
 ```
 
 Keys are stored securely using:

src/commands/catalogs.ts

@@ -52,6 +52,7 @@ export const catalogCommands: CommandDefinition[] = [
     description: "Delete a catalog",
     clientMethod: "deleteCatalog",
     schema: DeleteCatalogParamsSchema,
+    destructive: true,
   }),
   defineCommand({
     category: "catalogs",
@@ -80,13 +81,15 @@ export const catalogCommands: CommandDefinition[] = [
     description: "Delete a specific catalog item by ID",
     clientMethod: "deleteCatalogItem",
     schema: DeleteCatalogItemParamsSchema,
+    destructive: true,
   }),
   defineCommand({
     category: "catalogs",
     name: "bulk-delete-items",
     description: "Bulk delete catalog items by their IDs",
     clientMethod: "bulkDeleteCatalogItems",
     schema: BulkDeleteCatalogItemsParamsSchema,
+    destructive: true,
   }),
   defineCommand({
     category: "catalogs",

src/commands/lists.ts

@@ -55,6 +55,7 @@ export const listCommands: CommandDefinition[] = [
     description: "Delete a user list",
     clientMethod: "deleteList",
     schema: DeleteListParamsSchema,
+    destructive: true,
   }),
   defineCommand({
     category: "lists",

src/commands/snippets.ts

@@ -45,5 +45,6 @@ export const snippetCommands: CommandDefinition[] = [
     description: "Delete a snippet by ID (numeric) or name (string)",
     clientMethod: "deleteSnippet",
     schema: DeleteSnippetParamsSchema,
+    destructive: true,
   }),
 ];

src/commands/templates.ts

@@ -41,6 +41,7 @@ export const templateCommands: CommandDefinition[] = [
     description: "Delete one or more templates by ID",
     clientMethod: "deleteTemplates",
     schema: BulkDeleteTemplatesParamsSchema,
+    destructive: true,
   }),
 
   // Email templates

src/commands/types.ts

@@ -20,6 +20,7 @@ export interface CommandDefinition {
   cliTransforms?: Record<string, CliTransform>;
   examples?: string[];
   isAlias?: boolean;
+  destructive?: boolean;
 }
 
 export function defineCommand<
@@ -38,6 +39,7 @@ export function defineCommand<
   positionalArgs?: (keyof z.infer<TSchema> & string)[];
   cliTransforms?: Record<string, CliTransform>;
   examples?: string[];
+  destructive?: boolean;
 }): CommandDefinition {
   const userExecute = def.execute;
   const execute: CommandDefinition["execute"] = userExecute
@@ -64,6 +66,7 @@ export function defineAlias<TSchema extends z.ZodType>(def: {
   positionalArgs?: (keyof z.infer<TSchema> & string)[];
   cliTransforms?: Record<string, CliTransform>;
   examples?: string[];
+  destructive?: boolean;
 }): CommandDefinition {
   const execute: CommandDefinition["execute"] = (client, params) =>
     def.execute(client, params as z.infer<TSchema>);

src/commands/users.ts

@@ -59,13 +59,15 @@ export const userCommands: CommandDefinition[] = [
       params.identifier.includes("@")
         ? client.deleteUserByEmail({ email: params.identifier })
         : client.deleteUserByUserId({ userId: params.identifier }),
+    destructive: true,
   }),
   defineCommand({
     category: "users",
     name: "delete-by-email",
     description: "Delete a user by email address (asynchronous)",
     clientMethod: "deleteUserByEmail",
     schema: DeleteUserByEmailParamsSchema,
+    destructive: true,
   }),
   defineCommand({
     category: "users",
@@ -74,6 +76,7 @@ export const userCommands: CommandDefinition[] = [
       "Delete a user by user ID (asynchronous, deletes all users with same userId)",
     clientMethod: "deleteUserByUserId",
     schema: DeleteUserByUserIdParamsSchema,
+    destructive: true,
   }),
   defineCommand({
     category: "users",

src/index.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 import { IterableClient } from "@iterable/api";
+import { readFileSync } from "fs";
 import { z } from "zod";
 
 import { loadCliConfig } from "./config.js";
@@ -75,14 +76,40 @@ async function main(): Promise<void> {
   });
 
   try {
+    let restArgs = parsed.rest;
+    if (parsed.globalFlags.file) {
+      const content = readFileSync(parsed.globalFlags.file, "utf-8").trim();
+      restArgs = ["--json", content];
+    }
+
     const params = await parseCommand(
       command.schema,
       `iterable ${parsed.category} ${parsed.action}`,
-      parsed.rest,
+      restArgs,
       command.positionalArgs,
       command.cliTransforms
     );
 
+    if (
+      command.destructive &&
+      !parsed.globalFlags.force &&
+      process.stdin.isTTY
+    ) {
+      const { default: inquirer } = await import("inquirer");
+      const { confirm } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "confirm",
+          message: `This will run a destructive operation (${parsed.category} ${parsed.action}). Continue?`,
+          default: false,
+        },
+      ]);
+      if (!confirm) {
+        console.error("Aborted."); // eslint-disable-line no-console
+        process.exit(0);
+      }
+    }
+
     const result = await command.execute(client, params);
 
     const format = parsed.globalFlags.output ?? getDefaultFormat();

src/keys-cli.ts

@@ -1,7 +1,9 @@
 /* eslint-disable no-console */
+import { IterableClient } from "@iterable/api";
 import chalk from "chalk";
 import inquirer from "inquirer";
 
+import { loadCliConfig } from "./config.js";
 import type { ApiKeyMetadata, KeyManager } from "./key-manager.js";
 import { getKeyManager } from "./key-manager.js";
 import { getSpinner, isTestEnv } from "./utils/cli-env.js";
@@ -23,7 +25,6 @@ import {
 
 function displayKeyDetails(meta: ApiKeyMetadata): void {
   const w = 12;
-  console.log();
   console.log(`  ${"Name:".padEnd(w)} ${chalk.white.bold(meta.name)}`);
   console.log(`  ${"ID:".padEnd(w)} ${chalk.gray(meta.id)}`);
   console.log(`  ${"Endpoint:".padEnd(w)} ${linkColor()(meta.baseUrl)}`);
@@ -474,6 +475,53 @@ export async function handleKeysCommand(args: string[]): Promise<void> {
       break;
     }
 
+    case "validate": {
+      spinner.start("Validating API connection...");
+      try {
+        const config = await loadCliConfig();
+        const client = new IterableClient({
+          apiKey: config.apiKey,
+          baseUrl: config.baseUrl,
+        });
+        try {
+          await client.getUserFields();
+          spinner.succeed("API connection successful");
+          const w = 12;
+          if (process.env.ITERABLE_API_KEY) {
+            console.log(
+              `  ${"Source:".padEnd(w)} ${chalk.white("ITERABLE_API_KEY environment variable")}`
+            );
+          } else {
+            const activeMeta = await keyManager.getActiveKeyMetadata();
+            if (activeMeta) {
+              console.log(
+                `  ${"Key:".padEnd(w)} ${chalk.white.bold(activeMeta.name)}`
+              );
+            }
+          }
+          const endpoint = config.baseUrl.replace("https://", "");
+          console.log(`  ${"Endpoint:".padEnd(w)} ${linkColor()(endpoint)}`);
+        } finally {
+          client.destroy();
+        }
+      } catch (error: unknown) {
+        spinner.fail("API connection failed");
+        if (process.env.ITERABLE_API_KEY) {
+          showInfo("Source: ITERABLE_API_KEY environment variable");
+        } else {
+          const activeMeta = await keyManager
+            .getActiveKeyMetadata()
+            .catch(() => null);
+          if (activeMeta) {
+            showInfo(`Key: ${activeMeta.name}`);
+          }
+        }
+        showError(error instanceof Error ? error.message : "Unknown error");
+        process.exit(1);
+      }
+      break;
+    }
+
     default: {
       showSection("Available Commands", icons.key);
       console.log();