serverless-ircd 0.1.0

package/tools/tcp-ws-forwarder/tests/line-scanner.test.ts

@@ -0,0 +1,75 @@
+import { describe, expect, it } from 'vitest';
+import { LineScanner } from '../src/line-scanner';
+
+/**
+ * The line scanner is the only stateful piece of framing in the forwarder;
+ * it must be byte-accurate at chunk boundaries and tolerant of both CRLF
+ * and bare-LF line endings (PLAN §9 transport tolerance). These tests pin
+ * that contract in isolation, away from real sockets.
+ */
+describe('LineScanner', () => {
+  it('emits a single CRLF-terminated line and leaves no carry', () => {
+    const s = new LineScanner();
+    expect(s.push(Buffer.from('PING :tok\r\n'))).toEqual(['PING :tok']);
+    expect(s.flush()).toEqual([]);
+  });
+
+  it('emits each of several CRLF-terminated lines in one chunk in order', () => {
+    const s = new LineScanner();
+    expect(s.push(Buffer.from('A\r\nB\r\nC\r\n'))).toEqual(['A', 'B', 'C']);
+  });
+
+  it('buffers a partial line across chunks and joins it once terminated', () => {
+    const s = new LineScanner();
+    expect(s.push(Buffer.from('PI'))).toEqual([]);
+    expect(s.push(Buffer.from('NG :tok\r\n'))).toEqual(['PING :tok']);
+  });
+
+  it('preserves a UTF-8 multi-byte character split across chunks', () => {
+    // 'café :hi\r\n' is bytes: c a f 0xC3 0xA9 SP : h i CR LF (11 bytes).
+    // Split at offset 4 — inside 'é' (0xC3 | 0xA9).
+    const full = Buffer.from('café :hi\r\n', 'utf8');
+    const s = new LineScanner();
+    expect(s.push(full.subarray(0, 4))).toEqual([]); // carries 'caf' + first byte of é
+    expect(s.push(full.subarray(4))).toEqual(['café :hi']); // second byte completes é
+  });
+
+  it('tolerates bare LF line endings', () => {
+    const s = new LineScanner();
+    expect(s.push(Buffer.from('A\nB\n'))).toEqual(['A', 'B']);
+  });
+
+  it('tolerates a mix of CRLF and bare LF endings', () => {
+    const s = new LineScanner();
+    expect(s.push(Buffer.from('A\r\nB\nC\r\n'))).toEqual(['A', 'B', 'C']);
+  });
+
+  it('returns no lines for empty input', () => {
+    const s = new LineScanner();
+    expect(s.push(Buffer.alloc(0))).toEqual([]);
+  });
+
+  it('keeps an unterminated tail buffered until a terminator arrives', () => {
+    const s = new LineScanner();
+    expect(s.push(Buffer.from('partial'))).toEqual([]);
+    expect(s.push(Buffer.from(' line\r\n'))).toEqual(['partial line']);
+  });
+
+  it('flush returns a previously-unterminated tail (lossless)', () => {
+    const s = new LineScanner();
+    s.push(Buffer.from('no-newline-here'));
+    expect(s.flush()).toEqual(['no-newline-here']);
+    expect(s.flush()).toEqual([]);
+  });
+
+  it('flush is empty when there is no carry', () => {
+    const s = new LineScanner();
+    expect(s.flush()).toEqual([]);
+  });
+
+  it('does not strip a leading CR that is not part of a CRLF', () => {
+    // A bare \r in the middle of text is data, not a terminator.
+    const s = new LineScanner();
+    expect(s.push(Buffer.from('a\rb\r\n'))).toEqual(['a\rb']);
+  });
+});

package/tools/tcp-ws-forwarder/tsconfig.build.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "composite": true,
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "tsBuildInfoFile": "./.tsbuildinfo",
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["dist", "tests", "**/*.test.ts"]
+}

package/tools/tcp-ws-forwarder/tsconfig.test.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "types": ["node"],
+    "composite": false
+  },
+  "include": ["src/**/*.ts", "tests/**/*.ts"],
+  "exclude": ["dist"]
+}

package/tools/tcp-ws-forwarder/vitest.config.ts

@@ -0,0 +1,27 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    environment: 'node',
+    include: ['tests/**/*.test.ts'],
+    // Forwarder integration tests spin up real TCP + WS servers per case;
+    // give them a little headroom while staying fast enough for watch mode.
+    testTimeout: 5000,
+    hookTimeout: 5000,
+    coverage: {
+      provider: 'v8',
+      all: false,
+      include: ['src/**/*.ts'],
+      // `main.ts` is CLI glue (argv parsing, signal handlers); exercised
+      // manually by `pnpm start`. Mirrors the apps/local-cli policy.
+      exclude: ['src/main.ts'],
+      reporter: ['text', 'html', 'json-summary'],
+      thresholds: {
+        lines: 90,
+        functions: 90,
+        branches: 80,
+        statements: 90,
+      },
+    },
+  },
+});

package/tsconfig.base.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "lib": ["ES2022"],
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    "noFallthroughCasesInSwitch": true,
+    "exactOptionalPropertyTypes": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "isolatedModules": true,
+    "verbatimModuleSyntax": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "useDefineForClassFields": true
+  }
+}

package/turbo.json

@@ -0,0 +1,29 @@
+{
+  "$schema": "https://turbo.build/schema.json",
+  "ui": "stream",
+  "globalDependencies": ["tsconfig.base.json", "biome.json"],
+  "tasks": {
+    "build": {
+      "dependsOn": ["^build"],
+      "outputs": ["dist/**"]
+    },
+    "typecheck": {
+      "dependsOn": ["^build"]
+    },
+    "test": {
+      "dependsOn": ["^build"],
+      "outputs": ["coverage/**"]
+    },
+    "test:watch": {
+      "cache": false,
+      "persistent": true
+    },
+    "coverage": {
+      "dependsOn": ["^build"],
+      "outputs": ["coverage/**"]
+    },
+    "clean": {
+      "cache": false
+    }
+  }
+}