nexus-agentd 0.2.0 → 0.2.1

package/README.md

@@ -215,7 +215,8 @@ GET  /v1/sessions/:id/events
 `/v1/meta` 和 Session 响应包含 Gateway `instanceId`；完成的 Session 还包含与当前 Run 绑定的
 `completion` 证明，客户端可识别进程重启和迟到/伪造的完成状态。授权与输入通过精确的
 `requestId` 解析；过期 ID 返回 `409`，不会误答后续请求。`DELETE /v1/sessions/:id` 会取消活动任务、
-释放 Agent 进程并移除内存 Session。
+释放 Agent 整个进程组并移除内存 Session。Gateway 停止时会先终止 Session，再在有限宽限期后关闭残留
+HTTP/SSE 连接，避免长连接或 Agent 孙进程阻塞服务重启。
 
 API Key 的 Agent scope 在 Agent inventory、Session 创建和后续 Session 操作上都会检查；Session
 还绑定创建它的 Key，其他 Key 即使拥有同一 Agent scope 也不能读取或控制该 Session。

package/dist/acp/runtime.js

@@ -4,6 +4,7 @@ import path from 'node:path';
 import { Readable, Writable } from 'node:stream';
 import { pathToFileURL } from 'node:url';
 import * as acp from '@agentclientprotocol/sdk';
+import { terminateProcessTree } from '../process-tree.js';
 import { TURN_COMPLETION_CONTRACT } from '../completion-contract.js';
 export class AcpProcessRuntime {
     driver;
@@ -61,7 +62,7 @@ export class AcpProcessRuntime {
             },
             clientInfo: {
                 name: 'nexus-agentd',
-                version: '0.2.0'
+                version: '0.2.1'
             }
         });
         if (initialize.protocolVersion !== acp.PROTOCOL_VERSION) {
@@ -224,15 +225,17 @@ export class AcpProcessRuntime {
         }
         this.connection?.close();
         this.connection = undefined;
+        const child = this.process;
+        this.process = undefined;
+        if (child) {
+            await terminateProcessTree(child, {
+                ownsProcessGroup: this.driver.ownsProcessGroup
+            });
+        }
         if (this.inputDirectory) {
             await rm(this.inputDirectory, { recursive: true, force: true }).catch(() => undefined);
             this.inputDirectory = undefined;
         }
-        const child = this.process;
-        this.process = undefined;
-        if (child && child.exitCode === null && child.signalCode === null) {
-            child.kill();
-        }
     }
     requestPermission(params) {
         if (this.driver.permissionPolicy === 'deny') {

package/dist/drivers/pi.d.ts

@@ -9,5 +9,6 @@ export declare function createPiDriver(id: string, config: AgentdDriverConfig):
     env: NodeJS.ProcessEnv;
     permissionPolicy: import("../types.js").PermissionPolicy;
     permissionTimeoutMs: number;
+    ownsProcessGroup?: boolean;
     spawn(workspace: string): import("child_process").ChildProcessWithoutNullStreams;
 };

package/dist/drivers/stdio.js

@@ -28,6 +28,7 @@ export function createStdioAcpDriver(id, config, defaults) {
         env,
         permissionPolicy: config.permissionPolicy || 'ask',
         permissionTimeoutMs: config.permissionTimeoutMs || 15 * 60 * 1000,
+        ownsProcessGroup: process.platform !== 'win32',
         async probe() {
             try {
                 const version = await probeCommand(command, defaults.probeArgs || ['--version'], env, name);
@@ -55,6 +56,7 @@ export function createStdioAcpDriver(id, config, defaults) {
             return spawn(command, args, {
                 cwd: workspace,
                 env,
+                detached: process.platform !== 'win32',
                 stdio: ['pipe', 'pipe', 'pipe']
             });
         }

package/dist/drivers/types.d.ts

@@ -9,6 +9,8 @@ export interface AgentDriver {
     env: NodeJS.ProcessEnv;
     permissionPolicy: PermissionPolicy;
     permissionTimeoutMs: number;
+    /** The spawned Agent owns a dedicated process group that can be terminated as a tree. */
+    ownsProcessGroup?: boolean;
     probe(): Promise<AgentdAgentView>;
     spawn(workspace: string): ChildProcessWithoutNullStreams;
 }

package/dist/index.d.ts

@@ -10,6 +10,7 @@ export declare function startAgentd(configPath: string): Promise<{
     controlPlane: AgentdControlPlane;
     close(): Promise<void>;
 }>;
+export declare function closeServer(server: Server, graceMs?: number): Promise<void>;
 export * from './config.js';
 export * from './control-plane.js';
 export * from './server.js';

package/dist/index.js

@@ -24,8 +24,7 @@ export async function startAgentd(configPath) {
         runStore,
         controlPlane,
         async close() {
-            await closeServer(server);
-            await sessions.shutdown();
+            await Promise.all([closeServer(server), sessions.shutdown()]);
             await runStore.flush();
         }
     };
@@ -45,9 +44,24 @@ function listen(server, port, host) {
         server.listen(port, host);
     });
 }
-function closeServer(server) {
+export function closeServer(server, graceMs = 2_000) {
     return new Promise((resolve, reject) => {
-        server.close((error) => (error ? reject(error) : resolve()));
+        let settled = false;
+        const finish = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            if (error)
+                reject(error);
+            else
+                resolve();
+        };
+        const timer = setTimeout(() => {
+            server.closeAllConnections?.();
+            finish();
+        }, Math.max(0, graceMs));
+        server.close((error) => finish(error || undefined));
         server.closeIdleConnections?.();
     });
 }

package/dist/process-tree.d.ts

@@ -0,0 +1,5 @@
+import { type ChildProcess } from 'node:child_process';
+export declare function terminateProcessTree(child: ChildProcess, options?: {
+    ownsProcessGroup?: boolean;
+    graceMs?: number;
+}): Promise<void>;

package/dist/process-tree.js

@@ -0,0 +1,105 @@
+import { spawn } from 'node:child_process';
+const DEFAULT_GRACE_MS = 2_000;
+const FORCE_KILL_WAIT_MS = 1_000;
+export async function terminateProcessTree(child, options = {}) {
+    const pid = child.pid;
+    if (!pid || hasExited(child))
+        return;
+    const graceMs = Math.max(0, options.graceMs ?? DEFAULT_GRACE_MS);
+    if (process.platform === 'win32') {
+        await taskkill(pid, false);
+        if (await waitForExit(child, graceMs))
+            return;
+        await taskkill(pid, true);
+        await waitForExit(child, FORCE_KILL_WAIT_MS);
+        return;
+    }
+    if (options.ownsProcessGroup === true) {
+        signalUnixGroup(pid, 'SIGTERM');
+        if (await waitForUnixGroupExit(pid, graceMs))
+            return;
+        signalUnixGroup(pid, 'SIGKILL');
+        await waitForUnixGroupExit(pid, FORCE_KILL_WAIT_MS);
+        return;
+    }
+    signalUnix(child, 'SIGTERM');
+    if (await waitForExit(child, graceMs))
+        return;
+    signalUnix(child, 'SIGKILL');
+    await waitForExit(child, FORCE_KILL_WAIT_MS);
+}
+function signalUnix(child, signal) {
+    try {
+        child.kill(signal);
+    }
+    catch { }
+}
+function signalUnixGroup(pid, signal) {
+    try {
+        process.kill(-pid, signal);
+    }
+    catch { }
+}
+async function waitForUnixGroupExit(pid, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (unixGroupExists(pid)) {
+        const remaining = deadline - Date.now();
+        if (remaining <= 0)
+            return false;
+        await delay(Math.min(25, remaining));
+    }
+    return true;
+}
+function unixGroupExists(pid) {
+    try {
+        process.kill(-pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code !== 'ESRCH';
+    }
+}
+function waitForExit(child, timeoutMs) {
+    if (hasExited(child))
+        return Promise.resolve(true);
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = (exited) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            child.off('exit', onExit);
+            resolve(exited);
+        };
+        const onExit = () => finish(true);
+        const timer = setTimeout(() => finish(hasExited(child)), timeoutMs);
+        child.once('exit', onExit);
+        if (hasExited(child))
+            finish(true);
+    });
+}
+function taskkill(pid, force) {
+    return new Promise((resolve) => {
+        const args = ['/PID', String(pid), '/T'];
+        if (force)
+            args.push('/F');
+        const killer = spawn('taskkill.exe', args, { stdio: 'ignore', windowsHide: true });
+        const timer = setTimeout(() => {
+            killer.kill();
+            resolve();
+        }, FORCE_KILL_WAIT_MS);
+        const finish = () => {
+            clearTimeout(timer);
+            resolve();
+        };
+        killer.once('error', finish);
+        killer.once('exit', finish);
+    });
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function hasExited(child) {
+    return child.exitCode !== null || child.signalCode !== null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexus-agentd",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Local Nexus Gateway daemon that exposes allowlisted Coding Agents through HTTP/SSE and ACP",
   "type": "module",
   "main": "dist/index.js",