lupine.api 1.1.55 → 1.1.57

package/admin/admin-config.tsx

@@ -12,7 +12,7 @@ export const AdminConfigPage = () => {
       const json = JSON.parse(ref.$('.input-cfg').value);
       const data = await getRenderPageProps().renderPageFunctions.fetchData('/api/admin/config/save', { json });
       if (data.json && data.json.status === 'ok') {
-        NotificationMessage.sendMessage('Saved', NotificationColor.Success);
+        NotificationMessage.sendMessage('Saved, and please refresh the page to load new configs', NotificationColor.Success);
       }
     } catch (e) {
       NotificationMessage.sendMessage('Config is not valid JSON', NotificationColor.Error);

package/admin/admin-release.tsx

@@ -9,6 +9,7 @@ import {
   formatBytes,
   downloadStream,
   ActionSheetSelectPromise,
+  encodeHtml,
 } from 'lupine.components';
 
 interface ReleaseListProps {
@@ -290,7 +291,7 @@ export const AdminReleasePage = () => {
       NotificationMessage.sendMessage(dataResponse.message || 'Failed to refresh cache', NotificationColor.Error);
       return;
     }
-    domLog.value = <pre>{JSON.stringify(dataResponse, null, 2)}</pre>;
+    domLog.value = <pre>{encodeHtml(JSON.stringify(dataResponse, null, 2))}</pre>;
     NotificationMessage.sendMessage('Cache refreshed successfully', NotificationColor.Success);
   };
 
@@ -308,9 +309,25 @@ export const AdminReleasePage = () => {
         return;
       }
     }
+  };
+
+  const onShellLocal = async () => {
+    return onShell(true);
+  };
+  const onShellRemote = async () => {
+    return onShell(false);
+  };
+  const onShell = async (isLocal?: boolean) => {
+    const data = getDomData();
+    if (!isLocal) {
+      if (!data.targetUrl || !data.accessToken) {
+        NotificationMessage.sendMessage('Please fill in all fields', NotificationColor.Error);
+        return;
+      }
+    }
 
     const index = await ActionSheetSelectPromise({
-      title: 'Restart App (users may get disconnected errors) ?',
+      title: 'Run Cmd ?',
       options: ['OK'],
       cancelButtonText: 'Cancel',
     });
@@ -318,17 +335,18 @@ export const AdminReleasePage = () => {
       return;
     }
 
-    const response = await getRenderPageProps().renderPageFunctions.fetchData('/api/admin/release/restart-app', {
+    const response = await getRenderPageProps().renderPageFunctions.fetchData('/api/admin/release/shell', {
       ...data,
       isLocal,
+      cmd: ref.$('.release-cmd').value,
     });
     const dataResponse = await response.json;
-    console.log('restart-app', dataResponse);
+    console.log('shell', dataResponse);
     if (!dataResponse || dataResponse.status !== 'ok') {
-      NotificationMessage.sendMessage(dataResponse.message || 'Failed to Restart App', NotificationColor.Error);
+      NotificationMessage.sendMessage(dataResponse.message || 'Failed to run cmd', NotificationColor.Error);
       return;
     }
-    domLog.value = <pre>{JSON.stringify(dataResponse, null, 2)}</pre>;
+    domLog.value = <pre>{encodeHtml(dataResponse.message) + '\r\n<br>' + encodeHtml(dataResponse.result)}</pre>;
     NotificationMessage.sendMessage('Restart App successfully', NotificationColor.Success);
   };
 
@@ -341,19 +359,19 @@ export const AdminReleasePage = () => {
   };
   return (
     <div ref={ref} css={css} class='admin-release-top'>
-      <div class='row-box mt1 mb1'>
+      <div class='row-box mt-m'>
         <label class='label mr-m release-label'>Target Url:</label>
         <div class='w-50p'>
           <input type='text' class='input-base w-100p target-url' placeholder='Target Url' />
         </div>
       </div>
-      <div class='row-box mt1 mb1'>
+      <div class='row-box mt-m'>
         <label class='label mr-m release-label'>Access token:</label>
         <div class='w-50p'>
           <input type='text' class='input-base w-100p access-token' placeholder='Access token' />
         </div>
       </div>
-      <div class='row-box mt1 mb1'>
+      <div class='row-box mt-m'>
         <button onClick={onCheck} class='button-base mr-m'>
           Check
         </button>
@@ -370,6 +388,15 @@ export const AdminReleasePage = () => {
           Restart App (Local)
         </button>
       </div>
+      <div class='row-box mt-m mb-m'>
+        <input type='text' class='input-base w-50p release-cmd' placeholder='Command' />
+        <button onClick={onShellRemote} class='button-base color-red'>
+          Run Cmd (Remote)
+        </button>
+        <button onClick={onShellLocal} class='button-base'>
+          Run Cmd (Local)
+        </button>
+      </div>
       {domUpdate.node}
       {domLog.node}
     </div>

package/admin/admin-table-data.tsx

@@ -6,7 +6,7 @@ import {
   getDefaultPageLimit,
   HtmlVar,
   PagingLink,
-  escapeHtml,
+  encodeHtml,
 } from 'lupine.components';
 
 const loadData = async (
@@ -34,7 +34,7 @@ const loadData = async (
         <div class='table'>
           <div class='fields bg-gray'>
             {Object.keys(data.json.result[0]).map((field: any, index: number) => {
-              return <div class='p1 item'>{escapeHtml(field)}</div>;
+              return <div class='p1 item'>{encodeHtml(field)}</div>;
             })}
             {update && update.onDelete && update.onEdit && <div class='p1 item'>Action</div>}
           </div>
@@ -43,7 +43,7 @@ const loadData = async (
             return (
               <div class='values'>
                 {Object.keys(item).map((field: any, index: number) => {
-                  return <div class='p1 item'>{escapeHtml(item[field])}</div>;
+                  return <div class='p1 item'>{encodeHtml(item[field])}</div>;
                 })}
                 {update && update.onDelete && update.onEdit && (
                   <div class='p1 item'>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lupine.api",
-  "version": "1.1.55",
+  "version": "1.1.57",
   "license": "MIT",
   "author": "uuware.com",
   "homepage": "https://github.com/uuware/lupine.js",
@@ -52,4 +52,4 @@
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.12"
   }
-}
+}

package/src/admin-api/admin-config.ts

@@ -1,6 +1,6 @@
 import { ServerResponse } from 'http';
 import * as fs from 'fs/promises';
-import { IApiBase, Logger, apiCache, ServerRequest, ApiRouter, ApiHelper, langHelper, FsUtils } from 'lupine.api';
+import { IApiBase, Logger, apiCache, ServerRequest, ApiRouter, ApiHelper, langHelper, FsUtils, appStorage } from 'lupine.api';
 import path from 'path';
 
 export class AdminConfig implements IApiBase {
@@ -72,6 +72,8 @@ export class AdminConfig implements IApiBase {
     const cfgPath = path.join(appData.dataPath, 'config.json');
     await fs.writeFile(cfgPath, JSON.stringify(data.json));
 
+    await appStorage.load(appData.appName, appData.dataPath);
+
     const response = {
       status: 'ok',
       message: langHelper.getLang('shared:operation_success'),

package/src/admin-api/admin-release.ts

@@ -12,6 +12,7 @@ import {
   processRefreshCache,
   apiStorage,
   processRestartApp,
+  processShell,
 } from 'lupine.api';
 import path from 'path';
 import { needDevAdminSession } from './admin-auth';
@@ -39,12 +40,16 @@ export class AdminRelease implements IApiBase {
     this.router.use('/refresh-cache', needDevAdminSession, this.refreshCache.bind(this));
     this.router.use('/restart-app', needDevAdminSession, this.restartApp.bind(this));
 
+    this.router.use('/shell', needDevAdminSession, this.shell.bind(this));
+
     // ...ByClient will verify credentials from post, so it doesn't need AdminSession
     this.router.use('/byClientCheck', this.byClientCheck.bind(this));
     this.router.use('/byClientUpdate', this.byClientUpdate.bind(this));
     this.router.use('/byClientRefreshCache', this.byClientRefreshCache.bind(this));
     this.router.use('/byClientRestartApp', this.byClientRestartApp.bind(this));
     this.router.use('/byClientViewLog', this.byClientViewLog.bind(this));
+
+    this.router.use('/byClientShell', this.byClientShell.bind(this));
   }
 
   async viewLog(req: ServerRequest, res: ServerResponse) {
@@ -170,6 +175,48 @@ export class AdminRelease implements IApiBase {
     return true;
   }
 
+  async shell(req: ServerRequest, res: ServerResponse) {
+    // check whether it's from online admin
+    const json = await adminApiHelper.getDevAdminFromCookie(req, res, false);
+    const jsonData = req.locals.json();
+    if (json && jsonData && !Array.isArray(jsonData) && jsonData.isLocal) {
+      const result = await processShell(req);
+      const response = {
+        status: 'ok',
+        message: 'Shell executed successfully.',
+        result,
+      };
+      ApiHelper.sendJson(req, res, response);
+      return true;
+    }
+
+    const data = await this.chkData(jsonData, req, res, true);
+    if (!data) return true;
+
+    let targetUrl = data.targetUrl as string;
+    if (targetUrl.endsWith('/')) {
+      targetUrl = targetUrl.slice(0, -1);
+    }
+    const remoteData = await fetch(targetUrl + '/api/admin/release/byClientShell', {
+      method: 'POST',
+      body: JSON.stringify(data),
+    });
+    const resultText = await remoteData.text();
+    let remoteResult: any;
+    try {
+      remoteResult = JSON.parse(resultText);
+    } catch (e: any) {
+      remoteResult = { status: 'error', message: resultText };
+    }
+    const response = {
+      status: 'ok',
+      message: 'check.',
+      ...remoteResult,
+    };
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+
   public async chkData(data: any, req: ServerRequest, res: ServerResponse, chkCredential: boolean) {
     // add access token
     if (!data || Array.isArray(data) || typeof data !== 'object' || !data.accessToken || !data.targetUrl) {
@@ -486,14 +533,12 @@ export class AdminRelease implements IApiBase {
         body: JSON.stringify({ ...data, chkOption, index: cnt, size: fileContent.length }) + '\n\n' + chunk,
       };
       this.logger.info(
-        `updateSendFile, index: ${cnt}, sending: ${chunk.length} (${i + chunk.length} / ${
-          fileContent.length
+        `updateSendFile, index: ${cnt}, sending: ${chunk.length} (${i + chunk.length} / ${fileContent.length
         }), f: ${sendFile}`
       );
       apiStorage.set(
         releaseProgress,
-        `updateSendFile, index: ${cnt}, sending: ${chunk.length} (${i + chunk.length} / ${
-          fileContent.length
+        `updateSendFile, index: ${cnt}, sending: ${chunk.length} (${i + chunk.length} / ${fileContent.length
         }), f: ${sendFile}`
       );
       i > 0 && (await new Promise((resolve) => setTimeout(resolve, 1000)));
@@ -536,6 +581,7 @@ export class AdminRelease implements IApiBase {
         !chkOption ||
         !toList ||
         (chkOption !== 'server' &&
+          chkOption !== 'app-loader' &&
           chkOption !== 'api' &&
           chkOption !== 'web' &&
           chkOption !== 'web-sub' &&
@@ -636,4 +682,19 @@ export class AdminRelease implements IApiBase {
     ApiHelper.sendJson(req, res, response);
     return true;
   }
+
+  async byClientShell(req: ServerRequest, res: ServerResponse) {
+    const jsonData = req.locals.json();
+    const data = await this.chkData(jsonData, req, res, true);
+    if (!data) return true;
+
+    const result = await processShell(req);
+    const response = {
+      status: 'ok',
+      message: 'Shell executed successfully.',
+      result,
+    };
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
 }

package/src/api/api-module.ts

@@ -22,7 +22,7 @@ export class ApiModule implements IApiModule {
     return result;
   }
 
-  // appCache is from app-loader (parent scope), not the same in current scope
+  // appCache is from app-helper (parent scope), not the same in current scope
   public async initApi(appConfig: HostToPathProps, appCacheFromApp: IAppCache, appStorageFromApp: IAppSharedStorage) {
 
     // const evnFile = appCacheFromApp.get(AppCacheGlobal, AppCacheKeys.APP_ENV_FILE);

package/src/api/shell-service.ts

@@ -1,4 +1,4 @@
-import { spawn, ChildProcessWithoutNullStreams } from 'child_process';
+import { spawn, exec, ChildProcessWithoutNullStreams } from 'child_process';
 import os from 'os';
 import { MiniWebSocket } from './mini-web-socket';
 import { Duplex } from 'stream';
@@ -13,7 +13,7 @@ export class ShellService {
     this._socket = socket;
     this._miniWebSocket = miniWebSocket;
     try {
-      const shellCmd: string = this.getDefaultShell();
+      const shellCmd: string = ShellService.getDefaultShell();
       this._shell = spawn(shellCmd, [], {
         stdio: ['pipe', 'pipe', 'pipe'],
       });
@@ -35,7 +35,7 @@ export class ShellService {
     });
   }
 
-  getDefaultShell() {
+  static getDefaultShell() {
     const platform = os.platform();
     if (platform === 'win32') {
       return process.env.COMSPEC || 'cmd.exe';
@@ -63,4 +63,12 @@ export class ShellService {
       this._miniWebSocket.sendMessage(this._socket!, 'Shell is not available.');
     }
   }
+
+  public static async directCmd(cmd: string): Promise<string> {
+    return new Promise((resolve) => {
+      exec(cmd, { shell: this.getDefaultShell() }, (error, stdout, stderr) => {
+        resolve(stdout + stderr);
+      });
+    });
+  }
 }

package/src/app/{app-loader.ts → app-helper.ts}

@@ -4,8 +4,8 @@ import { appCache } from './app-cache';
 import { AppCacheKeys, AppLoaderProps, HostToPathProps, IApiModule, setAppCache } from '../models';
 import { appStorage } from './app-shared-storage';
 
-class AppLoader {
-  logger: Logger = new Logger('app-loader');
+class AppHelper {
+  logger: Logger = new Logger('app-helper');
 
   constructor() {}
 
@@ -59,4 +59,4 @@ class AppLoader {
   }
 }
 
-export const appLoader = /* @__PURE__ */ new AppLoader();
+export const appHelper = /* @__PURE__ */ new AppHelper();

package/src/app/app-message.ts

@@ -1,6 +1,6 @@
 import cluster from 'cluster';
 import { Logger, LogWriter, LogWriterMessageId } from '../lib';
-import { processDebugMessage, snedRestartAppMsgToLoader } from './process-dev-requests';
+import { processDebugMessage, sendRestartAppMsgToLoader } from './process-dev-requests';
 import { cleanupAndExit } from './cleanup-exit';
 
 export type AppMessageProps = {
@@ -79,7 +79,7 @@ export const processMessageFromWorker = (msgObject: AppMessageProps) => {
       `Message from worker ${cluster.worker?.id}, message: ${msgObject.message}, appName: ${msgObject.appName}`
     );
     if (msgObject.message === 'restartApp') {
-      snedRestartAppMsgToLoader();
+      sendRestartAppMsgToLoader();
       return;
     } else if (msgObject.message === 'refresh') {
       broadcast(msgObject);

package/src/app/app-shared-storage.ts

@@ -99,6 +99,8 @@ export class AppSharedStorage implements IAppSharedStorage {
     } else if (msgObject.action === 'set') {
       const storage = this.getStorage(msgObject.appName);
       storage.set(msgObject.key, msgObject.value);
+    } else if (msgObject.action === 'load') {
+      this.load(msgObject.appName, msgObject.rootPath || '');
     } else if (msgObject.action === 'save') {
       this.save(msgObject.appName);
     } else {
@@ -116,7 +118,9 @@ export class AppSharedStorage implements IAppSharedStorage {
   // should be only called from primary when the app is starting
   async load(appName: string, rootPath: string) {
     if (!cluster.isPrimary) {
-      throw new Error('AppStorage.load should be only called from primary');
+      // throw new Error('AppStorage.load should be only called from primary');
+      await AppSharedStorageWorker.load(appName, rootPath);
+      return;
     }
 
     const map = this.getStorageMap(appName);
@@ -147,6 +151,7 @@ export class AppSharedStorage implements IAppSharedStorage {
       return;
     }
 
+    console.log(`${process.pid} - AppStorage save, appName: ${appName}, exit: ${exit}`);
     if (appName) {
       const map = this.configMap[appName];
       if (map && map.fPath && map.storage.size() > 0 && map.storage.Dirty) {
@@ -166,7 +171,7 @@ export class AppSharedStorage implements IAppSharedStorage {
   // this can be called in primary or worker
   get(appName: string, key: string): Promise<string> {
     return new Promise((resolve, reject) => {
-      console.log(`${process.pid} - AppStorage get value for key: ${key}`);
+      // console.log(`${process.pid} - AppStorage get value for key: ${key}`);
 
       if (!cluster.isPrimary) {
         AppSharedStorageWorker.get(appName, key, resolve, reject);
@@ -196,7 +201,7 @@ export class AppSharedStorage implements IAppSharedStorage {
   }
   getWithPrefix(appName: string, prefixKey: string): Promise<SimpleStorageDataProps> {
     return new Promise((resolve, reject) => {
-      console.log(`${process.pid} - AppStorage getWithPrefix for prefixKey: ${prefixKey}`);
+      // console.log(`${process.pid} - AppStorage getWithPrefix for prefixKey: ${prefixKey}`);
 
       if (!cluster.isPrimary) {
         AppSharedStorageWorker.getWithPrefix(appName, prefixKey, resolve, reject);
@@ -238,7 +243,7 @@ class AppSharedStorageWorker {
     }
 
     if (msgObject.action === 'get') {
-      console.log(`${process.pid} - AppStorage get value end for key: ${msgObject.key}`);
+      // console.log(`${process.pid} - AppStorage get value end for key: ${msgObject.key}`);
 
       const value = msgObject.value;
       // how to pass the value to the caller
@@ -265,6 +270,22 @@ class AppSharedStorageWorker {
     }
   }
 
+  static async load(appName: string, rootPath: string) {
+    if (cluster.isPrimary) {
+      throw new Error('AppSharedStorageWorker should be only called from workers');
+    }
+    const obj: StorageMessageFromSubProcess = {
+      id: AppSharedStorageMessageId,
+      pid: process.pid,
+      workerId: cluster.worker?.id || 0,
+      action: 'load',
+      appName: appName,
+      rootPath: rootPath,
+      key: 'load',
+    };
+    process.send!(obj);
+  }
+
   static async save(appName?: string) {
     if (cluster.isPrimary) {
       throw new Error('AppSharedStorageWorker should be only called from workers');

package/src/app/app-start.ts

@@ -1,6 +1,6 @@
 import cluster from 'cluster';
 import { WebProcessor } from './web-processor';
-import { appLoader } from './app-loader';
+import { appHelper } from './app-helper';
 import { processMessageFromPrimary, processMessageFromWorker } from './app-message';
 import { WebServer } from './web-server';
 import { processDevRequests } from './process-dev-requests';
@@ -59,7 +59,7 @@ class AppStart {
       process.on('message', processMessageFromPrimary);
 
       HostToPath.setHostToPathList(props.apiConfig.webHostMap);
-      appLoader.loadApi(props.apiConfig);
+      appHelper.loadApi(props.apiConfig);
       this.initServer(props.serverConfig);
     } else if (cluster.isPrimary) {
       const numCPUs = props.debug ? 1 : require('os').cpus().length;

package/src/app/index.ts

@@ -1,5 +1,5 @@
 export * from './app-cache';
-export * from './app-loader';
+export * from './app-helper';
 export * from './app-message';
 export * from './app-shared-storage';
 export * from './app-start';

package/src/app/process-dev-requests.ts

@@ -2,10 +2,11 @@ import cluster from 'cluster';
 import { Logger } from '../lib/logger';
 import { ServerResponse } from 'http';
 import { AddressInfo } from 'net';
-import { appLoader } from './app-loader';
+import { appHelper } from './app-helper';
 import { DebugService } from '../api/debug-service';
 import { AppCacheGlobal, AppCacheKeys, getAppCache, ServerRequest } from '../models';
 import { cleanupAndExit } from './cleanup-exit';
+import { ShellService } from '../api/shell-service';
 const logger = new Logger('process-dev-requests');
 
 function deleteRequireCache(moduleName: string) {
@@ -27,13 +28,13 @@ export const processDebugMessage = async (msgObject: any) => {
   if (msgObject.id === 'debug' && msgObject.message === 'refresh') {
     if (msgObject.appName) {
       const appConfig = getAppCache().get(msgObject.appName, AppCacheKeys.API_CONFIG);
-      appLoader.refreshApi(appConfig);
+      appHelper.refreshApi(appConfig);
     } else {
       // refresh all in a worker (app scope)
       let appList = getAppCache().get(AppCacheGlobal, AppCacheKeys.APP_LIST);
       for (const appName of appList) {
         const appConfig = getAppCache().get(appName, AppCacheKeys.API_CONFIG);
-        appLoader.refreshApi(appConfig);
+        appHelper.refreshApi(appConfig);
       }
     }
 
@@ -72,10 +73,20 @@ export async function processRestartApp(req: ServerRequest) {
   }
   // in case if it's only one process (primary process)
   else {
-    snedRestartAppMsgToLoader();
+    sendRestartAppMsgToLoader();
   }
 }
 
+export async function processShell(req: ServerRequest) {
+  const data = req.locals.json();
+  if (!data || Array.isArray(data) || !data.cmd) {
+    return 'Wrong data.';
+  }
+  const cmd = data.cmd as string;
+  const shell = await ShellService.directCmd(cmd);
+  return shell;
+}
+
 // this is called from a request in debug mode
 export async function processDevRequests(req: ServerRequest, res: ServerResponse, rootUrl?: string) {
   res.end();
@@ -103,7 +114,7 @@ export async function processDevRequests(req: ServerRequest, res: ServerResponse
 }
 
 // this is called from a request and passes the restartApp message to loader
-export const snedRestartAppMsgToLoader = async () => {
+export const sendRestartAppMsgToLoader = async () => {
   if (!cluster.isPrimary) {
     console.warn(`restartApp: shouldn't come here`);
     return;

package/src/models/app-shared-storage-props.ts

@@ -2,7 +2,7 @@ import { ISimpleStorage, SimpleStorageDataProps } from './simple-storage-props';
 
 // interface of AppSharedStorage
 export const AppSharedStorageMessageId = 'AppSharedStorage';
-export type StorageMessageAction = 'get' | 'set' | 'save' | 'getWithPrefix';
+export type StorageMessageAction = 'get' | 'set' | 'load'  | 'save' | 'getWithPrefix';
 export interface StorageMessageFromSubProcess {
   id: string;
   pid: number | undefined;
@@ -13,6 +13,7 @@ export interface StorageMessageFromSubProcess {
   value?: any;
   uniqueKey?: string;
   appName: string;
+  rootPath?: string;
 }
 
 // also used in packages\lupine.api\src\common-js\web-env.js

package/src/models/app-start-props.ts

@@ -1,5 +1,5 @@
 import { RenderPageFunctionsType } from '../api';
-import { AppLoaderProps } from './app-loader-props';
+import { AppLoaderProps } from './app-helper-props';
 
 export type InitStartProps = {
   bindIp: string;

package/src/models/index.ts

@@ -3,7 +3,7 @@ export * from './api-module-props';
 export * from './api-router-props';
 export * from './app-cache-props';
 export * from './app-data-props';
-export * from './app-loader-props';
+export * from './app-helper-props';
 export * from './app-shared-storage-props';
 export * from './app-start-props';
 export * from './async-storage-props';