sks-maximo-utils 1.0.5 → 1.0.7

package/CLI.md

@@ -0,0 +1,226 @@
+# CLI 命令使用说明
+
+## 命令概览
+
+| 命令 | 说明 |
+|------|------|
+| `sks-maximo` | 检查配置文件并打开配置目录 |
+| `sks-maximo <env>` | 加载指定环境配置 |
+| `sks-maximo call <scriptName>` | 调用通用脚本接口 |
+| `sks-maximo import-object <fileName>` | 导入 Maximo 对象配置 |
+| `sks-maximo import-appinfo <fileName>` | 导入应用信息配置 |
+| `sks-maximo import-presentation <fileName>` | 导入应用XML配置 |
+| `sks-maximo import-script <fileName>` | 导入自动化脚本 |
+| `sks-maximo import-domain <fileName>` | 导入域配置 |
+
+---
+
+## 1. 打开配置目录
+
+```bash
+sks-maximo
+```
+
+**功能：**
+- 检查 `~/.sks/nodeutils/config.json` 是否存在
+- 不存在则复制 `sample.config.json` 创建
+- 自动打开配置文件所在目录
+
+---
+
+## 2. 加载环境配置
+
+```bash
+sks-maximo local    # 使用本地环境配置
+sks-maximo dev      # 使用开发环境配置  
+sks-maximo hd       # 使用测试环境配置
+```
+
+**功能：**
+- 加载指定环境的配置到全局
+- 后续所有 API 调用使用该环境的 baseUrl、apiKey 等配置
+
+---
+
+## 3. 导入命令
+
+所有导入命令均支持 `-e` / `--env` 指定环境和 `-l` / `--logname` 指定日志名。
+
+### 3.1 导入对象配置
+
+```bash
+sks-maximo import-object <fileName> [-e env] [-l logname]
+```
+
+**说明：** 导入 Maximo 对象配置（JSON/XML）
+
+| 参数 | 说明 | 必填 |
+|------|------|------|
+| `<fileName>` | JSON 或 XML 配置文件路径 | 是 |
+| `-e` / `--env` | 指定环境（默认 local） | 否 |
+| `-l` / `--logname` | 日志打印名称 | 否 |
+
+---
+
+### 3.2 导入应用信息
+
+```bash
+sks-maximo import-appinfo <fileName> [-e env] [-l logname]
+```
+
+**说明：** 导入 Maximo 应用信息配置（JSON）
+
+| 参数 | 说明 | 必填 |
+|------|------|------|
+| `<fileName>` | 应用信息 JSON 文件路径 | 是 |
+| `-e` / `--env` | 指定环境（默认 local） | 否 |
+| `-l` / `--logname` | 日志打印名称 | 否 |
+
+---
+
+### 3.3 导入应用XML配置
+
+```bash
+sks-maximo import-presentation <fileName> [-e env] [-l logname]
+```
+
+**说明：** 导入 Maximo 应用 XML 配置
+
+| 参数 | 说明 | 必填 |
+|------|------|------|
+| `<fileName>` | XML 配置文件路径 | 是 |
+| `-e` / `--env` | 指定环境（默认 local） | 否 |
+| `-l` / `--logname` | 日志打印名称 | 否 |
+
+---
+
+### 3.4 导入自动化脚本
+
+```bash
+sks-maximo import-script <fileName> [-e env] [-l logname]
+```
+
+**说明：** 导入 Maximo 自动化脚本。`<fileName>` 可以是 JSON 配置文件路径，也可以是 `.js`/`.py` 脚本文件路径（会自动找同目录下的同名 JSON 配置文件）
+
+| 参数 | 说明 | 必填 |
+|------|------|------|
+| `<fileName>` | JSON 配置或脚本文件路径 | 是 |
+| `-e` / `--env` | 指定环境（默认 local） | 否 |
+| `-l` / `--logname` | 日志打印名称 | 否 |
+
+---
+
+### 3.5 导入域配置
+
+```bash
+sks-maximo import-domain <fileName> [-e env] [-l logname]
+```
+
+**说明：** 导入 Maximo 域配置
+
+| 参数 | 说明 | 必填 |
+|------|------|------|
+| `<fileName>` | 域 JSON 文件路径 | 是 |
+| `-e` / `--env` | 指定环境（默认 local） | 否 |
+| `-l` / `--logname` | 日志打印名称 | 否 |
+
+---
+
+## 4. 调用通用脚本接口
+
+```bash
+sks-maximo call <scriptName> [--file <fileName>] [--params <params>] [--logname <logname>]
+```
+
+**参数说明：**
+
+| 参数 | 简写 | 说明 | 必填 |
+|------|------|------|------|
+| `<scriptName>` | - | Maximo 脚本接口名称 | 是 |
+| `--file` | `-f` | 请求体文件路径（JSON/XML等） | 否 |
+| `--params` | `-p` | URL 查询参数（JSON格式） | 否 |
+| `--logname` | `-l` | 日志名称 | 否 |
+
+### 4.1 GET 请求（无请求体）
+
+```bash
+sks-maximo call SHARPTREE.AUTOSCRIPT.LIBRARY --params '{"name":"TEST"}'
+```
+
+### 4.2 POST 请求（带请求体文件）
+
+```bash
+# JSON 请求体
+sks-maximo call SKS_DEPLOY_AUTOKEY --file data/autokey.json
+
+# XML 请求体
+sks-maximo call SHARPTREE.AUTOSCRIPT.SCREENS --file screens/test.xml
+
+# 同时带参数和请求体
+sks-maximo call SKS_IMP_MAXAPPINFO --file appinfo.json --params '{"debug":true}' --logname "导入应用信息"
+```
+
+### 4.3 请求体文件处理
+
+- **`.json` 文件**：自动解析为 JSON 对象作为请求体
+- **其他文件**：读取文件内容作为字符串请求体
+
+---
+
+## 配置文件说明
+
+配置文件位置：`~/.sks/nodeutils/config.json`
+
+```json
+{
+  "logLevel": "INFO",
+  "langcode": "zh",
+  "envs": {
+    "local": {
+      "baseUrl": "http://127.0.0.1:9080/maximo",
+      "apiKey": "your-api-key",
+      "maxauth": "",
+      "authType": "apiKey",
+      "langcode": "zh"
+    },
+    "dev": {
+      "baseUrl": "https://mdev/maximo",
+      "apiKey": "your-api-key",
+      "maxauth": "",
+      "authType": "apiKey"
+    }
+  }
+}
+```
+
+---
+
+## 示例
+
+### 示例 1：查询脚本库
+
+```bash
+sks-maximo call SHARPTREE.AUTOSCRIPT.LIBRARY --params '{"name":"MY_SCRIPT"}'
+```
+
+### 示例 2：部署自动编码
+
+```bash
+sks-maximo call SKS_DEPLOY_AUTOKEY --file autokey/test.json --logname "部署自动编码"
+```
+
+### 示例 3：导入应用信息
+
+```bash
+sks-maximo call SKS_IMP_MAXAPPINFO --file appinfo/APP001.json
+```
+
+---
+
+## 帮助信息
+
+```bash
+sks-maximo --help    # 显示帮助
+sks-maximo -h        # 显示帮助
+sks-maximo -v        # 显示版本号
+```

package/README.md

@@ -11,7 +11,7 @@ npm install -g shoukaiseki-maximo-utils
 
 ### 项目中安装（引用使用）
 ```bash
-npm install shoukaiseki-maximo-utils
+npm install sks-maximo-utils
 ```
 
 ## 使用方式
@@ -40,9 +40,11 @@ import {
   importMaxAutoKey,
   importMaxScript,
   importMaxAppInfo,
+  callMaxScript,
+  fileUtils,
   loadConfig,
   logger
-} from 'shoukaiseki-maximo-utils';
+} from 'sks-maximo-utils';
 
 // 加载配置（可选，默认 local）
 loadConfig('local');
@@ -66,6 +68,16 @@ importMaxScript({ fileName: "scripts/TEST.json" });
 
 // 导入应用信息配置
 importMaxAppInfo({ fileName: "MAXAPPINFO/appinfo.json", logname: "应用信息" });
+
+// 通用脚本接口调用（GET）
+callMaxScript({ apiScriptName: "SHARPTREE.AUTOSCRIPT.LIBRARY", params: { name: "test" }, logname: "查询脚本库" });
+
+// 通用脚本接口调用（POST，读取文件内容作为请求体）
+callMaxScript({ apiScriptName: "SKS_DEPLOY_AUTOKEY", fileName: "data/autokey.json", logname: "部署自动编码" });
+
+// 文件工具
+fileUtils.listFiles('scripts', '.json');
+fileUtils.readFileContent('test.txt');
 ```
 
 ## 配置文件
@@ -126,11 +138,15 @@ importMaxAppInfo({ fileName: "MAXAPPINFO/appinfo.json", logname: "应用信息"
 
 | 方法 | 说明 |
 |------|------|
+| callMaxScript | 通用脚本接口调用（GET/POST） |
 | loadConfig(env) | 加载指定环境配置 |
 | saveScriptHistory(options) | 保存脚本历史记录 |
 | readFileContent(fileName) | 读取文件内容 |
 | readJsonFile(fileName) | 读取并解析 JSON 文件 |
 | fileExists(fileName) | 检查文件是否存在 |
+| fileUtils.listFiles(dirName, extFilter, recursive) | 列出目录文件 |
+| fileUtils.readFileContent(fileName) | 读取文件内容 |
+| fileUtils.readJsonFile(fileName) | 读取并解析 JSON 文件 |
 
 ### 日志文件
 
@@ -148,7 +164,7 @@ npm install
 npm link
 
 # 在其他项目中链接测试
-npm link shoukaiseki-maximo-utils
+npm link sks-maximo-utils
 ```
 
 ## License

package/cli.js

@@ -1,29 +1,67 @@
 #!/usr/bin/env node
 import { exec } from 'child_process';
+import { readFileSync } from 'fs';
+import { fileURLToPath, URL } from 'url';
 import { checkAndCreateConfig, getConfigDir, loadConfig } from './nodeutils/config.js';
+import { callMaxScript, importMaxObject, importMaxPresentation, importMaxDomain, importMaxAutoKey, importMaxScript, importMaxAppInfo } from './nodeutils/maximoTools.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = new URL('.', import.meta.url).pathname;
+const packageJson = JSON.parse(readFileSync(new URL('./package.json', import.meta.url), 'utf-8'));
 
 const args = process.argv.slice(2);
-const env = args[0];
 
-if (!env || ['-h', '--help', '-?', '--version', '-v'].includes(env)) {
-  console.log(`sks-maximo v${require('./package.json').version}`);
+// 解析全局选项（--env）
+let globalEnv = 'local';
+const filteredArgs = [];
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === '--env' || args[i] === '-e') {
+    globalEnv = args[i + 1];
+    i++; // 跳过值
+  } else {
+    filteredArgs.push(args[i]);
+  }
+}
+
+const cmd = filteredArgs[0];
+const env = filteredArgs[0];
+
+if (!cmd || ['-h', '--help', '-?', '--version', '-v'].includes(cmd)) {
+  console.log(`sks-maximo v${packageJson.version}`);
   console.log('');
   console.log('用法:');
   console.log('  sks-maximo              # 检查配置文件并打开配置目录');
   console.log('  sks-maximo <env>        # 加载指定环境配置');
+  console.log('  sks-maximo call <scriptName> [options]  # 调用脚本接口');
+  console.log('  sks-maximo import-object <fileName>    # 导入 Maximo 对象配置');
+  console.log('  sks-maximo import-appinfo <fileName>    # 导入应用信息配置');
+  console.log('  sks-maximo import-presentation <fileName> # 导入应用XML配置');
+  console.log('  sks-maximo import-script <fileName>    # 导入自动化脚本');
+  console.log('  sks-maximo import-domain <fileName>    # 导入域配置');
   console.log('');
   console.log('环境:');
   console.log('  local                   # 使用本地环境配置');
   console.log('  dev                     # 使用开发环境配置');
   console.log('  hd                      # 使用测试环境配置');
   console.log('');
+  console.log('命令:');
+  console.log('  call                    # 调用通用脚本接口');
+  console.log('  import-object           # 导入 Maximo 对象配置');
+  console.log('  import-appinfo          # 导入应用信息配置');
+  console.log('  import-presentation     # 导入应用XML配置');
+  console.log('  import-script           # 导入自动化脚本');
+  console.log('  import-domain           # 导入域配置');
+  console.log('');
   console.log('选项:');
   console.log('  -h, --help              # 显示帮助信息');
   console.log('  -v, --version           # 显示版本信息');
+  console.log('  --env, -e <env>         # 指定环境（默认 local）');
+  console.log('  --file <fileName>       # 请求体文件路径（JSON）');
+  console.log('  --params <params>       # URL参数（JSON格式）');
   console.log('');
   console.log('配置文件位置: ~/.sks/nodeutils/config.json');
   
-  if (!env) {
+  if (!cmd) {
     const configPath = checkAndCreateConfig();
     const configDir = getConfigDir();
     
@@ -48,8 +86,195 @@ if (!env || ['-h', '--help', '-?', '--version', '-v'].includes(env)) {
       }
     });
   }
+} else if (cmd === 'call') {
+  const scriptName = args[1];
+  
+  if (!scriptName) {
+    console.error('错误: 请指定脚本名称');
+    console.log('用法: sks-maximo call <scriptName> [--file <fileName>] [--params <params>]');
+    process.exit(1);
+  }
+  
+  let fileName = null;
+  let params = {};
+  let logname = null;
+  
+  for (let i = 2; i < args.length; i++) {
+    if (args[i] === '--file' || args[i] === '-f') {
+      fileName = args[i + 1];
+      i++;
+    } else if (args[i] === '--params' || args[i] === '-p') {
+      try {
+        params = JSON.parse(args[i + 1]);
+      } catch (e) {
+        console.error(`参数解析失败: ${e.message}`);
+        process.exit(1);
+      }
+      i++;
+    } else if (args[i] === '--logname' || args[i] === '-l') {
+      logname = args[i + 1];
+      i++;
+    }
+  }
+  
+  loadConfig(globalEnv);
+  
+  (async () => {
+    try {
+      const response = await callMaxScript({ apiScriptName: scriptName, fileName, params, logname });
+      if (response) {
+        console.log('响应:', JSON.stringify(response, null, 2));
+      } else {
+        console.error('调用失败');
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error('调用出错:', error.message);
+      process.exit(1);
+    }
+  })();
+} else if (cmd === 'import-object') {
+  const fileName = filteredArgs[1];
+  if (!fileName) {
+    console.error('错误: 请指定 JSON 文件路径');
+    console.log('用法: sks-maximo import-object <fileName> [-e env]');
+    process.exit(1);
+  }
+  loadConfig(globalEnv);
+  (async () => {
+    try {
+      const result = await importMaxObject({ fileName, logname: fileName });
+      if (result) {
+        console.log('导入成功');
+      } else {
+        console.error('导入失败');
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error('导入出错:', error.message);
+      process.exit(1);
+    }
+  })();
+} else if (cmd === 'import-appinfo') {
+  const fileName = filteredArgs[1];
+  if (!fileName) {
+    console.error('错误: 请指定 JSON 文件路径');
+    console.log('用法: sks-maximo import-appinfo <fileName> [-e env] [-l logname]');
+    process.exit(1);
+  }
+  let logname = null;
+  for (let i = 2; i < filteredArgs.length; i++) {
+    if (filteredArgs[i] === '--logname' || filteredArgs[i] === '-l') {
+      logname = filteredArgs[i + 1];
+      i++;
+    }
+  }
+  loadConfig(globalEnv);
+  (async () => {
+    try {
+      const result = await importMaxAppInfo({ fileName, logname: logname || fileName });
+      if (result) {
+        console.log('导入成功');
+      } else {
+        console.error('导入失败');
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error('导入出错:', error.message);
+      process.exit(1);
+    }
+  })();
+} else if (cmd === 'import-presentation') {
+  const fileName = filteredArgs[1];
+  if (!fileName) {
+    console.error('错误: 请指定 XML 文件路径');
+    console.log('用法: sks-maximo import-presentation <fileName> [-e env] [-l logname]');
+    process.exit(1);
+  }
+  let logname = null;
+  for (let i = 2; i < filteredArgs.length; i++) {
+    if (filteredArgs[i] === '--logname' || filteredArgs[i] === '-l') {
+      logname = filteredArgs[i + 1];
+      i++;
+    }
+  }
+  loadConfig(globalEnv);
+  (async () => {
+    try {
+      const result = await importMaxPresentation({ fileName, logname: logname || fileName });
+      if (result) {
+        console.log('导入成功');
+      } else {
+        console.error('导入失败');
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error('导入出错:', error.message);
+      process.exit(1);
+    }
+  })();
+} else if (cmd === 'import-script') {
+  const fileName = filteredArgs[1];
+  if (!fileName) {
+    console.error('错误: 请指定脚本 JSON 配置文件路径');
+    console.log('用法: sks-maximo import-script <fileName> [-e env] [-l logname]');
+    process.exit(1);
+  }
+  let logname = null;
+  for (let i = 2; i < filteredArgs.length; i++) {
+    if (filteredArgs[i] === '--logname' || filteredArgs[i] === '-l') {
+      logname = filteredArgs[i + 1];
+      i++;
+    }
+  }
+  loadConfig(globalEnv);
+  (async () => {
+    try {
+      const result = await importMaxScript({ fileName, logname: logname || fileName });
+      if (result) {
+        console.log('导入成功');
+      } else {
+        console.error('导入失败');
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error('导入出错:', error.message);
+      process.exit(1);
+    }
+  })();
+} else if (cmd === 'import-domain') {
+  const fileName = filteredArgs[1];
+  if (!fileName) {
+    console.error('错误: 请指定域 JSON 文件路径');
+    console.log('用法: sks-maximo import-domain <fileName> [-e env] [-l logname]');
+    process.exit(1);
+  }
+  let logname = null;
+  for (let i = 2; i < filteredArgs.length; i++) {
+    if (filteredArgs[i] === '--logname' || filteredArgs[i] === '-l') {
+      logname = filteredArgs[i + 1];
+      i++;
+    }
+  }
+  loadConfig(globalEnv);
+  (async () => {
+    try {
+      const result = await importMaxDomain({ fileName, logname: logname || fileName });
+      if (result) {
+        console.log('导入成功');
+      } else {
+        console.error('导入失败');
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error('导入出错:', error.message);
+      process.exit(1);
+    }
+  })();
 } else {
-  loadConfig(env);
+  console.error(`不支持的命令: ${cmd}`);
+  console.log('使用 sks-maximo --help 查看帮助信息');
+  process.exit(1);
 }
 
 export * from './nodeutils/maximoTools.js';

package/index.js

@@ -2,6 +2,6 @@
 export { loadConfig, getConfig, getWorkDir } from './nodeutils/config.js';
 export { default as logger } from './nodeutils/logger.js';
 export { default as request } from './nodeutils/requestHttp.js';
-export { readFileContent, readJsonFile, readXmlFile, fileExists } from './nodeutils/fileUtils.js';
-export { importMaxObject, importMaxPresentation, importMaxDomain, importMaxAutoKey, importMaxScript, saveScriptHistory, importMaxAppInfo } from './nodeutils/maximoTools.js';
+export * as fileUtils from './nodeutils/fileUtils.js';
+export { importMaxObject, importMaxPresentation, importMaxDomain, importMaxAutoKey, importMaxScript, saveScriptHistory, importMaxAppInfo, callMaxScript, batchImport, printBatchStats } from './nodeutils/maximoTools.js';
 export { sendMockData, sendMockDataBatch, sendPOMockData, sendPOMockDataBatch, sendRlImportMockDataBatch } from './nodeutils/mockdataTools.js';

package/nodeutils/fileUtils.js

@@ -88,9 +88,70 @@ function fileExists(fileNameIn) {
   }
 }
 
+/**
+ * 通用文件路径转换 - 将各种形式的文件路径转换为规范化后的实际可用路径
+ * @param {string} fileName - 文件名或路径（支持相对路径、绝对路径）
+ * @returns {string} 规范化后的绝对路径
+ */
+function resolveFilePath(fileName) {
+  if (!fileName) return '';
+  // 统一分隔符
+  fileName = fileName.replace(/\\/g, '/');
+  // 绝对路径直接规范化返回
+  if (path.isAbsolute(fileName)) {
+    return path.normalize(fileName);
+  }
+  // 相对路径拼接工作目录
+  return path.normalize(path.join(getWorkDir(), fileName));
+}
+
+/**
+ * 列出目录中的文件
+ * @param {string} dirName - 目录名（相对或绝对路径）
+ * @param {string} [extFilter] - 文件扩展名过滤，如 '.json'、'.js'，不传则返回所有文件
+ * @param {boolean} [recursive=true] - 是否递归检索子目录
+ * @returns {string[]} 文件全路径数组
+ */
+function listFiles(dirName, extFilter, recursive = true) {
+  const dirPath = path.isAbsolute(dirName.replace(/\\/g, '/')) ? dirName : path.join(getWorkDir(), dirName);
+
+  try {
+    if (!fs.existsSync(dirPath)) {
+      console.error(`目录不存在: ${dirPath}`);
+      return [];
+    }
+
+    const results = [];
+
+    function scanDir(currentPath, baseRelative) {
+      const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(currentPath, entry.name);
+        const relativePath = baseRelative ? path.join(baseRelative, entry.name) : entry.name;
+
+        if (entry.isFile()) {
+          if (!extFilter || entry.name.endsWith(extFilter)) {
+            results.push(fullPath);
+          }
+        } else if (entry.isDirectory() && recursive) {
+          scanDir(fullPath, relativePath);
+        }
+      }
+    }
+
+    scanDir(dirPath, '');
+    return results;
+  } catch (error) {
+    console.error(`列出目录文件失败: ${dirName}`, error.message);
+    return [];
+  }
+}
+
 export {
   readFileContent,
   readJsonFile,
   readXmlFile,
-  fileExists
+  fileExists,
+  listFiles,
+  resolveFilePath
 };

package/nodeutils/logger.js

@@ -8,6 +8,17 @@ const LEVELS = {
   FATAL: 5
 };
 
+// 颜色定义
+const COLORS = {
+  TRACE: '\x1b[90m',  // 灰色
+  DEBUG: '\x1b[36m',  // 青色
+  INFO:  '\x1b[32m',  // 绿色
+  WARN:  '\x1b[33m',  // 黄色
+  ERROR: '\x1b[31m',  // 红色
+  FATAL: '\x1b[1;31m' // 粗体红
+};
+const RESET = '\x1b[0m';
+
 class ConsoleLogger {
   constructor(level = 'INFO') {
     this.level = LEVELS[level] !== undefined ? LEVELS[level] : LEVELS.INFO;
@@ -27,7 +38,8 @@ class ConsoleLogger {
     if (levelValue < this.level) return;
 
     const timestamp = new Date().toLocaleTimeString();
-    const prefix = `[${timestamp}] [${levelName}]`;
+    const color = COLORS[levelName] || '';
+    const prefix = `${color}[${timestamp}] [${levelName}]${RESET}`;
 
     switch (levelValue) {
       case LEVELS.TRACE:
@@ -36,11 +48,11 @@ class ConsoleLogger {
         console.log(prefix, ...args);
         break;
       case LEVELS.WARN:
-        console.warn(prefix, ...args); // 输出到 stderr，但通常显示为黄色警告
+        console.warn(prefix, ...args);
         break;
       case LEVELS.ERROR:
       case LEVELS.FATAL:
-        console.error(prefix, ...args); // 输出到 stderr，通常显示为红色错误
+        console.error(prefix, ...args);
         break;
     }
   }

package/nodeutils/maximoTools.js

@@ -1,8 +1,9 @@
 import request from '../nodeutils/requestHttp.js'
-import { readFileContent, readJsonFile, readXmlFile } from './fileUtils.js'
+import { readFileContent, readJsonFile, readXmlFile, resolveFilePath, listFiles } from './fileUtils.js'
 import logger from './logger.js';
 import { getConfig } from './config.js';
 import os from 'os'
+import path from 'path'
 
 /**
  * 导入Maximo对象配置
@@ -177,7 +178,7 @@ export async function importMaxDomain({fileName, logname}) {
         
         logger.warn(`[${logname}]收到响应`);
         logger.warn(`[${logname}]响应类型:`, typeof response);
-        logger.debug(`[${logname}]响应内容:`, response);
+        logger.warn(`[${logname}]响应内容:`, response);
         
         // 检查响应 - requestHttp的响应拦截器已返回res.data
         if (response !== null && response !== undefined) {
@@ -255,10 +256,23 @@ export async function saveScriptHistory({autoscript, source, version = '', alias
  */
 export async function importMaxScript({fileName, logname}) {
     try {
-        const jsonContent = readJsonFile(fileName);
+        // 使用通用路径转换方法解析路径
+        const resolvedFilePath = resolveFilePath(fileName);
+        const fileExt = path.extname(resolvedFilePath).toLowerCase();
+        
+        // 如果不是JSON文件（如直接传入了.js/.py脚本文件路径），自动找同目录下的同名JSON配置文件
+        let jsonFilePath = resolvedFilePath;
+        if (fileExt !== '.json') {
+            const dir = path.dirname(resolvedFilePath);
+            const baseName = path.basename(resolvedFilePath, fileExt);
+            jsonFilePath = path.join(dir, `${baseName}.json`);
+            logger.info(`[导入脚本] 传入的是脚本文件，尝试查找配置文件: ${jsonFilePath}`);
+        }
+        
+        const jsonContent = readJsonFile(jsonFilePath);
         
         if (!jsonContent) {
-            logger.error(`文件读取失败: ${fileName}`);
+            logger.error(`配置文件读取失败: ${jsonFilePath}`);
             return false;
         }
         
@@ -275,12 +289,13 @@ export async function importMaxScript({fileName, logname}) {
         const scriptExt = isPython ? '.py' : '.js';
         
         const actualLogname = logname || autoscript;
-        logger.info(`[${actualLogname}]成功读取配置文件: ${fileName}`);
+        logger.info(`[${actualLogname}]成功读取配置文件: ${jsonFilePath}`);
         logger.warn(`[${actualLogname}]脚本名称: ${autoscript}`);
         logger.warn(`[${actualLogname}]脚本语言: ${scriptLanguage}`);
         
-        const dirname = fileName.substring(0, fileName.lastIndexOf('/')) || fileName.substring(0, fileName.lastIndexOf('\\')) || '';
-        const scriptFileName = dirname ? `${dirname}/${autoscript}${scriptExt}` : `${autoscript}${scriptExt}`;
+        // 脚本文件路径：在配置文件同目录下，按 autoscript 名称查找
+        const dirname = path.dirname(jsonFilePath);
+        const scriptFileName = path.join(dirname, `${autoscript}${scriptExt}`);
         
         const fileContent = readFileContent(scriptFileName);
         
@@ -607,4 +622,189 @@ export async function importMaxAppInfo({fileName, logname}) {
         }
         return false
     }
-}
+}
+export async function callMaxScript({ apiScriptName, fileName, params = {}, logname }) {
+    if (!apiScriptName) {
+        logger.error('[callMaxScript]脚本名称不能为空')
+        return false
+    }
+    
+    const actualLogname = logname || apiScriptName
+    
+    try {
+        logger.info(`[${actualLogname}]开始调用脚本: ${apiScriptName}`)
+        
+        let data = null
+        if (fileName) {
+            const fileContent = readFileContent(fileName)
+            if (!fileContent) {
+                logger.error(`[${actualLogname}]文件读取失败: ${fileName}`)
+                return false
+            }
+            logger.info(`[${actualLogname}]已读取请求体文件: ${fileName}`)
+            
+            if (fileName.endsWith('.json')) {
+                try {
+                    data = JSON.parse(fileContent)
+                } catch (e) {
+                    logger.error(`[${actualLogname}]JSON解析失败: ${e.message}`)
+                    return false
+                }
+            } else {
+                data = fileContent
+            }
+        }
+        
+        const requestConfig = {
+            url: `/api/script/${apiScriptName}`,
+            method: data ? 'POST' : 'GET',
+            params: {
+                ...params,
+                _langcode: getConfig().langcode,
+            }
+        }
+        
+        if (data !== null) {
+            requestConfig.data = data
+        }
+        
+        const response = await request(requestConfig)
+        
+        logger.info(`[${actualLogname}]收到响应`)
+        logger.warn(`[${actualLogname}]响应内容:`, response)
+        
+        if (response !== null && response !== undefined) {
+            logger.info(`[${actualLogname}]调用成功`)
+            return response
+        } else {
+            logger.error(`[${actualLogname}]调用失败，响应为空或null`)
+            return null
+        }
+    } catch (error) {
+        logger.error(`[${actualLogname}]请求出错:`, error.message)
+        if (error.response) {
+            logger.error(`[${actualLogname}]服务器返回错误:`, error.response.data)
+        } else if (error.request) {
+            logger.error(`[${actualLogname}]请求已发出但无响应`)
+        } else {
+            logger.error(`[${actualLogname}]错误详情:`, error)
+        }
+        return null
+    }
+}
+
+/**
+ * 通用批量导入 - 支持各种导入功能（对象、脚本、应用信息、域、应用XML等）的批量处理
+ * @param {Object} options - 配置选项
+ * @param {string} [options.dirName] - 目录名（与files二选一），自动列出目录下符合条件的文件
+ * @param {string[]} [options.files] - 文件路径数组（与dirName二选一），直接指定要导入的文件
+ * @param {string} [options.extFilter] - 扩展名过滤，如 '.json'、'.xml'（配合dirName使用）
+ * @param {boolean} [options.recursive=true] - 是否递归检索子目录（配合dirName使用）
+ * @param {Function} options.importFn - 导入函数，接收 {fileName, logname} 参数，如 importMaxObject、importMaxScript 等
+ * @param {string} [options.logname] - 日志打印名称
+ * @param {number} [options.concurrency=1] - 并发数量，默认1串行执行
+ * @param {boolean} [options.continueOnError=true] - 单个文件失败时是否继续，默认继续
+ * @returns {Promise<Object>} 批量导入统计结果
+ */
+export async function batchImport({ dirName, files, extFilter, recursive = true, importFn, logname = '批量导入', concurrency = 1, continueOnError = true }) {
+    if (typeof importFn !== 'function') {
+        logger.error('[batchImport]必须指定importFn导入函数')
+        return null;
+    }
+    
+    let fileNames = [];
+    if (files && Array.isArray(files) && files.length > 0) {
+        fileNames = files;
+    } else if (dirName) {
+        fileNames = listFiles(dirName, extFilter, recursive);
+    } else {
+        logger.error('[batchImport]必须指定dirName或files');
+        return null;
+    }
+    
+    if (fileNames.length === 0) {
+        logger.warn('[batchImport]没有找到需要导入的文件');
+        return null;
+    }
+    
+    const stats = {
+        fileCount: fileNames.length,
+        successCount: 0,
+        failCount: 0,
+        successList: [],
+        failList: [],
+        startTime: new Date().getTime(),
+        endTime: null,
+        totalTime: null
+    };
+    
+    logger.warn(`[${logname}]开始批量导入，共 ${fileNames.length} 个文件，并发数: ${concurrency}`);
+    
+    // 并发池处理
+    let index = 0;
+    const worker = async () => {
+        while (index < fileNames.length) {
+            const cur = index++;
+            const filename = fileNames[cur];
+            try {
+                const result = await importFn({ fileName: filename, logname });
+                if (result) {
+                    stats.successCount++;
+                    stats.successList.push(filename);
+                } else {
+                    stats.failCount++;
+                    stats.failList.push(filename);
+                }
+            } catch (error) {
+                stats.failCount++;
+                stats.failList.push(filename);
+                logger.error(`[${logname}]导入异常: ${filename}`, error.message);
+                if (!continueOnError) {
+                    throw error;
+                }
+            }
+            logger.warn(`[${logname}]进度: ${cur + 1}/${fileNames.length} 成功: ${stats.successCount} 失败: ${stats.failCount}`);
+        }
+    };
+    
+    const workerCount = Math.max(1, Math.min(concurrency, fileNames.length));
+    await Promise.all(Array.from({ length: workerCount }, () => worker()));
+    
+    stats.endTime = new Date().getTime();
+    stats.totalTime = stats.endTime - stats.startTime;
+    
+    logger.warn(`[${logname}]批量导入完成，耗时: ${stats.totalTime}ms，成功: ${stats.successCount}，失败: ${stats.failCount}`);
+    if (stats.failList.length > 0) {
+        logger.warn(`[${logname}]失败文件列表:`);
+        stats.failList.forEach(f => logger.warn(`  ${f}`));
+    }
+    
+    return stats;
+}
+
+/**
+ * 打印批量导入统计结果
+ * @param {Object} stats - batchImport 返回的统计结果
+ * @param {string} [logname] - 日志打印名称
+ */
+export function printBatchStats(stats, logname = '批量导入') {
+    if (!stats) {
+        logger.warn(`[${logname}]无统计结果可打印`);
+        return;
+    }
+    const formatDateTime = (timestamp) => {
+        const d = new Date(timestamp);
+        const pad = n => String(n).padStart(2, '0');
+        return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+    };
+    logger.warn(`[${logname}]========== 批量导入统计 ==========`);
+    logger.warn(`[${logname}]总文件数: ${stats.fileCount}`);
+    logger.warn(`[${logname}]成功数量: ${stats.successCount}`);
+    logger.warn(`[${logname}]失败数量: ${stats.failCount}`);
+    logger.warn(`[${logname}]开始时间: ${formatDateTime(stats.startTime)} 结束时间: ${formatDateTime(stats.endTime)} 耗时: ${stats.totalTime}ms`);
+    logger.warn(`[${logname}]成功文件列表:`);
+    stats.successList.forEach(f => logger.warn(`  ${f}`));
+    logger.warn(`[${logname}]失败文件列表:`);
+    stats.failList.forEach(f => logger.warn(`  ${f}`));
+    logger.warn(`[${logname}]====================================`);
+}

package/nodeutils/requestHttp.js

@@ -27,6 +27,10 @@ function limitLogOutput(data, maxLength = 200) {
   }
 }
 
+function joinUrl(base, path) {
+  return `${base.replace(/\/$/, '')}/${path.replace(/^\//, '')}`;
+}
+
 function getLogDir() {
   return path.join(os.homedir(), '.sks', 'nodeutils', 'logs');
 }
@@ -39,7 +43,7 @@ function saveRequestLog(config, globalConfig) {
     }
 
     const method = config.method?.toUpperCase() || 'GET';
-    let url = `${config.url}`;
+    let url = joinUrl(globalConfig.baseUrl, config.url);
     
     if (config.params && Object.keys(config.params).length > 0) {
       const paramsStr = Object.entries(config.params)
@@ -79,6 +83,44 @@ function saveRequestLog(config, globalConfig) {
   }
 }
 
+function saveErrorLog(error) {
+  try {
+    const logDir = getLogDir();
+    if (!fs.existsSync(logDir)) {
+      fs.mkdirSync(logDir, { recursive: true });
+    }
+
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const method = error.config?.method?.toUpperCase() || 'GET';
+    const fullUrl = error.config ? joinUrl(getConfig().baseUrl, error.config.url) : 'unknown';
+    
+    const errorLog = {
+      timestamp: timestamp,
+      method: method,
+      url: fullUrl,
+      message: error.message,
+      status: error.response?.status,
+      statusText: error.response?.statusText,
+      headers: error.response?.headers,
+      data: error.response?.data || error.data,
+      config: {
+        url: error.config?.url,
+        method: error.config?.method,
+        params: error.config?.params,
+        data: error.config?.data
+      }
+    };
+
+    const fileName = `response-error-${method}-${timestamp}.json`;
+    const filePath = path.join(logDir, fileName);
+
+    fs.writeFileSync(filePath, JSON.stringify(errorLog, null, 2), 'utf-8');
+
+    logger.warn(`[HTTP Log] 错误日志已保存: ${filePath}`);
+  } catch (e) {
+    logger.error('[HTTP Log] 保存错误日志失败:', e.message);
+  }
+}
 function saveResponseLog(response) {
   try {
     const logDir = getLogDir();
@@ -88,12 +130,24 @@ function saveResponseLog(response) {
 
     const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
     const method = response.config.method?.toUpperCase() || 'GET';
+    const fullUrl = joinUrl(getConfig().baseUrl, response.config.url);
+    
+    const responseLog = {
+      timestamp: timestamp,
+      method: method,
+      url: fullUrl,
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers,
+      data: response.data
+    };
+
     const fileName = `response-${method}-${timestamp}.json`;
     const filePath = path.join(logDir, fileName);
 
-    fs.writeFileSync(filePath, JSON.stringify(response.data, null, 2), 'utf-8');
+    fs.writeFileSync(filePath, JSON.stringify(responseLog, null, 2), 'utf-8');
 
-    logger.error(`[HTTP Log] 响应日志已保存: ${filePath}`);
+    logger.warn(`[HTTP Log] 响应日志已保存: ${filePath}`);
   } catch (error) {
     logger.error('[HTTP Log] 保存响应日志失败:', error.message);
   }
@@ -140,7 +194,7 @@ function createService() {
     if (!config.params['_langcode']) {
       config.params['_langcode'] = globalConfig.langcode || 'zh';
     }
-    var url = `${config.method} ${globalConfig.baseUrl}${config.url}`;
+    var url = `${config.method} ${joinUrl(globalConfig.baseUrl, config.url)}`;
     if (config.params && Object.keys(config.params).length > 0) {
       if (url.indexOf('?') > -1) {
         url += `&`;
@@ -200,18 +254,27 @@ function createService() {
       return Promise.reject(new Error('未知错误'));
     }
   }, error => {
-    logger.error('[Response Error] 请求错误:', error.message);
     try{
       if(error){
+        logger.error('[Response Error] 请求错误:', error.message);
+        saveErrorLog(error);
         logger.debug('[Response Error] 错误对象:', error);
         if (error.data) {
           logger.info('[Response Error] 错误error.data:', error.data);
         }
         if (error.response&&error.response.data) {
           logger.info('[Response Error] 错误error.response.data:', error.response.data);
-          if(error.response.data['oslc:Error']&&error.response.data['oslc:Error']['oslc:extendedError']&&error.response.data['oslc:Error']['oslc:extendedError']['oslc:moreInfo']){
-            logger.info('[Response Error] 错误error.response.data:', error.response.data['oslc:Error']['oslc:extendedError']['oslc:moreInfo']);
+          if (error.response.data['oslc:Error']) {
+            if (error.response.data['oslc:Error']['oslc:message']) {
+                logger.error('[Response Error] 错误error.response.data.oslc:Error.oslc:message:\x1b[32m['+error.response.data['oslc:Error']['oslc:message']+"]\x1b[0m");
+            }else if (error.response.data['oslc:Error']['oslc:extendedError']) {
+              if (error.response.data['oslc:Error']['oslc:extendedError']['oslc:moreInfo']) {
+                logger.error('[Response Error] 错误error.response.data:', error.response.data['oslc:Error']['oslc:extendedError']['oslc:moreInfo']);
 
+              }
+            } else {
+              logger.error('[Response Error] 错误error.response.data.oslc:Error', error.response.data['oslc:Error']);
+            }
           }
         }
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sks-maximo-utils",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Maximo helper tools for updating table structures and data",
   "type": "module",
   "main": "index.js",
@@ -10,7 +10,10 @@
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
-  "keywords": ["maximo", "sks"],
+  "keywords": [
+    "maximo",
+    "sks"
+  ],
   "author": "shoukaiseki",
   "license": "ISC",
   "dependencies": {