@kevisual/cli 0.0.77 → 0.0.78

package/dist/assistant-server.js

@@ -41464,7 +41464,7 @@ var require_commander = __commonJS((exports) => {
   exports.InvalidOptionArgumentError = InvalidArgumentError;
 });
 
-// ../node_modules/.pnpm/@kevisual+router@0.0.49_supports-color@10.2.2/node_modules/@kevisual/router/dist/router.js
+// ../node_modules/.pnpm/@kevisual+router@0.0.51_supports-color@10.2.2/node_modules/@kevisual/router/dist/router.js
 import require$$1, { webcrypto } from "node:crypto";
 import require$$2 from "node:http";
 import require$$1$1 from "node:https";
@@ -41994,13 +41994,13 @@ class QueryRouter {
   hasRoute(path, key = "") {
     return this.routes.find((r) => r.path === path && r.key === key);
   }
-  createRouteList(force = false) {
-    const hasListRoute = this.hasRoute("route", "list");
+  createRouteList(force = false, filter) {
+    const hasListRoute = this.hasRoute("router", "list");
     if (!hasListRoute || force) {
-      const listRoute = new Route("route", "list", {
+      const listRoute = new Route("router", "list", {
         description: "列出当前应用下的所有的路由信息",
         run: async (ctx) => {
-          const list = this.getList();
+          const list = this.getList(filter);
           ctx.body = list;
         }
       });
@@ -42010,7 +42010,7 @@ class QueryRouter {
   wait(params, opts) {
     const getList = opts?.getList ?? true;
     if (getList) {
-      this.createRouteList();
+      this.createRouteList(opts?.force ?? false, opts?.filter);
     }
     return listenProcess({ app: this, params, ...opts });
   }
@@ -46054,7 +46054,7 @@ class App {
   }
 }
 
-// ../node_modules/.pnpm/@kevisual+router@0.0.49_supports-color@10.2.2/node_modules/@kevisual/router/dist/router-sign.js
+// ../node_modules/.pnpm/@kevisual+router@0.0.51_supports-color@10.2.2/node_modules/@kevisual/router/dist/router-sign.js
 import require$$12 from "node:crypto";
 var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
 function getAugmentedNamespace(n) {
@@ -58841,13 +58841,122 @@ function requireSelfsigned() {
         return "SHA-1";
     }
   }
-  function getSigningAlgorithm(key) {
-    const hashAlg = getAlgorithmName(key);
+  function getSigningAlgorithm(hashKey, keyType) {
+    const hashAlg = getAlgorithmName(hashKey);
+    if (keyType === "ec") {
+      return {
+        name: "ECDSA",
+        hash: hashAlg
+      };
+    }
+    return {
+      name: "RSASSA-PKCS1-v1_5",
+      hash: hashAlg
+    };
+  }
+  function getKeyAlgorithm(options) {
+    const keyType = options.keyType || "rsa";
+    const hashAlg = getAlgorithmName(options.algorithm || "sha1");
+    if (keyType === "ec") {
+      const curve = options.curve || "P-256";
+      return {
+        name: "ECDSA",
+        namedCurve: curve
+      };
+    }
     return {
       name: "RSASSA-PKCS1-v1_5",
+      modulusLength: options.keySize || 2048,
+      publicExponent: new Uint8Array([1, 0, 1]),
       hash: hashAlg
     };
   }
+  function buildExtensions(userExtensions, commonName) {
+    if (!userExtensions || userExtensions.length === 0) {
+      return [
+        new BasicConstraintsExtension2(false, undefined, true),
+        new KeyUsagesExtension2(KeyUsageFlags2.digitalSignature | KeyUsageFlags2.keyEncipherment, true),
+        new ExtendedKeyUsageExtension2([ExtendedKeyUsage3.serverAuth, ExtendedKeyUsage3.clientAuth], false),
+        new SubjectAlternativeNameExtension2([
+          { type: "dns", value: commonName },
+          ...commonName === "localhost" ? [{ type: "ip", value: "127.0.0.1" }] : []
+        ], false)
+      ];
+    }
+    const extensions = [];
+    for (const ext of userExtensions) {
+      const critical = ext.critical || false;
+      switch (ext.name) {
+        case "basicConstraints":
+          extensions.push(new BasicConstraintsExtension2(ext.cA || false, ext.pathLenConstraint, critical));
+          break;
+        case "keyUsage":
+          let flags = 0;
+          if (ext.digitalSignature)
+            flags |= KeyUsageFlags2.digitalSignature;
+          if (ext.nonRepudiation || ext.contentCommitment)
+            flags |= KeyUsageFlags2.nonRepudiation;
+          if (ext.keyEncipherment)
+            flags |= KeyUsageFlags2.keyEncipherment;
+          if (ext.dataEncipherment)
+            flags |= KeyUsageFlags2.dataEncipherment;
+          if (ext.keyAgreement)
+            flags |= KeyUsageFlags2.keyAgreement;
+          if (ext.keyCertSign)
+            flags |= KeyUsageFlags2.keyCertSign;
+          if (ext.cRLSign)
+            flags |= KeyUsageFlags2.cRLSign;
+          if (ext.encipherOnly)
+            flags |= KeyUsageFlags2.encipherOnly;
+          if (ext.decipherOnly)
+            flags |= KeyUsageFlags2.decipherOnly;
+          extensions.push(new KeyUsagesExtension2(flags, critical));
+          break;
+        case "extKeyUsage":
+          const usages = [];
+          if (ext.serverAuth)
+            usages.push(ExtendedKeyUsage3.serverAuth);
+          if (ext.clientAuth)
+            usages.push(ExtendedKeyUsage3.clientAuth);
+          if (ext.codeSigning)
+            usages.push(ExtendedKeyUsage3.codeSigning);
+          if (ext.emailProtection)
+            usages.push(ExtendedKeyUsage3.emailProtection);
+          if (ext.timeStamping)
+            usages.push(ExtendedKeyUsage3.timeStamping);
+          extensions.push(new ExtendedKeyUsageExtension2(usages, critical));
+          break;
+        case "subjectAltName":
+          const altNames = (ext.altNames || []).map((alt) => {
+            switch (alt.type) {
+              case 1:
+                return { type: "email", value: alt.value };
+              case 2:
+                return { type: "dns", value: alt.value };
+              case 6:
+                return { type: "url", value: alt.value };
+              case 7:
+                return { type: "ip", value: alt.ip || alt.value };
+              default:
+                if (alt.ip)
+                  return { type: "ip", value: alt.ip };
+                if (alt.dns)
+                  return { type: "dns", value: alt.dns };
+                if (alt.email)
+                  return { type: "email", value: alt.email };
+                if (alt.uri || alt.url)
+                  return { type: "url", value: alt.uri || alt.url };
+                return { type: "dns", value: alt.value };
+            }
+          });
+          extensions.push(new SubjectAlternativeNameExtension2(altNames, critical));
+          break;
+        default:
+          console.warn(`Unknown extension "${ext.name}" ignored`);
+      }
+    }
+    return extensions;
+  }
   function convertAttributes(attrs) {
     const nameMap = {
       commonName: "CN",
@@ -58863,36 +58972,62 @@ function requireSelfsigned() {
       return `${oid}=${attr.value}`;
     }).join(", ");
   }
-  async function importPrivateKey(pemKey, algorithm) {
-    const pkcs8Match = pemKey.match(/-----BEGIN PRIVATE KEY-----([\s\S]*?)-----END PRIVATE KEY-----/);
-    const rsaMatch = pemKey.match(/-----BEGIN RSA PRIVATE KEY-----([\s\S]*?)-----END RSA PRIVATE KEY-----/);
-    if (pkcs8Match) {
-      const pemContents = pkcs8Match[1].replace(/\s/g, "");
-      const binaryDer = Buffer.from(pemContents, "base64");
-      return await crypto2.subtle.importKey("pkcs8", binaryDer, {
-        name: "RSASSA-PKCS1-v1_5",
-        hash: getAlgorithmName(algorithm)
-      }, true, ["sign"]);
-    } else if (rsaMatch) {
-      const keyObject = nodeCrypto.createPrivateKey(pemKey);
-      const pkcs8Pem = keyObject.export({ type: "pkcs8", format: "pem" });
-      const pemContents = pkcs8Pem.replace(/-----BEGIN PRIVATE KEY-----/, "").replace(/-----END PRIVATE KEY-----/, "").replace(/\s/g, "");
-      const binaryDer = Buffer.from(pemContents, "base64");
-      return await crypto2.subtle.importKey("pkcs8", binaryDer, {
+  function normalizeECCurve(curveName) {
+    const curveMap = {
+      prime256v1: "P-256",
+      secp384r1: "P-384",
+      secp521r1: "P-521",
+      "P-256": "P-256",
+      "P-384": "P-384",
+      "P-521": "P-521"
+    };
+    return curveMap[curveName] || curveName;
+  }
+  function getECCurve(keyObject) {
+    const details = keyObject.asymmetricKeyDetails;
+    if (details && details.namedCurve) {
+      return normalizeECCurve(details.namedCurve);
+    }
+    return "P-256";
+  }
+  async function importPrivateKey(pemKey, algorithm, keyType) {
+    const keyObject = nodeCrypto.createPrivateKey(pemKey);
+    const detectedKeyType = keyObject.asymmetricKeyType;
+    const actualKeyType = keyType || detectedKeyType;
+    const pkcs8Pem = keyObject.export({ type: "pkcs8", format: "pem" });
+    const pemContents = pkcs8Pem.replace(/-----BEGIN PRIVATE KEY-----/, "").replace(/-----END PRIVATE KEY-----/, "").replace(/\s/g, "");
+    const binaryDer = Buffer.from(pemContents, "base64");
+    let importAlgorithm;
+    if (actualKeyType === "ec") {
+      const curve = getECCurve(keyObject);
+      importAlgorithm = {
+        name: "ECDSA",
+        namedCurve: curve
+      };
+    } else {
+      importAlgorithm = {
         name: "RSASSA-PKCS1-v1_5",
         hash: getAlgorithmName(algorithm)
-      }, true, ["sign"]);
-    } else {
-      throw new Error("Unsupported private key format. Expected PKCS#8 or PKCS#1 RSA key.");
+      };
     }
+    return await crypto2.subtle.importKey("pkcs8", binaryDer, importAlgorithm, true, ["sign"]);
   }
-  async function importPublicKey(pemKey, algorithm) {
+  async function importPublicKey(pemKey, algorithm, keyType, curve) {
     const pemContents = pemKey.replace(/-----BEGIN PUBLIC KEY-----/, "").replace(/-----END PUBLIC KEY-----/, "").replace(/\s/g, "");
     const binaryDer = Buffer.from(pemContents, "base64");
-    return await crypto2.subtle.importKey("spki", binaryDer, {
-      name: "RSASSA-PKCS1-v1_5",
-      hash: getAlgorithmName(algorithm)
-    }, true, ["verify"]);
+    let importAlgorithm;
+    if (keyType === "ec") {
+      importAlgorithm = {
+        name: "ECDSA",
+        namedCurve: curve
+      };
+    } else {
+      importAlgorithm = {
+        name: "RSASSA-PKCS1-v1_5",
+        hash: getAlgorithmName(algorithm)
+      };
+    }
+    return await crypto2.subtle.importKey("spki", binaryDer, importAlgorithm, true, ["verify"]);
   }
   async function generatePemAsync(keyPair, attrs, options, ca) {
     const { privateKey, publicKey } = keyPair;
@@ -58933,22 +59068,15 @@ function requireSelfsigned() {
       }
     ];
     const subjectName = convertAttributes(attrs);
-    const signingAlg = getSigningAlgorithm(options.algorithm);
+    const keyType = options.keyType || "rsa";
+    const signingAlg = getSigningAlgorithm(options.algorithm, keyType);
     const commonNameAttr = attrs.find((attr) => attr.name === "commonName" || attr.shortName === "CN");
     const commonName = commonNameAttr ? commonNameAttr.value : "localhost";
-    const extensions = [
-      new BasicConstraintsExtension2(false, undefined, true),
-      new KeyUsagesExtension2(KeyUsageFlags2.digitalSignature | KeyUsageFlags2.keyEncipherment, true),
-      new ExtendedKeyUsageExtension2([ExtendedKeyUsage3.serverAuth, ExtendedKeyUsage3.clientAuth], false),
-      new SubjectAlternativeNameExtension2([
-        { type: "dns", value: commonName },
-        ...commonName === "localhost" ? [{ type: "ip", value: "127.0.0.1" }] : []
-      ], false)
-    ];
+    const extensions = buildExtensions(options.extensions, commonName);
     let cert;
     if (ca) {
       const caCert = new X509Certificate2(ca.cert);
-      const caPrivateKey = await importPrivateKey(ca.key, options.algorithm || "sha256");
+      const caPrivateKey = await importPrivateKey(ca.key, options.algorithm || "sha256", keyType);
       cert = await X509CertificateGenerator2.create({
         serialNumber: serialHex,
         subject: subjectName,
@@ -59016,12 +59144,15 @@ function requireSelfsigned() {
       const clientKeySize = clientOpts.keySize || options.clientCertificateKeySize || 2048;
       const clientAlgorithm = clientOpts.algorithm || options.algorithm || "sha1";
       const clientCN = clientOpts.cn || options.clientCertificateCN || "John Doe jdoe123";
-      const clientKeyPair = await crypto2.subtle.generateKey({
-        name: "RSASSA-PKCS1-v1_5",
-        modulusLength: clientKeySize,
-        publicExponent: new Uint8Array([1, 0, 1]),
-        hash: getAlgorithmName(clientAlgorithm)
-      }, true, ["sign", "verify"]);
+      const clientKeyType = clientOpts.keyType || keyType;
+      const clientCurve = clientOpts.curve || options.curve || "P-256";
+      const clientKeyAlg = getKeyAlgorithm({
+        keyType: clientKeyType,
+        keySize: clientKeySize,
+        algorithm: clientAlgorithm,
+        curve: clientCurve
+      });
+      const clientKeyPair = await crypto2.subtle.generateKey(clientKeyAlg, true, ["sign", "verify"]);
       const clientSerialBytes = crypto2.getRandomValues(new Uint8Array(9));
       const clientSerialHex = toPositiveHex(Buffer.from(clientSerialBytes).toString("hex"));
       const clientNotBefore = clientOpts.notBeforeDate || new Date;
@@ -59043,7 +59174,7 @@ function requireSelfsigned() {
       }
       const clientSubjectName = convertAttributes(clientAttrs);
       const issuerName = convertAttributes(attrs);
-      const clientSigningAlg = getSigningAlgorithm(clientAlgorithm);
+      const clientSigningAlg = getSigningAlgorithm(clientAlgorithm, keyType);
       const clientCertRaw = await X509CertificateGenerator2.create({
         serialNumber: clientSerialHex,
         subject: clientSubjectName,
@@ -59086,20 +59217,17 @@ function requireSelfsigned() {
   selfsigned.generate = async function generate(attrs, options) {
     attrs = attrs || undefined;
     options = options || {};
-    const keySize = options.keySize || 2048;
+    const keyType = options.keyType || "rsa";
+    const curve = options.curve || "P-256";
     let keyPair;
     if (options.keyPair) {
       keyPair = {
-        privateKey: await importPrivateKey(options.keyPair.privateKey, options.algorithm || "sha1"),
-        publicKey: await importPublicKey(options.keyPair.publicKey, options.algorithm || "sha1")
+        privateKey: await importPrivateKey(options.keyPair.privateKey, options.algorithm || "sha1", keyType),
+        publicKey: await importPublicKey(options.keyPair.publicKey, options.algorithm || "sha1", keyType, curve)
       };
     } else {
-      keyPair = await crypto2.subtle.generateKey({
-        name: "RSASSA-PKCS1-v1_5",
-        modulusLength: keySize,
-        publicExponent: new Uint8Array([1, 0, 1]),
-        hash: getAlgorithmName(options.algorithm || "sha1")
-      }, true, ["sign", "verify"]);
+      const keyAlg = getKeyAlgorithm(options);
+      keyPair = await crypto2.subtle.generateKey(keyAlg, true, ["sign", "verify"]);
     }
     return await generatePemAsync(keyPair, attrs, options, options.ca);
   };
@@ -68535,6 +68663,7 @@ var import_fast_glob = __toESM(require_out4(), 1);
 import fs8 from "node:fs";
 
 // src/module/local-apps/src/modules/pm2.ts
+import { spawn } from "node:child_process";
 import pm23 from "pm2";
 import { promisify as promisify3 } from "node:util";
 var normalizeScriptPath2 = (scriptPath) => {
@@ -68561,6 +68690,23 @@ var restart3 = promisify3(pm23.restart).bind(pm23);
 var reload2 = promisify3(pm23.reload).bind(pm23);
 var deleteProcess3 = promisify3(pm23.delete).bind(pm23);
 var list3 = promisify3(pm23.list).bind(pm23);
+var checkInstall = async (app) => {
+  return new Promise((resolve, reject) => {
+    const install = spawn("pnpm", ["install"], {
+      cwd: app.path,
+      stdio: "inherit"
+    });
+    install.on("close", (code) => {
+      if (code !== 0) {
+        console.log("install failed");
+        return resolve(false);
+      }
+      console.log("install success");
+      resolve(true);
+    });
+  });
+};
+
 class Pm2Connect2 {
   needConnect = true;
   isConnected = false;
@@ -68702,6 +68848,9 @@ class Pm2Manager2 {
       this.pm2Connect.checkDisconnect(runOpts);
     }
   }
+  async remove(runOpts) {
+    this.deleteProcess(runOpts);
+  }
   async deleteProcess(runOpts) {
     try {
       await this.pm2Connect.checkConnect();
@@ -68749,61 +68898,7 @@ class Manager2 {
   async loadApp(app) {
     const mainApp = this.mainApp;
     this.apps.set(app.key, app);
-    if (app.status !== "running") {
-      return;
-    }
-    if (!fileIsExist2(app.path)) {
-      console.error("app is not found");
-      return;
-    }
-    const pathEntry = path8.join(app.path, app.entry);
-    if (!fileIsExist2(pathEntry)) {
-      console.error("file entry not found");
-      return;
-    }
-    const entry2 = app.entry + `?timestamp=${app?.timestamp}`;
-    if (app.type === "micro-app" /* MicroApp */) {
-      const childProcess = fork2(app.entry, [], {
-        stdio: "inherit",
-        cwd: app.path,
-        env: {
-          ...process.env,
-          ...app.env,
-          APP_KEY: app.key,
-          APP_PATH: app.path,
-          APP_ENTRY: entry2
-        }
-      });
-      app.process = childProcess;
-    } else if (app.type === "system-app" /* SystemApp */) {
-      const pathEntryAndTimestamp = path8.join(app.path, entry2);
-      const importPath = process.platform === "win32" ? "file:///" + pathEntryAndTimestamp.replace(/\\/g, "/") : pathEntryAndTimestamp;
-      const module = await import(importPath);
-      if (module.loadApp && mainApp) {
-        await module.loadApp?.(mainApp, app);
-      }
-    } else if (app.type === "gateway-app" /* GatewayApp */) {
-      console.log("gateway app not support");
-    } else if (app.type === "pm2-system-app" /* Pm2SystemApp */) {
-      const pathEntry2 = path8.join(app.path, app.entry);
-      const pm2Manager = new Pm2Manager2({
-        appName: app.key,
-        script: pathEntry2,
-        pm2Connect: this.#pm2Connect
-      });
-      const pm2Options = app.pm2Options || {};
-      if (app?.engine) {
-        pm2Options.interpreter = pm2Options.interpreter || app?.engine;
-      }
-      if (!pm2Options.cwd) {
-        pm2Options.cwd = path8.join(app.path, "../..");
-      }
-      await pm2Manager.start(pm2Options);
-    } else {
-      console.error("app type not support", app.type);
-    }
-    console.log(`load ${app.type} success`, app.key);
-    return true;
+    return await LoadApp(app, { mainApp, pm2Connect: this.#pm2Connect });
   }
   async saveAppInfo(app, newTimeData = false) {
     const list4 = this.appInfo.list || [];
@@ -68904,24 +68999,7 @@ class Manager2 {
     if (!app) {
       return;
     }
-    if (app.status === "stop" && app.type === "system-app" /* SystemApp */) {
-      console.log(`app ${key} is stopped`);
-      return;
-    }
-    app.status = "stop";
-    if (app.type === "micro-app" /* MicroApp */) {
-      if (app.process) {
-        app.process.kill();
-      }
-    }
-    if (app.type === "pm2-system-app" /* Pm2SystemApp */) {
-      const pm2Manager = new Pm2Manager2({
-        appName: app.key,
-        script: app.entry,
-        pm2Connect: this.#pm2Connect
-      });
-      await pm2Manager.stop();
-    }
+    await StopApp(app, { pm2Connect: this.#pm2Connect, todo: "stop" });
     await this.saveAppInfo(app);
   }
   async restart(key) {
@@ -68968,8 +69046,9 @@ class Manager2 {
     await this.saveAppInfo(app);
     return onAppShowInfo2(app);
   }
-  async removeApp(key) {
+  async removeApp(key, opts) {
     const app = this.apps.get(key);
+    const deleteFile = opts?.deleteFile ?? true;
     if (!app) {
       return false;
     }
@@ -68989,6 +69068,9 @@ class Manager2 {
     } catch (e) {
       console.log("delete pm2 process error", e);
     }
+    if (!deleteFile) {
+      return true;
+    }
     try {
       deleteFileAppInfo2(key, this.appsPath);
     } catch (e) {
@@ -69054,6 +69136,99 @@ class Manager2 {
     }
   }
 }
+var LoadApp = async (app, opts) => {
+  const mainApp = opts?.mainApp;
+  const pm2Connect = opts?.pm2Connect;
+  if (app.status !== "running") {
+    return false;
+  }
+  if (!fileIsExist2(app.path)) {
+    console.error("app is not found");
+    return false;
+  }
+  const pathEntry = path8.join(app.path, app.entry);
+  if (!fileIsExist2(pathEntry)) {
+    console.error("file entry not found");
+    return false;
+  }
+  const entry2 = app.entry + `?timestamp=${app?.timestamp}`;
+  if (app.type === "micro-app" /* MicroApp */) {
+    const childProcess = fork2(app.entry, [], {
+      stdio: "inherit",
+      cwd: app.path,
+      env: {
+        ...process.env,
+        ...app.env,
+        APP_KEY: app.key,
+        APP_PATH: app.path,
+        APP_ENTRY: entry2
+      }
+    });
+    app.process = childProcess;
+  } else if (app.type === "system-app" /* SystemApp */) {
+    const pathEntryAndTimestamp = path8.join(app.path, entry2);
+    const importPath = process.platform === "win32" ? "file:///" + pathEntryAndTimestamp.replace(/\\/g, "/") : pathEntryAndTimestamp;
+    const module = await import(importPath);
+    if (module.loadApp && mainApp) {
+      await module.loadApp?.(mainApp, app);
+    }
+  } else if (app.type === "gateway-app" /* GatewayApp */) {
+    console.log("gateway app not support");
+  } else if (app.type === "pm2-system-app" /* Pm2SystemApp */) {
+    const pathEntry2 = path8.join(app.path, app.entry);
+    console.log("pm2 system app start", pathEntry2);
+    const pm2Manager = new Pm2Manager2({
+      appName: app.key,
+      script: pathEntry2,
+      pm2Connect
+    });
+    if (app?.init) {
+      const isInstall = await checkInstall(app);
+      if (!isInstall) {
+        console.log("install failed");
+        return false;
+      }
+    }
+    const pm2Options = app.pm2Options || {};
+    if (app?.engine) {
+      pm2Options.interpreter = pm2Options.interpreter || app?.engine;
+    }
+    if (!pm2Options.cwd) {
+      pm2Options.cwd = path8.join(app.path, "../..");
+    }
+    console.log("pm2 start options", pm2Options);
+    await pm2Manager.start(pm2Options);
+  } else if (app.type === "script-app" /* ScriptApp */) {
+    return true;
+  } else {
+    console.error("app type not support", app.type);
+  }
+  console.log(`load ${app.type} success`, app.key);
+  return true;
+};
+var StopApp = async (app, opts) => {
+  const key = app.key;
+  const pm2Connect = opts?.pm2Connect;
+  const todo = opts?.todo || "stop";
+  if (app.status === "stop" && app.type === "system-app" /* SystemApp */) {
+    console.log(`app ${key} is stopped`);
+    return;
+  }
+  app.status = "stop";
+  if (app.type === "micro-app" /* MicroApp */) {
+    if (app.process) {
+      app.process.kill();
+    }
+  }
+  if (app.type === "pm2-system-app" /* Pm2SystemApp */) {
+    const pm2Manager = new Pm2Manager2({
+      appName: app.key,
+      script: app.entry,
+      pm2Connect
+    });
+    await pm2Manager[todo]?.();
+  }
+};
 var installAppFromKey2 = async (key, _appPath) => {
   const normalizedKey = key.replace(/\//g, path8.sep);
   const directory = path8.join(_appPath, normalizedKey);
@@ -69641,7 +69816,7 @@ class AssistantQuery {
   }
 }
 // src/module/npm-install.ts
-import { spawn, spawnSync } from "child_process";
+import { spawn as spawn2, spawnSync } from "child_process";
 var checkPnpm = () => {
   try {
     spawnSync("pnpm", ["--version"]);
@@ -69661,7 +69836,7 @@ var installDeps = async (opts) => {
     params.push("--omit=dev");
   }
   console.log("installDeps", appPath, params);
-  const syncSpawn = opts.sync ? spawnSync : spawn;
+  const syncSpawn = opts.sync ? spawnSync : spawn2;
   if (isPnpm) {
     syncSpawn("pnpm", params, { cwd: appPath, stdio: "inherit", env: process.env });
   } else {
@@ -70476,6 +70651,14 @@ var app = useContextKey("app", () => {
     }
   });
 });
+app.route({
+  path: "router",
+  key: "list",
+  description: "获取路由列表"
+}).define(async (ctx) => {
+  const list4 = ctx.app.getList();
+  ctx.body = { list: list4 };
+}).addTo(app);
 
 // src/module/local-proxy/index.ts
 import fs12 from "node:fs";
@@ -72368,7 +72551,7 @@ var dist_default2 = createPrompt((config2, done) => {
 // ../node_modules/.pnpm/@inquirer+external-editor@2.0.2_@types+node@25.0.3/node_modules/@inquirer/external-editor/dist/index.js
 var import_chardet = __toESM(require_lib2(), 1);
 var import_iconv_lite = __toESM(require_lib3(), 1);
-import { spawn as spawn2, spawnSync as spawnSync2 } from "child_process";
+import { spawn as spawn3, spawnSync as spawnSync2 } from "child_process";
 import { readFileSync, unlinkSync, writeFileSync } from "fs";
 import path12 from "node:path";
 import os3 from "node:os";
@@ -72554,7 +72737,7 @@ class ExternalEditor {
   }
   launchEditorAsync(callback) {
     try {
-      const editorProcess = spawn2(this.editor.bin, this.editor.args.concat([this.tempFile]), { stdio: "inherit" });
+      const editorProcess = spawn3(this.editor.bin, this.editor.args.concat([this.tempFile]), { stdio: "inherit" });
       editorProcess.on("exit", (code) => {
         this.lastExitStatus = code;
         setImmediate(callback);
@@ -77519,6 +77702,15 @@ var wrapper_default = import_websocket.default;
 // src/services/proxy/proxy-page-index.ts
 var localProxy = new LocalProxy({});
 localProxy.initFromAssistantConfig(assistantConfig2);
+var isOpenPath = (pathname) => {
+  const openPaths = ["/root/home", "/root/cli"];
+  for (const openPath of openPaths) {
+    if (pathname.startsWith(openPath)) {
+      return true;
+    }
+  }
+  return false;
+};
 var authFilter = async (req, res) => {
   const _assistantConfig = assistantConfig2.getCacheAssistantConfig();
   const auth = _assistantConfig?.auth || {};
@@ -77606,6 +77798,7 @@ var proxyRoute = async (req, res) => {
       target: apiBackendProxy.target
     });
   }
+  logger.debug("proxyRoute handle by router", { url: req.url }, noAdmin);
   const urls = pathname.split("/");
   const [_2, _user, _app] = urls;
   if (!_app) {
@@ -77613,7 +77806,9 @@ var proxyRoute = async (req, res) => {
     res.end("Not Found Proxy");
     return;
   }
-  if (noAdmin) {
+  const isOpen = isOpenPath(pathname);
+  log.debug("proxyRoute", { _user, _app, pathname, noAdmin, isOpen });
+  if (noAdmin && !isOpen) {
     return toSetting();
   }
   if (_app && urls.length === 3) {
@@ -77951,7 +78146,7 @@ var getBunPath = () => {
   return bunExecutableName;
 };
 
-// ../node_modules/.pnpm/@kevisual+video-tools@0.0.12_dotenv@17.2.3_supports-color@10.2.2/node_modules/@kevisual/video-tools/src/ws/index.ts
+// ../node_modules/.pnpm/@kevisual+video-tools@0.0.13_dotenv@17.2.3_supports-color@10.2.2/node_modules/@kevisual/video-tools/src/ws/index.ts
 var isBrowser3 = typeof process === "undefined" || typeof window !== "undefined" && typeof window.document !== "undefined" || typeof process !== "undefined" && process?.env?.BROWSER === "true";
 var chantHttpToWs = (url2) => {
   if (url2.startsWith("http://")) {
@@ -77980,7 +78175,7 @@ var initWs = async (url2, options) => {
   return ws;
 };
 
-// ../node_modules/.pnpm/@kevisual+video-tools@0.0.12_dotenv@17.2.3_supports-color@10.2.2/node_modules/@kevisual/video-tools/src/asr/ws.ts
+// ../node_modules/.pnpm/@kevisual+video-tools@0.0.13_dotenv@17.2.3_supports-color@10.2.2/node_modules/@kevisual/video-tools/src/asr/ws.ts
 class WSServer {
   ws;
   onConnect;
@@ -78161,9 +78356,20 @@ class WSServer {
   async sendBlankJson() {
     this.ws.send(JSON.stringify({ type: "blankVoice" }));
   }
+  async fixBrowerBuffer(base64) {
+    let voice = Buffer.from(base64, "base64");
+    const floatArray = new Float32Array(voice.buffer, voice.byteOffset, voice.length / 4);
+    const pcm16 = Buffer.alloc(floatArray.length * 2);
+    for (let i = 0;i < floatArray.length; i++) {
+      const sample = Math.max(-1, Math.min(1, floatArray[i]));
+      pcm16.writeInt16LE(sample < 0 ? sample * 32768 : sample * 32767, i * 2);
+    }
+    voice = pcm16;
+    return voice;
+  }
 }
 
-// ../node_modules/.pnpm/@kevisual+video-tools@0.0.12_dotenv@17.2.3_supports-color@10.2.2/node_modules/@kevisual/video-tools/src/asr/provider/aliyun/base.ts
+// ../node_modules/.pnpm/@kevisual+video-tools@0.0.13_dotenv@17.2.3_supports-color@10.2.2/node_modules/@kevisual/video-tools/src/asr/provider/aliyun/base.ts
 class AsrRelatime extends WSServer {
   static baseURL = "wss://dashscope.aliyuncs.com/api-ws/v1/realtime";
   enableServerVad = true;
@@ -78266,17 +78472,6 @@ class AsrRelatime extends WSServer {
       console.log("error", error2);
     }
   }
-  async fixBrowerBuffer(base64) {
-    let voice = Buffer.from(base64, "base64");
-    const floatArray = new Float32Array(voice.buffer, voice.byteOffset, voice.length / 4);
-    const pcm16 = Buffer.alloc(floatArray.length * 2);
-    for (let i = 0;i < floatArray.length; i++) {
-      const sample = Math.max(-1, Math.min(1, floatArray[i]));
-      pcm16.writeInt16LE(sample < 0 ? sample * 32768 : sample * 32767, i * 2);
-    }
-    voice = pcm16;
-    return voice;
-  }
   async onClose(event) {
     let { code } = event;
     if (code === 1007) {
@@ -79779,7 +79974,19 @@ var func = async (req, res) => {
     return;
   }
   if (!asr) {
-    const token = process.env.BAILIAN_API_KEY || "";
+    const confg = assistantConfig2.getConfig();
+    const asrConfig = confg?.asr;
+    if (!asrConfig?.enabled) {
+      ws.send(JSON.stringify({ type: "error", message: "asr服务未启用" }));
+      ws.close();
+      return;
+    }
+    const token = asrConfig?.token;
+    if (!token) {
+      ws.send(JSON.stringify({ type: "error", message: "asr服务未配置token" }));
+      ws.close();
+      return;
+    }
     asr = new AsrRelatime({
       token,
       onConnect: () => {
@@ -79853,20 +80060,17 @@ var func = async (req, res) => {
     console.log("ASR receive data", "blank voice");
   } else if (data?.voice) {
     if (!data?.isRelatime) {
-      console.log("ASR receive data", "has voice", !!data?.voice);
-    }
-    const isBrowserFormat = data.format === "float32";
-    const time = data?.time || 0;
-    if (time) {
+      console.log("ASR receive data", "has voice", !!data?.voice, data?.isRelatime);
+      const time = data?.time || 0;
       console.log("receiveDelay", Date.now() - time);
     }
+    const isBrowserFormat = data.format === "float32";
     let voice;
     if (isBrowserFormat) {
       voice = await asr.fixBrowerBuffer(data.voice);
     } else {
       voice = Buffer.from(data.voice, "base64");
     }
-    console.log("sendTime", Date.now());
     ws.data.startTime = Date.now();
     asr.sendBuffer(voice);
   }
@@ -79904,7 +80108,11 @@ var runServer = async (port = 51515, listenPath = "127.0.0.1") => {
   } else {
     app.listen(_port, listenPath, () => {
       const protocol = assistantConfig2.getHttps().protocol;
-      console.log(`Server is running on ${protocol}://${listenPath}:${_port}`);
+      let showListenPath = listenPath;
+      if (listenPath === "::") {
+        showListenPath = "localhost";
+      }
+      console.log(`Server is running on ${protocol}://${showListenPath}:${_port}`);
     });
   }
   app.server.on([