@yeaft/webchat-agent 1.0.14 → 1.0.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.14",
+  "version": "1.0.16",
   "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/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/systemd-scope.js

@@ -0,0 +1,88 @@
+/**
+ * systemd-scope.js — run child processes outside the agent service cgroup.
+ *
+ * When yeaft-agent runs as a systemd user service, shell tasks inherit the
+ * yeaft-agent.service cgroup by default. Long-lived commands then show up as
+ * "left-over process" entries every time the agent service restarts. Wrapping
+ * shell commands in a transient user scope keeps those user workloads alive
+ * without polluting the agent service lifecycle.
+ */
+
+import { existsSync } from 'fs';
+import { delimiter, isAbsolute, join } from 'path';
+
+const DEFAULT_SCOPE_PREFIX = 'yeaft-shell';
+const UNIT_MAX_LENGTH = 180;
+
+function hasPathSeparator(command) {
+  return command.includes('/') || command.includes('\\');
+}
+
+export function findExecutableOnPath(command, env = process.env) {
+  if (!command || typeof command !== 'string') return null;
+  if (hasPathSeparator(command)) return existsSync(command) ? command : null;
+
+  const pathValue = env.PATH || '';
+  for (const dir of pathValue.split(delimiter)) {
+    if (!dir) continue;
+    const candidate = isAbsolute(dir) ? join(dir, command) : join(process.cwd(), dir, command);
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+
+export function shouldUseSystemdUserScope({ runtimePlatform, env = process.env, systemdRunPath = null } = {}) {
+  if (!runtimePlatform?.isLinux) return false;
+  if (env.YEAFT_DISABLE_SYSTEMD_SCOPE === '1') return false;
+
+  // INVOCATION_ID is set for systemd services and transient scopes. XDG_RUNTIME_DIR
+  // is required for `systemd-run --user` to talk to the user manager.
+  if (!env.INVOCATION_ID || !env.XDG_RUNTIME_DIR) return false;
+
+  const resolvedSystemdRun = systemdRunPath || findExecutableOnPath('systemd-run', env);
+  return !!resolvedSystemdRun;
+}
+
+export function sanitizeSystemdUnitPart(value) {
+  const raw = String(value || '').trim() || `${Date.now()}-${process.pid}`;
+  return raw
+    .replace(/[^A-Za-z0-9_.-]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, UNIT_MAX_LENGTH) || `${Date.now()}-${process.pid}`;
+}
+
+export function buildSystemdScopeName(scopeId, prefix = DEFAULT_SCOPE_PREFIX) {
+  const safePrefix = sanitizeSystemdUnitPart(prefix).slice(0, 48);
+  const safeId = sanitizeSystemdUnitPart(scopeId);
+  const base = `${safePrefix}-${safeId}`.slice(0, UNIT_MAX_LENGTH);
+  return base.endsWith('.scope') ? base : `${base}.scope`;
+}
+
+export function wrapInvocationInSystemdUserScope(invocation, {
+  runtimePlatform,
+  env = process.env,
+  scopeId = null,
+  scopePrefix = DEFAULT_SCOPE_PREFIX,
+  systemdRunPath = null,
+} = {}) {
+  if (!shouldUseSystemdUserScope({ runtimePlatform, env, systemdRunPath })) {
+    return { ...invocation, systemdScope: null };
+  }
+
+  const scopeName = buildSystemdScopeName(scopeId, scopePrefix);
+  return {
+    command: systemdRunPath || findExecutableOnPath('systemd-run', env) || 'systemd-run',
+    args: [
+      '--user',
+      '--scope',
+      '--quiet',
+      '--collect',
+      `--unit=${scopeName}`,
+      invocation.command,
+      ...(invocation.args || []),
+    ],
+    family: invocation.family,
+    systemdScope: scopeName,
+    wrappedCommand: invocation.command,
+  };
+}

package/yeaft/tasks/manager.js

@@ -149,6 +149,7 @@ export class TaskManager {
         command,
         cwd,
         pid: null,
+        systemdScope: null,
         platform: (runtimePlatform || this.runtimePlatform)?.platform || process.platform,
       },
       log: {
@@ -170,6 +171,7 @@ export class TaskManager {
       command,
       cwd,
       runtimePlatform: runtime,
+      scopeId: task.id,
       onOutput: (stream, text) => {
         const prefix = stream === 'stderr' ? '[stderr] ' : '';
         this.store.appendLog(task.sessionId, task.id, prefix ? text.split(/(\n)/).map(part => part === '\n' ? part : (part ? `${prefix}${part}` : part)).join('') : text);
@@ -191,6 +193,7 @@ export class TaskManager {
     });
 
     task.runtime.pid = runner.pid;
+    task.runtime.systemdScope = runner.systemdScope || null;
     this.processes.set(this.#key(task.sessionId, task.id), runner);
     this.store.writeTask(task);
     this.#emit('updated', task);

package/yeaft/tasks/shell-runner.js

@@ -4,6 +4,7 @@
 
 import { spawn, spawnSync } from 'child_process';
 import { buildShellInvocation, getRuntimePlatformInfo } from '../runtime-platform.js';
+import { wrapInvocationInSystemdUserScope } from '../systemd-scope.js';
 
 export function buildWindowsTaskkillArgs(pid) {
   return ['/pid', String(pid), '/t', '/f'];
@@ -33,12 +34,18 @@ export function killShellProcessTree(pid, runtimePlatform, signal = 'SIGTERM') {
   }
 }
 
-export function startShellProcess({ command, cwd, runtimePlatform, onOutput, onExit, onError }) {
+export function startShellProcess({ command, cwd, runtimePlatform, scopeId = null, onOutput, onExit, onError }) {
   const platform = runtimePlatform || getRuntimePlatformInfo();
-  const invocation = buildShellInvocation(command, { runtimePlatform: platform });
+  const env = { ...process.env, TERM: 'dumb', FORCE_COLOR: '0' };
+  const baseInvocation = buildShellInvocation(command, { runtimePlatform: platform });
+  const invocation = wrapInvocationInSystemdUserScope(baseInvocation, {
+    runtimePlatform: platform,
+    env,
+    scopeId,
+  });
   const proc = spawn(invocation.command, invocation.args, {
     cwd,
-    env: { ...process.env, TERM: 'dumb', FORCE_COLOR: '0' },
+    env,
     stdio: ['ignore', 'pipe', 'pipe'],
     detached: !platform.isWindows,
     windowsHide: true,
@@ -57,6 +64,7 @@ export function startShellProcess({ command, cwd, runtimePlatform, onOutput, onE
 
   return {
     pid: proc.pid || null,
+    systemdScope: invocation.systemdScope || null,
     kill(signal = 'SIGTERM') {
       return killShellProcessTree(proc.pid, platform, signal);
     },

package/yeaft/tools/bash.js

@@ -13,6 +13,7 @@ import { spawn } from 'child_process';
 import { existsSync } from 'fs';
 import { resolve } from 'path';
 import { buildShellInvocation, getRuntimePlatformInfo } from '../runtime-platform.js';
+import { wrapInvocationInSystemdUserScope } from '../systemd-scope.js';
 
 export { buildShellInvocation };
 
@@ -32,10 +33,16 @@ const MAX_TIMEOUT_MS = 600_000;
 function runCommand(command, { cwd, timeout, signal, runtimePlatform }) {
   return new Promise((resolve) => {
     const platform = runtimePlatform || getRuntimePlatformInfo();
-    const invocation = buildShellInvocation(command, { runtimePlatform: platform });
+    const env = { ...process.env, TERM: 'dumb', FORCE_COLOR: '0' };
+    const baseInvocation = buildShellInvocation(command, { runtimePlatform: platform });
+    const invocation = wrapInvocationInSystemdUserScope(baseInvocation, {
+      runtimePlatform: platform,
+      env,
+      scopeId: `foreground-${Date.now()}-${process.pid}`,
+    });
     const proc = spawn(invocation.command, invocation.args, {
       cwd,
-      env: { ...process.env, TERM: 'dumb', FORCE_COLOR: '0' },
+      env,
       stdio: ['ignore', 'pipe', 'pipe'],
       detached: !platform.isWindows,
     });