@yancyyu/openhermit 1.5.9 → 1.5.11

package/bin/alias-loader.mjs

@@ -0,0 +1,51 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+const repoRoot = path.resolve(path.dirname(new URL(import.meta.url).pathname), '..');
+
+const ALIASES = [
+  ['@features/', 'src/features/'],
+  ['@main/', 'src/main/'],
+  ['@renderer/', 'src/renderer/'],
+  ['@shared/', 'src/shared/'],
+];
+
+const EXACT_ALIASES = new Map([
+  ['@shared/types', 'src/shared/types/index.ts'],
+  ['@main/types', 'src/main/types/index.ts'],
+]);
+
+function resolveAlias(specifier) {
+  const exactTarget = EXACT_ALIASES.get(specifier);
+  if (exactTarget) {
+    const absolutePath = path.join(repoRoot, exactTarget);
+    if (existsSync(absolutePath)) return pathToFileURL(absolutePath).href;
+  }
+
+  for (const [prefix, target] of ALIASES) {
+    if (!specifier.startsWith(prefix)) continue;
+    const relativePath = specifier.slice(prefix.length);
+    const basePath = path.join(repoRoot, target, relativePath);
+    const candidates = [
+      basePath,
+      `${basePath}.ts`,
+      `${basePath}.tsx`,
+      `${basePath}.js`,
+      path.join(basePath, 'index.ts'),
+      path.join(basePath, 'index.tsx'),
+      path.join(basePath, 'index.js'),
+    ];
+    const match = candidates.find((candidate) => existsSync(candidate));
+    if (match) return pathToFileURL(match).href;
+  }
+  return null;
+}
+
+export async function resolve(specifier, context, nextResolve) {
+  const aliasUrl = resolveAlias(specifier);
+  if (aliasUrl) {
+    return { url: aliasUrl, shortCircuit: true };
+  }
+  return nextResolve(specifier, context);
+}

package/bin/hermit.mjs

@@ -16,11 +16,11 @@
 
 import { spawn, execSync } from 'node:child_process';
 import crypto from 'node:crypto';
-import { mkdirSync, writeFileSync, readFileSync, existsSync } from 'node:fs';
+import { mkdirSync, writeFileSync, readFileSync, existsSync, openSync, closeSync, unlinkSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import os from 'node:os';
 import path from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const repoRoot = path.resolve(__dirname, '..');
@@ -56,12 +56,18 @@ Usage:
 Options:
   --port <number>    HTTP server port (default: 5680)
   --no-cc-connect    Do not auto-start bundled cc-connect
+  --daemon           Run in the background
   --version          Show current version
   --help             Show this help message
   update             Check and install updates
+  status             Show background service status
+  stop               Stop the background service
 
 Examples:
   openhermit                      # Start on port 5680
+  openhermit --daemon             # Start in background
+  openhermit status               # Show background status
+  openhermit stop                 # Stop background service
   openhermit --port 8080          # Start on port 8080
   openhermit --no-cc-connect      # Start only openHermit
   openhermit --version            # Show version
@@ -81,11 +87,131 @@ const portIndex = args.indexOf('--port');
 const port = portIndex !== -1 && args[portIndex + 1] ? args[portIndex + 1] : '5680';
 const skipCcConnect = args.includes('--no-cc-connect') || process.env.HERMIT_NO_CC_CONNECT === '1';
 const hermitHome = process.env.HERMIT_HOME || path.join(os.homedir(), '.hermit');
+const daemonRequested = args.includes('--daemon');
+const daemonChild = process.env.HERMIT_DAEMON_CHILD === '1';
+const daemonPidPath = path.join(hermitHome, 'openhermit.pid');
+const daemonLogPath = path.join(hermitHome, 'logs', 'openhermit.log');
 const ccConnectConfigPath =
   process.env.HERMIT_CC_CONNECT_CONFIG ||
   process.env.CC_CONNECT_CONFIG ||
   path.join(hermitHome, 'cc-connect', 'config.toml');
 
+function readDaemonPid() {
+  try {
+    const raw = readFileSync(daemonPidPath, 'utf-8').trim();
+    const pid = Number.parseInt(raw, 10);
+    return Number.isFinite(pid) && pid > 0 ? pid : null;
+  } catch {
+    return null;
+  }
+}
+
+function isPidRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function removeDaemonPidFile() {
+  try {
+    unlinkSync(daemonPidPath);
+  } catch {
+    // Already gone.
+  }
+}
+
+function signalDaemon(pid, signal) {
+  try {
+    process.kill(-pid, signal);
+    return true;
+  } catch {
+    // Fall back to direct process signal.
+  }
+  try {
+    process.kill(pid, signal);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function printDaemonStatus() {
+  const pid = readDaemonPid();
+  if (pid && isPidRunning(pid)) {
+    console.log(`[openHermit] Running in background (pid ${pid})`);
+    console.log(`[openHermit] Log: ${daemonLogPath}`);
+    process.exit(0);
+  }
+  if (pid) removeDaemonPidFile();
+  console.log('[openHermit] Not running');
+  process.exit(1);
+}
+
+async function stopDaemon() {
+  const pid = readDaemonPid();
+  if (!pid || !isPidRunning(pid)) {
+    if (pid) removeDaemonPidFile();
+    console.log('[openHermit] Not running');
+    process.exit(0);
+  }
+  console.log(`[openHermit] Stopping background service (pid ${pid})...`);
+  signalDaemon(pid, 'SIGTERM');
+  await new Promise((resolve) => setTimeout(resolve, 2_000));
+  if (isPidRunning(pid)) {
+    signalDaemon(pid, 'SIGKILL');
+  }
+  removeDaemonPidFile();
+  console.log('[openHermit] Stopped');
+  process.exit(0);
+}
+
+function startDaemon() {
+  const existingPid = readDaemonPid();
+  if (existingPid && isPidRunning(existingPid)) {
+    console.log(`[openHermit] Already running in background (pid ${existingPid})`);
+    console.log(`[openHermit] Log: ${daemonLogPath}`);
+    process.exit(0);
+  }
+
+  mkdirSync(path.dirname(daemonPidPath), { recursive: true });
+  mkdirSync(path.dirname(daemonLogPath), { recursive: true });
+  const out = openSync(daemonLogPath, 'a');
+  const err = openSync(daemonLogPath, 'a');
+  const childArgs = process.argv.slice(2).filter((arg) => arg !== '--daemon');
+  const child = spawn(process.execPath, [fileURLToPath(import.meta.url), ...childArgs], {
+    cwd: repoRoot,
+    detached: true,
+    env: {
+      ...process.env,
+      HERMIT_DAEMON_CHILD: '1',
+    },
+    stdio: ['ignore', out, err],
+  });
+  child.unref();
+  closeSync(out);
+  closeSync(err);
+  writeFileSync(daemonPidPath, String(child.pid), 'utf-8');
+  console.log(`[openHermit] Started in background (pid ${child.pid})`);
+  console.log(`[openHermit] URL: http://127.0.0.1:${port}`);
+  console.log(`[openHermit] Log: ${daemonLogPath}`);
+  process.exit(0);
+}
+
+if (args.includes('status')) {
+  printDaemonStatus();
+}
+
+if (args.includes('stop')) {
+  await stopDaemon();
+}
+
+if (daemonRequested && !daemonChild) {
+  startDaemon();
+}
+
 // ---------------------------------------------------------------------------
 // Update command
 // ---------------------------------------------------------------------------
@@ -252,8 +378,42 @@ function resolveCcConnectRunner() {
   return path.join(path.dirname(pkgPath), 'run.js');
 }
 
-function resolveTsxCli() {
-  return require.resolve('tsx/cli');
+function resolveTsxLoader() {
+  return require.resolve('tsx');
+}
+
+function resolveAliasLoaderRegister() {
+  const aliasLoaderUrl = pathToFileURL(path.join(__dirname, 'alias-loader.mjs')).href;
+  return `data:text/javascript,import { register } from "node:module"; import { pathToFileURL } from "node:url"; register(${JSON.stringify(aliasLoaderUrl)}, pathToFileURL("./"));`;
+}
+
+function terminateProcessGroup(child, signal = 'SIGTERM') {
+  if (!child?.pid) return;
+  try {
+    process.kill(-child.pid, signal);
+    return;
+  } catch {
+    // Fall back to the direct child if it was not started as a process group.
+  }
+  try {
+    child.kill(signal);
+  } catch {
+    // Already gone.
+  }
+}
+
+let shuttingDown = false;
+function shutdown(exitCode = 0) {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  console.log('\n[openHermit] Shutting down...');
+  terminateProcessGroup(serverProcess, 'SIGTERM');
+  terminateProcessGroup(ccConnectProcess, 'SIGTERM');
+  setTimeout(() => {
+    terminateProcessGroup(serverProcess, 'SIGKILL');
+    terminateProcessGroup(ccConnectProcess, 'SIGKILL');
+    process.exit(exitCode);
+  }, 2_000).unref();
 }
 
 let ccConnectProcess = null;
@@ -273,6 +433,7 @@ if (!skipCcConnect) {
     console.log(`[openHermit] cc-connect config: ${ccConnectConfigPath}`);
     ccConnectProcess = spawn(process.execPath, [resolveCcConnectRunner(), '-config', ccConnectConfigPath], {
       cwd: repoRoot,
+      detached: true,
       env: {
         ...process.env,
         CC_CONNECT_TOKEN: ccTokens.managementToken,
@@ -325,39 +486,42 @@ if (!existsSync(distRenderererDir) || !existsSync(path.join(distRenderererDir, '
 // Start the server
 console.log('[openHermit] Launching server...\n');
 
-const serverProcess = spawn(process.execPath, [resolveTsxCli(), 'src/main/server.ts'], {
-  cwd: repoRoot,
-  env: {
-    ...process.env,
-    PORT: port,
-    HOST: process.env.HOST || '127.0.0.1',
-    NODE_ENV: 'production',
-    HERMIT_HOME: hermitHome,
-    CC_CONNECT_TOKEN: ccTokens.managementToken,
-    CC_CONNECT_MANAGEMENT_TOKEN: ccTokens.managementToken,
-    CC_CONNECT_BRIDGE_TOKEN: ccTokens.bridgeToken,
-    CC_CONNECT_CONFIG: ccConnectConfigPath,
-  },
-  stdio: 'inherit',
-});
+const serverProcess = spawn(
+  process.execPath,
+  ['--import', resolveAliasLoaderRegister(), '--import', resolveTsxLoader(), 'src/main/server.ts'],
+  {
+    cwd: repoRoot,
+    detached: true,
+    env: {
+      ...process.env,
+      PORT: port,
+      HOST: process.env.HOST || '127.0.0.1',
+      NODE_ENV: 'production',
+      HERMIT_HOME: hermitHome,
+      CC_CONNECT_TOKEN: ccTokens.managementToken,
+      CC_CONNECT_MANAGEMENT_TOKEN: ccTokens.managementToken,
+      CC_CONNECT_BRIDGE_TOKEN: ccTokens.bridgeToken,
+      CC_CONNECT_CONFIG: ccConnectConfigPath,
+    },
+    stdio: 'inherit',
+  }
+);
 
 serverProcess.on('exit', (code) => {
+  if (shuttingDown) return;
+  terminateProcessGroup(ccConnectProcess, 'SIGTERM');
   if (code !== 0) {
     console.error(`[openHermit] Server exited with code ${code}`);
     process.exit(code ?? 1);
   }
+  process.exit(0);
 });
 
-process.on('SIGINT', () => {
-  console.log('\n[openHermit] Shutting down...');
-  serverProcess.kill('SIGINT');
-  ccConnectProcess?.kill('SIGINT');
-});
-
-process.on('SIGTERM', () => {
-  console.log('\n[openHermit] Shutting down...');
-  serverProcess.kill('SIGTERM');
-  ccConnectProcess?.kill('SIGTERM');
+process.on('SIGINT', () => shutdown(0));
+process.on('SIGTERM', () => shutdown(0));
+process.on('exit', () => {
+  terminateProcessGroup(serverProcess, 'SIGTERM');
+  terminateProcessGroup(ccConnectProcess, 'SIGTERM');
 });
 
 console.log(`[openHermit] Server starting on http://127.0.0.1:${port}`);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@yancyyu/openhermit",
   "type": "module",
-  "version": "1.5.9",
+  "version": "1.5.11",
   "description": "openHermit: team-oriented agent management workbench atop cc-connect.",
   "license": "AGPL-3.0",
   "author": {

package/src/main/server.ts

@@ -299,7 +299,10 @@ function resolveTeamFromSessionKey(sessionKey: string): string | null {
   return sessionKey;
 }
 
-const app = Fastify({ logger: { level: 'info' } });
+const app = Fastify({
+  logger: { level: process.env.HERMIT_LOG_LEVEL ?? 'warn' },
+  disableRequestLogging: true,
+});
 
 // ===========================================================================
 // Plugins
@@ -3839,14 +3842,17 @@ app.get('/api/events', (request, reply) => {
 
 const SSE_FALLBACK_RE = /^\/api\/(.*\/(events|stream|notifications\/stream))$/;
 
+app.get('/api/extensions/mcp/browse', async () => ({
+  servers: [],
+  items: [],
+}));
+
 app.setNotFoundHandler((request, reply) => {
   const u = request.url;
   if (!u.startsWith('/api/')) {
     return reply.code(404).type('text/plain').send('not found');
   }
 
-  request.log.info({ method: request.method, url: u }, '[stub]');
-
   if (request.method === 'GET' && SSE_FALLBACK_RE.test(u)) {
     reply.raw.writeHead(200, {
       'Content-Type': 'text/event-stream; charset=utf-8',