@sendly/cli 3.12.3 → 3.13.0

package/dist/commands/keys/usage.js

@@ -0,0 +1,102 @@
+import { Args } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { table, json, info, colors, isJsonMode, formatRelativeTime, } from "../../lib/output.js";
+export default class KeysUsage extends AuthenticatedCommand {
+    static description = "Get usage statistics for an API key";
+    static examples = [
+        "<%= config.bin %> keys usage KEY_ID",
+        "<%= config.bin %> keys usage KEY_ID --json",
+    ];
+    static args = {
+        id: Args.string({
+            description: "API key ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(KeysUsage);
+        const response = await apiClient.get(`/api/v1/account/keys/${args.id}/usage`);
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        console.log();
+        console.log(colors.bold(`Usage for "${response.keyName}"`));
+        console.log();
+        console.log(`  ${colors.dim("Total Requests:")}  ${colors.info(String(response.summary.totalRequests))}`);
+        console.log(`  ${colors.dim("Total Credits:")}   ${colors.warning(String(response.summary.totalCredits))}`);
+        console.log(`  ${colors.dim("Last Used:")}       ${response.summary.lastUsed ? formatRelativeTime(response.summary.lastUsed) : colors.dim("never")}`);
+        if (response.endpointBreakdown.length > 0) {
+            console.log();
+            console.log(colors.bold("Endpoint Breakdown"));
+            console.log();
+            table(response.endpointBreakdown.slice(0, 10), [
+                {
+                    header: "Endpoint",
+                    key: "endpoint",
+                    width: 40,
+                },
+                {
+                    header: "Requests",
+                    key: "count",
+                    width: 10,
+                    formatter: (v) => colors.info(String(v)),
+                },
+            ]);
+        }
+        if (response.recentRequests.length > 0) {
+            console.log();
+            console.log(colors.bold("Recent Requests"));
+            console.log();
+            table(response.recentRequests.slice(0, 10), [
+                {
+                    header: "Endpoint",
+                    key: "endpoint",
+                    width: 25,
+                    formatter: (v) => {
+                        const s = String(v);
+                        return s.length > 22 ? s.slice(0, 22) + "..." : s;
+                    },
+                },
+                {
+                    header: "Method",
+                    key: "method",
+                    width: 8,
+                },
+                {
+                    header: "Status",
+                    key: "statusCode",
+                    width: 8,
+                    formatter: (v) => {
+                        const code = Number(v);
+                        if (code >= 200 && code < 300)
+                            return colors.success(String(code));
+                        if (code >= 400)
+                            return colors.error(String(code));
+                        return String(code);
+                    },
+                },
+                {
+                    header: "Credits",
+                    key: "creditsUsed",
+                    width: 8,
+                    formatter: (v) => (v ? colors.warning(String(v)) : colors.dim("0")),
+                },
+                {
+                    header: "Time",
+                    key: "createdAt",
+                    width: 12,
+                    formatter: (v) => formatRelativeTime(String(v)),
+                },
+            ]);
+        }
+        if (response.summary.totalRequests === 0) {
+            info("No usage recorded yet for this key");
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"usage.js","sourceRoot":"","sources":["../../../src/commands/keys/usage.ts"],"names":[],"mappings":"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","sourcesContent":["import { Args } from \"@oclif/core\";\nimport { AuthenticatedCommand } from \"../../lib/base-command.js\";\nimport { apiClient } from \"../../lib/api-client.js\";\nimport {\n  table,\n  json,\n  info,\n  colors,\n  isJsonMode,\n  formatRelativeTime,\n} from \"../../lib/output.js\";\n\ninterface RecentRequest {\n  endpoint: string;\n  method: string;\n  statusCode: number;\n  creditsUsed: number;\n  createdAt: string;\n}\n\ninterface EndpointBreakdown {\n  endpoint: string;\n  count: number;\n}\n\ninterface UsageResponse {\n  keyId: string;\n  keyName: string;\n  summary: {\n    totalRequests: number;\n    totalCredits: number;\n    lastUsed: string | null;\n  };\n  recentRequests: RecentRequest[];\n  endpointBreakdown: EndpointBreakdown[];\n}\n\nexport default class KeysUsage extends AuthenticatedCommand {\n  static description = \"Get usage statistics for an API key\";\n\n  static examples = [\n    \"<%= config.bin %> keys usage KEY_ID\",\n    \"<%= config.bin %> keys usage KEY_ID --json\",\n  ];\n\n  static args = {\n    id: Args.string({\n      description: \"API key ID\",\n      required: true,\n    }),\n  };\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n  };\n\n  async run(): Promise<void> {\n    const { args } = await this.parse(KeysUsage);\n\n    const response = await apiClient.get<UsageResponse>(\n      `/api/v1/account/keys/${args.id}/usage`,\n    );\n\n    if (isJsonMode()) {\n      json(response);\n      return;\n    }\n\n    console.log();\n    console.log(colors.bold(`Usage for \"${response.keyName}\"`));\n    console.log();\n\n    console.log(`  ${colors.dim(\"Total Requests:\")}  ${colors.info(String(response.summary.totalRequests))}`);\n    console.log(`  ${colors.dim(\"Total Credits:\")}   ${colors.warning(String(response.summary.totalCredits))}`);\n    console.log(`  ${colors.dim(\"Last Used:\")}       ${response.summary.lastUsed ? formatRelativeTime(response.summary.lastUsed) : colors.dim(\"never\")}`);\n\n    if (response.endpointBreakdown.length > 0) {\n      console.log();\n      console.log(colors.bold(\"Endpoint Breakdown\"));\n      console.log();\n\n      table(response.endpointBreakdown.slice(0, 10), [\n        {\n          header: \"Endpoint\",\n          key: \"endpoint\",\n          width: 40,\n        },\n        {\n          header: \"Requests\",\n          key: \"count\",\n          width: 10,\n          formatter: (v) => colors.info(String(v)),\n        },\n      ]);\n    }\n\n    if (response.recentRequests.length > 0) {\n      console.log();\n      console.log(colors.bold(\"Recent Requests\"));\n      console.log();\n\n      table(response.recentRequests.slice(0, 10), [\n        {\n          header: \"Endpoint\",\n          key: \"endpoint\",\n          width: 25,\n          formatter: (v) => {\n            const s = String(v);\n            return s.length > 22 ? s.slice(0, 22) + \"...\" : s;\n          },\n        },\n        {\n          header: \"Method\",\n          key: \"method\",\n          width: 8,\n        },\n        {\n          header: \"Status\",\n          key: \"statusCode\",\n          width: 8,\n          formatter: (v) => {\n            const code = Number(v);\n            if (code >= 200 && code < 300) return colors.success(String(code));\n            if (code >= 400) return colors.error(String(code));\n            return String(code);\n          },\n        },\n        {\n          header: \"Credits\",\n          key: \"creditsUsed\",\n          width: 8,\n          formatter: (v) => (v ? colors.warning(String(v)) : colors.dim(\"0\")),\n        },\n        {\n          header: \"Time\",\n          key: \"createdAt\",\n          width: 12,\n          formatter: (v) => formatRelativeTime(String(v)),\n        },\n      ]);\n    }\n\n    if (response.summary.totalRequests === 0) {\n      info(\"No usage recorded yet for this key\");\n    }\n  }\n}\n"]}

package/dist/commands/templates/clone.d.ts

@@ -0,0 +1,14 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class TemplatesClone extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        name: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/templates/clone.js

@@ -0,0 +1,45 @@
+import { Args, Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { json, success, colors, isJsonMode, keyValue } from "../../lib/output.js";
+export default class TemplatesClone extends AuthenticatedCommand {
+    static description = "Clone a template";
+    static examples = [
+        "<%= config.bin %> templates clone tpl_preset_otp",
+        '<%= config.bin %> templates clone tpl_preset_otp --name "My Custom OTP"',
+        "<%= config.bin %> templates clone tpl_xxx --json",
+    ];
+    static args = {
+        id: Args.string({
+            description: "Template ID to clone",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        name: Flags.string({
+            char: "n",
+            description: "Name for the cloned template",
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(TemplatesClone);
+        const template = await apiClient.post(`/api/v1/templates/${args.id}/clone`, flags.name ? { name: flags.name } : {});
+        if (isJsonMode()) {
+            json(template);
+            return;
+        }
+        success(`Template cloned: ${template.id}`);
+        console.log();
+        keyValue([
+            ["Name", template.name],
+            ["Status", colors.dim("draft")],
+            ["Text", template.text.length > 50 ? template.text.slice(0, 50) + "..." : template.text],
+        ]);
+        console.log();
+        console.log(colors.dim("Next steps:"));
+        console.log(`  Edit:    ${colors.code(`sendly templates get ${template.id}`)}`);
+        console.log(`  Publish: ${colors.code(`sendly templates publish ${template.id}`)}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/verify/list.d.ts

@@ -4,6 +4,9 @@ export default class VerifyList extends AuthenticatedCommand {
     static examples: string[];
     static flags: {
         limit: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        page: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        offset: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        status: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
         json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
         quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
     };

package/dist/commands/verify/list.js

@@ -7,15 +7,28 @@ export default class VerifyList extends AuthenticatedCommand {
     static examples = [
         "<%= config.bin %> verify list",
         "<%= config.bin %> verify list --limit 10",
+        "<%= config.bin %> verify list --page 2",
+        "<%= config.bin %> verify list --status verified",
         "<%= config.bin %> verify list --json",
     ];
     static flags = {
         ...AuthenticatedCommand.baseFlags,
         limit: Flags.integer({
-            char: "n",
-            description: "Number of verifications to show",
+            char: "l",
+            description: "Number of verifications per page",
             default: 20,
         }),
+        page: Flags.integer({
+            char: "p",
+            description: "Page number (starts at 1)",
+        }),
+        offset: Flags.integer({
+            description: "Offset from start (alternative to --page)",
+        }),
+        status: Flags.string({
+            char: "s",
+            description: "Filter by status (pending, verified, expired, failed)",
+        }),
     };
     async run() {
         const { flags } = await this.parse(VerifyList);
@@ -26,6 +39,9 @@ export default class VerifyList extends AuthenticatedCommand {
         try {
             const response = await apiClient.get("/api/v1/verify", {
                 limit: flags.limit,
+                ...(flags.page && { page: flags.page }),
+                ...(flags.offset && { offset: flags.offset }),
+                ...(flags.status && { status: flags.status }),
             });
             listSpinner.stop();
             if (isJsonMode()) {
@@ -37,6 +53,15 @@ export default class VerifyList extends AuthenticatedCommand {
                 console.log(colors.dim(`Send one with: ${colors.code('sendly verify send --to "+1234567890"')}`));
                 return;
             }
+            const pagination = response.pagination || {
+                total: response.verifications.length,
+                page: 1,
+                totalPages: 1,
+                hasMore: false,
+            };
+            console.log();
+            console.log(colors.dim(`Showing ${response.verifications.length} verifications (page ${pagination.page} of ${pagination.totalPages}, ${pagination.total} total)`));
+            console.log();
             const statusColor = (status) => {
                 switch (status) {
                     case "verified":
@@ -61,8 +86,9 @@ export default class VerifyList extends AuthenticatedCommand {
                 { header: "Sandbox", key: "sandbox", width: 8, formatter: (v) => v ? colors.dim("yes") : "" },
                 { header: "Created", key: "created_at", width: 20, formatter: (v) => new Date(String(v)).toLocaleString() },
             ]);
-            if (response.pagination.has_more) {
-                console.log(colors.dim(`\nShowing ${response.verifications.length} verifications. Use --limit to see more.`));
+            if (pagination.hasMore) {
+                console.log();
+                console.log(colors.dim(`  Use ${colors.code(`--page ${pagination.page + 1}`)} to see more`));
             }
         }
         catch (err) {
@@ -71,4 +97,4 @@ export default class VerifyList extends AuthenticatedCommand {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list.js","sourceRoot":"","sources":["../../../src/commands/verify/list.ts"],"names":[],"mappings":"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","sourcesContent":["import { Flags } from \"@oclif/core\";\nimport { AuthenticatedCommand } from \"../../lib/base-command.js\";\nimport { apiClient } from \"../../lib/api-client.js\";\nimport { json, colors, spinner, isJsonMode, table } from \"../../lib/output.js\";\n\ninterface Verification {\n  id: string;\n  status: string;\n  phone: string;\n  delivery_status: string;\n  attempts: number;\n  max_attempts: number;\n  expires_at: string;\n  verified_at: string | null;\n  created_at: string;\n  sandbox: boolean;\n}\n\ninterface ListResponse {\n  verifications: Verification[];\n  pagination: {\n    limit: number;\n    has_more: boolean;\n  };\n}\n\nexport default class VerifyList extends AuthenticatedCommand {\n  static description = \"List recent verifications\";\n\n  static examples = [\n    \"<%= config.bin %> verify list\",\n    \"<%= config.bin %> verify list --limit 10\",\n    \"<%= config.bin %> verify list --json\",\n  ];\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    limit: Flags.integer({\n      char: \"n\",\n      description: \"Number of verifications to show\",\n      default: 20,\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { flags } = await this.parse(VerifyList);\n\n    const listSpinner = spinner(\"Fetching verifications...\");\n\n    if (!isJsonMode()) {\n      listSpinner.start();\n    }\n\n    try {\n      const response = await apiClient.get<ListResponse>(\"/api/v1/verify\", {\n        limit: flags.limit,\n      });\n\n      listSpinner.stop();\n\n      if (isJsonMode()) {\n        json(response);\n        return;\n      }\n\n      if (response.verifications.length === 0) {\n        console.log(colors.dim(\"No verifications found.\"));\n        console.log(\n          colors.dim(\n            `Send one with: ${colors.code('sendly verify send --to \"+1234567890\"')}`,\n          ),\n        );\n        return;\n      }\n\n      const statusColor = (status: string) => {\n        switch (status) {\n          case \"verified\":\n            return colors.success(status);\n          case \"pending\":\n            return colors.primary(status);\n          case \"expired\":\n            return colors.dim(status);\n          default:\n            return colors.error(status);\n        }\n      };\n\n      const rows = response.verifications.map((v) => ({\n        ...v,\n        attemptsDisplay: `${v.attempts}/${v.max_attempts}`,\n      }));\n\n      table(rows, [\n        { header: \"ID\", key: \"id\", width: 20, formatter: (v) => colors.code(String(v).slice(0, 16) + \"...\") },\n        { header: \"Phone\", key: \"phone\", width: 16 },\n        { header: \"Status\", key: \"status\", width: 12, formatter: (v) => statusColor(String(v)) },\n        { header: \"Attempts\", key: \"attemptsDisplay\", width: 10 },\n        { header: \"Sandbox\", key: \"sandbox\", width: 8, formatter: (v) => v ? colors.dim(\"yes\") : \"\" },\n        { header: \"Created\", key: \"created_at\", width: 20, formatter: (v) => new Date(String(v)).toLocaleString() },\n      ]);\n\n      if (response.pagination.has_more) {\n        console.log(\n          colors.dim(\n            `\\nShowing ${response.verifications.length} verifications. Use --limit to see more.`,\n          ),\n        );\n      }\n    } catch (err: any) {\n      listSpinner.stop();\n      throw err;\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list.js","sourceRoot":"","sources":["../../../src/commands/verify/list.ts"],"names":[],"mappings":"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","sourcesContent":["import { Flags } from \"@oclif/core\";\nimport { AuthenticatedCommand } from \"../../lib/base-command.js\";\nimport { apiClient } from \"../../lib/api-client.js\";\nimport { json, colors, spinner, isJsonMode, table } from \"../../lib/output.js\";\n\ninterface Verification {\n  id: string;\n  status: string;\n  phone: string;\n  delivery_status: string;\n  attempts: number;\n  max_attempts: number;\n  expires_at: string;\n  verified_at: string | null;\n  created_at: string;\n  sandbox: boolean;\n}\n\ninterface Pagination {\n  total: number;\n  limit: number;\n  offset: number;\n  page: number;\n  totalPages: number;\n  hasMore: boolean;\n}\n\ninterface ListResponse {\n  verifications: Verification[];\n  pagination: Pagination;\n}\n\nexport default class VerifyList extends AuthenticatedCommand {\n  static description = \"List recent verifications\";\n\n  static examples = [\n    \"<%= config.bin %> verify list\",\n    \"<%= config.bin %> verify list --limit 10\",\n    \"<%= config.bin %> verify list --page 2\",\n    \"<%= config.bin %> verify list --status verified\",\n    \"<%= config.bin %> verify list --json\",\n  ];\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    limit: Flags.integer({\n      char: \"l\",\n      description: \"Number of verifications per page\",\n      default: 20,\n    }),\n    page: Flags.integer({\n      char: \"p\",\n      description: \"Page number (starts at 1)\",\n    }),\n    offset: Flags.integer({\n      description: \"Offset from start (alternative to --page)\",\n    }),\n    status: Flags.string({\n      char: \"s\",\n      description: \"Filter by status (pending, verified, expired, failed)\",\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { flags } = await this.parse(VerifyList);\n\n    const listSpinner = spinner(\"Fetching verifications...\");\n\n    if (!isJsonMode()) {\n      listSpinner.start();\n    }\n\n    try {\n      const response = await apiClient.get<ListResponse>(\"/api/v1/verify\", {\n        limit: flags.limit,\n        ...(flags.page && { page: flags.page }),\n        ...(flags.offset && { offset: flags.offset }),\n        ...(flags.status && { status: flags.status }),\n      });\n\n      listSpinner.stop();\n\n      if (isJsonMode()) {\n        json(response);\n        return;\n      }\n\n      if (response.verifications.length === 0) {\n        console.log(colors.dim(\"No verifications found.\"));\n        console.log(\n          colors.dim(\n            `Send one with: ${colors.code('sendly verify send --to \"+1234567890\"')}`,\n          ),\n        );\n        return;\n      }\n\n      const pagination = response.pagination || {\n        total: response.verifications.length,\n        page: 1,\n        totalPages: 1,\n        hasMore: false,\n      };\n\n      console.log();\n      console.log(\n        colors.dim(\n          `Showing ${response.verifications.length} verifications (page ${pagination.page} of ${pagination.totalPages}, ${pagination.total} total)`,\n        ),\n      );\n      console.log();\n\n      const statusColor = (status: string) => {\n        switch (status) {\n          case \"verified\":\n            return colors.success(status);\n          case \"pending\":\n            return colors.primary(status);\n          case \"expired\":\n            return colors.dim(status);\n          default:\n            return colors.error(status);\n        }\n      };\n\n      const rows = response.verifications.map((v) => ({\n        ...v,\n        attemptsDisplay: `${v.attempts}/${v.max_attempts}`,\n      }));\n\n      table(rows, [\n        { header: \"ID\", key: \"id\", width: 20, formatter: (v) => colors.code(String(v).slice(0, 16) + \"...\") },\n        { header: \"Phone\", key: \"phone\", width: 16 },\n        { header: \"Status\", key: \"status\", width: 12, formatter: (v) => statusColor(String(v)) },\n        { header: \"Attempts\", key: \"attemptsDisplay\", width: 10 },\n        { header: \"Sandbox\", key: \"sandbox\", width: 8, formatter: (v) => v ? colors.dim(\"yes\") : \"\" },\n        { header: \"Created\", key: \"created_at\", width: 20, formatter: (v) => new Date(String(v)).toLocaleString() },\n      ]);\n\n      if (pagination.hasMore) {\n        console.log();\n        console.log(\n          colors.dim(\n            `  Use ${colors.code(`--page ${pagination.page + 1}`)} to see more`,\n          ),\n        );\n      }\n    } catch (err: any) {\n      listSpinner.stop();\n      throw err;\n    }\n  }\n}\n"]}

package/dist/lib/api-client.d.ts

@@ -19,10 +19,11 @@ export declare class ApiError extends Error {
     code: string;
     statusCode: number;
     details?: Record<string, unknown> | undefined;
-    constructor(code: string, message: string, statusCode: number, details?: Record<string, unknown> | undefined);
+    hint?: string;
+    constructor(code: string, message: string, statusCode: number, details?: Record<string, unknown> | undefined, hint?: string);
 }
 export declare class AuthenticationError extends ApiError {
-    constructor(message?: string);
+    constructor(message?: string, hint?: string);
 }
 export declare class ApiKeyRequiredError extends ApiError {
     hint: string;
@@ -35,6 +36,12 @@ export declare class RateLimitError extends ApiError {
 export declare class InsufficientCreditsError extends ApiError {
     constructor(message?: string);
 }
+export declare class NotFoundError extends ApiError {
+    constructor(message?: string, hint?: string);
+}
+export declare class ValidationError extends ApiError {
+    constructor(message?: string, details?: Record<string, unknown>);
+}
 declare class ApiClient {
     private rateLimitInfo?;
     private getBaseUrl;

package/dist/lib/api-client.js

@@ -31,17 +31,19 @@ export class ApiError extends Error {
     code;
     statusCode;
     details;
-    constructor(code, message, statusCode, details) {
+    hint;
+    constructor(code, message, statusCode, details, hint) {
         super(message);
         this.code = code;
         this.statusCode = statusCode;
         this.details = details;
         this.name = "ApiError";
+        this.hint = hint;
     }
 }
 export class AuthenticationError extends ApiError {
-    constructor(message = "Not authenticated. Run 'sendly login' first.") {
-        super("authentication_error", message, 401);
+    constructor(message = "Authentication failed", hint = "Run 'sendly login' to authenticate, or check your API key with 'sendly config show'") {
+        super("authentication_error", message, 401, undefined, hint);
         this.name = "AuthenticationError";
     }
 }
@@ -56,17 +58,32 @@ export class ApiKeyRequiredError extends ApiError {
 export class RateLimitError extends ApiError {
     retryAfter;
     constructor(retryAfter, message = "Rate limit exceeded") {
-        super("rate_limit_exceeded", message, 429);
+        const hint = `Wait ${retryAfter} seconds before retrying, or upgrade your plan for higher limits`;
+        super("rate_limit_exceeded", message, 429, undefined, hint);
         this.retryAfter = retryAfter;
         this.name = "RateLimitError";
     }
 }
 export class InsufficientCreditsError extends ApiError {
     constructor(message = "Insufficient credits") {
-        super("insufficient_credits", message, 402);
+        const hint = "Check your balance with 'sendly credits', or add credits at https://sendly.live/dashboard/billing";
+        super("insufficient_credits", message, 402, undefined, hint);
         this.name = "InsufficientCreditsError";
     }
 }
+export class NotFoundError extends ApiError {
+    constructor(message = "Resource not found", hint = "Verify the ID is correct, or use a list command to see available resources") {
+        super("not_found", message, 404, undefined, hint);
+        this.name = "NotFoundError";
+    }
+}
+export class ValidationError extends ApiError {
+    constructor(message = "Validation failed", details) {
+        const hint = "Check the command help with --help for valid options and formats";
+        super("validation_error", message, 400, details, hint);
+        this.name = "ValidationError";
+    }
+}
 class ApiClient {
     rateLimitInfo;
     getBaseUrl() {
@@ -164,13 +181,20 @@ class ApiClient {
                     throw new ApiKeyRequiredError("API key required for sending messages", "Set SENDLY_API_KEY environment variable or create a key with:\n  sendly keys create --type test");
                 }
                 throw new AuthenticationError(message);
+            case 400:
+                throw new ValidationError(message, details);
             case 402:
                 throw new InsufficientCreditsError(message);
+            case 404:
+                throw new NotFoundError(message);
             case 429:
                 const retryAfter = data?.retryAfter || 60;
                 throw new RateLimitError(retryAfter, message);
             default:
-                throw new ApiError(error, message, statusCode, details);
+                const defaultHint = statusCode >= 500
+                    ? "This is a server error. Try again later or check https://status.sendly.live"
+                    : undefined;
+                throw new ApiError(error, message, statusCode, details, defaultHint);
         }
     }
     getRateLimitInfo() {
@@ -252,4 +276,4 @@ class ApiClient {
     }
 }
 export const apiClient = new ApiClient();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-client.js","sourceRoot":"","sources":["../../src/lib/api-client.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * API Client for Sendly CLI\n * Handles all HTTP requests to the Sendly API\n */\n\nimport { createRequire } from \"node:module\";\nimport { getAuthToken, getConfigValue, getEffectiveValue } from \"./config.js\";\n\n// Read version from package.json\nconst require = createRequire(import.meta.url);\nconst { version } = require(\"../../package.json\") as { version: string };\n\n/**\n * Sleep for a given number of milliseconds\n */\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\n/**\n * Check if an error is retryable (network errors or 5xx server errors)\n */\nfunction isRetryableError(error: unknown): boolean {\n  // Network errors\n  if (error instanceof TypeError && error.message.includes(\"fetch\")) {\n    return true;\n  }\n  // Server errors (5xx) are retryable\n  if (error instanceof ApiError && error.statusCode >= 500) {\n    return true;\n  }\n  return false;\n}\n\nexport interface ApiResponse<T> {\n  data?: T;\n  error?: {\n    code: string;\n    message: string;\n    details?: Record<string, unknown>;\n  };\n}\n\nexport interface RateLimitInfo {\n  limit: number;\n  remaining: number;\n  reset: number;\n}\n\nexport class ApiError extends Error {\n  constructor(\n    public code: string,\n    message: string,\n    public statusCode: number,\n    public details?: Record<string, unknown>,\n  ) {\n    super(message);\n    this.name = \"ApiError\";\n  }\n}\n\nexport class AuthenticationError extends ApiError {\n  constructor(\n    message: string = \"Not authenticated. Run 'sendly login' first.\",\n  ) {\n    super(\"authentication_error\", message, 401);\n    this.name = \"AuthenticationError\";\n  }\n}\n\nexport class ApiKeyRequiredError extends ApiError {\n  constructor(\n    message: string = \"API key required for this operation.\",\n    public hint: string = \"Set SENDLY_API_KEY environment variable or create a key with: sendly keys create --type test\",\n  ) {\n    super(\"api_key_required\", message, 401);\n    this.name = \"ApiKeyRequiredError\";\n  }\n}\n\nexport class RateLimitError extends ApiError {\n  constructor(\n    public retryAfter: number,\n    message: string = \"Rate limit exceeded\",\n  ) {\n    super(\"rate_limit_exceeded\", message, 429);\n    this.name = \"RateLimitError\";\n  }\n}\n\nexport class InsufficientCreditsError extends ApiError {\n  constructor(message: string = \"Insufficient credits\") {\n    super(\"insufficient_credits\", message, 402);\n    this.name = \"InsufficientCreditsError\";\n  }\n}\n\nclass ApiClient {\n  private rateLimitInfo?: RateLimitInfo;\n\n  private getBaseUrl(): string {\n    return getConfigValue(\"baseUrl\") || \"https://sendly.live\";\n  }\n\n  private getHeaders(requireAuth: boolean = true): Record<string, string> {\n    const headers: Record<string, string> = {\n      \"Content-Type\": \"application/json\",\n      Accept: \"application/json\",\n      \"User-Agent\": `@sendly/cli/${version}`,\n    };\n\n    if (requireAuth) {\n      const token = getAuthToken();\n      if (!token) {\n        throw new AuthenticationError();\n      }\n      headers[\"Authorization\"] = `Bearer ${token}`;\n    }\n\n    return headers;\n  }\n\n  async request<T>(\n    method: string,\n    path: string,\n    options: {\n      body?: Record<string, unknown>;\n      query?: Record<string, string | number | boolean | undefined>;\n      requireAuth?: boolean;\n    } = {},\n  ): Promise<T> {\n    const { body, query, requireAuth = true } = options;\n    const maxRetries = getEffectiveValue(\"maxRetries\");\n    const timeout = getEffectiveValue(\"timeout\");\n\n    const url = new URL(`${this.getBaseUrl()}${path}`);\n    if (query) {\n      Object.entries(query).forEach(([key, value]) => {\n        if (value !== undefined) {\n          url.searchParams.append(key, String(value));\n        }\n      });\n    }\n\n    let lastError: Error | undefined;\n\n    for (let attempt = 0; attempt <= maxRetries; attempt++) {\n      try {\n        const controller = new AbortController();\n        const timeoutId = setTimeout(() => controller.abort(), timeout);\n\n        const response = await fetch(url.toString(), {\n          method,\n          headers: this.getHeaders(requireAuth),\n          body: body ? JSON.stringify(body) : undefined,\n          signal: controller.signal,\n        });\n\n        clearTimeout(timeoutId);\n\n        // Update rate limit info\n        this.updateRateLimitInfo(response.headers);\n\n        // Parse response\n        const data = await response.json().catch(() => ({}));\n\n        if (!response.ok) {\n          this.handleError(response.status, data);\n        }\n\n        return data as T;\n      } catch (error) {\n        lastError = error as Error;\n\n        // Don't retry non-retryable errors (4xx client errors)\n        if (!isRetryableError(error)) {\n          throw error;\n        }\n\n        // Don't retry on last attempt\n        if (attempt === maxRetries) {\n          throw error;\n        }\n\n        // Exponential backoff: 1s, 2s, 4s, etc.\n        const backoffMs = Math.min(1000 * Math.pow(2, attempt), 10000);\n        await sleep(backoffMs);\n      }\n    }\n\n    // Should never reach here, but TypeScript needs this\n    throw lastError || new Error(\"Request failed\");\n  }\n\n  private updateRateLimitInfo(headers: Headers): void {\n    const limit = headers.get(\"X-RateLimit-Limit\");\n    const remaining = headers.get(\"X-RateLimit-Remaining\");\n    const reset = headers.get(\"X-RateLimit-Reset\");\n\n    if (limit && remaining && reset) {\n      this.rateLimitInfo = {\n        limit: parseInt(limit, 10),\n        remaining: parseInt(remaining, 10),\n        reset: parseInt(reset, 10),\n      };\n    }\n  }\n\n  private handleError(statusCode: number, data: any): never {\n    const error = data?.error || \"unknown_error\";\n    const message = data?.message || `HTTP ${statusCode}`;\n    const details = data?.details;\n\n    switch (statusCode) {\n      case 401:\n      case 403:\n        // Detect if this is an API key required error vs general auth error\n        if (\n          error === \"invalid_api_key\" ||\n          error === \"api_key_required\" ||\n          message?.toLowerCase().includes(\"api key\")\n        ) {\n          throw new ApiKeyRequiredError(\n            \"API key required for sending messages\",\n            \"Set SENDLY_API_KEY environment variable or create a key with:\\n  sendly keys create --type test\",\n          );\n        }\n        throw new AuthenticationError(message);\n      case 402:\n        throw new InsufficientCreditsError(message);\n      case 429:\n        const retryAfter = data?.retryAfter || 60;\n        throw new RateLimitError(retryAfter, message);\n      default:\n        throw new ApiError(error, message, statusCode, details);\n    }\n  }\n\n  getRateLimitInfo(): RateLimitInfo | undefined {\n    return this.rateLimitInfo;\n  }\n\n  // Convenience methods\n  async get<T>(\n    path: string,\n    query?: Record<string, string | number | boolean | undefined>,\n    requireAuth: boolean = true,\n  ): Promise<T> {\n    return this.request<T>(\"GET\", path, { query, requireAuth });\n  }\n\n  async post<T>(\n    path: string,\n    body?: Record<string, unknown>,\n    requireAuth: boolean = true,\n  ): Promise<T> {\n    return this.request<T>(\"POST\", path, { body, requireAuth });\n  }\n\n  async patch<T>(\n    path: string,\n    body?: Record<string, unknown>,\n    requireAuth: boolean = true,\n  ): Promise<T> {\n    return this.request<T>(\"PATCH\", path, { body, requireAuth });\n  }\n\n  async delete<T>(path: string, requireAuth: boolean = true): Promise<T> {\n    return this.request<T>(\"DELETE\", path, { requireAuth });\n  }\n\n  /**\n   * Upload a file using multipart/form-data\n   * Used for batch CSV uploads to Supabase storage\n   */\n  async uploadFile<T>(\n    path: string,\n    file: {\n      buffer: Buffer;\n      filename: string;\n      mimetype?: string;\n    },\n    requireAuth: boolean = true,\n  ): Promise<T> {\n    const maxRetries = getEffectiveValue(\"maxRetries\");\n    const timeout = getEffectiveValue(\"timeout\");\n    const url = `${this.getBaseUrl()}${path}`;\n\n    // Build multipart form data manually (Node.js compatible)\n    const boundary = `----FormBoundary${Date.now()}${Math.random().toString(36).substring(2)}`;\n    const mimetype = file.mimetype || \"text/csv\";\n\n    const header = Buffer.from(\n      `--${boundary}\\r\\n` +\n        `Content-Disposition: form-data; name=\"file\"; filename=\"${file.filename}\"\\r\\n` +\n        `Content-Type: ${mimetype}\\r\\n\\r\\n`,\n    );\n    const footer = Buffer.from(`\\r\\n--${boundary}--\\r\\n`);\n    const body = Buffer.concat([header, file.buffer, footer]);\n\n    const headers: Record<string, string> = {\n      \"Content-Type\": `multipart/form-data; boundary=${boundary}`,\n      Accept: \"application/json\",\n      \"User-Agent\": `@sendly/cli/${version}`,\n    };\n\n    if (requireAuth) {\n      const token = getAuthToken();\n      if (!token) {\n        throw new AuthenticationError();\n      }\n      headers[\"Authorization\"] = `Bearer ${token}`;\n    }\n\n    let lastError: Error | undefined;\n\n    for (let attempt = 0; attempt <= maxRetries; attempt++) {\n      try {\n        const controller = new AbortController();\n        const timeoutId = setTimeout(() => controller.abort(), timeout);\n\n        const response = await fetch(url, {\n          method: \"POST\",\n          headers,\n          body,\n          signal: controller.signal,\n        });\n\n        clearTimeout(timeoutId);\n\n        this.updateRateLimitInfo(response.headers);\n        const data = await response.json().catch(() => ({}));\n\n        if (!response.ok) {\n          this.handleError(response.status, data);\n        }\n\n        return data as T;\n      } catch (error) {\n        lastError = error as Error;\n\n        if (!isRetryableError(error)) {\n          throw error;\n        }\n\n        if (attempt === maxRetries) {\n          throw error;\n        }\n\n        const backoffMs = Math.min(1000 * Math.pow(2, attempt), 10000);\n        await sleep(backoffMs);\n      }\n    }\n\n    throw lastError || new Error(\"Upload failed\");\n  }\n}\n\nexport const apiClient = new ApiClient();\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-client.js","sourceRoot":"","sources":["../../src/lib/api-client.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * API Client for Sendly CLI\n * Handles all HTTP requests to the Sendly API\n */\n\nimport { createRequire } from \"node:module\";\nimport { getAuthToken, getConfigValue, getEffectiveValue } from \"./config.js\";\n\n// Read version from package.json\nconst require = createRequire(import.meta.url);\nconst { version } = require(\"../../package.json\") as { version: string };\n\n/**\n * Sleep for a given number of milliseconds\n */\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\n/**\n * Check if an error is retryable (network errors or 5xx server errors)\n */\nfunction isRetryableError(error: unknown): boolean {\n  // Network errors\n  if (error instanceof TypeError && error.message.includes(\"fetch\")) {\n    return true;\n  }\n  // Server errors (5xx) are retryable\n  if (error instanceof ApiError && error.statusCode >= 500) {\n    return true;\n  }\n  return false;\n}\n\nexport interface ApiResponse<T> {\n  data?: T;\n  error?: {\n    code: string;\n    message: string;\n    details?: Record<string, unknown>;\n  };\n}\n\nexport interface RateLimitInfo {\n  limit: number;\n  remaining: number;\n  reset: number;\n}\n\nexport class ApiError extends Error {\n  public hint?: string;\n\n  constructor(\n    public code: string,\n    message: string,\n    public statusCode: number,\n    public details?: Record<string, unknown>,\n    hint?: string,\n  ) {\n    super(message);\n    this.name = \"ApiError\";\n    this.hint = hint;\n  }\n}\n\nexport class AuthenticationError extends ApiError {\n  constructor(\n    message: string = \"Authentication failed\",\n    hint: string = \"Run 'sendly login' to authenticate, or check your API key with 'sendly config show'\",\n  ) {\n    super(\"authentication_error\", message, 401, undefined, hint);\n    this.name = \"AuthenticationError\";\n  }\n}\n\nexport class ApiKeyRequiredError extends ApiError {\n  constructor(\n    message: string = \"API key required for this operation.\",\n    public hint: string = \"Set SENDLY_API_KEY environment variable or create a key with: sendly keys create --type test\",\n  ) {\n    super(\"api_key_required\", message, 401);\n    this.name = \"ApiKeyRequiredError\";\n  }\n}\n\nexport class RateLimitError extends ApiError {\n  constructor(\n    public retryAfter: number,\n    message: string = \"Rate limit exceeded\",\n  ) {\n    const hint = `Wait ${retryAfter} seconds before retrying, or upgrade your plan for higher limits`;\n    super(\"rate_limit_exceeded\", message, 429, undefined, hint);\n    this.name = \"RateLimitError\";\n  }\n}\n\nexport class InsufficientCreditsError extends ApiError {\n  constructor(message: string = \"Insufficient credits\") {\n    const hint =\n      \"Check your balance with 'sendly credits', or add credits at https://sendly.live/dashboard/billing\";\n    super(\"insufficient_credits\", message, 402, undefined, hint);\n    this.name = \"InsufficientCreditsError\";\n  }\n}\n\nexport class NotFoundError extends ApiError {\n  constructor(\n    message: string = \"Resource not found\",\n    hint: string = \"Verify the ID is correct, or use a list command to see available resources\",\n  ) {\n    super(\"not_found\", message, 404, undefined, hint);\n    this.name = \"NotFoundError\";\n  }\n}\n\nexport class ValidationError extends ApiError {\n  constructor(\n    message: string = \"Validation failed\",\n    details?: Record<string, unknown>,\n  ) {\n    const hint = \"Check the command help with --help for valid options and formats\";\n    super(\"validation_error\", message, 400, details, hint);\n    this.name = \"ValidationError\";\n  }\n}\n\nclass ApiClient {\n  private rateLimitInfo?: RateLimitInfo;\n\n  private getBaseUrl(): string {\n    return getConfigValue(\"baseUrl\") || \"https://sendly.live\";\n  }\n\n  private getHeaders(requireAuth: boolean = true): Record<string, string> {\n    const headers: Record<string, string> = {\n      \"Content-Type\": \"application/json\",\n      Accept: \"application/json\",\n      \"User-Agent\": `@sendly/cli/${version}`,\n    };\n\n    if (requireAuth) {\n      const token = getAuthToken();\n      if (!token) {\n        throw new AuthenticationError();\n      }\n      headers[\"Authorization\"] = `Bearer ${token}`;\n    }\n\n    return headers;\n  }\n\n  async request<T>(\n    method: string,\n    path: string,\n    options: {\n      body?: Record<string, unknown>;\n      query?: Record<string, string | number | boolean | undefined>;\n      requireAuth?: boolean;\n    } = {},\n  ): Promise<T> {\n    const { body, query, requireAuth = true } = options;\n    const maxRetries = getEffectiveValue(\"maxRetries\");\n    const timeout = getEffectiveValue(\"timeout\");\n\n    const url = new URL(`${this.getBaseUrl()}${path}`);\n    if (query) {\n      Object.entries(query).forEach(([key, value]) => {\n        if (value !== undefined) {\n          url.searchParams.append(key, String(value));\n        }\n      });\n    }\n\n    let lastError: Error | undefined;\n\n    for (let attempt = 0; attempt <= maxRetries; attempt++) {\n      try {\n        const controller = new AbortController();\n        const timeoutId = setTimeout(() => controller.abort(), timeout);\n\n        const response = await fetch(url.toString(), {\n          method,\n          headers: this.getHeaders(requireAuth),\n          body: body ? JSON.stringify(body) : undefined,\n          signal: controller.signal,\n        });\n\n        clearTimeout(timeoutId);\n\n        // Update rate limit info\n        this.updateRateLimitInfo(response.headers);\n\n        // Parse response\n        const data = await response.json().catch(() => ({}));\n\n        if (!response.ok) {\n          this.handleError(response.status, data);\n        }\n\n        return data as T;\n      } catch (error) {\n        lastError = error as Error;\n\n        // Don't retry non-retryable errors (4xx client errors)\n        if (!isRetryableError(error)) {\n          throw error;\n        }\n\n        // Don't retry on last attempt\n        if (attempt === maxRetries) {\n          throw error;\n        }\n\n        // Exponential backoff: 1s, 2s, 4s, etc.\n        const backoffMs = Math.min(1000 * Math.pow(2, attempt), 10000);\n        await sleep(backoffMs);\n      }\n    }\n\n    // Should never reach here, but TypeScript needs this\n    throw lastError || new Error(\"Request failed\");\n  }\n\n  private updateRateLimitInfo(headers: Headers): void {\n    const limit = headers.get(\"X-RateLimit-Limit\");\n    const remaining = headers.get(\"X-RateLimit-Remaining\");\n    const reset = headers.get(\"X-RateLimit-Reset\");\n\n    if (limit && remaining && reset) {\n      this.rateLimitInfo = {\n        limit: parseInt(limit, 10),\n        remaining: parseInt(remaining, 10),\n        reset: parseInt(reset, 10),\n      };\n    }\n  }\n\n  private handleError(statusCode: number, data: any): never {\n    const error = data?.error || \"unknown_error\";\n    const message = data?.message || `HTTP ${statusCode}`;\n    const details = data?.details;\n\n    switch (statusCode) {\n      case 401:\n      case 403:\n        // Detect if this is an API key required error vs general auth error\n        if (\n          error === \"invalid_api_key\" ||\n          error === \"api_key_required\" ||\n          message?.toLowerCase().includes(\"api key\")\n        ) {\n          throw new ApiKeyRequiredError(\n            \"API key required for sending messages\",\n            \"Set SENDLY_API_KEY environment variable or create a key with:\\n  sendly keys create --type test\",\n          );\n        }\n        throw new AuthenticationError(message);\n      case 400:\n        throw new ValidationError(message, details);\n      case 402:\n        throw new InsufficientCreditsError(message);\n      case 404:\n        throw new NotFoundError(message);\n      case 429:\n        const retryAfter = data?.retryAfter || 60;\n        throw new RateLimitError(retryAfter, message);\n      default:\n        const defaultHint =\n          statusCode >= 500\n            ? \"This is a server error. Try again later or check https://status.sendly.live\"\n            : undefined;\n        throw new ApiError(error, message, statusCode, details, defaultHint);\n    }\n  }\n\n  getRateLimitInfo(): RateLimitInfo | undefined {\n    return this.rateLimitInfo;\n  }\n\n  // Convenience methods\n  async get<T>(\n    path: string,\n    query?: Record<string, string | number | boolean | undefined>,\n    requireAuth: boolean = true,\n  ): Promise<T> {\n    return this.request<T>(\"GET\", path, { query, requireAuth });\n  }\n\n  async post<T>(\n    path: string,\n    body?: Record<string, unknown>,\n    requireAuth: boolean = true,\n  ): Promise<T> {\n    return this.request<T>(\"POST\", path, { body, requireAuth });\n  }\n\n  async patch<T>(\n    path: string,\n    body?: Record<string, unknown>,\n    requireAuth: boolean = true,\n  ): Promise<T> {\n    return this.request<T>(\"PATCH\", path, { body, requireAuth });\n  }\n\n  async delete<T>(path: string, requireAuth: boolean = true): Promise<T> {\n    return this.request<T>(\"DELETE\", path, { requireAuth });\n  }\n\n  /**\n   * Upload a file using multipart/form-data\n   * Used for batch CSV uploads to Supabase storage\n   */\n  async uploadFile<T>(\n    path: string,\n    file: {\n      buffer: Buffer;\n      filename: string;\n      mimetype?: string;\n    },\n    requireAuth: boolean = true,\n  ): Promise<T> {\n    const maxRetries = getEffectiveValue(\"maxRetries\");\n    const timeout = getEffectiveValue(\"timeout\");\n    const url = `${this.getBaseUrl()}${path}`;\n\n    // Build multipart form data manually (Node.js compatible)\n    const boundary = `----FormBoundary${Date.now()}${Math.random().toString(36).substring(2)}`;\n    const mimetype = file.mimetype || \"text/csv\";\n\n    const header = Buffer.from(\n      `--${boundary}\\r\\n` +\n        `Content-Disposition: form-data; name=\"file\"; filename=\"${file.filename}\"\\r\\n` +\n        `Content-Type: ${mimetype}\\r\\n\\r\\n`,\n    );\n    const footer = Buffer.from(`\\r\\n--${boundary}--\\r\\n`);\n    const body = Buffer.concat([header, file.buffer, footer]);\n\n    const headers: Record<string, string> = {\n      \"Content-Type\": `multipart/form-data; boundary=${boundary}`,\n      Accept: \"application/json\",\n      \"User-Agent\": `@sendly/cli/${version}`,\n    };\n\n    if (requireAuth) {\n      const token = getAuthToken();\n      if (!token) {\n        throw new AuthenticationError();\n      }\n      headers[\"Authorization\"] = `Bearer ${token}`;\n    }\n\n    let lastError: Error | undefined;\n\n    for (let attempt = 0; attempt <= maxRetries; attempt++) {\n      try {\n        const controller = new AbortController();\n        const timeoutId = setTimeout(() => controller.abort(), timeout);\n\n        const response = await fetch(url, {\n          method: \"POST\",\n          headers,\n          body,\n          signal: controller.signal,\n        });\n\n        clearTimeout(timeoutId);\n\n        this.updateRateLimitInfo(response.headers);\n        const data = await response.json().catch(() => ({}));\n\n        if (!response.ok) {\n          this.handleError(response.status, data);\n        }\n\n        return data as T;\n      } catch (error) {\n        lastError = error as Error;\n\n        if (!isRetryableError(error)) {\n          throw error;\n        }\n\n        if (attempt === maxRetries) {\n          throw error;\n        }\n\n        const backoffMs = Math.min(1000 * Math.pow(2, attempt), 10000);\n        await sleep(backoffMs);\n      }\n    }\n\n    throw lastError || new Error(\"Upload failed\");\n  }\n}\n\nexport const apiClient = new ApiClient();\n"]}