local-commander-agent-linux-arm64 0.0.0-stage → 0.3.46

package/runtime/job-host.mjs

@@ -0,0 +1,543 @@
+// agent/posix/job-host.mjs
+import { spawn, execFile as execFile2 } from "node:child_process";
+import { readFile, lstat, mkdtemp, writeFile, rm, realpath } from "node:fs/promises";
+import { promisify as promisify2 } from "node:util";
+import { randomUUID } from "node:crypto";
+import { fileURLToPath } from "node:url";
+import net from "node:net";
+import os from "node:os";
+import path2 from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+
+// src/child-environment.ts
+var COMMON_ALLOWED_KEYS = /* @__PURE__ */ new Set([
+  "PATH",
+  "TEMP",
+  "TMP",
+  "TMPDIR",
+  "HOME",
+  "USER",
+  "USERNAME",
+  "LOGNAME",
+  "LANG",
+  "LC_ALL",
+  "LC_CTYPE",
+  "TERM",
+  "COLORTERM",
+  "NO_COLOR",
+  "FORCE_COLOR",
+  "CI",
+  "DOTNET_ROOT",
+  "DOTNET_CLI_HOME"
+]);
+var WINDOWS_ALLOWED_KEYS = /* @__PURE__ */ new Set([
+  "PATHEXT",
+  "SYSTEMROOT",
+  "WINDIR",
+  "COMSPEC",
+  "USERPROFILE",
+  "HOMEDRIVE",
+  "HOMEPATH",
+  "APPDATA",
+  "LOCALAPPDATA",
+  "PROGRAMFILES",
+  "PROGRAMFILES(X86)",
+  "PROGRAMW6432",
+  "PROCESSOR_ARCHITECTURE",
+  "PROCESSOR_ARCHITEW6432",
+  "NUMBER_OF_PROCESSORS",
+  "OS",
+  "USERDOMAIN",
+  "PUBLIC"
+]);
+var POSIX_ALLOWED_KEYS = /* @__PURE__ */ new Set([
+  "SHELL",
+  "XDG_CACHE_HOME",
+  "XDG_CONFIG_HOME",
+  "XDG_DATA_HOME"
+]);
+var DENIED_KEYS = /* @__PURE__ */ new Set([
+  "NODE_OPTIONS",
+  "PYTHONPATH",
+  "PYTHONHOME",
+  "PYTHONSTARTUP",
+  "RUBYOPT",
+  "PERL5OPT",
+  "LD_PRELOAD",
+  "LD_LIBRARY_PATH",
+  "DYLD_INSERT_LIBRARIES",
+  "DYLD_LIBRARY_PATH",
+  "GIT_SSH_COMMAND",
+  "GIT_ASKPASS",
+  "SSH_ASKPASS",
+  "NPM_CONFIG_USERCONFIG"
+]);
+var DENIED_SUBSTRINGS = [
+  "LCMCP",
+  "LOCAL_COMMANDER",
+  "PAYPAL",
+  "SQL",
+  "CONNECTIONSTRING",
+  "CONNECTION_STRING",
+  "PASSWORD",
+  "PASSWD",
+  "SECRET",
+  "TOKEN",
+  "CREDENTIAL",
+  "OPENAI",
+  "ANTHROPIC",
+  "API_KEY",
+  "ACCESS_KEY",
+  "PRIVATE_KEY"
+];
+function canonicalAllowedKeys(platform) {
+  const keys = new Set(COMMON_ALLOWED_KEYS);
+  if (platform === "win32") {
+    for (const key of WINDOWS_ALLOWED_KEYS) keys.add(key);
+  } else {
+    for (const key of POSIX_ALLOWED_KEYS) keys.add(key);
+  }
+  const result = /* @__PURE__ */ new Map();
+  for (const key of keys) result.set(platform === "win32" ? key.toUpperCase() : key, key);
+  return result;
+}
+function isDeniedKey(key) {
+  const upper = key.toUpperCase();
+  if (DENIED_KEYS.has(upper)) return true;
+  return DENIED_SUBSTRINGS.some((item) => upper.includes(item));
+}
+function buildChildEnvironment(source, platform = process.platform) {
+  const allowed = canonicalAllowedKeys(platform);
+  const result = {};
+  const seen = /* @__PURE__ */ new Set();
+  for (const [rawKey, value] of Object.entries(source)) {
+    if (value === void 0) continue;
+    const lookupKey = platform === "win32" ? rawKey.toUpperCase() : rawKey;
+    const outputKey = allowed.get(lookupKey);
+    if (!outputKey) continue;
+    if (isDeniedKey(rawKey) || isDeniedKey(outputKey)) continue;
+    if (seen.has(lookupKey)) continue;
+    seen.add(lookupKey);
+    result[outputKey] = value;
+  }
+  return result;
+}
+
+// agent/src/linux-containment.ts
+import { execFile } from "node:child_process";
+import path from "node:path";
+import { promisify } from "node:util";
+var uuid = "[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}";
+var unitName = new RegExp("^lc-command-" + uuid + "\\.service$");
+var bootId = new RegExp("^" + uuid + "$");
+function validLinuxContainment(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const v = value;
+  return Object.keys(v).length === 5 && Number.isInteger(v.uid) && v.uid > 0 && v.uid <= 4294967295 && typeof v.unit === "string" && unitName.test(v.unit) && typeof v.bootId === "string" && bootId.test(v.bootId) && typeof v.invocationId === "string" && /^[0-9a-f]{32}$/.test(v.invocationId) && !/^0+$/.test(v.invocationId) && typeof v.cgroup === "string" && v.cgroup.length <= 2048 && !v.cgroup.includes("\0") && v.cgroup.startsWith("/user.slice/user-" + v.uid + ".slice/user@" + v.uid + ".service/") && path.posix.normalize(v.cgroup) === v.cgroup && path.posix.basename(v.cgroup) === v.unit;
+}
+var exec = promisify(execFile);
+
+// agent/posix/job-host.mjs
+var exec2 = promisify2(execFile2);
+var env = buildChildEnvironment(process.env);
+if (process.platform === "linux") {
+  env.XDG_RUNTIME_DIR = "/run/user/" + process.getuid();
+  env.DBUS_SESSION_BUS_ADDRESS = "unix:path=" + env.XDG_RUNTIME_DIR + "/bus";
+}
+var unit = "lc-command-" + randomUUID() + ".service";
+var forcedExit;
+var approve;
+var stage = "REQUEST";
+var runner;
+var cgroup;
+var started = false;
+var cancelled = false;
+var timedOut = false;
+var failed = false;
+var finished = false;
+var timer;
+var emit = (value) => process.stdout.write(JSON.stringify(value) + "\n");
+var control = (args) => exec2(
+  "/usr/bin/systemctl",
+  ["--user", "--no-ask-password", ...args, unit],
+  { env, timeout: 2e3, maxBuffer: 8192, encoding: "utf8" }
+);
+var stop = async () => {
+  try {
+    await control(["stop"]);
+  } catch {
+  }
+};
+var cancel = () => {
+  if (!finished) {
+    cancelled = true;
+    approve?.(false);
+    approve = void 0;
+    void stop();
+    forcedExit ??= setTimeout(() => process.exit(1), 2500);
+  }
+};
+process.stdin.on("end", cancel);
+process.on("SIGTERM", cancel);
+process.on("SIGINT", cancel);
+process.stdout.on("error", () => {
+  failed = true;
+  cancel();
+});
+function packet(args, childEnv) {
+  const pieces = [], number = (n) => {
+    const b = Buffer.alloc(4);
+    b.writeUInt32BE(n);
+    pieces.push(b);
+  };
+  const strings = (values) => {
+    number(values.length);
+    for (const value of values) {
+      const b = Buffer.from(value);
+      if (b.length > 32768 || value.includes("\0")) throw Error();
+      number(b.length);
+      pieces.push(b);
+    }
+  };
+  strings(args);
+  strings(Object.entries(childEnv).map(([key, value]) => key + "=" + value));
+  const data = Buffer.concat(pieces);
+  if (data.length > 262144) throw Error();
+  return data;
+}
+async function emptyGroup() {
+  if (!cgroup) return false;
+  try {
+    return /(?:^|\n)populated 0(?:\n|$)/.test(await readFile(cgroup + "/cgroup.events", "utf8"));
+  } catch (e) {
+    return e.code === "ENOENT";
+  }
+}
+function validRequest(request) {
+  if (!process.getuid() || process.getuid() !== process.geteuid()) throw Error();
+  const { executable, args, cwd, timeoutMs, maxProcesses } = request;
+  const absolute = (value) => typeof value === "string" && path2.isAbsolute(value) && path2.resolve(value) === value && !value.includes("\0");
+  if (!absolute(executable) || !absolute(cwd) || !Array.isArray(args) || args.length > 128 || args.some((x) => typeof x !== "string" || x.length > 8192 || x.includes("\0")) || !Number.isInteger(timeoutMs) || timeoutMs < 100 || timeoutMs > 864e5 || !Number.isInteger(maxProcesses) || maxProcesses < 1 || maxProcesses > 128) throw Error();
+  return { executable, args, cwd, timeoutMs, maxProcesses };
+}
+async function verifiedBridge() {
+  const bridge = fileURLToPath(new URL("./posix-host", import.meta.url));
+  stage = "BRIDGE";
+  const stat = await lstat(bridge);
+  if (!stat.isFile() || stat.isSymbolicLink() || stat.mode & 18 || stat.uid !== 0 && stat.uid !== process.getuid()) throw Error();
+  if (cancelled) throw Error();
+  return bridge;
+}
+async function execute(request) {
+  if (process.platform === "darwin") return executeDarwin(request);
+  if (process.platform !== "linux") throw Error();
+  const { executable, args, cwd, timeoutMs, maxProcesses } = validRequest(request);
+  const payload = packet([executable, ...args], buildChildEnvironment(process.env));
+  const bridge = await verifiedBridge();
+  stage = "CGROUP";
+  runner = spawn(
+    "/usr/bin/systemd-run",
+    [
+      "--user",
+      "--no-ask-password",
+      "--quiet",
+      "--wait",
+      "--pipe",
+      "--collect",
+      "--expand-environment=no",
+      "--unit=" + unit,
+      "--description=Local Commander bounded command",
+      "--service-type=exec",
+      "--working-directory=" + cwd,
+      "--property=TasksMax=" + maxProcesses,
+      "--property=KillMode=control-group",
+      "--property=SendSIGKILL=yes",
+      "--property=TimeoutStopSec=1s",
+      "--property=RuntimeMaxSec=" + (timeoutMs + 5e3) / 1e3,
+      "--",
+      bridge
+    ],
+    { env, stdio: ["pipe", "pipe", "pipe"], shell: false }
+  );
+  let runnerClosed = false, prefix = Buffer.alloc(0);
+  const closed = new Promise((resolve, reject) => {
+    runner.once("error", reject);
+    runner.once("close", (code2) => {
+      runnerClosed = true;
+      resolve(code2);
+    });
+  });
+  void closed.catch(() => {
+  });
+  const output = (stream, bytes) => {
+    for (let i = 0; i < bytes.length; i += 4096) {
+      if (!emit({ type: stream, data: bytes.subarray(i, i + 4096).toString("base64") })) {
+        runner.stdout.pause();
+        runner.stderr.pause();
+      }
+    }
+  };
+  process.stdout.on("drain", () => {
+    runner.stdout.resume();
+    runner.stderr.resume();
+  });
+  runner.stdout.on("data", (bytes) => {
+    if (!started) {
+      prefix = Buffer.concat([prefix, bytes]);
+      const newline = prefix.indexOf(10);
+      if (newline < 0) {
+        if (prefix.length > 32) {
+          failed = true;
+          cancel();
+        }
+        return;
+      }
+      const text = prefix.subarray(0, newline).toString();
+      if (!/^[1-9][0-9]{0,9}$/.test(text)) {
+        failed = true;
+        cancel();
+        return;
+      }
+      started = true;
+      emit({ type: "started", pid: Number(text) });
+      bytes = prefix.subarray(newline + 1);
+      prefix = Buffer.alloc(0);
+    }
+    output("stdout", bytes);
+  });
+  runner.stderr.on("data", (bytes) => output("stderr", bytes));
+  runner.stdin.on("error", () => {
+    failed = true;
+    void stop();
+  });
+  const bootId2 = (await readFile("/proc/sys/kernel/random/boot_id", "utf8")).trim();
+  let containment;
+  const setupDeadline = Date.now() + 4e3;
+  while (!cgroup && !runnerClosed && !cancelled && Date.now() < setupDeadline) {
+    try {
+      const { stdout } = await control(["show", "--property=ControlGroup", "--property=TasksMax", "--property=ActiveState", "--property=InvocationID"]);
+      const fields = Object.fromEntries(stdout.trim().split("\n").map((line) => {
+        const i = line.indexOf("=");
+        return [line.slice(0, i), line.slice(i + 1)];
+      }));
+      const proof = { uid: process.getuid(), unit, cgroup: fields.ControlGroup, bootId: bootId2, invocationId: fields.InvocationID };
+      if (fields.ActiveState === "active" && fields.TasksMax === String(maxProcesses) && validLinuxContainment(proof)) {
+        const directory = "/sys/fs/cgroup" + fields.ControlGroup;
+        if ((await readFile(directory + "/pids.max", "utf8")).trim() === String(maxProcesses)) {
+          cgroup = directory;
+          containment = proof;
+        }
+      }
+    } catch {
+    }
+    if (!cgroup) await delay(25);
+  }
+  if (!cgroup || cancelled || runnerClosed) {
+    await stop();
+    throw Error();
+  }
+  const approval = new Promise((resolve) => {
+    approve = resolve;
+  });
+  emit({ type: "containment", containment });
+  const approved = await Promise.race([approval, delay(1e4, false, { ref: false })]);
+  approve = void 0;
+  if (!approved || cancelled || runnerClosed) {
+    await stop();
+    throw Error();
+  }
+  timer = setTimeout(() => {
+    timedOut = true;
+    void stop();
+    forcedExit ??= setTimeout(() => process.exit(1), 2500);
+  }, timeoutMs);
+  stage = "EXECUTION";
+  runner.stdin.end(payload);
+  const code = await closed;
+  clearTimeout(timer);
+  await stop();
+  stage = "CLEANUP";
+  if (failed || !started || !Number.isInteger(code) || !await emptyGroup()) throw Error();
+  finished = true;
+  emit({ type: "exit", exitCode: code, timedOut, cancelled, treeTerminated: true });
+}
+var xml = (value) => String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+async function executeDarwin(request) {
+  const { executable, args, cwd, timeoutMs, maxProcesses } = validRequest(request);
+  const uid = process.getuid();
+  const payload = packet([executable, ...args], buildChildEnvironment(process.env));
+  const bridge = await verifiedBridge();
+  const helper = async (...values) => (await exec2(bridge, values, { env, timeout: 7e3, maxBuffer: 1024, encoding: "utf8" })).stdout.trim();
+  const launchctl = (values) => exec2("/bin/launchctl", values, { env, timeout: 5e3, maxBuffer: 65536, encoding: "utf8" });
+  const own = await helper("--coalition", String(process.pid));
+  const bootSession = (await exec2("/usr/sbin/sysctl", ["-n", "kern.bootsessionuuid"], { env, timeout: 2e3, maxBuffer: 1024, encoding: "utf8" })).stdout.trim();
+  if (!/^[1-9][0-9]{0,19}$/.test(own) || cancelled) throw Error();
+  stage = "CGROUP";
+  const directory = await mkdtemp(path2.join(await realpath(os.tmpdir()), "lc-"));
+  const socketPath = path2.join(directory, "s"), plist = path2.join(directory, "job.plist");
+  const label = "app.localcmd.command." + randomUUID(), job = "gui/" + uid + "/" + label;
+  const roles = /* @__PURE__ */ new Map();
+  let lines = "", hello, code, empty, coalition, loaded = false, sent = false, reaping;
+  const streams = () => [roles.get("o"), roles.get("e")].filter(Boolean);
+  const output = (stream, bytes) => {
+    for (let i = 0; i < bytes.length; i += 4096) {
+      if (!emit({ type: stream, data: bytes.subarray(i, i + 4096).toString("base64") })) for (const s of streams()) s.pause();
+    }
+  };
+  process.stdout.on("drain", () => {
+    for (const s of streams()) s.resume();
+  });
+  const reject = () => {
+    failed = true;
+    cancel();
+  };
+  const onControl = (bytes) => {
+    lines += bytes.toString("latin1");
+    if (lines.length > 256) {
+      reject();
+      return;
+    }
+    for (let i; (i = lines.indexOf("\n")) >= 0; ) {
+      const line = lines.slice(0, i);
+      lines = lines.slice(i + 1);
+      let m;
+      if (!hello && (m = /^hello ([1-9][0-9]{0,9}) ([1-9][0-9]{0,19})$/.exec(line))) hello = { pid: Number(m[1]), coalition: m[2] };
+      else if (sent && !started && (m = /^started ([1-9][0-9]{0,9})$/.exec(line))) {
+        started = true;
+        emit({ type: "started", pid: Number(m[1]) });
+      } else if (sent && code === void 0 && (m = /^exit ([0-9]{1,3})$/.exec(line))) code = Number(m[1]);
+      else if (code !== void 0 && empty === void 0 && (m = /^empty ([01])$/.exec(line))) empty = m[1] === "1";
+      else {
+        reject();
+        return;
+      }
+    }
+  };
+  const server = net.createServer((socket) => {
+    socket.on("error", () => {
+    });
+    const claim = () => {
+      const role = socket.read(1);
+      if (role === null) {
+        socket.once("readable", claim);
+        return;
+      }
+      const name = role.toString("latin1");
+      if (!["c", "o", "e"].includes(name) || roles.has(name)) {
+        socket.destroy();
+        reject();
+        return;
+      }
+      roles.set(name, socket);
+      socket.on("data", name === "c" ? onControl : (bytes) => output(name === "o" ? "stdout" : "stderr", bytes));
+    };
+    socket.once("readable", claim);
+  });
+  stop = async () => {
+    const controlSocket = roles.get("c");
+    if (sent && controlSocket && !controlSocket.destroyed) controlSocket.write("k", () => {
+    });
+    if (coalition && !finished) reaping ??= delay(800).then(() => finished ? void 0 : helper("--reap", coalition).catch(() => {
+    }));
+    await reaping;
+  };
+  try {
+    await new Promise((resolve, fail) => {
+      server.once("error", fail);
+      server.listen(socketPath, resolve);
+    });
+    await writeFile(plist, '<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n<plist version="1.0"><dict><key>Label</key><string>' + xml(label) + "</string><key>ProgramArguments</key><array>" + [bridge, "--launchd", socketPath, String(maxProcesses), String(timeoutMs)].map((v) => "<string>" + xml(v) + "</string>").join("") + "</array><key>WorkingDirectory</key><string>" + xml(cwd) + "</string><key>RunAtLoad</key><true/><key>LaunchOnlyOnce</key><true/><key>KeepAlive</key><false/><key>ProcessType</key><string>Interactive</string></dict></plist>\n", { mode: 384, flag: "wx" });
+    if (cancelled) throw Error();
+    await launchctl(["bootstrap", "gui/" + uid, plist]);
+    loaded = true;
+    const setupDeadline = Date.now() + 4e3;
+    while (!(hello && roles.size === 3) && !cancelled && !failed && Date.now() < setupDeadline) await delay(25);
+    if (!hello || roles.size !== 3 || cancelled || failed) throw Error();
+    const printed = /^\tpid = ([1-9][0-9]{0,9})$/m.exec((await launchctl(["print", job])).stdout);
+    if (!printed || Number(printed[1]) !== hello.pid || hello.coalition === own || await helper("--coalition", String(hello.pid)) !== hello.coalition) throw Error();
+    coalition = hello.coalition;
+    if (cancelled) throw Error();
+    const approval = new Promise((resolve) => {
+      approve = resolve;
+    });
+    emit({ type: "containment", containment: { uid, label, coalition, bootSession } });
+    const approved = await Promise.race([approval, delay(1e4, false, { ref: false })]);
+    approve = void 0;
+    if (!approved || cancelled || failed) throw Error();
+    const closed = new Promise((resolve) => roles.get("c").once("close", resolve));
+    const drained = Promise.all(streams().map((s) => new Promise((resolve) => s.once("close", resolve))));
+    timer = setTimeout(() => {
+      timedOut = true;
+      void stop();
+      forcedExit ??= setTimeout(() => process.exit(1), 2500);
+    }, timeoutMs);
+    stage = "EXECUTION";
+    sent = true;
+    roles.get("c").write(payload);
+    await closed;
+    clearTimeout(timer);
+    await Promise.race([drained, delay(2e3)]);
+    stage = "CLEANUP";
+  } finally {
+    if (coalition) await helper("--reap", coalition).catch(() => {
+      failed = true;
+    });
+    if (loaded) await launchctl(["bootout", job]).catch(() => {
+    });
+    server.close();
+    for (const socket of roles.values()) socket.destroy();
+    await rm(directory, { recursive: true, force: true });
+  }
+  if (failed || !started || code === void 0 || empty !== true || await helper("--count", coalition) !== "0") throw Error();
+  finished = true;
+  emit({ type: "exit", exitCode: code, timedOut, cancelled, treeTerminated: true });
+}
+var buffer = "";
+var received = false;
+var deadline = setTimeout(() => {
+  failed = true;
+  cancel();
+  process.exitCode = 1;
+  process.stdin.destroy();
+}, 15e3);
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (chunk) => {
+  buffer += chunk;
+  if (Buffer.byteLength(buffer) > 65536) {
+    failed = true;
+    cancel();
+    return;
+  }
+  for (; ; ) {
+    const index = buffer.indexOf("\n");
+    if (index < 0) break;
+    const line = buffer.slice(0, index);
+    buffer = buffer.slice(index + 1);
+    if (received) {
+      if (line === "cancel") cancel();
+      else if (line === "continue" && approve) {
+        const accept = approve;
+        approve = void 0;
+        accept(true);
+      } else {
+        failed = true;
+        cancel();
+      }
+      continue;
+    }
+    received = true;
+    clearTimeout(deadline);
+    Promise.resolve().then(() => execute(JSON.parse(line))).catch(async () => {
+      failed = true;
+      await stop();
+      emit({ type: "error", stage });
+      process.exit(1);
+    }).finally(() => {
+      clearTimeout(timer);
+      clearTimeout(deadline);
+      clearTimeout(forcedExit);
+      finished = true;
+      process.stdin.destroy();
+    });
+  }
+});