@gtkx/utils 1.6.0 → 2.0.0-beta.10

package/src/process/kill-process-group.ts

@@ -0,0 +1,105 @@
+import { lstatSync, rmSync } from "node:fs";
+import { isAbsolute, resolve } from "node:path";
+import { readProcessStatFields } from "./process-status.ts";
+
+type ProcessGroupIdentity = {
+    processGroupId: number;
+    leaderStartTime: string;
+};
+
+type CleanupDirectoryIdentity = {
+    path: string;
+    device: string;
+    inode: string;
+    userId: string;
+};
+
+const isProcessGroupId = (value: number): boolean => Number.isSafeInteger(value) && value > 1;
+
+const processGroupIdentity = (processGroupId: number): ProcessGroupIdentity | undefined => {
+    if (!isProcessGroupId(processGroupId)) {
+        return undefined;
+    }
+
+    const fields = readProcessStatFields(processGroupId);
+
+    if (fields === undefined) {
+        return undefined;
+    }
+
+    const actualProcessGroupId = Number(fields[2]);
+    const sessionId = Number(fields[3]);
+    const leaderStartTime = fields[19];
+
+    return actualProcessGroupId === processGroupId && sessionId === processGroupId && leaderStartTime !== undefined
+        ? { processGroupId, leaderStartTime }
+        : undefined;
+};
+
+const isCurrentProcessGroup = (identity: ProcessGroupIdentity): boolean => {
+    const current = processGroupIdentity(identity.processGroupId);
+
+    return current?.leaderStartTime === identity.leaderStartTime;
+};
+
+const killProcessGroup = (identity: ProcessGroupIdentity, signal: NodeJS.Signals = "SIGKILL"): void => {
+    if (!isCurrentProcessGroup(identity)) {
+        return;
+    }
+
+    try {
+        process.kill(-identity.processGroupId, signal);
+    } catch {
+        return;
+    }
+};
+
+const cleanupDirectoryIdentity = (path: string): CleanupDirectoryIdentity | undefined => {
+    const absolutePath = resolve(path);
+
+    if (absolutePath === "/" || !isAbsolute(path)) {
+        return undefined;
+    }
+
+    try {
+        const entry = lstatSync(absolutePath, { bigint: true });
+
+        return entry.isDirectory()
+            ? {
+                    path: absolutePath,
+                    device: entry.dev.toString(),
+                    inode: entry.ino.toString(),
+                    userId: entry.uid.toString(),
+                }
+            : undefined;
+    } catch {
+        return undefined;
+    }
+};
+
+const removeCleanupDirectory = (identity: CleanupDirectoryIdentity): void => {
+    const current = cleanupDirectoryIdentity(identity.path);
+
+    if (
+        current?.device !== identity.device ||
+        current.inode !== identity.inode ||
+        current.userId !== identity.userId
+    ) {
+        return;
+    }
+
+    try {
+        rmSync(identity.path, { recursive: true, force: true });
+    } catch {
+        return;
+    }
+};
+
+export {
+    type CleanupDirectoryIdentity,
+    cleanupDirectoryIdentity,
+    killProcessGroup,
+    type ProcessGroupIdentity,
+    processGroupIdentity,
+    removeCleanupDirectory,
+};

package/src/process/process-guard.ts

@@ -1,20 +1,275 @@
-import { killMarkedProcesses } from "./kill-marked-processes.ts";
+import { readFileSync } from "node:fs";
+import { killMarkedProcesses, killMarkedProcessRun } from "./kill-marked-processes.ts";
+import {
+    type CleanupDirectoryIdentity,
+    killProcessGroup,
+    type ProcessGroupIdentity,
+    processGroupIdentity,
+    removeCleanupDirectory,
+} from "./kill-process-group.ts";
 
 const GUARD_PREFIX = process.argv[2] ?? "";
+const PROCESS_WATCH_ARGUMENT = process.argv[3];
 const WATCHED_SIGNALS = ["SIGTERM", "SIGINT", "SIGHUP"] as const satisfies NodeJS.Signals[];
+const OWNER_POLL_INTERVAL_MS = 50;
+const SUPERVISOR_EXIT_TIMEOUT_MS = 2000;
 
-const sweep = (): void => {
+type ProcessIdentity = {
+    pid: number;
+    startTime: string;
+};
+
+type ProcessWatch = {
+    owner: ProcessIdentity;
+    target: ProcessIdentity;
+};
+
+type GuardJob = {
+    marker: string;
+    processGroup: ProcessGroupIdentity;
+    cleanupDirectories: CleanupDirectoryIdentity[];
+    signal: NodeJS.Signals;
+};
+
+const state: { bufferedCommands: string; isSweeping: boolean; jobs: Map<string, GuardJob> } = {
+    bufferedCommands: "",
+    isSweeping: false,
+    jobs: new Map(),
+};
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+    typeof value === "object" && value !== null && !Array.isArray(value);
+
+const isProcessIdentity = (value: unknown): value is ProcessIdentity =>
+    isRecord(value) &&
+    typeof value.pid === "number" &&
+    Number.isSafeInteger(value.pid) &&
+    value.pid > 1 &&
+    typeof value.startTime === "string" &&
+    /^\d+$/.test(value.startTime);
+
+const isProcessWatch = (value: unknown): value is ProcessWatch =>
+    isRecord(value) && isProcessIdentity(value.owner) && isProcessIdentity(value.target);
+
+const isProcessGroupIdentity = (value: unknown): value is ProcessGroupIdentity =>
+    isRecord(value) &&
+    typeof value.processGroupId === "number" &&
+    Number.isSafeInteger(value.processGroupId) &&
+    value.processGroupId > 1 &&
+    typeof value.leaderStartTime === "string" &&
+    /^\d+$/.test(value.leaderStartTime);
+
+const isCleanupDirectoryIdentity = (value: unknown): value is CleanupDirectoryIdentity =>
+    isRecord(value) &&
+    typeof value.path === "string" &&
+    typeof value.device === "string" &&
+    typeof value.inode === "string" &&
+    typeof value.userId === "string";
+
+const isGuardJob = (value: unknown): value is GuardJob =>
+    isRecord(value) &&
+    typeof value.marker === "string" &&
+    isProcessGroupIdentity(value.processGroup) &&
+    Array.isArray(value.cleanupDirectories) &&
+    value.cleanupDirectories.every(isCleanupDirectoryIdentity) &&
+    (value.signal === "SIGKILL" || value.signal === "SIGCONT");
+
+const parseProcessWatch = (): ProcessWatch | undefined => {
+    if (PROCESS_WATCH_ARGUMENT === undefined) {
+        return undefined;
+    }
+
+    try {
+        const value: unknown = JSON.parse(PROCESS_WATCH_ARGUMENT);
+
+        return isProcessWatch(value) ? value : undefined;
+    } catch {
+        return undefined;
+    }
+};
+
+const currentProcessIdentity = (pid: number): ProcessIdentity | undefined => {
+    try {
+        const stat = readFileSync(`/proc/${String(pid)}/stat`, "utf8");
+        const fields = stat.slice(stat.lastIndexOf(") ") + 2).split(" ", 20);
+        const state = fields[0];
+        const startTime = fields[19];
+
+        return startTime !== undefined && state !== undefined && !["Z", "X", "x"].includes(state)
+            ? { pid, startTime }
+            : undefined;
+    } catch {
+        return undefined;
+    }
+};
+
+const isCurrentProcess = (identity: ProcessIdentity): boolean =>
+    currentProcessIdentity(identity.pid)?.startTime === identity.startTime;
+
+const killProcess = (identity: ProcessIdentity): void => {
+    if (!isCurrentProcess(identity)) {
+        return;
+    }
+
+    try {
+        process.kill(identity.pid, "SIGKILL");
+    } catch {
+        return;
+    }
+};
+
+const applyCommand = (command: string): void => {
+    const operation = command[0];
+    let value: unknown;
+
+    try {
+        value = JSON.parse(command.slice(1));
+    } catch {
+        return;
+    }
+
+    if (!isGuardJob(value)) {
+        return;
+    }
+
+    if (operation === "+") {
+        state.jobs.set(value.marker, value);
+    } else if (operation === "-") {
+        state.jobs.delete(value.marker);
+    }
+};
+
+const receiveCommands = (chunk: Buffer | string): void => {
+    state.bufferedCommands += chunk.toString();
+    const commands = state.bufferedCommands.split("\n");
+    state.bufferedCommands = commands.pop() ?? "";
+
+    for (const command of commands) {
+        applyCommand(command);
+    }
+};
+
+const killJobs = (): void => {
+    for (const job of state.jobs.values()) {
+        killProcessGroup(job.processGroup, job.signal);
+
+        if (job.signal === "SIGKILL") {
+            killMarkedProcesses(job.marker);
+        }
+    }
+};
+
+const removeCleanupDirectories = (): void => {
+    const cleanupDirectories: Map<string, CleanupDirectoryIdentity> = new Map();
+
+    for (const job of state.jobs.values()) {
+        for (const identity of job.cleanupDirectories) {
+            cleanupDirectories.set(`${identity.device}:${identity.inode}`, identity);
+        }
+    }
+
+    for (const identity of cleanupDirectories.values()) {
+        removeCleanupDirectory(identity);
+    }
+};
+
+const hasRunningSupervisor = (): boolean => {
+    for (const job of state.jobs.values()) {
+        if (job.signal !== "SIGCONT") {
+            continue;
+        }
+
+        const current = processGroupIdentity(job.processGroup.processGroupId);
+
+        if (current?.leaderStartTime === job.processGroup.leaderStartTime) {
+            return true;
+        }
+    }
+
+    return false;
+};
+
+const forceSupervisors = (): void => {
+    for (const job of state.jobs.values()) {
+        if (job.signal === "SIGCONT") {
+            killProcessGroup(job.processGroup);
+        }
+    }
+};
+
+const finishSweep = (): void => {
     if (GUARD_PREFIX.length > 0) {
-        killMarkedProcesses(GUARD_PREFIX);
+        killMarkedProcessRun(GUARD_PREFIX);
     }
 
+    removeCleanupDirectories();
     process.exit(0);
 };
 
+const awaitSupervisors = (deadline: number): void => {
+    if (hasRunningSupervisor() && Date.now() < deadline) {
+        setTimeout(() => {
+            awaitSupervisors(deadline);
+        }, OWNER_POLL_INTERVAL_MS);
+
+        return;
+    }
+
+    forceSupervisors();
+    finishSweep();
+};
+
+const sweep = (target?: ProcessIdentity): void => {
+    if (state.isSweeping) {
+        return;
+    }
+
+    state.isSweeping = true;
+    applyCommand(state.bufferedCommands);
+
+    if (target !== undefined) {
+        killProcess(target);
+    }
+
+    killJobs();
+    awaitSupervisors(Date.now() + SUPERVISOR_EXIT_TIMEOUT_MS);
+};
+
+const watch = parseProcessWatch();
+
+const startOwnerPoll = (): void => {
+    if (watch === undefined) {
+        return;
+    }
+
+    const ownerPoll = setInterval(() => {
+        if (isCurrentProcess(watch.owner)) {
+            return;
+        }
+
+        clearInterval(ownerPoll);
+        sweep(watch.target);
+    }, OWNER_POLL_INTERVAL_MS);
+
+    if (!isCurrentProcess(watch.owner)) {
+        clearInterval(ownerPoll);
+        sweep(watch.target);
+    }
+};
+
+startOwnerPoll();
+
 process.stdin.resume();
-process.stdin.on("end", sweep);
-process.stdin.on("error", sweep);
+process.stdin.on("data", receiveCommands);
+process.stdin.on("end", () => {
+    sweep();
+});
+process.stdin.on("error", () => {
+    sweep();
+});
 
 for (const signal of WATCHED_SIGNALS) {
-    process.on(signal, sweep);
+    process.on(signal, () => {
+        sweep();
+    });
 }

package/src/process/process-status.ts

@@ -0,0 +1,25 @@
+import { readFileSync } from "node:fs";
+
+const REAPED_STATES: ReadonlySet<string> = new Set(["Z", "X", "x"]);
+
+const readProcessStatFields = (pid: number): string[] | undefined => {
+    if (!Number.isSafeInteger(pid) || pid <= 0) {
+        return undefined;
+    }
+
+    try {
+        const stat = readFileSync(`/proc/${String(pid)}/stat`, "utf8");
+        const separator = stat.lastIndexOf(") ");
+
+        return separator === -1 ? undefined : stat.slice(separator + 2).split(" ");
+    } catch {
+        return undefined;
+    }
+};
+
+const isReapedState = (state: string | undefined): boolean => state === undefined || REAPED_STATES.has(state);
+
+const isProcessAlive = (pid: number | undefined): boolean =>
+    pid !== undefined && pid > 1 && !isReapedState(readProcessStatFields(pid)?.[0]);
+
+export { isProcessAlive, isReapedState, readProcessStatFields };

package/src/process/resolve-executable.ts

@@ -1,50 +1,8 @@
-import { accessSync, constants, statSync } from "node:fs";
-import { delimiter, isAbsolute, join, resolve } from "node:path";
+import which from "which";
 
-const isExecutable = (path: string): boolean => {
-    try {
-        accessSync(path, constants.X_OK);
+const tryResolveExecutable = (command: string): string | undefined =>
+    which.sync(command, { nothrow: true }) ?? undefined;
 
-        return statSync(path).isFile();
-    } catch {
-        return false;
-    }
-};
-
-const findOnPath = (command: string): string | undefined => {
-    const searchPaths = (process.env.PATH ?? "").split(delimiter).filter((entry) => entry.length > 0);
-
-    for (const directory of searchPaths) {
-        const candidate = join(directory, command);
-
-        if (isExecutable(candidate)) {
-            return candidate;
-        }
-    }
-
-    return undefined;
-};
-
-function tryResolveExecutable(command: string): string | undefined {
-    if (isAbsolute(command)) {
-        return command;
-    }
-
-    if (command.includes("/")) {
-        return resolve(command);
-    }
-
-    return findOnPath(command);
-}
-
-function resolveExecutable(command: string): string {
-    const found = tryResolveExecutable(command);
-
-    if (found === undefined) {
-        throw new Error(`Cannot find the "${command}" executable on PATH`);
-    }
-
-    return found;
-}
+const resolveExecutable = (command: string): string => which.sync(command);
 
 export { resolveExecutable, tryResolveExecutable };