sks-maximo-utils 1.0.6 → 1.0.8

package/CLI.md

@@ -7,6 +7,11 @@
 | `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>` | 导入域配置 |
 
 ---
 
@@ -37,7 +42,91 @@ sks-maximo hd       # 使用测试环境配置
 
 ---
 
-## 3. 调用通用脚本接口
+## 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>]
@@ -52,26 +141,26 @@ sks-maximo call <scriptName> [--file <fileName>] [--params <params>] [--logname
 | `--params` | `-p` | URL 查询参数（JSON格式） | 否 |
 | `--logname` | `-l` | 日志名称 | 否 |
 
-### 3.1 GET 请求（无请求体）
+### 4.1 GET 请求（无请求体）
 
 ```bash
-sks-maximo call SHARPTREE.AUTOSCRIPT.LIBRARY --params '{"name":"TEST"}'
+sks-maximo call SKS.AUTOSCRIPT.LIBRARY --params '{"name":"TEST"}'
 ```
 
-### 3.2 POST 请求（带请求体文件）
+### 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.AUTOSCRIPT.SCREENS --file screens/test.xml
 
 # 同时带参数和请求体
 sks-maximo call SKS_IMP_MAXAPPINFO --file appinfo.json --params '{"debug":true}' --logname "导入应用信息"
 ```
 
-### 3.3 请求体文件处理
+### 4.3 请求体文件处理
 
 - **`.json` 文件**：自动解析为 JSON 对象作为请求体
 - **其他文件**：读取文件内容作为字符串请求体
@@ -111,7 +200,7 @@ sks-maximo call SKS_IMP_MAXAPPINFO --file appinfo.json --params '{"debug":true}'
 ### 示例 1：查询脚本库
 
 ```bash
-sks-maximo call SHARPTREE.AUTOSCRIPT.LIBRARY --params '{"name":"MY_SCRIPT"}'
+sks-maximo call SKS.AUTOSCRIPT.LIBRARY --params '{"name":"MY_SCRIPT"}'
 ```
 
 ### 示例 2：部署自动编码

package/README.md

@@ -40,9 +40,13 @@ import {
   importMaxAutoKey,
   importMaxScript,
   importMaxAppInfo,
+  callMaxScript,
+  batchImport,
+  printBatchStats,
+  fileUtils,
   loadConfig,
   logger
-} from 'shoukaiseki-maximo-utils';
+} from 'sks-maximo-utils';
 
 // 加载配置（可选，默认 local）
 loadConfig('local');
@@ -66,6 +70,32 @@ importMaxScript({ fileName: "scripts/TEST.json" });
 
 // 导入应用信息配置
 importMaxAppInfo({ fileName: "MAXAPPINFO/appinfo.json", logname: "应用信息" });
+
+// 通用脚本接口调用（GET）
+callMaxScript({ apiScriptName: "SKS.AUTOSCRIPT.LIBRARY", params: { name: "test" }, logname: "查询脚本库" });
+
+// 通用脚本接口调用（POST，读取文件内容作为请求体）
+callMaxScript({ apiScriptName: "SKS_DEPLOY_AUTOKEY", fileName: "data/autokey.json", logname: "部署自动编码" });
+
+// 通用批量导入（支持对象、脚本、域、应用信息等所有导入功能）
+const stats = await batchImport({
+    dirName: "C:/Temp/hd/maxobject_backup",   // 目录名（与files二选一）
+    extFilter: ".json",                         // 扩展名过滤
+    importFn: importMaxObject,                  // 导入函数（可换成其他导入方法）
+    logname: "批量导入对象",
+    concurrency: 1                              // 并发数，默认1串行
+});
+printBatchStats(stats);  // 打印批量导入统计结果
+
+// 直接指定文件列表批量导入
+await batchImport({
+    files: ["a.json", "b.json", "c.json"],
+    importFn: importMaxDomain
+});
+
+// 文件工具
+fileUtils.listFiles('scripts', '.json');
+fileUtils.readFileContent('test.txt');
 ```
 
 ## 配置文件
@@ -126,11 +156,18 @@ importMaxAppInfo({ fileName: "MAXAPPINFO/appinfo.json", logname: "应用信息"
 
 | 方法 | 说明 |
 |------|------|
+| callMaxScript | 通用脚本接口调用（GET/POST） |
+| batchImport | 通用批量导入（支持对象、脚本、域、应用信息等所有导入功能） |
+| printBatchStats | 打印批量导入统计结果 |
 | loadConfig(env) | 加载指定环境配置 |
 | saveScriptHistory(options) | 保存脚本历史记录 |
 | readFileContent(fileName) | 读取文件内容 |
 | readJsonFile(fileName) | 读取并解析 JSON 文件 |
 | fileExists(fileName) | 检查文件是否存在 |
+| fileUtils.resolveFilePath(fileName) | 通用路径转换（相对/绝对路径转规范化绝对路径） |
+| fileUtils.listFiles(dirName, extFilter, recursive) | 列出目录文件 |
+| fileUtils.readFileContent(fileName) | 读取文件内容 |
+| fileUtils.readJsonFile(fileName) | 读取并解析 JSON 文件 |
 
 ### 日志文件
 

package/cli.js

@@ -3,15 +3,28 @@ import { exec } from 'child_process';
 import { readFileSync } from 'fs';
 import { fileURLToPath, URL } from 'url';
 import { checkAndCreateConfig, getConfigDir, loadConfig } from './nodeutils/config.js';
-import { callMaxScript } from './nodeutils/maximoTools.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 cmd = args[0];
-const env = args[0];
+
+// 解析全局选项（--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}`);
@@ -19,7 +32,12 @@ if (!cmd || ['-h', '--help', '-?', '--version', '-v'].includes(cmd)) {
   console.log('用法:');
   console.log('  sks-maximo              # 检查配置文件并打开配置目录');
   console.log('  sks-maximo <env>        # 加载指定环境配置');
-  console.log('  sks-maximo call <scriptName> [--file <fileName>] [--params <params>]  # 调用脚本接口');
+  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                   # 使用本地环境配置');
@@ -28,10 +46,16 @@ if (!cmd || ['-h', '--help', '-?', '--version', '-v'].includes(cmd)) {
   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('');
@@ -93,7 +117,7 @@ if (!cmd || ['-h', '--help', '-?', '--version', '-v'].includes(cmd)) {
     }
   }
   
-  loadConfig('local');
+  loadConfig(globalEnv);
   
   (async () => {
     try {
@@ -109,8 +133,148 @@ if (!cmd || ['-h', '--help', '-?', '--version', '-v'].includes(cmd)) {
       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, callMaxScript } 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对象配置
@@ -33,7 +34,7 @@ export async function importMaxObject({fileName, logname}) {
         // 发送请求到Maximo API
         logger.info(`[${logname}]开始发送请求...`);
         const response = await request({
-            url: '/api/script/SHARPTREE.AUTOSCRIPT.LIBRARY',
+            url: '/api/script/SKS.AUTOSCRIPT.LIBRARY',
             method: 'post',
             params: {
                 develop: true,
@@ -100,7 +101,7 @@ export async function importMaxPresentation({fileName, logname}) {
         
         logger.info(`[${logname}]开始发送请求...`);
         const response = await request({
-            url: '/api/script/SHARPTREE.AUTOSCRIPT.SCREENS',
+            url: '/api/script/SKS.AUTOSCRIPT.SCREENS',
             method: 'post',
               headers: {
                 'Content-Type': 'application/xml'
@@ -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);
         
@@ -656,7 +671,7 @@ export async function callMaxScript({ apiScriptName, fileName, params = {}, logn
         const response = await request(requestConfig)
         
         logger.info(`[${actualLogname}]收到响应`)
-        logger.debug(`[${actualLogname}]响应内容:`, response)
+        logger.warn(`[${actualLogname}]响应内容:`, response)
         
         if (response !== null && response !== undefined) {
             logger.info(`[${actualLogname}]调用成功`)
@@ -677,3 +692,119 @@ export async function callMaxScript({ apiScriptName, fileName, params = {}, logn
         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

@@ -265,17 +265,15 @@ function createService() {
         if (error.response&&error.response.data) {
           logger.info('[Response Error] 错误error.response.data:', error.response.data);
           if (error.response.data['oslc:Error']) {
-            if (error.response.data['oslc:Error']['oslc:extendedError']) {
+            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 {
-              if(error.response.data['oslc:Error']['oslc:message']){
-                logger.error('[Response Error] 错误error.response.data.oslc:Error.oslc:message:', error.response.data['oslc:Error']['oslc:message']);
-              }else{
-                logger.error('[Response Error] 错误error.response.data.oslc:Error.oslc:message:', error.response.data['oslc:Error']);
-              }
+              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.6",
+  "version": "1.0.8",
   "description": "Maximo helper tools for updating table structures and data",
   "type": "module",
   "main": "index.js",