@bitseek/hermes-webui 0.1.0-beta.0

package/bin/hermes-webui.mjs

@@ -0,0 +1,588 @@
+#!/usr/bin/env node
+import {
+  createReadStream,
+  existsSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs'
+import { access, constants } from 'node:fs/promises'
+import { spawn, spawnSync } from 'node:child_process'
+import { delimiter, dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { homedir, platform } from 'node:os'
+import { createInterface } from 'node:readline'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const packageRoot = resolve(__dirname, '..')
+const vendorRoot = resolve(packageRoot, 'vendor', 'agent-frontend-shell')
+const bootstrapPath = resolve(vendorRoot, 'bootstrap.py')
+const serverPath = resolve(vendorRoot, 'server.py')
+const requirementsPath = resolve(vendorRoot, 'requirements.txt')
+const sourceInfoPath = resolve(vendorRoot, '.bitseek-source.json')
+const packageJson = JSON.parse(readFileSync(resolve(packageRoot, 'package.json'), 'utf8'))
+
+const DEFAULT_HOST = '127.0.0.1'
+const DEFAULT_PORT = 8787
+
+function usage() {
+  console.log(`@bitseek/hermes-webui v${packageJson.version}
+
+Usage:
+  hermes-webui start [--foreground] [--port <port>] [--host <host>] [--open]
+  hermes-webui stop [--port <port>]
+  hermes-webui restart [--port <port>] [--host <host>]
+  hermes-webui status [--port <port>]
+  hermes-webui logs [--lines <n>] [--follow]
+  hermes-webui doctor [--port <port>]
+  hermes-webui version
+
+Environment:
+  HERMES_HOME              Defaults to ~/.hermes
+  HERMES_WEBUI_STATE_DIR   Defaults to $HERMES_HOME/webui
+  HERMES_WEBUI_PYTHON      Use an existing Python interpreter
+  HERMES_WEBUI_VENV_DIR    Defaults to $HERMES_WEBUI_STATE_DIR/venv
+  HERMES_WEBUI_AGENT_DIR   Optional Hermes Agent checkout
+`)
+}
+
+function parseArgs(argv) {
+  const command = argv[2] || 'start'
+  const options = {
+    command,
+    host: process.env.HERMES_WEBUI_HOST || DEFAULT_HOST,
+    port: Number(process.env.HERMES_WEBUI_PORT || DEFAULT_PORT),
+    foreground: false,
+    open: false,
+    follow: false,
+    lines: 100,
+  }
+
+  const rest = argv.slice(3)
+  for (let i = 0; i < rest.length; i += 1) {
+    const arg = rest[i]
+    if (arg === '--foreground') options.foreground = true
+    else if (arg === '--open') options.open = true
+    else if (arg === '--follow') options.follow = true
+    else if (arg === '--host') options.host = rest[++i]
+    else if (arg.startsWith('--host=')) options.host = arg.slice('--host='.length)
+    else if (arg === '--port') options.port = Number(rest[++i])
+    else if (arg.startsWith('--port=')) options.port = Number(arg.slice('--port='.length))
+    else if (arg === '--lines') options.lines = Number(rest[++i])
+    else if (arg.startsWith('--lines=')) options.lines = Number(arg.slice('--lines='.length))
+    else if (/^\d+$/.test(arg)) options.port = Number(arg)
+    else if (arg === '-h' || arg === '--help') options.command = 'help'
+    else {
+      throw new Error(`Unknown argument: ${arg}`)
+    }
+  }
+
+  if (!Number.isInteger(options.port) || options.port < 1 || options.port > 65535) {
+    throw new Error(`Invalid port: ${options.port}`)
+  }
+  if (!Number.isInteger(options.lines) || options.lines < 1) {
+    throw new Error(`Invalid --lines: ${options.lines}`)
+  }
+  return options
+}
+
+function expandHome(value) {
+  if (!value) return value
+  if (value === '~') return homedir()
+  if (value.startsWith('~/')) return join(homedir(), value.slice(2))
+  return value
+}
+
+function hermesHome() {
+  return resolve(expandHome(process.env.HERMES_HOME || join(homedir(), '.hermes')))
+}
+
+function stateDir() {
+  return resolve(expandHome(process.env.HERMES_WEBUI_STATE_DIR || join(hermesHome(), 'webui')))
+}
+
+function statePaths() {
+  const dir = stateDir()
+  return {
+    dir,
+    pid: join(dir, 'server.pid'),
+    log: join(dir, 'server.log'),
+    runtime: join(dir, 'runtime.json'),
+    venv: resolve(expandHome(process.env.HERMES_WEBUI_VENV_DIR || join(dir, 'venv'))),
+  }
+}
+
+function readJson(path) {
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+function sourceInfo() {
+  return readJson(sourceInfoPath)
+}
+
+function runtimeInfo() {
+  return readJson(statePaths().runtime)
+}
+
+function writeRuntimeInfo(info) {
+  const paths = statePaths()
+  mkdirSync(paths.dir, { recursive: true })
+  writeFileSync(paths.runtime, `${JSON.stringify(info, null, 2)}\n`, { mode: 0o600 })
+}
+
+function readPid() {
+  try {
+    const raw = readFileSync(statePaths().pid, 'utf8').trim()
+    const pid = Number(raw)
+    return Number.isInteger(pid) && pid > 0 ? pid : null
+  } catch {
+    return null
+  }
+}
+
+function writePid(pid) {
+  const paths = statePaths()
+  mkdirSync(paths.dir, { recursive: true })
+  writeFileSync(paths.pid, `${pid}\n`, { mode: 0o600 })
+}
+
+function removePid() {
+  rmSync(statePaths().pid, { force: true })
+}
+
+function isRunning(pid) {
+  if (!pid) return false
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch (err) {
+    return err?.code === 'EPERM'
+  }
+}
+
+function commandExists(command) {
+  const result = spawnSync(platform() === 'win32' ? 'where' : 'sh', platform() === 'win32'
+    ? [command]
+    : ['-c', 'command -v "$1" >/dev/null 2>&1', 'sh', command], {
+    stdio: 'ignore',
+  })
+  return result.status === 0
+}
+
+function findSystemPython() {
+  const candidates = platform() === 'win32' ? ['python.exe', 'python'] : ['python3', 'python']
+  for (const candidate of candidates) {
+    const result = spawnSync(candidate, ['--version'], { stdio: 'ignore' })
+    if (result.status === 0) return candidate
+  }
+  return null
+}
+
+function venvPython(venvDir) {
+  return platform() === 'win32'
+    ? join(venvDir, 'Scripts', 'python.exe')
+    : join(venvDir, 'bin', 'python')
+}
+
+function runChecked(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    stdio: options.stdio || 'inherit',
+    env: options.env || process.env,
+    cwd: options.cwd,
+    encoding: options.encoding,
+  })
+  if (result.status !== 0) {
+    throw new Error(`${command} ${args.join(' ')} failed with exit code ${result.status}`)
+  }
+  return result
+}
+
+function pythonImportsOk(python) {
+  const result = spawnSync(python, ['-c', 'import yaml; import cryptography; print("ok")'], {
+    stdio: ['ignore', 'pipe', 'pipe'],
+    encoding: 'utf8',
+  })
+  return result.status === 0
+}
+
+function preparePython() {
+  if (process.env.HERMES_WEBUI_PYTHON) {
+    return resolve(expandHome(process.env.HERMES_WEBUI_PYTHON))
+  }
+
+  const paths = statePaths()
+  const python = venvPython(paths.venv)
+  if (!existsSync(python)) {
+    const basePython = findSystemPython()
+    if (!basePython) throw new Error('Python 3 is required but was not found in PATH')
+    mkdirSync(paths.dir, { recursive: true })
+    runChecked(basePython, ['-m', 'venv', '--system-site-packages', paths.venv])
+  }
+
+  if (!pythonImportsOk(python)) {
+    runChecked(python, ['-m', 'pip', 'install', '-r', requirementsPath])
+  }
+  return python
+}
+
+function resolveAgentDir() {
+  const candidates = [
+    process.env.HERMES_WEBUI_AGENT_DIR,
+    join(hermesHome(), 'hermes-agent'),
+    resolve(packageRoot, '..', 'hermes-agent'),
+  ].filter(Boolean)
+
+  for (const candidate of candidates) {
+    const resolved = resolve(expandHome(candidate))
+    if (existsSync(join(resolved, 'run_agent.py'))) return resolved
+  }
+  return null
+}
+
+function buildEnv(python, options) {
+  const paths = statePaths()
+  const env = {
+    ...process.env,
+    HERMES_HOME: hermesHome(),
+    HERMES_WEBUI_STATE_DIR: paths.dir,
+    HERMES_WEBUI_HOST: options.host,
+    HERMES_WEBUI_PORT: String(options.port),
+    HERMES_WEBUI_PYTHON: python,
+    HERMES_WEBUI_PRESERVE_ENV: '1',
+    PYTHONUNBUFFERED: '1',
+  }
+  const agentDir = resolveAgentDir()
+  if (agentDir) {
+    env.HERMES_WEBUI_AGENT_DIR = agentDir
+    env.PYTHONPATH = env.PYTHONPATH ? `${agentDir}${delimiter}${env.PYTHONPATH}` : agentDir
+  }
+  if (process.env.BITSEEK_HERMES_BUNDLE_MANAGED) {
+    env.BITSEEK_HERMES_BUNDLE_MANAGED = process.env.BITSEEK_HERMES_BUNDLE_MANAGED
+  }
+  return env
+}
+
+async function healthCheck(host, port, timeoutMs = 1000) {
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(), timeoutMs)
+  try {
+    const res = await fetch(`http://${host}:${port}/health`, {
+      signal: controller.signal,
+      cache: 'no-store',
+    })
+    if (!res.ok) return { ok: false, status: res.status }
+    const text = await res.text()
+    return { ok: text.includes('"status": "ok"'), status: res.status, body: text }
+  } catch (err) {
+    return { ok: false, error: err?.message || String(err) }
+  } finally {
+    clearTimeout(timer)
+  }
+}
+
+async function waitForHealth(host, port, child, timeoutMs = 30000) {
+  const started = Date.now()
+  while (Date.now() - started < timeoutMs) {
+    if (child && !isRunning(child.pid)) {
+      return { ok: false, error: 'process exited before health check passed' }
+    }
+    const result = await healthCheck(host, port, 1500)
+    if (result.ok) return result
+    await new Promise((resolveWait) => setTimeout(resolveWait, 500))
+  }
+  return { ok: false, error: `health check did not pass within ${timeoutMs / 1000}s` }
+}
+
+async function start(options) {
+  if (!existsSync(bootstrapPath) || !existsSync(serverPath)) {
+    throw new Error('Vendored agent-frontend-shell runtime is missing. Run npm run sync:vendor.')
+  }
+
+  const existing = readPid()
+  if (existing && isRunning(existing)) {
+    throw new Error(`Hermes WebUI is already running (PID ${existing})`)
+  }
+  removePid()
+
+  const occupied = await portOccupied(options.host, options.port)
+  if (occupied) {
+    throw new Error(`Port ${options.port} is already occupied; not managed by this wrapper`)
+  }
+
+  const paths = statePaths()
+  mkdirSync(paths.dir, { recursive: true })
+  const python = preparePython()
+  const env = buildEnv(python, options)
+  const args = [serverPath]
+
+  if (options.foreground) {
+    const child = spawn(python, args, {
+      stdio: 'inherit',
+      env,
+      cwd: vendorRoot,
+    })
+    writePid(child.pid)
+    writeRuntimeInfo({
+      pid: child.pid,
+      mode: 'foreground',
+      host: options.host,
+      port: options.port,
+      log: null,
+      python,
+      hermes_home: hermesHome(),
+      state_dir: paths.dir,
+      agent_dir: env.HERMES_WEBUI_AGENT_DIR || null,
+      vendor: sourceInfo(),
+      started_at: new Date().toISOString(),
+    })
+    process.on('SIGINT', () => child.kill('SIGINT'))
+    process.on('SIGTERM', () => child.kill('SIGTERM'))
+    child.on('exit', (code, signal) => {
+      removePid()
+      process.exit(code ?? (signal ? 128 : 1))
+    })
+    return
+  }
+
+  const logFd = openSync(paths.log, 'a')
+  const child = spawn(python, args, {
+    detached: true,
+    stdio: ['ignore', logFd, logFd],
+    env,
+    cwd: vendorRoot,
+  })
+  child.unref()
+  writePid(child.pid)
+  writeRuntimeInfo({
+    pid: child.pid,
+    mode: 'daemon',
+    host: options.host,
+    port: options.port,
+    log: paths.log,
+    python,
+    hermes_home: hermesHome(),
+    state_dir: paths.dir,
+    agent_dir: env.HERMES_WEBUI_AGENT_DIR || null,
+    vendor: sourceInfo(),
+    started_at: new Date().toISOString(),
+  })
+
+  console.log(`Starting Bitseek Hermes WebUI (PID ${child.pid}, port ${options.port})...`)
+  const health = await waitForHealth(options.host, options.port, child)
+  if (!health.ok) {
+    console.log(`Health check failed: ${health.error || health.status || 'unknown error'}`)
+    console.log(`Log: ${paths.log}`)
+    process.exit(1)
+  }
+
+  console.log('Bitseek Hermes WebUI started')
+  console.log(`URL: http://${options.host === '127.0.0.1' ? 'localhost' : options.host}:${options.port}`)
+  console.log(`Log: ${paths.log}`)
+  if (options.open) openBrowser(options.host, options.port)
+}
+
+async function stop() {
+  const pid = readPid()
+  if (!pid) {
+    const info = runtimeInfo()
+    if (info?.port) {
+      const occupied = await portOccupied(info.host || DEFAULT_HOST, Number(info.port))
+      if (occupied) {
+        console.log(`WebUI pid file missing. Port ${info.port} is occupied, not managed by this wrapper.`)
+        process.exit(1)
+      }
+    }
+    console.log('Bitseek Hermes WebUI is not running')
+    return
+  }
+
+  if (!isRunning(pid)) {
+    removePid()
+    console.log(`Bitseek Hermes WebUI was not running; cleaned stale PID ${pid}`)
+    return
+  }
+
+  process.kill(pid, 'SIGTERM')
+  for (let i = 0; i < 20; i += 1) {
+    if (!isRunning(pid)) break
+    await new Promise((resolveWait) => setTimeout(resolveWait, 250))
+  }
+  if (isRunning(pid)) {
+    process.kill(pid, 'SIGKILL')
+  }
+  removePid()
+  console.log(`Bitseek Hermes WebUI stopped (PID ${pid})`)
+}
+
+async function restart(options) {
+  await stop()
+  await start(options)
+}
+
+async function status(options) {
+  const paths = statePaths()
+  const pid = readPid()
+  const running = pid ? isRunning(pid) : false
+  const info = runtimeInfo() || {}
+  const host = info.host || options.host
+  const port = Number(info.port || options.port)
+  const health = running ? await healthCheck(host, port, 1500) : { ok: false }
+  const vendor = sourceInfo()
+
+  console.log(`Status: ${running ? 'running' : 'stopped'}`)
+  console.log(`PID: ${pid || '-'}`)
+  console.log(`Host: ${host}`)
+  console.log(`Port: ${port}`)
+  console.log(`Health: ${health.ok ? 'ok' : 'unavailable'}`)
+  console.log(`Log: ${paths.log}`)
+  console.log(`State dir: ${paths.dir}`)
+  console.log(`Python: ${info.python || process.env.HERMES_WEBUI_PYTHON || '-'}`)
+  console.log(`Hermes home: ${info.hermes_home || hermesHome()}`)
+  console.log(`Hermes Agent dir: ${info.agent_dir || resolveAgentDir() || '-'}`)
+  console.log(`Vendor commit: ${vendor?.commit || '-'}`)
+}
+
+async function logs(options) {
+  const path = statePaths().log
+  if (!existsSync(path)) {
+    throw new Error(`Log file does not exist: ${path}`)
+  }
+  if (options.follow) {
+    await tailFollow(path, options.lines)
+    return
+  }
+  const content = readFileSync(path, 'utf8')
+  const lines = content.split(/\r?\n/)
+  console.log(lines.slice(-options.lines).join('\n'))
+}
+
+async function tailFollow(path, lines) {
+  const content = readFileSync(path, 'utf8')
+  console.log(content.split(/\r?\n/).slice(-lines).join('\n'))
+  const child = spawn(platform() === 'win32' ? 'powershell.exe' : 'tail', platform() === 'win32'
+    ? ['-NoProfile', '-Command', `Get-Content -Wait -Tail 0 ${JSON.stringify(path)}`]
+    : ['-f', path], {
+    stdio: 'inherit',
+  })
+  child.on('exit', (code) => process.exit(code ?? 0))
+}
+
+async function doctor(options) {
+  const checks = []
+  const add = (name, ok, detail = '') => checks.push({ name, ok, detail })
+  const paths = statePaths()
+
+  add('node version', /^v(2[0-4])\./.test(process.version), process.version)
+  add('vendor runtime', existsSync(vendorRoot), vendorRoot)
+  add('bootstrap.py', existsSync(bootstrapPath), bootstrapPath)
+  add('server.py', existsSync(serverPath), serverPath)
+  add('requirements.txt', existsSync(requirementsPath), requirementsPath)
+  add('source metadata', existsSync(sourceInfoPath), sourceInfoPath)
+  mkdirSync(paths.dir, { recursive: true })
+  add('state dir writable', await writable(paths.dir), paths.dir)
+  add('HERMES_HOME writable', await writable(hermesHome()), hermesHome())
+  let python = process.env.HERMES_WEBUI_PYTHON || (existsSync(venvPython(paths.venv)) ? venvPython(paths.venv) : findSystemPython())
+  if (python && !pythonImportsOk(python)) {
+    try {
+      python = preparePython()
+    } catch {
+      // Keep the original python value so the failed check below points at it.
+    }
+  }
+  add('python available', Boolean(python), python || 'not found')
+  if (python) add('webui requirements import', pythonImportsOk(python), python)
+  const agentDir = resolveAgentDir()
+  add('Hermes Agent dir', Boolean(agentDir), agentDir || 'not found')
+  add('run_agent.py', Boolean(agentDir && existsSync(join(agentDir, 'run_agent.py'))), agentDir ? join(agentDir, 'run_agent.py') : 'not found')
+  add('port available', !(await portOccupied(options.host, options.port)), `${options.host}:${options.port}`)
+  add('no vendored .env', !existsSync(join(vendorRoot, '.env')), join(vendorRoot, '.env'))
+  add('no vendored .git', !existsSync(join(vendorRoot, '.git')), join(vendorRoot, '.git'))
+  add('no vendored .venv', !existsSync(join(vendorRoot, '.venv')), join(vendorRoot, '.venv'))
+  add('no vendored node_modules', !existsSync(join(vendorRoot, 'node_modules')), join(vendorRoot, 'node_modules'))
+
+  for (const check of checks) {
+    console.log(`${check.ok ? 'ok' : 'fail'} - ${check.name}${check.detail ? `: ${check.detail}` : ''}`)
+  }
+  if (checks.some((check) => !check.ok)) process.exit(1)
+}
+
+async function writable(path) {
+  try {
+    mkdirSync(path, { recursive: true })
+    await access(path, constants.W_OK)
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function portOccupied(host, port) {
+  const result = await healthCheck(host, port, 300)
+  if (result.ok || result.status) return true
+
+  return new Promise((resolveOccupied) => {
+    const tester = spawn(process.execPath, ['-e', `
+      const net = require('net');
+      const server = net.createServer();
+      server.once('error', () => process.exit(1));
+      server.once('listening', () => server.close(() => process.exit(0)));
+      server.listen(${JSON.stringify(port)}, ${JSON.stringify(host)});
+    `], { stdio: 'ignore' })
+    tester.on('exit', (code) => resolveOccupied(code !== 0))
+  })
+}
+
+function openBrowser(host, port) {
+  const url = `http://${host === '127.0.0.1' ? 'localhost' : host}:${port}`
+  const opener = platform() === 'win32' ? 'cmd' : platform() === 'darwin' ? 'open' : 'xdg-open'
+  const args = platform() === 'win32' ? ['/c', 'start', '', url] : [url]
+  spawn(opener, args, { stdio: 'ignore', detached: true }).unref()
+}
+
+async function main() {
+  const options = parseArgs(process.argv)
+  switch (options.command) {
+    case 'help':
+    case '-h':
+    case '--help':
+      usage()
+      break
+    case 'version':
+    case '-v':
+    case '--version':
+      console.log(packageJson.version)
+      break
+    case 'start':
+      await start(options)
+      break
+    case 'stop':
+      await stop()
+      break
+    case 'restart':
+      await restart(options)
+      break
+    case 'status':
+      await status(options)
+      break
+    case 'logs':
+      await logs(options)
+      break
+    case 'doctor':
+      await doctor(options)
+      break
+    default:
+      throw new Error(`Unknown command: ${options.command}`)
+  }
+}
+
+main().catch((err) => {
+  console.error(`error: ${err?.message || err}`)
+  process.exit(1)
+})

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@bitseek/hermes-webui",
+  "version": "0.1.0-beta.0",
+  "type": "module",
+  "description": "Npm wrapper for Bitseek Hermes WebUI runtime.",
+  "bin": {
+    "hermes-webui": "./bin/hermes-webui.mjs"
+  },
+  "engines": {
+    "node": ">=20 <25"
+  },
+  "files": [
+    "bin/",
+    "scripts/",
+    "templates/",
+    "vendor/agent-frontend-shell/",
+    "README.md"
+  ],
+  "scripts": {
+    "sync:vendor": "node ./scripts/sync-vendor.mjs",
+    "pack:dry-run": "npm pack --dry-run",
+    "check": "node --check ./bin/hermes-webui.mjs && node --check ./scripts/sync-vendor.mjs"
+  },
+  "license": "MIT"
+}

package/scripts/sync-vendor.mjs

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+import { cpSync, existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs'
+import { dirname, resolve } from 'node:path'
+import { execFileSync } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const packageRoot = resolve(__dirname, '..')
+const defaultSource = resolve(packageRoot, '..', 'agent-frontend-shell')
+const sourceRoot = resolve(process.env.AGENT_FRONTEND_SHELL_DIR || defaultSource)
+const vendorRoot = resolve(packageRoot, 'vendor', 'agent-frontend-shell')
+
+const excludedNames = new Set([
+  '.git',
+  '.env',
+  '.venv',
+  'venv',
+  'node_modules',
+  '__pycache__',
+  '.pytest_cache',
+  '.ruff_cache',
+  'tests',
+  'hermes_data',
+])
+
+function runGit(args) {
+  try {
+    return execFileSync('git', args, {
+      cwd: sourceRoot,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    }).trim()
+  } catch {
+    return 'unknown'
+  }
+}
+
+function filter(src) {
+  const name = src.split(/[\\/]/).pop()
+  if (excludedNames.has(name)) return false
+  if (name.endsWith('.pyc')) return false
+  if (name.endsWith('.log')) return false
+  if (name.endsWith('.pid')) return false
+  return true
+}
+
+if (!existsSync(resolve(sourceRoot, 'bootstrap.py')) || !existsSync(resolve(sourceRoot, 'server.py'))) {
+  console.error(`agent-frontend-shell source not found or incomplete: ${sourceRoot}`)
+  process.exit(1)
+}
+
+rmSync(vendorRoot, { recursive: true, force: true })
+mkdirSync(vendorRoot, { recursive: true })
+cpSync(sourceRoot, vendorRoot, {
+  recursive: true,
+  dereference: false,
+  filter,
+})
+
+const sourceInfo = {
+  repo: 'adv-org/agent-frontend-shell',
+  branch: runGit(['branch', '--show-current']),
+  commit: runGit(['rev-parse', 'HEAD']),
+  synced_at: new Date().toISOString(),
+}
+
+writeFileSync(
+  resolve(vendorRoot, '.bitseek-source.json'),
+  `${JSON.stringify(sourceInfo, null, 2)}\n`,
+  { mode: 0o644 },
+)
+
+console.log(`Synced ${sourceRoot} -> ${vendorRoot}`)
+console.log(`${sourceInfo.repo}@${sourceInfo.branch} ${sourceInfo.commit}`)

package/templates/launchd/com.bitseek.hermes-webui.plist

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>com.bitseek.hermes-webui</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>/Users/USER/.hermes/local-bundle/runtime/node/bin/node</string>
+    <string>/Users/USER/.hermes/local-bundle/node-global/bin/hermes-webui</string>
+    <string>start</string>
+    <string>--foreground</string>
+    <string>--port</string>
+    <string>8787</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+</dict>
+</plist>