@oxiaom/adoremix 1.0.0

package/src/config/wizard.js

@@ -0,0 +1,124 @@
+'use strict';
+
+const os = require('os');
+const prompts = require('prompts');
+const logger = require('../logger');
+
+function guessLocalIP() {
+  const ifaces = os.networkInterfaces();
+  for (const name of Object.keys(ifaces)) {
+    for (const it of ifaces[name]) {
+      if (it.family === 'IPv4' && !it.internal) return it.address;
+    }
+  }
+  return '127.0.0.1';
+}
+
+const QUESTIONS = [
+  {
+    type: 'text',
+    name: 'LocalIP',
+    message: '本机对外 IP（用于 Meida_ip / Fip / LocalIP）',
+    initial: () => guessLocalIP()
+  },
+  {
+    type: 'text',
+    name: 'task_ip',
+    message: 'MySQL 主机',
+    initial: '127.0.0.1'
+  },
+  {
+    type: 'number',
+    name: 'sqltask_port',
+    message: 'MySQL 端口',
+    initial: 3307
+  },
+  {
+    type: 'text',
+    name: 'task_username',
+    message: 'MySQL 用户名',
+    initial: 'root'
+  },
+  {
+    type: 'password',
+    name: 'task_passwd',
+    message: 'MySQL 密码'
+  },
+  {
+    type: 'text',
+    name: 'basename',
+    message: 'MySQL 数据库名',
+    initial: 'adore'
+  },
+  {
+    type: 'confirm',
+    name: 'EnableRedis',
+    message: '启用 Redis？',
+    initial: false
+  },
+  {
+    type: (prev) => prev ? 'text' : null,
+    name: 'RedisIP',
+    message: 'Redis 主机',
+    initial: '127.0.0.1'
+  },
+  {
+    type: (prev, values) => values.EnableRedis ? 'number' : null,
+    name: 'RedisPort',
+    message: 'Redis 端口',
+    initial: 6379
+  },
+  {
+    type: (prev, values) => values.EnableRedis ? 'password' : null,
+    name: 'RedisAUTH',
+    message: 'Redis 密码（无可留空）'
+  },
+  {
+    type: 'confirm',
+    name: '_enableTTS',
+    message: '启用讯飞 TTS？',
+    initial: true
+  },
+  {
+    type: (prev) => prev ? 'text' : null,
+    name: 'ttsxfAPPID',
+    message: '讯飞 APPID'
+  },
+  {
+    type: (prev, values) => values._enableTTS ? 'text' : null,
+    name: 'ttsxfAPISecret',
+    message: '讯飞 APISecret'
+  },
+  {
+    type: (prev, values) => values._enableTTS ? 'text' : null,
+    name: 'ttsxfAPIKey',
+    message: '讯飞 APIKey'
+  }
+];
+
+async function run(current) {
+  const answers = {};
+  const initial = Object.assign({}, current || {});
+
+  const onCancel = () => {
+    logger.warn('已取消');
+    process.exit(1);
+  };
+
+  for (const q of QUESTIONS) {
+    let q2 = q;
+    if (typeof q.initial === 'function' && q.type === 'text') {
+      q2 = Object.assign({}, q, { initial: q.initial(answers) });
+    } else if (initial[q.name] !== undefined) {
+      q2 = Object.assign({}, q, { initial: initial[q.name] });
+    }
+    const res = await prompts(q2, { onCancel });
+    if (res[q.name] !== undefined) {
+      answers[q.name] = res[q.name];
+    }
+  }
+  delete answers._enableTTS;
+  return answers;
+}
+
+module.exports = { run, guessLocalIP };

package/src/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+module.exports = {
+  paths: require('./paths'),
+  logger: require('./logger'),
+  cli: require('./cli')
+};

package/src/install.js

@@ -0,0 +1,173 @@
+'use strict';
+
+const fs = require('fs');
+const fse = require('fs-extra');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const paths = require('./paths');
+const logger = require('./logger');
+
+const EMPTY_DIRS = ['var', 'logs', 'dmp', 'tty', 'temp'];
+
+const NODE_HELPER_DEPS = {
+  'axios': '^1.5.0',
+  'crypto-js': '^4.1.1',
+  'log4node': '^0.1.6',
+  'mysql': '^2.18.1',
+  'request': '^2.88.2',
+  'sqlite': '^4.2.0',
+  'ws': '^8.13.0'
+};
+
+function isWorkdirInitialized(workdir) {
+  return fs.existsSync(path.join(workdir, '.adoremix-installed'));
+}
+
+function ensureWorkdir(workdir) {
+  if (!fs.existsSync(workdir)) {
+    fse.ensureDirSync(workdir);
+    logger.ok(`创建工作目录 ${workdir}`);
+  } else {
+    logger.info(`工作目录已存在 ${workdir}`);
+  }
+}
+
+function copyNative(native, workdir, force) {
+  if (!native.exists()) {
+    throw new Error(
+      `原生二进制 ${native.binName} 未找到。\n` +
+      `路径：${native.bin}\n` +
+      `请先运行拆分脚本：node scripts/split-zip.js --only ${paths.PLATFORM_KEY.replace('_', '-')}`
+    );
+  }
+  const marker = path.join(workdir, '.adoremix-installed');
+  if (fs.existsSync(marker) && !force) {
+    logger.warn(`工作目录已初始化（存在 ${marker}）。使用 --force 覆盖。`);
+    return false;
+  }
+  logger.info(`复制 native 资源 ${native.root} -> ${workdir}`);
+  fse.copySync(native.root, workdir, {
+    filter: (s) => {
+      const base = path.basename(s);
+      return base !== 'README.md' || path.dirname(s) !== native.root;
+    }
+  });
+  fs.writeFileSync(marker, JSON.stringify({
+    version: require('../package.json').version,
+    platform: native.platform,
+    arch: native.arch,
+    binName: native.binName,
+    installedAt: new Date().toISOString()
+  }, null, 2), 'utf8');
+  logger.ok('资源复制完成');
+  return true;
+}
+
+function chmodBinaries(workdir, native) {
+  if (process.platform === 'win32') return;
+  for (const rel of [native.binName, 'lame', 'xiaoboshu.py']) {
+    const p = path.join(workdir, rel);
+    if (fs.existsSync(p)) {
+      fs.chmodSync(p, 0o755);
+      logger.log(`  chmod 0755 ${rel}`);
+    }
+  }
+}
+
+function ensureEmptyDirs(workdir) {
+  for (const d of EMPTY_DIRS) {
+    const p = path.join(workdir, d);
+    fse.ensureDirSync(p);
+  }
+  logger.ok('创建空目录：var/ logs/ dmp/ tty/ temp/');
+}
+
+function writeHelperPackageJson(workdir) {
+  const pkgPath = path.join(workdir, 'package.json');
+  const existing = fs.existsSync(pkgPath) ? JSON.parse(fs.readFileSync(pkgPath, 'utf8')) : {};
+  existing.name = existing.name || 'adoremix-workdir';
+  existing.version = existing.version || '1.0.0';
+  existing.private = true;
+  existing.dependencies = Object.assign({}, NODE_HELPER_DEPS, existing.dependencies || {});
+  fs.writeFileSync(pkgPath, JSON.stringify(existing, null, 2), 'utf8');
+  logger.ok('写入 package.json（tts.js/find.js/findsc.js 协作依赖）');
+  return pkgPath;
+}
+
+function installHelperDeps(workdir, skipNpmInstall) {
+  if (skipNpmInstall) {
+    logger.warn('--skip-npm-install 跳过协作依赖安装');
+    return;
+  }
+  logger.info('在工作目录安装 Node 协作依赖（axios/ws/crypto-js/mysql 等）...');
+  try {
+    execSync('npm install --production --no-audit --no-fund', {
+      cwd: workdir,
+      stdio: 'inherit'
+    });
+    logger.ok('协作依赖安装完成');
+  } catch (e) {
+    logger.error('npm install 失败，请手动到工作目录执行 npm install');
+    throw e;
+  }
+}
+
+async function runInstall(opts) {
+  opts = opts || {};
+  const workdir = opts.workdir || paths.defaultWorkdir();
+  let native;
+  try {
+    native = opts.native || paths.loadNative();
+  } catch (e) {
+    logger.error(e.message);
+    return 1;
+  }
+  if (native.notice) {
+    logger.warn(native.notice);
+  }
+  logger.log(`平台       ${native.platform}-${native.arch}`);
+  logger.log(`工作目录   ${workdir}`);
+  logger.log(`主二进制   ${native.binName}`);
+  logger.log('');
+
+  ensureWorkdir(workdir);
+  let copied;
+  try {
+    copied = copyNative(native, workdir, opts.force);
+  } catch (e) {
+    logger.error(e.message);
+    return 1;
+  }
+  if (!copied && !opts.force) return 1;
+
+  chmodBinaries(workdir, native);
+  ensureEmptyDirs(workdir);
+  writeHelperPackageJson(workdir);
+  try {
+    installHelperDeps(workdir, opts.skipNpmInstall);
+  } catch (e) {
+    return 1;
+  }
+
+  const config = require('./config');
+  const cfgOk = await config.ensureConfig(workdir, { interactive: opts.interactive !== false, force: opts.force });
+  if (!cfgOk) {
+    logger.warn('配置未生成。请稍后运行 adoremix config init');
+  }
+
+  logger.log('');
+  logger.ok('安装完成。');
+  logger.log('  启动（前台）        adoremix start');
+  logger.log('  开机自启            adoremix service install');
+  logger.log('  查看状态            adoremix status');
+  logger.log('  查看日志            adoremix logs --follow');
+  return 0;
+}
+
+module.exports = {
+  runInstall,
+  EMPTY_DIRS,
+  NODE_HELPER_DEPS,
+  isWorkdirInitialized
+};

package/src/logger.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const isatty = process.stdout.isTTY;
+
+function ts() {
+  return new Date().toISOString();
+}
+
+function fmt(level, args) {
+  return [`${ts()} [${level}]`].concat(Array.from(args));
+}
+
+module.exports = {
+  log(...args) {
+    console.log(...args);
+  },
+  info(...args) {
+    console.log(...(isatty ? ['\x1b[36m[info]\x1b[0m'] : ['[info]']).concat(args));
+  },
+  warn(...args) {
+    console.warn(...(isatty ? ['\x1b[33m[warn]\x1b[0m'] : ['[warn]']).concat(args));
+  },
+  error(...args) {
+    console.error(...(isatty ? ['\x1b[31m[err ]\x1b[0m'] : ['[err ]']).concat(args));
+  },
+  ok(...args) {
+    console.log(...(isatty ? ['\x1b[32m[ok  ]\x1b[0m'] : ['[ok  ]']).concat(args));
+  }
+};

package/src/paths.js

@@ -0,0 +1,94 @@
+'use strict';
+
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+
+const PLATFORM_KEY = `${process.platform}_${process.arch}`;
+const PLATFORM_PKG = {
+  'win32_x64': '@oxiaom/adoremix-win32-x64',
+  'linux_x64': '@oxiaom/adoremix-linux-x64',
+  'linux_arm64': '@oxiaom/adoremix-linux-arm64',
+  'linux_arm': '@oxiaom/adoremix-linux-arm'
+}[PLATFORM_KEY];
+
+let _native = null;
+let _loadError = null;
+
+function loadNative() {
+  if (_native) return _native;
+  if (_loadError) throw _loadError;
+  if (!PLATFORM_PKG) {
+    _loadError = new Error(`不支持的平台：${PLATFORM_KEY}。当前支持 win32-x64 / linux-x64 / linux-arm64 / linux-arm。`);
+    throw _loadError;
+  }
+  try {
+    _native = require(PLATFORM_PKG);
+  } catch (e) {
+    _loadError = new Error(
+      `未安装平台子包 ${PLATFORM_PKG}。可能原因：\n` +
+      `  - npm install 时被 --no-optional 跳过\n` +
+      `  - 子包尚未发布到 npm registry\n` +
+      `原始错误：${e.message}`
+    );
+    throw _loadError;
+  }
+  return _native;
+}
+
+function defaultWorkdir() {
+  if (process.platform === 'win32') {
+    const base = process.env.PROGRAMDATA || 'C:\\ProgramData';
+    return path.join(base, 'adoremix');
+  }
+  if (process.getuid && process.getuid() === 0) {
+    return '/opt/adoremix';
+  }
+  const xdg = process.env.XDG_DATA_HOME;
+  return xdg ? path.join(xdg, 'adoremix') : path.join(os.homedir(), '.local', 'share', 'adoremix');
+}
+
+function workdirPaths(workdir) {
+  return {
+    root: workdir,
+    config: path.join(workdir, 'config.ini'),
+    bin: null,
+    lame: null,
+    pidfile: path.join(workdir, 'var', 'app.pid'),
+    logfile: path.join(workdir, 'var', 'app.log'),
+    svcLog: path.join(workdir, 'logs', 'svc.log'),
+    svcErr: path.join(workdir, 'logs', 'svc.err'),
+    varDir: path.join(workdir, 'var'),
+    logsDir: path.join(workdir, 'logs'),
+    dmpDir: path.join(workdir, 'dmp'),
+    ttyDir: path.join(workdir, 'tty'),
+    tempDir: path.join(workdir, 'temp'),
+    etcDir: path.join(workdir, 'etc'),
+    confDir: path.join(workdir, 'conf'),
+    htmlDir: path.join(workdir, 'html'),
+    nodeModulesDir: path.join(workdir, 'node_modules')
+  };
+}
+
+function cliRoot() {
+  return path.join(__dirname, '..');
+}
+
+function nodeExecutable() {
+  return process.execPath;
+}
+
+function cliBin() {
+  return path.join(cliRoot(), 'bin', 'adoremix.js');
+}
+
+module.exports = {
+  PLATFORM_KEY,
+  PLATFORM_PKG,
+  loadNative,
+  defaultWorkdir,
+  workdirPaths,
+  cliRoot,
+  cliBin,
+  nodeExecutable
+};

package/src/runner/index.js

@@ -0,0 +1,6 @@
+'use strict';
+
+module.exports = Object.assign(
+  require('./spawn'),
+  { pid: require('./pid'), signals: require('./signals') }
+);

package/src/runner/pid.js

@@ -0,0 +1,65 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const pidusage = require('pidusage');
+
+function readPid(pidfile) {
+  if (!fs.existsSync(pidfile)) return null;
+  const txt = fs.readFileSync(pidfile, 'utf8').trim();
+  if (!txt) return null;
+  const n = parseInt(txt, 10);
+  return Number.isFinite(n) ? n : null;
+}
+
+function writePid(pidfile, pid) {
+  fs.mkdirSync(path.dirname(pidfile), { recursive: true });
+  fs.writeFileSync(pidfile, String(pid), 'utf8');
+}
+
+function clearPid(pidfile) {
+  if (fs.existsSync(pidfile)) fs.unlinkSync(pidfile);
+}
+
+function isRunning(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === 'EPERM';
+  }
+}
+
+async function stat(pid) {
+  if (!pid) return null;
+  try {
+    const s = await pidusage(pid);
+    return s;
+  } catch (e) {
+    return null;
+  }
+}
+
+async function killPid(pid, timeout) {
+  timeout = timeout || 8000;
+  if (!isRunning(pid)) return true;
+  const sig = process.platform === 'win32' ? 'SIGTERM' : 'SIGTERM';
+  try {
+    process.kill(pid, sig);
+  } catch (e) {
+    if (e.code !== 'ESRCH') throw e;
+  }
+  const deadline = Date.now() + timeout;
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, 200));
+    if (!isRunning(pid)) return true;
+  }
+  if (process.platform !== 'win32') {
+    try { process.kill(pid, 'SIGKILL'); } catch (e) {}
+    await new Promise((r) => setTimeout(r, 300));
+  }
+  return !isRunning(pid);
+}
+
+module.exports = { readPid, writePid, clearPid, isRunning, stat, killPid };

package/src/runner/signals.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const logger = require('../logger');
+
+function installGlobalHandlers(context) {
+  const forward = (sig) => {
+    if (context && context.child && !context.child.killed) {
+      try { process.kill(context.child.pid, sig); } catch (e) {}
+    }
+  };
+  process.on('SIGINT', () => { logger.info('SIGINT 收到，转发'); forward('SIGINT'); });
+  process.on('SIGTERM', () => { logger.info('SIGTERM 收到，转发'); forward('SIGTERM'); });
+}
+
+module.exports = { installGlobalHandlers };

package/src/runner/spawn.js

@@ -0,0 +1,153 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const pidMgr = require('./pid');
+const paths = require('../paths');
+const logger = require('../logger');
+
+function ensureLogFiles(workdirPaths) {
+  fs.mkdirSync(workdirPaths.varDir, { recursive: true });
+  fs.mkdirSync(workdirPaths.logsDir, { recursive: true });
+}
+
+function startForeground(opts) {
+  const native = opts.native;
+  const workdir = opts.workdir;
+  const configPath = opts.configPath;
+  const wp = paths.workdirPaths(workdir);
+
+  ensureLogFiles(wp);
+  if (!fs.existsSync(configPath)) {
+    throw new Error(`配置不存在 ${configPath}，请先运行 adoremix install`);
+  }
+  if (!fs.existsSync(native.bin)) {
+    throw new Error(`原生二进制不存在 ${native.bin}`);
+  }
+
+  const args = [path.basename(configPath)];
+  logger.info(`spawn ${native.binName} ${args.join(' ')} (cwd=${workdir})`);
+  const child = spawn(native.bin, args, {
+    cwd: workdir,
+    stdio: ['ignore', 'pipe', 'pipe'],
+    windowsHide: false
+  });
+
+  child.stdout.on('data', (d) => process.stdout.write(d));
+  child.stderr.on('data', (d) => process.stderr.write(d));
+
+  pidMgr.writePid(wp.pidfile, child.pid);
+  logger.ok(`已启动 PID=${child.pid}（前台模式，Ctrl+C 退出）`);
+
+  const forward = (sig) => {
+    if (!child.killed) {
+      try { process.kill(child.pid, sig); } catch (e) {}
+    }
+  };
+  process.on('SIGINT', () => forward('SIGINT'));
+  process.on('SIGTERM', () => forward('SIGTERM'));
+
+  child.on('exit', (code, signal) => {
+    pidMgr.clearPid(wp.pidfile);
+    logger.log(`子进程退出 code=${code} signal=${signal}`);
+    process.exit(code == null ? 0 : code);
+  });
+
+  return child;
+}
+
+function startDaemon(opts) {
+  const native = opts.native;
+  const workdir = opts.workdir;
+  const configPath = opts.configPath;
+  const wp = paths.workdirPaths(workdir);
+
+  ensureLogFiles(wp);
+  if (!fs.existsSync(configPath)) {
+    throw new Error(`配置不存在 ${configPath}，请先运行 adoremix install`);
+  }
+  if (!fs.existsSync(native.bin)) {
+    throw new Error(`原生二进制不存在 ${native.bin}`);
+  }
+
+  const running = pidMgr.readPid(wp.pidfile);
+  if (running && pidMgr.isRunning(running)) {
+    logger.warn(`已在运行 PID=${running}`);
+    return { alreadyRunning: true, pid: running };
+  }
+
+  const out = fs.openSync(wp.logfile, 'a');
+  const err = fs.openSync(wp.logfile, 'a');
+  const args = [path.basename(configPath)];
+  logger.info(`spawn ${native.binName} ${args.join(' ')} (cwd=${workdir}, daemon)`);
+  const child = spawn(native.bin, args, {
+    cwd: workdir,
+    stdio: ['ignore', out, err],
+    detached: true,
+    windowsHide: false
+  });
+  child.unref();
+  pidMgr.writePid(wp.pidfile, child.pid);
+  logger.ok(`已启动 PID=${child.pid}（后台模式，日志：${path.relative(workdir, wp.logfile)}`);
+  return { pid: child.pid };
+}
+
+async function stop(opts) {
+  const workdir = opts.workdir;
+  const wp = paths.workdirPaths(workdir);
+  const pid = pidMgr.readPid(wp.pidfile);
+  if (!pid) {
+    logger.warn(`未找到 PID 文件 ${wp.pidfile}`);
+    return 1;
+  }
+  if (!pidMgr.isRunning(pid)) {
+    logger.warn(`PID=${pid} 已不在运行，清理 pidfile`);
+    pidMgr.clearPid(wp.pidfile);
+    return 0;
+  }
+  logger.info(`停止 PID=${pid} ...`);
+  const ok = await pidMgr.killPid(pid, opts.timeout || 10000);
+  if (ok) {
+    pidMgr.clearPid(wp.pidfile);
+    logger.ok('已停止');
+    return 0;
+  }
+  logger.error(`无法停止 PID=${pid}，请用系统工具手动结束`);
+  return 1;
+}
+
+async function status(opts) {
+  const workdir = opts.workdir;
+  const wp = paths.workdirPaths(workdir);
+  const pid = pidMgr.readPid(wp.pidfile);
+  if (!pid) {
+    logger.log('状态：未运行');
+    return 2;
+  }
+  if (!pidMgr.isRunning(pid)) {
+    logger.log(`状态：未运行（残留 pidfile，PID=${pid}）`);
+    pidMgr.clearPid(wp.pidfile);
+    return 2;
+  }
+  const s = await pidMgr.stat(pid);
+  const cpu = s ? s.cpu.toFixed(1) + '%' : '?';
+  const mem = s ? Math.round(s.memory / 1024 / 1024) + ' MB' : '?';
+  logger.log(`状态：运行中  PID=${pid}  CPU=${cpu}  MEM=${mem}`);
+  return 0;
+}
+
+async function restart(opts) {
+  await stop(opts);
+  await new Promise((r) => setTimeout(r, 500));
+  return opts.daemon ? startDaemon(opts) : startForeground(opts);
+}
+
+module.exports = {
+  startForeground,
+  startDaemon,
+  stop,
+  status,
+  restart
+};

package/src/service/index.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const logger = require('../logger');
+
+function pick() {
+  if (process.platform === 'win32') return require('./windows');
+  if (process.platform === 'linux') return require('./linux');
+  throw new Error(`service 子命令暂不支持平台 ${process.platform}`);
+}
+
+module.exports = {
+  install(opts) { return pick().install(opts); },
+  uninstall(opts) { return pick().uninstall(opts); },
+  status() { return pick().status(); }
+};