openclaw-overlay-plugin 0.7.22

package/dist/test/overlay-submit.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Unit tests for overlay /submit endpoint compatibility.
+ *
+ * These tests validate that the client constructs BEEF and payloads
+ * in the exact format expected by the clawdbot-overlay server's
+ * topic managers using PushDrop tokens.
+ *
+ * Run with: npx tsx src/test/overlay-submit.test.ts
+ */
+export {};

package/dist/test/overlay-submit.test.js

@@ -0,0 +1,460 @@
+/**
+ * Unit tests for overlay /submit endpoint compatibility.
+ *
+ * These tests validate that the client constructs BEEF and payloads
+ * in the exact format expected by the clawdbot-overlay server's
+ * topic managers using PushDrop tokens.
+ *
+ * Run with: npx tsx src/test/overlay-submit.test.ts
+ */
+import { Beef, Transaction, PrivateKey, P2PKH, LockingScript, OP, PushDrop } from '@bsv/sdk';
+const PROTOCOL_ID = 'clawdbot-overlay-v1';
+/**
+ * Extract data fields from a PushDrop script using the SDK's decode method.
+ */
+function extractPushDropFields(script) {
+    try {
+        const decoded = PushDrop.decode(script);
+        return decoded.fields;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Parse identity output using PushDrop decode and server's validation logic.
+ */
+function parseIdentityOutput(script) {
+    const fields = extractPushDropFields(script);
+    if (!fields || fields.length < 1)
+        return null;
+    try {
+        const payload = JSON.parse(new TextDecoder().decode(new Uint8Array(fields[0])));
+        // Server validation rules
+        if (payload.protocol !== PROTOCOL_ID)
+            return null;
+        if (payload.type !== 'identity')
+            return null;
+        if (typeof payload.identityKey !== 'string' || !/^[0-9a-fA-F]{66}$/.test(payload.identityKey))
+            return null;
+        if (typeof payload.name !== 'string' || payload.name.length === 0)
+            return null;
+        if (!Array.isArray(payload.capabilities))
+            return null;
+        if (typeof payload.timestamp !== 'string')
+            return null;
+        return payload;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Parse service output using PushDrop decode and server's validation logic.
+ */
+function parseServiceOutput(script) {
+    const fields = extractPushDropFields(script);
+    if (!fields || fields.length < 1)
+        return null;
+    try {
+        const payload = JSON.parse(new TextDecoder().decode(new Uint8Array(fields[0])));
+        // Server validation rules
+        if (payload.protocol !== PROTOCOL_ID)
+            return null;
+        if (payload.type !== 'service')
+            return null;
+        if (typeof payload.identityKey !== 'string' || !/^[0-9a-fA-F]{66}$/.test(payload.identityKey))
+            return null;
+        if (typeof payload.serviceId !== 'string' || payload.serviceId.length === 0)
+            return null;
+        if (typeof payload.name !== 'string' || payload.name.length === 0)
+            return null;
+        if (!payload.pricing || typeof payload.pricing.amountSats !== 'number')
+            return null;
+        if (typeof payload.timestamp !== 'string')
+            return null;
+        return payload;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Create a minimally encoded push chunk for script building.
+ */
+function createPushChunk(data) {
+    if (data.length === 0) {
+        return { op: 0 };
+    }
+    if (data.length === 1 && data[0] === 0) {
+        return { op: 0 };
+    }
+    if (data.length === 1 && data[0] > 0 && data[0] <= 16) {
+        return { op: 0x50 + data[0] };
+    }
+    if (data.length <= 75) {
+        return { op: data.length, data };
+    }
+    if (data.length <= 255) {
+        return { op: 0x4c, data };
+    }
+    if (data.length <= 65535) {
+        return { op: 0x4d, data };
+    }
+    return { op: 0x4e, data };
+}
+/**
+ * Build a PushDrop-style locking script with JSON payload.
+ * Format: <pubkey> OP_CHECKSIG <jsonBytes> OP_DROP
+ */
+function buildPushDropScript(privKey, payload) {
+    const pubKey = privKey.toPublicKey();
+    const pubKeyBytes = pubKey.toDER();
+    const jsonBytes = Array.from(new TextEncoder().encode(JSON.stringify(payload)));
+    const chunks = [];
+    // P2PK lock: <pubkey> OP_CHECKSIG
+    chunks.push({ op: pubKeyBytes.length, data: pubKeyBytes });
+    chunks.push({ op: OP.OP_CHECKSIG });
+    // Data field: <jsonBytes>
+    chunks.push(createPushChunk(jsonBytes));
+    // OP_DROP to clean stack
+    chunks.push({ op: OP.OP_DROP });
+    return new LockingScript(chunks);
+}
+/**
+ * Simulate the server's identifyAdmissibleOutputs logic.
+ */
+function identifyAdmissibleOutputs(beef, type) {
+    // Parse BEEF and get the newest (subject) transaction
+    const parsedBeef = Beef.fromBinary(beef);
+    const subjectTx = parsedBeef.txs[0]._tx;
+    if (!subjectTx) {
+        return { outputsToAdmit: [], coinsToRetain: [] };
+    }
+    const outputsToAdmit = [];
+    for (let i = 0; i < subjectTx.outputs.length; i++) {
+        const output = subjectTx.outputs[i];
+        if (output.lockingScript) {
+            const parsed = type === 'identity'
+                ? parseIdentityOutput(output.lockingScript)
+                : parseServiceOutput(output.lockingScript);
+            if (parsed !== null) {
+                outputsToAdmit.push(i);
+            }
+        }
+    }
+    return { outputsToAdmit, coinsToRetain: [] };
+}
+// ============================================================================
+// Test utilities
+// ============================================================================
+let testsPassed = 0;
+let testsFailed = 0;
+function assert(condition, message) {
+    if (!condition) {
+        console.error(`❌ FAIL: ${message}`);
+        testsFailed++;
+        throw new Error(message);
+    }
+    console.log(`✅ PASS: ${message}`);
+    testsPassed++;
+}
+function assertThrows(fn, message) {
+    try {
+        fn();
+        console.error(`❌ FAIL: ${message} (expected to throw)`);
+        testsFailed++;
+    }
+    catch {
+        console.log(`✅ PASS: ${message}`);
+        testsPassed++;
+    }
+}
+// ============================================================================
+// Test: BEEF format validation
+// ============================================================================
+async function testBeefFormat() {
+    console.log('\n=== Test: BEEF Format Validation ===');
+    // Create a minimal transaction chain
+    const privKey = PrivateKey.fromRandom();
+    const pubKeyHash = privKey.toPublicKey().toHash();
+    // Source transaction (simulating a mined tx with merkle proof)
+    const sourceTx = new Transaction();
+    sourceTx.addOutput({
+        lockingScript: new P2PKH().lock(pubKeyHash),
+        satoshis: 10000,
+    });
+    // Spending transaction with PushDrop output
+    const tx = new Transaction();
+    tx.addInput({
+        sourceTransaction: sourceTx,
+        sourceOutputIndex: 0,
+        unlockingScriptTemplate: new P2PKH().unlock(privKey),
+    });
+    tx.addOutput({
+        lockingScript: buildPushDropScript(privKey, { protocol: PROTOCOL_ID, type: 'identity', test: true }),
+        satoshis: 1,
+    });
+    await tx.sign();
+    // Build BEEF
+    const beef = new Beef();
+    beef.mergeTransaction(tx);
+    const binary = beef.toBinary();
+    // Validate BEEF magic bytes
+    const magic = binary.slice(0, 4);
+    const magicHex = magic.map(b => b.toString(16).padStart(2, '0')).join('');
+    assert(magicHex === '0100beef' || magicHex === '0200beef', `BEEF magic bytes should be 0100beef or 0200beef, got ${magicHex}`);
+    // Validate BEEF can be parsed
+    const parsed = Beef.fromBinary(binary);
+    assert(parsed.txs.length >= 1, `BEEF should contain at least 1 transaction, got ${parsed.txs.length}`);
+    // Validate the newest transaction can be found in BEEF
+    const beefTx = parsed.txs[0];
+    const newestTxid = beefTx.txid || beefTx._tx?.id('hex');
+    assert(newestTxid === tx.id('hex'), `Newest transaction in BEEF should match original, got ${newestTxid?.slice(0, 16)}`);
+}
+// ============================================================================
+// Test: Identity payload validation
+// ============================================================================
+async function testIdentityPayload() {
+    console.log('\n=== Test: Identity Payload Validation ===');
+    const privKey = PrivateKey.fromRandom();
+    const identityKey = privKey.toPublicKey().toString();
+    // Valid identity payload
+    const validPayload = {
+        protocol: PROTOCOL_ID,
+        type: 'identity',
+        identityKey,
+        name: 'test-agent',
+        description: 'A test agent',
+        channels: { overlay: 'https://example.com' },
+        capabilities: ['test'],
+        timestamp: new Date().toISOString(),
+    };
+    const script = buildPushDropScript(privKey, validPayload);
+    const parsed = parseIdentityOutput(script);
+    assert(parsed !== null, 'Valid identity payload should be parsed');
+    assert(parsed.identityKey === identityKey, 'Identity key should match');
+    assert(parsed.name === 'test-agent', 'Name should match');
+    assert(parsed.type === 'identity', 'Type should be identity');
+    // Invalid: wrong protocol
+    const wrongProtocol = { ...validPayload, protocol: 'wrong-protocol' };
+    const script2 = buildPushDropScript(privKey, wrongProtocol);
+    assert(parseIdentityOutput(script2) === null, 'Wrong protocol should be rejected');
+    // Invalid: wrong type
+    const wrongType = { ...validPayload, type: 'service' };
+    const script3 = buildPushDropScript(privKey, wrongType);
+    assert(parseIdentityOutput(script3) === null, 'Wrong type should be rejected');
+    // Invalid: bad identity key
+    const badKey = { ...validPayload, identityKey: 'not-a-valid-key' };
+    const script4 = buildPushDropScript(privKey, badKey);
+    assert(parseIdentityOutput(script4) === null, 'Invalid identity key should be rejected');
+    // Invalid: empty name
+    const emptyName = { ...validPayload, name: '' };
+    const script5 = buildPushDropScript(privKey, emptyName);
+    assert(parseIdentityOutput(script5) === null, 'Empty name should be rejected');
+    // Invalid: capabilities not array
+    const badCaps = { ...validPayload, capabilities: 'not-array' };
+    const script6 = buildPushDropScript(privKey, badCaps);
+    assert(parseIdentityOutput(script6) === null, 'Non-array capabilities should be rejected');
+}
+// ============================================================================
+// Test: Service payload validation
+// ============================================================================
+async function testServicePayload() {
+    console.log('\n=== Test: Service Payload Validation ===');
+    const privKey = PrivateKey.fromRandom();
+    const identityKey = privKey.toPublicKey().toString();
+    // Valid service payload
+    const validPayload = {
+        protocol: PROTOCOL_ID,
+        type: 'service',
+        identityKey,
+        serviceId: 'test-service',
+        name: 'Test Service',
+        description: 'A test service',
+        pricing: { model: 'per-task', amountSats: 100 },
+        timestamp: new Date().toISOString(),
+    };
+    const script = buildPushDropScript(privKey, validPayload);
+    const parsed = parseServiceOutput(script);
+    assert(parsed !== null, 'Valid service payload should be parsed');
+    assert(parsed.serviceId === 'test-service', 'Service ID should match');
+    assert(parsed.pricing.amountSats === 100, 'Price should match');
+    // Invalid: missing pricing
+    const noPricing = { ...validPayload, pricing: undefined };
+    const script2 = buildPushDropScript(privKey, noPricing);
+    assert(parseServiceOutput(script2) === null, 'Missing pricing should be rejected');
+    // Invalid: empty serviceId
+    const emptyId = { ...validPayload, serviceId: '' };
+    const script3 = buildPushDropScript(privKey, emptyId);
+    assert(parseServiceOutput(script3) === null, 'Empty serviceId should be rejected');
+}
+// ============================================================================
+// Test: Full BEEF submission simulation
+// ============================================================================
+async function testBeefSubmission() {
+    console.log('\n=== Test: BEEF Submission Simulation ===');
+    const privKey = PrivateKey.fromRandom();
+    const pubKeyHash = privKey.toPublicKey().toHash();
+    const identityKey = privKey.toPublicKey().toString();
+    // Create source transaction (simulating confirmed tx)
+    const sourceTx = new Transaction();
+    sourceTx.addOutput({
+        lockingScript: new P2PKH().lock(pubKeyHash),
+        satoshis: 10000,
+    });
+    // Valid identity registration
+    const identityPayload = {
+        protocol: PROTOCOL_ID,
+        type: 'identity',
+        identityKey,
+        name: 'test-agent',
+        description: 'Test agent for unit tests',
+        channels: { overlay: 'https://clawoverlay.com' },
+        capabilities: ['testing'],
+        timestamp: new Date().toISOString(),
+    };
+    const tx = new Transaction();
+    tx.addInput({
+        sourceTransaction: sourceTx,
+        sourceOutputIndex: 0,
+        unlockingScriptTemplate: new P2PKH().unlock(privKey),
+    });
+    tx.addOutput({
+        lockingScript: buildPushDropScript(privKey, identityPayload),
+        satoshis: 1,
+    });
+    tx.addOutput({
+        lockingScript: new P2PKH().lock(pubKeyHash),
+        satoshis: 9900,
+    });
+    await tx.sign();
+    // Build BEEF with ancestry
+    const beef = new Beef();
+    beef.mergeTransaction(tx);
+    const beefBinary = beef.toBinary();
+    // Simulate server's topic manager
+    const result = identifyAdmissibleOutputs(beefBinary, 'identity');
+    assert(result.outputsToAdmit.length === 1, `Should admit 1 output, got ${result.outputsToAdmit.length}`);
+    assert(result.outputsToAdmit[0] === 0, 'Should admit output index 0 (PushDrop)');
+}
+// ============================================================================
+// Test: Chained transactions (stored BEEF)
+// ============================================================================
+async function testChainedBeef() {
+    console.log('\n=== Test: Chained BEEF (multiple unconfirmed txs) ===');
+    const privKey = PrivateKey.fromRandom();
+    const pubKeyHash = privKey.toPublicKey().toHash();
+    const identityKey = privKey.toPublicKey().toString();
+    // Grandparent tx (simulating mined tx - would have merkle proof)
+    const grandparentTx = new Transaction();
+    grandparentTx.addOutput({
+        lockingScript: new P2PKH().lock(pubKeyHash),
+        satoshis: 100000,
+    });
+    // Parent tx (first overlay submission - unconfirmed)
+    const parentTx = new Transaction();
+    parentTx.addInput({
+        sourceTransaction: grandparentTx,
+        sourceOutputIndex: 0,
+        unlockingScriptTemplate: new P2PKH().unlock(privKey),
+    });
+    parentTx.addOutput({
+        lockingScript: buildPushDropScript(privKey, {
+            protocol: PROTOCOL_ID,
+            type: 'identity',
+            identityKey,
+            name: 'parent-tx',
+            description: 'First registration',
+            channels: {},
+            capabilities: [],
+            timestamp: new Date().toISOString(),
+        }),
+        satoshis: 1,
+    });
+    parentTx.addOutput({
+        lockingScript: new P2PKH().lock(pubKeyHash),
+        satoshis: 99900,
+    });
+    await parentTx.sign();
+    // Child tx (second overlay submission - spending parent's change)
+    const childTx = new Transaction();
+    childTx.addInput({
+        sourceTransaction: parentTx,
+        sourceOutputIndex: 1, // Spend the change output
+        unlockingScriptTemplate: new P2PKH().unlock(privKey),
+    });
+    childTx.addOutput({
+        lockingScript: buildPushDropScript(privKey, {
+            protocol: PROTOCOL_ID,
+            type: 'service',
+            identityKey,
+            serviceId: 'test-svc',
+            name: 'Test Service',
+            description: 'Service from child tx',
+            pricing: { model: 'per-task', amountSats: 50 },
+            timestamp: new Date().toISOString(),
+        }),
+        satoshis: 1,
+    });
+    childTx.addOutput({
+        lockingScript: new P2PKH().lock(pubKeyHash),
+        satoshis: 99800,
+    });
+    await childTx.sign();
+    // Build BEEF - should include full chain
+    const beef = new Beef();
+    beef.mergeTransaction(childTx);
+    const beefBinary = beef.toBinary();
+    // Verify BEEF contains all transactions
+    const parsedBeef = Beef.fromBinary(beefBinary);
+    assert(parsedBeef.txs.length >= 2, `BEEF should contain at least 2 txs for chain, got ${parsedBeef.txs.length}`);
+    // Verify child tx is the newest in BEEF
+    const beefTx = parsedBeef.txs[0];
+    const newestTxid = beefTx.txid || beefTx._tx?.id('hex');
+    assert(newestTxid === childTx.id('hex'), 'Newest tx in BEEF should be the child transaction');
+    // Simulate server validation
+    const result = identifyAdmissibleOutputs(beefBinary, 'service');
+    assert(result.outputsToAdmit.length === 1, 'Should admit the service output');
+}
+// ============================================================================
+// Test: Invalid BEEF handling
+// ============================================================================
+async function testInvalidBeef() {
+    console.log('\n=== Test: Invalid BEEF Handling ===');
+    // Empty BEEF
+    const emptyBeef = new Beef();
+    const emptyBinary = emptyBeef.toBinary();
+    assertThrows(() => Transaction.fromBEEF(emptyBinary), 'Empty BEEF should throw when extracting transaction');
+    // Malformed BEEF (random bytes)
+    const garbage = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
+    assertThrows(() => Beef.fromBinary(Array.from(garbage)), 'Garbage bytes should throw when parsing BEEF');
+    // BEEF with wrong magic
+    const wrongMagic = new Uint8Array([0xDE, 0xAD, 0xBE, 0xEF, 0, 0]);
+    assertThrows(() => Beef.fromBinary(Array.from(wrongMagic)), 'Wrong magic bytes should throw when parsing BEEF');
+}
+// ============================================================================
+// Main test runner
+// ============================================================================
+async function runTests() {
+    console.log('Starting overlay submit tests (PushDrop format)...\n');
+    try {
+        await testBeefFormat();
+        await testIdentityPayload();
+        await testServicePayload();
+        await testBeefSubmission();
+        await testChainedBeef();
+        await testInvalidBeef();
+        console.log(`\n========================================`);
+        console.log(`Tests completed: ${testsPassed} passed, ${testsFailed} failed`);
+        console.log(`========================================`);
+        if (testsFailed > 0) {
+            process.exit(1);
+        }
+    }
+    catch (e) {
+        console.error('\nTest suite failed:', e);
+        process.exit(1);
+    }
+}
+runTests();

package/dist/test/request-response-flow.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for request/response flow and duplicate prevention.
+ */
+declare function run(): Promise<void>;
+export { run };

package/dist/test/request-response-flow.test.js

@@ -0,0 +1,209 @@
+/**
+ * Tests for request/response flow and duplicate prevention.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+// Simple test runner (matching existing pattern)
+let passed = 0;
+let failed = 0;
+function test(name, fn) {
+    return (async () => {
+        try {
+            await fn();
+            console.log(`  ✓ ${name}`);
+            passed++;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.log(`  ✗ ${name}`);
+            console.log(`    ${msg}`);
+            failed++;
+        }
+    })();
+}
+function assert(condition, message) {
+    if (!condition)
+        throw new Error(`Assertion failed: ${message}`);
+}
+// Mock paths for testing
+const TEST_DIR = path.join(process.cwd(), 'test-data');
+const TEST_PATHS = {
+    serviceQueue: path.join(TEST_DIR, 'service-queue.jsonl'),
+    walletDir: path.join(TEST_DIR, 'wallet'),
+    registration: path.join(TEST_DIR, 'registration.json'),
+    services: path.join(TEST_DIR, 'services.json'),
+};
+function setupTestEnv() {
+    // Setup test directory
+    if (fs.existsSync(TEST_DIR)) {
+        fs.rmSync(TEST_DIR, { recursive: true, force: true });
+    }
+    fs.mkdirSync(TEST_DIR, { recursive: true });
+}
+function cleanupTestEnv() {
+    if (fs.existsSync(TEST_DIR)) {
+        fs.rmSync(TEST_DIR, { recursive: true, force: true });
+    }
+}
+async function run() {
+    console.log('\nRequest/Response Flow Tests\n');
+    // ── Queue Cleanup Tests ──────────────────────────────────────────────
+    await test('cleanupServiceQueue removes old fulfilled entries', async () => {
+        setupTestEnv();
+        const now = Date.now();
+        const oldTime = now - (3 * 60 * 60 * 1000); // 3 hours ago
+        const recentTime = now - (30 * 60 * 1000); // 30 minutes ago
+        // Add test entries
+        const entries = [
+            { status: 'pending', requestId: 'pending-1', _ts: recentTime },
+            { status: 'fulfilled', requestId: 'old-fulfilled', _ts: oldTime },
+            { status: 'fulfilled', requestId: 'recent-fulfilled', _ts: recentTime },
+            { status: 'rejected', requestId: 'old-rejected', _ts: oldTime }
+        ];
+        const content = entries.map(e => JSON.stringify(e)).join('\n') + '\n';
+        fs.writeFileSync(TEST_PATHS.serviceQueue, content);
+        // Mock PATHS for cleanupServiceQueue
+        const originalPaths = await import('../scripts/config.js');
+        const mockPaths = { ...originalPaths.PATHS, serviceQueue: TEST_PATHS.serviceQueue };
+        // Temporarily replace PATHS
+        globalThis.mockPaths = mockPaths;
+        // Redefine cleanupServiceQueue with mocked paths
+        function mockCleanupServiceQueue(maxAgeMs = 24 * 60 * 60 * 1000, finalStatusMaxAgeMs = 2 * 60 * 60 * 1000) {
+            if (!fs.existsSync(TEST_PATHS.serviceQueue))
+                return;
+            const currentTime = Date.now();
+            const finalStatuses = ['fulfilled', 'rejected', 'delivery_failed', 'failed', 'error'];
+            const lines = fs.readFileSync(TEST_PATHS.serviceQueue, 'utf-8').trim().split('\n').filter(Boolean);
+            const keptLines = [];
+            let removedCount = 0;
+            for (const line of lines) {
+                try {
+                    const entry = JSON.parse(line);
+                    const entryAge = currentTime - (entry._ts || 0);
+                    // Always keep pending entries that aren't too old
+                    if (entry.status === 'pending' && entryAge < maxAgeMs) {
+                        keptLines.push(line);
+                        continue;
+                    }
+                    // Keep final status entries only if they're recent
+                    if (finalStatuses.includes(entry.status) && entryAge < finalStatusMaxAgeMs) {
+                        keptLines.push(line);
+                        continue;
+                    }
+                    // Remove this entry
+                    removedCount++;
+                }
+                catch {
+                    // Keep malformed entries to avoid data loss
+                    keptLines.push(line);
+                }
+            }
+            if (removedCount > 0) {
+                fs.writeFileSync(TEST_PATHS.serviceQueue, keptLines.join('\n') + (keptLines.length ? '\n' : ''));
+            }
+        }
+        // Run cleanup with 2 hour limit for final statuses
+        mockCleanupServiceQueue(24 * 60 * 60 * 1000, 2 * 60 * 60 * 1000);
+        // Check remaining entries
+        const lines = fs.readFileSync(TEST_PATHS.serviceQueue, 'utf-8').trim().split('\n').filter(Boolean);
+        const remaining = lines.map(line => JSON.parse(line));
+        assert(remaining.length === 2, `Expected 2 remaining entries, got ${remaining.length}`);
+        assert(remaining.find(e => e.requestId === 'pending-1') !== undefined, 'Should keep recent pending');
+        assert(remaining.find(e => e.requestId === 'recent-fulfilled') !== undefined, 'Should keep recent fulfilled');
+        assert(remaining.find(e => e.requestId === 'old-fulfilled') === undefined, 'Should remove old fulfilled');
+        assert(remaining.find(e => e.requestId === 'old-rejected') === undefined, 'Should remove old rejected');
+        cleanupTestEnv();
+    });
+    await test('updateServiceQueueStatus updates request status atomically', async () => {
+        setupTestEnv();
+        // Add a test entry
+        const entry = {
+            status: 'pending',
+            requestId: 'test-request-456',
+            serviceId: 'test-service',
+            from: 'sender-key',
+            _ts: Date.now()
+        };
+        fs.writeFileSync(TEST_PATHS.serviceQueue, JSON.stringify(entry) + '\n');
+        // Mock updateServiceQueueStatus with test paths
+        function mockUpdateServiceQueueStatus(requestId, newStatus, additionalFields = {}) {
+            if (!fs.existsSync(TEST_PATHS.serviceQueue))
+                return false;
+            const lines = fs.readFileSync(TEST_PATHS.serviceQueue, 'utf-8').trim().split('\n').filter(Boolean);
+            let updated = false;
+            const updatedLines = lines.map(line => {
+                try {
+                    const entryData = JSON.parse(line);
+                    if (entryData.requestId === requestId) {
+                        updated = true;
+                        return JSON.stringify({
+                            ...entryData,
+                            status: newStatus,
+                            ...additionalFields,
+                            updatedAt: Date.now()
+                        });
+                    }
+                    return line;
+                }
+                catch {
+                    return line;
+                }
+            });
+            if (updated) {
+                fs.writeFileSync(TEST_PATHS.serviceQueue, updatedLines.join('\n') + '\n');
+            }
+            return updated;
+        }
+        // Update status
+        const updated = mockUpdateServiceQueueStatus('test-request-456', 'fulfilled', {
+            fulfilledAt: Date.now(),
+            result: { message: 'success' }
+        });
+        assert(updated === true, 'Should return true for successful update');
+        // Verify update
+        const lines = fs.readFileSync(TEST_PATHS.serviceQueue, 'utf-8').trim().split('\n').filter(Boolean);
+        const updatedEntry = JSON.parse(lines[0]);
+        assert(updatedEntry.status === 'fulfilled', 'Status should be updated to fulfilled');
+        assert(updatedEntry.requestId === 'test-request-456', 'Request ID should remain the same');
+        assert(updatedEntry.fulfilledAt !== undefined, 'Should have fulfilledAt timestamp');
+        assert(updatedEntry.updatedAt !== undefined, 'Should have updatedAt timestamp');
+        assert(updatedEntry.result?.message === 'success', 'Should have result data');
+        cleanupTestEnv();
+    });
+    await test('updateServiceQueueStatus returns false for non-existent request', async () => {
+        setupTestEnv();
+        // Mock updateServiceQueueStatus with test paths
+        function mockUpdateServiceQueueStatus(requestId, _newStatus) {
+            if (!fs.existsSync(TEST_PATHS.serviceQueue))
+                return false;
+            const lines = fs.readFileSync(TEST_PATHS.serviceQueue, 'utf-8').trim().split('\n').filter(Boolean);
+            let updated = false;
+            lines.map(line => {
+                try {
+                    const entry = JSON.parse(line);
+                    if (entry.requestId === requestId) {
+                        updated = true;
+                    }
+                    return line;
+                }
+                catch {
+                    return line;
+                }
+            });
+            return updated;
+        }
+        const updated = mockUpdateServiceQueueStatus('non-existent-request', 'fulfilled');
+        assert(updated === false, 'Should return false for non-existent request');
+        cleanupTestEnv();
+    });
+    // ── Summary ──────────────────────────────────────────────────────────
+    console.log(`\n${passed} passed, ${failed} failed\n`);
+    if (failed > 0) {
+        process.exit(1);
+    }
+}
+// Run tests if this file is executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+    run().catch(console.error);
+}
+export { run };

package/dist/test/service-system.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Service system comprehensive tests.
+ * Tests service registration, loading, validation, and execution.
+ */
+export {};