@ebay/muse-runner 1.0.21

package/.muserc

@@ -0,0 +1 @@
+{}

package/README.md

@@ -0,0 +1,8 @@
+# muse-runner-node
+Runner of Muse plugins for development.
+
+## Usage
+
+```
+muse-runner-ebay [--no-check-update]
+```

package/bin/muse-runner.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import * as url from 'url';
+import path from 'path';
+import fs from 'fs-extra';
+import upgrade240102 from '../lib/upgrades/up_240102.js';
+
+// Enforce the cwd is the root of the project
+// So that it won't use unexpected muse config file.
+const __dirname = url.fileURLToPath(new URL('.', import.meta.url));
+process.chdir(path.join(__dirname, '../'));
+
+if (process.argv.includes('--version') || process.argv.includes('-v')) {
+  const pkgJson = fs.readJsonSync('./package.json');
+  console.log(pkgJson.version);
+  process.exit(0);
+}
+upgrade240102();
+
+import('../lib/server.js');

package/lib/AppRunner.js

@@ -0,0 +1,54 @@
+import { Worker } from 'node:worker_threads';
+import path from 'path';
+import * as url from 'url';
+import getPort, { portNumbers } from 'get-port';
+import { EventEmitter } from 'node:events';
+
+const __dirname = url.fileURLToPath(new URL('.', import.meta.url));
+
+/**
+ * Start a Muse app at dev mode.
+ * It controls whether plusin are loaded from local bundles or deployed ones.
+ * It also allows to change app/env
+ */
+export default class AppRunner extends EventEmitter {
+  async start({ id, port, app, env = 'staging' }) {
+    this.id = id;
+    if (this.worker) {
+      throw new Error(`App already started.`);
+    }
+    const realPort = port || (await getPort({ port: portNumbers(50000, 50500) }));
+
+    // Use a worker, so that we can get seperate stdout of the current server.
+    const worker = new Worker(path.join(__dirname, './appWorker.js'), {
+      env: process.env,
+      workerData: {
+        id,
+        port: realPort,
+      },
+    });
+    this.app = app;
+    this.env = env;
+    this.port = realPort;
+
+    worker.on('error', (err) => {
+      // TODO: handle error
+      console.log('[worker error]', err);
+      // this.emit('error', err);
+    });
+    worker.on('exit', (code) => {
+      this.emit('exit', code);
+    });
+
+    this.worker = worker;
+
+    return {
+      port: realPort,
+      worker,
+    };
+  }
+
+  async stop() {
+    await this.worker.terminate();
+  }
+}

package/lib/Command.js

@@ -0,0 +1,55 @@
+import * as os from 'node:os';
+import * as pty from 'node-pty';
+import { EventEmitter } from 'node:events';
+
+/**
+ * The reason we use node-pty is that it can keep output color?
+ */
+
+export default class Command extends EventEmitter {
+  cwd;
+  cmd;
+  port;
+  ptyArgs;
+  constructor({ cwd, cmd, env, ptyArgs = {} }) {
+    super();
+    this.cwd = cwd;
+    this.cmd = cmd;
+    this.ptyArgs = ptyArgs;
+    this.env = env;
+  }
+  start() {
+    const shell = os.platform() === 'win32' ? 'powershell.exe' : 'bash';
+
+    const ptyProcess = pty.spawn(shell, ['-c', this.cmd], {
+      name: 'xterm-instance',
+      cols: 80,
+      rows: 30,
+      cwd: this.cwd,
+      env: {
+        ...process.env,
+        ...this.env,
+      },
+      ...this.ptyArgs,
+    });
+
+    ptyProcess.onData((data) => {
+      // process.stdout.write(data);
+      // ptyProcess.on('data');
+    });
+
+    ptyProcess.onExit((code) => {
+      this.emit('exit', code);
+    });
+
+    // ptyProcess.write('ls\r');
+    // ptyProcess.resize(100, 40);
+    // ptyProcess.write('ls\r');
+    this.ptyProcess = ptyProcess;
+    return ptyProcess;
+  }
+
+  terminate() {
+    this.ptyProcess.kill();
+  }
+}

package/lib/MuseRunner.js

@@ -0,0 +1,135 @@
+import _ from 'lodash';
+import EventEmitter from 'node:events';
+import museDevUtils from '@ebay/muse-dev-utils/lib/utils.js';
+import AppRunner from './AppRunner.js';
+import PluginRunner from './PluginRunner.js';
+
+export default class MuseRunner extends EventEmitter {
+  runningApps = [];
+  runningPlugins = [];
+  async startApp({ id, app, env, port }) {
+    const found = this.runningApps.find((r) => r.id === id);
+    if (found) {
+      return found;
+    }
+
+    const appRunner = new AppRunner();
+    appRunner.on('exit', () => {
+      _.pull(this.runningApps, appRunner);
+    });
+
+    await appRunner.start({
+      id,
+      app,
+      env,
+      port,
+    });
+    this.runningApps.push(appRunner);
+    return appRunner;
+  }
+
+  async stopApp({ id }) {
+    const app = this.runningApps.find((r) => r.id === id);
+    if (!app) {
+      return;
+      // throw new Error(`Running app not found: ${id}.`);
+    }
+
+    await app.stop();
+    _.pull(this.runningApps, app);
+  }
+
+  getLinkedLibs(targetPlugin, changedLibPluginRunner) {
+    // Note, if no changedLibPluginRunner, means start a new plugin
+    const runningLibPlugins = this.runningPlugins.filter((p) => p.pluginInfo.type === 'lib');
+
+    const depLibs = museDevUtils.getMuseLibsByFolder(targetPlugin.dir);
+    if (
+      changedLibPluginRunner &&
+      !depLibs.find((d) => d.name === changedLibPluginRunner.pluginInfo.name)
+    ) {
+      return null;
+    }
+    const shouldLink = depLibs.reduce((acc, lib) => {
+      const found = runningLibPlugins.find((lp) => lp.pluginInfo.name === lib.name);
+      if (found) {
+        acc.push(found);
+      }
+      return acc;
+    }, []);
+    return shouldLink.map((d) => d.dir).join(';');
+  }
+
+  async updateMuseLinkedLibs(changedLibPluginRunner) {
+    // notify running plugins to update MUSE_LINKED_LIBS if it's changed
+    this.runningPlugins.forEach((rp) => {
+      const linkedLibs = this.getLinkedLibs(rp, changedLibPluginRunner);
+      if (linkedLibs !== null) {
+        // Means the linked libs of the plugin is changed
+        // Should ask the plugin dev server to restart
+        // console.log('updating linked libs: ', rp.name, linkedLibs);
+        // rp.cmd.ptyProcess.write(`MUSE_LINKED_LIBS=${linkedLibs}\n`);'
+        this.restartPlugin({ dir: rp.dir, env: {} });
+      }
+    });
+  }
+
+  async startPlugin({ dir, port, env }) {
+    const found = this.runningPlugins.find((r) => r.dir === dir);
+    if (found) {
+      return found;
+    }
+
+    const pluginRunner = new PluginRunner();
+    pluginRunner.on('exit', () => {
+      _.pull(this.runningPlugins, pluginRunner);
+    });
+    if (!env) env = {};
+    const linkedLibs = this.getLinkedLibs({ dir });
+    if (linkedLibs) {
+      env.MUSE_LINKED_LIBS = linkedLibs;
+    }
+    await pluginRunner.start({ dir, port, env });
+    this.runningPlugins.push(pluginRunner);
+    this.runningApps.forEach((appRunner) => {
+      appRunner.worker.postMessage({
+        type: 'running-plugins',
+        payload: this.runningPlugins.map((p) => ({
+          port: p.port,
+          name: p.pluginInfo.name,
+          type: p.pluginInfo.type,
+        })),
+      });
+    });
+
+    if (pluginRunner.pluginInfo.type === 'lib') {
+      // If a lib plugin is started or stopped,
+      // need to update MUSE_LINKED_LIBS for all other running plugins
+      await this.updateMuseLinkedLibs(pluginRunner);
+    }
+    // Emit an event to allow UI part get the change
+    this.emit('start-plugin', { pluginRunner });
+    return pluginRunner;
+  }
+  async stopPlugin({ dir }) {
+    const pluginRunner = this.runningPlugins.find((r) => r.dir === dir);
+    if (!pluginRunner) {
+      // throw new Error(`Running plugin not found: ${dir}.`);
+      return;
+    }
+
+    await pluginRunner.stop();
+    _.pull(this.runningPlugins, pluginRunner);
+    if (pluginRunner.pluginInfo.type === 'lib') {
+      // If a lib plugin is started or stopped,
+      // need to update MUSE_LINKED_LIBS for all other running plugins
+      await this.updateMuseLinkedLibs(pluginRunner);
+    }
+  }
+
+  async restartPlugin({ dir, port, env }) {
+    console.log('restart plugin: ', dir);
+    await this.stopPlugin({ dir });
+    await this.startPlugin({ dir, port, env });
+  }
+}

package/lib/PluginRunner.js

@@ -0,0 +1,67 @@
+import getPort, { portNumbers } from 'get-port';
+import { EventEmitter } from 'node:events';
+import Command from './Command.js';
+import utils from './utils.js';
+
+/**
+ * Start a Muse plugin project
+ * It controls whether plusin are loaded from local bundles or deployed ones.
+ */
+export default class PluginRunner extends EventEmitter {
+  constructor() {
+    super();
+  }
+  async start({ dir, port, env }) {
+    const realPort = port || (await getPort({ port: portNumbers(30000, 31000) }));
+    const pluginInfo = utils.getPluginInfo(dir);
+    pluginInfo.dir = dir;
+    const devScriptName = 'start';
+    const devScript = pluginInfo.pkgJson.scripts[devScriptName];
+    if (!devScript) {
+      throw new Error(
+        `Missing "${devScriptName}" script in the package.json of the plugin: "${pluginInfo.pkgJson.name}".`,
+      );
+    }
+
+    if (devScript.split(/ /).some((s) => s.startsWith('PORT='))) {
+      throw new Error(
+        `Should not have PORT env variable in the package script when using Muse Runner: "${devScriptName}": "${devScript}".`,
+      );
+    }
+
+    const pkgManager = utils.getPkgManager(dir);
+
+    const cmd = new Command({
+      cwd: dir,
+      cmd: `${pkgManager} run ${devScriptName}`,
+      env: {
+        PORT: realPort,
+        ...env,
+        // SSL_CRT_FILE: '',
+        // SSL_KEY_FILE: '',
+        MUSE_CONFIG_FILE: '', // The config file should be empty, so that the plugin can use the default config.
+      },
+    });
+    cmd.start();
+
+    this.dir = dir;
+    this.port = realPort;
+    this.cmd = cmd;
+    this.pluginInfo = pluginInfo;
+    this.name = this.pluginInfo.name;
+
+    this.cmd.on('exit', (code) => {
+      this.emit('exit', code);
+    });
+
+    return {
+      port: realPort,
+      cmd,
+      pluginInfo,
+    };
+  }
+
+  async stop() {
+    this.cmd.terminate();
+  }
+}

package/lib/apis/checkUpdate.js

@@ -0,0 +1,25 @@
+import fs from 'fs-extra';
+import path from 'path';
+import semver from 'semver';
+import * as url from 'url';
+import pkgJson from 'package-json';
+
+const __dirname = url.fileURLToPath(new URL('.', import.meta.url));
+
+// TODO: expose it as rest api in server.js
+export default async function checkUpdate() {
+  const selfPkg = fs.readJsonSync(path.join(__dirname, '../package.json'));
+
+  const args = {};
+  if (process.env.RUNNER_NPM_REGISTRY) {
+    args.registryUrl = process.env.RUNNER_NPM_REGISTRY;
+  }
+  const publishedPkg = await pkgJson(selfPkg.name, args);
+
+  if (semver.lt(selfPkg.version, publishedPkg.version)) {
+    return {
+      newVersion: publishedPkg.version,
+    };
+  }
+  return {};
+}

package/lib/apis/gitStatus.js

@@ -0,0 +1,89 @@
+import simpleGit from 'simple-git';
+import _ from 'lodash';
+import fs from 'fs-extra';
+import chokidar from 'chokidar';
+import path from 'path';
+
+const gitDirMap = {};
+const watcherMap = {};
+const gitStatusMap = {};
+
+const getGitDir = (dir) => {
+  if (gitDirMap[dir]) return gitDirMap[dir];
+  // find the nearest git dir
+  const git = simpleGit(dir);
+  return git.revparse(['--show-toplevel']).then((gitDir) => {
+    gitDirMap[dir] = gitDir;
+    return gitDir;
+  });
+};
+
+const gitMap = {};
+const getGitClient = (dir) => {
+  if (gitMap[dir]) return gitMap[dir];
+  gitMap[dir] = simpleGit(dir);
+  return gitMap[dir];
+};
+
+// watch git status of all plugins
+// TODO: remove watcher if a folder is removed.
+export default ({ app, io, config }) => {
+  const callbacks = {};
+  const handleGitChange = (gitDir) => {
+    if (callbacks[gitDir]) return callbacks[gitDir];
+    callbacks[gitDir] = _.debounce(async () => {
+      const git = getGitClient(gitDir);
+      const status = await git.status();
+      _.invertBy(gitDirMap)[gitDir]?.forEach((d) => {
+        gitStatusMap[d] = status;
+      });
+
+      io.emit({
+        type: 'git-status-changed',
+        data: gitStatusMap,
+      });
+    }, 300);
+    return callbacks[gitDir];
+  };
+
+  const handleConfigChange = async () => {
+    const plugins = config.get('plugins', {});
+
+    for (let dir of Object.values(plugins).map((p) => p.dir)) {
+      if (!fs.existsSync(dir) || !fs.existsSync(path.join(dir, '.git'))) continue;
+      try {
+        const gitDir = await getGitDir(dir);
+        if (!watcherMap[gitDir]) {
+          watcherMap[gitDir] = chokidar.watch(gitDir, { ignored: /node_modules/ });
+          watcherMap[gitDir].on('all', handleGitChange(gitDir));
+          handleGitChange(gitDir)();
+        }
+      } catch (e) {
+        // ignore
+        console.log('failed to watch git dir: ' + dir, e.message);
+      }
+    }
+  };
+
+  config.onDidChange('plugins', handleConfigChange);
+
+  handleConfigChange();
+  app.get('/api/git-status', (req, res) => {
+    res.end(JSON.stringify(gitStatusMap));
+    // const dir = decodeURIComponent(req.query.dir);
+    // const git = simpleGit(dir);
+    // git.status((err, result) => {
+    //   if (err) {
+    //     res.end({
+    //       code: 1,
+    //       msg: err,
+    //     });
+    //   } else {
+    //     res.end({
+    //       code: 0,
+    //       data: result,
+    //     });
+    //   }
+    // });
+  });
+};

package/lib/apis/settings.js

@@ -0,0 +1,9 @@
+export default function settings({ app, config }) {
+  app.post('/api/settings', (req, res) => {
+    const { key, value } = req.body;
+    const settings = config.get('settings', {});
+    settings[key] = value;
+    config.set('settings', settings);
+    res.end();
+  });
+}

package/lib/apis/startPlugin.js

@@ -0,0 +1,22 @@
+import { handleAsyncError } from '../utils.js';
+
+export default ({ config, runner }) =>
+  handleAsyncError(async (req, res) => {
+    const { pluginName } = req.body;
+    const plugins = config.get('plugins', {});
+    const dir = plugins[pluginName]?.dir;
+    if (!dir) throw new Error(`Plugin folder not found: ${pluginName}`);
+
+    const pluginRunner = await runner.startPlugin({
+      dir,
+      plugin: plugins[pluginName],
+    });
+
+    res.setHeader('Content-Type', 'application/json');
+    res.end(
+      JSON.stringify({
+        ...pluginRunner.pluginInfo,
+        port: pluginRunner.port,
+      }),
+    );
+  });

package/lib/apis/stopPlugin.js

@@ -0,0 +1,8 @@
+import utils, { handleAsyncError } from '../utils.js';
+
+export default ({ runner }) =>
+  handleAsyncError(async (req, res) => {
+    const { dir } = req.body;
+    await runner.stopPlugin({ dir });
+    res.end('ok');
+  });

package/lib/apis/terminals.js

@@ -0,0 +1,118 @@
+import os from 'os';
+import * as pty from 'node-pty';
+import fs from 'fs-extra';
+
+const getSehll = () => {
+  if (process.platform === 'win32') {
+    // For windows 10 use powershell
+    try {
+      const ver = os
+        .release()
+        .split('.')
+        .shift();
+      if (parseInt(ver, 10) >= 10) return 'powershell.exe';
+      // For windows 7 and below, use cmd.exe
+      return 'cmd.exe';
+    } catch (err) {
+      return 'cmd.exe';
+    }
+  }
+  // else {
+  //   // Use system shell for Mac
+
+  //   let source;
+  //   ['.bash_profile', '.bashrc']
+  //     .map(f => path.join(os.homedir(), f))
+  //     .some(file => {
+  //       if (fs.existsSync(file)) {
+  //         source = file;
+  //         return true;
+  //       }
+  //       return false;
+  //     });
+  //   console.log('bashrc: ', source);
+  //   if (source) shellArgs.push('--rcfile', source);
+
+  if (fs.existsSync('/bin/zsh')) return '/bin/zsh';
+  return '/bin/bash';
+
+  // }
+};
+
+export default function setupTerminals({ app }) {
+  const terminals = {};
+  const logs = {};
+
+  // Create a terminal
+  app.post('/api/terminals', function(req, res) {
+    const { dir, cols, rows } = req.body;
+    res.setHeader('Content-Type', 'application/json');
+    if (terminals[dir]) {
+      res.end(JSON.stringify({ pid: terminals[dir].pid }));
+      res.end();
+      return;
+    }
+
+    const shellArgs = [];
+    const term = pty.spawn(getSehll(), shellArgs, {
+      name: 'xterm-color',
+      cols: cols || 80,
+      rows: rows || 24,
+      cwd: dir,
+      env: process.env,
+    });
+
+    console.log('Created terminal with PID: ' + term.pid);
+    terminals[dir] = term;
+    logs[term.pid] = [];
+    term.on('data', function(data) {
+      const arr = logs[term.pid];
+      arr.push(data);
+      if (arr.length > 100) logs[term.pid] = arr.slice(arr.length - 100);
+    });
+    res.end(JSON.stringify({ pid: term.pid }));
+    res.end();
+  });
+
+  // Resize the terminal
+  app.post('/api/terminals/:pid/size', function(req, res) {
+    const pid = parseInt(req.params.pid, 10);
+    const { cols, rows } = req.body;
+    const term = Object.values(terminals).find((t) => t.pid === pid);
+    if (!term) {
+      res.end(`No terminal with PID: ${pid}`);
+      return;
+    }
+    term.resize(cols, rows);
+    res.end('Resized terminal ' + pid + ' to ' + cols + ' cols and ' + rows + ' rows.');
+  });
+
+  // Connect to the terminal
+  app.ws('/api/terminals/:pid', function(ws, req) {
+    console.log('Connecting to terminal ' + req.params.pid);
+    const term = Object.values(terminals).find((t) => t.pid === parseInt(req.params.pid, 10));
+
+    console.log('Connect to terminal ' + term.pid);
+    if (!term) throw new Error('Terminal not found');
+
+    ws.send(logs[term.pid].join(''));
+
+    term.on('data', function(data) {
+      try {
+        ws.send(data);
+      } catch (ex) {
+        // The WebSocket is not open, ignore
+      }
+    });
+    ws.on('message', function(msg) {
+      term.write(msg);
+    });
+    // ws.on('close', function () {
+    // console.log('Closed terminal ' + term.pid);
+    // term.kill();
+    // Clean things up
+    // delete terminals[term.pid];
+    // delete logs[term.pid];
+    // });
+  });
+}