pi-session-mcp 0.6.4 → 0.7.1

package/dist/setup-process.js

@@ -1,10 +1,24 @@
 import { spawn } from "node:child_process";
-import { lstatSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { lstatSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 const DEFAULT_TIMEOUT = 10_000;
 const DEFAULT_MAX = 65_536;
 const ABORT_GROUP_CLEANUP_TIMEOUT = 2_000;
 const GUARDIAN_START_TIMEOUT = 5_000;
+let platformModule;
+/**
+ * Source-mode harnesses import this file through Node type stripping, which
+ * cannot map a static `./setup-platform.js` import to its `.ts` source.
+ */
+function loadSetupPlatform() {
+    platformModule ??= import(import.meta.url.endsWith(".ts") ? "./setup-platform.ts" : "./setup-platform.js");
+    return platformModule;
+}
+async function currentProcessTable() {
+    const platform = await loadSetupPlatform();
+    const name = platform.currentSetupPlatform();
+    return name ? platform.createProcessTable(name) : undefined;
+}
 /** Kill a detached process and every descendant in its process group. */
 function terminateProcessGroup(child, signal) {
     if (child.pid === undefined)
@@ -21,51 +35,16 @@ function terminateProcessGroup(child, signal) {
     }
     catch { /* already exited */ }
 }
-function processGroupState(child) {
-    if (child.pid === undefined || process.platform !== "linux")
-        return "unknown";
-    const group = child.pid;
-    try {
-        for (const entry of readdirSync("/proc", { withFileTypes: true })) {
-            if (!entry.isDirectory() || !/^\d+$/.test(entry.name))
-                continue;
-            try {
-                const stat = readProcStat(Number(entry.name));
-                if (stat.pgrp === group && stat.state !== "Z")
-                    return "alive";
-            }
-            catch (error) {
-                if (error.code !== "ENOENT")
-                    return "unknown";
-            }
-        }
-    }
-    catch {
-        return "unknown";
-    }
-    return "gone";
-}
-function readProcStat(pid) {
-    const line = readFileSync(`/proc/${pid}/stat`, "utf8").trim();
-    const close = line.lastIndexOf(") ");
-    const state = line[close + 2];
-    if (close < 3 || !state || !/^[A-Za-z]$/.test(state) || line[close + 3] !== " ")
-        throw new Error("process_stat_invalid");
-    const fields = line.slice(close + 4).trim().split(/\s+/);
-    const pgrp = Number(fields[1]);
-    if (!Number.isSafeInteger(pgrp) || pgrp < 0)
-        throw new Error("process_group_invalid");
-    return { pgrp, state };
-}
 const delay = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
 /** Runs only an explicit executable/argv pair, with bounded output and termination. */
 export function createProcessRunner(options = {}) {
     const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT;
     const maxOutputBytes = options.maxOutputBytes ?? DEFAULT_MAX;
-    return { run(command, args, signal) {
+    return { async run(command, args, signal) {
             const effectiveSignal = options.signal && signal ? AbortSignal.any([options.signal, signal]) : options.signal ?? signal;
-            if (process.platform !== "linux")
-                return Promise.resolve({ exitCode: 126, stdout: "", stderr: "" });
+            const table = await currentProcessTable();
+            if (!table)
+                return { exitCode: 126, stdout: "", stderr: "" };
             return new Promise((resolve) => {
                 const child = spawn(command, [...args], { stdio: ["ignore", "pipe", "pipe"], env: options.env, detached: process.platform !== "win32" });
                 let stdout = "";
@@ -92,18 +71,26 @@ export function createProcessRunner(options = {}) {
                     clearTimeout(killTimer); if (!timedOut && hardTimer)
                     clearTimeout(hardTimer); if (groupPoll)
                     clearTimeout(groupPoll); resolve({ exitCode, stdout: overflow ? Buffer.from(stdout).subarray(0, maxOutputBytes).toString("utf8") : stdout, stderr: overflow ? "output_limit" : stderr }); };
+                let groupCheck = false;
                 const finishAfterGroup = (successCode) => {
-                    if (done)
+                    if (done || groupCheck)
                         return;
-                    if (processGroupState(child) === "gone") {
-                        finish(successCode);
-                        return;
-                    }
-                    if (Date.now() >= groupDeadline) {
-                        finish(126);
-                        return;
-                    }
-                    groupPoll = setTimeout(() => finishAfterGroup(successCode), 10);
+                    groupCheck = true;
+                    const group = child.pid;
+                    void (group === undefined ? Promise.resolve("unknown") : table.groupState(group)).then((state) => {
+                        groupCheck = false;
+                        if (done)
+                            return;
+                        if (state === "gone") {
+                            finish(successCode);
+                            return;
+                        }
+                        if (Date.now() >= groupDeadline) {
+                            finish(126);
+                            return;
+                        }
+                        groupPoll = setTimeout(() => finishAfterGroup(successCode), table.pollMs);
+                    });
                 };
                 const abort = () => { if (done)
                     return; aborted = true; groupDeadline = Date.now() + ABORT_GROUP_CLEANUP_TIMEOUT; terminateProcessGroup(child, "SIGTERM"); killTimer = setTimeout(() => { terminateProcessGroup(child, "SIGKILL"); finishAfterGroup(125); }, 100); };
@@ -137,6 +124,7 @@ export function createProcessRunner(options = {}) {
 /** Starts the local MCP server with only the controlled configuration environment. */
 export function createMcpStdioLauncher(options) {
     return async (signal) => {
+        const table = await currentProcessTable();
         const child = spawn(options.nodePath, [options.entryPath], { stdio: ["pipe", "pipe", "pipe"], env: { PI_SESSION_MCP_CONFIG: options.configPath }, detached: process.platform !== "win32" });
         const max = options.maxFrameBytes ?? DEFAULT_MAX;
         let buffer = "";
@@ -194,33 +182,35 @@ export function createMcpStdioLauncher(options) {
                 await delay(100);
                 terminateProcessGroup(child, "SIGKILL");
                 const childClosed = await waitForClose(1_000);
+                const group = child.pid;
+                const groupState = async () => table && group !== undefined ? table.groupState(group) : "unknown";
                 const groupDeadline = Date.now() + 1_000;
-                while (processGroupState(child) === "alive" && Date.now() < groupDeadline)
-                    await delay(10);
-                if (!childClosed || processGroupState(child) !== "gone")
+                let state = await groupState();
+                while (state !== "gone" && Date.now() < groupDeadline) {
+                    await delay(table?.pollMs ?? 10);
+                    state = await groupState();
+                }
+                if (!childClosed || state !== "gone")
                     throw new Error("mcp_process_cleanup_failed");
             },
         };
     };
 }
 /**
- * Acquires the Linux kernel fence and starts the transaction guardian. The
- * guardian inherits the locked file description, so parent death cannot release
- * the fence while a client mutation or descendant is still live.
+ * Starts the transaction guardian with the kernel fence held. On Linux the
+ * trusted util-linux `flock` locks the caller's open file description first;
+ * on macOS the caller passes a descriptor from `openLockedDarwin`, which is
+ * locked at open time. The guardian inherits the locked file description, so
+ * parent death cannot release the fence while a client mutation or
+ * descendant is still live.
  */
 export async function acquireSetupGuardian(lockFd, timeoutMs, signal, validateFence) {
-    if (process.platform !== "linux")
+    const platform = await loadSetupPlatform();
+    const platformName = platform.currentSetupPlatform();
+    if (!platformName)
         throw new Error("platform_unsupported");
-    const flockPath = ["/usr/bin/flock", "/bin/flock"].find((candidate) => {
-        try {
-            const file = statSync(candidate);
-            return file.isFile() && file.uid === 0 && (file.mode & 0o022) === 0 && (file.mode & 0o111) !== 0;
-        }
-        catch {
-            return false;
-        }
-    });
-    if (!flockPath)
+    const flockPath = platformName === "linux" ? ["/usr/bin/flock", "/bin/flock"].find((candidate) => platform.isTrustedSystemBinary(candidate)) : undefined;
+    if (platformName === "linux" && !flockPath)
         throw new Error("ownership_lock_unavailable");
     const modulePath = fileURLToPath(import.meta.url);
     const guardianPath = fileURLToPath(new URL(modulePath.endsWith(".ts") ? "./setup-command-guardian.ts" : "./setup-command-guardian.js", import.meta.url));
@@ -231,34 +221,36 @@ export async function acquireSetupGuardian(lockFd, timeoutMs, signal, validateFe
     catch {
         throw new Error("ownership_lock_unavailable");
     }
-    const waitSeconds = String(Math.ceil(Math.max(1_000, Math.min(timeoutMs, 120_000)) / 1_000));
-    let locker;
-    try {
-        locker = spawn(flockPath, ["-E", "75", "-w", waitSeconds, "3"], {
-            stdio: ["ignore", "ignore", "ignore", lockFd],
-            detached: true,
-        });
-    }
-    catch {
-        throw new Error("ownership_lock_unavailable");
-    }
-    const stopAcquisition = () => { if (locker.pid !== undefined) {
+    if (flockPath) {
+        const waitSeconds = String(Math.ceil(Math.max(1_000, Math.min(timeoutMs, 120_000)) / 1_000));
+        let locker;
         try {
-            process.kill(-locker.pid, "SIGKILL");
+            locker = spawn(flockPath, ["-E", "75", "-w", waitSeconds, "3"], {
+                stdio: ["ignore", "ignore", "ignore", lockFd],
+                detached: true,
+            });
+        }
+        catch {
+            throw new Error("ownership_lock_unavailable");
+        }
+        const stopAcquisition = () => { if (locker.pid !== undefined) {
+            try {
+                process.kill(-locker.pid, "SIGKILL");
+            }
+            catch { /* already gone */ }
+        } };
+        if (signal?.aborted)
+            stopAcquisition();
+        signal?.addEventListener("abort", stopAcquisition, { once: true });
+        try {
+            await new Promise((resolve, reject) => {
+                locker.once("error", () => reject(new Error("ownership_lock_unavailable")));
+                locker.once("close", (code) => code === 0 ? resolve() : reject(new Error(code === 75 ? "ownership_lock_busy" : signal?.aborted ? "operation_aborted" : "ownership_lock_unavailable")));
+            });
+        }
+        finally {
+            signal?.removeEventListener("abort", stopAcquisition);
         }
-        catch { /* already gone */ }
-    } };
-    if (signal?.aborted)
-        stopAcquisition();
-    signal?.addEventListener("abort", stopAcquisition, { once: true });
-    try {
-        await new Promise((resolve, reject) => {
-            locker.once("error", () => reject(new Error("ownership_lock_unavailable")));
-            locker.once("close", (code) => code === 0 ? resolve() : reject(new Error(code === 75 ? "ownership_lock_busy" : signal?.aborted ? "operation_aborted" : "ownership_lock_unavailable")));
-        });
-    }
-    finally {
-        signal?.removeEventListener("abort", stopAcquisition);
     }
     if (signal?.aborted)
         throw new Error("operation_aborted");

package/dist/setup.js

@@ -254,7 +254,8 @@ export async function immutableReleaseBinding(packageRoot) {
         throw new Error("release_version_mismatch");
     const runtimeRoot = join(packageRoot, "dist");
     const runtimeFiles = await listRuntimeFiles(runtimeRoot);
-    for (const required of ["main.js", "setup-command-guardian.js"]) {
+    // The guardian loads setup-platform.js at runtime, so it is mandatory too.
+    for (const required of ["main.js", "setup-command-guardian.js", "setup-platform.js"]) {
         if (!runtimeFiles.includes(required))
             throw new Error("release_entry_missing");
         const entry = await lstat(join(runtimeRoot, required));

package/dist/stdout-guard-install.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Installed when this module is evaluated. `main.ts` imports it first, so the guard is
+ * in place before any other module, the Pi SDK or an extension, can write to stdout.
+ */
+export declare const stdoutGuard: import("./stdout-guard.js").StdoutGuard;

package/dist/stdout-guard-install.js

@@ -0,0 +1,6 @@
+import { installStdoutGuard } from "./stdout-guard.js";
+/**
+ * Installed when this module is evaluated. `main.ts` imports it first, so the guard is
+ * in place before any other module, the Pi SDK or an extension, can write to stdout.
+ */
+export const stdoutGuard = installStdoutGuard();

package/dist/stdout-guard.d.ts

@@ -0,0 +1,20 @@
+import { Writable } from "node:stream";
+export interface StdoutGuardOptions {
+    readonly stream?: NodeJS.WriteStream;
+    readonly console?: Pick<Console, "log" | "info" | "debug">;
+    readonly report?: (line: string) => void;
+    readonly intervalMs?: number;
+    readonly onExit?: (flush: () => void) => void;
+}
+export interface StdoutGuard {
+    /** The only writer that reaches the real stdout: hand it to the MCP transport. */
+    readonly transportStdout: Writable;
+    /** Writes the pending suppression counts to stderr. */
+    flush(): void;
+}
+/**
+ * Reserves stdout for MCP frames. Any other write, an extension's `console.log`
+ * included, is dropped; stderr gets only a byte and write count, never the content,
+ * because the content may hold prompts or secrets.
+ */
+export declare function installStdoutGuard(options?: StdoutGuardOptions): StdoutGuard;

package/dist/stdout-guard.js

@@ -0,0 +1,72 @@
+import { format } from "node:util";
+/**
+ * Reserves stdout for MCP frames. Any other write, an extension's `console.log`
+ * included, is dropped; stderr gets only a byte and write count, never the content,
+ * because the content may hold prompts or secrets.
+ */
+export function installStdoutGuard(options = {}) {
+    const stream = options.stream ?? process.stdout;
+    const target = options.console ?? console;
+    const report = options.report ?? ((line) => { process.stderr.write(line); });
+    const intervalMs = options.intervalMs ?? 1_000;
+    const realWrite = stream.write.bind(stream);
+    const realEnd = stream.end.bind(stream);
+    let bytes = 0;
+    let writes = 0;
+    let timer;
+    const flush = () => {
+        if (timer) {
+            clearTimeout(timer);
+            timer = undefined;
+        }
+        if (writes === 0)
+            return;
+        report(JSON.stringify({ level: "warning", event: "foreign_stdout_suppressed", bytes, writes }) + "\n");
+        bytes = 0;
+        writes = 0;
+    };
+    const suppress = (chunk, encoding) => {
+        bytes += typeof chunk === "string"
+            ? Buffer.byteLength(chunk, typeof encoding === "string" ? encoding : "utf8")
+            : chunk instanceof Uint8Array ? chunk.byteLength : 0;
+        writes += 1;
+        if (!timer) {
+            timer = setTimeout(flush, intervalMs);
+            timer.unref();
+        }
+    };
+    stream.write = ((chunk, encodingOrCallback, callback) => {
+        suppress(chunk, encodingOrCallback);
+        const done = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
+        if (typeof done === "function")
+            queueMicrotask(() => { done(); });
+        return true;
+    });
+    // A foreign `end` must neither leak content nor close the real stdout, which would break every later frame.
+    stream.end = ((...args) => {
+        const [first, second] = args;
+        if (typeof first === "string" || first instanceof Uint8Array)
+            suppress(first, second);
+        const done = args.find((arg) => typeof arg === "function");
+        if (typeof done === "function")
+            queueMicrotask(() => { done(); });
+        return stream;
+    });
+    for (const method of ["log", "info", "debug"]) {
+        target[method] = (...args) => { suppress(`${format(...args)}\n`); };
+    }
+    // Write-through, not a buffering wrapper: queued frames must reach stdout before `process.exit`,
+    // and a wrapper `Writable` would hold all but one of them until a later tick.
+    const transportStdout = new Proxy(stream, {
+        get(target, property) {
+            if (property === "write")
+                return realWrite;
+            if (property === "end")
+                return realEnd;
+            const value = Reflect.get(target, property, target);
+            return typeof value === "function" ? value.bind(target) : value;
+        },
+    });
+    (options.onExit ?? ((exitFlush) => { process.once("exit", exitFlush); }))(flush);
+    return { transportStdout, flush };
+}