@vibecodetown/mcp-server 1.3.1 → 1.5.0

package/build/native/bloom-wrapper.js

@@ -0,0 +1,120 @@
+/**
+ * Bloom Filter Wrapper
+ *
+ * Provides a unified API that uses native bindings when available,
+ * with a pure JavaScript fallback.
+ */
+import { loadNative, isNativeAvailable } from './loader.js';
+/**
+ * Pure JavaScript Bloom Filter implementation for fallback.
+ */
+class JsBloomFilter {
+    bits;
+    numHashes;
+    itemCount;
+    constructor(size, numHashes) {
+        this.bits = new Uint8Array(Math.ceil(size / 8));
+        this.numHashes = numHashes;
+        this.itemCount = 0;
+    }
+    insert(item) {
+        for (let i = 0; i < this.numHashes; i++) {
+            const index = this.hashIndex(item, i);
+            const byteIndex = Math.floor(index / 8);
+            const bitIndex = index % 8;
+            this.bits[byteIndex] |= 1 << bitIndex;
+        }
+        this.itemCount++;
+    }
+    contains(item) {
+        for (let i = 0; i < this.numHashes; i++) {
+            const index = this.hashIndex(item, i);
+            const byteIndex = Math.floor(index / 8);
+            const bitIndex = index % 8;
+            if ((this.bits[byteIndex] & (1 << bitIndex)) === 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+    merge(other) {
+        if (this.bits.length !== other.bits.length) {
+            throw new Error('Cannot merge bloom filters of different sizes');
+        }
+        for (let i = 0; i < this.bits.length; i++) {
+            this.bits[i] |= other.bits[i];
+        }
+        this.itemCount += other.itemCount;
+    }
+    count() {
+        return this.itemCount;
+    }
+    size() {
+        return this.bits.length * 8;
+    }
+    estimatedFalsePositiveRate() {
+        let ones = 0;
+        for (let i = 0; i < this.bits.length; i++) {
+            for (let j = 0; j < 8; j++) {
+                if ((this.bits[i] & (1 << j)) !== 0)
+                    ones++;
+            }
+        }
+        const fillRatio = ones / (this.bits.length * 8);
+        return Math.pow(fillRatio, this.numHashes);
+    }
+    clear() {
+        this.bits.fill(0);
+        this.itemCount = 0;
+    }
+    toBytes() {
+        const sizeBytes = Buffer.alloc(4);
+        sizeBytes.writeUInt32LE(this.bits.length * 8, 0);
+        const header = Buffer.alloc(5);
+        header.writeUInt32LE(this.bits.length * 8, 0);
+        header.writeUInt8(this.numHashes, 4);
+        const countBytes = Buffer.alloc(4);
+        countBytes.writeUInt32LE(this.itemCount, 0);
+        return Buffer.concat([header, countBytes, Buffer.from(this.bits)]);
+    }
+    hashIndex(item, seed) {
+        let hash = seed;
+        for (let i = 0; i < item.length; i++) {
+            hash = ((hash << 5) - hash + item.charCodeAt(i)) | 0;
+        }
+        return Math.abs(hash) % (this.bits.length * 8);
+    }
+}
+/**
+ * Create a Bloom Filter using native bindings if available,
+ * otherwise use JavaScript fallback.
+ *
+ * @param size - Number of bits in the filter
+ * @param numHashes - Number of hash functions to use
+ */
+export function createBloomFilter(size, numHashes) {
+    const native = loadNative();
+    if (native) {
+        return new native.BloomFilter(size, numHashes);
+    }
+    return new JsBloomFilter(size, numHashes);
+}
+/**
+ * Create a Bloom Filter optimized for expected items and false positive rate.
+ * Only available with native bindings, falls back to default JS implementation.
+ *
+ * @param expectedItems - Expected number of items
+ * @param falsePositiveRate - Desired false positive rate (e.g., 0.01 for 1%)
+ */
+export function createBloomFilterWithRate(expectedItems, falsePositiveRate) {
+    // Calculate optimal size and hash count
+    const m = Math.ceil((-expectedItems * Math.log(falsePositiveRate)) / Math.pow(Math.log(2), 2));
+    const k = Math.ceil((m / expectedItems) * Math.log(2));
+    return createBloomFilter(Math.max(64, m), Math.max(1, Math.min(16, k)));
+}
+/**
+ * Check if native Bloom Filter is being used.
+ */
+export function isNativeBloomFilter() {
+    return isNativeAvailable();
+}

package/build/native/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Native Module Exports
+ *
+ * Re-exports all native bindings and wrappers with fallbacks.
+ */
+export { loadNative, isNativeAvailable, getNativeLoadError, getNativePlatformInfo, type NativeModule, type NativeBloomFilter, type NativeAntiEntropyManager, type NativeSyncStats, type NativeMerkleTree, type NativeMerkleTreeConstructor, type NativeMerkleProof, type NativeMerkleProofStep, type NativeScoutDispatcher, } from './loader.js';
+export { createBloomFilter, createBloomFilterWithRate, isNativeBloomFilter, type BloomFilter, } from './bloom-wrapper.js';
+export { createMerkleTree, createMerkleTreeFromBlockIds, verifyMerkleProof, isNativeMerkleTree, type MerkleTree, type MerkleProof, type MerkleProofStep, type ProofDirection, } from './merkle-wrapper.js';
+export { createNativeBlockStoreWriter, isNativeBlockStoreWriter, type BlockStoreWriter, type WriteBlockResult, type CreateChainResult, type BlockInput, } from './block-writer-wrapper.js';
+export { computeBlockId, computeRootHash, sha256Hex, isValidBlockId, isValidRootHash, } from './utils-wrapper.js';
+export { initScoutSingleton, dispatchScout, buildScoutPrompt, isScoutAvailable, isBitNetAvailable, saveScoutReport, type ScoutTriggerInput, type ScoutReportOutput, } from './scout-wrapper.js';

package/build/native/index.js

@@ -0,0 +1,17 @@
+/**
+ * Native Module Exports
+ *
+ * Re-exports all native bindings and wrappers with fallbacks.
+ */
+// Loader utilities
+export { loadNative, isNativeAvailable, getNativeLoadError, getNativePlatformInfo, } from './loader.js';
+// Bloom Filter with fallback
+export { createBloomFilter, createBloomFilterWithRate, isNativeBloomFilter, } from './bloom-wrapper.js';
+// MerkleTree with fallback
+export { createMerkleTree, createMerkleTreeFromBlockIds, verifyMerkleProof, isNativeMerkleTree, } from './merkle-wrapper.js';
+// BlockStoreWriter (native-only, no JS fallback — use BlockStore from blocks/store.ts)
+export { createNativeBlockStoreWriter, isNativeBlockStoreWriter, } from './block-writer-wrapper.js';
+// Utility functions with fallback
+export { computeBlockId, computeRootHash, sha256Hex, isValidBlockId, isValidRootHash, } from './utils-wrapper.js';
+// Scout Dispatcher with fallback
+export { initScoutSingleton, dispatchScout, buildScoutPrompt, isScoutAvailable, isBitNetAvailable, saveScoutReport, } from './scout-wrapper.js';

package/build/native/loader.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Native Module Loader
+ *
+ * Loads platform-specific native bindings for musu-node-bridge.
+ * Falls back gracefully if native bindings are not available.
+ */
+/**
+ * Native module interface matching musu-node-bridge exports.
+ */
+export interface NativeModule {
+    BloomFilter: new (size: number, numHashes: number) => NativeBloomFilter;
+    AntiEntropyManager: new (nodeId: string) => NativeAntiEntropyManager;
+    MerkleTree: NativeMerkleTreeConstructor;
+    BlockStoreWriter: new (workspaceRoot: string) => NativeBlockStoreWriter;
+    ScoutDispatcher: new (workspaceRoot: string) => NativeScoutDispatcher;
+    getVersion(): string;
+    isNative(): boolean;
+    getPlatform(): string;
+    computeBlockId(content: string, sourceRef: string): string;
+    computeRootHash(sourcePath: string): string;
+    sha256Hex(input: string): string;
+    isValidBlockId(blockId: string): boolean;
+    isValidRootHash(rootHash: string): boolean;
+    verifyMerkleProof(blockId: string, proof: NativeMerkleProof, expectedRoot: string): boolean;
+    initScout(workspaceRoot: string): boolean;
+    isScoutInitialized(): boolean;
+    isBitnetReady(): boolean;
+    dispatchScoutAction(triggerJson: string): Promise<{
+        scenario: string;
+        blockId: string;
+        rootHash: string;
+        analysis: string;
+        latencyMs: number;
+        tokens: number;
+        timestamp: number;
+    }>;
+    saveScoutReport(analysisJson: string, scenario: string): string;
+}
+export interface NativeBloomFilter {
+    insert(item: string): void;
+    contains(item: string): boolean;
+    merge(other: NativeBloomFilter): void;
+    count(): number;
+    size(): number;
+    estimatedFalsePositiveRate(): number;
+    clear(): void;
+    toBytes(): Buffer;
+}
+export interface NativeAntiEntropyManager {
+    addBlock(blockId: string): void;
+    removeBlock(blockId: string): void;
+    hasBlock(blockId: string): boolean;
+    localBlockCount(): number;
+    nodeId(): string;
+    getBloomBytes(): Buffer;
+    findMissingBlocks(peerBloomBytes: Buffer): string[];
+    getStats(): NativeSyncStats;
+}
+export interface NativeSyncStats {
+    roundsCompleted: number;
+    blocksSynced: number;
+    blocksSent: number;
+    roundsFailed: number;
+}
+export interface NativeMerkleTreeConstructor {
+    new (): NativeMerkleTree;
+    fromBlockIds(ids: string[]): NativeMerkleTree;
+}
+export interface NativeMerkleTree {
+    rootHash(): string;
+    contains(blockId: string): boolean;
+    len(): number;
+    isEmpty(): boolean;
+    addBlock(blockId: string): void;
+    getProof(blockId: string): NativeMerkleProof | null;
+}
+export interface NativeMerkleProofStep {
+    siblingHash: string;
+    direction: string;
+}
+export interface NativeMerkleProof {
+    blockId: string;
+    path: NativeMerkleProofStep[];
+    root: string;
+}
+export interface NativeBlockStoreWriter {
+    put(blockJson: string): {
+        blockId: string;
+        stored: boolean;
+    };
+    has(blockId: string): boolean;
+    delete(blockId: string): boolean;
+    createChain(sourcePath: string, blocksJson: string): {
+        rootHash: string;
+        storedCount: number;
+        skippedCount: number;
+    };
+    putChain(chainJson: string): void;
+    deleteChain(rootHash: string): boolean;
+    invalidateCache(): void;
+    getIndexJson(): string;
+}
+export interface NativeScoutDispatcher {
+    isAvailable(): boolean;
+    buildPrompt(triggerJson: string): string;
+    dispatch(triggerJson: string): {
+        scenario: string;
+        blockId: string;
+        rootHash: string;
+        analysis: string;
+        latencyMs: number;
+        tokens: number;
+        timestamp: number;
+    };
+}
+/**
+ * Attempt to load the native module.
+ * Returns the module if successful, null otherwise.
+ */
+export declare function loadNative(): NativeModule | null;
+/**
+ * Check if native bindings are available.
+ */
+export declare function isNativeAvailable(): boolean;
+/**
+ * Get the error that occurred when loading native module.
+ */
+export declare function getNativeLoadError(): Error | null;
+/**
+ * Get platform info for diagnostics.
+ */
+export declare function getNativePlatformInfo(): {
+    platform: string;
+    arch: string;
+    overridePath: string | null;
+    packageName: string | null;
+    available: boolean;
+    error: string | null;
+};

package/build/native/loader.js

@@ -0,0 +1,116 @@
+/**
+ * Native Module Loader
+ *
+ * Loads platform-specific native bindings for musu-node-bridge.
+ * Falls back gracefully if native bindings are not available.
+ */
+import { platform, arch } from 'os';
+import { readFileSync } from 'fs';
+import { createRequire } from 'module';
+import { resolve, isAbsolute } from 'path';
+// Create require function for loading native modules in ESM context
+const require = createRequire(import.meta.url);
+function getNativeOverridePath() {
+    const raw = process.env.MUSU_NATIVE_BINDING_PATH?.trim();
+    if (!raw)
+        return null;
+    return isAbsolute(raw) ? raw : resolve(process.cwd(), raw);
+}
+// Cache for loaded module
+let nativeModule = null;
+let loadError = null;
+let loadAttempted = false;
+/**
+ * Detect if running on musl-based Linux (e.g., Alpine).
+ */
+function isMusl() {
+    if (platform() !== 'linux')
+        return false;
+    try {
+        return readFileSync('/proc/self/maps', 'utf8').includes('musl');
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get the platform-specific package name.
+ */
+function getPlatformPackage() {
+    const p = platform();
+    const a = arch();
+    // Linux has separate gnu and musl builds
+    if (p === 'linux' && a === 'x64') {
+        return isMusl() ? '@vibecodetown/musu-linux-x64-musl' : '@vibecodetown/musu-linux-x64-gnu';
+    }
+    const mapping = {
+        'linux-arm64': '@vibecodetown/musu-linux-arm64-gnu',
+        'darwin-x64': '@vibecodetown/musu-darwin-x64',
+        'darwin-arm64': '@vibecodetown/musu-darwin-arm64',
+        'win32-x64': '@vibecodetown/musu-win32-x64-msvc',
+    };
+    return mapping[`${p}-${a}`] || null;
+}
+/**
+ * Attempt to load the native module.
+ * Returns the module if successful, null otherwise.
+ */
+export function loadNative() {
+    if (loadAttempted) {
+        return nativeModule;
+    }
+    loadAttempted = true;
+    // CI/testing override: allow loading a specific local .node file path.
+    // This lets us validate the freshly built binding artifact in CI without relying on published optionalDependencies.
+    const overridePath = getNativeOverridePath();
+    if (overridePath) {
+        try {
+            nativeModule = require(overridePath);
+            return nativeModule;
+        }
+        catch (e) {
+            loadError = e;
+            return null;
+        }
+    }
+    const pkg = getPlatformPackage();
+    if (!pkg) {
+        loadError = new Error(`Unsupported platform: ${platform()}-${arch()}`);
+        return null;
+    }
+    try {
+        // Load native module using createRequire (required for .node files in ESM)
+        nativeModule = require(pkg);
+        return nativeModule;
+    }
+    catch (e) {
+        loadError = e;
+        return null;
+    }
+}
+/**
+ * Check if native bindings are available.
+ */
+export function isNativeAvailable() {
+    return loadNative() !== null;
+}
+/**
+ * Get the error that occurred when loading native module.
+ */
+export function getNativeLoadError() {
+    loadNative(); // Ensure load was attempted
+    return loadError;
+}
+/**
+ * Get platform info for diagnostics.
+ */
+export function getNativePlatformInfo() {
+    return {
+        platform: platform(),
+        arch: arch(),
+        overridePath: getNativeOverridePath(),
+        packageName: getPlatformPackage(),
+        available: isNativeAvailable(),
+        error: loadError?.message || null,
+    };
+}

package/build/native/merkle-wrapper.d.ts

@@ -0,0 +1,47 @@
+/**
+ * MerkleTree Wrapper
+ *
+ * Provides a unified API that uses native bindings when available,
+ * with a pure JavaScript fallback using crypto.createHash('sha256').
+ */
+/** Direction in a Merkle proof path */
+export type ProofDirection = 'left' | 'right';
+/** A single step in a Merkle proof */
+export interface MerkleProofStep {
+    siblingHash: string;
+    direction: ProofDirection;
+}
+/** A Merkle proof for verifying block membership */
+export interface MerkleProof {
+    blockId: string;
+    path: MerkleProofStep[];
+    root: string;
+}
+/** Unified MerkleTree interface */
+export interface MerkleTree {
+    rootHash(): string;
+    contains(blockId: string): boolean;
+    len(): number;
+    isEmpty(): boolean;
+    addBlock(blockId: string): void;
+    getProof(blockId: string): MerkleProof | null;
+}
+/**
+ * Create an empty MerkleTree.
+ * Uses native bindings if available, otherwise JS fallback.
+ */
+export declare function createMerkleTree(): MerkleTree;
+/**
+ * Create a MerkleTree from an array of block IDs.
+ * Uses native bindings if available, otherwise JS fallback.
+ */
+export declare function createMerkleTreeFromBlockIds(blockIds: string[]): MerkleTree;
+/**
+ * Verify a Merkle proof against an expected root hash.
+ * Uses native bindings if available, otherwise JS fallback.
+ */
+export declare function verifyMerkleProof(blockId: string, proof: MerkleProof, expectedRoot: string): boolean;
+/**
+ * Check if native MerkleTree is being used.
+ */
+export declare function isNativeMerkleTree(): boolean;

package/build/native/merkle-wrapper.js

@@ -0,0 +1,203 @@
+/**
+ * MerkleTree Wrapper
+ *
+ * Provides a unified API that uses native bindings when available,
+ * with a pure JavaScript fallback using crypto.createHash('sha256').
+ */
+import { createHash } from 'node:crypto';
+import { loadNative, isNativeAvailable } from './loader.js';
+// --- JS fallback helpers (same domain separators as Rust) ---
+function hashLeaf(blockId) {
+    return createHash('sha256').update('merkle_leaf:').update(blockId).digest('hex');
+}
+function hashPair(left, right) {
+    return createHash('sha256').update('merkle_node:').update(left).update(right).digest('hex');
+}
+function buildTree(blockIds) {
+    if (blockIds.length === 1) {
+        return { hash: hashLeaf(blockIds[0]), left: null, right: null };
+    }
+    let nodes = blockIds.map(id => ({
+        hash: hashLeaf(id),
+        left: null,
+        right: null,
+    }));
+    if (nodes.length % 2 === 1) {
+        nodes.push({ ...nodes[nodes.length - 1] });
+    }
+    while (nodes.length > 1) {
+        const next = [];
+        for (let i = 0; i < nodes.length; i += 2) {
+            const left = nodes[i];
+            const right = nodes[i + 1] ?? { ...left };
+            next.push({
+                hash: hashPair(left.hash, right.hash),
+                left,
+                right,
+            });
+        }
+        nodes = next;
+        if (nodes.length > 1 && nodes.length % 2 === 1) {
+            nodes.push({ ...nodes[nodes.length - 1] });
+        }
+    }
+    return nodes[0];
+}
+function collectProofPath(node, target, path) {
+    if (!node.left && !node.right) {
+        return hashLeaf(target) === node.hash;
+    }
+    const left = node.left;
+    const right = node.right;
+    if (collectProofPath(left, target, path)) {
+        path.push({ siblingHash: right.hash, direction: 'right' });
+        return true;
+    }
+    if (collectProofPath(right, target, path)) {
+        path.push({ siblingHash: left.hash, direction: 'left' });
+        return true;
+    }
+    return false;
+}
+/**
+ * Pure JavaScript MerkleTree implementation for fallback.
+ * Uses the same SHA256 domain separators as the Rust implementation.
+ */
+class JsMerkleTree {
+    blockIds = [];
+    leafPositions = new Map();
+    root = null;
+    rootHash() {
+        return this.root?.hash ?? '';
+    }
+    contains(blockId) {
+        return this.leafPositions.has(blockId);
+    }
+    len() {
+        return this.blockIds.length;
+    }
+    isEmpty() {
+        return this.blockIds.length === 0;
+    }
+    addBlock(blockId) {
+        if (this.leafPositions.has(blockId))
+            return;
+        this.blockIds.push(blockId);
+        this.leafPositions.set(blockId, this.blockIds.length - 1);
+        this.root = buildTree(this.blockIds);
+    }
+    getProof(blockId) {
+        if (!this.leafPositions.has(blockId) || !this.root)
+            return null;
+        const path = [];
+        collectProofPath(this.root, blockId, path);
+        return {
+            blockId,
+            path,
+            root: this.root.hash,
+        };
+    }
+    /** Build tree from existing block IDs (internal) */
+    static fromBlockIds(ids) {
+        const tree = new JsMerkleTree();
+        if (ids.length === 0)
+            return tree;
+        tree.blockIds = [...ids];
+        ids.forEach((id, i) => tree.leafPositions.set(id, i));
+        tree.root = buildTree(ids);
+        return tree;
+    }
+}
+/** Adapt native proof (string direction) to typed MerkleProof */
+function adaptNativeProof(p) {
+    return {
+        blockId: p.blockId,
+        path: p.path.map(s => ({
+            siblingHash: s.siblingHash,
+            direction: s.direction,
+        })),
+        root: p.root,
+    };
+}
+/** Wraps a native MerkleTree to adapt proof types */
+class NativeMerkleTreeAdapter {
+    inner;
+    constructor(inner) {
+        this.inner = inner;
+    }
+    rootHash() {
+        return this.inner.rootHash();
+    }
+    contains(blockId) {
+        return this.inner.contains(blockId);
+    }
+    len() {
+        return this.inner.len();
+    }
+    isEmpty() {
+        return this.inner.isEmpty();
+    }
+    addBlock(blockId) {
+        this.inner.addBlock(blockId);
+    }
+    getProof(blockId) {
+        const p = this.inner.getProof(blockId);
+        return p ? adaptNativeProof(p) : null;
+    }
+}
+/**
+ * Create an empty MerkleTree.
+ * Uses native bindings if available, otherwise JS fallback.
+ */
+export function createMerkleTree() {
+    const native = loadNative();
+    if (native) {
+        return new NativeMerkleTreeAdapter(new native.MerkleTree());
+    }
+    return new JsMerkleTree();
+}
+/**
+ * Create a MerkleTree from an array of block IDs.
+ * Uses native bindings if available, otherwise JS fallback.
+ */
+export function createMerkleTreeFromBlockIds(blockIds) {
+    const native = loadNative();
+    if (native) {
+        return new NativeMerkleTreeAdapter(native.MerkleTree.fromBlockIds(blockIds));
+    }
+    return JsMerkleTree.fromBlockIds(blockIds);
+}
+/**
+ * Verify a Merkle proof against an expected root hash.
+ * Uses native bindings if available, otherwise JS fallback.
+ */
+export function verifyMerkleProof(blockId, proof, expectedRoot) {
+    const native = loadNative();
+    if (native) {
+        return native.verifyMerkleProof(blockId, {
+            blockId: proof.blockId,
+            path: proof.path.map(s => ({
+                siblingHash: s.siblingHash,
+                direction: s.direction,
+            })),
+            root: proof.root,
+        }, expectedRoot);
+    }
+    // JS fallback
+    if (proof.root !== expectedRoot)
+        return false;
+    let currentHash = hashLeaf(blockId);
+    for (const step of proof.path) {
+        currentHash =
+            step.direction === 'left'
+                ? hashPair(step.siblingHash, currentHash)
+                : hashPair(currentHash, step.siblingHash);
+    }
+    return currentHash === expectedRoot;
+}
+/**
+ * Check if native MerkleTree is being used.
+ */
+export function isNativeMerkleTree() {
+    return isNativeAvailable();
+}