@yeaft/webchat-agent 0.1.1104 → 0.1.1107

package/service/linux.js

@@ -1,31 +1,34 @@
-/**
+/*
  * Service — Linux (systemd) platform implementation
  */
 import { execSync } from 'child_process';
 import { existsSync, writeFileSync, unlinkSync, mkdirSync } from 'fs';
 import { join, dirname } from 'path';
 import { homedir } from 'os';
-import { SERVICE_NAME, getLogDir, getNodePath, getCliPath } from './config.js';
+import { getServiceName, getLogDir, getNodePath, getCliPath, DEFAULT_INSTANCE_ID } from './config.js';
 
 /** Pure path getter — no side effects (no directory creation). */
-export function getSystemdServicePath() {
-  return join(homedir(), '.config', 'systemd', 'user', `${SERVICE_NAME}.service`);
+export function getSystemdServicePath(instanceId = DEFAULT_INSTANCE_ID) {
+  return join(homedir(), '.config', 'systemd', 'user', `${getServiceName(instanceId)}.service`);
 }
 
 function generateSystemdUnit(config) {
   const nodePath = getNodePath();
   const cliPath = getCliPath();
+  const logDir = getLogDir(config.instanceId);
   const envLines = [];
+  if (config.instanceId) envLines.push(`Environment=YEAFT_AGENT_INSTANCE=${config.instanceId}`);
   if (config.serverUrl) envLines.push(`Environment=SERVER_URL=${config.serverUrl}`);
   if (config.agentName) envLines.push(`Environment=AGENT_NAME=${config.agentName}`);
   if (config.agentSecret) envLines.push(`Environment=AGENT_SECRET=${config.agentSecret}`);
   if (config.workDir) envLines.push(`Environment=WORK_DIR=${config.workDir}`);
+  if (config.yeaftDir) envLines.push(`Environment=YEAFT_DIR=${config.yeaftDir}`);
 
   // Include node's bin dir in PATH for claude CLI access
   const nodeBinDir = dirname(nodePath);
 
   return `[Unit]
-Description=Yeaft WebChat Agent
+Description=Yeaft WebChat Agent (${config.instanceId || DEFAULT_INSTANCE_ID})
 After=network-online.target
 Wants=network-online.target
 
@@ -39,8 +42,8 @@ KillMode=process
 ${envLines.join('\n')}
 Environment=PATH=${nodeBinDir}:${homedir()}/.local/bin:${homedir()}/.npm-global/bin:/usr/local/bin:/usr/bin:/bin
 
-StandardOutput=append:${getLogDir()}/out.log
-StandardError=append:${getLogDir()}/error.log
+StandardOutput=append:${logDir}/out.log
+StandardError=append:${logDir}/error.log
 
 [Install]
 WantedBy=default.target
@@ -48,61 +51,68 @@ WantedBy=default.target
 }
 
 export function linuxInstall(config) {
-  const servicePath = getSystemdServicePath();
+  const serviceName = getServiceName(config.instanceId);
+  const servicePath = getSystemdServicePath(config.instanceId);
   // Ensure systemd user directory exists before writing
   mkdirSync(join(homedir(), '.config', 'systemd', 'user'), { recursive: true });
+  mkdirSync(getLogDir(config.instanceId), { recursive: true });
   writeFileSync(servicePath, generateSystemdUnit(config));
   execSync('systemctl --user daemon-reload');
-  execSync(`systemctl --user enable ${SERVICE_NAME}`);
-  execSync(`systemctl --user start ${SERVICE_NAME}`);
-  console.log(`Service installed and started.`);
+  execSync(`systemctl --user enable ${serviceName}`);
+  execSync(`systemctl --user start ${serviceName}`);
+  console.log(`Service installed and started: ${serviceName}`);
   console.log(`\nManage with:`);
-  console.log(`  yeaft-agent status`);
-  console.log(`  yeaft-agent logs`);
-  console.log(`  yeaft-agent restart`);
-  console.log(`  yeaft-agent uninstall`);
+  console.log(`  yeaft-agent status --instance ${config.instanceId}`);
+  console.log(`  yeaft-agent logs --instance ${config.instanceId}`);
+  console.log(`  yeaft-agent restart --instance ${config.instanceId}`);
+  console.log(`  yeaft-agent uninstall --instance ${config.instanceId}`);
   console.log(`\nTo run when not logged in:`);
   console.log(`  sudo loginctl enable-linger $(whoami)`);
 }
 
-export function linuxUninstall() {
-  try { execSync(`systemctl --user stop ${SERVICE_NAME} 2>/dev/null`); } catch {}
-  try { execSync(`systemctl --user disable ${SERVICE_NAME} 2>/dev/null`); } catch {}
-  const servicePath = getSystemdServicePath();
+export function linuxUninstall(instanceId = DEFAULT_INSTANCE_ID) {
+  const serviceName = getServiceName(instanceId);
+  try { execSync(`systemctl --user stop ${serviceName} 2>/dev/null`); } catch {}
+  try { execSync(`systemctl --user disable ${serviceName} 2>/dev/null`); } catch {}
+  const servicePath = getSystemdServicePath(instanceId);
   if (existsSync(servicePath)) unlinkSync(servicePath);
   try { execSync('systemctl --user daemon-reload'); } catch {}
-  console.log('Service uninstalled.');
+  console.log(`Service uninstalled: ${serviceName}`);
 }
 
-export function linuxStart() {
-  execSync(`systemctl --user start ${SERVICE_NAME}`, { stdio: 'inherit' });
-  console.log('Service started.');
+export function linuxStart(instanceId = DEFAULT_INSTANCE_ID) {
+  const serviceName = getServiceName(instanceId);
+  execSync(`systemctl --user start ${serviceName}`, { stdio: 'inherit' });
+  console.log(`Service started: ${serviceName}`);
 }
 
-export function linuxStop() {
-  execSync(`systemctl --user stop ${SERVICE_NAME}`, { stdio: 'inherit' });
-  console.log('Service stopped.');
+export function linuxStop(instanceId = DEFAULT_INSTANCE_ID) {
+  const serviceName = getServiceName(instanceId);
+  execSync(`systemctl --user stop ${serviceName}`, { stdio: 'inherit' });
+  console.log(`Service stopped: ${serviceName}`);
 }
 
-export function linuxRestart() {
-  execSync(`systemctl --user restart ${SERVICE_NAME}`, { stdio: 'inherit' });
-  console.log('Service restarted.');
+export function linuxRestart(instanceId = DEFAULT_INSTANCE_ID) {
+  const serviceName = getServiceName(instanceId);
+  execSync(`systemctl --user restart ${serviceName}`, { stdio: 'inherit' });
+  console.log(`Service restarted: ${serviceName}`);
 }
 
 /**
  * Query systemd for the current service status.
  * Returns { running: boolean, pid: string|null }.
  */
-export function getLinuxServiceStatus() {
+export function getLinuxServiceStatus(instanceId = DEFAULT_INSTANCE_ID) {
+  const serviceName = getServiceName(instanceId);
   try {
-    const output = execSync(`systemctl --user is-active ${SERVICE_NAME}`, {
+    const output = execSync(`systemctl --user is-active ${serviceName}`, {
       encoding: 'utf-8',
       stdio: ['pipe', 'pipe', 'pipe'],
     }).trim();
     if (output === 'active') {
       let pid = null;
       try {
-        pid = execSync(`systemctl --user show ${SERVICE_NAME} --property=MainPID --value`, {
+        pid = execSync(`systemctl --user show ${serviceName} --property=MainPID --value`, {
           encoding: 'utf-8',
           stdio: ['pipe', 'pipe', 'pipe'],
         }).trim();
@@ -116,20 +126,21 @@ export function getLinuxServiceStatus() {
   }
 }
 
-export function linuxStatus() {
+export function linuxStatus(instanceId = DEFAULT_INSTANCE_ID) {
   try {
-    execSync(`systemctl --user status ${SERVICE_NAME}`, { stdio: 'inherit' });
+    execSync(`systemctl --user status ${getServiceName(instanceId)}`, { stdio: 'inherit' });
   } catch {
     // systemctl status returns non-zero when service is stopped
   }
 }
 
-export function linuxLogs() {
+export function linuxLogs(instanceId = DEFAULT_INSTANCE_ID) {
+  const serviceName = getServiceName(instanceId);
   try {
-    execSync(`journalctl --user -u ${SERVICE_NAME} -f --no-pager -n 100`, { stdio: 'inherit' });
+    execSync(`journalctl --user -u ${serviceName} -f --no-pager -n 100`, { stdio: 'inherit' });
   } catch {
     // Fallback to log files
-    const logFile = join(getLogDir(), 'out.log');
+    const logFile = join(getLogDir(instanceId), 'out.log');
     if (existsSync(logFile)) {
       execSync(`tail -f -n 100 ${logFile}`, { stdio: 'inherit' });
     } else {

package/service/macos.js

@@ -1,34 +1,37 @@
-/**
+/*
  * Service — macOS (launchd) platform implementation
  */
 import { execSync } from 'child_process';
 import { existsSync, writeFileSync, unlinkSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
-import { getLogDir, getNodePath, getCliPath } from './config.js';
+import { getLaunchdLabel, getLogDir, getNodePath, getCliPath, DEFAULT_INSTANCE_ID } from './config.js';
 
 /** Pure path getter — no side effects (no directory creation). */
-export function getLaunchdPlistPath() {
-  return join(homedir(), 'Library', 'LaunchAgents', 'com.yeaft.agent.plist');
+export function getLaunchdPlistPath(instanceId = DEFAULT_INSTANCE_ID) {
+  return join(homedir(), 'Library', 'LaunchAgents', `${getLaunchdLabel(instanceId)}.plist`);
 }
 
 function generateLaunchdPlist(config) {
   const nodePath = getNodePath();
   const cliPath = getCliPath();
-  const logDir = getLogDir();
+  const logDir = getLogDir(config.instanceId);
+  const label = getLaunchdLabel(config.instanceId);
 
   const envDict = [];
+  if (config.instanceId) envDict.push(`      <key>YEAFT_AGENT_INSTANCE</key>\n      <string>${config.instanceId}</string>`);
   if (config.serverUrl) envDict.push(`      <key>SERVER_URL</key>\n      <string>${config.serverUrl}</string>`);
   if (config.agentName) envDict.push(`      <key>AGENT_NAME</key>\n      <string>${config.agentName}</string>`);
   if (config.agentSecret) envDict.push(`      <key>AGENT_SECRET</key>\n      <string>${config.agentSecret}</string>`);
   if (config.workDir) envDict.push(`      <key>WORK_DIR</key>\n      <string>${config.workDir}</string>`);
+  if (config.yeaftDir) envDict.push(`      <key>YEAFT_DIR</key>\n      <string>${config.yeaftDir}</string>`);
 
   return `<?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.yeaft.agent</string>
+    <string>${label}</string>
     <key>ProgramArguments</key>
     <array>
         <string>${nodePath}</string>
@@ -59,62 +62,64 @@ ${envDict.join('\n')}
 }
 
 export function macInstall(config) {
-  const plistPath = getLaunchdPlistPath();
+  const plistPath = getLaunchdPlistPath(config.instanceId);
   // Ensure LaunchAgents directory exists before writing
   mkdirSync(join(homedir(), 'Library', 'LaunchAgents'), { recursive: true });
+  mkdirSync(getLogDir(config.instanceId), { recursive: true });
   // Unload first if exists
   if (existsSync(plistPath)) {
     try { execSync(`launchctl unload ${plistPath} 2>/dev/null`); } catch {}
   }
   writeFileSync(plistPath, generateLaunchdPlist(config));
   execSync(`launchctl load ${plistPath}`);
-  console.log('Service installed and started.');
+  console.log(`Service installed and started: ${getLaunchdLabel(config.instanceId)}`);
   console.log(`\nManage with:`);
-  console.log(`  yeaft-agent status`);
-  console.log(`  yeaft-agent logs`);
-  console.log(`  yeaft-agent restart`);
-  console.log(`  yeaft-agent uninstall`);
+  console.log(`  yeaft-agent status --instance ${config.instanceId}`);
+  console.log(`  yeaft-agent logs --instance ${config.instanceId}`);
+  console.log(`  yeaft-agent restart --instance ${config.instanceId}`);
+  console.log(`  yeaft-agent uninstall --instance ${config.instanceId}`);
 }
 
-export function macUninstall() {
-  const plistPath = getLaunchdPlistPath();
+export function macUninstall(instanceId = DEFAULT_INSTANCE_ID) {
+  const plistPath = getLaunchdPlistPath(instanceId);
   if (existsSync(plistPath)) {
     try { execSync(`launchctl unload ${plistPath}`); } catch {}
     unlinkSync(plistPath);
   }
-  console.log('Service uninstalled.');
+  console.log(`Service uninstalled: ${getLaunchdLabel(instanceId)}`);
 }
 
-export function macStart() {
-  const plistPath = getLaunchdPlistPath();
+export function macStart(instanceId = DEFAULT_INSTANCE_ID) {
+  const plistPath = getLaunchdPlistPath(instanceId);
   if (!existsSync(plistPath)) {
     console.error('Service not installed. Run "yeaft-agent install" first.');
     process.exit(1);
   }
   execSync(`launchctl load ${plistPath}`);
-  console.log('Service started.');
+  console.log(`Service started: ${getLaunchdLabel(instanceId)}`);
 }
 
-export function macStop() {
-  const plistPath = getLaunchdPlistPath();
+export function macStop(instanceId = DEFAULT_INSTANCE_ID) {
+  const plistPath = getLaunchdPlistPath(instanceId);
   if (existsSync(plistPath)) {
     execSync(`launchctl unload ${plistPath}`);
   }
-  console.log('Service stopped.');
+  console.log(`Service stopped: ${getLaunchdLabel(instanceId)}`);
 }
 
-export function macRestart() {
-  macStop();
-  macStart();
+export function macRestart(instanceId = DEFAULT_INSTANCE_ID) {
+  macStop(instanceId);
+  macStart(instanceId);
 }
 
 /**
  * Query launchd for the current service status.
  * Returns { running: boolean, pid: string|null, exitCode: string|null }.
  */
-export function getMacServiceStatus() {
+export function getMacServiceStatus(instanceId = DEFAULT_INSTANCE_ID) {
+  const label = getLaunchdLabel(instanceId);
   try {
-    const output = execSync('launchctl list | grep com.yeaft.agent', {
+    const output = execSync(`launchctl list | grep ${label}`, {
       encoding: 'utf-8',
       stdio: ['pipe', 'pipe', 'pipe'],
     });
@@ -133,8 +138,8 @@ export function getMacServiceStatus() {
   }
 }
 
-export function macStatus() {
-  const status = getMacServiceStatus();
+export function macStatus(instanceId = DEFAULT_INSTANCE_ID) {
+  const status = getMacServiceStatus(instanceId);
   if (status.running) {
     console.log(`Service is running (PID: ${status.pid})`);
   } else if (status.exitCode !== null) {
@@ -144,8 +149,8 @@ export function macStatus() {
   }
 }
 
-export function macLogs() {
-  const logFile = join(getLogDir(), 'out.log');
+export function macLogs(instanceId = DEFAULT_INSTANCE_ID) {
+  const logFile = join(getLogDir(instanceId), 'out.log');
   if (existsSync(logFile)) {
     execSync(`tail -f -n 100 ${logFile}`, { stdio: 'inherit' });
   } else {

package/service/windows.js

@@ -1,17 +1,16 @@
-/**
+/*
  * Service — Windows (pm2) platform implementation
  */
 import { execSync, spawn } from 'child_process';
 import { existsSync, mkdirSync, writeFileSync, readFileSync, unlinkSync } from 'fs';
 import { join, dirname } from 'path';
-import { SERVICE_NAME, getConfigDir, getLogDir, getNodePath, getCliPath } from './config.js';
+import { getConfigDir, getLogDir, getNodePath, getCliPath, getPm2AppName, DEFAULT_INSTANCE_ID } from './config.js';
 
 const WIN_TASK_NAME = 'YeaftAgent';
-const PM2_APP_NAME = 'yeaft-agent';
 
 // Legacy paths for cleanup
-function getWinWrapperPath() { return join(getConfigDir(), 'run.vbs'); }
-function getWinBatPath() { return join(getConfigDir(), 'run.bat'); }
+function getWinWrapperPath(instanceId = DEFAULT_INSTANCE_ID) { return join(getConfigDir(instanceId), 'run.vbs'); }
+function getWinBatPath(instanceId = DEFAULT_INSTANCE_ID) { return join(getConfigDir(instanceId), 'run.bat'); }
 
 function ensurePm2() {
   try {
@@ -22,25 +21,28 @@ function ensurePm2() {
   }
 }
 
-export function getEcosystemPath() {
-  return join(getConfigDir(), 'ecosystem.config.cjs');
+export function getEcosystemPath(instanceId = DEFAULT_INSTANCE_ID) {
+  return join(getConfigDir(instanceId), 'ecosystem.config.cjs');
 }
 
 function generateEcosystem(config) {
   const nodePath = getNodePath();
   const cliPath = getCliPath();
   const cliDir = dirname(cliPath);
-  const logDir = getLogDir();
+  const logDir = getLogDir(config.instanceId);
+  const pm2AppName = getPm2AppName(config.instanceId);
 
   const env = {};
+  if (config.instanceId) env.YEAFT_AGENT_INSTANCE = config.instanceId;
   if (config.serverUrl) env.SERVER_URL = config.serverUrl;
   if (config.agentName) env.AGENT_NAME = config.agentName;
   if (config.agentSecret) env.AGENT_SECRET = config.agentSecret;
   if (config.workDir) env.WORK_DIR = config.workDir;
+  if (config.yeaftDir) env.YEAFT_DIR = config.yeaftDir;
 
   return `module.exports = {
   apps: [{
-    name: '${PM2_APP_NAME}',
+    name: '${pm2AppName}',
     script: '${cliPath.replace(/\\/g, '\\\\')}',
     interpreter: '${nodePath.replace(/\\/g, '\\\\')}',
     cwd: '${cliDir.replace(/\\/g, '\\\\')}',
@@ -61,15 +63,16 @@ function generateEcosystem(config) {
 
 export function winInstall(config) {
   ensurePm2();
-  const logDir = getLogDir();
+  const logDir = getLogDir(config.instanceId);
+  const pm2AppName = getPm2AppName(config.instanceId);
   mkdirSync(logDir, { recursive: true });
 
   // Generate ecosystem config
-  const ecoPath = getEcosystemPath();
+  const ecoPath = getEcosystemPath(config.instanceId);
   writeFileSync(ecoPath, generateEcosystem(config));
 
   // Stop existing instance if any
-  try { execSync(`pm2 delete ${PM2_APP_NAME}`, { stdio: 'pipe' }); } catch {}
+  try { execSync(`pm2 delete ${pm2AppName}`, { stdio: 'pipe' }); } catch {}
 
   // Start with pm2
   execSync(`pm2 start "${ecoPath}"`, { stdio: 'inherit' });
@@ -81,7 +84,7 @@ export function winInstall(config) {
   // pm2-startup doesn't work well on Windows, use Startup folder approach
   const trayScript = join(dirname(getCliPath()), 'scripts', 'agent-tray.ps1');
   const startupDir = join(process.env.APPDATA, 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'Startup');
-  const startupBat = join(startupDir, `${PM2_APP_NAME}.bat`);
+  const startupBat = join(startupDir, `${pm2AppName}.bat`);
   // Resurrect pm2 processes + launch tray icon
   let batContent = `@echo off\r\npm2 resurrect\r\n`;
   if (existsSync(trayScript)) {
@@ -96,41 +99,43 @@ export function winInstall(config) {
     }).unref();
   }
 
-  console.log(`\nService installed and started.`);
+  console.log(`\nService installed and started: ${pm2AppName}`);
   console.log(`  Ecosystem: ${ecoPath}`);
   console.log(`  Startup:   ${startupBat}`);
   console.log(`\nManage with:`);
-  console.log(`  yeaft-agent status`);
-  console.log(`  yeaft-agent logs`);
-  console.log(`  yeaft-agent restart`);
-  console.log(`  yeaft-agent uninstall`);
+  console.log(`  yeaft-agent status --instance ${config.instanceId}`);
+  console.log(`  yeaft-agent logs --instance ${config.instanceId}`);
+  console.log(`  yeaft-agent restart --instance ${config.instanceId}`);
+  console.log(`  yeaft-agent uninstall --instance ${config.instanceId}`);
 }
 
-export function winUninstall() {
-  try { execSync(`pm2 delete ${PM2_APP_NAME}`, { stdio: 'pipe' }); } catch {}
+export function winUninstall(instanceId = DEFAULT_INSTANCE_ID) {
+  const pm2AppName = getPm2AppName(instanceId);
+  try { execSync(`pm2 delete ${pm2AppName}`, { stdio: 'pipe' }); } catch {}
   try { execSync('pm2 save', { stdio: 'pipe' }); } catch {}
   // Clean up ecosystem config
-  const ecoPath = getEcosystemPath();
+  const ecoPath = getEcosystemPath(instanceId);
   if (existsSync(ecoPath)) unlinkSync(ecoPath);
   // Clean up Startup bat
-  const startupBat = join(process.env.APPDATA, 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'Startup', `${PM2_APP_NAME}.bat`);
+  const startupBat = join(process.env.APPDATA, 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'Startup', `${pm2AppName}.bat`);
   if (existsSync(startupBat)) unlinkSync(startupBat);
   // Clean up legacy files
-  const vbsPath = getWinWrapperPath();
-  const batPath = getWinBatPath();
+  const vbsPath = getWinWrapperPath(instanceId);
+  const batPath = getWinBatPath(instanceId);
   if (existsSync(vbsPath)) unlinkSync(vbsPath);
   if (existsSync(batPath)) unlinkSync(batPath);
   const startupVbs = join(process.env.APPDATA, 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'Startup', `${WIN_TASK_NAME}.vbs`);
   if (existsSync(startupVbs)) unlinkSync(startupVbs);
-  console.log('Service uninstalled.');
+  console.log(`Service uninstalled: ${pm2AppName}`);
 }
 
-export function winStart() {
+export function winStart(instanceId = DEFAULT_INSTANCE_ID) {
+  const pm2AppName = getPm2AppName(instanceId);
   try {
-    execSync(`pm2 start ${PM2_APP_NAME}`, { stdio: 'inherit' });
+    execSync(`pm2 start ${pm2AppName}`, { stdio: 'inherit' });
   } catch {
     // Try ecosystem file
-    const ecoPath = getEcosystemPath();
+    const ecoPath = getEcosystemPath(instanceId);
     if (existsSync(ecoPath)) {
       execSync(`pm2 start "${ecoPath}"`, { stdio: 'inherit' });
     } else {
@@ -140,17 +145,17 @@ export function winStart() {
   }
 }
 
-export function winStop() {
+export function winStop(instanceId = DEFAULT_INSTANCE_ID) {
   try {
-    execSync(`pm2 stop ${PM2_APP_NAME}`, { stdio: 'inherit' });
+    execSync(`pm2 stop ${getPm2AppName(instanceId)}`, { stdio: 'inherit' });
   } catch {
     console.error('Service not running or not installed.');
   }
 }
 
-export function winRestart() {
+export function winRestart(instanceId = DEFAULT_INSTANCE_ID) {
   try {
-    execSync(`pm2 restart ${PM2_APP_NAME}`, { stdio: 'inherit' });
+    execSync(`pm2 restart ${getPm2AppName(instanceId)}`, { stdio: 'inherit' });
   } catch {
     console.error('Service not running. Use "yeaft-agent start" to start.');
   }
@@ -160,14 +165,15 @@ export function winRestart() {
  * Query pm2 for the current service status.
  * Returns { running: boolean, pid: string|null }.
  */
-export function getWinServiceStatus() {
+export function getWinServiceStatus(instanceId = DEFAULT_INSTANCE_ID) {
+  const pm2AppName = getPm2AppName(instanceId);
   try {
     const output = execSync('pm2 jlist', {
       encoding: 'utf-8',
       stdio: ['pipe', 'pipe', 'pipe'],
     });
     const apps = JSON.parse(output);
-    const app = Array.isArray(apps) && apps.find(a => a.name === 'yeaft-agent');
+    const app = Array.isArray(apps) && apps.find(a => a.name === pm2AppName);
     if (app) {
       const running = app.pm2_env && app.pm2_env.status === 'online';
       const pid = running ? app.pid : null;
@@ -179,22 +185,23 @@ export function getWinServiceStatus() {
   }
 }
 
-export function winStatus() {
+export function winStatus(instanceId = DEFAULT_INSTANCE_ID) {
   try {
-    execSync(`pm2 describe ${PM2_APP_NAME}`, { stdio: 'inherit' });
+    execSync(`pm2 describe ${getPm2AppName(instanceId)}`, { stdio: 'inherit' });
   } catch {
     console.log('Service is not installed.');
   }
 }
 
-export function winLogs() {
-  const child = spawn('pm2', ['logs', PM2_APP_NAME, '--lines', '100'], {
+export function winLogs(instanceId = DEFAULT_INSTANCE_ID) {
+  const pm2AppName = getPm2AppName(instanceId);
+  const child = spawn('pm2', ['logs', pm2AppName, '--lines', '100'], {
     stdio: 'inherit',
     shell: true
   });
   child.on('error', () => {
     // Fallback to reading log file directly
-    const logFile = join(getLogDir(), 'out.log');
+    const logFile = join(getLogDir(instanceId), 'out.log');
     if (existsSync(logFile)) {
       console.log(readFileSync(logFile, 'utf-8'));
     } else {

package/service.js

@@ -16,6 +16,16 @@ export {
   saveServiceConfig,
   loadServiceConfig,
   parseServiceArgs,
+  SERVICE_NAME,
+  DEFAULT_INSTANCE_ID,
+  normalizeInstanceId,
+  isDefaultInstance,
+  validateInstanceId,
+  getInstanceIdFromArgs,
+  getServiceName,
+  getPm2AppName,
+  getLaunchdLabel,
+  getDefaultYeaftDir,
   install,
   uninstall,
   start,

package/terminal.js

@@ -3,6 +3,8 @@ import { existsSync, chmodSync, statSync } from 'fs';
 import { join, dirname } from 'path';
 import { createRequire } from 'module';
 import ctx from './context.js';
+import { getRuntimePlatformInfo } from './yeaft/runtime-platform.js';
+import { wrapInvocationInSystemdUserScope } from './yeaft/systemd-scope.js';
 
 // Package name of the PTY backend. We use the Homebridge prebuilt fork
 // because upstream node-pty ships no Linux prebuilds and falls back to
@@ -91,12 +93,22 @@ export async function handleTerminalCreate(msg) {
           ? `${process.env.SystemRoot || 'C:\\Windows'}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`
           : (process.env.COMSPEC || 'cmd.exe')))
       : (process.env.SHELL || 'bash');
-    const ptyProcess = pty.spawn(shell, [], {
+    const terminalEnv = { ...process.env };
+    const terminalInvocation = wrapInvocationInSystemdUserScope(
+      { command: shell, args: [], family: platform() === 'win32' ? 'powershell' : 'posix' },
+      {
+        runtimePlatform: getRuntimePlatformInfo(),
+        env: terminalEnv,
+        scopeId: `terminal-${terminalId}`,
+        scopePrefix: 'yeaft-terminal',
+      },
+    );
+    const ptyProcess = pty.spawn(terminalInvocation.command, terminalInvocation.args || [], {
       name: 'xterm-256color',
       cols: cols || 80,
       rows: rows || 24,
       cwd: workDir,
-      env: process.env
+      env: terminalEnv
     });
 
     // 输出缓冲 - 每 16ms 批量发送

package/yeaft/cli.js

@@ -7,7 +7,7 @@
  *
  * Features:
  *   --dry-run "prompt"   — Assemble system prompt + messages, don't call LLM
- *   --trace stats|recent|search <keyword>|tools|compact  — Query/maintain debug.db
+ *   --trace stats|recent|search <keyword>|tools|compact  — Query/maintain debug trace files
  *   -i / --interactive   — REPL mode with / commands
  *   <prompt>             — One-shot query (Phase 1: engine.query)
  *   --skip-mcp           — Skip MCP server connections (faster startup)
@@ -117,12 +117,12 @@ function parseArgs(argv) {
 // ─── Trace query handler ───────────────────────────────────────
 
 function handleTraceQuery(args, config) {
-  const dbPath = join(config.dir, 'debug.db');
+  const traceDir = config.dir;
   let trace;
   try {
-    trace = new DebugTrace(dbPath);
+    trace = new DebugTrace(traceDir);
   } catch (e) {
-    throw new Error(`Cannot open debug database at ${dbPath}: ${e.message}`);
+    throw new Error(`Cannot open debug trace store at ${traceDir}: ${e.message}`);
   }
 
   try {
@@ -133,7 +133,7 @@ function handleTraceQuery(args, config) {
         console.log(`  Turns:    ${s.turnCount}`);
         console.log(`  Tools:    ${s.toolCount}`);
         console.log(`  Events:   ${s.eventCount}`);
-        console.log(`  DB Size:  ${(s.dbSizeBytes / 1024).toFixed(1)} KB`);
+        console.log(`  Disk:     ${(s.dbSizeBytes / 1024).toFixed(1)} KB`);
         break;
       }
       case 'recent': {
@@ -175,8 +175,8 @@ function handleTraceQuery(args, config) {
       }
       case 'compact': {
         const s = trace.stats();
-        console.log(`Compacting debug database (${(s.dbSizeBytes / 1048576).toFixed(1)} MB, ${s.turnCount} turns)...`);
-        console.log('This rebuilds the file and may take a while on a large DB. Do not interrupt.');
+        console.log(`Compacting debug trace files (${(s.dbSizeBytes / 1048576).toFixed(1)} MB, ${s.turnCount} turns)...`);
+        console.log('This prunes old request folders and may take a moment. Do not interrupt.');
         const { before, after } = trace.compact();
         const saved = Math.max(0, before - after);
         console.log(`Done. ${(before / 1048576).toFixed(1)} MB → ${(after / 1048576).toFixed(1)} MB (reclaimed ${(saved / 1048576).toFixed(1)} MB).`);