querysub 0.451.0 → 0.453.0

package/src/diagnostics/logs/IndexedLogs/MCPIndexedLogs.ts

@@ -27,6 +27,32 @@ const PROGRESS_LOG_INTERVAL = timeInSecond * 5;
 const LOGGER_NAMES = ["logs/log", "logs/info", "logs/warn", "logs/error"] as const;
 type LoggerName = typeof LOGGER_NAMES[number];
 
+// Public-facing short names callers pass in via the `logTypes` parameter, mapped
+//  to the internal logger names above.
+const EXTERNAL_TO_INTERNAL_LOGGER: Record<string, LoggerName> = {
+    "log": "logs/log",
+    "info": "logs/info",
+    "warn": "logs/warn",
+    "error": "logs/error",
+};
+
+// Parses the caller's `logTypes` string (e.g. "warn|error") into the matching
+//  internal logger names. Empty / undefined means "all four" (no restriction).
+function parseLogTypes(value: string | undefined): readonly LoggerName[] {
+    if (!value) return LOGGER_NAMES;
+    let parts = value.split("|").map(s => s.trim().toLowerCase()).filter(s => s);
+    if (parts.length === 0) return LOGGER_NAMES;
+    let result: LoggerName[] = [];
+    for (let p of parts) {
+        let internal = EXTERNAL_TO_INTERNAL_LOGGER[p];
+        if (!internal) {
+            throw new Error(`logTypes: unknown log type ${JSON.stringify(p)}; expected one of log, info, warn, error (separated by "|")`);
+        }
+        if (!result.includes(internal)) result.push(internal);
+    }
+    return result;
+}
+
 // Per-logger accounting for one search. Byte counts are raw buffer sizes.
 export type LoggerStats = {
     // Files in range matching the requested machine.
@@ -142,8 +168,11 @@ function createProgressLogger(): (message: string) => void {
 }
 
 export class MCPIndexedLogs {
-    // machineId -> latest timestamp guaranteed to already be moved-to-public.
-    private movedThroughByMachine = new Map<string, number>();
+    // `${machineId}|${loggerName}` -> latest timestamp guaranteed to already be
+    //  moved-to-public for that specific (machine, logger). Keyed per-logger so
+    //  a search scoped to only some loggers doesn't poison the cache for the
+    //  others.
+    private movedThroughByMachineLogger = new Map<string, number>();
 
     // Cache: `${type}|${loggerName}|${startBucket}|${endBucket}` -> { time, paths }.
     // Buckets are hour-aligned start/end so adjacent searches reuse work.
@@ -157,11 +186,15 @@ export class MCPIndexedLogs {
         direction: Direction;
         columns: string[];
         limit?: number;
+        // Optional pipe-separated list restricting which log streams to scan
+        //  (e.g. "warn|error", "log"). Omit / empty = all four streams.
+        logTypes?: string;
     }): Promise<SearchResult> {
         let limit = config.limit ?? 100;
         let startTime = normalizeTime(config.startTime, "startTime");
         let endTime = normalizeTime(config.endTime, "endTime");
-        console.log(`[search] query=${JSON.stringify(config.query)} | machine=${config.machine} | startTime=${formatDateTime(startTime)} | endTime=${formatDateTime(endTime)} | direction=${config.direction} | columns=[${config.columns.join(",")}] | limit=${config.limit ?? "(default)"}`);
+        let enabledLoggers = parseLogTypes(config.logTypes);
+        console.log(`[search] query=${JSON.stringify(config.query)} | machine=${config.machine} | startTime=${formatDateTime(startTime)} | endTime=${formatDateTime(endTime)} | direction=${config.direction} | columns=[${config.columns.join(",")}] | limit=${config.limit ?? "(default)"} | logTypes=${config.logTypes ?? "(all)"}`);
         let now = Date.now();
         if (endTime > now - END_TIME_MIN_AGE) {
             throw new Error(`endTime must be at least ${formatTime(END_TIME_MIN_AGE)} in the past (got ${formatTime(now - endTime)} ago)`);
@@ -173,7 +206,7 @@ export class MCPIndexedLogs {
         let machineId = config.machine === "local" ? getOwnMachineId() : config.machine;
 
         let moveStart = Date.now();
-        let moveOutcome = await this.ensureMovedThrough(machineId, endTime);
+        let moveOutcome = await this.ensureMovedThrough(machineId, endTime, enabledLoggers);
         console.log(`[search] ensureMovedThrough ${moveOutcome} in ${formatTime(Date.now() - moveStart)}`);
 
         let loggers = await getLoggers2Async();
@@ -190,7 +223,7 @@ export class MCPIndexedLogs {
 
         let pathsStart = Date.now();
         let totalPathsSeen = 0;
-        await Promise.all(LOGGER_NAMES.map(async (loggerName) => {
+        await Promise.all(enabledLoggers.map(async (loggerName) => {
             let logger = this.getLoggerByName(loggers, loggerName);
             let archives = logger.debugGetCachedLogs({ type: useType });
 
@@ -300,9 +333,11 @@ export class MCPIndexedLogs {
 
         // Trim the internal LoggerStats down to just total + scanned. The rest
         // (bytes/blocks/timing) stays in the console.log above and is NOT
-        // returned — see the warning on SearchResult.
+        // returned — see the warning on SearchResult. We only emit entries for
+        // the loggers we actually searched, so a caller who scoped to
+        // `warn|error` doesn't see misleading 0s for the loggers they skipped.
         let files: Record<string, { total: number; scanned: number }> = {};
-        for (let name of LOGGER_NAMES) {
+        for (let name of enabledLoggers) {
             files[name] = { total: fileCounts[name].total, scanned: fileCounts[name].scanned };
         }
 
@@ -450,16 +485,20 @@ export class MCPIndexedLogs {
         sink.loggerStats.rows++;
     }
 
-    // For each logger, asks each remote node on the target machine whether it
-    // has pending logs overlapping [0, endTime]. The first node that answers
-    // without throwing wins; if it says yes, we ask the same node to flush.
-    // We iterate because not every node necessarily exposes the new endpoints
-    // (e.g. older versions still running). Records moved-through up to
-    // now - MOVE_GRACE so we skip this on subsequent calls covering the same
-    // window.
-    private async ensureMovedThrough(machineId: string, endTime: number): Promise<"cached" | "no-node" | "moved"> {
-        let lastMoved = this.movedThroughByMachine.get(machineId) ?? 0;
-        if (lastMoved >= endTime) return "cached";
+    // For each requested logger, asks each remote node on the target machine
+    // whether it has pending logs overlapping [0, endTime]. The first node that
+    // answers without throwing wins; if it says yes, we ask the same node to
+    // flush. We iterate because not every node necessarily exposes the new
+    // endpoints (e.g. older versions still running). Records moved-through up
+    // to now - MOVE_GRACE per (machine, logger) so we skip this on subsequent
+    // calls covering the same window. Only the loggers listed in `loggers` are
+    // touched; the others aren't queried or flushed.
+    private async ensureMovedThrough(machineId: string, endTime: number, loggers: readonly LoggerName[]): Promise<"cached" | "no-node" | "moved"> {
+        let needed = loggers.filter(name => {
+            let lastMoved = this.movedThroughByMachineLogger.get(`${machineId}|${name}`) ?? 0;
+            return lastMoved < endTime;
+        });
+        if (needed.length === 0) return "cached";
 
         let nodeIds = await this.findRemoteNodesOnMachine(machineId);
         if (nodeIds.length === 0) {
@@ -467,7 +506,7 @@ export class MCPIndexedLogs {
             return "no-node";
         }
 
-        for (let loggerName of LOGGER_NAMES) {
+        for (let loggerName of needed) {
             let answered = false;
             for (let nodeId of nodeIds) {
                 try {
@@ -495,7 +534,10 @@ export class MCPIndexedLogs {
             }
         }
 
-        this.movedThroughByMachine.set(machineId, Date.now() - MOVE_GRACE);
+        let recordTime = Date.now() - MOVE_GRACE;
+        for (let loggerName of needed) {
+            this.movedThroughByMachineLogger.set(`${machineId}|${loggerName}`, recordTime);
+        }
         return "moved";
     }
 
@@ -511,11 +553,11 @@ export class MCPIndexedLogs {
         let preferred: string[] = [];
         let rest: string[] = [];
         await Promise.all(candidates.map(async (nodeId) => {
-            let entry = await timeoutToUndefinedSilent(
+            let metadata = await timeoutToUndefinedSilent(
                 2500,
-                NodeCapabilitiesController.nodes[nodeId].getEntryPoint(),
+                NodeCapabilitiesController.nodes[nodeId].getMetadata(),
             );
-            if (entry?.includes("movelogs")) preferred.push(nodeId);
+            if (metadata?.entryPoint.includes("movelogs")) preferred.push(nodeId);
             else rest.push(nodeId);
         }));
         return [...preferred, ...rest];

package/src/diagnostics/logs/IndexedLogs/MCPIndexedLogsEntry.ts

@@ -14,12 +14,15 @@ module.hotreload = false;
 import "../../../inject";
 
 import * as http from "http";
-import { logErrors } from "../../../errors";
+import { logErrors, timeoutToUndefinedSilent } from "../../../errors";
 import { Querysub } from "../../../4-querysub/QuerysubController";
 import { MCPIndexedLogs } from "./MCPIndexedLogs";
+import { getAllNodeIds } from "../../../-f-node-discovery/NodeDiscovery";
+import { NodeCapabilitiesController } from "../../../-g-core-values/NodeCapabilities";
 import { formatTime } from "socket-function/src/formatting/format";
 
 const DEFAULT_MCP_HTTP_PORT = 4487;
+const NODE_INFO_TIMEOUT_MS = 5000;
 
 const PROTOCOL_VERSION = "2025-03-26";
 const SERVER_INFO = { name: "querysub-indexed-logs", version: "0.1.0" };
@@ -33,6 +36,8 @@ Returns { allColumns, results, files: { <loggerName>: {total, scanned} } }. If a
 
 \`allColumns\` is the union of every key seen on any returned row, so callers can pick additional columns for follow-up calls.
 
+Optional \`logTypes\` parameter restricts which log streams are scanned. Pass a pipe-separated list of \`log\`, \`info\`, \`warn\`, \`error\` (e.g. \`"warn|error"\`, \`"log"\`). Omit to search all four. The returned \`files\` object only includes the streams you asked for.
+
 Query syntax (case-insensitive substring match by default):
   | — OR. \`cat|dog\` matches if either substring is present.
   & — AND. \`error&timeout\` matches if both are present (in any order, anywhere).
@@ -50,10 +55,19 @@ Note: each segment between operators ideally has at least 4 contiguous character
                 direction: { type: "string", enum: ["fromStart", "fromEnd"] },
                 columns: { type: "array", items: { type: "string" }, description: "Which fields to project onto each row. Use [] to get just metadata; use allColumns from a prior result to pick more." },
                 limit: { type: "number", default: 100 },
+                logTypes: { type: "string", description: "Optional pipe-separated list restricting which log streams to scan. Allowed values: log, info, warn, error. Examples: \"warn|error\", \"log\". Omit (default) to search all four." },
             },
             required: ["query", "machine", "startTime", "endTime", "direction", "columns"],
         },
     },
+    {
+        name: "listNodes",
+        description: `List every node in the Querysub cluster, with each node's process entry point. Returns an array of { nodeId, entryPoint }. A node that does not answer in time has entryPoint left undefined.`,
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
 ];
 
 type JsonRpcRequest = {
@@ -122,6 +136,8 @@ async function dispatch(method: string, params: unknown, mcp: MCPIndexedLogs): P
         let result: unknown;
         if (toolName === "search") {
             result = await mcp.search(args as Parameters<MCPIndexedLogs["search"]>[0]);
+        } else if (toolName === "listNodes") {
+            result = await getNodeInfos();
         } else {
             throw new Error(`Unknown tool ${toolName}`);
         }
@@ -143,6 +159,21 @@ function errorResponse(id: number | string | null, code: number, message: string
     return { jsonrpc: "2.0", id, error: { code, message } };
 }
 
+type NodeInfo = {
+    nodeId: string;
+    entryPoint?: string;
+};
+
+async function getNodeInfos(): Promise<NodeInfo[]> {
+    let nodes = await getAllNodeIds();
+    return Promise.all(
+        nodes.map(async (nodeId): Promise<NodeInfo> => {
+            let metadata = await timeoutToUndefinedSilent(NODE_INFO_TIMEOUT_MS, NodeCapabilitiesController.nodes[nodeId].getMetadata());
+            return { nodeId, entryPoint: metadata?.entryPoint };
+        }),
+    );
+}
+
 async function main() {
     let mcp = new MCPIndexedLogs();
 

package/src/diagnostics/managementPages.tsx

@@ -93,6 +93,12 @@ export async function registerManagementPages2(config: {
         controllerName: "NodeViewerController",
         getModule: () => import("./NodeViewer"),
     });
+    inputPages.push({
+        title: "Authority Specs",
+        componentName: "AuthoritySpecPage",
+        controllerName: "AuthoritySpecPageController",
+        getModule: () => import("./misc-pages/AuthoritySpecPage"),
+    });
     inputPages.push({
         title: "LOG VIEWER",
         componentName: "LogViewer3",
@@ -306,6 +312,7 @@ export function renderIsManagementUser() {
 }
 
 const ErrorWarning = createLazyComponent(() => import("./logs/errorNotifications2/ErrorWarning"))("ErrorWarning");
+const LaunchTrackingHeader = createLazyComponent(() => import("../deployManager/LaunchTrackingHeader"))("LaunchTrackingHeader");
 
 class ManagementRoot extends qreact.Component {
     state = {
@@ -378,6 +385,7 @@ class ManagementRoot extends qreact.Component {
                         {isCurrentUserSuperUser() && <div className={css.vbox(4)}>
                             <PathDistributionInfo />
                             <ValuePathWarning />
+                            <LaunchTrackingHeader />
                         </div>}
                     </div>
                     {currentPage &&

package/src/diagnostics/misc-pages/AuthoritySpecPage.tsx

@@ -0,0 +1,113 @@
+module.allowclient = true;
+
+import { qreact } from "../../4-dom/qreact";
+import { css } from "typesafecss";
+import { SocketFunction } from "socket-function/SocketFunction";
+import { getAllNodeIds, getBrowserUrlNode } from "../../-f-node-discovery/NodeDiscovery";
+import { getSyncedController } from "../../library-components/SyncedController";
+import { assertIsManagementUser } from "../managementPages";
+import { NodeCapabilitiesController } from "../../-g-core-values/NodeCapabilities";
+import { timeoutToUndefinedSilent } from "../../errors";
+import { sort } from "socket-function/src/misc";
+import type { AuthoritySpec } from "../../0-path-value-core/PathRouter";
+
+const PROBE_TIMEOUT_MS = 5000;
+const RANGE_BAR_WIDTH_PX = 360;
+const RANGE_BAR_HEIGHT_PX = 14;
+
+type NodeAuthorityInfo = {
+    nodeId: string;
+    entryPoint?: string;
+    spec?: AuthoritySpec;
+};
+
+class AuthoritySpecPageControllerBase {
+    public async getAllNodeAuthoritySpecs(): Promise<NodeAuthorityInfo[]> {
+        let nodes = await getAllNodeIds();
+        return Promise.all(nodes.map(async (nodeId): Promise<NodeAuthorityInfo> => {
+            let metadata = await timeoutToUndefinedSilent(PROBE_TIMEOUT_MS, NodeCapabilitiesController.nodes[nodeId].getMetadata());
+            return { nodeId, entryPoint: metadata?.entryPoint, spec: metadata?.authoritySpec };
+        }));
+    }
+}
+
+export const AuthoritySpecPageController = SocketFunction.register(
+    "AuthoritySpecPageController-7b8c9d0e-1f2a-3b4c-5d6e-7f8090a1b2c3",
+    new AuthoritySpecPageControllerBase(),
+    () => ({
+        getAllNodeAuthoritySpecs: {},
+    }),
+    () => ({
+        hooks: [assertIsManagementUser],
+    }),
+    {
+        noAutoExpose: true,
+    }
+);
+
+const AuthoritySpecSynced = getSyncedController(AuthoritySpecPageController, {
+    reads: { getAllNodeAuthoritySpecs: ["nodeAuthoritySpecs"] },
+    writes: {},
+});
+
+class AuthorityRangeBar extends qreact.Component<{ start: number; end: number }> {
+    render() {
+        let startPct = this.props.start * 100;
+        let widthPct = (this.props.end - this.props.start) * 100;
+        return <div className={css.relative.size(RANGE_BAR_WIDTH_PX, RANGE_BAR_HEIGHT_PX).flexShrink0.hsl(0, 0, 92).bord2(0, 0, 75)}>
+            <div className={css.absolute.top(0).left(`${startPct}%`).size(`${widthPct}%`, "100%").hsl(210, 65, 50)} />
+        </div>;
+    }
+}
+
+class AuthorityNodeRow extends qreact.Component<{ info: NodeAuthorityInfo }> {
+    state = {
+        expanded: false,
+    };
+    render() {
+        let info = this.props.info;
+        let spec = info.spec!;
+        let expanded = this.state.expanded;
+        return <div
+            className={css.button.vbox(6).pad2(10).fillWidth.bord2(0, 0, 85).hsl(0, 0, 99)}
+            onClick={() => this.state.expanded = !expanded}
+        >
+            <div className={css.hbox(10).fillWidth}>
+                <span>{expanded ? "▼" : "▶"}</span>
+                <span className={css.boldStyle}>{info.nodeId}</span>
+                <span>{spec.routeStart.toFixed(4)} - {spec.routeEnd.toFixed(4)}</span>
+                <AuthorityRangeBar start={spec.routeStart} end={spec.routeEnd} />
+                <span className={css.colorhsl(0, 0, 50)}>width {(spec.routeEnd - spec.routeStart).toFixed(4)}</span>
+                {spec.excludeDefault && <span className={css.colorhsl(0, 70, 35)}>(excludes default)</span>}
+                <span className={css.colorhsl(0, 0, 40).ellipsis.flexFillWidth}>{info.entryPoint || "(no entry point)"}</span>
+            </div>
+            {expanded &&
+                <div className={css.vbox(2)}>
+                    <div className={css.boldStyle}>Prefixes ({spec.prefixes.length}):</div>
+                    {spec.prefixes.length === 0 && <div className={css.colorhsl(0, 0, 50)}>(none)</div>}
+                    {spec.prefixes.map(p =>
+                        <div key={p.originalPrefix} className={css.colorhsl(0, 0, 25)}>{p.originalPrefix}</div>
+                    )}
+                </div>
+            }
+        </div>;
+    }
+}
+
+export class AuthoritySpecPage extends qreact.Component {
+    render() {
+        let infos = AuthoritySpecSynced(getBrowserUrlNode()).getAllNodeAuthoritySpecs();
+        if (!infos) {
+            return <div className={css.pad2(16)}>Loading authority specs...</div>;
+        }
+        infos = infos.filter(x => x.spec && x.spec.routeStart >= 0 && x.spec.routeEnd >= 0);
+        sort(infos, x => x.spec!.routeStart);
+
+        return <div className={css.vbox(12).pad2(16).fillWidth}>
+            <h2>Node Authority Specs ({infos.length})</h2>
+            <div className={css.vbox(8).fillWidth}>
+                {infos.map(info => <AuthorityNodeRow key={info.nodeId} info={info} />)}
+            </div>
+        </div>;
+    }
+}

package/src/diagnostics/pathAuditer.ts

@@ -333,8 +333,6 @@ async function auditAuthority(nodeId: string, pathsToAudit: { path: string }[],
         if (response.valid && response.time && compareTime(response.time, ourValue.time) > 0) {
             valuesToRequest.push({ path: response.path, time: response.time });
             let authorities = PathRouter.getAllAuthorities(response.path);
-            debugbreak(2);
-            debugger;
             trackSyncAge({
                 path: response.path,
                 ourTimeId: ourValue.time.time,
@@ -349,8 +347,6 @@ async function auditAuthority(nodeId: string, pathsToAudit: { path: string }[],
         //      - Send it our value
         else if (response.valid === undefined && (!response.time || compareTime(ourValue.time, response.time) > 0)) {
             valuesToSend.push(ourValue);
-            debugbreak(2);
-            debugger;
             trackSyncAge({
                 path: response.path,
                 ourTimeId: ourValue.time.time,
@@ -370,8 +366,6 @@ async function auditAuthority(nodeId: string, pathsToAudit: { path: string }[],
             let age = now - ourValue.time.time;
             if (age >= MAX_CHANGE_AGE) {
                 pathsToForceSync.add(response.path);
-                debugbreak(2);
-                debugger;
                 trackSyncAge({
                     path: response.path,
                     ourTimeId: ourValue.time.time,

package/test.ts

@@ -43,7 +43,8 @@ async function main() {
 
     let nodes = await getAllNodeIds();
     let values = await Promise.all(nodes.map(async node => {
-        return timeoutToUndefinedSilent(5000, NodeCapabilitiesController.nodes[node].getEntryPoint());
+        let metadata = await timeoutToUndefinedSilent(5000, NodeCapabilitiesController.nodes[node].getMetadata());
+        return metadata?.entryPoint;
     }));
     console.log({ values });
 

package/src/misc/getParentProcessId.cs

@@ -1,53 +0,0 @@
-using System;
-using System.Diagnostics;
-using System.Text;
-using System.Runtime.InteropServices;
-
-public class PPIDService
-{
-    [DllImport("kernel32.dll")]
-    static extern IntPtr OpenProcess(int dwDesiredAccess, bool bInheritHandle, int dwProcessId);
-
-    [DllImport("kernel32.dll")]
-    static extern bool CloseHandle(IntPtr hObject);
-
-    [DllImport("ntdll.dll")]
-    static extern int NtQueryInformationProcess(IntPtr processHandle, int processInformationClass, ref PROCESS_BASIC_INFORMATION pbi, int processInformationLength, out int returnLength);
-
-    [StructLayout(LayoutKind.Sequential)]
-    internal struct PROCESS_BASIC_INFORMATION
-    {
-        public IntPtr Reserved1;
-        public IntPtr PebBaseAddress;
-        public IntPtr Reserved2_0;
-        public IntPtr Reserved2_1;
-        public IntPtr UniqueProcessId;
-        public IntPtr InheritedFromUniqueProcessId;
-    }
-
-    public static int GetParentProcessId(int pid)
-    {
-        IntPtr hProcess = OpenProcess(0x1000, false, pid);
-        if (hProcess == IntPtr.Zero)
-        {
-            return 0;
-        }
-
-        try
-        {
-            PROCESS_BASIC_INFORMATION pbi = new PROCESS_BASIC_INFORMATION();
-            int returnLength;
-            int status = NtQueryInformationProcess(hProcess, 0, ref pbi, Marshal.SizeOf(pbi), out returnLength);
-            if (status == 0)
-            {
-                return pbi.InheritedFromUniqueProcessId.ToInt32();
-            }
-        }
-        finally
-        {
-            CloseHandle(hProcess);
-        }
-
-        return 0;
-    }
-}

package/src/misc/getParentProcessId.ts

@@ -1,53 +0,0 @@
-import fs from "fs";
-
-import { lazy } from "socket-function/src/caching";
-import { runInSerial } from "socket-function/src/batching";
-import child_process from "child_process";
-import os from "os";
-import readline from "readline";
-import net from "net";
-
-const windowsGetPPID = lazy(async () => {
-    const powershellProcess = child_process.spawn("powershell.exe", [
-        "-NoProfile",
-        "-NonInteractive",
-        "-Command",
-        "-",
-    ], { stdio: ["pipe", "pipe", "pipe"] });
-    powershellProcess.stderr.pipe(process.stderr);
-    // powershellProcess.stdout.pipe(process.stdout);
-
-    powershellProcess.on("error", (error) => {
-        console.error("Failed to spawn powershell process", error);
-    });
-
-    powershellProcess.stdin.write(`$inject = Get-Content -Raw -Path ${JSON.stringify(__dirname + "/getParentProcessId.cs")};\n`);
-    powershellProcess.stdin.write(`Add-Type -TypeDefinition $inject\n`);
-
-    return runInSerial((pid: number): Promise<number> => {
-        return new Promise((resolve) => {
-            powershellProcess.stdin.write(`[PPIDService]::GetParentProcessId(${pid})\n`);
-            powershellProcess.stdout.once("data", (data) => {
-                resolve(parseInt(data.toString()) || 0);
-            });
-        });
-    });
-});
-
-export async function getPPID(pid: number): Promise<number> {
-    const platform = os.platform();
-    if (platform === "win32") {
-        let getPPID = await windowsGetPPID();
-        return getPPID(pid);
-    } else if (platform === "darwin" || platform === "linux") {
-        try {
-            const statContent = await fs.promises.readFile(`/proc/${pid}/stat`, "utf8");
-            const ppid = parseInt(statContent.split(" ")[3], 10);
-            return isNaN(ppid) ? 0 : ppid;
-        } catch (error) {
-            return 0;
-        }
-    } else {
-        throw new Error("Unsupported operating system");
-    }
-}