@abbacchio/transport 0.1.0 → 0.1.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@abbacchio/transport",
-  "version": "0.1.0",
-  "description": "Abbacchio transport - Log transports for Pino, Winston, Bunyan, and console",
+  "version": "0.1.2",
+  "description": "Node.js log transports for Pino, Winston, and Bunyan - send logs to Abbacchio",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -27,10 +27,6 @@
       "default": "./dist/transports/console.js"
     }
   },
-  "scripts": {
-    "build": "tsc",
-    "dev": "tsc --watch"
-  },
   "keywords": [
     "pino",
     "winston",
@@ -52,5 +48,9 @@
   },
   "engines": {
     "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
   }
-}
+}

package/src/client.ts

@@ -1,148 +1,148 @@
-import { encrypt } from "./encrypt.js";
-
-export interface AbbacchioClientOptions {
-  /** Server URL endpoint */
-  url?: string;
-  /** Secret key for encryption. If provided, logs will be encrypted before sending */
-  secretKey?: string;
-  /** Channel/app name for multi-app support. Defaults to 'default' */
-  channel?: string;
-  /** Number of logs to batch before sending. Defaults to 10 */
-  batchSize?: number;
-  /** Interval in ms between flushes. Defaults to 1000 */
-  interval?: number;
-  /** Additional headers to send with requests */
-  headers?: Record<string, string>;
-}
-
-/**
- * Shared HTTP client for all Abbacchio transports.
- * Handles batching, encryption, and HTTP communication.
- */
-export class AbbacchioClient {
-  private url: string;
-  private secretKey?: string;
-  private channel?: string;
-  private batchSize: number;
-  private interval: number;
-  private headers: Record<string, string>;
-
-  private buffer: unknown[] = [];
-  private timer: ReturnType<typeof setTimeout> | null = null;
-
-  constructor(options: AbbacchioClientOptions = {}) {
-    this.url = options.url || "http://localhost:4000/api/logs";
-    this.secretKey = options.secretKey;
-    this.channel = options.channel;
-    this.batchSize = options.batchSize || 10;
-    this.interval = options.interval || 1000;
-    this.headers = options.headers || {};
-  }
-
-  /**
-   * Process a log entry (encrypt if secretKey is provided)
-   */
-  private processLog(log: unknown): unknown {
-    if (this.secretKey) {
-      return { encrypted: encrypt(JSON.stringify(log), this.secretKey) };
-    }
-    return log;
-  }
-
-  /**
-   * Add a log to the buffer and trigger send if needed
-   */
-  add(log: unknown): void {
-    this.buffer.push(this.processLog(log));
-
-    if (this.buffer.length >= this.batchSize) {
-      this.flush();
-    } else {
-      this.scheduleSend();
-    }
-  }
-
-  /**
-   * Add multiple logs at once
-   */
-  addBatch(logs: unknown[]): void {
-    for (const log of logs) {
-      this.buffer.push(this.processLog(log));
-    }
-
-    if (this.buffer.length >= this.batchSize) {
-      this.flush();
-    } else {
-      this.scheduleSend();
-    }
-  }
-
-  /**
-   * Send logs immediately without batching
-   */
-  async send(logs: unknown[]): Promise<void> {
-    const processedLogs = logs.map(log => this.processLog(log));
-    await this.sendToServer(processedLogs);
-  }
-
-  /**
-   * Schedule a send after the interval
-   */
-  private scheduleSend(): void {
-    if (this.timer) return;
-    this.timer = setTimeout(() => {
-      this.timer = null;
-      this.flush();
-    }, this.interval);
-  }
-
-  /**
-   * Flush the buffer and send to server
-   */
-  async flush(): Promise<void> {
-    if (this.buffer.length === 0) return;
-
-    const toSend = this.buffer;
-    this.buffer = [];
-
-    await this.sendToServer(toSend);
-  }
-
-  /**
-   * Send logs to the Abbacchio server
-   */
-  private async sendToServer(logs: unknown[]): Promise<void> {
-    try {
-      await fetch(this.url, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "X-Encrypted": this.secretKey ? "true" : "false",
-          ...(this.channel ? { "X-Channel": this.channel } : {}),
-          ...this.headers,
-        },
-        body: JSON.stringify({ logs }),
-      });
-    } catch {
-      // Silently fail - don't break the app if Abbacchio server is down
-    }
-  }
-
-  /**
-   * Close the client and flush any remaining logs
-   */
-  async close(): Promise<void> {
-    if (this.timer) {
-      clearTimeout(this.timer);
-      this.timer = null;
-    }
-    await this.flush();
-  }
-}
-
-/**
- * Create a new Abbacchio client instance
- */
-export function createClient(options?: AbbacchioClientOptions): AbbacchioClient {
-  return new AbbacchioClient(options);
-}
+import { encrypt } from "./encrypt.js";
+
+export interface AbbacchioClientOptions {
+  /** Server URL endpoint */
+  url?: string;
+  /** Secret key for encryption. If provided, logs will be encrypted before sending */
+  secretKey?: string;
+  /** Channel/app name for multi-app support. Defaults to 'default' */
+  channel?: string;
+  /** Number of logs to batch before sending. Defaults to 10 */
+  batchSize?: number;
+  /** Interval in ms between flushes. Defaults to 1000 */
+  interval?: number;
+  /** Additional headers to send with requests */
+  headers?: Record<string, string>;
+}
+
+/**
+ * Shared HTTP client for all Abbacchio transports.
+ * Handles batching, encryption, and HTTP communication.
+ */
+export class AbbacchioClient {
+  private url: string;
+  private secretKey?: string;
+  private channel?: string;
+  private batchSize: number;
+  private interval: number;
+  private headers: Record<string, string>;
+
+  private buffer: unknown[] = [];
+  private timer: ReturnType<typeof setTimeout> | null = null;
+
+  constructor(options: AbbacchioClientOptions = {}) {
+    this.url = options.url || "http://localhost:4000/api/logs";
+    this.secretKey = options.secretKey;
+    this.channel = options.channel;
+    this.batchSize = options.batchSize || 10;
+    this.interval = options.interval || 1000;
+    this.headers = options.headers || {};
+  }
+
+  /**
+   * Process a log entry (encrypt if secretKey is provided)
+   */
+  private processLog(log: unknown): unknown {
+    if (this.secretKey) {
+      return { encrypted: encrypt(JSON.stringify(log), this.secretKey) };
+    }
+    return log;
+  }
+
+  /**
+   * Add a log to the buffer and trigger send if needed
+   */
+  add(log: unknown): void {
+    this.buffer.push(this.processLog(log));
+
+    if (this.buffer.length >= this.batchSize) {
+      this.flush();
+    } else {
+      this.scheduleSend();
+    }
+  }
+
+  /**
+   * Add multiple logs at once
+   */
+  addBatch(logs: unknown[]): void {
+    for (const log of logs) {
+      this.buffer.push(this.processLog(log));
+    }
+
+    if (this.buffer.length >= this.batchSize) {
+      this.flush();
+    } else {
+      this.scheduleSend();
+    }
+  }
+
+  /**
+   * Send logs immediately without batching
+   */
+  async send(logs: unknown[]): Promise<void> {
+    const processedLogs = logs.map(log => this.processLog(log));
+    await this.sendToServer(processedLogs);
+  }
+
+  /**
+   * Schedule a send after the interval
+   */
+  private scheduleSend(): void {
+    if (this.timer) return;
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      this.flush();
+    }, this.interval);
+  }
+
+  /**
+   * Flush the buffer and send to server
+   */
+  async flush(): Promise<void> {
+    if (this.buffer.length === 0) return;
+
+    const toSend = this.buffer;
+    this.buffer = [];
+
+    await this.sendToServer(toSend);
+  }
+
+  /**
+   * Send logs to the Abbacchio server
+   */
+  private async sendToServer(logs: unknown[]): Promise<void> {
+    try {
+      await fetch(this.url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-Encrypted": this.secretKey ? "true" : "false",
+          ...(this.channel ? { "X-Channel": this.channel } : {}),
+          ...this.headers,
+        },
+        body: JSON.stringify({ logs }),
+      });
+    } catch {
+      // Silently fail - don't break the app if Abbacchio server is down
+    }
+  }
+
+  /**
+   * Close the client and flush any remaining logs
+   */
+  async close(): Promise<void> {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    await this.flush();
+  }
+}
+
+/**
+ * Create a new Abbacchio client instance
+ */
+export function createClient(options?: AbbacchioClientOptions): AbbacchioClient {
+  return new AbbacchioClient(options);
+}

package/src/encrypt.ts

@@ -1,112 +1,112 @@
-import { createCipheriv, createDecipheriv, randomBytes, pbkdf2Sync } from "crypto";
-
-/**
- * Generate a cryptographically secure random key for encryption.
- * Use this on the server/producer side to create a key for each channel.
- *
- * @param length - Length of the key in bytes (default: 32 for 256-bit key)
- * @returns A hex-encoded random key
- *
- * @example
- * ```typescript
- * import { generateKey } from "@abbacchio/client";
- *
- * // Generate a key for a channel
- * const key = generateKey();
- *
- * // Use in pino transport
- * const logger = pino({
- *   transport: {
- *     target: "@abbacchio/client/transports/pino",
- *     options: {
- *       url: "http://localhost:4000/api/logs",
- *       channel: "my-app",
- *       secretKey: key,
- *     },
- *   },
- * });
- *
- * // Share the dashboard URL with the key
- * console.log(`Dashboard: http://localhost:4000?channel=my-app&key=${key}`);
- * ```
- */
-export function generateKey(length: number = 32): string {
-  return randomBytes(length).toString("hex");
-}
-
-const ALGORITHM = "aes-256-gcm";
-const IV_LENGTH = 16;
-const AUTH_TAG_LENGTH = 16;
-const SALT_LENGTH = 32;
-const PBKDF2_ITERATIONS = 100000;
-
-/**
- * Derive a key from a password using PBKDF2 (browser-compatible)
- */
-function deriveKey(password: string, salt: Buffer): Buffer {
-  return pbkdf2Sync(password, salt, PBKDF2_ITERATIONS, 32, "sha256");
-}
-
-/**
- * Encrypt data with AES-256-GCM
- * Returns base64 encoded string: salt:iv:authTag:ciphertext
- */
-export function encrypt(data: string, secretKey: string): string {
-  const salt = randomBytes(SALT_LENGTH);
-  const key = deriveKey(secretKey, salt);
-  const iv = randomBytes(IV_LENGTH);
-
-  const cipher = createCipheriv(ALGORITHM, key, iv);
-  const encrypted = Buffer.concat([
-    cipher.update(data, "utf8"),
-    cipher.final(),
-  ]);
-  const authTag = cipher.getAuthTag();
-
-  // Combine: salt + iv + authTag + ciphertext
-  const combined = Buffer.concat([salt, iv, authTag, encrypted]);
-  return combined.toString("base64");
-}
-
-/**
- * Decrypt data encrypted with encrypt()
- */
-export function decrypt(encryptedData: string, secretKey: string): string {
-  const combined = Buffer.from(encryptedData, "base64");
-
-  // Extract components
-  const salt = combined.subarray(0, SALT_LENGTH);
-  const iv = combined.subarray(SALT_LENGTH, SALT_LENGTH + IV_LENGTH);
-  const authTag = combined.subarray(
-    SALT_LENGTH + IV_LENGTH,
-    SALT_LENGTH + IV_LENGTH + AUTH_TAG_LENGTH
-  );
-  const ciphertext = combined.subarray(SALT_LENGTH + IV_LENGTH + AUTH_TAG_LENGTH);
-
-  const key = deriveKey(secretKey, salt);
-  const decipher = createDecipheriv(ALGORITHM, key, iv);
-  decipher.setAuthTag(authTag);
-
-  const decrypted = Buffer.concat([
-    decipher.update(ciphertext),
-    decipher.final(),
-  ]);
-
-  return decrypted.toString("utf8");
-}
-
-/**
- * Encrypt a log object
- */
-export function encryptLog(log: unknown, secretKey: string): { encrypted: string } {
-  const jsonStr = JSON.stringify(log);
-  return { encrypted: encrypt(jsonStr, secretKey) };
-}
-
-/**
- * Decrypt an encrypted log
- */
-export function decryptLog<T = unknown>(encryptedLog: { encrypted: string }, secretKey: string): T {
-  const jsonStr = decrypt(encryptedLog.encrypted, secretKey);
-  return JSON.parse(jsonStr);
-}
+import { createCipheriv, createDecipheriv, randomBytes, pbkdf2Sync } from "crypto";
+
+/**
+ * Generate a cryptographically secure random key for encryption.
+ * Use this on the server/producer side to create a key for each channel.
+ *
+ * @param length - Length of the key in bytes (default: 32 for 256-bit key)
+ * @returns A hex-encoded random key
+ *
+ * @example
+ * ```typescript
+ * import { generateKey } from "@abbacchio/client";
+ *
+ * // Generate a key for a channel
+ * const key = generateKey();
+ *
+ * // Use in pino transport
+ * const logger = pino({
+ *   transport: {
+ *     target: "@abbacchio/client/transports/pino",
+ *     options: {
+ *       url: "http://localhost:4000/api/logs",
+ *       channel: "my-app",
+ *       secretKey: key,
+ *     },
+ *   },
+ * });
+ *
+ * // Share the dashboard URL with the key
+ * console.log(`Dashboard: http://localhost:4000?channel=my-app&key=${key}`);
+ * ```
+ */
+export function generateKey(length: number = 32): string {
+  return randomBytes(length).toString("hex");
+}
+
+const ALGORITHM = "aes-256-gcm";
+const IV_LENGTH = 16;
+const AUTH_TAG_LENGTH = 16;
+const SALT_LENGTH = 32;
+const PBKDF2_ITERATIONS = 100000;
+
+/**
+ * Derive a key from a password using PBKDF2 (browser-compatible)
+ */
+function deriveKey(password: string, salt: Buffer): Buffer {
+  return pbkdf2Sync(password, salt, PBKDF2_ITERATIONS, 32, "sha256");
+}
+
+/**
+ * Encrypt data with AES-256-GCM
+ * Returns base64 encoded string: salt:iv:authTag:ciphertext
+ */
+export function encrypt(data: string, secretKey: string): string {
+  const salt = randomBytes(SALT_LENGTH);
+  const key = deriveKey(secretKey, salt);
+  const iv = randomBytes(IV_LENGTH);
+
+  const cipher = createCipheriv(ALGORITHM, key, iv);
+  const encrypted = Buffer.concat([
+    cipher.update(data, "utf8"),
+    cipher.final(),
+  ]);
+  const authTag = cipher.getAuthTag();
+
+  // Combine: salt + iv + authTag + ciphertext
+  const combined = Buffer.concat([salt, iv, authTag, encrypted]);
+  return combined.toString("base64");
+}
+
+/**
+ * Decrypt data encrypted with encrypt()
+ */
+export function decrypt(encryptedData: string, secretKey: string): string {
+  const combined = Buffer.from(encryptedData, "base64");
+
+  // Extract components
+  const salt = combined.subarray(0, SALT_LENGTH);
+  const iv = combined.subarray(SALT_LENGTH, SALT_LENGTH + IV_LENGTH);
+  const authTag = combined.subarray(
+    SALT_LENGTH + IV_LENGTH,
+    SALT_LENGTH + IV_LENGTH + AUTH_TAG_LENGTH
+  );
+  const ciphertext = combined.subarray(SALT_LENGTH + IV_LENGTH + AUTH_TAG_LENGTH);
+
+  const key = deriveKey(secretKey, salt);
+  const decipher = createDecipheriv(ALGORITHM, key, iv);
+  decipher.setAuthTag(authTag);
+
+  const decrypted = Buffer.concat([
+    decipher.update(ciphertext),
+    decipher.final(),
+  ]);
+
+  return decrypted.toString("utf8");
+}
+
+/**
+ * Encrypt a log object
+ */
+export function encryptLog(log: unknown, secretKey: string): { encrypted: string } {
+  const jsonStr = JSON.stringify(log);
+  return { encrypted: encrypt(jsonStr, secretKey) };
+}
+
+/**
+ * Decrypt an encrypted log
+ */
+export function decryptLog<T = unknown>(encryptedLog: { encrypted: string }, secretKey: string): T {
+  const jsonStr = decrypt(encryptedLog.encrypted, secretKey);
+  return JSON.parse(jsonStr);
+}

package/src/index.ts

@@ -1,19 +1,19 @@
-// Core client
-export { AbbacchioClient, createClient } from "./client.js";
-export type { AbbacchioClientOptions } from "./client.js";
-
-// Encryption utilities
-export { generateKey, encrypt, decrypt, encryptLog, decryptLog } from "./encrypt.js";
-
-// Re-export transports for convenience
-export { default as pinoTransport } from "./transports/pino.js";
-export type { PinoTransportOptions } from "./transports/pino.js";
-
-export { winstonTransport, AbbacchioWinstonTransport } from "./transports/winston.js";
-export type { WinstonTransportOptions } from "./transports/winston.js";
-
-export { bunyanStream, AbbacchioBunyanStream } from "./transports/bunyan.js";
-export type { BunyanStreamOptions } from "./transports/bunyan.js";
-
-export { interceptConsole, restoreConsole, getActiveClient } from "./transports/console.js";
-export type { ConsoleInterceptorOptions } from "./transports/console.js";
+// Core client
+export { AbbacchioClient, createClient } from "./client.js";
+export type { AbbacchioClientOptions } from "./client.js";
+
+// Encryption utilities
+export { generateKey, encrypt, decrypt, encryptLog, decryptLog } from "./encrypt.js";
+
+// Re-export transports for convenience
+export { default as pinoTransport } from "./transports/pino.js";
+export type { PinoTransportOptions } from "./transports/pino.js";
+
+export { winstonTransport, AbbacchioWinstonTransport } from "./transports/winston.js";
+export type { WinstonTransportOptions } from "./transports/winston.js";
+
+export { bunyanStream, AbbacchioBunyanStream } from "./transports/bunyan.js";
+export type { BunyanStreamOptions } from "./transports/bunyan.js";
+
+export { interceptConsole, restoreConsole, getActiveClient } from "./transports/console.js";
+export type { ConsoleInterceptorOptions } from "./transports/console.js";