@anusornneal/chat-relay 0.7.2 → 0.8.1

package/agent/macos-desktop-helper.js

@@ -0,0 +1,243 @@
+ObjC.import("AppKit");
+ObjC.import("CoreGraphics");
+
+function ok(extra) {
+  return Object.assign({ ok: true }, extra || {});
+}
+
+function fail(error) {
+  return { ok: false, error: String(error || "input_failed") };
+}
+
+function screenInfo() {
+  $.NSApplication.sharedApplication;
+  const screens = $.NSScreen.screens;
+  const count = Number(screens.count);
+  if (!count) return fail("session_unavailable");
+  const primary = screens.objectAtIndex(0);
+  const primaryHeight = Number(primary.frame.size.height);
+  const output = [];
+
+  for (let i = 0; i < count; i += 1) {
+    const screen = screens.objectAtIndex(i);
+    const frame = screen.frame;
+    const x = Number(frame.origin.x);
+    const nsY = Number(frame.origin.y);
+    const width = Number(frame.size.width);
+    const height = Number(frame.size.height);
+    output.push({
+      index: i,
+      x,
+      y: primaryHeight - (nsY + height),
+      width,
+      height,
+      scaleFactor: Number(screen.backingScaleFactor || 1),
+      isPrimary: i === 0,
+      deviceName: "Display " + (i + 1),
+    });
+  }
+
+  const minX = Math.min.apply(null, output.map((item) => item.x));
+  const minY = Math.min.apply(null, output.map((item) => item.y));
+  const maxX = Math.max.apply(null, output.map((item) => item.x + item.width));
+  const maxY = Math.max.apply(null, output.map((item) => item.y + item.height));
+
+  return ok({
+    screens: output,
+    virtualDesktopOriginX: minX,
+    virtualDesktopOriginY: minY,
+    virtualDesktopWidth: maxX - minX,
+    virtualDesktopHeight: maxY - minY,
+  });
+}
+
+function modifierList(input) {
+  const result = [];
+  if (input.ctrl) result.push("control down");
+  if (input.alt) result.push("option down");
+  if (input.shift) result.push("shift down");
+  if (input.win) result.push("command down");
+  return result;
+}
+
+function keyboardInput(input) {
+  const system = Application("System Events");
+  const modifiers = modifierList(input);
+  const options = modifiers.length === 0
+    ? {}
+    : { using: modifiers.length === 1 ? modifiers[0] : modifiers };
+
+  if (typeof input.text === "string") {
+    system.keystroke(input.text);
+    return ok();
+  }
+
+  const key = String(input.key || "").toLowerCase();
+  const special = {
+    enter: 36,
+    tab: 48,
+    escape: 53,
+    backspace: 51,
+    delete: 117,
+    arrowleft: 123,
+    arrowup: 126,
+    arrowright: 124,
+    arrowdown: 125,
+    home: 115,
+    end: 119,
+    pageup: 116,
+    pagedown: 121,
+    space: 49,
+    f1: 122,
+    f2: 120,
+    f3: 99,
+    f4: 118,
+    f5: 96,
+    f6: 97,
+    f7: 98,
+    f8: 100,
+    f9: 101,
+    f10: 109,
+    f11: 103,
+    f12: 111,
+  };
+
+  if (Object.prototype.hasOwnProperty.call(special, key)) {
+    system.keyCode(special[key], options);
+    return ok();
+  }
+
+  if (/^[a-z0-9]$/.test(key)) {
+    system.keystroke(key, options);
+    return ok();
+  }
+
+  return fail("unsupported_key");
+}
+
+function mouseClick(input) {
+  const info = screenInfo();
+  if (!info.ok) return info;
+  const x = Number(input.x);
+  const y = Number(input.y);
+  const contains = info.screens.some((screen) =>
+    x >= screen.x && x < screen.x + screen.width &&
+    y >= screen.y && y < screen.y + screen.height
+  );
+  if (!contains) return fail("invalid_coordinates");
+
+  const button = String(input.button || "left");
+  let mouseButton = $.kCGMouseButtonLeft;
+  let downType = $.kCGEventLeftMouseDown;
+  let upType = $.kCGEventLeftMouseUp;
+  if (button === "right") {
+    mouseButton = $.kCGMouseButtonRight;
+    downType = $.kCGEventRightMouseDown;
+    upType = $.kCGEventRightMouseUp;
+  } else if (button === "middle") {
+    mouseButton = $.kCGMouseButtonCenter;
+    downType = $.kCGEventOtherMouseDown;
+    upType = $.kCGEventOtherMouseUp;
+  } else if (button !== "left") {
+    return fail("invalid_button");
+  }
+
+  const point = $.CGPointMake(x, y);
+  const count = Number(input.clicks || 1);
+  for (let i = 0; i < count; i += 1) {
+    const down = $.CGEventCreateMouseEvent($(), downType, point, mouseButton);
+    const up = $.CGEventCreateMouseEvent($(), upType, point, mouseButton);
+    if (!down || !up) return fail("input_failed");
+    if (count > 1) {
+      const clickState = i + 1;
+      $.CGEventSetIntegerValueField(down, $.kCGMouseEventClickState, clickState);
+      $.CGEventSetIntegerValueField(up, $.kCGMouseEventClickState, clickState);
+    }
+    $.CGEventPost($.kCGHIDEventTap, down);
+    $.CGEventPost($.kCGHIDEventTap, up);
+    $.CFRelease(down);
+    $.CFRelease(up);
+    if (i + 1 < count) $.NSThread.sleepForTimeInterval(0.08);
+  }
+  return ok();
+}
+
+function windowList(input) {
+  const limit = Math.max(1, Math.min(100, Number(input.limit || 50)));
+  const system = Application("System Events");
+  const processes = system.applicationProcesses();
+  const windows = [];
+
+  for (let p = 0; p < processes.length && windows.length < limit; p += 1) {
+    const processRef = processes[p];
+    let pid;
+    let items;
+    try {
+      pid = Number(processRef.unixId());
+      items = processRef.windows();
+    } catch (_) {
+      continue;
+    }
+
+    for (let i = 0; i < items.length && windows.length < limit; i += 1) {
+      const windowRef = items[i];
+      try {
+        const position = windowRef.position();
+        const size = windowRef.size();
+        const title = String(windowRef.name() || "");
+        const width = Number(size[0]);
+        const height = Number(size[1]);
+        if (!(width > 0 && height > 0)) continue;
+        windows.push({
+          windowId: String(pid * 10000 + i + 1),
+          processId: pid,
+          title,
+          x: Number(position[0]),
+          y: Number(position[1]),
+          width,
+          height,
+          isForeground: processRef.frontmost() === true,
+        });
+      } catch (_) {}
+    }
+  }
+
+  return ok({ windows, count: windows.length });
+}
+
+function windowFocus(input) {
+  const encoded = Number(input.windowId);
+  if (!Number.isFinite(encoded) || encoded <= 0) return fail("invalid_window_id");
+  const pid = Math.floor(encoded / 10000);
+  const index = (encoded % 10000) - 1;
+  if (!(pid > 0 && index >= 0)) return fail("invalid_window_id");
+
+  const system = Application("System Events");
+  const matches = system.applicationProcesses.whose({ unixId: pid });
+  if (!matches.length) return fail("window_not_found");
+  const processRef = matches[0];
+  const items = processRef.windows();
+  if (index >= items.length) return fail("window_not_found");
+
+  processRef.frontmost = true;
+  try {
+    const action = items[index].actions.byName("AXRaise");
+    action.perform();
+  } catch (_) {}
+  return ok();
+}
+
+function run(argv) {
+  try {
+    const operation = String(argv[0] || "");
+    const input = argv[1] ? JSON.parse(argv[1]) : {};
+    if (operation === "screen_info") return JSON.stringify(screenInfo());
+    if (operation === "keyboard_input") return JSON.stringify(keyboardInput(input));
+    if (operation === "mouse_click") return JSON.stringify(mouseClick(input));
+    if (operation === "window_list") return JSON.stringify(windowList(input));
+    if (operation === "window_focus") return JSON.stringify(windowFocus(input));
+    return JSON.stringify(fail("unsupported_operation"));
+  } catch (error) {
+    return JSON.stringify(fail(error && error.message ? error.message : "input_failed"));
+  }
+}

package/agent/macos-desktop-runner.mjs

@@ -0,0 +1,292 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { execFile, spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { randomUUID } from "node:crypto";
+
+const MAX_SCREENSHOT_BINARY_BYTES = 32 * 1024;
+const DEFAULT_TIMEOUT_MS = 15_000;
+const helperPath = path.join(path.dirname(fileURLToPath(import.meta.url)), "macos-desktop-helper.js");
+
+function execNative(file, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    execFile(file, args, {
+      timeout: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+      maxBuffer: options.maxBuffer ?? 512 * 1024,
+      encoding: "utf8",
+    }, (error, stdout, stderr) => {
+      if (error) {
+        reject(new Error(String(stderr || error.message).trim()));
+        return;
+      }
+      resolve(String(stdout || ""));
+    });
+  });
+}
+
+function writeNative(file, args, input, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(file, args, { stdio: ["pipe", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    const timer = setTimeout(() => {
+      try { child.kill("SIGKILL"); } catch {}
+      reject(new Error("native_command_timeout"));
+    }, options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    child.stdout.on("data", (chunk) => { stdout += String(chunk); });
+    child.stderr.on("data", (chunk) => { stderr += String(chunk); });
+    child.on("error", (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+    child.on("exit", (code) => {
+      clearTimeout(timer);
+      if (code === 0) resolve(stdout);
+      else reject(new Error(stderr.trim() || "native_command_failed"));
+    });
+    child.stdin.end(input);
+  });
+}
+
+function parseSipsSize(output) {
+  const width = Number(/pixelWidth:\s*(\d+)/.exec(output)?.[1] || 0);
+  const height = Number(/pixelHeight:\s*(\d+)/.exec(output)?.[1] || 0);
+  return { width, height };
+}
+
+export class MacOSDesktopRunner {
+  constructor(options = {}) {
+    this.platform = options.platform ?? process.platform;
+    this.timeoutMs = Number(options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+  }
+
+  async #jxa(operation, args = {}) {
+    try {
+      const stdout = await execNative("/usr/bin/osascript", [
+        "-l", "JavaScript", helperPath, operation, JSON.stringify(args),
+      ], { timeoutMs: this.timeoutMs });
+      const line = stdout.trim().split(/\r?\n/).filter(Boolean).at(-1);
+      const result = line ? JSON.parse(line) : { ok: false, error: "desktop_helper_error" };
+      if (result?.ok === false && /not authorized|assistive|accessibility|(-1743)|(-25211)/i.test(String(result.error || ""))) {
+        return { ok: false, error: "accessibility_permission_required" };
+      }
+      return result;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "";
+      if (/not authorized|assistive|accessibility|(-1743)/i.test(message)) {
+        return { ok: false, error: "accessibility_permission_required" };
+      }
+      return { ok: false, error: "desktop_helper_error" };
+    }
+  }
+
+  async #screenInfo() {
+    return this.#jxa("screen_info", {});
+  }
+
+  async #screenshot(args = {}) {
+    const screenshotStartedAt = Date.now();
+    const info = await this.#screenInfo();
+    if (!info?.ok || !Array.isArray(info.screens) || info.screens.length === 0) {
+      return info?.ok === false ? info : { ok: false, error: "capture_failed" };
+    }
+
+    const requested = args.monitor ?? "primary";
+    let index;
+    if (requested === "primary") index = 0;
+    else if (requested === "secondary") index = 1;
+    else index = Number(requested);
+    if (!Number.isInteger(index) || index < 0 || index >= info.screens.length) {
+      return { ok: false, error: "monitor_not_found" };
+    }
+
+    const screen = info.screens[index];
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), "chat-relay-shot-"));
+    const source = path.join(dir, "source.jpg");
+    const output = path.join(dir, "output.jpg");
+    try {
+      const captureStartedAt = Date.now();
+      await execNative("/usr/sbin/screencapture", ["-x", "-D", String(index + 1), "-t", "jpg", source], {
+        timeoutMs: this.timeoutMs,
+      }).catch((error) => {
+        const message = error instanceof Error ? error.message : "";
+        if (/screen recording|permission|not authorized/i.test(message)) throw new Error("screen_recording_permission_required");
+        throw error;
+      });
+      const captureMs = Math.max(0, Date.now() - captureStartedAt);
+      const encodeStartedAt = Date.now();
+
+      const originalInfo = parseSipsSize(await execNative("/usr/bin/sips", [
+        "-g", "pixelWidth", "-g", "pixelHeight", source,
+      ]));
+      if (!(originalInfo.width > 0 && originalInfo.height > 0)) {
+        return { ok: false, error: "capture_failed" };
+      }
+
+      let targetWidth = Math.min(Number(args.maxWidth || 960), originalInfo.width);
+      const requestedQuality = Math.max(20, Math.min(85, Number(args.quality || 58)));
+      const qualities = [...new Set([requestedQuality, 55, 45, 35, 25, 20].filter((q) => q <= requestedQuality))];
+      let data = null;
+      let finalWidth = 0;
+      let finalHeight = 0;
+      let finalQuality = requestedQuality;
+
+      for (let attempt = 0; attempt < 5 && !data; attempt += 1) {
+        for (const quality of qualities) {
+          await fs.rm(output, { force: true });
+          await execNative("/usr/bin/sips", [
+            "-Z", String(Math.max(320, Math.round(targetWidth))),
+            "-s", "format", "jpeg",
+            "-s", "formatOptions", String(quality),
+            source,
+            "--out", output,
+          ]);
+          const bytes = await fs.readFile(output);
+          if (bytes.byteLength > 0 && bytes.byteLength <= MAX_SCREENSHOT_BINARY_BYTES) {
+            const resized = parseSipsSize(await execNative("/usr/bin/sips", [
+              "-g", "pixelWidth", "-g", "pixelHeight", output,
+            ]));
+            data = bytes.toString("base64");
+            finalWidth = resized.width;
+            finalHeight = resized.height;
+            finalQuality = quality;
+            break;
+          }
+        }
+        targetWidth = Math.max(320, Math.floor(targetWidth * 0.78));
+      }
+
+      if (!data) return { ok: false, error: "screenshot_too_large" };
+      const scaleX = Number(screen.width) / finalWidth;
+      const scaleY = Number(screen.height) / finalHeight;
+      return {
+        ok: true,
+        mimeType: "image/jpeg",
+        data,
+        width: finalWidth,
+        height: finalHeight,
+        desktopOriginX: Number(screen.x),
+        desktopOriginY: Number(screen.y),
+        desktopWidth: Number(screen.width),
+        desktopHeight: Number(screen.height),
+        scaleX,
+        scaleY,
+        monitorIndex: index,
+        isPrimary: index === 0,
+        deviceName: String(screen.deviceName || ("Display " + (index + 1))),
+        virtualDesktopOriginX: Number(info.virtualDesktopOriginX),
+        virtualDesktopOriginY: Number(info.virtualDesktopOriginY),
+        virtualDesktopWidth: Number(info.virtualDesktopWidth),
+        virtualDesktopHeight: Number(info.virtualDesktopHeight),
+        monitorCount: info.screens.length,
+        jpegQuality: finalQuality,
+        timing: {
+          captureMs,
+          encodeMs: Math.max(0, Date.now() - encodeStartedAt),
+          screenshotTotalMs: Math.max(0, Date.now() - screenshotStartedAt),
+        },
+      };
+    } catch (error) {
+      if (error instanceof Error && error.message === "screen_recording_permission_required") {
+        return { ok: false, error: "screen_recording_permission_required" };
+      }
+      return { ok: false, error: "capture_failed" };
+    } finally {
+      await fs.rm(dir, { recursive: true, force: true }).catch(() => {});
+    }
+  }
+
+  async #clipboardRead() {
+    try {
+      const text = await execNative("/usr/bin/pbpaste", [], { timeoutMs: this.timeoutMs, maxBuffer: 64 * 1024 });
+      return { ok: true, text, truncated: false };
+    } catch {
+      return { ok: false, error: "clipboard_failed" };
+    }
+  }
+
+  async #clipboardWrite(args = {}) {
+    try {
+      await writeNative("/usr/bin/pbcopy", [], String(args.text ?? ""), { timeoutMs: this.timeoutMs });
+      return { ok: true };
+    } catch {
+      return { ok: false, error: "clipboard_failed" };
+    }
+  }
+
+  async #step(args = {}) {
+    const startedAt = Date.now();
+    let inputMs = 0;
+    let explicitWaitMs = 0;
+    let settleMs = 0;
+
+    for (const action of args.actions || []) {
+      if (action.type === "wait") {
+        const waitStartedAt = Date.now();
+        await new Promise((resolve) => setTimeout(resolve, action.ms));
+        explicitWaitMs += Math.max(0, Date.now() - waitStartedAt);
+        continue;
+      }
+
+      const inputStartedAt = Date.now();
+      const result = action.type === "click"
+        ? await this.#jxa("mouse_click", action)
+        : await this.#jxa("keyboard_input", action);
+      inputMs += Math.max(0, Date.now() - inputStartedAt);
+      if (!result?.ok) {
+        return {
+          ...(result || { ok: false, error: "input_failed" }),
+          timing: { inputMs, explicitWaitMs, settleMs, captureMs: 0, encodeMs: 0, workerMs: Math.max(0, Date.now() - startedAt) },
+        };
+      }
+
+      if (Number(action.settleAfterMs) > 0) {
+        const settleStartedAt = Date.now();
+        await new Promise((resolve) => setTimeout(resolve, Number(action.settleAfterMs)));
+        settleMs += Math.max(0, Date.now() - settleStartedAt);
+      }
+    }
+
+    if (Number(args.settleMs) > 0) {
+      const settleStartedAt = Date.now();
+      await new Promise((resolve) => setTimeout(resolve, Number(args.settleMs)));
+      settleMs += Math.max(0, Date.now() - settleStartedAt);
+    }
+
+    if (args.captureAfter !== true) {
+      return {
+        ok: true,
+        timing: { inputMs, explicitWaitMs, settleMs, captureMs: 0, encodeMs: 0, workerMs: Math.max(0, Date.now() - startedAt) },
+      };
+    }
+
+    const screenshot = await this.#screenshot(args);
+    return {
+      ...screenshot,
+      timing: {
+        inputMs,
+        explicitWaitMs,
+        settleMs,
+        captureMs: Number(screenshot?.timing?.captureMs) || 0,
+        encodeMs: Number(screenshot?.timing?.encodeMs) || 0,
+        workerMs: Math.max(0, Date.now() - startedAt),
+      },
+    };
+  }
+
+  async run(operation, args = {}) {
+    if (this.platform !== "darwin") return { ok: false, error: "unsupported_platform" };
+    if (operation === "screenshot") return this.#screenshot(args);
+    if (operation === "clipboard_read") return this.#clipboardRead();
+    if (operation === "clipboard_write") return this.#clipboardWrite(args);
+    if (operation === "window_list") return this.#jxa("window_list", args);
+    if (operation === "window_focus") return this.#jxa("window_focus", args);
+    if (operation === "mouse_click") return this.#jxa("mouse_click", args);
+    if (operation === "keyboard_input") return this.#jxa("keyboard_input", args);
+    if (operation === "step") return this.#step(args);
+    return { ok: false, error: "unsupported_operation" };
+  }
+
+  close() {}
+}

package/agent/process-manager.mjs

@@ -1,37 +1,88 @@
 import { execFile } from "node:child_process";
+import path from "node:path";
 import os from "node:os";
 
-function execPowerShell(script, timeout = 15000) {
+function execCommand(file, args, options = {}) {
   return new Promise((resolve, reject) => {
     execFile(
-      "powershell.exe",
-      ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", script],
-      { timeout, windowsHide: true, maxBuffer: 256 * 1024 },
+      file,
+      args,
+      {
+        timeout: options.timeout ?? 15000,
+        windowsHide: true,
+        maxBuffer: options.maxBuffer ?? 256 * 1024,
+        encoding: "utf8",
+      },
       (error, stdout, stderr) => {
         if (error) {
-          reject(new Error(stderr?.trim() || error.message));
+          reject(new Error(String(stderr || error.message).trim()));
           return;
         }
-        resolve(stdout);
+        resolve(String(stdout || ""));
       },
     );
   });
 }
 
+function execPowerShell(script, timeout = 15000) {
+  return execCommand(
+    "powershell.exe",
+    ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", script],
+    { timeout },
+  );
+}
+
+function parsePosixProcesses(stdout, filter = "") {
+  const query = String(filter || "").toLowerCase();
+  const items = [];
+  for (const line of stdout.split(/\r?\n/)) {
+    const match = /^\s*(\d+)\s+(\d+)\s+(.+)$/.exec(line);
+    if (!match) continue;
+    const processId = Number(match[1]);
+    const parentProcessId = Number(match[2]);
+    const commandLine = match[3].trim();
+    if (!commandLine) continue;
+    const executablePath = commandLine.split(/\s+/)[0] || "";
+    const name = path.basename(executablePath) || executablePath;
+    if (query && !name.toLowerCase().includes(query) && !commandLine.toLowerCase().includes(query)) continue;
+    items.push({
+      ProcessId: processId,
+      ParentProcessId: parentProcessId,
+      Name: name,
+      CommandLine: commandLine,
+      ExecutablePath: executablePath,
+    });
+  }
+  return items;
+}
+
 export class ProcessManager {
+  constructor(options = {}) {
+    this.platform = options.platform ?? process.platform;
+  }
+
   async list(filter = "") {
-    const escaped = String(filter).replace(/'/g, "''");
-    const where = escaped
-      ? ` | Where-Object { $_.Name -like '*${escaped}*' -or $_.CommandLine -like '*${escaped}*' }`
-      : "";
-    const script =
-      "$items = Get-CimInstance Win32_Process" + where +
-      " | Select-Object ProcessId,Name,CommandLine,ExecutablePath;" +
-      "$items | ConvertTo-Json -Compress -Depth 3";
-    const stdout = await execPowerShell(script);
-    if (!stdout.trim()) return [];
-    const parsed = JSON.parse(stdout);
-    return Array.isArray(parsed) ? parsed : [parsed];
+    if (this.platform === "win32") {
+      const escaped = String(filter).replace(/'/g, "''");
+      const where = escaped
+        ? ` | Where-Object { $_.Name -like '*${escaped}*' -or $_.CommandLine -like '*${escaped}*' }`
+        : "";
+      const script =
+        "$items = Get-CimInstance Win32_Process" + where +
+        " | Select-Object ProcessId,Name,CommandLine,ExecutablePath;" +
+        "$items | ConvertTo-Json -Compress -Depth 3";
+      const stdout = await execPowerShell(script);
+      if (!stdout.trim()) return [];
+      const parsed = JSON.parse(stdout);
+      return Array.isArray(parsed) ? parsed : [parsed];
+    }
+
+    if (this.platform === "darwin" || this.platform === "linux") {
+      const stdout = await execCommand("/bin/ps", ["-axo", "pid=,ppid=,command="]);
+      return parsePosixProcesses(stdout, filter);
+    }
+
+    throw new Error("unsupported_platform");
   }
 
   async kill(pid) {
@@ -39,15 +90,46 @@ export class ProcessManager {
     if (!Number.isInteger(value) || value <= 100 || value === process.pid) {
       throw new Error("invalid_or_protected_pid");
     }
-    return new Promise((resolve, reject) => {
-      execFile("taskkill.exe", ["/PID", String(value), "/T", "/F"], { windowsHide: true }, (error, stdout, stderr) => {
-        if (error) {
-          reject(new Error(stderr?.trim() || error.message));
-          return;
-        }
-        resolve({ ok: true, pid: value, output: stdout.trim() });
+
+    if (this.platform === "win32") {
+      return new Promise((resolve, reject) => {
+        execFile("taskkill.exe", ["/PID", String(value), "/T", "/F"], { windowsHide: true }, (error, stdout, stderr) => {
+          if (error) {
+            reject(new Error(stderr?.trim() || error.message));
+            return;
+          }
+          resolve({ ok: true, pid: value, output: stdout.trim() });
+        });
       });
-    });
+    }
+
+    if (this.platform === "darwin" || this.platform === "linux") {
+      const processes = await this.list();
+      const children = new Map();
+      for (const item of processes) {
+        const parent = Number(item.ParentProcessId);
+        const child = Number(item.ProcessId);
+        if (!children.has(parent)) children.set(parent, []);
+        children.get(parent).push(child);
+      }
+      const ordered = [];
+      const visit = (parent) => {
+        for (const child of children.get(parent) || []) {
+          visit(child);
+          ordered.push(child);
+        }
+      };
+      visit(value);
+      ordered.push(value);
+      for (const target of ordered) {
+        try { process.kill(target, "SIGKILL"); } catch (error) {
+          if (target === value && error?.code !== "ESRCH") throw error;
+        }
+      }
+      return { ok: true, pid: value, output: "" };
+    }
+
+    throw new Error("unsupported_platform");
   }
 
   info(extra = {}) {
@@ -67,3 +149,5 @@ export class ProcessManager {
     };
   }
 }
+
+export { parsePosixProcesses };