kafka-console 3.0.0-rc.3 → 3.0.0

package/package.json

@@ -1,8 +1,7 @@
 {
   "name": "kafka-console",
-  "version": "3.0.0-rc.3",
+  "version": "3.0.0",
   "description": "Kafka CLI tool",
-  "main": "index.js",
   "type": "module",
   "bin": {
     "kcli": "build/cli.js",

package/.claude/settings.local.json

@@ -1,35 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "WebFetch(domain:3axap4ehko.github.io)",
-      "WebFetch(domain:raw.githubusercontent.com)",
-      "Bash(pnpm run:*)",
-      "Bash(pnpm test:*)",
-      "Bash(node scripts/bench-kafka.js:*)",
-      "Bash(node --trace-warnings scripts/bench-kafka.js:*)",
-      "Bash(timeout 30s node:*)",
-      "Bash(timeout 20s node:*)",
-      "Bash(timeout 15s node:*)",
-      "Bash(npm ls:*)",
-      "Bash(pnpm ls:*)",
-      "Bash(node -e:*)",
-      "Bash(timeout 60s node:*)",
-      "mcp__context7__query-docs",
-      "Bash(timeout 60 node:*)",
-      "Bash(kafka-topics.sh:*)",
-      "Bash(docker exec:*)",
-      "Bash(timeout 30 node:*)",
-      "Bash(node build/cli.js:*)",
-      "Bash(timeout 5 node:*)",
-      "Skill(ask-codex)",
-      "Bash(pnpm test:e2e:*)",
-      "Bash(pnpm build:*)",
-      "Bash(node build/index.js:*)",
-      "Bash(node:*)",
-      "mcp__context7__resolve-library-id",
-      "WebSearch"
-    ],
-    "deny": [],
-    "ask": []
-  }
-}

package/.progress/master.md

@@ -1,63 +0,0 @@
-[2026-02-13 15:03:00] - Starting comprehensive E2E test of all CLI commands against local Kafka
-[2026-02-13 15:04:00] - Build failed: `Admin` not exported from `@platformatic/kafka` - it's at `adminClient.Admin`
-[2026-02-13 15:05:00] - Fixed import: `import { adminClient } from '@platformatic/kafka'; const { Admin } = adminClient;`
-[2026-02-13 15:05:30] - Fixed type annotation: `Promise<InstanceType<typeof Admin>>` since Admin is a value not a type
-[2026-02-13 15:06:00] - Build succeeds after fixes
-[2026-02-13 15:06:30] - --version, --help: PASS
-[2026-02-13 15:07:00] - list, list -p, list -a, ls alias: PASS
-[2026-02-13 15:07:30] - topic:create, topic:delete: PASS
-[2026-02-13 15:08:00] - metadata: PARTIAL - broker info works but topics always empty (metadata({topics:[]}) returns 0 topics in @platformatic/kafka unlike kafkajs)
-[2026-02-13 15:08:30] - produce (stdin pipe, file input, static headers, --wait): PASS
-[2026-02-13 15:09:00] - consume (--from 0, --from ISO, --count, --skip, --pretty, --output file, -d raw): PASS
-[2026-02-13 15:09:30] - topic:offsets (no args, timestamp, ISO, consumer group): PASS
-[2026-02-13 15:10:00] - config: PASS (intentionally throws unsupported error)
-[2026-02-13 15:10:30] - Error handling for nonexistent topics: exits with code 1 (generic "failed N times" messages from library)
-[2026-02-13 15:11:00] - Unit tests: fixed mock (added adminClient export), all 21 tests pass
-[2026-02-13 15:11:30] - BUG: metadata command always shows 0 topics - @platformatic/kafka metadata({topics:[]}) returns empty unlike kafkajs
-[2026-02-13 15:11:30] - BUG: consuming a raw-produced message with default json formatter crashes the consumer (unhandled JSON parse error)
-[2026-02-13 15:15:00] - config command was incorrectly stubbed out - @platformatic/kafka has describeConfigs(), just needs resourceType/resourceName params (not type/name)
-[2026-02-13 15:17:00] - Implemented config command, added resourceTypeToNumber mapping, added ConfigResourceTypes to mock
-[2026-02-13 15:17:30] - Verified: config -r topic -n <name> and config -r broker -n 1 both work. All 21 unit tests pass
-[2026-02-13 15:31:00] - Enhanced consumer output: added partition, offset, timestamp, ahead fields to consume output
-[2026-02-13 15:31:00] - Added `high` (bigint) to ConsumerMessage interface, fetched via listOffsets(LATEST) before consumption starts
-[2026-02-13 15:31:00] - ahead = Number(high - offset), offset/timestamp serialized as strings for JSON precision
-[2026-02-13 15:31:30] - Build clean, all 21 tests pass
-[TIME 2026-03-01 10:50:41] - Started writing unit tests to reproduce reported src/ bug findings (metadata scope, swallowed async errors, timeout type mismatch, missing close on failures).
-[TIME 2026-03-04 23:44:00] - Redesign: removed Pool indirection, commands own lifecycle directly
-[TIME 2026-03-04 23:44:00] - Deleted pool.ts + pool tests, removed evnty dependency
-[TIME 2026-03-04 23:44:00] - kafka.ts: exported getClientConfig, removed createClient/createAdmin/createCluster/createConsumer/createProducer wrappers and intermediate types
-[TIME 2026-03-04 23:44:00] - fetch* functions now accept config object (ReturnType<typeof getClientConfig>) instead of ClientOptions
-[TIME 2026-03-04 23:44:00] - Admin commands (list, config, createTopic, deleteTopic, metadata): use new Admin(getClientConfig(...)) directly
-[TIME 2026-03-04 23:44:00] - consume.ts: full rewrite - Consumer+MessagesStream directly, skip/count/timeout as inline loop logic, try/finally lifecycle
-[TIME 2026-03-04 23:44:00] - produce.ts: full rewrite - Producer.send() directly, stdin via async generator (readline), file via async generator
-[TIME 2026-03-04 23:44:00] - Build clean, all 11 tests pass (pool tests removed, rest unchanged)
-[TIME 2026-03-05 09:25:00] - Fixed 2 failing e2e tests:
-[TIME 2026-03-05 09:25:00] - metadata.ts: added `if (!topicMeta) continue;` guard for topics with undefined metadata in meta.topics Map
-[TIME 2026-03-05 09:25:00] - consume.ts: moved break check from top of loop to after index increment. Bug was: after processing last needed message, loop awaited next message from stream (which never came), causing timeout. Fix: `if (++index >= limit) break;` at end of loop body.
-[TIME 2026-03-05 09:28:00] - All tests pass: 11 unit, 10 e2e. Lint clean.
-[TIME 2026-03-05 09:35:00] - Expanded e2e tests from 10 to 28. Added coverage for: consume --skip, --pretty, --output, -d raw, --from ISO, static headers, file-produced messages, timeout; produce --header, --input, -d raw, --wait; list --all, ls alias, -p; config -r topic, -r broker; metadata -p.
-[TIME 2026-03-05 20:12:51] - Started JSONL output refactor: unify command outputs around line-delimited JSON and update tests.
-[TIME 2026-03-06 10:37:59] - Added src/utils/output.ts with writeJsonl/writeJsonlMany; switched list/config/createTopic/metadata/topic:offsets to JSONL emission and made consume always compact single-line JSON per record.
-[TIME 2026-03-06 10:37:59] - Updated e2e suite to parse JSONL outputs (line-wise JSON.parse) instead of array/object dumps; unit tests and e2e now pass.
-[TIME 2026-03-06 10:39:35] - Verification: pnpm build, pnpm test, pnpm test:e2e, pnpm lint all pass after JSONL output refactor.
-[TIME 2026-03-06 18:19:07] - Removed AWS auth completely: deleted aws-related CLI flags and env mappings, removed aws branch in getSASL, and cleaned README auth/features/env docs.
-[TIME 2026-03-06 18:19:07] - Verification after AWS removal: pnpm build, pnpm lint, pnpm test all pass.
-[TIME 2026-03-06 18:19:59] - Follow-up cleanup requested: remove dead options/types after JSONL and AWS removals (-p, -l, unused GlobalOptions fields, unused Format alias), and align tests/docs.
-[TIME 2026-03-06 18:28:56] - Removed dead CLI flags -l/--log-level and -p/--pretty from index.ts; removed unused logLevelParser and GlobalOptions.logLevel/pretty from kafka.ts; removed unused Format alias from formatters.ts.
-[TIME 2026-03-06 18:28:56] - Updated README and e2e tests to drop stale --pretty usage/docs; verification passed: pnpm build, pnpm lint, pnpm test, KAFKA_BROKERS=localhost:9092 pnpm test:e2e (25 tests).
-[TIME 2026-03-06 18:42:12] - Following up on 2 correctness issues: consume output close race and produce crash on missing value. Plan is targeted fixes plus unit tests reproducing both.
-[TIME 2026-03-06 18:51:33] - consume.ts already had finished(output) from the interrupted patch; completed produce.ts validation for missing value in stdin/file inputs and added command-level regression tests for both issues.
-[TIME 2026-03-06 18:51:33] - New tests exposed broken Kafka vitest mock constructors (arrow mock implementations were not new-able); fixed Admin/Consumer/Producer mocks to use constructable function implementations.
-[TIME 2026-03-06 18:51:33] - Verification passed: pnpm test (13), pnpm build, pnpm lint, KAFKA_BROKERS=localhost:9092 pnpm test:e2e (25).
-[TIME 2026-03-07 00:34:24] - Minor follow-up: moving producer header short flag off -h, making consume shut down cleanly on SIGINT/SIGTERM, and wiring metadata ISR through from actual partition metadata with regression coverage.
-[TIME 2026-03-09 17:31:04] - Implemented minor fixes: producer header shorthand is now -H, consume registers SIGINT/SIGTERM handlers that close the stream cleanly, and metadata now serializes partition.isr instead of [].
-[TIME 2026-03-09 17:31:04] - Added regression coverage for header flag registration, consume SIGINT shutdown, and metadata ISR propagation; unit/build/lint passed.
-[TIME 2026-03-09 17:31:04] - E2E blocked by environment: localhost:9092 is currently unreachable. Direct `node build/cli.js metadata -b localhost:9092` fails with `Cannot connect to any broker`, so the full e2e suite currently fails before exercising behavior.
-[TIME 2026-03-09 18:14:43] - Broker came back; reran smoke + e2e and the SIGINT case initially exposed another real bug: closing the consumer directly while consuming throws `Cannot leave group while consuming messages.` Adjusted signal handler to close stream first when active and only close consumer during startup interruption.
-[TIME 2026-03-09 18:14:43] - Final verification passed: pnpm test (17), pnpm lint, KAFKA_BROKERS=localhost:9092 pnpm test:e2e (26).
-[TIME 2026-03-09 23:07:44] - Verified the new review items against @platformatic/kafka source before editing. Consumer.close() and MessagesStream.close() are idempotent, so the extra close booleans in consume.ts were just local indirection.
-[TIME 2026-03-09 23:07:44] - Applied targeted cleanup/hardening: removed redundant consume close guards and dead interrupted checks, preserved the first cleanup error when file finalization also fails, hardened produce input parsing against undefined values, fixed the Kafka mock indentation, and aligned commander tests with the actual exported CLI instance.
-[TIME 2026-03-09 23:24:16] - Verification after the final consume refactor passed end-to-end: pnpm test (19), pnpm build, pnpm lint, KAFKA_BROKERS=localhost:9092 pnpm test:e2e (26). ESLint initially rejected `throw` inside finally, so consume now carries cleanup errors out after finally instead of throwing from it.
-[TIME 2026-03-10 00:34:38] - Removing built-in js formatter entirely. Scope: formatter registry/code, CLI help text, README format tables/examples, and unit tests so json/raw + custom module paths are the only advertised formats.
-[TIME 2026-03-10 18:50:37] - Built-in js formatter removed cleanly. Deleted vm-based formatter code, updated CLI descriptions/help examples to advertise json/raw/custom module paths only, removed README js docs, and added tests that js is no longer exported or advertised. Verification passed: pnpm test (21), pnpm build, pnpm lint, KAFKA_BROKERS=localhost:9092 pnpm test:e2e (26).
-[TIME 2026-03-10 21:48:04] - Hardening TLS defaults: added global --insecure flag, switched --ssl to verify certificates by default, updated README auth/troubleshooting text, and added unit coverage for secure-vs-insecure TLS config plus CLI flag registration.

package/build/cli.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-import './index.ts';

package/build/commands/config.d.ts

@@ -1,7 +0,0 @@
-import { type CommandContext, type ConfigResourceType } from '../utils/kafka.ts';
-interface ConfigOptions {
-    resource: ConfigResourceType;
-    resourceName: string;
-}
-export default function config(opts: ConfigOptions, { parent }: CommandContext): Promise<void>;
-export {};

package/build/commands/consume.d.ts

@@ -1,12 +0,0 @@
-import { type CommandContext } from '../utils/kafka.ts';
-interface ConsumeOptions {
-    group: string;
-    dataFormat: string;
-    from?: string;
-    count: number;
-    skip: number;
-    output?: string;
-    snapshot?: boolean;
-}
-export default function consume(topic: string, opts: ConsumeOptions, { parent }: CommandContext): Promise<void>;
-export {};

package/build/commands/createTopic.d.ts

@@ -1,7 +0,0 @@
-import { type CommandContext } from '../utils/kafka.ts';
-interface CreateTopicOptions {
-    partitions?: number;
-    replicas?: number;
-}
-export default function createTopic(topic: string, opts: CreateTopicOptions, { parent }: CommandContext): Promise<void>;
-export {};

package/build/commands/deleteTopic.d.ts

@@ -1,2 +0,0 @@
-import { type CommandContext } from '../utils/kafka.ts';
-export default function deleteTopic(topic: string, _opts: object, { parent }: CommandContext): Promise<void>;

package/build/commands/fetchTopicOffsets.d.ts

@@ -1,6 +0,0 @@
-import { type CommandContext } from '../utils/kafka.ts';
-interface FetchTopicOffsetsOptions {
-    group?: string;
-}
-export default function fetchTopicOffset(topic: string, timestamp: string | undefined, opts: FetchTopicOffsetsOptions, { parent }: CommandContext): Promise<void>;
-export {};

package/build/commands/list.d.ts

@@ -1,6 +0,0 @@
-import { type CommandContext } from '../utils/kafka.ts';
-interface ListOptions {
-    all?: boolean;
-}
-export default function list(opts: ListOptions, { parent }: CommandContext): Promise<void>;
-export {};

package/build/commands/metadata.d.ts

@@ -1,2 +0,0 @@
-import { type CommandContext } from '../utils/kafka.ts';
-export default function metadata(_opts: object, { parent }: CommandContext): Promise<void>;

package/build/commands/produce.d.ts

@@ -1,9 +0,0 @@
-import { type CommandContext } from '../utils/kafka.ts';
-interface ProduceOptions {
-    dataFormat: string;
-    header: string[];
-    input?: string;
-    wait: number;
-}
-export default function produce(topic: string, opts: ProduceOptions, { parent }: CommandContext): Promise<void>;
-export {};

package/build/index.d.ts

@@ -1,5 +0,0 @@
-import { Command } from 'commander';
-export declare function collect(value: string, previous: string[]): string[];
-export declare function toInt(value: string): number;
-declare const commander: Command;
-export default commander;

package/build/utils/formatters.d.ts

@@ -1,13 +0,0 @@
-export interface Encoder<T> {
-    (value: T): Promise<string | Buffer> | string | Buffer;
-}
-export interface Decoder<T> {
-    (value: Buffer | string | null): Promise<T> | T;
-}
-export interface Formatter<T> {
-    encode: Encoder<T>;
-    decode: Decoder<T>;
-}
-export declare const json: Formatter<unknown>;
-export declare const raw: Formatter<unknown>;
-export declare function getFormatter(format: string): Formatter<unknown>;

package/build/utils/kafka.d.ts

@@ -1,56 +0,0 @@
-import { ConfigResourceTypes } from '@platformatic/kafka';
-import type { ConnectionOptions } from 'node:tls';
-export type ConfigResourceType = 'UNKNOWN' | 'TOPIC' | 'BROKER' | 'BROKER_LOGGER';
-export declare function resourceParser(resource: string): ConfigResourceType;
-export declare function resourceTypeToNumber(type: ConfigResourceType): (typeof ConfigResourceTypes)[keyof typeof ConfigResourceTypes];
-export interface GlobalOptions {
-    brokers: string;
-    timeout: number;
-    ssl: boolean;
-    insecure?: boolean;
-    mechanism?: string;
-    username?: string;
-    password?: string;
-    oauthBearer?: string;
-}
-export interface CommandContext {
-    parent: {
-        opts(): GlobalOptions;
-    };
-}
-export interface SASLConfig {
-    mechanism: 'PLAIN' | 'SCRAM-SHA-256' | 'SCRAM-SHA-512' | 'OAUTHBEARER';
-    username?: string;
-    password?: string;
-    token?: string;
-}
-export declare function getSASL({ mechanism, username, password, oauthBearer, }: Pick<GlobalOptions, 'mechanism' | 'username' | 'password' | 'oauthBearer'>): SASLConfig | undefined;
-export declare function getClientConfig(bootstrapServer: string, ssl: boolean, sasl?: SASLConfig, insecure?: boolean): {
-    clientId: string;
-    bootstrapBrokers: string[];
-    tls?: ConnectionOptions;
-    sasl?: SASLConfig;
-};
-export declare function getClientConfigFromOpts(opts: GlobalOptions): {
-    clientId: string;
-    bootstrapBrokers: string[];
-    tls?: ConnectionOptions;
-    sasl?: SASLConfig;
-};
-export declare function fetchTopicOffsets(config: ReturnType<typeof getClientConfig>, topic: string): Promise<{
-    partition: number;
-    offset: string;
-    high: string;
-    low: string;
-}[]>;
-export declare function fetchTopicOffsetsByTimestamp(config: ReturnType<typeof getClientConfig>, topic: string, timestamp: number): Promise<{
-    partition: number;
-    offset: string;
-}[]>;
-export declare function fetchConsumerGroupOffsets(config: ReturnType<typeof getClientConfig>, groupId: string, topics: string[]): Promise<{
-    topic: string;
-    partitions: {
-        partition: number;
-        offset: string;
-    }[];
-}[]>;

package/build/utils/output.d.ts

@@ -1,4 +0,0 @@
-type WritableLike = Pick<NodeJS.WritableStream, 'write'>;
-export declare function writeJsonl(value: unknown, output?: WritableLike): void;
-export declare function writeJsonlMany(values: unknown, output?: WritableLike): void;
-export {};

package/e2e/cli.test.ts

@@ -1,325 +0,0 @@
-import { execSync, spawn } from 'child_process';
-import { mkdtempSync, writeFileSync, readFileSync, rmSync, existsSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-
-const BROKERS = process.env.KAFKA_BROKERS || 'localhost:9092';
-const CLI_PATH = 'node build/cli.js';
-const TEST_TOPIC = `e2e-test-${Date.now()}`;
-const TEST_GROUP = `e2e-group-${Date.now()}`;
-const TMP_DIR = mkdtempSync(join(tmpdir(), 'kafka-e2e-'));
-
-function cli(args: string): string {
-  return execSync(`${CLI_PATH} ${args} -b ${BROKERS}`, {
-    encoding: 'utf-8',
-    timeout: 15000,
-  }).trim();
-}
-
-function cliWithInput(args: string, input: string): string {
-  return execSync(`echo '${input}' | ${CLI_PATH} ${args} -b ${BROKERS}`, {
-    encoding: 'utf-8',
-    shell: '/bin/bash',
-    timeout: 15000,
-  }).trim();
-}
-
-function parseJsonl<T = unknown>(output: string): T[] {
-  if (!output) return [];
-  return output.split('\n').map((line) => JSON.parse(line) as T);
-}
-
-function cliExpectFail(args: string): { stdout: string; stderr: string } {
-  try {
-    const stdout = cli(args);
-    return { stdout, stderr: '' };
-  } catch (e: unknown) {
-    const err = e as { stdout?: string; stderr?: string };
-    return { stdout: (err.stdout ?? '').trim(), stderr: (err.stderr ?? '').trim() };
-  }
-}
-
-describe('CLI e2e tests', () => {
-  beforeAll(() => {
-    execSync('pnpm build', { encoding: 'utf-8' });
-  });
-
-  afterAll(() => {
-    try {
-      cli(`topic:delete ${TEST_TOPIC}`);
-    } catch {
-      // ignore cleanup errors
-    }
-    try {
-      rmSync(TMP_DIR, { recursive: true });
-    } catch {
-      // ignore cleanup errors
-    }
-  });
-
-  describe('metadata', () => {
-    it('should return cluster metadata', () => {
-      const output = cli('metadata');
-      const [metadata] = parseJsonl<Record<string, unknown>>(output);
-
-      expect(metadata).toHaveProperty('brokers');
-      expect(metadata).toHaveProperty('clusterId');
-      expect(metadata).toHaveProperty('controllerId');
-      expect(Array.isArray(metadata.brokers)).toBe(true);
-      expect(metadata.brokers.length).toBeGreaterThan(0);
-      expect(metadata.brokers[0]).toHaveProperty('host');
-      expect(metadata.brokers[0]).toHaveProperty('port');
-    });
-  });
-
-  describe('topic:create', () => {
-    it('should create a topic', () => {
-      const output = cli(`topic:create ${TEST_TOPIC}`);
-      const topics = parseJsonl<Record<string, unknown>>(output);
-
-      expect(topics.length).toBe(1);
-      expect(topics[0]).toHaveProperty('name', TEST_TOPIC);
-      expect(topics[0]).toHaveProperty('partitions');
-      expect(topics[0]).toHaveProperty('replicas');
-    });
-  });
-
-  describe('list', () => {
-    it('should list topics including the created one', () => {
-      const output = cli('list');
-      const topics = parseJsonl<string>(output);
-      expect(topics).toContain(TEST_TOPIC);
-    });
-
-    it('should list topics with ls alias', () => {
-      const output = cli('ls');
-      const topics = parseJsonl<string>(output);
-      expect(topics).toContain(TEST_TOPIC);
-    });
-
-    it('should list topics with --all flag including internals', () => {
-      const output = cli('list --all');
-      const topics = parseJsonl<string>(output);
-      expect(topics).toContain(TEST_TOPIC);
-    });
-  });
-
-  describe('config', () => {
-    it('should describe topic config', () => {
-      const output = cli(`config -r topic -n ${TEST_TOPIC}`);
-      const configs = parseJsonl<Record<string, unknown>>(output);
-      expect(configs.length).toBeGreaterThan(0);
-    });
-
-    it('should describe broker config', () => {
-      const output = cli('config -r broker -n 1');
-      const configs = parseJsonl<Record<string, unknown>>(output);
-      expect(configs.length).toBeGreaterThan(0);
-    });
-  });
-
-  describe('produce', () => {
-    it('should produce messages via stdin', () => {
-      const message = JSON.stringify({ key: 'test-key', value: 'test-value', headers: { h1: 'v1' } });
-      cliWithInput(`produce ${TEST_TOPIC}`, message);
-    });
-
-    it('should produce multiple messages via stdin', () => {
-      for (let i = 0; i < 3; i++) {
-        const message = JSON.stringify({ key: `key-${i}`, value: `value-${i}` });
-        cliWithInput(`produce ${TEST_TOPIC}`, message);
-      }
-    });
-
-    it('should produce with static headers', () => {
-      const message = JSON.stringify({ key: 'header-key', value: 'header-value' });
-      cliWithInput(`produce ${TEST_TOPIC} -H x-source:test -H x-env:e2e`, message);
-    });
-
-    it('should produce from input file', () => {
-      const filePath = join(TMP_DIR, 'produce-input.json');
-      const messages = [
-        { key: 'file-key-0', value: 'file-value-0' },
-        { key: 'file-key-1', value: 'file-value-1' },
-      ];
-      writeFileSync(filePath, JSON.stringify(messages));
-
-      cli(`produce ${TEST_TOPIC} --input ${filePath}`);
-    });
-
-    it('should produce with raw data format', () => {
-      const message = JSON.stringify({ key: 'raw-key', value: 'raw-value' });
-      cliWithInput(`produce ${TEST_TOPIC} -d raw`, message);
-    });
-
-    it('should produce with --wait', () => {
-      const message = JSON.stringify({ key: 'wait-key', value: 'wait-value' });
-      cliWithInput(`produce ${TEST_TOPIC} --wait 10`, message);
-    });
-  });
-
-  describe('consume', () => {
-    it('should consume messages from the beginning', () => {
-      const group = `${TEST_GROUP}-from0`;
-      const output = cli(`consume ${TEST_TOPIC} -g ${group} --from 0 --count 4 -t 10000`);
-      const messages = output.split('\n').map(line => JSON.parse(line));
-
-      expect(messages.length).toBe(4);
-      expect(messages[0]).toHaveProperty('key', 'test-key');
-      expect(messages[0]).toHaveProperty('value', 'test-value');
-      expect(messages[0]).toHaveProperty('headers');
-      expect(messages[0].headers).toHaveProperty('h1', 'v1');
-      expect(messages[0]).toHaveProperty('partition');
-      expect(messages[0]).toHaveProperty('offset');
-      expect(messages[0]).toHaveProperty('timestamp');
-      expect(messages[0]).toHaveProperty('ahead');
-    });
-
-    it('should skip messages with --skip', () => {
-      const group = `${TEST_GROUP}-skip`;
-      const output = cli(`consume ${TEST_TOPIC} -g ${group} --from 0 --skip 2 --count 2 -t 10000`);
-      const messages = output.split('\n').map(line => JSON.parse(line));
-
-      expect(messages.length).toBe(2);
-      expect(messages[0]).toHaveProperty('key', 'key-1');
-      expect(messages[1]).toHaveProperty('key', 'key-2');
-    });
-
-    it('should consume with --from ISO timestamp', () => {
-      const past = new Date(Date.now() - 120000).toISOString();
-      const group = `${TEST_GROUP}-iso`;
-      const output = cli(`consume ${TEST_TOPIC} -g ${group} --from "${past}" --count 1 -t 10000`);
-      const messages = output.split('\n').map(line => JSON.parse(line));
-
-      expect(messages.length).toBe(1);
-      expect(messages[0]).toHaveProperty('key');
-      expect(messages[0]).toHaveProperty('value');
-    });
-
-    it('should write output to file', () => {
-      const outPath = join(TMP_DIR, 'consume-output.json');
-      const group = `${TEST_GROUP}-file`;
-      cli(`consume ${TEST_TOPIC} -g ${group} --from 0 --count 2 -t 10000 --output ${outPath}`);
-
-      expect(existsSync(outPath)).toBe(true);
-      const content = readFileSync(outPath, 'utf8').trim();
-      const messages = content.split('\n').map(line => JSON.parse(line));
-      expect(messages.length).toBe(2);
-      expect(messages[0]).toHaveProperty('key', 'test-key');
-    });
-
-    it('should consume with raw data format', () => {
-      const group = `${TEST_GROUP}-raw`;
-      const output = cli(`consume ${TEST_TOPIC} -g ${group} --from 0 --count 1 -t 10000 -d raw`);
-      const message = JSON.parse(output);
-      expect(message).toHaveProperty('key', 'test-key');
-      // raw decoder returns the string as-is (JSON-encoded value from producer)
-      expect(message).toHaveProperty('value', '"test-value"');
-    });
-
-    it('should consume static headers from producer', () => {
-      const group = `${TEST_GROUP}-headers`;
-      // Message at offset 4 has static headers x-source:test and x-env:e2e
-      const output = cli(`consume ${TEST_TOPIC} -g ${group} --from 0 --skip 4 --count 1 -t 10000`);
-      const message = JSON.parse(output);
-      expect(message).toHaveProperty('key', 'header-key');
-      expect(message.headers).toHaveProperty('x-source', 'test');
-      expect(message.headers).toHaveProperty('x-env', 'e2e');
-    });
-
-    it('should consume messages produced from file', () => {
-      const group = `${TEST_GROUP}-fileinput`;
-      // Messages at offsets 5-6 were produced from file
-      const output = cli(`consume ${TEST_TOPIC} -g ${group} --from 0 --skip 5 --count 2 -t 10000`);
-      const messages = output.split('\n').map(line => JSON.parse(line));
-      expect(messages.length).toBe(2);
-      expect(messages[0]).toHaveProperty('key', 'file-key-0');
-      expect(messages[1]).toHaveProperty('key', 'file-key-1');
-    });
-
-    it('should timeout when no messages available', () => {
-      const group = `${TEST_GROUP}-timeout`;
-      const result = cliExpectFail(`consume ${TEST_TOPIC} -g ${group} -t 2000`);
-      expect(result.stderr).toContain('TIMEOUT');
-    });
-
-    it('should exit cleanly on SIGINT without timeout', async () => {
-      const group = `${TEST_GROUP}-sigint`;
-      const child = spawn('node', ['build/cli.js', 'consume', TEST_TOPIC, '-g', group, '-b', BROKERS], {
-        stdio: ['ignore', 'pipe', 'pipe'],
-      });
-
-      const stdoutChunks: Buffer[] = [];
-      const stderrChunks: Buffer[] = [];
-      child.stdout.on('data', (chunk: Buffer) => stdoutChunks.push(chunk));
-      child.stderr.on('data', (chunk: Buffer) => stderrChunks.push(chunk));
-
-      await new Promise((resolve) => setTimeout(resolve, 300));
-      cliWithInput(`produce ${TEST_TOPIC}`, JSON.stringify({ key: 'sigint-key', value: 'sigint-value' }));
-      await new Promise<void>((resolve, reject) => {
-        const timer = setTimeout(() => reject(new Error('consume did not receive a message before SIGINT')), 3000);
-        child.stdout.once('data', () => {
-          clearTimeout(timer);
-          resolve();
-        });
-      });
-      child.kill('SIGINT');
-
-      const result = await new Promise<{ code: number | null; signal: NodeJS.Signals | null }>((resolve) => {
-        child.once('exit', (code, signal) => resolve({ code, signal }));
-      });
-
-      expect(result.signal).toBeNull();
-      expect(result.code).toBe(0);
-      expect(Buffer.concat(stdoutChunks).toString()).toContain('"key":"sigint-key"');
-      expect(Buffer.concat(stderrChunks).toString()).not.toContain('TIMEOUT');
-    });
-  });
-
-  describe('topic:offsets', () => {
-    it('should return topic offsets (high/low)', () => {
-      const output = cli(`topic:offsets ${TEST_TOPIC}`);
-      const offsets = parseJsonl<Record<string, unknown>>(output);
-
-      expect(offsets.length).toBeGreaterThan(0);
-      expect(offsets[0]).toHaveProperty('partition');
-      expect(offsets[0]).toHaveProperty('offset');
-      expect(offsets[0]).toHaveProperty('high');
-      expect(offsets[0]).toHaveProperty('low');
-      expect(Number(offsets[0].high)).toBeGreaterThanOrEqual(4);
-    });
-
-    it('should return consumer group offsets', () => {
-      const output = cli(`topic:offsets ${TEST_TOPIC} -g ${TEST_GROUP}-from0`);
-      const offsets = parseJsonl<Record<string, unknown>>(output);
-
-      expect(offsets.length).toBe(1);
-      expect(offsets[0]).toHaveProperty('topic', TEST_TOPIC);
-      expect(offsets[0]).toHaveProperty('partitions');
-      expect(Array.isArray(offsets[0].partitions)).toBe(true);
-    });
-
-    it('should return offsets by timestamp', () => {
-      const timestamp = new Date(Date.now() - 60000).toISOString();
-      const output = cli(`topic:offsets ${TEST_TOPIC} "${timestamp}"`);
-      const offsets = parseJsonl<Record<string, unknown>>(output);
-
-      expect(offsets.length).toBeGreaterThan(0);
-      expect(offsets[0]).toHaveProperty('partition');
-      expect(offsets[0]).toHaveProperty('offset');
-      expect(offsets[0]).not.toHaveProperty('high');
-      expect(offsets[0]).not.toHaveProperty('low');
-    });
-  });
-
-  describe('topic:delete', () => {
-    it('should delete the topic', () => {
-      cli(`topic:delete ${TEST_TOPIC}`);
-
-      const output = cli('list');
-      const topics = parseJsonl<string>(output);
-      expect(topics).not.toContain(TEST_TOPIC);
-    });
-  });
-});

package/eslint.config.js

@@ -1,37 +0,0 @@
-import eslint from '@eslint/js';
-import tseslint from 'typescript-eslint';
-import { defineConfig, globalIgnores } from 'eslint/config';
-import prettier from 'eslint-plugin-prettier';
-
-export default defineConfig(
-  globalIgnores(['**/docs', '**/build', '**/coverage', '**/node_modules', '**/scripts', '**/*.tmp.ts', '**/__tests__/*', '**/__bench__/*', '**/__mocks__/*', '**/e2e/*', 'vitest.config*.ts', '**/*.js', '**/*.cjs', '**/*.mjs']),
-  eslint.configs.recommended,
-  tseslint.configs.recommendedTypeChecked,
-  {
-    files: ['**/*.ts'],
-    plugins: {
-      prettier,
-    },
-    languageOptions: {
-      parserOptions: {
-        projectService: true,
-        tsconfigRootDir: import.meta.dirname,
-      },
-    },
-    rules: {
-      'prettier/prettier': 2,
-      '@typescript-eslint/no-unused-vars': 2,
-      '@typescript-eslint/ban-ts-comment': 1,
-      '@typescript-eslint/await-thenable': 1,
-      '@typescript-eslint/no-floating-promises': 1,
-      '@typescript-eslint/ban-types': 0,
-      '@typescript-eslint/no-explicit-any': 0,
-      '@typescript-eslint/require-await': 0,
-      '@typescript-eslint/no-misused-promises': 0,
-      '@typescript-eslint/no-empty-object-type': 0,
-      '@typescript-eslint/no-unsafe-declaration-merging': 0,
-      '@typescript-eslint/prefer-promise-reject-errors': 0,
-    },
-  },
-);
-

package/pnpm-workspace.yaml

@@ -1,3 +0,0 @@
-onlyBuiltDependencies:
-  - esbuild
-  - protobufjs

package/scripts/bench-kafka.js

@@ -1,456 +0,0 @@
-/* eslint-disable no-console */
-const { Kafka, CompressionTypes, logLevel } = require('kafkajs');
-const KafkaRDKafka = require('node-rdkafka');
-const { Producer: PlatformaticProducer, Consumer: PlatformaticConsumer, CompressionAlgorithms, ProduceAcks, stringSerializers, stringDeserializers, MessagesStreamModes } = require('@platformatic/kafka');
-const crypto = require('crypto');
-
-function generatePayload(size) {
-  // Simulate JSON-like data: ~50% compressible structure, ~50% random values
-  const template = '{"id":"","ts":,"data":""}';
-  const randomPart = crypto.randomBytes(Math.floor(size / 2)).toString('base64');
-  const padding = 'x'.repeat(Math.max(0, size - template.length - randomPart.length));
-  return JSON.stringify({ id: crypto.randomUUID(), ts: Date.now(), data: randomPart, pad: padding }).slice(0, size).padEnd(size, ' ');
-}
-
-function parseArgs() {
-  const args = process.argv.slice(2);
-  const out = {
-    brokers: process.env.KAFKA_BROKERS || 'localhost:9092',
-    topic: `kcli-bench-${Date.now()}`,
-    count: 1_000_000,
-    size: 1024,
-    batchSize: 1000,
-    concurrency: 16,
-    partitions: 12,
-    acks: 1,
-    rdkConsumeBatch: 1000,
-    rdkFetchMinBytes: 1048576,
-    rdkFetchWaitMs: 50,
-    rdkMaxPartitionFetchBytes: 5242880,
-    rdkQueuedMinMessages: 10000,
-    rdkQueuedMaxKbytes: 102400,
-  };
-
-  for (let i = 0; i < args.length; i += 1) {
-    const arg = args[i];
-    if (arg === '--brokers') out.brokers = args[++i];
-    else if (arg === '--topic') out.topic = args[++i];
-    else if (arg === '--count') out.count = Number(args[++i]);
-    else if (arg === '--size') out.size = Number(args[++i]);
-    else if (arg === '--batch') out.batchSize = Number(args[++i]);
-    else if (arg === '--concurrency') out.concurrency = Number(args[++i]);
-    else if (arg === '--partitions') out.partitions = Number(args[++i]);
-    else if (arg === '--acks') out.acks = Number(args[++i]);
-    else if (arg === '--rdk-consume-batch') out.rdkConsumeBatch = Number(args[++i]);
-    else if (arg === '--rdk-fetch-min-bytes') out.rdkFetchMinBytes = Number(args[++i]);
-    else if (arg === '--rdk-fetch-wait-ms') out.rdkFetchWaitMs = Number(args[++i]);
-    else if (arg === '--rdk-max-partition-fetch-bytes') out.rdkMaxPartitionFetchBytes = Number(args[++i]);
-    else if (arg === '--rdk-queued-min-messages') out.rdkQueuedMinMessages = Number(args[++i]);
-    else if (arg === '--rdk-queued-max-kbytes') out.rdkQueuedMaxKbytes = Number(args[++i]);
-  }
-
-  return out;
-}
-
-function elapsedMs(start) {
-  const diff = process.hrtime.bigint() - start;
-  return Number(diff) / 1_000_000;
-}
-
-async function ensureTopicKafkaJS(brokers, topic, partitions) {
-  const kafka = new Kafka({
-    clientId: 'kcli-bench-admin',
-    brokers: brokers.split(','),
-    logLevel: logLevel.NOTHING,
-  });
-  const admin = kafka.admin();
-  await admin.connect();
-  try {
-    await admin.createTopics({
-      topics: [{ topic, numPartitions: partitions }],
-      waitForLeaders: true,
-    });
-  } catch (err) {
-    // topic may already exist or auto-create is enabled
-  } finally {
-    await admin.disconnect();
-  }
-}
-
-async function benchKafkaJSProduce({ brokers, topic, count, size, batchSize, concurrency, acks }) {
-  const kafka = new Kafka({
-    clientId: 'kcli-bench-producer',
-    brokers: brokers.split(','),
-    logLevel: logLevel.NOTHING,
-  });
-  const producer = kafka.producer({ allowAutoTopicCreation: true });
-  await producer.connect();
-
-  const payload = generatePayload(size);
-  const start = process.hrtime.bigint();
-  const inFlight = [];
-  const windowSize = Math.max(1, concurrency);
-
-  for (let i = 0; i < count; i += batchSize) {
-    const messages = [];
-    const end = Math.min(i + batchSize, count);
-    for (let j = i; j < end; j += 1) {
-      messages.push({ value: payload });
-    }
-    inFlight.push(producer.send({
-      topic,
-      messages,
-      compression: CompressionTypes.GZIP,
-      acks,
-    }));
-    if (inFlight.length >= windowSize) {
-      await Promise.all(inFlight);
-      inFlight.length = 0;
-    }
-  }
-
-  if (inFlight.length > 0) {
-    await Promise.all(inFlight);
-  }
-
-  const ms = elapsedMs(start);
-  await producer.disconnect();
-  return ms;
-}
-
-async function benchKafkaJSConsume({ brokers, topic, count }) {
-  const kafka = new Kafka({
-    clientId: 'kcli-bench-consumer',
-    brokers: brokers.split(','),
-    logLevel: logLevel.NOTHING,
-  });
-  const groupId = `kcli-bench-js-${Date.now()}`;
-  const consumer = kafka.consumer({ groupId });
-  await consumer.connect();
-  await consumer.subscribe({ topic, fromBeginning: true });
-
-  let firstMessageMs = null;
-  let seen = 0;
-  const start = process.hrtime.bigint();
-  let resolveDone;
-  let doneResolved = false;
-
-  const done = new Promise((resolve, reject) => {
-    resolveDone = resolve;
-    consumer.run({
-      autoCommit: false,
-      eachBatch: async ({ batch, resolveOffset, heartbeat, isRunning, isStale }) => {
-        for (const message of batch.messages) {
-          if (!isRunning() || isStale()) return;
-          if (firstMessageMs === null) {
-            firstMessageMs = elapsedMs(start);
-          }
-          seen += 1;
-          resolveOffset(message.offset);
-          if (seen >= count && !doneResolved) {
-            doneResolved = true;
-            resolveDone();
-            break;
-          }
-        }
-        await heartbeat();
-      },
-    }).catch(reject);
-  });
-
-  await done;
-  await consumer.stop();
-  await consumer.disconnect();
-
-  return { totalMs: elapsedMs(start), firstMessageMs };
-}
-
-function createRDKafkaProducer(brokers, acks) {
-  return new KafkaRDKafka.Producer({
-    'metadata.broker.list': brokers,
-    'request.required.acks': acks,
-    'dr_cb': true,
-    'queue.buffering.max.messages': 1000000,
-    'compression.codec': 'gzip',
-  });
-}
-
-async function benchRDKafkaProduce({ brokers, topic, count, size, acks }) {
-  const producer = createRDKafkaProducer(brokers, acks);
-  let delivered = 0;
-  let deliveryErrors = 0;
-
-  await new Promise((resolve, reject) => {
-    producer.on('ready', resolve);
-    producer.on('event.error', reject);
-    producer.connect();
-  });
-
-  producer.on('delivery-report', (err) => {
-    if (err) {
-      deliveryErrors += 1;
-      return;
-    }
-    delivered += 1;
-  });
-
-  producer.setPollInterval(100);
-  const payload = Buffer.from(generatePayload(size));
-  const start = process.hrtime.bigint();
-
-  for (let i = 0; i < count; i += 1) {
-    try {
-      producer.produce(topic, null, payload, null, Date.now());
-    } catch (err) {
-      if (err && err.code === -184) {
-        await new Promise((resolve) => producer.once('drain', resolve));
-        producer.produce(topic, null, payload, null, Date.now());
-      } else {
-        throw err;
-      }
-    }
-  }
-
-  await new Promise((resolve, reject) => {
-    producer.flush(30_000, (err) => {
-      if (err) return reject(err);
-      resolve();
-    });
-  });
-
-  await new Promise((resolve) => {
-    const waitStart = Date.now();
-    const check = () => {
-      if (delivered + deliveryErrors >= count) return resolve();
-      if (Date.now() - waitStart >= 60_000) return resolve();
-      setTimeout(check, 50);
-    };
-    check();
-  });
-
-  const ms = elapsedMs(start);
-  producer.disconnect();
-  return { ms, delivered, deliveryErrors };
-}
-
-async function benchRDKafkaConsume({
-  brokers,
-  topic,
-  count,
-  rdkConsumeBatch,
-  rdkFetchMinBytes,
-  rdkFetchWaitMs,
-  rdkMaxPartitionFetchBytes,
-  rdkQueuedMinMessages,
-  rdkQueuedMaxKbytes,
-}) {
-  const groupId = `kcli-bench-rdk-${Date.now()}`;
-
-  const consumer = new KafkaRDKafka.KafkaConsumer({
-    'metadata.broker.list': brokers,
-    'group.id': groupId,
-    'enable.auto.commit': false,
-    'auto.offset.reset': 'earliest',
-    'fetch.min.bytes': rdkFetchMinBytes,
-    'fetch.wait.max.ms': rdkFetchWaitMs,
-    'max.partition.fetch.bytes': rdkMaxPartitionFetchBytes,
-    'queued.min.messages': rdkQueuedMinMessages,
-    'queued.max.messages.kbytes': rdkQueuedMaxKbytes,
-  }, {});
-
-  await new Promise((resolve, reject) => {
-    consumer.on('ready', resolve);
-    consumer.on('event.error', reject);
-    consumer.connect();
-  });
-
-  const metadata = await new Promise((resolve, reject) => {
-    consumer.getMetadata({ topic, timeout: 10000 }, (err, data) => {
-      if (err) reject(err);
-      else resolve(data);
-    });
-  });
-
-  const topicMeta = metadata.topics.find((t) => t.name === topic);
-  if (!topicMeta) throw new Error(`Topic ${topic} not found in metadata`);
-
-  const RD_KAFKA_OFFSET_BEGINNING = -2;
-  const assignments = topicMeta.partitions.map((p) => ({
-    topic,
-    partition: p.id,
-    offset: RD_KAFKA_OFFSET_BEGINNING,
-  }));
-  consumer.assign(assignments);
-
-  let firstMessageMs = null;
-  let seen = 0;
-  const start = process.hrtime.bigint();
-  const progressInterval = Math.max(1, Math.floor(count / 10));
-  const batchSize = 5000;
-
-  await new Promise((resolve, reject) => {
-    consumer.on('event.error', reject);
-
-    const consumeNext = () => {
-      if (seen >= count) {
-        consumer.disconnect();
-        resolve();
-        return;
-      }
-      consumer.consume(batchSize, (err, messages) => {
-        if (err) return reject(err);
-        const len = messages ? messages.length : 0;
-        if (len > 0) {
-          if (firstMessageMs === null) firstMessageMs = elapsedMs(start);
-          seen += len;
-          if (seen % progressInterval < len) {
-            console.log(`node-rdkafka consume progress: ${seen}/${count}`);
-          }
-        }
-        setImmediate(consumeNext);
-      });
-    };
-    consumeNext();
-  });
-  return { totalMs: elapsedMs(start), firstMessageMs };
-}
-
-async function benchPlatformaticProduce({ brokers, topic, count, size, batchSize, acks }) {
-  const producer = new PlatformaticProducer({
-    clientId: 'kcli-bench-platformatic-producer',
-    bootstrapBrokers: brokers.split(','),
-    compression: CompressionAlgorithms.GZIP,
-    serializers: stringSerializers,
-  });
-
-  const payload = generatePayload(size);
-  const start = process.hrtime.bigint();
-
-  for (let i = 0; i < count; i += batchSize) {
-    const messages = [];
-    const end = Math.min(i + batchSize, count);
-    for (let j = i; j < end; j += 1) {
-      messages.push({ topic, value: payload });
-    }
-    await producer.send({
-      messages,
-      acks: acks === 1 ? ProduceAcks.LEADER : ProduceAcks.ALL,
-    });
-  }
-
-  const ms = elapsedMs(start);
-  await producer.close();
-  return ms;
-}
-
-async function benchPlatformaticConsume({ brokers, topic, count }) {
-  const groupId = `kcli-bench-platformatic-${Date.now()}`;
-
-  const consumer = new PlatformaticConsumer({
-    clientId: 'kcli-bench-platformatic-consumer',
-    bootstrapBrokers: brokers.split(','),
-    groupId,
-    autocommit: true,
-    deserializers: stringDeserializers,
-  });
-
-  // Get earliest offsets for all partitions
-  const offsetsMap = await consumer.listOffsets({ topics: [topic], timestamp: -2n });
-  const offsets = [];
-  const partitionOffsets = offsetsMap.get(topic);
-  if (partitionOffsets) {
-    for (let partition = 0; partition < partitionOffsets.length; partition++) {
-      offsets.push({ topic, partition, offset: partitionOffsets[partition] });
-    }
-  }
-  console.log(`@plt: using MANUAL mode with ${offsets.length} partitions`);
-
-  const stream = await consumer.consume({
-    topics: [topic],
-    mode: MessagesStreamModes.MANUAL,
-    offsets,
-    sessionTimeout: 10000,
-    heartbeatInterval: 500,
-  });
-
-  let firstMessageMs = null;
-  let seen = 0;
-  const start = process.hrtime.bigint();
-  const progressInterval = Math.max(1, Math.floor(count / 10));
-
-  const result = await new Promise((resolve, reject) => {
-    stream.on('error', (err) => {
-      console.error('@platformatic/kafka stream error:', err);
-      reject(err);
-    });
-
-    stream.on('data', (message) => {
-      if (firstMessageMs === null) {
-        firstMessageMs = elapsedMs(start);
-      }
-      seen += 1;
-      if (seen % progressInterval === 0) {
-        console.log(`platformatic consume progress: ${seen}/${count}`);
-      }
-      if (seen >= count) {
-        stream.destroy();
-        resolve({ totalMs: elapsedMs(start), firstMessageMs });
-      }
-    });
-
-    stream.on('end', () => {
-      console.log('@platformatic/kafka stream ended');
-      resolve({ totalMs: elapsedMs(start), firstMessageMs });
-    });
-
-    stream.resume();
-  });
-
-  await consumer.close(true);
-  return result;
-}
-
-(async () => {
-  const config = parseArgs();
-  const { brokers, topic } = config;
-  const jsTopic = `${topic}-js`;
-  const rdkTopic = `${topic}-rdk`;
-  const pltTopic = `${topic}-plt`;
-
-  console.log('Benchmark config:', { ...config, topics: { kafkaJs: jsTopic, rdkafka: rdkTopic, platformatic: pltTopic } });
-  await ensureTopicKafkaJS(brokers, jsTopic, config.partitions);
-  await ensureTopicKafkaJS(brokers, rdkTopic, config.partitions);
-  await ensureTopicKafkaJS(brokers, pltTopic, config.partitions);
-
-  console.log('\nKafkaJS produce...');
-  const jsProduceMs = await benchKafkaJSProduce({ ...config, topic: jsTopic });
-  console.log(`KafkaJS produce: ${jsProduceMs.toFixed(1)} ms (${(config.count / (jsProduceMs / 1000)).toFixed(1)} msg/s)`);
-
-  console.log('KafkaJS consume...');
-  const jsConsume = await benchKafkaJSConsume({ ...config, topic: jsTopic });
-  console.log(`KafkaJS first message: ${jsConsume.firstMessageMs.toFixed(1)} ms`);
-  console.log(`KafkaJS consume: ${jsConsume.totalMs.toFixed(1)} ms (${(config.count / (jsConsume.totalMs / 1000)).toFixed(1)} msg/s)`);
-
-  console.log('\nnode-rdkafka produce...');
-  const rdkProduce = await benchRDKafkaProduce({ ...config, topic: rdkTopic });
-  const rdkDelivered = rdkProduce.delivered > 0 ? rdkProduce.delivered : config.count;
-  console.log(`node-rdkafka produce: ${rdkProduce.ms.toFixed(1)} ms (${(config.count / (rdkProduce.ms / 1000)).toFixed(1)} msg/s)`);
-  console.log(`node-rdkafka delivered: ${rdkDelivered} (errors: ${rdkProduce.deliveryErrors})`);
-
-  console.log('node-rdkafka consume...');
-  const rdkConsume = await benchRDKafkaConsume({ ...config, topic: rdkTopic, count: rdkDelivered });
-  console.log(`node-rdkafka first message: ${rdkConsume.firstMessageMs.toFixed(1)} ms`);
-  console.log(`node-rdkafka consume: ${rdkConsume.totalMs.toFixed(1)} ms (${(rdkDelivered / (rdkConsume.totalMs / 1000)).toFixed(1)} msg/s)`);
-
-  console.log('\n@platformatic/kafka produce...');
-  const pltProduceMs = await benchPlatformaticProduce({ ...config, topic: pltTopic });
-  console.log(`@platformatic/kafka produce: ${pltProduceMs.toFixed(1)} ms (${(config.count / (pltProduceMs / 1000)).toFixed(1)} msg/s)`);
-
-  console.log('@platformatic/kafka consume...');
-  const pltConsume = await benchPlatformaticConsume({ ...config, topic: pltTopic });
-  console.log(`@platformatic/kafka first message: ${pltConsume.firstMessageMs?.toFixed(1) ?? 'N/A'} ms`);
-  console.log(`@platformatic/kafka consume: ${pltConsume.totalMs.toFixed(1)} ms (${(config.count / (pltConsume.totalMs / 1000)).toFixed(1)} msg/s)`);
-})().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});

package/tsconfig.build.json

@@ -1,8 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "noEmit": false,
-    "declaration": true,
-    "outDir": "build"
-  }
-}

package/vitest.config.e2e.ts

@@ -1,9 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    include: ['e2e/**/*.test.ts'],
-    testTimeout: 30000,
-    hookTimeout: 30000,
-  },
-});

package/vitest.config.ts

@@ -1,17 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    include: ['src/**/__tests__/**/*.ts'],
-    exclude: ['src/**/__tests__/**/*.e2e.ts'],
-    alias: {
-      '@platformatic/kafka': new URL('./src/__mocks__/@platformatic/kafka.ts', import.meta.url).pathname,
-      'commander': new URL('./src/__mocks__/commander.ts', import.meta.url).pathname,
-    },
-    coverage: {
-      enabled: !!process.env.CI || !!process.env.COVERAGE,
-      include: ['src/**/*.ts'],
-      exclude: ['src/__mocks__/**', 'src/**/__tests__/**'],
-    },
-  },
-});