gsd-pi 2.26.1-next.1 → 2.28.0-dev.346ee62

package/dist/resources/extensions/gsd/semantic-chunker.ts

@@ -0,0 +1,336 @@
+// GSD Extension — Semantic Chunker with TF-IDF Relevance Scoring
+// Splits code/text into semantic chunks and selects the most relevant ones for a given task.
+// Pure TypeScript — no external dependencies.
+
+// ─── Types ──────────────────────────────────────────────────────────────────
+
+export interface Chunk {
+	content: string;
+	startLine: number;
+	endLine: number;
+	score: number;
+}
+
+export interface ChunkResult {
+	chunks: Chunk[];
+	totalChunks: number;
+	omittedChunks: number;
+	savingsPercent: number;
+}
+
+interface ChunkOptions {
+	minLines?: number;
+	maxLines?: number;
+}
+
+interface RelevanceOptions {
+	maxChunks?: number;
+	minChunkLines?: number;
+	maxChunkLines?: number;
+	minScore?: number;
+}
+
+// ─── Constants ──────────────────────────────────────────────────────────────
+
+const CODE_BOUNDARY_RE = /^(export\s+)?(async\s+)?(function|class|interface|type|const|enum)\s/;
+
+const MARKDOWN_HEADING_RE = /^#{1,6}\s/;
+
+const STOP_WORDS = new Set([
+	"the", "a", "an", "is", "are", "was", "were", "be", "to", "of", "in",
+	"for", "on", "with", "at", "by", "from", "this", "that", "it", "as",
+	"or", "and", "not", "but", "if", "do", "no", "so", "up", "its", "has",
+	"had", "get", "set", "can", "may", "all", "use", "new", "one", "two",
+	"also", "each", "than", "been", "into", "most", "only", "over", "such",
+	"how", "some", "any", "our", "his", "her", "out", "did", "let", "say", "she",
+]);
+
+const DEFAULT_MIN_LINES = 3;
+const DEFAULT_MAX_LINES = 80;
+const DEFAULT_MAX_CHUNKS = 5;
+const DEFAULT_MIN_SCORE = 0.1;
+
+// ─── Content Type Detection ─────────────────────────────────────────────────
+
+type ContentType = "code" | "markdown" | "text";
+
+function detectContentType(lines: string[]): ContentType {
+	let codeSignals = 0;
+	let mdSignals = 0;
+	const sampleSize = Math.min(lines.length, 50);
+
+	for (let i = 0; i < sampleSize; i++) {
+		const line = lines[i];
+		if (CODE_BOUNDARY_RE.test(line) || /^\s*import\s/.test(line)) {
+			codeSignals++;
+		}
+		if (MARKDOWN_HEADING_RE.test(line)) {
+			mdSignals++;
+		}
+	}
+
+	if (mdSignals >= 2 && mdSignals > codeSignals) return "markdown";
+	if (codeSignals >= 2) return "code";
+	return "text";
+}
+
+// ─── Tokenizer ──────────────────────────────────────────────────────────────
+
+function tokenize(text: string): string[] {
+	return text
+		.toLowerCase()
+		.split(/[\s\W]+/)
+		.filter((w) => w.length >= 2 && !STOP_WORDS.has(w));
+}
+
+// ─── splitIntoChunks ────────────────────────────────────────────────────────
+
+export function splitIntoChunks(
+	content: string,
+	options?: ChunkOptions,
+): Chunk[] {
+	if (!content || content.trim().length === 0) return [];
+
+	const minLines = options?.minLines ?? DEFAULT_MIN_LINES;
+	const maxLines = options?.maxLines ?? DEFAULT_MAX_LINES;
+	const lines = content.split("\n");
+
+	if (lines.length === 0) return [];
+
+	const contentType = detectContentType(lines);
+	let boundaries: number[];
+
+	switch (contentType) {
+		case "code":
+			boundaries = findCodeBoundaries(lines);
+			break;
+		case "markdown":
+			boundaries = findMarkdownBoundaries(lines);
+			break;
+		default:
+			boundaries = findTextBoundaries(lines);
+			break;
+	}
+
+	// Always include 0 as first boundary
+	if (boundaries.length === 0 || boundaries[0] !== 0) {
+		boundaries.unshift(0);
+	}
+
+	// Build raw chunks from boundaries
+	const rawChunks: Chunk[] = [];
+	for (let i = 0; i < boundaries.length; i++) {
+		const start = boundaries[i];
+		const end = i + 1 < boundaries.length ? boundaries[i + 1] - 1 : lines.length - 1;
+		const chunkLines = lines.slice(start, end + 1);
+		rawChunks.push({
+			content: chunkLines.join("\n"),
+			startLine: start + 1,  // 1-based
+			endLine: end + 1,      // 1-based
+			score: 0,
+		});
+	}
+
+	// Split oversized chunks at maxLines
+	const splitChunks: Chunk[] = [];
+	for (const chunk of rawChunks) {
+		const chunkLineCount = chunk.endLine - chunk.startLine + 1;
+		if (chunkLineCount <= maxLines) {
+			splitChunks.push(chunk);
+		} else {
+			const chunkLines = chunk.content.split("\n");
+			for (let offset = 0; offset < chunkLines.length; offset += maxLines) {
+				const slice = chunkLines.slice(offset, offset + maxLines);
+				splitChunks.push({
+					content: slice.join("\n"),
+					startLine: chunk.startLine + offset,
+					endLine: chunk.startLine + offset + slice.length - 1,
+					score: 0,
+				});
+			}
+		}
+	}
+
+	// Merge tiny chunks into predecessor
+	const merged: Chunk[] = [];
+	for (const chunk of splitChunks) {
+		const chunkLineCount = chunk.endLine - chunk.startLine + 1;
+		if (chunkLineCount < minLines && merged.length > 0) {
+			const prev = merged[merged.length - 1];
+			prev.content += "\n" + chunk.content;
+			prev.endLine = chunk.endLine;
+		} else {
+			merged.push({ ...chunk });
+		}
+	}
+
+	return merged;
+}
+
+function findCodeBoundaries(lines: string[]): number[] {
+	const boundaries: number[] = [];
+	for (let i = 0; i < lines.length; i++) {
+		if (CODE_BOUNDARY_RE.test(lines[i])) {
+			// Also consider a blank line before a boundary marker
+			if (i > 0 && lines[i - 1].trim() === "" && !boundaries.includes(i)) {
+				boundaries.push(i);
+			} else if (!boundaries.includes(i)) {
+				boundaries.push(i);
+			}
+		}
+	}
+	return boundaries;
+}
+
+function findMarkdownBoundaries(lines: string[]): number[] {
+	const boundaries: number[] = [];
+	for (let i = 0; i < lines.length; i++) {
+		if (MARKDOWN_HEADING_RE.test(lines[i])) {
+			boundaries.push(i);
+		}
+	}
+	return boundaries;
+}
+
+function findTextBoundaries(lines: string[]): number[] {
+	const boundaries: number[] = [0];
+	for (let i = 1; i < lines.length; i++) {
+		if (lines[i - 1].trim() === "" && lines[i].trim() !== "") {
+			boundaries.push(i);
+		}
+	}
+	return boundaries;
+}
+
+// ─── scoreChunks ────────────────────────────────────────────────────────────
+
+export function scoreChunks(chunks: Chunk[], query: string): Chunk[] {
+	if (chunks.length === 0) return [];
+
+	const queryTerms = tokenize(query);
+	if (queryTerms.length === 0) {
+		return chunks.map((c) => ({ ...c, score: 0 }));
+	}
+
+	const totalChunks = chunks.length;
+
+	// Pre-compute IDF for each query term
+	const termChunkCounts = new Map<string, number>();
+	const chunkTokenSets: Set<string>[] = [];
+
+	for (const chunk of chunks) {
+		const tokens = new Set(tokenize(chunk.content));
+		chunkTokenSets.push(tokens);
+		for (const term of queryTerms) {
+			if (tokens.has(term)) {
+				termChunkCounts.set(term, (termChunkCounts.get(term) ?? 0) + 1);
+			}
+		}
+	}
+
+	const idf = new Map<string, number>();
+	for (const term of queryTerms) {
+		const df = termChunkCounts.get(term) ?? 0;
+		idf.set(term, Math.log(1 + totalChunks / (1 + df)));
+	}
+
+	// Score each chunk
+	const scored = chunks.map((chunk, idx) => {
+		const chunkTokens = tokenize(chunk.content);
+		const totalTerms = chunkTokens.length;
+		if (totalTerms === 0) return { ...chunk, score: 0 };
+
+		// Count term frequencies
+		const termFreq = new Map<string, number>();
+		for (const token of chunkTokens) {
+			termFreq.set(token, (termFreq.get(token) ?? 0) + 1);
+		}
+
+		let score = 0;
+		for (const term of queryTerms) {
+			const tf = (termFreq.get(term) ?? 0) / totalTerms;
+			const termIdf = idf.get(term) ?? 0;
+			score += tf * termIdf;
+		}
+
+		return { ...chunk, score };
+	});
+
+	// Normalize to 0-1
+	const maxScore = Math.max(...scored.map((c) => c.score));
+	if (maxScore > 0) {
+		for (const chunk of scored) {
+			chunk.score = chunk.score / maxScore;
+		}
+	}
+
+	return scored;
+}
+
+// ─── chunkByRelevance ───────────────────────────────────────────────────────
+
+export function chunkByRelevance(
+	content: string,
+	query: string,
+	options?: RelevanceOptions,
+): ChunkResult {
+	const maxChunks = options?.maxChunks ?? DEFAULT_MAX_CHUNKS;
+	const minScore = options?.minScore ?? DEFAULT_MIN_SCORE;
+	const minLines = options?.minChunkLines ?? DEFAULT_MIN_LINES;
+	const maxLines = options?.maxChunkLines ?? DEFAULT_MAX_LINES;
+
+	const rawChunks = splitIntoChunks(content, { minLines, maxLines });
+	if (rawChunks.length === 0) {
+		return { chunks: [], totalChunks: 0, omittedChunks: 0, savingsPercent: 0 };
+	}
+
+	const scored = scoreChunks(rawChunks, query);
+
+	// Filter by minScore and take top maxChunks by score
+	const qualifying = scored
+		.filter((c) => c.score >= minScore)
+		.sort((a, b) => b.score - a.score)
+		.slice(0, maxChunks);
+
+	// Return in original document order (by startLine)
+	const selected = qualifying.sort((a, b) => a.startLine - b.startLine);
+
+	const totalChars = content.length;
+	const selectedChars = selected.reduce((sum, c) => sum + c.content.length, 0);
+	const savingsPercent = totalChars > 0
+		? Math.round(((totalChars - selectedChars) / totalChars) * 100)
+		: 0;
+
+	return {
+		chunks: selected,
+		totalChunks: rawChunks.length,
+		omittedChunks: rawChunks.length - selected.length,
+		savingsPercent: Math.max(0, savingsPercent),
+	};
+}
+
+// ─── formatChunks ───────────────────────────────────────────────────────────
+
+export function formatChunks(result: ChunkResult, filePath: string): string {
+	if (result.chunks.length === 0) {
+		return `[${filePath}: empty or no relevant chunks]`;
+	}
+
+	const parts: string[] = [];
+	let lastEndLine = 0;
+
+	for (const chunk of result.chunks) {
+		// Show omission gap
+		if (lastEndLine > 0 && chunk.startLine > lastEndLine + 1) {
+			const gapLines = chunk.startLine - lastEndLine - 1;
+			parts.push(`[...${gapLines} lines omitted...]`);
+		}
+
+		parts.push(`[Lines ${chunk.startLine}-${chunk.endLine}]`);
+		parts.push(chunk.content);
+
+		lastEndLine = chunk.endLine;
+	}
+
+	return parts.join("\n");
+}

package/dist/resources/extensions/gsd/session-forensics.ts

@@ -20,7 +20,9 @@
 
 import { readFileSync, readdirSync, existsSync, statSync } from "node:fs";
 import { basename, join } from "node:path";
+import { truncateWithEllipsis } from "../shared/format-utils.js";
 import { nativeParseJsonlTail } from "./native-parser-bridge.js";
+import { MAX_JSONL_BYTES, parseJSONL } from "./jsonl-utils.js";
 import { nativeWorkingTreeStatus, nativeDiffStat } from "./native-git-bridge.js";
 import { getAutoWorktreePath } from "./auto-worktree.js";
 
@@ -63,21 +65,7 @@ export interface RecoveryBriefing {
 }
 
 // ─── JSONL Parsing ────────────────────────────────────────────────────────────
-
-/** Max bytes to parse from a JSONL source. Prevents V8 OOM on bloated activity logs. */
-const MAX_JSONL_BYTES = 10 * 1024 * 1024; // 10 MB
-
-function parseJSONL(raw: string): unknown[] {
-  // If the file is enormous, only parse the tail (most recent entries).
-  // This prevents the OOM crash path: large file → split → map → parse → OOM.
-  const source = raw.length > MAX_JSONL_BYTES
-    ? raw.slice(-MAX_JSONL_BYTES)
-    : raw;
-  return source.trim().split("\n").map(line => {
-    try { return JSON.parse(line); }
-    catch { return null; }
-  }).filter(Boolean) as unknown[];
-}
+// MAX_JSONL_BYTES and parseJSONL are imported from ./jsonl-utils.js
 
 /**
  * Find the entries belonging to the last session in a JSONL file.
@@ -379,7 +367,7 @@ function formatRecoveryPrompt(
     sections.push("", "### Commands Already Run");
     for (const c of significantCommands.slice(-10)) {
       const status = c.failed ? " ❌" : " ✓";
-      sections.push(`- \`${truncate(c.command, 120)}\`${status}`);
+      sections.push(`- \`${truncateWithEllipsis(c.command, 121)}\`${status}`);
     }
   }
 
@@ -387,7 +375,7 @@ function formatRecoveryPrompt(
   if (trace.errors.length > 0) {
     sections.push(
       "", "### Errors Before Interruption",
-      ...trace.errors.slice(-3).map(e => `- ${truncate(e, 200)}`),
+      ...trace.errors.slice(-3).map(e => `- ${truncateWithEllipsis(e, 201)}`),
     );
   }
 
@@ -453,7 +441,7 @@ function compressToolCallTrace(calls: ToolCall[]): string {
     if (call.name === "write" || call.name === "edit") {
       lines.push(`${num}. ${call.name} \`${call.input.path || "?"}\`${err}`);
     } else if (call.name === "bash" || call.name === "bg_shell") {
-      const cmd = truncate(String(call.input.command || ""), 80);
+      const cmd = truncateWithEllipsis(String(call.input.command || ""), 81);
       lines.push(`${num}. ${call.name}: \`${cmd}\`${err}`);
     } else {
       lines.push(`${num}. ${call.name}${err}`);
@@ -472,7 +460,7 @@ function formatTraceSummary(trace: ExecutionTrace): string {
     parts.push(`Files written: ${trace.filesWritten.map(f => `\`${f}\``).join(", ")}`);
   }
   if (trace.commandsRun.length > 0) {
-    const cmds = trace.commandsRun.slice(-5).map(c => `\`${truncate(c.command, 80)}\`${c.failed ? " ❌" : ""}`);
+    const cmds = trace.commandsRun.slice(-5).map(c => `\`${truncateWithEllipsis(c.command, 81)}\`${c.failed ? " ❌" : ""}`);
     parts.push(`Commands run: ${cmds.join(", ")}`);
   }
   if (trace.errors.length > 0) {
@@ -530,7 +518,7 @@ function redactInput(name: string, input: Record<string, unknown>): Record<strin
   const safe: Record<string, unknown> = {};
   for (const [key, value] of Object.entries(input)) {
     if (key === "content" || key === "oldText" || key === "newText") {
-      safe[key] = typeof value === "string" ? truncate(value, 100) : "[redacted]";
+      safe[key] = typeof value === "string" ? truncateWithEllipsis(value, 101) : "[redacted]";
     } else {
       safe[key] = value;
     }
@@ -546,6 +534,3 @@ function findLast<T>(arr: T[], predicate: (item: T) => boolean): T | undefined {
   return undefined;
 }
 
-function truncate(s: string, max: number): string {
-  return s.length > max ? s.slice(0, max) + "…" : s;
-}

package/dist/resources/extensions/gsd/session-lock.ts

@@ -0,0 +1,284 @@
+/**
+ * GSD Session Lock — OS-level exclusive locking for auto-mode sessions.
+ *
+ * Prevents multiple GSD processes from running auto-mode concurrently on
+ * the same project. Uses proper-lockfile for OS-level file locking (flock/
+ * lockfile) which eliminates the TOCTOU race condition that existed with
+ * the old advisory JSON lock approach.
+ *
+ * The lock file (.gsd/auto.lock) contains JSON metadata (PID, start time,
+ * unit info) for diagnostics, but the actual exclusion is enforced by the
+ * OS-level lock held via proper-lockfile.
+ *
+ * Lifecycle:
+ *   acquireSessionLock()  — called at the START of bootstrapAutoSession
+ *   validateSessionLock() — called periodically during dispatch to detect takeover
+ *   releaseSessionLock()  — called on clean stop/pause
+ */
+
+import { createRequire } from "node:module";
+import { existsSync, readFileSync, mkdirSync, unlinkSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { gsdRoot } from "./paths.js";
+import { atomicWriteSync } from "./atomic-write.js";
+
+const _require = createRequire(import.meta.url);
+
+// ─── Types ──────────────────────────────────────────────────────────────────
+
+export interface SessionLockData {
+  pid: number;
+  startedAt: string;
+  unitType: string;
+  unitId: string;
+  unitStartedAt: string;
+  completedUnits: number;
+  sessionFile?: string;
+}
+
+export type SessionLockResult =
+  | { acquired: true }
+  | { acquired: false; reason: string; existingPid?: number };
+
+// ─── Module State ───────────────────────────────────────────────────────────
+
+/** Release function from proper-lockfile — calling it releases the OS lock. */
+let _releaseFunction: (() => void) | null = null;
+
+/** The path we currently hold a lock on. */
+let _lockedPath: string | null = null;
+
+/** Our PID at lock acquisition time. */
+let _lockPid: number = 0;
+
+const LOCK_FILE = "auto.lock";
+
+function lockPath(basePath: string): string {
+  return join(gsdRoot(basePath), LOCK_FILE);
+}
+
+// ─── Public API ─────────────────────────────────────────────────────────────
+
+/**
+ * Attempt to acquire an exclusive session lock for the given project.
+ *
+ * This uses proper-lockfile for OS-level file locking. If another process
+ * already holds the lock, this returns { acquired: false } with details.
+ *
+ * The lock file also contains JSON metadata about the session for
+ * diagnostic purposes (PID, unit info, etc.).
+ */
+export function acquireSessionLock(basePath: string): SessionLockResult {
+  const lp = lockPath(basePath);
+
+  // Ensure the directory exists
+  mkdirSync(dirname(lp), { recursive: true });
+
+  // Write our lock data first (the content is informational; the OS lock is the real guard)
+  const lockData: SessionLockData = {
+    pid: process.pid,
+    startedAt: new Date().toISOString(),
+    unitType: "starting",
+    unitId: "bootstrap",
+    unitStartedAt: new Date().toISOString(),
+    completedUnits: 0,
+  };
+
+  let lockfile: typeof import("proper-lockfile");
+  try {
+    lockfile = _require("proper-lockfile") as typeof import("proper-lockfile");
+  } catch {
+    // proper-lockfile not available — fall back to PID-based check
+    return acquireFallbackLock(basePath, lp, lockData);
+  }
+
+  try {
+    // Try to acquire an exclusive OS-level lock on the lock file.
+    // We lock the directory (gsdRoot) since proper-lockfile works best
+    // on directories, and the lock file itself may not exist yet.
+    const gsdDir = gsdRoot(basePath);
+    mkdirSync(gsdDir, { recursive: true });
+
+    const release = lockfile.lockSync(gsdDir, {
+      realpath: false,
+      stale: 300_000, // 5 minutes — consider lock stale if holder hasn't updated
+      update: 10_000, // Update lock mtime every 10s to prove liveness
+    });
+
+    _releaseFunction = release;
+    _lockedPath = basePath;
+    _lockPid = process.pid;
+
+    // Write the informational lock data
+    atomicWriteSync(lp, JSON.stringify(lockData, null, 2));
+
+    return { acquired: true };
+  } catch (err) {
+    // Lock is held by another process
+    const existingData = readExistingLockData(lp);
+    const existingPid = existingData?.pid;
+    const reason = existingPid
+      ? `Another auto-mode session (PID ${existingPid}) is already running on this project.`
+      : `Another auto-mode session is already running on this project.`;
+
+    return { acquired: false, reason, existingPid };
+  }
+}
+
+/**
+ * Fallback lock acquisition when proper-lockfile is not available.
+ * Uses PID-based liveness checking (the old approach, but with the lock
+ * written BEFORE initialization rather than after).
+ */
+function acquireFallbackLock(
+  basePath: string,
+  lp: string,
+  lockData: SessionLockData,
+): SessionLockResult {
+  // Check if an existing lock is held by a live process
+  const existing = readExistingLockData(lp);
+  if (existing && existing.pid !== process.pid) {
+    if (isPidAlive(existing.pid)) {
+      return {
+        acquired: false,
+        reason: `Another auto-mode session (PID ${existing.pid}) is already running on this project.`,
+        existingPid: existing.pid,
+      };
+    }
+    // Stale lock from dead process — we can take over
+  }
+
+  // Write our lock data
+  atomicWriteSync(lp, JSON.stringify(lockData, null, 2));
+  _lockedPath = basePath;
+  _lockPid = process.pid;
+
+  return { acquired: true };
+}
+
+/**
+ * Update the lock file metadata (called on each unit dispatch).
+ * Does NOT re-acquire the OS lock — just updates the JSON content.
+ */
+export function updateSessionLock(
+  basePath: string,
+  unitType: string,
+  unitId: string,
+  completedUnits: number,
+  sessionFile?: string,
+): void {
+  if (_lockedPath !== basePath && _lockedPath !== null) return;
+
+  const lp = lockPath(basePath);
+  try {
+    const data: SessionLockData = {
+      pid: process.pid,
+      startedAt: new Date().toISOString(),
+      unitType,
+      unitId,
+      unitStartedAt: new Date().toISOString(),
+      completedUnits,
+      sessionFile,
+    };
+    atomicWriteSync(lp, JSON.stringify(data, null, 2));
+  } catch {
+    // Non-fatal: lock update failure
+  }
+}
+
+/**
+ * Validate that we still own the session lock.
+ *
+ * Returns true if we still hold the lock, false if another process
+ * has taken over (indicating we should gracefully stop).
+ *
+ * This is called periodically during the dispatch loop.
+ */
+export function validateSessionLock(basePath: string): boolean {
+  // If we have an OS-level lock, we're still the owner
+  if (_releaseFunction && _lockedPath === basePath) {
+    return true;
+  }
+
+  // Fallback: check the lock file PID
+  const lp = lockPath(basePath);
+  const existing = readExistingLockData(lp);
+  if (!existing) {
+    // Lock file was deleted — we lost ownership
+    return false;
+  }
+
+  return existing.pid === process.pid;
+}
+
+/**
+ * Release the session lock. Called on clean stop/pause.
+ */
+export function releaseSessionLock(basePath: string): void {
+  // Release the OS-level lock
+  if (_releaseFunction) {
+    try {
+      _releaseFunction();
+    } catch {
+      // Lock may already be released
+    }
+    _releaseFunction = null;
+  }
+
+  // Remove the lock file
+  const lp = lockPath(basePath);
+  try {
+    if (existsSync(lp)) unlinkSync(lp);
+  } catch {
+    // Non-fatal
+  }
+
+  _lockedPath = null;
+  _lockPid = 0;
+}
+
+/**
+ * Check if a session lock exists and return its data (for crash recovery).
+ * Does NOT acquire the lock.
+ */
+export function readSessionLockData(basePath: string): SessionLockData | null {
+  return readExistingLockData(lockPath(basePath));
+}
+
+/**
+ * Check if the process that wrote the lock is still alive.
+ */
+export function isSessionLockProcessAlive(data: SessionLockData): boolean {
+  return isPidAlive(data.pid);
+}
+
+/**
+ * Returns true if we currently hold a session lock for the given path.
+ */
+export function isSessionLockHeld(basePath: string): boolean {
+  return _lockedPath === basePath && _lockPid === process.pid;
+}
+
+// ─── Internal Helpers ───────────────────────────────────────────────────────
+
+function readExistingLockData(lp: string): SessionLockData | null {
+  try {
+    if (!existsSync(lp)) return null;
+    const raw = readFileSync(lp, "utf-8");
+    return JSON.parse(raw) as SessionLockData;
+  } catch {
+    return null;
+  }
+}
+
+function isPidAlive(pid: number): boolean {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  if (pid === process.pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code === "EPERM") return true;
+    return false;
+  }
+}