hooksdash 1.0.0

package/bin/hooksdash.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require('../dist/index.js');

package/dist/commands/forward.d.ts

@@ -0,0 +1,7 @@
+interface ForwardOptions {
+    port: number;
+    host: string;
+    endpoint?: string;
+}
+export declare function forward(options: ForwardOptions): Promise<void>;
+export {};

package/dist/commands/forward.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forward = forward;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const axios_1 = __importDefault(require("axios"));
+const config_1 = require("../lib/config");
+const websocket_1 = require("../lib/websocket");
+async function forward(options) {
+    if (!(0, config_1.isLoggedIn)()) {
+        console.error(chalk_1.default.red('Error: You must be logged in to forward webhooks'));
+        console.log(chalk_1.default.gray('Run: hooksdash login --api-key <key>'));
+        process.exit(1);
+    }
+    const apiKey = (0, config_1.getApiKey)();
+    const apiUrl = (0, config_1.getApiUrl)();
+    // If no endpoint specified, we need to get/create one
+    let endpointSlug = options.endpoint;
+    if (!endpointSlug) {
+        const spinner = (0, ora_1.default)('Fetching your endpoints...').start();
+        try {
+            const response = await axios_1.default.get(`${apiUrl}/endpoints`, {
+                headers: { 'X-API-Key': apiKey },
+            });
+            const endpoints = response.data.data || [];
+            if (endpoints.length === 0) {
+                spinner.text = 'Creating a new endpoint...';
+                const createResponse = await axios_1.default.post(`${apiUrl}/endpoints`, { name: 'CLI Endpoint' }, {
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'X-API-Key': apiKey,
+                    },
+                });
+                endpointSlug = createResponse.data.data.slug;
+                spinner.succeed(`Created endpoint: ${endpointSlug}`);
+            }
+            else {
+                endpointSlug = endpoints[0].slug;
+                spinner.succeed(`Using endpoint: ${endpointSlug}`);
+            }
+        }
+        catch (error) {
+            spinner.fail('Failed to connect to API');
+            if (error instanceof Error) {
+                console.error(chalk_1.default.gray(error.message));
+            }
+            process.exit(1);
+        }
+    }
+    if (!endpointSlug) {
+        console.error(chalk_1.default.red('Error: Could not determine endpoint'));
+        process.exit(1);
+    }
+    console.log(chalk_1.default.cyan(`\nForwarding webhooks to ${options.host}:${options.port}`));
+    const client = new websocket_1.TunnelClient({
+        apiKey,
+        apiUrl,
+        endpointSlug,
+        localPort: options.port,
+        localHost: options.host,
+    });
+    // Handle graceful shutdown
+    process.on('SIGINT', () => {
+        console.log(chalk_1.default.yellow('\nDisconnecting...'));
+        client.disconnect();
+        process.exit(0);
+    });
+    process.on('SIGTERM', () => {
+        client.disconnect();
+        process.exit(0);
+    });
+    try {
+        await client.connect();
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('Failed to establish tunnel'));
+        if (error instanceof Error) {
+            console.error(chalk_1.default.gray(error.message));
+        }
+        process.exit(1);
+    }
+}

package/dist/commands/login.d.ts

@@ -0,0 +1,6 @@
+interface LoginOptions {
+    apiKey?: string;
+    apiUrl?: string;
+}
+export declare function login(options: LoginOptions): Promise<void>;
+export {};

package/dist/commands/login.js

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.login = login;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const open_1 = __importDefault(require("open"));
+const axios_1 = __importDefault(require("axios"));
+const config_1 = require("../lib/config");
+async function validateApiKey(apiKey) {
+    try {
+        const response = await axios_1.default.get(`${(0, config_1.getApiUrl)()}/users/validate`, {
+            headers: {
+                'X-API-Key': apiKey,
+            },
+        });
+        return response.data.data;
+    }
+    catch (error) {
+        throw new Error('Invalid API key');
+    }
+}
+async function browserAuthentication() {
+    const spinner = (0, ora_1.default)('Creating authentication session...').start();
+    try {
+        // Create CLI session
+        const createResponse = await axios_1.default.post(`${(0, config_1.getApiUrl)()}/auth/cli-session`);
+        const sessionData = createResponse.data;
+        spinner.succeed('Authentication session created');
+        console.log(chalk_1.default.cyan('Opening browser for authentication...'));
+        console.log(chalk_1.default.gray(`If browser doesn't open, visit: ${sessionData.data.authUrl}`));
+        // Open browser
+        await (0, open_1.default)(sessionData.data.authUrl);
+        // Poll for completion
+        const pollSpinner = (0, ora_1.default)('Waiting for authentication in browser...').start();
+        const startTime = Date.now();
+        const timeout = sessionData.data.expiresIn * 1000; // Convert to milliseconds
+        const pollInterval = 2000; // 2 seconds
+        while (Date.now() - startTime < timeout) {
+            // Wait before polling
+            await new Promise((resolve) => setTimeout(resolve, pollInterval));
+            // Check session status
+            const statusResponse = await axios_1.default.get(`${(0, config_1.getApiUrl)()}/auth/cli-session/${sessionData.data.sessionId}`);
+            const statusData = statusResponse.data.data;
+            if (statusData.status === 'completed' && statusData.apiKey) {
+                pollSpinner.succeed('Authentication completed!');
+                return statusData.apiKey;
+            }
+            if (statusData.status === 'expired') {
+                pollSpinner.fail('Authentication session expired');
+                throw new Error('Session expired. Please try again.');
+            }
+            // Continue polling (status is 'pending')
+        }
+        // Timeout reached
+        pollSpinner.fail('Authentication timed out');
+        throw new Error('Authentication timed out. Please try again.');
+    }
+    catch (error) {
+        spinner.fail('Authentication failed');
+        throw error;
+    }
+}
+async function login(options) {
+    const { apiKey, apiUrl } = options;
+    // Set API URL if provided
+    if (apiUrl) {
+        (0, config_1.setApiUrl)(apiUrl);
+    }
+    try {
+        let finalApiKey;
+        if (apiKey) {
+            // Legacy flow: manual API key
+            const spinner = (0, ora_1.default)('Validating API key...').start();
+            const userData = await validateApiKey(apiKey);
+            spinner.succeed('Logged in successfully');
+            finalApiKey = apiKey;
+            console.log(chalk_1.default.green(`Welcome! You're logged in as ${userData.email}`));
+            console.log(chalk_1.default.gray(`Tier: ${userData.tier}`));
+        }
+        else {
+            // New flow: browser authentication
+            finalApiKey = await browserAuthentication();
+            // Validate the API key to get user info
+            const spinner = (0, ora_1.default)('Fetching user information...').start();
+            const userData = await validateApiKey(finalApiKey);
+            spinner.succeed('Successfully authenticated!');
+            console.log(chalk_1.default.green(`Welcome! You're logged in as ${userData.email}`));
+            console.log(chalk_1.default.gray(`Tier: ${userData.tier}`));
+        }
+        // Save API key
+        (0, config_1.setApiKey)(finalApiKey);
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('Could not connect to HooksDash API'));
+        if (error instanceof Error) {
+            console.error(chalk_1.default.gray(error.message));
+        }
+        process.exit(1);
+    }
+}

package/dist/commands/logout.d.ts

@@ -0,0 +1 @@
+export declare function logout(): void;

package/dist/commands/logout.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logout = logout;
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("../lib/config");
+function logout() {
+    if (!(0, config_1.isLoggedIn)()) {
+        console.log(chalk_1.default.yellow('You are not logged in'));
+        return;
+    }
+    (0, config_1.clearApiKey)();
+    console.log(chalk_1.default.green('Logged out successfully'));
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+const commander_1 = require("commander");
+const login_1 = require("./commands/login");
+const logout_1 = require("./commands/logout");
+const forward_1 = require("./commands/forward");
+const config_1 = require("./lib/config");
+const program = new commander_1.Command();
+program
+    .name('hooksdash')
+    .description('HooksDash CLI - Forward webhooks to your local machine')
+    .version('1.0.0');
+program
+    .command('login')
+    .description('Login via browser or with API key')
+    .option('-k, --api-key <key>', 'Your HooksDash API key (optional, defaults to browser login)')
+    .option('--api-url <url>', 'Custom API URL (for development)')
+    .action(login_1.login);
+program.command('logout').description('Logout and clear stored credentials').action(logout_1.logout);
+program
+    .command('forward')
+    .description('Forward webhooks to your local server')
+    .option('-p, --port <port>', 'Local port to forward to', '3000')
+    .option('-h, --host <host>', 'Local host to forward to', 'localhost')
+    .option('-e, --endpoint <slug>', 'Endpoint slug to use')
+    .action((options) => {
+    (0, forward_1.forward)({
+        port: parseInt(options.port, 10),
+        host: options.host,
+        endpoint: options.endpoint,
+    });
+});
+program
+    .command('status')
+    .description('Check login status')
+    .action(() => {
+    if ((0, config_1.isLoggedIn)()) {
+        const apiKey = (0, config_1.getApiKey)();
+        const maskedKey = apiKey ? `${apiKey.slice(0, 7)}****${apiKey.slice(-4)}` : '';
+        console.log(chalk_1.default.green('Logged in'));
+        console.log(chalk_1.default.gray(`API Key: ${maskedKey}`));
+    }
+    else {
+        console.log(chalk_1.default.yellow('Not logged in'));
+        console.log(chalk_1.default.gray('Run: hooksdash login'));
+    }
+});
+program.parse();

package/dist/lib/config.d.ts

@@ -0,0 +1,13 @@
+import Conf from 'conf';
+interface ConfigSchema {
+    apiKey?: string;
+    apiUrl: string;
+}
+declare const config: Conf<ConfigSchema>;
+export declare function getApiKey(): string | undefined;
+export declare function setApiKey(apiKey: string): void;
+export declare function clearApiKey(): void;
+export declare function getApiUrl(): string;
+export declare function setApiUrl(url: string): void;
+export declare function isLoggedIn(): boolean;
+export { config };

package/dist/lib/config.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+exports.getApiKey = getApiKey;
+exports.setApiKey = setApiKey;
+exports.clearApiKey = clearApiKey;
+exports.getApiUrl = getApiUrl;
+exports.setApiUrl = setApiUrl;
+exports.isLoggedIn = isLoggedIn;
+const conf_1 = __importDefault(require("conf"));
+const config = new conf_1.default({
+    projectName: 'hooksdash',
+    defaults: {
+        apiUrl: 'https://api.hooksdash.ibadsiddiqui.dev/api',
+    },
+});
+exports.config = config;
+function getApiKey() {
+    return config.get('apiKey');
+}
+function setApiKey(apiKey) {
+    config.set('apiKey', apiKey);
+}
+function clearApiKey() {
+    config.delete('apiKey');
+}
+function getApiUrl() {
+    return config.get('apiUrl');
+}
+function setApiUrl(url) {
+    config.set('apiUrl', url);
+}
+function isLoggedIn() {
+    return !!getApiKey();
+}

package/dist/lib/websocket.d.ts

@@ -0,0 +1,18 @@
+interface TunnelOptions {
+    apiKey: string;
+    apiUrl: string;
+    endpointSlug: string;
+    localPort: number;
+    localHost: string;
+}
+export declare class TunnelClient {
+    private socket;
+    private options;
+    private reconnectAttempts;
+    constructor(options: TunnelOptions);
+    connect(): Promise<void>;
+    private authenticate;
+    private forwardRequest;
+    disconnect(): void;
+}
+export {};

package/dist/lib/websocket.js

@@ -0,0 +1,119 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TunnelClient = void 0;
+const socket_io_client_1 = require("socket.io-client");
+const chalk_1 = __importDefault(require("chalk"));
+const axios_1 = __importDefault(require("axios"));
+const shared_1 = require("@hooksdash/shared");
+class TunnelClient {
+    socket = null;
+    options;
+    reconnectAttempts = 0;
+    constructor(options) {
+        this.options = options;
+    }
+    async connect() {
+        return new Promise((resolve, reject) => {
+            const wsUrl = this.options.apiUrl.replace('http', 'ws');
+            this.socket = (0, socket_io_client_1.io)(`${wsUrl}/tunnel`, {
+                transports: ['websocket'],
+                reconnection: true,
+                reconnectionDelay: shared_1.WEBSOCKET.RECONNECT_DELAY,
+                reconnectionAttempts: shared_1.WEBSOCKET.MAX_RECONNECT_ATTEMPTS,
+            });
+            this.socket.on('connect', () => {
+                console.log(chalk_1.default.green('Connected to HooksDash'));
+                this.authenticate();
+                this.reconnectAttempts = 0;
+            });
+            this.socket.on(shared_1.TUNNEL_MESSAGE_TYPE.AUTH_SUCCESS, (data) => {
+                console.log(chalk_1.default.green(`Authenticated! Forwarding to localhost:${this.options.localPort}`));
+                console.log(chalk_1.default.cyan(`Webhook URL: https://hooksdash.ibadsiddiqui.dev/api/h/${data.endpoint.slug}`));
+                console.log(chalk_1.default.gray('Press Ctrl+C to stop'));
+                resolve();
+            });
+            this.socket.on(shared_1.TUNNEL_MESSAGE_TYPE.AUTH_ERROR, (data) => {
+                console.error(chalk_1.default.red(`Authentication failed: ${data.message}`));
+                this.disconnect();
+                reject(new Error(data.message));
+            });
+            this.socket.on('request', async (payload, callback) => {
+                console.log(chalk_1.default.cyan(`← ${payload.method} ${payload.path}`));
+                try {
+                    const response = await this.forwardRequest(payload);
+                    console.log(chalk_1.default.green(`→ ${response.statusCode}`));
+                    callback(response);
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                    console.error(chalk_1.default.red(`→ Error: ${errorMessage}`));
+                    callback({
+                        requestId: payload.requestId,
+                        statusCode: 502,
+                        headers: {},
+                        body: JSON.stringify({ error: errorMessage }),
+                    });
+                }
+            });
+            this.socket.on(shared_1.TUNNEL_MESSAGE_TYPE.HEARTBEAT, () => {
+                // Respond to heartbeat
+            });
+            this.socket.on('disconnect', (reason) => {
+                if (reason === 'io server disconnect') {
+                    console.log(chalk_1.default.yellow('Disconnected by server'));
+                }
+                else {
+                    console.log(chalk_1.default.yellow('Connection lost, attempting to reconnect...'));
+                }
+            });
+            this.socket.on('connect_error', (error) => {
+                this.reconnectAttempts++;
+                if (this.reconnectAttempts >= shared_1.WEBSOCKET.MAX_RECONNECT_ATTEMPTS) {
+                    console.error(chalk_1.default.red('Failed to connect after multiple attempts'));
+                    reject(error);
+                }
+            });
+            this.socket.on('error', (error) => {
+                console.error(chalk_1.default.red(`Socket error: ${error}`));
+            });
+        });
+    }
+    authenticate() {
+        const payload = {
+            apiKey: this.options.apiKey,
+            endpointSlug: this.options.endpointSlug,
+        };
+        this.socket?.emit(shared_1.TUNNEL_MESSAGE_TYPE.AUTH, payload);
+    }
+    async forwardRequest(payload) {
+        const url = `http://${this.options.localHost}:${this.options.localPort}${payload.path}`;
+        try {
+            const response = await (0, axios_1.default)({
+                method: payload.method.toLowerCase(),
+                url,
+                headers: payload.headers,
+                data: payload.body || undefined,
+                validateStatus: () => true, // Accept any status code
+            });
+            return {
+                requestId: payload.requestId,
+                statusCode: response.status,
+                headers: response.headers,
+                body: typeof response.data === 'string' ? response.data : JSON.stringify(response.data),
+            };
+        }
+        catch (error) {
+            throw new Error(error instanceof Error ? error.message : 'Request forwarding failed');
+        }
+    }
+    disconnect() {
+        if (this.socket) {
+            this.socket.disconnect();
+            this.socket = null;
+        }
+    }
+}
+exports.TunnelClient = TunnelClient;

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "hooksdash",
+  "version": "1.0.0",
+  "description": "CLI tool for HooksDash - Inspect, debug, and forward webhooks to your local development environment",
+  "bin": {
+    "hooksdash": "bin/hooksdash.js",
+    "hd": "bin/hooksdash.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "bin",
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "dev": "tsc --watch",
+    "prepublishOnly": "pnpm run build"
+  },
+  "dependencies": {
+    "@hooksdash/shared": "workspace:*",
+    "axios": "^1.13.3",
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "conf": "^10.2.0",
+    "open": "^11.0.0",
+    "ora": "^5.4.1",
+    "socket.io-client": "^4.7.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "typescript": "^5.3.0"
+  },
+  "keywords": [
+    "webhook",
+    "webhooks",
+    "cli",
+    "tunnel",
+    "hooksdash",
+    "webhook-testing",
+    "webhook-debugging",
+    "localhost-tunnel",
+    "ngrok-alternative",
+    "webhook-inspector",
+    "webhook-forwarding",
+    "development-tools",
+    "api-testing"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ibadsiddiqui/hooksdash.git",
+    "directory": "packages/cli"
+  },
+  "bugs": {
+    "url": "https://github.com/ibadsiddiqui/hooksdash/issues"
+  },
+  "homepage": "https://hooksdash.ibadsiddiqui.dev",
+  "author": "Ibad Siddiqui <ibad@hooksdash.ibadsiddiqui.dev> (https://hooksdash.ibadsiddiqui.dev)",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}