ehbp 0.0.3 → 0.0.5

package/src/test/identity.test.ts

@@ -1,46 +0,0 @@
-import { describe, it } from 'node:test';
-import assert from 'node:assert';
-import { Identity } from '../identity.js';
-
-describe('Identity', () => {
-  it('should generate a new identity', async () => {
-    const identity = await Identity.generate();
-    
-    assert(identity.getPublicKey() instanceof CryptoKey, 'Public key should be a CryptoKey');
-    assert(identity.getPrivateKey() instanceof CryptoKey, 'Private key should be a CryptoKey');
-    const publicKeyHex = await identity.getPublicKeyHex();
-    assert(publicKeyHex.length > 0, 'Public key hex should not be empty');
-  });
-
-  it('should serialize and deserialize identity', async () => {
-    const original = await Identity.generate();
-    const json = await original.toJSON();
-    const restored = await Identity.fromJSON(json);
-    
-    const originalHex = await original.getPublicKeyHex();
-    const restoredHex = await restored.getPublicKeyHex();
-    assert(originalHex === restoredHex, 'Public keys should match');
-    assert(original.getPrivateKey() instanceof CryptoKey, 'Private key should be a CryptoKey');
-    assert(restored.getPrivateKey() instanceof CryptoKey, 'Private key should be a CryptoKey');
-  });
-
-  it('should marshal configuration', async () => {
-    const identity = await Identity.generate();
-    const config = await identity.marshalConfig();
-    
-    assert(config.length > 0, 'Config should not be empty');
-    assert(config[0] === 0, 'Key ID should be 0');
-    assert(config[1] === 0x00, 'KEM ID high byte should be 0x00');
-    assert(config[2] === 0x20, 'KEM ID low byte should be 0x20');
-  });
-
-  it('should unmarshal public configuration', async () => {
-    const identity = await Identity.generate();
-    const config = await identity.marshalConfig();
-    const restored = await Identity.unmarshalPublicConfig(config);
-    
-    const originalHex = await identity.getPublicKeyHex();
-    const restoredHex = await restored.getPublicKeyHex();
-    assert(restoredHex === originalHex, 'Public keys should match');
-  });
-});

package/src/test/streaming.test.ts

@@ -1,85 +0,0 @@
-import { describe, it } from 'node:test';
-import assert from 'node:assert';
-
-describe('Streaming', () => {
-
-  it('should handle streaming responses', async () => {
-    // Create a mock streaming response
-    const mockStreamData = 'Number: 1\nNumber: 2\nNumber: 3\n';
-    const mockResponse = new Response(mockStreamData, {
-      status: 200,
-      headers: {
-        'Content-Type': 'text/plain',
-        'Ehbp-Encapsulated-Key': 'abcd1234' // Mock encapsulated key
-      }
-    });
-
-    // Test that we can read from a stream
-    const reader = mockResponse.body?.getReader();
-    assert(reader, 'Response should have a readable stream');
-
-    const decoder = new TextDecoder();
-    let receivedData = '';
-
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-
-      const text = decoder.decode(value, { stream: true });
-      receivedData += text;
-    }
-
-    assert(receivedData === mockStreamData, 'Should receive all stream data');
-  });
-
-  it('should handle empty streams', async () => {
-    const emptyResponse = new Response('', {
-      status: 200,
-      headers: {
-        'Ehbp-Encapsulated-Key': 'abcd1234'
-      }
-    });
-
-    const reader = emptyResponse.body?.getReader();
-    assert(reader, 'Response should have a readable stream');
-
-    const { done } = await reader.read();
-    assert(done, 'Empty stream should be done immediately');
-  });
-
-  it('should handle chunked data correctly', async () => {
-    // Simulate chunked data
-    const chunks = ['Hello', ' ', 'World', '!'];
-    const stream = new ReadableStream({
-      start(controller) {
-        chunks.forEach(chunk => {
-          controller.enqueue(new TextEncoder().encode(chunk));
-        });
-        controller.close();
-      }
-    });
-
-    const response = new Response(stream, {
-      status: 200,
-      headers: {
-        'Ehbp-Encapsulated-Key': 'abcd1234'
-      }
-    });
-
-    const reader = response.body?.getReader();
-    assert(reader, 'Response should have a readable stream');
-
-    const decoder = new TextDecoder();
-    let receivedData = '';
-
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-
-      const text = decoder.decode(value, { stream: true });
-      receivedData += text;
-    }
-
-    assert(receivedData === 'Hello World!', 'Should receive all chunks correctly');
-  });
-});

package/test.html

@@ -1,271 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>EHBP Streaming Test</title>
-    <style>
-        body {
-            font-family: Arial, sans-serif;
-            max-width: 800px;
-            margin: 0 auto;
-            padding: 20px;
-            background-color: #f5f5f5;
-        }
-        .container {
-            background: white;
-            padding: 20px;
-            border-radius: 8px;
-            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
-        }
-        h1 {
-            color: #333;
-            text-align: center;
-        }
-        .test-section {
-            margin: 20px 0;
-            padding: 15px;
-            border: 1px solid #ddd;
-            border-radius: 5px;
-        }
-        .test-section h3 {
-            margin-top: 0;
-            color: #555;
-        }
-        button {
-            background-color: #007bff;
-            color: white;
-            border: none;
-            padding: 10px 20px;
-            border-radius: 4px;
-            cursor: pointer;
-            margin: 5px;
-        }
-        button:hover {
-            background-color: #0056b3;
-        }
-        button:disabled {
-            background-color: #6c757d;
-            cursor: not-allowed;
-        }
-        .output {
-            background-color: #f8f9fa;
-            border: 1px solid #dee2e6;
-            border-radius: 4px;
-            padding: 10px;
-            margin: 10px 0;
-            height: 100px;
-            font-family: monospace;
-            white-space: pre-wrap;
-            overflow-y: auto;
-        }
-        .status {
-            padding: 10px;
-            margin: 10px 0;
-            border-radius: 4px;
-        }
-        .status.success {
-            background-color: #d4edda;
-            color: #155724;
-            border: 1px solid #c3e6cb;
-        }
-        .status.error {
-            background-color: #f8d7da;
-            color: #721c24;
-            border: 1px solid #f5c6cb;
-        }
-        .status.info {
-            background-color: #d1ecf1;
-            color: #0c5460;
-            border: 1px solid #bee5eb;
-        }
-        .clear-btn {
-            background-color: #6c757d;
-        }
-        .clear-btn:hover {
-            background-color: #545b62;
-        }
-    </style>
-</head>
-<body>
-    <div class="container">
-        <h1>EHBP Test</h1>
-        
-        <div class="test-section">
-            <h3>Server Configuration</h3>
-            <label for="serverUrl">Server URL:</label>
-            <input type="text" id="serverUrl" value="http://localhost:8080" style="width: 300px; padding: 5px; margin: 5px;">
-            <div id="serverStatus" class="status info">Ready to test</div>
-        </div>
-
-        <div class="test-section">
-            <h3>Test 1: POST to /secure</h3>
-            <button id="test1Btn" onclick="runTest1()">Run POST Test</button>
-            <button class="clear-btn" onclick="clearOutput('test1Output')">Clear</button>
-            <div id="test1Output" class="output"></div>
-        </div>
-
-        <div class="test-section">
-            <h3>Test 2: Streaming</h3>
-            <button id="test2Btn" onclick="runTest2()">Run Streaming Test</button>
-            <button class="clear-btn" onclick="clearOutput('test2Output')">Clear</button>
-            <div id="test2Output" class="output"></div>
-        </div>
-
-    </div>
-
-    <script type="module">
-        import { Identity, createTransport } from './dist/browser.js';
-
-        let transport = null;
-        let clientIdentity = null;
-
-        async function initializeClient() {
-            try {
-                updateStatus('serverStatus', 'info', 'Initializing client...');
-                clientIdentity = await Identity.generate();
-                const serverUrl = document.getElementById('serverUrl').value;
-                transport = await createTransport(serverUrl, clientIdentity);
-                updateStatus('serverStatus', 'success', `Connected to ${serverUrl}`);
-                return true;
-            } catch (error) {
-                updateStatus('serverStatus', 'error', `Failed to connect: ${error.message}`);
-                return false;
-            }
-        }
-
-        function updateStatus(elementId, type, message) {
-            const element = document.getElementById(elementId);
-            element.className = `status ${type}`;
-            element.textContent = message;
-        }
-
-        function appendOutput(elementId, text) {
-            const element = document.getElementById(elementId);
-            element.textContent += text;
-            element.scrollTop = element.scrollHeight;
-        }
-
-        function clearOutput(elementId) {
-            document.getElementById(elementId).textContent = '';
-        }
-
-        function clearAllOutputs() {
-            clearOutput('test1Output');
-            clearOutput('test2Output');
-        }
-
-        async function runTest1() {
-            const btn = document.getElementById('test1Btn');
-            const output = document.getElementById('test1Output');
-            
-            btn.disabled = true;
-            clearOutput('test1Output');
-
-            let endpoint = '/secure';
-            const exampleName = 'John Doe';
-
-            appendOutput('test1Output', 'Starting POST ' + endpoint + ' test...\n');
-            
-            try {
-                if (!transport) {
-                    const initialized = await initializeClient();
-                    if (!initialized) return;
-                }
-
-                const serverUrl = document.getElementById('serverUrl').value;
-                
-                try {
-                    const testBody = "John Doe";
-                    appendOutput('test1Output', `Sending POST request with body: ${testBody}\n`);
-                    
-                    const response1 = await transport.post(`${serverUrl}${endpoint}`, testBody, {
-                        headers: {
-                            'Content-Type': 'text/plain'
-                        }
-                    });
-                    
-                    appendOutput('test1Output', `Response status: ${response1.status}\n`);
-                    if (response1.ok) {
-                        const responseText = await response1.text();
-                        appendOutput('test1Output', `Response body: ${responseText}\n`);
-                        if (responseText !== "Hello, "+exampleName) {
-                            appendOutput('test1Output', '✗ Basic POST test failed with response: '+responseText+'\n\n');
-                            return;
-                        } else {
-                            appendOutput('test1Output', '✓ Basic POST test passed\n\n');
-                        }
-                    } else {
-                        appendOutput('test1Output', `✗ Basic POST test failed with status: ${response1.status}\n\n`);
-                    }
-                } catch (error) {
-                    appendOutput('test1Output', `✗ Basic POST test failed with error: ${error.message}\n\n`);
-                }
-
-                appendOutput('test1Output', 'POST ' + endpoint + ' test completed!\n');
-            } catch (error) {
-                appendOutput('test1Output', `Error: ${error.message}\n`);
-            } finally {
-                btn.disabled = false;
-            }
-        }
-
-        async function runTest2() {
-            const btn = document.getElementById('test2Btn');
-            const output = document.getElementById('test2Output');
-            
-            btn.disabled = true;
-            clearOutput('test2Output');
-            appendOutput('test2Output', 'Starting basic streaming test...\n');
-            
-            try {
-                if (!transport) {
-                    const initialized = await initializeClient();
-                    if (!initialized) return;
-                }
-
-                const serverUrl = document.getElementById('serverUrl').value;
-                const response = await transport.get(`${serverUrl}/stream`);
-                
-                appendOutput('test2Output', `Stream response status: ${response.status}\n`);
-                
-                if (response.ok) {
-                    appendOutput('test2Output', 'Reading stream data...\n');
-                    const reader = response.body?.getReader();
-                    
-                    if (reader) {
-                        const decoder = new TextDecoder();
-                        
-                        while (true) {
-                            const { done, value } = await reader.read();
-                            if (done) break;
-                            
-                            const text = decoder.decode(value, { stream: true });
-                            appendOutput('test2Output', text);
-                        }
-                        
-                        appendOutput('test2Output', '\nStream completed!\n');
-                    } else {
-                        appendOutput('test2Output', 'No readable stream available\n');
-                    }
-                } else {
-                    appendOutput('test2Output', `Stream request failed with status: ${response.status}\n`);
-                }
-            } catch (error) {
-                appendOutput('test2Output', `Error: ${error.message}\n`);
-            } finally {
-                btn.disabled = false;
-            }
-        }
-
-        window.runTest1 = runTest1;
-        window.runTest2 = runTest2;
-        window.clearOutput = clearOutput;
-        window.clearAllOutputs = clearAllOutputs;
-
-        document.addEventListener('DOMContentLoaded', () => {
-            updateStatus('serverStatus', 'info', 'Ready to test - click a test button to start');
-        });
-    </script>
-</body>
-</html>

package/tsconfig.cjs.json

@@ -1,8 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "module": "CommonJS",
-    "outDir": "./dist/cjs"
-  },
-  "exclude": ["node_modules", "dist", "src/example.ts", "src/streaming-test.ts", "src/test"]
-}

package/tsconfig.esm.json

@@ -1,7 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "module": "ESNext",
-    "outDir": "./dist/esm"
-  }
-}

package/tsconfig.json

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