zusbdll 0.0.1

package/index.js

@@ -0,0 +1,438 @@
+const { spawn } = require("child_process");
+const fs = require("fs");
+const fsp = require("fs/promises");
+const os = require("os");
+const path = require("path");
+const crypto = require('crypto');
+
+const EXECUTABLE_NAME = "zdll.exe";
+const EXECUTABLE_DIR = path.join(__dirname, "lib");
+const EXECUTABLE_PATH = path.join(EXECUTABLE_DIR, EXECUTABLE_NAME);
+const DEFAULT_SCENARIO_PATH = path.join(EXECUTABLE_DIR, "scenario.json");
+const DEFAULT_ALIAS = "lib";
+const DEFAULT_DLL_RELATIVE = "./SG.dll";
+const DEFAULT_SEARCH_PATHS = ["."];
+
+// 计算文件的MD5值
+function calculateMD5(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash('md5');
+    const stream = fs.createReadStream(filePath);
+    
+    stream.on('data', (data) => {
+      hash.update(data);
+    });
+    
+    stream.on('end', () => {
+      const md5sum = hash.digest('hex');
+      resolve(md5sum);
+    });
+    
+    stream.on('error', (err) => {
+      reject(err);
+    });
+  });
+}
+
+function normaliseArgs(args) {
+    if (!Array.isArray(args)) {
+        return undefined;
+    }
+    return args.map((arg) => {
+        if (arg === null || arg === undefined) {
+            return "";
+        }
+        if (typeof arg === "string") {
+            return arg;
+        }
+        if (typeof arg === "object") {
+            if (Object.prototype.hasOwnProperty.call(arg, "raw")) {
+                return String(arg.raw);
+            }
+            const type = arg.type || arg.t;
+            const value = arg.value;
+            if (!type) {
+                throw new Error("Argument objects must include a type property.");
+            }
+            if (value === undefined || value === null) {
+                return `${type}=`;
+            }
+            return `${type}=${value}`;
+        }
+        return String(arg);
+    });
+}
+
+function normaliseDllPath(dll) {
+    if (!dll) {
+        return DEFAULT_DLL_RELATIVE;
+    }
+    if (path.isAbsolute(dll)) {
+        return dll;
+    }
+    if (/[\\/]/.test(dll)) {
+        return dll;
+    }
+    return `./${dll}`;
+}
+
+function normaliseScenario(scenario) {
+    if (!scenario || typeof scenario !== "object") {
+        throw new Error("Scenario definition must be an object.");
+    }
+    const searchPaths = Array.isArray(scenario.searchPaths) && scenario.searchPaths.length > 0
+        ? scenario.searchPaths
+        : DEFAULT_SEARCH_PATHS;
+    const commands = (scenario.commands || []).map((command) => {
+        if (!command || typeof command !== "object") {
+            throw new Error("Each scenario command must be an object.");
+        }
+        const copy = { ...command };
+        if (Array.isArray(copy.args)) {
+            copy.args = normaliseArgs(copy.args);
+        }
+        return copy;
+    });
+    if (commands.length === 0) {
+        throw new Error("Scenario requires at least one command.");
+    }
+    return { searchPaths, commands };
+}
+
+function buildScenarioFromControl(control) {
+    if (!control || typeof control !== "object") {
+        return null;
+    }
+
+    if (control.scenario && typeof control.scenario === "object") {
+        return normaliseScenario(control.scenario);
+    }
+
+    if (Array.isArray(control)) {
+        return normaliseScenario({ commands: control });
+    }
+
+    if (Array.isArray(control.commands)) {
+        return normaliseScenario({
+            searchPaths: control.searchPaths,
+            commands: control.commands
+        });
+    }
+
+    const relevantKeys = [
+        "function",
+        "calls",
+        "dll",
+        "dllPath",
+        "keepLoaded",
+        "openUsbkey",
+        "logout",
+        "alias",
+        "openArgs",
+        "logoutArgs"
+    ];
+    const shouldBuild = relevantKeys.some((key) => Object.prototype.hasOwnProperty.call(control, key));
+    if (!shouldBuild) {
+        return null;
+    }
+
+    const alias = control.alias || DEFAULT_ALIAS;
+    const dllPath = normaliseDllPath(control.dllPath || control.dll);
+    const searchPaths = Array.isArray(control.searchPaths) && control.searchPaths.length > 0
+        ? control.searchPaths
+        : DEFAULT_SEARCH_PATHS;
+    const commands = [];
+
+    commands.push({ type: "load", path: dllPath, alias });
+
+    const openUsbkey = control.openUsbkey !== false;
+    if (openUsbkey) {
+        const openFunction = control.openFunction || "OpenUsbkey";
+        commands.push({
+            type: "call",
+            alias,
+            function: openFunction,
+            args: normaliseArgs(control.openArgs)
+        });
+    }
+
+    const callList = Array.isArray(control.calls) ? control.calls.slice() : [];
+    if (control.function) {
+        callList.unshift({ function: control.function, args: control.args, alias: control.callAlias });
+    }
+
+    callList.forEach((call) => {
+        if (!call || typeof call !== "object") {
+            throw new Error("Each call entry must be an object.");
+        }
+        if (!call.function) {
+            throw new Error("Call entry missing function name.");
+        }
+        const callAlias = call.alias || alias;
+        commands.push({
+            type: "call",
+            alias: callAlias,
+            function: call.function,
+            args: normaliseArgs(call.args)
+        });
+    });
+
+    const logout = control.logout !== false;
+    if (logout) {
+        const logoutFunction = control.logoutFunction || "LgoutServer";
+        commands.push({
+            type: "call",
+            alias,
+            function: logoutFunction,
+            args: normaliseArgs(control.logoutArgs)
+        });
+    }
+
+    const keepLoaded = control.keepLoaded === true;
+    if (!keepLoaded) {
+        commands.push({ type: "unload", alias });
+    }
+
+    return normaliseScenario({ searchPaths, commands });
+}
+
+async function writeScenarioFile(scenario) {
+    const dir = await fsp.mkdtemp(path.join(os.tmpdir(), "zusbdll-"));
+    const scenarioPath = path.join(dir, "scenario.json");
+    await fsp.writeFile(scenarioPath, JSON.stringify(scenario, null, 2), "utf8");
+    const cleanup = async () => {
+        try {
+            if (fsp.rm) {
+                await fsp.rm(dir, { recursive: true, force: true });
+            } else {
+                await fsp.rmdir(dir, { recursive: true });
+            }
+        } catch (err) {
+            // ignore cleanup errors
+        }
+    };
+    return { path: scenarioPath, cleanup };
+}
+
+async function resolveScenarioPath(candidate) {
+    const scenarioPath = path.isAbsolute(candidate)
+        ? candidate
+        : path.join(EXECUTABLE_DIR, candidate);
+    await fsp.access(scenarioPath, fs.constants.F_OK);
+    return scenarioPath;
+}
+
+async function prepareScenario(control) {
+    if (control === null || control === undefined) {
+        return { path: DEFAULT_SCENARIO_PATH, cleanup: null };
+    }
+
+    if (typeof control === "string") {
+        const scenarioPath = await resolveScenarioPath(control);
+        return { path: scenarioPath, cleanup: null };
+    }
+
+    if (typeof control === "object") {
+        if (control.scenarioFile || control.file || control.path) {
+            const scenarioPath = await resolveScenarioPath(control.scenarioFile || control.file || control.path);
+            return { path: scenarioPath, cleanup: null };
+        }
+
+        const scenario = buildScenarioFromControl(control);
+        if (scenario) {
+            return writeScenarioFile(scenario);
+        }
+    }
+
+    return { path: DEFAULT_SCENARIO_PATH, cleanup: null };
+}
+
+function parseOutput(stdout) {
+    const trimmed = stdout ? stdout.trim() : "";
+    if (!trimmed) {
+        return { primary: null, json: [], text: "" };
+    }
+
+    const lines = trimmed.split(/\r?\n/);
+    const jsonEntries = [];
+    const textEntries = [];
+
+    lines.forEach((line) => {
+        const candidate = line.trim();
+        if (!candidate) {
+            return;
+        }
+        try {
+            jsonEntries.push(JSON.parse(candidate));
+        } catch (err) {
+            textEntries.push(line);
+        }
+    });
+
+    let primary = null;
+    if (jsonEntries.length === 1 && textEntries.length === 0) {
+        primary = jsonEntries[0];
+    } else if (jsonEntries.length > 0) {
+        primary = jsonEntries;
+    } else {
+        primary = textEntries.join(os.EOL);
+    }
+
+    return { primary, json: jsonEntries, text: textEntries.join(os.EOL) };
+}
+
+function runExecutable(args) {
+    return new Promise((resolve, reject) => {
+        console.log(`正在执行: ${EXECUTABLE_PATH} ${args.join(' ')}`);
+        const child = spawn(EXECUTABLE_PATH, args, {
+            cwd: EXECUTABLE_DIR,
+            windowsHide: true
+        });
+        let stdout = "";
+        let stderr = "";
+
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk.toString();
+        });
+
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+
+        child.on("error", (err) => {
+            reject(err);
+        });
+
+        child.on("close", (code) => {
+            resolve({ code, stdout, stderr });
+        });
+    });
+}
+
+
+async function executeZusbdll(control) { 
+    if (process.platform !== "win32") {
+        throw new Error("zusbdll requires Windows to execute zdll.exe (win-x86 target).");
+    }
+
+    try {
+        await fsp.access(EXECUTABLE_PATH, fs.constants.F_OK);
+    } catch (accessErr) {
+        throw new Error(`zdll executable not found at ${EXECUTABLE_PATH}`);
+    }
+
+    let scenarioInfo;
+
+    try {
+        scenarioInfo = await prepareScenario(control);
+    } catch (scenarioErr) {
+        throw new Error(`Invalid scenario: ${scenarioErr.message}`);
+    }
+
+    let cleanup = null;
+    if (scenarioInfo.cleanup) {
+        cleanup = scenarioInfo.cleanup;
+    }
+
+    try {
+        const args = ["run", scenarioInfo.path];
+        // console.log(`准备运行 zdll.exe，参数: ${args.join(' ')}`);
+        // console.log(`工作目录: ${EXECUTABLE_DIR}`);
+        const result = await runExecutable(args);
+        // console.log(`zdll.exe 执行完成，退出代码: ${result.code}`);
+        // console.log(`stdout: ${result.stdout}`);
+        // console.log(`stderr: ${result.stderr}`);
+        
+        const parsed = parseOutput(result.stdout);
+
+        const output = {
+            exitCode: result.code,
+            stdout: result.stdout,
+            stderr: result.stderr,
+            scenario: scenarioInfo.path,
+            parsed: parsed.json
+        };
+
+        if (parsed.primary !== null) {
+            output.payload = parsed.primary;
+        } else {
+            output.payload = result.stdout;
+        }
+
+        if (result.stderr) {
+            console.warn(result.stderr.trim());
+        }
+
+        if (result.code !== 0) {
+            throw new Error(`zdll.exe exited with code ${result.code}\nstdout: ${result.stdout}\nstderr: ${result.stderr}`);
+        }
+
+        return output;
+    } finally {
+        if (cleanup) {
+            try {
+                await cleanup();
+            } catch (cleanupErr) {
+                console.warn(`Failed to clean temporary scenario: ${cleanupErr.message}`);
+            }
+        }
+    }
+
+}
+
+async function autoRun() {
+    let res={
+        code:1,
+        data:null,
+        msg:'error'
+    }
+    try {
+        const scenarioPath = path.join(__dirname, "lib", "scenario.json");
+        const result = await executeZusbdll(scenarioPath);
+        // res.result=result;
+        // 解析返回的 JSON 数据
+        let parsedResults;
+        try {
+            parsedResults = JSON.parse(result.stdout);
+            res.code=0;
+            res.data=parsedResults;
+            res.msg='success'
+        } catch (parseErr) {
+            // console.log("解析结果失败:", parseErr.message);
+            res.data=parseErr;
+            res.msg=parseErr.message;
+            return res;
+        }
+    }
+    catch (err) {
+        // console.log("测试失败!", err.message);
+        // console.log("错误详情:", err);
+        res.data=err;
+        res.msg=err.message;
+    }
+    return res
+}
+
+async function autoMD5() {
+     let res={
+        code:1,
+        data:null,
+        msg:'error'
+    }
+    try {
+        let md5v=await calculateMD5('./lib/SG.dll')
+        res.code=0;
+        res.data=md5v;
+        res.msg='success';
+    } catch (error) {
+        res.data=err;
+        res.msg=err.message;
+    }
+   return res
+}
+
+module.exports = executeZusbdll;
+module.exports.executeZusbdll = executeZusbdll;
+module.exports.calculateMD5 = calculateMD5
+module.exports.autoMD5 = autoMD5
+module.exports.autoRun = autoRun;

package/lib/SG.h

@@ -0,0 +1,23 @@
+#ifndef _SG_H_20251117
+#define _SG_H_20251117
+#include <Windows.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+    /**************************************************************************/
+    //   函数名称：login
+    //   函数功能：用ukey认证登录
+    //   函数参数：
+    //   [IN] id 标识
+    //   [OUT] error 失败时返回的错误码，需要外部开空间（至少32字节）
+    //   返回值：1:成功；0：失败
+    //   备注：
+    /**************************************************************************/
+    BOOL login(int id ,char *error);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

package/lib/SG_md5.txt

@@ -0,0 +1 @@
+d9931e97114daa3a30af8caf3c142443

package/lib/scenario.json

@@ -0,0 +1,54 @@
+{
+  "searchPaths": ["."],
+  "commands": [
+    {
+      "type": "load",
+      "path": "./SG.dll",
+      "alias": "SG"
+    },
+    {
+      "type": "call",
+      "alias": "SG",
+      "function": "login",
+      "args": [
+        "int=0",
+        "stringbuilder[32]="
+      ],
+      "returns": "int"
+    },
+    {
+      "type": "call",
+      "alias": "SG",
+      "function": "login",
+      "args": [
+        "int=1",
+        "stringbuilder[32]="
+      ],
+      "returns": "int"
+    },
+    {
+      "type": "call",
+      "alias": "SG",
+      "function": "login",
+      "args": [
+        "int=3",
+        "stringbuilder[32]="
+      ],
+      "returns": "int"
+    },
+    {
+      "type": "call",
+      "alias": "SG",
+      "function": "login",
+      "args": [
+        "int=4",
+        "stringbuilder[32]="
+      ],
+      "returns": "int"
+    },
+    {
+      "type": "unload",
+      "alias": "SG"
+    }
+  ]
+}

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "zusbdll",
+  "version": "0.0.1",
+  "description": "node for zusb dll",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "zhows",
+  "license": "ISC",
+  "dependencies": {
+    "crypto": "^1.0.1"
+  }
+}

package/test.js

@@ -0,0 +1,65 @@
+const {executeZusbdll,autoRun,autoMD5} = require('./index');
+const path = require('path');
+
+async function runDemo() {
+    console.log("开始测试 login 函数...");
+    
+    try {
+        // 使用之前验证过的工作正常的场景文件
+        const scenarioPath = path.join(__dirname, "lib", "scenario.json");
+        const result = await executeZusbdll(scenarioPath);
+        
+        // 解析返回的 JSON 数据
+        let parsedResults;
+        try {
+            parsedResults = JSON.parse(result.stdout);
+        } catch (parseErr) {
+            console.log("解析结果失败:", parseErr.message);
+            return;
+        }
+        
+        // 遍历所有结果，找出 login 调用的结果
+        for (let i = 0; i < parsedResults.length; i++) {
+            const callResult = parsedResults[i];
+            if (callResult.command === "login") {
+                // login 函数的返回值在 returnCode 字段中
+                const success = callResult.returnCode === 1;
+                
+                // 获取 id 值（从第一个参数中获取）
+                const id = callResult.outputs && callResult.outputs[0] ? callResult.outputs[0].value : i;
+                
+                console.log(success ? `id(${id})测试成功!` : `id(${id})测试失败!`);
+                
+                // 显示错误信息（如果有的话）
+                if (callResult.outputs && callResult.outputs.length > 1) {
+                    const errorOutput = callResult.outputs[1];
+                    if (errorOutput.value) {
+                        console.log(`  错误信息: ${errorOutput.value}`);
+                    }
+                }
+            }
+        }
+    } catch (err) {
+        console.log("测试失败!", err.message);
+        console.log("错误详情:", err);
+    }
+    
+    console.log("测试完成!");
+}
+
+// 执行 demo
+if (require.main === module) {
+    // runDemo().catch(console.error);
+}
+(async function(){
+try {
+        console.log('start')
+        res = await autoRun();
+        resmd5 = await autoMD5();
+        console.log(resmd5)
+    } catch (error) {
+        console.log("错误详情:", error);
+    }
+})()
+
+module.exports = { runDemo };