@sendly/cli 1.0.0

package/README.md

@@ -0,0 +1,323 @@
+# @sendly/cli
+
+Official command-line interface for the [Sendly](https://sendly.live) SMS API.
+
+## Installation
+
+```bash
+npm install -g @sendly/cli
+```
+
+## Quick Start
+
+```bash
+# Login to your Sendly account
+sendly login
+
+# Send an SMS
+sendly sms send --to "+15551234567" --text "Hello from Sendly CLI!"
+
+# Check your credit balance
+sendly credits balance
+```
+
+## Authentication
+
+The CLI supports two authentication methods:
+
+### Browser Login (Recommended)
+
+```bash
+sendly login
+```
+
+This opens your browser to authenticate via Sendly's secure login flow. After authorization, your credentials are stored locally.
+
+### API Key Login
+
+```bash
+sendly login --api-key sk_test_v1_your_key
+```
+
+Or interactively:
+
+```bash
+sendly login -i
+```
+
+### Check Authentication Status
+
+```bash
+sendly whoami
+```
+
+### Logout
+
+```bash
+sendly logout
+```
+
+## Commands
+
+### SMS Commands
+
+#### Send a Message
+
+```bash
+sendly sms send --to "+15551234567" --text "Hello!"
+
+# With sender ID (international)
+sendly sms send --to "+447700900000" --text "Hello!" --from "MyBrand"
+```
+
+#### List Messages
+
+```bash
+sendly sms list
+
+# Filter by status
+sendly sms list --status delivered
+
+# Limit results
+sendly sms list --limit 10
+```
+
+#### Get Message Details
+
+```bash
+sendly sms get msg_abc123
+```
+
+#### Send Batch Messages
+
+```bash
+# From a CSV file
+sendly sms batch --file recipients.csv --text "Hello {name}!"
+
+# Multiple recipients inline
+sendly sms batch --to "+15551234567,+15559876543" --text "Hello everyone!"
+```
+
+#### Schedule a Message
+
+```bash
+sendly sms schedule --to "+15551234567" --text "Reminder!" --at "2025-12-25T10:00:00Z"
+```
+
+#### List Scheduled Messages
+
+```bash
+sendly sms scheduled
+```
+
+#### Cancel a Scheduled Message
+
+```bash
+sendly sms cancel sched_abc123
+```
+
+### API Key Commands
+
+#### List API Keys
+
+```bash
+sendly keys list
+```
+
+#### Create a New Key
+
+```bash
+sendly keys create --name "Production Key" --type live
+```
+
+#### Revoke a Key
+
+```bash
+sendly keys revoke key_abc123
+```
+
+### Credit Commands
+
+#### Check Balance
+
+```bash
+sendly credits balance
+```
+
+Output includes:
+- Current balance
+- Reserved credits
+- Estimated messages remaining
+
+#### View Transaction History
+
+```bash
+sendly credits history
+
+# Limit results
+sendly credits history --limit 20
+```
+
+### Webhook Commands
+
+#### List Webhooks
+
+```bash
+sendly webhooks list
+```
+
+#### Listen for Webhooks Locally
+
+Start a local tunnel to receive webhook events during development (similar to Stripe CLI):
+
+```bash
+sendly webhooks listen
+
+# Forward to a specific URL
+sendly webhooks listen --forward http://localhost:3000/webhook
+
+# Listen for specific events
+sendly webhooks listen --events message.delivered,message.failed
+```
+
+This creates a secure tunnel and displays:
+- Tunnel URL
+- Webhook secret for signature verification
+- Real-time event stream
+
+### Logs Commands
+
+#### Tail Logs
+
+Stream real-time API activity:
+
+```bash
+sendly logs tail
+
+# Filter by status
+sendly logs tail --status error
+```
+
+### Configuration Commands
+
+#### Get Configuration Value
+
+```bash
+sendly config get baseUrl
+```
+
+#### Set Configuration Value
+
+```bash
+sendly config set baseUrl https://api.sendly.live
+```
+
+#### List All Configuration
+
+```bash
+sendly config list
+```
+
+### Diagnostics
+
+Run diagnostics to check your setup:
+
+```bash
+sendly doctor
+```
+
+This checks:
+- Authentication status
+- API connectivity
+- Configuration validity
+- Network issues
+
+## Environment Variables
+
+Override CLI configuration with environment variables:
+
+| Variable | Description |
+|----------|-------------|
+| `SENDLY_API_KEY` | API key for authentication |
+| `SENDLY_BASE_URL` | API base URL (default: `https://sendly.live`) |
+| `SENDLY_OUTPUT_FORMAT` | Output format: `text` or `json` |
+| `SENDLY_NO_COLOR` | Disable colored output |
+| `SENDLY_TIMEOUT` | Request timeout in milliseconds |
+| `SENDLY_MAX_RETRIES` | Maximum retry attempts |
+
+## Output Formats
+
+### Text (Default)
+
+Human-readable formatted output with colors.
+
+### JSON
+
+Machine-readable JSON output for scripting:
+
+```bash
+sendly sms list --json
+sendly credits balance --json
+```
+
+## CI/CD Usage
+
+For non-interactive environments:
+
+```bash
+# Set API key via environment variable
+export SENDLY_API_KEY=sk_live_v1_your_key
+
+# Or pass directly
+sendly sms send --api-key sk_live_v1_your_key --to "+15551234567" --text "Hello!"
+
+# Use JSON output for parsing
+sendly credits balance --json | jq '.balance'
+```
+
+## Configuration Storage
+
+Configuration is stored in:
+- **macOS**: `~/.config/sendly/`
+- **Linux**: `~/.config/sendly/`
+- **Windows**: `%APPDATA%\sendly\`
+
+## Webhook Signature Verification
+
+When using `sendly webhooks listen`, verify signatures in your app:
+
+```javascript
+import crypto from 'crypto';
+
+function verifyWebhook(payload, signature, secret) {
+  const expectedSig = 'v1=' + crypto
+    .createHmac('sha256', secret)
+    .update(payload)
+    .digest('hex');
+  
+  return crypto.timingSafeEqual(
+    Buffer.from(signature),
+    Buffer.from(expectedSig)
+  );
+}
+```
+
+## Requirements
+
+- Node.js 18.0.0 or higher
+- A Sendly account ([sign up free](https://sendly.live))
+
+## Documentation
+
+- [CLI Documentation](https://sendly.live/docs/cli)
+- [API Reference](https://sendly.live/docs/api)
+- [Sendly Dashboard](https://sendly.live/dashboard)
+
+## Support
+
+- [GitHub Issues](https://github.com/sendly-live/sendly-cli/issues)
+- Email: support@sendly.live
+
+## License
+
+MIT

package/bin/run.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { execute } from "@oclif/core";
+
+await execute({ dir: import.meta.url });

package/dist/commands/config/get.d.ts

@@ -0,0 +1,13 @@
+import { BaseCommand } from "../../lib/base-command.js";
+export default class ConfigGet extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        key: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        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/config/get.js

@@ -0,0 +1,38 @@
+import { Args } from "@oclif/core";
+import { BaseCommand } from "../../lib/base-command.js";
+import { getConfigValue } from "../../lib/config.js";
+import { colors, json, isJsonMode } from "../../lib/output.js";
+const ALLOWED_KEYS = [
+    "environment",
+    "baseUrl",
+    "defaultFormat",
+    "colorEnabled",
+];
+export default class ConfigGet extends BaseCommand {
+    static description = "Get a configuration value";
+    static examples = [
+        "<%= config.bin %> config get environment",
+        "<%= config.bin %> config get baseUrl",
+    ];
+    static args = {
+        key: Args.string({
+            description: "Configuration key",
+            required: true,
+            options: ALLOWED_KEYS,
+        }),
+    };
+    static flags = {
+        ...BaseCommand.baseFlags,
+    };
+    async run() {
+        const { args, flags } = await this.parse(ConfigGet);
+        const key = args.key;
+        const value = getConfigValue(key);
+        if (isJsonMode()) {
+            json({ [key]: value });
+            return;
+        }
+        console.log(`${colors.dim(key + ":")} ${colors.primary(String(value))}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,10 @@
+import { BaseCommand } from "../../lib/base-command.js";
+export default class ConfigList extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        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/config/list.js

@@ -0,0 +1,45 @@
+import { BaseCommand } from "../../lib/base-command.js";
+import { getConfig, getConfigPath, } from "../../lib/config.js";
+import { colors, keyValue, json, isJsonMode, header } from "../../lib/output.js";
+export default class ConfigList extends BaseCommand {
+    static description = "List all configuration values";
+    static examples = [
+        "<%= config.bin %> config list",
+        "<%= config.bin %> config list --json",
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+    };
+    async run() {
+        const config = getConfig();
+        if (isJsonMode()) {
+            // Don't expose sensitive data in JSON output
+            const safeConfig = {
+                environment: config.environment,
+                baseUrl: config.baseUrl,
+                defaultFormat: config.defaultFormat,
+                colorEnabled: config.colorEnabled,
+                hasApiKey: !!config.apiKey,
+                hasAccessToken: !!config.accessToken,
+                configPath: getConfigPath(),
+            };
+            json(safeConfig);
+            return;
+        }
+        header("Configuration");
+        const displayConfig = {
+            Environment: config.environment === "live"
+                ? colors.success(config.environment)
+                : colors.warning(config.environment),
+            "Base URL": config.baseUrl,
+            "Output Format": config.defaultFormat,
+            "Colors": config.colorEnabled ? colors.success("enabled") : colors.dim("disabled"),
+            "API Key": config.apiKey ? colors.success("configured") : colors.dim("not set"),
+            "Access Token": config.accessToken ? colors.success("configured") : colors.dim("not set"),
+        };
+        keyValue(displayConfig);
+        console.log();
+        console.log(colors.dim(`Config file: ${getConfigPath()}`));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/config/set.d.ts

@@ -0,0 +1,14 @@
+import { BaseCommand } from "../../lib/base-command.js";
+export default class ConfigSet extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        key: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+        value: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        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/config/set.js

@@ -0,0 +1,67 @@
+import { Args } from "@oclif/core";
+import { BaseCommand } from "../../lib/base-command.js";
+import { setConfig } from "../../lib/config.js";
+import { success, error, colors } from "../../lib/output.js";
+const ALLOWED_KEYS = [
+    "environment",
+    "baseUrl",
+    "defaultFormat",
+    "colorEnabled",
+];
+export default class ConfigSet extends BaseCommand {
+    static description = "Set a configuration value";
+    static examples = [
+        "<%= config.bin %> config set environment live",
+        "<%= config.bin %> config set defaultFormat json",
+        "<%= config.bin %> config set baseUrl https://api.sendly.live",
+    ];
+    static args = {
+        key: Args.string({
+            description: "Configuration key",
+            required: true,
+            options: ALLOWED_KEYS,
+        }),
+        value: Args.string({
+            description: "Configuration value",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...BaseCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(ConfigSet);
+        const key = args.key;
+        // Validate and transform value
+        let value = args.value;
+        switch (key) {
+            case "environment":
+                if (!["test", "live"].includes(value)) {
+                    error("Invalid environment. Use 'test' or 'live'");
+                    this.exit(1);
+                }
+                break;
+            case "defaultFormat":
+                if (!["human", "json"].includes(value)) {
+                    error("Invalid format. Use 'human' or 'json'");
+                    this.exit(1);
+                }
+                break;
+            case "colorEnabled":
+                value = value === "true" || value === "1";
+                break;
+            case "baseUrl":
+                try {
+                    new URL(value);
+                }
+                catch {
+                    error("Invalid URL format");
+                    this.exit(1);
+                }
+                break;
+        }
+        setConfig(key, value);
+        success(`Set ${colors.code(key)} = ${colors.primary(String(value))}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/credits/balance.d.ts

@@ -0,0 +1,10 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class CreditsBalance extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        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/credits/balance.js

@@ -0,0 +1,38 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { json, keyValue, colors, header, isJsonMode, } from "../../lib/output.js";
+export default class CreditsBalance extends AuthenticatedCommand {
+    static description = "Check your credit balance";
+    static examples = [
+        "<%= config.bin %> credits balance",
+        "<%= config.bin %> credits balance --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const credits = await apiClient.get("/api/credits");
+        if (isJsonMode()) {
+            json(credits);
+            return;
+        }
+        header("Credit Balance");
+        const availableCredits = credits.balance - (credits.reservedBalance || 0);
+        keyValue({
+            Available: colors.primary(`${availableCredits.toLocaleString()} credits`),
+            Reserved: credits.reservedBalance
+                ? colors.warning(`${credits.reservedBalance.toLocaleString()} credits`)
+                : colors.dim("0 credits"),
+            "Total Balance": `${credits.balance.toLocaleString()} credits`,
+            "Lifetime Credits": colors.dim(`${credits.lifetimeCredits.toLocaleString()} credits`),
+        });
+        console.log();
+        // Show approximate message capacity
+        const domesticMessages = Math.floor(availableCredits / 1);
+        const internationalMessages = Math.floor(availableCredits / 8);
+        console.log(colors.dim("Estimated capacity:"));
+        console.log(`  ${colors.dim("US/Canada:")} ~${domesticMessages.toLocaleString()} messages`);
+        console.log(`  ${colors.dim("International:")} ~${internationalMessages.toLocaleString()} messages`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/credits/history.d.ts

@@ -0,0 +1,11 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class CreditsHistory extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        limit: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number, 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>;
+}