@ai-development-environment/control-agent 0.0.78 → 0.0.79

package/dist/control-agent.js

@@ -2276,7 +2276,7 @@ var require_websocket = __commonJS({
     var http = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes, createHash: createHash6 } = __require("crypto");
+    var { randomBytes, createHash: createHash7 } = __require("crypto");
     var { Duplex, Readable: Readable2 } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -2944,7 +2944,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash6("sha1").update(key + GUID).digest("base64");
+        const digest = createHash7("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -3313,7 +3313,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter = __require("events");
     var http = __require("http");
     var { Duplex } = __require("stream");
-    var { createHash: createHash6 } = __require("crypto");
+    var { createHash: createHash7 } = __require("crypto");
     var extension2 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -3620,7 +3620,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash6("sha1").update(key + GUID).digest("base64");
+        const digest = createHash7("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -8283,10 +8283,183 @@ function collectInventory() {
 }
 
 // src/handlers/commands.ts
-import { spawn } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
 import { chmod as chmod2, mkdtemp, realpath, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
 import { homedir as homedir2, tmpdir } from "node:os";
 import { join as join2 } from "node:path";
+
+// src/command-processes.ts
+import { createHash as createHash3 } from "node:crypto";
+
+// src/capture-command.ts
+import { spawn } from "node:child_process";
+var MAX_OUTPUT_BYTES = 2 * 1024 * 1024;
+function captureCommand(options) {
+  if (options.signal.aborted || options.timeoutMs <= 0) {
+    return Promise.resolve({
+      exitCode: null,
+      signal: null,
+      timedOut: !options.signal.aborted,
+      cancelled: options.signal.aborted,
+      stdout: "",
+      stderr: ""
+    });
+  }
+  return new Promise((resolve8, reject) => {
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    let cancelled = false;
+    let settled = false;
+    let killTimer = null;
+    const child = spawn(options.command, options.args, {
+      shell: false,
+      stdio: [
+        "ignore",
+        options.stdoutFileDescriptor === void 0 ? "pipe" : options.stdoutFileDescriptor,
+        "pipe"
+      ],
+      env: options.env ?? process.env,
+      cwd: options.cwd
+    });
+    const append = (current, chunk) => `${current}${String(chunk)}`.slice(0, MAX_OUTPUT_BYTES);
+    child.stdout?.on("data", (chunk) => {
+      stdout = append(stdout, chunk);
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr = append(stderr, chunk);
+    });
+    const terminate = () => {
+      if (child.exitCode !== null || child.killed) return;
+      child.kill("SIGTERM");
+      killTimer = setTimeout(() => {
+        if (child.exitCode === null) child.kill("SIGKILL");
+      }, 5e3);
+      killTimer.unref();
+    };
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      terminate();
+    }, options.timeoutMs);
+    timeout.unref();
+    const abort = () => {
+      cancelled = true;
+      terminate();
+    };
+    options.signal.addEventListener("abort", abort, { once: true });
+    if (options.signal.aborted) abort();
+    child.once("error", (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      if (killTimer) clearTimeout(killTimer);
+      options.signal.removeEventListener("abort", abort);
+      reject(error);
+    });
+    child.once("close", (exitCode, signal) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      if (killTimer) clearTimeout(killTimer);
+      options.signal.removeEventListener("abort", abort);
+      resolve8({
+        exitCode,
+        signal,
+        timedOut,
+        cancelled,
+        stdout,
+        stderr
+      });
+    });
+  });
+}
+
+// src/command-processes.ts
+var COMMAND_SCRIPT_PREFIX = "aide-command-";
+var TERMINATE_GRACE_MS = 5e3;
+function commandScriptPrefix(agentId) {
+  const marker = createHash3("sha256").update(agentId).digest("hex").slice(0, 16);
+  return `${COMMAND_SCRIPT_PREFIX}${marker}-`;
+}
+var scriptPattern = (agentId) => `${commandScriptPrefix(agentId)}[^/]*/command\\.sh`;
+function parseCommandProcesses(output, ownPid) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const line of output.split("\n")) {
+    const [rawPid, rawGroup] = line.trim().split(/\s+/);
+    const pid = Number(rawPid);
+    const processGroup = Number(rawGroup);
+    if (!Number.isInteger(pid) || !Number.isInteger(processGroup)) continue;
+    if (processGroup <= 1 || pid <= 1) continue;
+    if (pid === ownPid || processGroup === ownPid) continue;
+    const known = groups.get(processGroup);
+    if (!known || pid === processGroup) {
+      groups.set(processGroup, { pid, processGroup });
+    }
+  }
+  return [...groups.values()];
+}
+async function listCommandProcesses(agentId, signal) {
+  const found = await captureCommand({
+    command: "/usr/bin/pgrep",
+    args: ["-f", scriptPattern(agentId)],
+    timeoutMs: 5e3,
+    signal
+  });
+  const pids = found.stdout.split("\n").map((line) => line.trim()).filter((line) => /^\d+$/.test(line));
+  if (!pids.length) return [];
+  const described = await captureCommand({
+    command: "/bin/ps",
+    args: ["-o", "pid=,pgid=", "-p", pids.join(",")],
+    timeoutMs: 5e3,
+    signal
+  });
+  return parseCommandProcesses(described.stdout, process.pid);
+}
+function signalGroup(processGroup, name) {
+  try {
+    process.kill(-processGroup, name);
+    return true;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ESRCH") {
+      return false;
+    }
+    console.error(
+      `Could not signal orphaned command process group ${processGroup}:`,
+      error instanceof Error ? error.message : error
+    );
+    return false;
+  }
+}
+async function reapOrphanedCommandProcesses(agentId, signal = new AbortController().signal) {
+  if (process.platform === "win32") return [];
+  let orphans;
+  try {
+    orphans = await listCommandProcesses(agentId, signal);
+  } catch (error) {
+    console.error(
+      "Could not look for orphaned command processes:",
+      error instanceof Error ? error.message : error
+    );
+    return [];
+  }
+  const signalled = orphans.filter(
+    (orphan) => signalGroup(orphan.processGroup, "SIGTERM")
+  );
+  if (!signalled.length) return [];
+  console.error(
+    `Terminating ${signalled.length} command process(es) left by a previous agent run.`
+  );
+  await new Promise((resolve8) => {
+    const timer = setTimeout(resolve8, TERMINATE_GRACE_MS);
+    timer.unref();
+    if (signal.aborted) resolve8();
+    else signal.addEventListener("abort", () => resolve8(), { once: true });
+  });
+  for (const orphan of signalled) signalGroup(orphan.processGroup, "SIGKILL");
+  return signalled;
+}
+
+// src/handlers/commands.ts
 var MAX_BATCH_BYTES = 128 * 1024;
 var FLUSH_DELAY_MS = 25;
 var MAX_UPLOAD_ATTEMPTS = 8;
@@ -8295,7 +8468,9 @@ var runCommand = async (rawPayload, _timeoutMs, signal, _onLog, context) => {
   if (!context?.appendCommandOutput) {
     throw new Error("Command output uploader is unavailable");
   }
-  const directory = await mkdtemp(join2(tmpdir(), "aide-command-"));
+  const directory = await mkdtemp(
+    join2(tmpdir(), commandScriptPrefix(context.agentId))
+  );
   const scriptPath = join2(directory, "command.sh");
   await writeFile2(scriptPath, payload.script, {
     encoding: "utf8",
@@ -8382,7 +8557,7 @@ var runCommand = async (rawPayload, _timeoutMs, signal, _onLog, context) => {
     return await new Promise((resolve8, reject) => {
       let cancelled = false;
       let settled = false;
-      const child = spawn(process.env.SHELL || "/bin/sh", ["-l", scriptPath], {
+      const child = spawn2(process.env.SHELL || "/bin/sh", ["-l", scriptPath], {
         cwd,
         detached: process.platform !== "win32",
         env: {
@@ -8466,7 +8641,7 @@ import { readFile as readFile3, realpath as realpath3, stat as stat3 } from "nod
 import { join as join4, relative as relative4, sep as sep4 } from "node:path";
 
 // src/handlers/builds.ts
-import { createHash as createHash4, randomUUID } from "node:crypto";
+import { createHash as createHash5, randomUUID } from "node:crypto";
 import {
   cp,
   mkdir as mkdir2,
@@ -8643,91 +8818,8 @@ function parsePlist(xml) {
   return parseValue(xml, from, 0)[0];
 }
 
-// src/capture-command.ts
-import { spawn as spawn2 } from "node:child_process";
-var MAX_OUTPUT_BYTES = 2 * 1024 * 1024;
-function captureCommand(options) {
-  if (options.signal.aborted || options.timeoutMs <= 0) {
-    return Promise.resolve({
-      exitCode: null,
-      signal: null,
-      timedOut: !options.signal.aborted,
-      cancelled: options.signal.aborted,
-      stdout: "",
-      stderr: ""
-    });
-  }
-  return new Promise((resolve8, reject) => {
-    let stdout = "";
-    let stderr = "";
-    let timedOut = false;
-    let cancelled = false;
-    let settled = false;
-    let killTimer = null;
-    const child = spawn2(options.command, options.args, {
-      shell: false,
-      stdio: [
-        "ignore",
-        options.stdoutFileDescriptor === void 0 ? "pipe" : options.stdoutFileDescriptor,
-        "pipe"
-      ],
-      env: options.env ?? process.env,
-      cwd: options.cwd
-    });
-    const append = (current, chunk) => `${current}${String(chunk)}`.slice(0, MAX_OUTPUT_BYTES);
-    child.stdout?.on("data", (chunk) => {
-      stdout = append(stdout, chunk);
-    });
-    child.stderr?.on("data", (chunk) => {
-      stderr = append(stderr, chunk);
-    });
-    const terminate = () => {
-      if (child.exitCode !== null || child.killed) return;
-      child.kill("SIGTERM");
-      killTimer = setTimeout(() => {
-        if (child.exitCode === null) child.kill("SIGKILL");
-      }, 5e3);
-      killTimer.unref();
-    };
-    const timeout = setTimeout(() => {
-      timedOut = true;
-      terminate();
-    }, options.timeoutMs);
-    timeout.unref();
-    const abort = () => {
-      cancelled = true;
-      terminate();
-    };
-    options.signal.addEventListener("abort", abort, { once: true });
-    if (options.signal.aborted) abort();
-    child.once("error", (error) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timeout);
-      if (killTimer) clearTimeout(killTimer);
-      options.signal.removeEventListener("abort", abort);
-      reject(error);
-    });
-    child.once("close", (exitCode, signal) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timeout);
-      if (killTimer) clearTimeout(killTimer);
-      options.signal.removeEventListener("abort", abort);
-      resolve8({
-        exitCode,
-        signal,
-        timedOut,
-        cancelled,
-        stdout,
-        stderr
-      });
-    });
-  });
-}
-
 // src/git-code-state.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 import { createReadStream as createReadStream2 } from "node:fs";
 import { lstat, readlink } from "node:fs/promises";
 import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve2, sep as sep2 } from "node:path";
@@ -8854,7 +8946,7 @@ async function worktreeCodeStateHash(folder, timeoutMs, signal) {
     if (head.exitCode !== 0 || untracked.exitCode !== 0 || submodules.exitCode !== 0 || operation.signal.aborted) {
       return null;
     }
-    const hash = createHash3("sha256");
+    const hash = createHash4("sha256");
     hash.update("head\0");
     hash.update(head.stdout.trim());
     hash.update("\0diff\0");
@@ -10209,7 +10301,7 @@ async function fileChecksum(path) {
   try {
     const information = await stat2(path);
     if (!information.isFile()) return null;
-    const hash = createHash4("sha256");
+    const hash = createHash5("sha256");
     await pipeline(createReadStream3(path), hash);
     return hash.digest("hex");
   } catch {
@@ -11563,7 +11655,7 @@ var importCoverageReport = async (payloadValue, timeoutMs, signal, onLog) => {
 };
 
 // src/handlers/signing.ts
-import { createHash as createHash5, randomUUID as randomUUID2, X509Certificate } from "node:crypto";
+import { createHash as createHash6, randomUUID as randomUUID2, X509Certificate } from "node:crypto";
 import {
   mkdir as mkdir3,
   mkdtemp as mkdtemp3,
@@ -11656,7 +11748,7 @@ function certificateFingerprints(value) {
     try {
       const der = Buffer.from(encoded.replace(/\s+/g, ""), "base64");
       if (!der.length) return [];
-      return [createHash5("sha1").update(der).digest("hex").toUpperCase()];
+      return [createHash6("sha1").update(der).digest("hex").toUpperCase()];
     } catch {
       return [];
     }
@@ -11737,7 +11829,7 @@ function profileAsset(decoded, now) {
   const createdAt = text(decoded.raw.CreationDate);
   return {
     uuid: profile.uuid,
-    contentHash: createHash5("sha256").update(decoded.content).digest("hex").toUpperCase(),
+    contentHash: createHash6("sha256").update(decoded.content).digest("hex").toUpperCase(),
     name: profile.name,
     profileType: profile.type,
     bundleId: profile.bundleId,
@@ -12031,7 +12123,7 @@ var readSigningProfile = async (payload, timeoutMs, signal) => {
     ...successfulProcess3,
     uuid,
     contentBase64: profile.content.toString("base64"),
-    sha256: createHash5("sha256").update(profile.content).digest("hex").toUpperCase()
+    sha256: createHash6("sha256").update(profile.content).digest("hex").toUpperCase()
   };
 };
 var installSigningProfile = async (payload, timeoutMs, signal) => {
@@ -12073,7 +12165,7 @@ var importSigningIdentity = async (payload, timeoutMs, signal, _onLog, context)
   }
   const secret = await context.claimSigningSecretTransfer(input.transferId);
   const p12 = Buffer.from(secret.p12Base64, "base64");
-  const hash = createHash5("sha256").update(p12).digest("hex").toUpperCase();
+  const hash = createHash6("sha256").update(p12).digest("hex").toUpperCase();
   if (hash !== input.sha256)
     throw new Error("Signing identity transfer changed");
   const temporaryRoot = await mkdtemp3(join5(tmpdir3(), "ade-identity-"));
@@ -16754,6 +16846,7 @@ var JobExecutor = class {
         controller.signal,
         (log) => this.client.appendLog(claimed.id, log).then(() => void 0),
         {
+          agentId: claimed.agentId,
           reportWorktreeActivity: (input) => this.client.reportWorktreeActivity(input),
           reportBuildProgress: (input) => this.client.reportBuildProgress(input),
           appendBuildLogChunks: (buildId, chunks) => this.client.appendBuildLogChunks(buildId, chunks),
@@ -51097,6 +51190,7 @@ async function prepareDevelopmentAgent(options, signal, dependencies = defaultDe
 }
 async function runDevelopmentAgent(options, signal) {
   const config = await prepareDevelopmentAgent(options, signal);
+  await reapOrphanedCommandProcesses(config.agentId, signal);
   await runAgent(config, signal);
 }
 
@@ -51369,7 +51463,9 @@ async function main() {
           controller.signal
         );
       }
-      return await runAgent(await loadConfig(), controller.signal);
+      const config = await loadConfig();
+      await reapOrphanedCommandProcesses(config.agentId, controller.signal);
+      return await runAgent(config, controller.signal);
     } finally {
       for (const signal of shutdownSignals) process.off(signal, stop2);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-development-environment/control-agent",
-  "version": "0.0.78",
+  "version": "0.0.79",
   "description": "Control agent for the AI Development Environment",
   "license": "MIT",
   "repository": {