@yeaft/webchat-agent 1.0.24 → 1.0.26

package/cli.js

@@ -64,35 +64,40 @@ function printHelp() {
   Usage:
     yeaft-agent [options]              Run agent in foreground
     yeaft-agent install [options]      Install as system service
-    yeaft-agent uninstall              Remove system service
-    yeaft-agent start                  Start installed service
-    yeaft-agent stop                   Stop installed service
-    yeaft-agent restart                Restart installed service
-    yeaft-agent status                 Show service status
-    yeaft-agent logs                   View service logs (follow mode)
+    yeaft-agent uninstall [options]    Remove system service
+    yeaft-agent start [options]        Start installed service
+    yeaft-agent stop [options]         Stop installed service
+    yeaft-agent restart [options]      Restart installed service
+    yeaft-agent status [options]       Show service status
+    yeaft-agent logs [options]         View service logs (follow mode)
     yeaft-agent doctor                 Diagnose service configuration
     yeaft-agent llm <command>          Configure local Yeaft LLM providers/models
     yeaft-agent upgrade                Upgrade to latest version
     yeaft-agent --version              Show version
 
   Options:
+    --instance <id>     Local service instance id (default: default)
     --server <url>      WebSocket server URL (default: ws://localhost:3456)
     --name <name>       Agent display name (default: Worker-{platform}-{pid})
     --secret <secret>   Agent secret for authentication
     --work-dir <dir>    Default working directory (default: cwd)
+    --yeaft-dir <dir>   Yeaft data directory for this instance
     --auto-upgrade      Check for updates on startup
 
   Environment variables (alternative to flags):
+    YEAFT_AGENT_INSTANCE Local service instance id
     SERVER_URL          WebSocket server URL
     AGENT_NAME          Agent display name
     AGENT_SECRET        Agent secret
     WORK_DIR            Working directory
+    YEAFT_DIR           Yeaft data directory
 
   Examples:
     yeaft-agent --server wss://your-server.com --name my-worker --secret xxx
     yeaft-agent install --server wss://your-server.com --name my-worker --secret xxx
-    yeaft-agent status
-    yeaft-agent logs
+    yeaft-agent install --instance second --server wss://your-server.com --name my-worker-2 --secret xxx
+    yeaft-agent status --instance second
+    yeaft-agent logs --instance second
 `);
 }
 
@@ -381,12 +386,12 @@ async function handleServiceCommand(command, args) {
   const service = await import('./service.js');
   switch (command) {
     case 'install':   service.install(args); break;
-    case 'uninstall': service.uninstall(); break;
-    case 'start':     service.start(); break;
-    case 'stop':      service.stop(); break;
-    case 'restart':   service.restart(); break;
-    case 'status':    service.status(); break;
-    case 'logs':      service.logs(); break;
+    case 'uninstall': service.uninstall(args); break;
+    case 'start':     service.start(args); break;
+    case 'stop':      service.stop(args); break;
+    case 'restart':   service.restart(args); break;
+    case 'status':    service.status(args); break;
+    case 'logs':      service.logs(args); break;
   }
 }
 
@@ -402,6 +407,9 @@ function parseAndStart(args) {
     const next = args[i + 1];
 
     switch (arg) {
+      case '--instance':
+        if (next) { process.env.YEAFT_AGENT_INSTANCE = process.env.YEAFT_AGENT_INSTANCE || next; i++; }
+        break;
       case '--server':
         if (next) { process.env.SERVER_URL = process.env.SERVER_URL || next; i++; }
         break;
@@ -414,6 +422,9 @@ function parseAndStart(args) {
       case '--work-dir':
         if (next) { process.env.WORK_DIR = process.env.WORK_DIR || next; i++; }
         break;
+      case '--yeaft-dir':
+        if (next) { process.env.YEAFT_DIR = process.env.YEAFT_DIR || next; i++; }
+        break;
       case '--auto-upgrade':
         checkForUpdates();
         break;

package/connection/index.js

@@ -5,12 +5,15 @@ import { startAgentHeartbeat, stopAgentHeartbeat, scheduleReconnect } from './he
 import { handleMessage } from './message-router.js';
 
 export function connect() {
-  // Don't include secret in URL - it will be sent via WebSocket message after connection
-  // 使用 agentName 作为唯一标识（不再使用随机 UUID）
+  // Don't include secret in URL - it will be sent via WebSocket message after connection.
+  // instanceId is the stable local service identity; agentName is display-only.
+  // Old configs without instanceId still use agentName for backward-compatible identity.
+  const instanceId = ctx.CONFIG.instanceId || ctx.CONFIG.agentName;
   const params = new URLSearchParams({
     type: 'agent',
-    id: ctx.CONFIG.agentName,  // 直接用名称作为 ID
+    id: instanceId,
     name: ctx.CONFIG.agentName,
+    instanceId,
     workDir: ctx.CONFIG.workDir,
     capabilities: ctx.agentCapabilities.join(',')
   });

package/connection/message-router.js

@@ -58,11 +58,13 @@ export async function handleMessage(msg) {
         console.log('[WS] Server accepts plaintext, disabling outbound encryption');
       }
 
-      // 只保存基本配置（不再保存 agentId，因为现在用 agentName 作为 ID）
+      // 只保存基本配置。instanceId 是本地服务实例身份；agentName 只用于展示。
       ctx.saveConfig({
+        instanceId: ctx.CONFIG.instanceId,
         serverUrl: ctx.CONFIG.serverUrl,
         agentName: ctx.CONFIG.agentName,
         workDir: ctx.CONFIG.workDir,
+        yeaftDir: ctx.CONFIG.yeaftDir,
         reconnectInterval: ctx.CONFIG.reconnectInterval
         // 不保存 agentSecret 到配置文件（安全考虑）
       });

package/index.js

@@ -2,14 +2,14 @@ import { assertNodeVersion } from './check-node-version.js';
 assertNodeVersion({ component: '@yeaft/webchat-agent' });
 
 import 'dotenv/config';
-import { platform, homedir } from 'os';
+import { platform } from 'os';
 import { existsSync, readFileSync, writeFileSync, mkdirSync, cpSync, chmodSync, readdirSync } from 'fs';
 import { join, dirname } from 'path';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import { fileURLToPath } from 'url';
 import ctx from './context.js';
-import { getConfigPath, loadServiceConfig } from './service.js';
+import { DEFAULT_INSTANCE_ID, getDefaultYeaftDir, validateInstanceId, getConfigPath, loadServiceConfig } from './service.js';
 import { loadNodePty } from './terminal.js';
 import { connect } from './connection.js';
 import { loadMcpServers } from './mcp.js';
@@ -60,6 +60,7 @@ function saveConfig(config) {
 }
 
 const fileConfig = loadConfig();
+const INSTANCE_ID = validateInstanceId(process.env.YEAFT_AGENT_INSTANCE || fileConfig.instanceId || DEFAULT_INSTANCE_ID);
 
 // task-fix (5-bugs): the Yeaft web-bridge reads `ctx.CONFIG.yeaftDir`
 // for every group / VP / memory operation. If unset, `path.join(undefined, …)`
@@ -67,7 +68,7 @@ const fileConfig = loadConfig();
 // and the UI surfaces "群组操作失败: …" with a raw node error. Resolve the
 // default (`~/.yeaft`) here and make sure the directory exists before the
 // WebSocket connection goes live, so downstream code can assume a real path.
-const YEAFT_DIR = process.env.YEAFT_DIR || fileConfig.yeaftDir || join(homedir(), '.yeaft');
+const YEAFT_DIR = process.env.YEAFT_DIR || fileConfig.yeaftDir || getDefaultYeaftDir(INSTANCE_ID);
 try {
   if (!existsSync(YEAFT_DIR)) {
     mkdirSync(YEAFT_DIR, { recursive: true });
@@ -78,6 +79,7 @@ try {
 }
 
 const CONFIG = {
+  instanceId: INSTANCE_ID,
   serverUrl: process.env.SERVER_URL || fileConfig.serverUrl,
   agentName: process.env.AGENT_NAME || fileConfig.agentName,
   workDir: process.env.WORK_DIR || fileConfig.workDir || process.cwd(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.24",
+  "version": "1.0.26",
   "description": "Remote worker agent for Yeaft Web Code Agent — connects the native Yeaft engine, CLI providers, and workbench tools",
   "main": "index.js",
   "type": "module",

package/service/config.js

@@ -1,4 +1,4 @@
-/**
+/*
  * Service — shared configuration and utility functions
  */
 import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
@@ -8,6 +8,7 @@ import { fileURLToPath } from 'url';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 export const SERVICE_NAME = 'yeaft-agent';
+export const DEFAULT_INSTANCE_ID = 'default';
 
 /**
  * Load .env file from agent directory (or cwd) into process.env
@@ -40,36 +41,98 @@ function loadDotenv() {
   }
 }
 
-// Standard config/log directory per platform
-export function getConfigDir() {
+export function normalizeInstanceId(instanceId) {
+  const raw = String(instanceId || '').trim();
+  return raw || DEFAULT_INSTANCE_ID;
+}
+
+export function isDefaultInstance(instanceId) {
+  return normalizeInstanceId(instanceId) === DEFAULT_INSTANCE_ID;
+}
+
+export function validateInstanceId(instanceId) {
+  const normalized = normalizeInstanceId(instanceId);
+  if (!/^[A-Za-z0-9_.-]+$/.test(normalized)) {
+    throw new Error('Instance id may only contain letters, numbers, dot, underscore, or dash');
+  }
+  return normalized;
+}
+
+export function getInstanceIdFromArgs(args = [], env = process.env) {
+  let instanceId = env.YEAFT_AGENT_INSTANCE || '';
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    const next = args[i + 1];
+    if (arg === '--instance' && next) {
+      instanceId = next;
+      i++;
+    }
+  }
+  return validateInstanceId(instanceId || DEFAULT_INSTANCE_ID);
+}
+
+export function getServiceName(instanceId = DEFAULT_INSTANCE_ID) {
+  const normalized = validateInstanceId(instanceId);
+  return isDefaultInstance(normalized) ? SERVICE_NAME : `${SERVICE_NAME}@${normalized}`;
+}
+
+export function getPm2AppName(instanceId = DEFAULT_INSTANCE_ID) {
+  const normalized = validateInstanceId(instanceId);
+  return isDefaultInstance(normalized) ? SERVICE_NAME : `${SERVICE_NAME}-${normalized}`;
+}
+
+export function getLaunchdLabel(instanceId = DEFAULT_INSTANCE_ID) {
+  const normalized = validateInstanceId(instanceId);
+  return isDefaultInstance(normalized) ? 'com.yeaft.agent' : `com.yeaft.agent.${normalized}`;
+}
+
+export function getDefaultYeaftDir(instanceId = DEFAULT_INSTANCE_ID) {
+  const normalized = validateInstanceId(instanceId);
+  return isDefaultInstance(normalized)
+    ? join(homedir(), '.yeaft')
+    : join(homedir(), '.yeaft', 'instances', normalized);
+}
+
+function getBaseConfigDir() {
   if (platform() === 'win32') {
     return join(process.env.APPDATA || join(homedir(), 'AppData', 'Roaming'), SERVICE_NAME);
   }
   return join(homedir(), '.config', SERVICE_NAME);
 }
 
-export function getLogDir() {
-  return join(getConfigDir(), 'logs');
+// Standard config/log directory per platform. The default instance keeps the
+// historical paths for compatibility; named instances live under instances/<id>.
+export function getConfigDir(instanceId = process.env.YEAFT_AGENT_INSTANCE || DEFAULT_INSTANCE_ID) {
+  const normalized = validateInstanceId(instanceId);
+  const base = getBaseConfigDir();
+  return isDefaultInstance(normalized) ? base : join(base, 'instances', normalized);
+}
+
+export function getLogDir(instanceId = process.env.YEAFT_AGENT_INSTANCE || DEFAULT_INSTANCE_ID) {
+  return join(getConfigDir(instanceId), 'logs');
 }
 
-export function getConfigPath() {
-  return join(getConfigDir(), 'config.json');
+export function getConfigPath(instanceId = process.env.YEAFT_AGENT_INSTANCE || DEFAULT_INSTANCE_ID) {
+  return join(getConfigDir(instanceId), 'config.json');
 }
 
 /** Save agent configuration to standard location */
 export function saveServiceConfig(config) {
-  const dir = getConfigDir();
+  const instanceId = validateInstanceId(config.instanceId || DEFAULT_INSTANCE_ID);
+  const dir = getConfigDir(instanceId);
   mkdirSync(dir, { recursive: true });
-  mkdirSync(getLogDir(), { recursive: true });
-  writeFileSync(getConfigPath(), JSON.stringify(config, null, 2));
+  mkdirSync(getLogDir(instanceId), { recursive: true });
+  writeFileSync(getConfigPath(instanceId), JSON.stringify({ ...config, instanceId }, null, 2));
 }
 
 /** Load agent configuration from standard location */
-export function loadServiceConfig() {
-  const configPath = getConfigPath();
+export function loadServiceConfig(instanceId = process.env.YEAFT_AGENT_INSTANCE || DEFAULT_INSTANCE_ID) {
+  const normalized = validateInstanceId(instanceId);
+  const configPath = getConfigPath(normalized);
   if (!existsSync(configPath)) return null;
   try {
-    return JSON.parse(readFileSync(configPath, 'utf-8'));
+    const loaded = JSON.parse(readFileSync(configPath, 'utf-8'));
+    return { ...loaded, instanceId: loaded.instanceId || normalized };
   } catch {
     return null;
   }
@@ -86,18 +149,21 @@ export function getCliPath() {
 }
 
 /**
- * Parse --server/--name/--secret/--work-dir from args, merge with existing config
+ * Parse service options from args, merging with the selected instance config.
  */
 export function parseServiceArgs(args) {
   // Load .env if available (for dev / source-based usage)
   loadDotenv();
 
-  const existing = loadServiceConfig() || {};
+  const instanceId = getInstanceIdFromArgs(args);
+  const existing = loadServiceConfig(instanceId) || {};
   const config = {
+    instanceId,
     serverUrl: existing.serverUrl || '',
     agentName: existing.agentName || '',
     agentSecret: existing.agentSecret || '',
     workDir: existing.workDir || '',
+    yeaftDir: existing.yeaftDir || '',
   };
 
   // Environment variables override saved config
@@ -105,16 +171,19 @@ export function parseServiceArgs(args) {
   if (process.env.AGENT_NAME) config.agentName = process.env.AGENT_NAME;
   if (process.env.AGENT_SECRET) config.agentSecret = process.env.AGENT_SECRET;
   if (process.env.WORK_DIR) config.workDir = process.env.WORK_DIR;
+  if (process.env.YEAFT_DIR) config.yeaftDir = process.env.YEAFT_DIR;
 
   // CLI args override everything
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     const next = args[i + 1];
     switch (arg) {
+      case '--instance': if (next) { i++; } break;
       case '--server': if (next) { config.serverUrl = next; i++; } break;
       case '--name': if (next) { config.agentName = next; i++; } break;
       case '--secret': if (next) { config.agentSecret = next; i++; } break;
       case '--work-dir': if (next) { config.workDir = next; i++; } break;
+      case '--yeaft-dir': if (next) { config.yeaftDir = next; i++; } break;
     }
   }
 
@@ -122,6 +191,12 @@ export function parseServiceArgs(args) {
 }
 
 export function validateConfig(config) {
+  try {
+    validateInstanceId(config.instanceId || DEFAULT_INSTANCE_ID);
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  }
   if (!config.serverUrl) {
     console.error('Error: --server <url> is required');
     process.exit(1);

package/service/index.js

@@ -1,13 +1,13 @@
-/**
+/*
  * Service — platform dispatcher
  * Routes install/uninstall/start/stop/restart/status/logs to the correct platform module.
  */
 import { existsSync } from 'fs';
 import { platform } from 'os';
 import {
-  SERVICE_NAME, getConfigDir, getLogDir, getConfigPath,
+  getConfigDir, getLogDir, getConfigPath,
   saveServiceConfig, loadServiceConfig,
-  parseServiceArgs, validateConfig
+  parseServiceArgs, validateConfig, getInstanceIdFromArgs, getDefaultYeaftDir
 } from './config.js';
 import { initYeaftDir } from '../yeaft/init.js';
 import { getSystemdServicePath, linuxInstall, linuxUninstall, linuxStart, linuxStop, linuxRestart, linuxStatus, linuxLogs } from './linux.js';
@@ -20,17 +20,29 @@ export {
   saveServiceConfig, loadServiceConfig,
   parseServiceArgs
 };
+export {
+  SERVICE_NAME,
+  DEFAULT_INSTANCE_ID,
+  normalizeInstanceId,
+  isDefaultInstance,
+  validateInstanceId,
+  getInstanceIdFromArgs,
+  getServiceName,
+  getPm2AppName,
+  getLaunchdLabel,
+  getDefaultYeaftDir,
+} from './config.js';
 
 const os = platform();
 
-function ensureInstalled() {
+function ensureInstalled(instanceId) {
   if (os === 'linux') {
-    if (!existsSync(getSystemdServicePath())) {
+    if (!existsSync(getSystemdServicePath(instanceId))) {
       console.error('Service not installed. Run "yeaft-agent install" first.');
       process.exit(1);
     }
   } else if (os === 'darwin') {
-    if (!existsSync(getLaunchdPlistPath())) {
+    if (!existsSync(getLaunchdPlistPath(instanceId))) {
       console.error('Service not installed. Run "yeaft-agent install" first.');
       process.exit(1);
     }
@@ -45,17 +57,19 @@ export function install(args) {
 
   // Initialize ~/.yeaft/ directory + default config.json
   // so `yeaft` CLI is ready to use immediately after install
-  const { dir, created } = initYeaftDir();
+  const effectiveYeaftDir = config.yeaftDir || getDefaultYeaftDir(config.instanceId);
+  const { dir, created } = initYeaftDir(effectiveYeaftDir);
   if (created.length > 0) {
     console.log(`Initialized ${dir}`);
     console.log(`  Edit ${dir}/config.json to configure LLM providers.`);
     console.log('');
   }
 
-  console.log(`Installing ${SERVICE_NAME} service...`);
-  console.log(`  Server: ${config.serverUrl}`);
-  console.log(`  Name:   ${config.agentName || '(auto)'}`);
-  console.log(`  WorkDir: ${config.workDir || '(home)'}`);
+  console.log(`Installing yeaft-agent service...`);
+  console.log(`  Instance: ${config.instanceId}`);
+  console.log(`  Server:   ${config.serverUrl}`);
+  console.log(`  Name:     ${config.agentName || '(auto)'}`);
+  console.log(`  WorkDir:  ${config.workDir || '(home)'}`);
   console.log('');
 
   if (os === 'linux') linuxInstall(config);
@@ -68,45 +82,51 @@ export function install(args) {
   }
 }
 
-export function uninstall() {
-  console.log(`Uninstalling ${SERVICE_NAME} service...`);
-  if (os === 'linux') linuxUninstall();
-  else if (os === 'darwin') macUninstall();
-  else if (os === 'win32') winUninstall();
+export function uninstall(args = []) {
+  const instanceId = getInstanceIdFromArgs(args);
+  console.log(`Uninstalling yeaft-agent service (${instanceId})...`);
+  if (os === 'linux') linuxUninstall(instanceId);
+  else if (os === 'darwin') macUninstall(instanceId);
+  else if (os === 'win32') winUninstall(instanceId);
   else { console.error(`Unsupported platform: ${os}`); process.exit(1); }
 }
 
-export function start() {
-  ensureInstalled();
-  if (os === 'linux') linuxStart();
-  else if (os === 'darwin') macStart();
-  else if (os === 'win32') winStart();
+export function start(args = []) {
+  const instanceId = getInstanceIdFromArgs(args);
+  ensureInstalled(instanceId);
+  if (os === 'linux') linuxStart(instanceId);
+  else if (os === 'darwin') macStart(instanceId);
+  else if (os === 'win32') winStart(instanceId);
 }
 
-export function stop() {
-  ensureInstalled();
-  if (os === 'linux') linuxStop();
-  else if (os === 'darwin') macStop();
-  else if (os === 'win32') winStop();
+export function stop(args = []) {
+  const instanceId = getInstanceIdFromArgs(args);
+  ensureInstalled(instanceId);
+  if (os === 'linux') linuxStop(instanceId);
+  else if (os === 'darwin') macStop(instanceId);
+  else if (os === 'win32') winStop(instanceId);
 }
 
-export function restart() {
-  ensureInstalled();
-  if (os === 'linux') linuxRestart();
-  else if (os === 'darwin') macRestart();
-  else if (os === 'win32') winRestart();
+export function restart(args = []) {
+  const instanceId = getInstanceIdFromArgs(args);
+  ensureInstalled(instanceId);
+  if (os === 'linux') linuxRestart(instanceId);
+  else if (os === 'darwin') macRestart(instanceId);
+  else if (os === 'win32') winRestart(instanceId);
 }
 
-export function status() {
-  if (os === 'linux') linuxStatus();
-  else if (os === 'darwin') macStatus();
-  else if (os === 'win32') winStatus();
+export function status(args = []) {
+  const instanceId = getInstanceIdFromArgs(args);
+  if (os === 'linux') linuxStatus(instanceId);
+  else if (os === 'darwin') macStatus(instanceId);
+  else if (os === 'win32') winStatus(instanceId);
 }
 
-export function logs() {
-  if (os === 'linux') linuxLogs();
-  else if (os === 'darwin') macLogs();
-  else if (os === 'win32') winLogs();
+export function logs(args = []) {
+  const instanceId = getInstanceIdFromArgs(args);
+  if (os === 'linux') linuxLogs(instanceId);
+  else if (os === 'darwin') macLogs(instanceId);
+  else if (os === 'win32') winLogs(instanceId);
 }
 
 export { doctor };

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,