simple-dynamsoft-mcp 2.0.3 → 2.0.4

package/code-snippet/dynamsoft-barcode-reader/python/Samples/camera.py

@@ -0,0 +1,96 @@
+from dynamsoft_barcode_reader_bundle import *
+import cv2
+import numpy as np
+import queue
+from utils import *
+
+
+class FrameFetcher(ImageSourceAdapter):
+    def has_next_image_to_fetch(self) -> bool:
+        return True
+
+    def add_frame(self, imageData):
+        self.add_image_to_buffer(imageData)
+
+
+class MyCapturedResultReceiver(CapturedResultReceiver):
+    def __init__(self, result_queue):
+        super().__init__()
+        self.result_queue = result_queue
+
+    def on_captured_result_received(self, captured_result):
+        self.result_queue.put(captured_result)
+
+
+if __name__ == '__main__':
+    errorCode, errorMsg = LicenseManager.init_license(
+        "DLS2eyJoYW5kc2hha2VDb2RlIjoiMjAwMDAxLTE2NDk4Mjk3OTI2MzUiLCJvcmdhbml6YXRpb25JRCI6IjIwMDAwMSIsInNlc3Npb25QYXNzd29yZCI6IndTcGR6Vm05WDJrcEQ5YUoifQ==")
+    if errorCode != EnumErrorCode.EC_OK and errorCode != EnumErrorCode.EC_LICENSE_CACHE_USED:
+        print("License initialization failed: ErrorCode:",
+              errorCode, ", ErrorString:", errorMsg)
+    else:
+        vc = cv2.VideoCapture(0)
+        if not vc.isOpened():
+            print("Error: Camera is not opened!")
+            exit(1)
+
+        cvr = CaptureVisionRouter()
+        fetcher = FrameFetcher()
+        cvr.set_input(fetcher)
+
+        # Create a thread-safe queue to store captured items
+        result_queue = queue.Queue()
+
+        receiver = MyCapturedResultReceiver(result_queue)
+        cvr.add_result_receiver(receiver)
+
+        errorCode, errorMsg = cvr.start_capturing(
+            EnumPresetTemplate.PT_READ_BARCODES.value)
+
+        if errorCode != EnumErrorCode.EC_OK:
+            print("error:", errorMsg)
+
+        while True:
+            ret, frame = vc.read()
+            if not ret:
+                print("Error: Cannot read frame!")
+                break
+
+            fetcher.add_frame(convertMat2ImageData(frame))
+
+            if not result_queue.empty():
+                captured_result = result_queue.get_nowait()
+
+                items = captured_result.get_items()
+                for item in items:
+
+                    if item.get_type() == EnumCapturedResultItemType.CRIT_BARCODE:
+                        text = item.get_text()
+                        location = item.get_location()
+                        x1 = location.points[0].x
+                        y1 = location.points[0].y
+                        x2 = location.points[1].x
+                        y2 = location.points[1].y
+                        x3 = location.points[2].x
+                        y3 = location.points[2].y
+                        x4 = location.points[3].x
+                        y4 = location.points[3].y
+                        pts = np.array([(x1, y1), (x2, y2), (x3, y3), (x4, y4)], np.int32).reshape((-1, 1, 2))
+                        cv2.drawContours(
+                            frame, [pts], 0, (0, 255, 0), 2)
+
+                        cv2.putText(frame, text, (x1, y1),
+                                    cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
+
+                        del location
+
+            if cv2.waitKey(1) & 0xFF == ord('q'):
+                break
+            elif  cv2.waitKey(1) & 0xFF == ord('c'):
+                cv2.imshow('Captured Image', frame)
+
+            cv2.imshow('frame', frame)
+
+        cvr.stop_capturing()
+        vc.release()
+        cv2.destroyAllWindows()

package/code-snippet/dynamsoft-barcode-reader/python/Samples/file.py

@@ -0,0 +1,82 @@
+import sys
+from dynamsoft_barcode_reader_bundle import *
+import os
+import cv2
+import numpy as np
+from utils import *
+
+if __name__ == '__main__':
+
+    print("**********************************************************")
+    print("Welcome to Dynamsoft Capture Vision - Barcode Sample")
+    print("**********************************************************")
+
+    error_code, error_message = LicenseManager.init_license(
+        "DLS2eyJoYW5kc2hha2VDb2RlIjoiMjAwMDAxLTE2NDk4Mjk3OTI2MzUiLCJvcmdhbml6YXRpb25JRCI6IjIwMDAwMSIsInNlc3Npb25QYXNzd29yZCI6IndTcGR6Vm05WDJrcEQ5YUoifQ==")
+    if error_code != EnumErrorCode.EC_OK and error_code != EnumErrorCode.EC_LICENSE_CACHE_USED:
+        print("License initialization failed: ErrorCode:",
+              error_code, ", ErrorString:", error_message)
+    else:
+        cvr_instance = CaptureVisionRouter()
+        while (True):
+            image_path = input(
+                ">> Input your image full path:\n"
+                ">> 'Enter' for sample image or 'Q'/'q' to quit\n"
+            ).strip('\'"')
+
+            if image_path.lower() == "q":
+                sys.exit(0)
+
+            if image_path == "":
+                image_path = "../../../images/multi.png"
+
+            if not os.path.exists(image_path):
+                print("The image path does not exist.")
+                continue
+
+            cv_image = cv2.imread(image_path)
+            result = cvr_instance.capture(
+                cv_image, EnumPresetTemplate.PT_READ_BARCODES.value)
+            if result.get_error_code() != EnumErrorCode.EC_OK:
+                print("Error:", result.get_error_code(),
+                      result.get_error_string())
+            else:
+                
+
+                items = result.get_items()
+                print('Found {} barcodes.'.format(len(items)))
+                for item in items:
+                    format_type = item.get_format_string()
+                    text = item.get_text()
+                    print("Barcode Format:", format_type)
+                    print("Barcode Text:", text)
+
+                    location = item.get_location()
+                    x1 = location.points[0].x
+                    y1 = location.points[0].y
+                    x2 = location.points[1].x
+                    y2 = location.points[1].y
+                    x3 = location.points[2].x
+                    y3 = location.points[2].y
+                    x4 = location.points[3].x
+                    y4 = location.points[3].y
+                    print("Location Points:")
+                    print("({}, {})".format(x1, y1))
+                    print("({}, {})".format(x2, y2))
+                    print("({}, {})".format(x3, y3))
+                    print("({}, {})".format(x4, y4))
+                    print("-------------------------------------------------")
+
+                    pts = np.array([(x1, y1), (x2, y2), (x3, y3), (x4, y4)], np.int32).reshape((-1, 1, 2))
+                    cv2.drawContours(
+                        cv_image, [pts], 0, (0, 255, 0), 2)
+
+                    cv2.putText(cv_image, text, (x1, y1 - 10),
+                                cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2)
+
+                cv2.imshow(
+                    "Original Image with Detected Barcodes", cv_image)
+                cv2.waitKey(0)
+                cv2.destroyAllWindows()
+
+    input("Press Enter to quit...")

package/code-snippet/dynamsoft-barcode-reader/python/Samples/utils.py

@@ -0,0 +1,60 @@
+from dynamsoft_barcode_reader_bundle import *
+import numpy as np
+
+
+def convertImageData2Mat(normalized_image):
+    ba = bytearray(normalized_image.get_bytes())
+    width = normalized_image.get_width()
+    height = normalized_image.get_height()
+
+    channels = 3
+    if normalized_image.get_image_pixel_format() == EnumImagePixelFormat.IPF_BINARY:
+        channels = 1
+        all = []
+        skip = normalized_image.stride * 8 - width
+
+        index = 0
+        n = 1
+        for byte in ba:
+
+            byteCount = 7
+            while byteCount >= 0:
+                b = (byte & (1 << byteCount)) >> byteCount
+
+                if index < normalized_image.stride * 8 * n - skip:
+                    if b == 1:
+                        all.append(255)
+                    else:
+                        all.append(0)
+
+                byteCount -= 1
+                index += 1
+
+            if index == normalized_image.stride * 8 * n:
+                n += 1
+
+        mat = np.array(all, dtype=np.uint8).reshape(height, width, channels)
+        return mat
+
+    elif normalized_image.get_image_pixel_format() == EnumImagePixelFormat.IPF_GRAYSCALED:
+        channels = 1
+
+    mat = np.array(ba, dtype=np.uint8).reshape(height, width, channels)
+
+    return mat
+
+
+def convertMat2ImageData(mat):
+    if len(mat.shape) == 3:
+        height, width, channels = mat.shape
+        pixel_format = EnumImagePixelFormat.IPF_RGB_888
+    else:
+        height, width = mat.shape
+        channels = 1
+        pixel_format = EnumImagePixelFormat.IPF_GRAYSCALED
+
+    stride = width * channels
+    imagedata = ImageData(mat.tobytes(), width, height, stride, pixel_format)
+    return imagedata
+
+

package/package.json

@@ -1,7 +1,11 @@
 {
   "name": "simple-dynamsoft-mcp",
-  "version": "2.0.3",
+  "version": "2.0.4",
   "description": "MCP server for Dynamsoft SDKs - Barcode Reader (Mobile/Python/Web) and Dynamic Web TWAIN. Provides documentation, code snippets, and API guidance.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yushulx/simple-dynamsoft-mcp.git"
+  },
   "type": "module",
   "engines": {
     "node": ">=18"
@@ -13,10 +17,12 @@
     "src",
     "data",
     "code-snippet",
+    "test",
     "README.md"
   ],
   "scripts": {
-    "start": "node src/index.js"
+    "start": "node src/index.js",
+    "test": "node test/server.test.js"
   },
   "keywords": [
     "mcp",

package/test/server.test.js

@@ -0,0 +1,401 @@
+#!/usr/bin/env node
+
+/**
+ * Automated tests for Dynamsoft MCP Server
+ * Run with: node test/server.test.js
+ */
+
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const serverPath = join(__dirname, '..', 'src', 'index.js');
+
+// Test counters
+let passed = 0;
+let failed = 0;
+const results = [];
+
+/**
+ * Send a JSON-RPC request to the server and get the response
+ */
+async function sendRequest(request) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn('node', [serverPath], {
+            stdio: ['pipe', 'pipe', 'pipe']
+        });
+
+        let stdout = '';
+        let stderr = '';
+
+        proc.stdout.on('data', (data) => {
+            stdout += data.toString();
+        });
+
+        proc.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+
+        proc.on('close', (code) => {
+            try {
+                // Parse only the JSON-RPC response (last complete JSON object)
+                const lines = stdout.trim().split('\n');
+                const jsonLine = lines.find(line => {
+                    try {
+                        const parsed = JSON.parse(line);
+                        return parsed.jsonrpc === '2.0';
+                    } catch {
+                        return false;
+                    }
+                });
+
+                if (jsonLine) {
+                    resolve(JSON.parse(jsonLine));
+                } else {
+                    reject(new Error(`No valid JSON-RPC response. stdout: ${stdout}, stderr: ${stderr}`));
+                }
+            } catch (e) {
+                reject(new Error(`Failed to parse response: ${e.message}. stdout: ${stdout}`));
+            }
+        });
+
+        proc.on('error', reject);
+
+        // Send the request and close stdin
+        proc.stdin.write(JSON.stringify(request) + '\n');
+        proc.stdin.end();
+    });
+}
+
+/**
+ * Run a test case
+ */
+async function test(name, fn) {
+    try {
+        await fn();
+        passed++;
+        results.push({ name, status: '✅ PASSED' });
+        console.log(`✅ ${name}`);
+    } catch (error) {
+        failed++;
+        results.push({ name, status: '❌ FAILED', error: error.message });
+        console.log(`❌ ${name}`);
+        console.log(`   Error: ${error.message}`);
+    }
+}
+
+/**
+ * Assert helper
+ */
+function assert(condition, message) {
+    if (!condition) {
+        throw new Error(message || 'Assertion failed');
+    }
+}
+
+// ============================================
+// Test Cases
+// ============================================
+
+console.log('\n🧪 Dynamsoft MCP Server Test Suite\n');
+console.log('='.repeat(50));
+
+// Test 1: Server initialization
+await test('Server responds to initialize request', async () => {
+    const response = await sendRequest({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'initialize',
+        params: {
+            protocolVersion: '2024-11-05',
+            capabilities: {},
+            clientInfo: { name: 'test-client', version: '1.0.0' }
+        }
+    });
+
+    assert(response.result, 'Should have result');
+    assert(response.result.serverInfo, 'Should have serverInfo');
+    assert(response.result.serverInfo.name === 'simple-dynamsoft-mcp', 'Server name should match');
+});
+
+// Test 2: List tools
+await test('tools/list returns all 13 tools', async () => {
+    const response = await sendRequest({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'tools/list'
+    });
+
+    assert(response.result, 'Should have result');
+    assert(response.result.tools, 'Should have tools array');
+    assert(response.result.tools.length === 13, `Expected 13 tools, got ${response.result.tools.length}`);
+
+    const toolNames = response.result.tools.map(t => t.name);
+    const expectedTools = [
+        'list_sdks', 'get_sdk_info', 'list_samples', 'list_python_samples',
+        'list_dwt_categories', 'get_code_snippet', 'get_python_sample',
+        'get_dwt_sample', 'get_quick_start', 'get_gradle_config',
+        'get_license_info', 'get_api_usage', 'search_samples'
+    ];
+
+    for (const expected of expectedTools) {
+        assert(toolNames.includes(expected), `Missing tool: ${expected}`);
+    }
+});
+
+// Test 3: list_sdks tool
+await test('list_sdks returns SDK information', async () => {
+    const response = await sendRequest({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'tools/call',
+        params: {
+            name: 'list_sdks',
+            arguments: {}
+        }
+    });
+
+    assert(response.result, 'Should have result');
+    assert(response.result.content, 'Should have content');
+    assert(response.result.content.length > 0, 'Should have content items');
+
+    const text = response.result.content[0].text;
+    assert(text.includes('dbr-mobile'), 'Should include dbr-mobile');
+    assert(text.includes('dbr-python'), 'Should include dbr-python');
+    assert(text.includes('dbr-web'), 'Should include dbr-web');
+    assert(text.includes('dwt'), 'Should include dwt');
+});
+
+// Test 4: get_sdk_info tool
+await test('get_sdk_info returns detailed SDK info', async () => {
+    const response = await sendRequest({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'tools/call',
+        params: {
+            name: 'get_sdk_info',
+            arguments: { sdk_id: 'dbr-mobile' }
+        }
+    });
+
+    assert(response.result, 'Should have result');
+    assert(response.result.content, 'Should have content');
+
+    const text = response.result.content[0].text;
+    assert(text.includes('Android') || text.includes('android'), 'Should include Android');
+    assert(text.includes('11.2.5000'), 'Should include version');
+});
+
+// Test 5: get_license_info tool (requires platform parameter)
+await test('get_license_info returns trial license', async () => {
+    const response = await sendRequest({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'tools/call',
+        params: {
+            name: 'get_license_info',
+            arguments: { platform: 'android' }
+        }
+    });
+
+    assert(response.result, 'Should have result');
+    assert(!response.result.isError, 'Should not be an error');
+
+    const text = response.result.content[0].text;
+    assert(text.includes('DLS2') || text.includes('License'), 'Should include license info');
+});
+
+// Test 6: list_samples tool
+await test('list_samples returns mobile samples', async () => {
+    const response = await sendRequest({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'tools/call',
+        params: {
+            name: 'list_samples',
+            arguments: { platform: 'android' }
+        }
+    });
+
+    assert(response.result, 'Should have result');
+
+    const text = response.result.content[0].text;
+    assert(text.includes('android'), 'Should include android');
+});
+
+// Test 7: list_python_samples tool
+await test('list_python_samples returns Python samples', async () => {
+    const response = await sendRequest({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'tools/call',
+        params: {
+            name: 'list_python_samples',
+            arguments: {}
+        }
+    });
+
+    assert(response.result, 'Should have result');
+    // Should return samples or indicate no local samples
+    assert(response.result.content, 'Should have content');
+});
+
+// Test 8: list_dwt_categories tool
+await test('list_dwt_categories returns DWT categories', async () => {
+    const response = await sendRequest({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'tools/call',
+        params: {
+            name: 'list_dwt_categories',
+            arguments: {}
+        }
+    });
+
+    assert(response.result, 'Should have result');
+    // Should return categories or indicate they exist
+    assert(response.result.content, 'Should have content');
+});
+
+// Test 9: get_quick_start tool
+await test('get_quick_start returns quick start guide', async () => {
+    const response = await sendRequest({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'tools/call',
+        params: {
+            name: 'get_quick_start',
+            arguments: { sdk_id: 'dbr-mobile', platform: 'android' }
+        }
+    });
+
+    assert(response.result, 'Should have result');
+
+    const text = response.result.content[0].text;
+    assert(text.includes('Quick Start') || text.includes('Android'), 'Should include quick start info');
+});
+
+// Test 10: get_gradle_config tool
+await test('get_gradle_config returns Gradle configuration', async () => {
+    const response = await sendRequest({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'tools/call',
+        params: {
+            name: 'get_gradle_config',
+            arguments: {}
+        }
+    });
+
+    assert(response.result, 'Should have result');
+
+    const text = response.result.content[0].text;
+    assert(text.includes('gradle') || text.includes('Gradle') || text.includes('implementation'),
+        'Should include Gradle config');
+});
+
+// Test 11: get_api_usage tool
+await test('get_api_usage returns API usage info', async () => {
+    const response = await sendRequest({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'tools/call',
+        params: {
+            name: 'get_api_usage',
+            arguments: { sdk_id: 'dbr-mobile', api_name: 'decode' }
+        }
+    });
+
+    assert(response.result, 'Should have result');
+    assert(response.result.content, 'Should have content');
+});
+
+// Test 12: search_samples tool
+await test('search_samples finds samples by keyword', async () => {
+    const response = await sendRequest({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'tools/call',
+        params: {
+            name: 'search_samples',
+            arguments: { query: 'barcode' }
+        }
+    });
+
+    assert(response.result, 'Should have result');
+    assert(response.result.content, 'Should have content');
+});
+
+// Test 13: resources/list returns resources
+await test('resources/list returns registered resources', async () => {
+    const response = await sendRequest({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'resources/list'
+    });
+
+    assert(response.result, 'Should have result');
+    assert(response.result.resources, 'Should have resources array');
+    assert(response.result.resources.length > 0, 'Should have at least one resource');
+
+    // Check for expected resource types
+    const uris = response.result.resources.map(r => r.uri);
+    assert(uris.some(u => u.includes('sdk-info')), 'Should have sdk-info resources');
+});
+
+// Test 14: Invalid tool call returns error
+await test('Invalid tool call returns proper error', async () => {
+    const response = await sendRequest({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'tools/call',
+        params: {
+            name: 'nonexistent_tool',
+            arguments: {}
+        }
+    });
+
+    assert(response.error || (response.result && response.result.isError),
+        'Should return error for invalid tool');
+});
+
+// Test 15: Tool with invalid arguments returns error
+await test('Tool with missing required arguments returns error', async () => {
+    const response = await sendRequest({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'tools/call',
+        params: {
+            name: 'get_license_info',
+            arguments: {} // Missing required platform
+        }
+    });
+
+    assert(response.result && response.result.isError,
+        'Should return error for missing required argument');
+});
+
+// ============================================
+// Test Summary
+// ============================================
+
+console.log('\n' + '='.repeat(50));
+console.log('\n📊 Test Summary\n');
+console.log(`   Total:  ${passed + failed}`);
+console.log(`   Passed: ${passed} ✅`);
+console.log(`   Failed: ${failed} ❌`);
+console.log(`   Rate:   ${((passed / (passed + failed)) * 100).toFixed(1)}%`);
+
+if (failed > 0) {
+    console.log('\n❌ Failed Tests:');
+    results.filter(r => r.status.includes('FAILED')).forEach(r => {
+        console.log(`   - ${r.name}: ${r.error}`);
+    });
+}
+
+console.log('\n' + '='.repeat(50));
+
+// Exit with appropriate code
+process.exit(failed > 0 ? 1 : 0);