grepmax 0.23.0 → 0.25.0

package/dist/lib/utils/operation-coordinator.js

@@ -0,0 +1,146 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperationCoordinator = exports.OperationClosedError = exports.OperationBusyError = void 0;
+class OperationBusyError extends Error {
+    constructor(operation) {
+        super(`daemon busy: exclusive operation ${operation} is pending`);
+        this.code = "DAEMON_BUSY";
+        this.name = "OperationBusyError";
+    }
+}
+exports.OperationBusyError = OperationBusyError;
+class OperationClosedError extends Error {
+    constructor(message = "daemon is closing") {
+        super(message);
+        this.code = "DAEMON_CLOSING";
+        this.name = "OperationClosedError";
+    }
+}
+exports.OperationClosedError = OperationClosedError;
+function abortError(reason) {
+    if (reason instanceof Error)
+        return reason;
+    const error = new Error("Aborted");
+    error.name = "AbortError";
+    return error;
+}
+class OperationCoordinator {
+    constructor() {
+        this.state = { kind: "open" };
+        this.controllers = new Set();
+        this.activeTasks = new Set();
+        this.sharedTasks = new Set();
+        this.closePromise = null;
+    }
+    get status() {
+        return this.state.kind;
+    }
+    get activeCount() {
+        return this.activeTasks.size;
+    }
+    runShared(_name, signal, fn) {
+        try {
+            this.assertSharedAdmission();
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        const controller = new AbortController();
+        const unlink = this.linkSignal(signal, controller);
+        this.controllers.add(controller);
+        const task = (() => __awaiter(this, void 0, void 0, function* () {
+            if (controller.signal.aborted) {
+                throw abortError(controller.signal.reason);
+            }
+            return fn(controller.signal);
+        }))();
+        this.activeTasks.add(task);
+        this.sharedTasks.add(task);
+        const cleanup = () => {
+            unlink();
+            this.controllers.delete(controller);
+            this.activeTasks.delete(task);
+            this.sharedTasks.delete(task);
+        };
+        void task.then(cleanup, cleanup);
+        return task;
+    }
+    runExclusive(name, quiesce, fn) {
+        if (this.state.kind === "closing" || this.state.kind === "closed") {
+            return Promise.reject(new OperationClosedError());
+        }
+        if (this.state.kind !== "open") {
+            const current = "name" in this.state ? this.state.name : "unknown operation";
+            return Promise.reject(new OperationBusyError(current));
+        }
+        this.state = { kind: "exclusive-pending", name };
+        const controller = new AbortController();
+        this.controllers.add(controller);
+        const task = (() => __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield quiesce();
+                yield Promise.allSettled([...this.sharedTasks]);
+                if (controller.signal.aborted) {
+                    throw abortError(controller.signal.reason);
+                }
+                if (this.state.kind === "closing" || this.state.kind === "closed") {
+                    throw new OperationClosedError();
+                }
+                this.state = { kind: "exclusive", name };
+                return yield fn(controller.signal);
+            }
+            finally {
+                this.controllers.delete(controller);
+                if (this.state.kind === "exclusive" ||
+                    this.state.kind === "exclusive-pending") {
+                    this.state = { kind: "open" };
+                }
+            }
+        }))();
+        this.activeTasks.add(task);
+        const cleanup = () => this.activeTasks.delete(task);
+        void task.then(cleanup, cleanup);
+        return task;
+    }
+    close(reason = new OperationClosedError()) {
+        if (this.closePromise)
+            return this.closePromise;
+        this.state = { kind: "closing" };
+        for (const controller of this.controllers)
+            controller.abort(reason);
+        const tasks = [...this.activeTasks];
+        this.closePromise = Promise.allSettled(tasks).then(() => {
+            this.state = { kind: "closed" };
+        });
+        return this.closePromise;
+    }
+    assertSharedAdmission() {
+        if (this.state.kind === "closing" || this.state.kind === "closed") {
+            throw new OperationClosedError();
+        }
+        if (this.state.kind === "exclusive" ||
+            this.state.kind === "exclusive-pending") {
+            throw new OperationBusyError(this.state.name);
+        }
+    }
+    linkSignal(source, target) {
+        if (!source)
+            return () => { };
+        const abort = () => target.abort(source.reason);
+        if (source.aborted)
+            abort();
+        else
+            source.addEventListener("abort", abort, { once: true });
+        return () => source.removeEventListener("abort", abort);
+    }
+}
+exports.OperationCoordinator = OperationCoordinator;

package/dist/lib/utils/path-containment.js

@@ -0,0 +1,106 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathContainmentError = void 0;
+exports.isPathWithin = isPathWithin;
+exports.resolveContainedPath = resolveContainedPath;
+exports.resolveContainedFile = resolveContainedFile;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+class PathContainmentError extends Error {
+    constructor(root, candidate) {
+        super(`Path is outside project root: ${candidate}`);
+        this.root = root;
+        this.candidate = candidate;
+        this.code = "PATH_OUTSIDE_PROJECT";
+        this.name = "PathContainmentError";
+    }
+}
+exports.PathContainmentError = PathContainmentError;
+function isWithinResolved(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return (relative === "" ||
+        (relative !== ".." &&
+            !relative.startsWith(`..${path.sep}`) &&
+            !path.isAbsolute(relative)));
+}
+function isPathWithin(root, candidate) {
+    return isWithinResolved(path.resolve(root), path.resolve(candidate));
+}
+function canonicalizeExistingPath(candidate) {
+    let existing = candidate;
+    while (!fs.existsSync(existing)) {
+        const parent = path.dirname(existing);
+        if (parent === existing)
+            return candidate;
+        existing = parent;
+    }
+    const canonicalExisting = fs.realpathSync(existing);
+    const remainder = path.relative(existing, candidate);
+    return path.resolve(canonicalExisting, remainder);
+}
+function resolveContainedPath(root, input, options = {}) {
+    if (input.includes("\0")) {
+        throw new PathContainmentError(path.resolve(root), input);
+    }
+    const resolvedRoot = path.resolve(root);
+    const candidate = path.isAbsolute(input)
+        ? path.resolve(input)
+        : path.resolve(resolvedRoot, input);
+    if (!isWithinResolved(resolvedRoot, candidate) ||
+        (options.allowRoot === false && candidate === resolvedRoot)) {
+        throw new PathContainmentError(resolvedRoot, candidate);
+    }
+    if (options.verifyExistingTarget) {
+        const canonicalRoot = fs.realpathSync(resolvedRoot);
+        const canonicalCandidate = canonicalizeExistingPath(candidate);
+        if (!isWithinResolved(canonicalRoot, canonicalCandidate)) {
+            throw new PathContainmentError(resolvedRoot, candidate);
+        }
+    }
+    return candidate;
+}
+/** Resolve an existing regular file and return its canonical, contained path. */
+function resolveContainedFile(root, input) {
+    const candidate = resolveContainedPath(root, input);
+    const resolvedRoot = path.resolve(root);
+    const canonicalRoot = fs.realpathSync(resolvedRoot);
+    const canonicalCandidate = fs.realpathSync(candidate);
+    if (!isWithinResolved(canonicalRoot, canonicalCandidate) ||
+        !fs.statSync(canonicalCandidate).isFile()) {
+        throw new PathContainmentError(resolvedRoot, candidate);
+    }
+    return canonicalCandidate;
+}

package/dist/lib/utils/process.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.killProcess = killProcess;
+exports.terminateProcessGroup = terminateProcessGroup;
 const watcher_store_1 = require("./watcher-store");
 /**
  * Send SIGTERM, wait up to 3s, then SIGKILL if still alive.
@@ -43,3 +44,46 @@ function killProcess(pid) {
         return !(0, watcher_store_1.isProcessRunning)(pid);
     });
 }
+function isProcessGroupRunning(pgid) {
+    try {
+        process.kill(-pgid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+function terminateProcessGroup(pgid_1) {
+    return __awaiter(this, arguments, void 0, function* (pgid, options = {}) {
+        var _a, _b;
+        const termTimeoutMs = (_a = options.termTimeoutMs) !== null && _a !== void 0 ? _a : 3000;
+        const killTimeoutMs = (_b = options.killTimeoutMs) !== null && _b !== void 0 ? _b : 1000;
+        try {
+            process.kill(-pgid, "SIGTERM");
+        }
+        catch (error) {
+            if (error.code === "ESRCH")
+                return true;
+            return false;
+        }
+        const waitForExit = (timeoutMs) => __awaiter(this, void 0, void 0, function* () {
+            const attempts = Math.max(1, Math.ceil(timeoutMs / 100));
+            for (let i = 0; i < attempts; i++) {
+                if (!isProcessGroupRunning(pgid))
+                    return true;
+                yield new Promise((resolve) => setTimeout(resolve, 100));
+            }
+            return !isProcessGroupRunning(pgid);
+        });
+        if (yield waitForExit(termTimeoutMs))
+            return true;
+        try {
+            process.kill(-pgid, "SIGKILL");
+        }
+        catch (error) {
+            if (error.code === "ESRCH")
+                return true;
+        }
+        return waitForExit(killTimeoutMs);
+    });
+}