@widget-js/cli 1.1.3 → 1.1.5

package/lib/index.cjs

@@ -496,7 +496,65 @@ async function checkParentDir(ftpClient, file, onMkdir) {
     await ftpClient.mkdir(dir, true);
   }
 }
-function ftpUpload() {
+async function runSSH(sshConfig, releaseConfig) {
+  import_consola3.default.info("run ssh:", sshConfig);
+  const answer = await import_inquirer3.default.prompt([{ type: "password", name: "password", mask: "*", message: "Enter key pair password" }]);
+  let ftpClient = new import_ssh2_sftp_client.default();
+  const port = sshConfig["Port"];
+  const key = import_fs7.default.readFileSync(import_path3.default.resolve(import_os.default.homedir(), ".ssh/id_rsa"));
+  const spinner3 = (0, import_ora4.default)("Connecting");
+  try {
+    spinner3.start();
+    await ftpClient.connect({
+      host: sshConfig["HostName"],
+      port: port ? parseInt(port) : 22,
+      username: sshConfig["User"],
+      passphrase: answer.password,
+      privateKey: key
+    });
+    releaseConfig.fileMap.sort((it1, it2) => (it1.order ?? 0) - (it2.order ?? 0));
+    for (let item of releaseConfig.fileMap) {
+      if (typeof item.src == "string") {
+        if (item.remoteCopy) {
+          await checkParentDir(ftpClient, item.dest, (dir) => {
+            spinner3.warn(`Create Dir: ${dir}`);
+          });
+          let destExists = await ftpClient.exists(item.dest);
+          if (destExists) {
+            spinner3.warn(`Delete exists file:${item.dest}`);
+            await ftpClient.delete(item.dest);
+          }
+          spinner3.info(`Copying File: ${item.src} -> ${item.dest}`);
+          await ftpClient.rcopy(item.src, item.dest);
+        } else {
+          const localFile = import_path3.default.resolve(process3.cwd(), item.src);
+          if (!item.remoteCopy && !import_fs7.default.existsSync(localFile)) {
+            spinner3.warn(`Skip not exists file:${localFile}`);
+            continue;
+          }
+          if (import_fs7.default.lstatSync(localFile).isDirectory()) {
+            spinner3.info(`Uploading Dir: ${localFile} -> ${item.dest}`);
+            await ftpClient.uploadDir(localFile, item.dest);
+          } else {
+            await checkParentDir(ftpClient, item.dest, (dir) => {
+              spinner3.warn(`Create Dir: ${dir}`);
+            });
+            spinner3.info(`Uploading File: ${localFile} -> ${item.dest}`);
+            await ftpClient.put(localFile, item.dest);
+          }
+        }
+      } else {
+        await ftpClient.put(Buffer.from(JSON.stringify(item.src), "utf-8"), item.dest);
+      }
+    }
+    spinner3.succeed("Files uploaded!");
+    await ftpClient.end();
+  } catch (e) {
+    spinner3.fail(`Connection error:${e}`);
+    await ftpClient.end();
+  }
+}
+async function ftpUpload() {
   const releaseJsonFilePath = import_path3.default.join(process3.cwd(), "release.json");
   const packageVersion = getPackageVersion();
   import_consola3.default.info("Package Version:", packageVersion);
@@ -505,68 +563,14 @@ function ftpUpload() {
   const sshConfigFile = import_path3.default.resolve(import_os.default.homedir(), ".ssh/config");
   import_consola3.default.info("SSH Config File Path:", sshConfigFile);
   const sshConfigs = import_ssh_config.default.parse(import_fs7.default.readFileSync(sshConfigFile).toString());
-  let sshConfig = sshConfigs.compute(releaseConfig.ftpConfig.host);
-  if (!sshConfig) {
-    import_consola3.default.error(`SSH config ${releaseConfig.ftpConfig.host} not found`);
-    return;
-  }
-  import_consola3.default.info(sshConfig);
-  import_inquirer3.default.prompt([{ type: "password", name: "password", mask: "*", message: "Enter key pair password" }]).then(async (answer) => {
-    let ftpClient = new import_ssh2_sftp_client.default();
-    const port = sshConfig["Port"];
-    const key = import_fs7.default.readFileSync(import_path3.default.resolve(import_os.default.homedir(), ".ssh/id_rsa"));
-    const spinner3 = (0, import_ora4.default)("Connecting");
-    try {
-      spinner3.start();
-      await ftpClient.connect({
-        host: sshConfig["HostName"],
-        port: port ? parseInt(port) : 22,
-        username: sshConfig["User"],
-        passphrase: answer.password,
-        privateKey: key
-      });
-      releaseConfig.fileMap.sort((it1, it2) => (it1.order ?? 0) - (it2.order ?? 0));
-      for (let item of releaseConfig.fileMap) {
-        if (typeof item.src == "string") {
-          if (item.remoteCopy) {
-            await checkParentDir(ftpClient, item.dest, (dir) => {
-              spinner3.warn(`Create Dir: ${dir}`);
-            });
-            let destExists = await ftpClient.exists(item.dest);
-            if (destExists) {
-              spinner3.warn(`Delete exists file:${item.dest}`);
-              await ftpClient.delete(item.dest);
-            }
-            spinner3.info(`Copying File: ${item.src} -> ${item.dest}`);
-            await ftpClient.rcopy(item.src, item.dest);
-          } else {
-            const localFile = import_path3.default.resolve(process3.cwd(), item.src);
-            if (!item.remoteCopy && !import_fs7.default.existsSync(localFile)) {
-              spinner3.warn(`Skip not exists file:${localFile}`);
-              continue;
-            }
-            if (import_fs7.default.lstatSync(localFile).isDirectory()) {
-              spinner3.info(`Uploading Dir: ${localFile} -> ${item.dest}`);
-              await ftpClient.uploadDir(localFile, item.dest);
-            } else {
-              await checkParentDir(ftpClient, item.dest, (dir) => {
-                spinner3.warn(`Create Dir: ${dir}`);
-              });
-              spinner3.info(`Uploading File: ${localFile} -> ${item.dest}`);
-              await ftpClient.put(localFile, item.dest);
-            }
-          }
-        } else {
-          await ftpClient.put(Buffer.from(JSON.stringify(item.src), "utf-8"), item.dest);
-        }
-      }
-      spinner3.succeed("Files uploaded!");
-      await ftpClient.end();
-    } catch (e) {
-      spinner3.fail(`Connection error:${e}`);
-      await ftpClient.end();
+  for (let host of releaseConfig.ftpConfig.host) {
+    let sshConfig = sshConfigs.compute(host);
+    if (!sshConfig) {
+      import_consola3.default.error(`SSH config ${releaseConfig.ftpConfig.host} not found`);
+      return;
     }
-  });
+    await runSSH(sshConfig, releaseConfig);
+  }
 }
 var import_path3, import_fs7, import_ssh_config, import_os, import_ssh2_sftp_client, import_consola3, import_inquirer3, import_ora4, process3;
 var init_ftp = __esm({
@@ -627,6 +631,9 @@ var init_release = __esm({
       if (!import_fs8.default.existsSync(installerPath)) {
         installerPath = import_path4.default.join(`./packaged/electron-${version}-setup-win-x64.exe`);
       }
+      if (!import_fs8.default.existsSync(installerPath)) {
+        installerPath = import_path4.default.join(`./packaged/app-${version}-setup-win-x64.exe`);
+      }
       const updateZipPath = import_path4.default.join(`./packaged/update.zip`);
       console.log(import_chalk3.default.blue("\u538B\u7F29\u66F4\u65B0\u6587\u4EF6\u4E2D"));
       await update_zip_default("./release", updateZipPath);

package/lib/index.js

@@ -27,7 +27,7 @@ program.command("build").description("\u6267\u884C\u7F16\u8BD1\u4EFB\u52A1").act
 });
 var typeOption = new Option("-t, --type <type>").choices(["ftp", "oss"]);
 program.command("release").description("\u901A\u8FC7FTP/OSS\u53D1\u5E03\u6587\u4EF6\uFF0C\u4EC5\u5185\u90E8\u4F7F\u7528").addOption(typeOption).action(async (options, command) => {
-  let release = await import("./release-U3O2EENP.js");
+  let release = await import("./release-W3SP4YSR.js");
   await release.default(options);
 });
 program.parse(process.argv);

package/lib/{release-U3O2EENP.js → release-W3SP4YSR.js}

@@ -84,7 +84,65 @@ async function checkParentDir(ftpClient, file, onMkdir) {
     await ftpClient.mkdir(dir, true);
   }
 }
-function ftpUpload() {
+async function runSSH(sshConfig, releaseConfig) {
+  consola.info("run ssh:", sshConfig);
+  const answer = await inquirer.prompt([{ type: "password", name: "password", mask: "*", message: "Enter key pair password" }]);
+  let ftpClient = new Client();
+  const port = sshConfig["Port"];
+  const key = fs3.readFileSync(path.resolve(os.homedir(), ".ssh/id_rsa"));
+  const spinner = ora("Connecting");
+  try {
+    spinner.start();
+    await ftpClient.connect({
+      host: sshConfig["HostName"],
+      port: port ? parseInt(port) : 22,
+      username: sshConfig["User"],
+      passphrase: answer.password,
+      privateKey: key
+    });
+    releaseConfig.fileMap.sort((it1, it2) => (it1.order ?? 0) - (it2.order ?? 0));
+    for (let item of releaseConfig.fileMap) {
+      if (typeof item.src == "string") {
+        if (item.remoteCopy) {
+          await checkParentDir(ftpClient, item.dest, (dir) => {
+            spinner.warn(`Create Dir: ${dir}`);
+          });
+          let destExists = await ftpClient.exists(item.dest);
+          if (destExists) {
+            spinner.warn(`Delete exists file:${item.dest}`);
+            await ftpClient.delete(item.dest);
+          }
+          spinner.info(`Copying File: ${item.src} -> ${item.dest}`);
+          await ftpClient.rcopy(item.src, item.dest);
+        } else {
+          const localFile = path.resolve(process.cwd(), item.src);
+          if (!item.remoteCopy && !fs3.existsSync(localFile)) {
+            spinner.warn(`Skip not exists file:${localFile}`);
+            continue;
+          }
+          if (fs3.lstatSync(localFile).isDirectory()) {
+            spinner.info(`Uploading Dir: ${localFile} -> ${item.dest}`);
+            await ftpClient.uploadDir(localFile, item.dest);
+          } else {
+            await checkParentDir(ftpClient, item.dest, (dir) => {
+              spinner.warn(`Create Dir: ${dir}`);
+            });
+            spinner.info(`Uploading File: ${localFile} -> ${item.dest}`);
+            await ftpClient.put(localFile, item.dest);
+          }
+        }
+      } else {
+        await ftpClient.put(Buffer.from(JSON.stringify(item.src), "utf-8"), item.dest);
+      }
+    }
+    spinner.succeed("Files uploaded!");
+    await ftpClient.end();
+  } catch (e) {
+    spinner.fail(`Connection error:${e}`);
+    await ftpClient.end();
+  }
+}
+async function ftpUpload() {
   const releaseJsonFilePath = path.join(process.cwd(), "release.json");
   const packageVersion = getPackageVersion();
   consola.info("Package Version:", packageVersion);
@@ -93,68 +151,14 @@ function ftpUpload() {
   const sshConfigFile = path.resolve(os.homedir(), ".ssh/config");
   consola.info("SSH Config File Path:", sshConfigFile);
   const sshConfigs = SSHConfig.parse(fs3.readFileSync(sshConfigFile).toString());
-  let sshConfig = sshConfigs.compute(releaseConfig.ftpConfig.host);
-  if (!sshConfig) {
-    consola.error(`SSH config ${releaseConfig.ftpConfig.host} not found`);
-    return;
-  }
-  consola.info(sshConfig);
-  inquirer.prompt([{ type: "password", name: "password", mask: "*", message: "Enter key pair password" }]).then(async (answer) => {
-    let ftpClient = new Client();
-    const port = sshConfig["Port"];
-    const key = fs3.readFileSync(path.resolve(os.homedir(), ".ssh/id_rsa"));
-    const spinner = ora("Connecting");
-    try {
-      spinner.start();
-      await ftpClient.connect({
-        host: sshConfig["HostName"],
-        port: port ? parseInt(port) : 22,
-        username: sshConfig["User"],
-        passphrase: answer.password,
-        privateKey: key
-      });
-      releaseConfig.fileMap.sort((it1, it2) => (it1.order ?? 0) - (it2.order ?? 0));
-      for (let item of releaseConfig.fileMap) {
-        if (typeof item.src == "string") {
-          if (item.remoteCopy) {
-            await checkParentDir(ftpClient, item.dest, (dir) => {
-              spinner.warn(`Create Dir: ${dir}`);
-            });
-            let destExists = await ftpClient.exists(item.dest);
-            if (destExists) {
-              spinner.warn(`Delete exists file:${item.dest}`);
-              await ftpClient.delete(item.dest);
-            }
-            spinner.info(`Copying File: ${item.src} -> ${item.dest}`);
-            await ftpClient.rcopy(item.src, item.dest);
-          } else {
-            const localFile = path.resolve(process.cwd(), item.src);
-            if (!item.remoteCopy && !fs3.existsSync(localFile)) {
-              spinner.warn(`Skip not exists file:${localFile}`);
-              continue;
-            }
-            if (fs3.lstatSync(localFile).isDirectory()) {
-              spinner.info(`Uploading Dir: ${localFile} -> ${item.dest}`);
-              await ftpClient.uploadDir(localFile, item.dest);
-            } else {
-              await checkParentDir(ftpClient, item.dest, (dir) => {
-                spinner.warn(`Create Dir: ${dir}`);
-              });
-              spinner.info(`Uploading File: ${localFile} -> ${item.dest}`);
-              await ftpClient.put(localFile, item.dest);
-            }
-          }
-        } else {
-          await ftpClient.put(Buffer.from(JSON.stringify(item.src), "utf-8"), item.dest);
-        }
-      }
-      spinner.succeed("Files uploaded!");
-      await ftpClient.end();
-    } catch (e) {
-      spinner.fail(`Connection error:${e}`);
-      await ftpClient.end();
+  for (let host of releaseConfig.ftpConfig.host) {
+    let sshConfig = sshConfigs.compute(host);
+    if (!sshConfig) {
+      consola.error(`SSH config ${releaseConfig.ftpConfig.host} not found`);
+      return;
     }
-  });
+    await runSSH(sshConfig, releaseConfig);
+  }
 }
 
 // src/release/release.ts
@@ -184,6 +188,9 @@ var release = async (options) => {
   if (!fs4.existsSync(installerPath)) {
     installerPath = path2.join(`./packaged/electron-${version}-setup-win-x64.exe`);
   }
+  if (!fs4.existsSync(installerPath)) {
+    installerPath = path2.join(`./packaged/app-${version}-setup-win-x64.exe`);
+  }
   const updateZipPath = path2.join(`./packaged/update.zip`);
   console.log(chalk2.blue("\u538B\u7F29\u66F4\u65B0\u6587\u4EF6\u4E2D"));
   await update_zip_default("./release", updateZipPath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@widget-js/cli",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "main": "lib/index.js",
   "author": "Neo Fu",
   "license": "MIT",
@@ -65,6 +65,7 @@
     "build:run": "npm run build && npm run widget",
     "prebuild": "",
     "widget": "node ./lib/index.js",
+    "widget:ftp": "node ./lib/index.js release -t ftp",
     "pnpm:publish": "pnpm publish --no-git-checks"
   }
 }

package/release.json

@@ -1,21 +1,7 @@
 {
   "fileMap": [
-    {
-      "src": "./dist/youlu-${version}-setup-win-ia32.exe",
-      "dest": "/www/wwwroot/download.tool-vip.com/youlu/youlu.exe",
-      "order": 0
-    },
-    {
-      "src": ".gitignore",
-      "dest": "/www/wwwroot/template/aa/.gitignore"
-    },
-    {
-      "src": "/www/wwwroot/template/aa/.gitignore",
-      "dest": "/www/wwwroot/template/bbb/.gitignorexxx",
-      "remoteCopy": true
-    }
   ],
   "ftpConfig": {
-    "host": "youlu"
+    "host": ["youlu","itime"]
   }
 }

package/src/release/ftp.ts

@@ -7,7 +7,7 @@ import consola from "consola";
 import inquirer from "inquirer";
 import ora from "ora";
 import * as process from "process";
-import { getPackageVersion } from "../utils";
+import {getPackageVersion} from "../utils";
 
 
 interface PasswordAnswer {
@@ -23,7 +23,69 @@ async function checkParentDir(ftpClient: Client, file: string, onMkdir: (dir: st
   }
 }
 
-export function ftpUpload() {
+async function runSSH(sshConfig: Record<string, string | string[]>, releaseConfig: ReleaseConfig) {
+  consola.info('run ssh:', sshConfig)
+  const answer = await inquirer
+    .prompt<PasswordAnswer>([{type: 'password', name: 'password', mask: '*', message: 'Enter key pair password'}])
+
+  let ftpClient = new Client()
+  const port = sshConfig['Port']
+  const key = fs.readFileSync(path.resolve(os.homedir(), '.ssh/id_rsa'))
+  const spinner = ora('Connecting')
+  try {
+    spinner.start()
+    await ftpClient.connect({
+      host: sshConfig['HostName'] as string,
+      port: port ? parseInt(port as string) : 22,
+      username: sshConfig['User'] as string,
+      passphrase: answer.password,
+      privateKey: key,
+    })
+    releaseConfig.fileMap.sort((it1, it2) => (it1.order ?? 0) - (it2.order ?? 0))
+    // upload files
+    for (let item of releaseConfig.fileMap) {
+      if (typeof item.src == 'string') {
+        if (item.remoteCopy) {
+          await checkParentDir(ftpClient, item.dest, dir => {
+            spinner.warn(`Create Dir: ${dir}`)
+          })
+          let destExists = await ftpClient.exists(item.dest)
+          if (destExists) {
+            spinner.warn(`Delete exists file:${item.dest}`)
+            await ftpClient.delete(item.dest)
+          }
+          spinner.info(`Copying File: ${item.src} -> ${item.dest}`)
+          await ftpClient.rcopy(item.src, item.dest)
+        } else {
+          const localFile = path.resolve(process.cwd(), item.src as string)
+          if (!item.remoteCopy && !fs.existsSync(localFile)) {
+            spinner.warn(`Skip not exists file:${localFile}`)
+            continue
+          }
+          if (fs.lstatSync(localFile).isDirectory()) {
+            spinner.info(`Uploading Dir: ${localFile} -> ${item.dest}`)
+            await ftpClient.uploadDir(localFile, item.dest)
+          } else {
+            await checkParentDir(ftpClient, item.dest, dir => {
+              spinner.warn(`Create Dir: ${dir}`)
+            })
+            spinner.info(`Uploading File: ${localFile} -> ${item.dest}`)
+            await ftpClient.put(localFile, item.dest)
+          }
+        }
+      } else {
+        await ftpClient.put(Buffer.from(JSON.stringify(item.src), 'utf-8'), item.dest)
+      }
+    }
+    spinner.succeed('Files uploaded!')
+    await ftpClient.end()
+  } catch (e) {
+    spinner.fail(`Connection error:${e}`)
+    await ftpClient.end()
+  }
+}
+
+export async function ftpUpload() {
   // 读取
   const releaseJsonFilePath = path.join(process.cwd(), 'release.json')
   const packageVersion = getPackageVersion()
@@ -34,73 +96,18 @@ export function ftpUpload() {
   const sshConfigFile = path.resolve(os.homedir(), '.ssh/config')
   consola.info('SSH Config File Path:', sshConfigFile)
   const sshConfigs = SSHConfig.parse(fs.readFileSync(sshConfigFile).toString())
-  let sshConfig = sshConfigs.compute(releaseConfig.ftpConfig.host)
-  if (!sshConfig) {
-    consola.error(`SSH config ${releaseConfig.ftpConfig.host} not found`)
-    return
+  for (let host of releaseConfig.ftpConfig.host) {
+    let sshConfig = sshConfigs.compute(host)
+    if (!sshConfig) {
+      consola.error(`SSH config ${releaseConfig.ftpConfig.host} not found`)
+      return
+    }
+    await runSSH(sshConfig, releaseConfig)
   }
-  consola.info(sshConfig)
-  inquirer
-    .prompt<PasswordAnswer>([{type: 'password', name: 'password', mask: '*', message: 'Enter key pair password'}])
-    .then(async (answer: PasswordAnswer) => {
-      let ftpClient = new Client()
-      const port = sshConfig['Port']
-      const key = fs.readFileSync(path.resolve(os.homedir(), '.ssh/id_rsa'))
-      const spinner = ora('Connecting')
-      try {
-        spinner.start()
-        await ftpClient.connect({
-          host: sshConfig['HostName'] as string,
-          port: port ? parseInt(port as string) : 22,
-          username: sshConfig['User'] as string,
-          passphrase: answer.password,
-          privateKey: key,
-        })
-        releaseConfig.fileMap.sort((it1, it2) => (it1.order ?? 0) - (it2.order ?? 0))
-        // upload files
-        for (let item of releaseConfig.fileMap) {
-          if (typeof item.src == 'string') {
-            if (item.remoteCopy) {
-              await checkParentDir(ftpClient, item.dest, dir => {
-                spinner.warn(`Create Dir: ${dir}`)
-              })
-              let destExists = await ftpClient.exists(item.dest)
-              if (destExists) {
-                spinner.warn(`Delete exists file:${item.dest}`)
-                await ftpClient.delete(item.dest)
-              }
-              spinner.info(`Copying File: ${item.src} -> ${item.dest}`)
-              await ftpClient.rcopy(item.src, item.dest)
-            } else {
-              const localFile = path.resolve(process.cwd(), item.src as string)
-              if (!item.remoteCopy && !fs.existsSync(localFile)) {
-                spinner.warn(`Skip not exists file:${localFile}`)
-                continue
-              }
-              if (fs.lstatSync(localFile).isDirectory()) {
-                spinner.info(`Uploading Dir: ${localFile} -> ${item.dest}`)
-                await ftpClient.uploadDir(localFile, item.dest)
-              } else {
-                await checkParentDir(ftpClient, item.dest, dir => {
-                  spinner.warn(`Create Dir: ${dir}`)
-                })
-                spinner.info(`Uploading File: ${localFile} -> ${item.dest}`)
-                await ftpClient.put(localFile, item.dest)
-              }
-            }
-          } else {
-            await ftpClient.put(Buffer.from(JSON.stringify(item.src), 'utf-8'), item.dest)
-          }
-        }
-        spinner.succeed('Files uploaded!')
-        await ftpClient.end()
-      } catch (e) {
-        spinner.fail(`Connection error:${e}`)
-        await ftpClient.end()
-      }
-    })
+
 }
 
+
 export interface ReleaseConfig {
   fileMap: {
     src: string | object
@@ -112,5 +119,5 @@ export interface ReleaseConfig {
 }
 
 export interface FTPConfig {
-  host: string
+  host: string[]
 }

package/src/release/release.ts

@@ -49,6 +49,9 @@ const release = async (options: any) => {
   if (!fs.existsSync(installerPath)) {
     installerPath = path.join(`./packaged/electron-${version}-setup-win-x64.exe`)
   }
+  if (!fs.existsSync(installerPath)) {
+    installerPath = path.join(`./packaged/app-${version}-setup-win-x64.exe`)
+  }
   const updateZipPath = path.join(`./packaged/update.zip`)
 
   console.log(chalk.blue('压缩更新文件中'))