@abbacchio/transport 0.1.0

package/src/encrypt.ts

@@ -0,0 +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);
+}

package/src/index.ts

@@ -0,0 +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";

package/src/transports/bunyan.ts

@@ -0,0 +1,99 @@
+import { Writable } from "stream";
+import { AbbacchioClient, type AbbacchioClientOptions } from "../client.js";
+
+export interface BunyanStreamOptions extends AbbacchioClientOptions {
+  /** Bunyan log level (optional) */
+  level?: number | string;
+}
+
+/**
+ * Bunyan stream for Abbacchio.
+ * Implements the Node.js Writable stream interface for Bunyan.
+ *
+ * @example
+ * ```typescript
+ * import bunyan from "bunyan";
+ * import { bunyanStream } from "@abbacchio/client/transports/bunyan";
+ *
+ * const logger = bunyan.createLogger({
+ *   name: "myapp",
+ *   streams: [
+ *     { stream: process.stdout },
+ *     bunyanStream({
+ *       url: "http://localhost:4000/api/logs",
+ *       channel: "my-app",
+ *       secretKey: "optional-encryption-key",
+ *     }),
+ *   ],
+ * });
+ *
+ * logger.info("Hello from Bunyan!");
+ * ```
+ */
+export class AbbacchioBunyanStream extends Writable {
+  private client: AbbacchioClient;
+  public level?: number | string;
+
+  constructor(opts: BunyanStreamOptions = {}) {
+    super({ objectMode: true });
+    this.client = new AbbacchioClient(opts);
+    this.level = opts.level;
+  }
+
+  /**
+   * Writable stream _write method - called for each log entry
+   */
+  _write(
+    chunk: Record<string, unknown>,
+    _encoding: BufferEncoding,
+    callback: (error?: Error | null) => void
+  ): void {
+    try {
+      // Transform Bunyan format to Abbacchio format
+      const log = this.transformLog(chunk);
+      this.client.add(log);
+      callback();
+    } catch (err) {
+      callback(err as Error);
+    }
+  }
+
+  /**
+   * Transform Bunyan log format to a normalized format
+   */
+  private transformLog(record: Record<string, unknown>): Record<string, unknown> {
+    const { name, hostname, pid, level, msg, time, v, ...rest } = record;
+
+    return {
+      level: level as number,
+      msg,
+      time: time ? new Date(time as string).getTime() : Date.now(),
+      name,
+      hostname,
+      pid,
+      ...rest,
+    };
+  }
+
+  /**
+   * Close the stream
+   */
+  _final(callback: (error?: Error | null) => void): void {
+    this.client.close().then(() => callback()).catch(callback);
+  }
+}
+
+/**
+ * Factory function to create a Bunyan stream
+ * Returns an object with stream and optional level for Bunyan's streams array
+ */
+export function bunyanStream(opts?: BunyanStreamOptions): { stream: AbbacchioBunyanStream; level?: number | string; type: "raw" } {
+  const stream = new AbbacchioBunyanStream(opts);
+  return {
+    stream,
+    level: opts?.level,
+    type: "raw",
+  };
+}
+
+export default bunyanStream;

package/src/transports/console.ts

@@ -0,0 +1,147 @@
+import { AbbacchioClient, type AbbacchioClientOptions } from "../client.js";
+
+export interface ConsoleInterceptorOptions extends AbbacchioClientOptions {
+  /** Which console methods to intercept. Defaults to all. */
+  methods?: ("log" | "info" | "warn" | "error" | "debug")[];
+  /** Whether to still output to original console. Defaults to true. */
+  passthrough?: boolean;
+}
+
+type ConsoleMethod = "log" | "info" | "warn" | "error" | "debug";
+
+const methodToLevel: Record<ConsoleMethod, number> = {
+  debug: 20,
+  log: 30,
+  info: 30,
+  warn: 40,
+  error: 50,
+};
+
+/**
+ * Console interceptor for Abbacchio.
+ * Intercepts console.log/info/warn/error/debug calls and sends them to Abbacchio.
+ *
+ * @example
+ * ```typescript
+ * import { interceptConsole, restoreConsole } from "@abbacchio/client/transports/console";
+ *
+ * // Start intercepting console calls
+ * interceptConsole({
+ *   url: "http://localhost:4000/api/logs",
+ *   channel: "my-app",
+ *   secretKey: "optional-encryption-key",
+ *   passthrough: true, // Still log to console
+ * });
+ *
+ * console.log("This will be sent to Abbacchio!");
+ * console.error("Errors too!");
+ *
+ * // Stop intercepting when done
+ * restoreConsole();
+ * ```
+ */
+
+// Store original console methods
+const originalConsole: Record<ConsoleMethod, (...args: unknown[]) => void> = {
+  log: console.log.bind(console),
+  info: console.info.bind(console),
+  warn: console.warn.bind(console),
+  error: console.error.bind(console),
+  debug: console.debug.bind(console),
+};
+
+let activeClient: AbbacchioClient | null = null;
+let activeOptions: ConsoleInterceptorOptions | null = null;
+
+/**
+ * Format console arguments into a message string
+ */
+function formatArgs(args: unknown[]): string {
+  return args
+    .map((arg) => {
+      if (typeof arg === "string") return arg;
+      if (arg instanceof Error) return `${arg.name}: ${arg.message}\n${arg.stack}`;
+      try {
+        return JSON.stringify(arg);
+      } catch {
+        return String(arg);
+      }
+    })
+    .join(" ");
+}
+
+/**
+ * Create an intercepted console method
+ */
+function createInterceptedMethod(
+  method: ConsoleMethod,
+  client: AbbacchioClient,
+  passthrough: boolean
+): (...args: unknown[]) => void {
+  return (...args: unknown[]) => {
+    // Send to Abbacchio
+    const log = {
+      level: methodToLevel[method],
+      msg: formatArgs(args),
+      time: Date.now(),
+      method,
+    };
+    client.add(log);
+
+    // Optionally pass through to original console
+    if (passthrough) {
+      originalConsole[method](...args);
+    }
+  };
+}
+
+/**
+ * Start intercepting console calls
+ */
+export function interceptConsole(opts: ConsoleInterceptorOptions = {}): void {
+  // Restore any existing interception first
+  if (activeClient) {
+    restoreConsole();
+  }
+
+  const methods = opts.methods || ["log", "info", "warn", "error", "debug"];
+  const passthrough = opts.passthrough !== false;
+
+  activeClient = new AbbacchioClient(opts);
+  activeOptions = opts;
+
+  // Replace console methods
+  for (const method of methods) {
+    (console as unknown as Record<string, unknown>)[method] = createInterceptedMethod(
+      method,
+      activeClient,
+      passthrough
+    );
+  }
+}
+
+/**
+ * Stop intercepting console calls and restore original behavior
+ */
+export function restoreConsole(): void {
+  // Restore original console methods
+  for (const method of Object.keys(originalConsole) as ConsoleMethod[]) {
+    (console as unknown as Record<string, unknown>)[method] = originalConsole[method];
+  }
+
+  // Flush and close client
+  if (activeClient) {
+    activeClient.close();
+    activeClient = null;
+    activeOptions = null;
+  }
+}
+
+/**
+ * Get the active client (for testing)
+ */
+export function getActiveClient(): AbbacchioClient | null {
+  return activeClient;
+}
+
+export default interceptConsole;

package/src/transports/index.ts

@@ -0,0 +1,15 @@
+// Pino transport
+export { default as pinoTransport } from "./pino.js";
+export type { PinoTransportOptions } from "./pino.js";
+
+// Winston transport
+export { winstonTransport, AbbacchioWinstonTransport } from "./winston.js";
+export type { WinstonTransportOptions } from "./winston.js";
+
+// Bunyan stream
+export { bunyanStream, AbbacchioBunyanStream } from "./bunyan.js";
+export type { BunyanStreamOptions } from "./bunyan.js";
+
+// Console interceptor
+export { interceptConsole, restoreConsole, getActiveClient } from "./console.js";
+export type { ConsoleInterceptorOptions } from "./console.js";

package/src/transports/pino.ts

@@ -0,0 +1,49 @@
+import build from "pino-abstract-transport";
+import { AbbacchioClient, type AbbacchioClientOptions } from "../client.js";
+
+export interface PinoTransportOptions extends AbbacchioClientOptions {}
+
+/**
+ * Pino transport for Abbacchio.
+ *
+ * @example
+ * ```typescript
+ * import pino from "pino";
+ *
+ * const logger = pino({
+ *   transport: {
+ *     target: "@abbacchio/client/transports/pino",
+ *     options: {
+ *       url: "http://localhost:4000/api/logs",
+ *       channel: "my-app",
+ *       secretKey: "optional-encryption-key",
+ *     },
+ *   },
+ * });
+ *
+ * logger.info("Hello from Pino!");
+ * ```
+ */
+export default async function pinoTransport(opts: PinoTransportOptions = {}) {
+  const client = new AbbacchioClient(opts);
+
+  return build(
+    async function (source) {
+      for await (const obj of source) {
+        client.add(obj);
+      }
+      // Flush remaining on close
+      await client.flush();
+    },
+    {
+      async close() {
+        await client.close();
+      },
+    }
+  );
+}
+
+/**
+ * Named export for programmatic usage
+ */
+export { pinoTransport };

package/src/transports/winston.ts

@@ -0,0 +1,100 @@
+import TransportStream from "winston-transport";
+import { AbbacchioClient, type AbbacchioClientOptions } from "../client.js";
+
+export interface WinstonTransportOptions extends AbbacchioClientOptions {
+  /** Winston log level (optional) */
+  level?: string;
+}
+
+/**
+ * Winston transport for Abbacchio.
+ * Extends winston-transport for proper integration.
+ *
+ * @example
+ * ```typescript
+ * import winston from "winston";
+ * import { AbbacchioWinstonTransport } from "@abbacchio/client/transports/winston";
+ *
+ * const logger = winston.createLogger({
+ *   transports: [
+ *     new winston.transports.Console(),
+ *     new AbbacchioWinstonTransport({
+ *       url: "http://localhost:4000/api/logs",
+ *       channel: "my-app",
+ *       secretKey: "optional-encryption-key",
+ *     }),
+ *   ],
+ * });
+ *
+ * logger.info("Hello from Winston!");
+ * ```
+ */
+export class AbbacchioWinstonTransport extends TransportStream {
+  private client: AbbacchioClient;
+
+  constructor(opts: WinstonTransportOptions = {}) {
+    super({ level: opts.level });
+    this.client = new AbbacchioClient(opts);
+  }
+
+  /**
+   * Winston log method - called for each log entry
+   */
+  log(info: Record<string, unknown>, callback: () => void): void {
+    setImmediate(() => {
+      this.emit("logged", info);
+    });
+
+    // Transform Winston format to Abbacchio format
+    const log = this.transformLog(info);
+    this.client.add(log);
+
+    callback();
+  }
+
+  /**
+   * Transform Winston log format to a normalized format
+   */
+  private transformLog(info: Record<string, unknown>): Record<string, unknown> {
+    const { level, message, timestamp, ...rest } = info;
+
+    return {
+      level: this.levelToNumber(level as string),
+      msg: message,
+      time: timestamp ? new Date(timestamp as string).getTime() : Date.now(),
+      ...rest,
+    };
+  }
+
+  /**
+   * Convert Winston level string to Pino-style number
+   */
+  private levelToNumber(level: string): number {
+    const levels: Record<string, number> = {
+      error: 50,
+      warn: 40,
+      info: 30,
+      http: 30,
+      verbose: 20,
+      debug: 20,
+      silly: 10,
+    };
+    return levels[level] || 30;
+  }
+
+  /**
+   * Close the transport
+   */
+  close(): void {
+    this.client.close();
+  }
+}
+
+/**
+ * Factory function to create a Winston transport
+ */
+export function winstonTransport(opts?: WinstonTransportOptions): AbbacchioWinstonTransport {
+  return new AbbacchioWinstonTransport(opts);
+}
+
+export default winstonTransport;

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}