@kungfu-tech/buildchain 2.5.1-alpha.0 → 2.5.1

package/bin/buildchain.mjs

@@ -311,6 +311,21 @@ function packageVersion() {
   return packageJson.version;
 }
 
+function createTailBuffer(limit = 64 * 1024) {
+  let value = "";
+  return {
+    append(chunk) {
+      value += Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk || "");
+      if (value.length > limit) {
+        value = value.slice(value.length - limit);
+      }
+    },
+    text() {
+      return value;
+    },
+  };
+}
+
 async function runProcessTreeSample(sampleArgs = []) {
   const separator = sampleArgs.indexOf("--");
   const optionArgs = separator === -1 ? sampleArgs : sampleArgs.slice(0, separator);
@@ -326,10 +341,20 @@ async function runProcessTreeSample(sampleArgs = []) {
   const outputPath = readFlag(optionArgs, "output", ".buildchain/diagnostics/process-samples.jsonl");
   const summaryOutputPath = readFlag(optionArgs, "summary-output", ".buildchain/diagnostics/process-summary.json");
   const startedAt = Date.now();
+  const stdoutTail = createTailBuffer();
+  const stderrTail = createTailBuffer();
   const child = spawn(command, args, {
     cwd: process.cwd(),
     env: process.env,
-    stdio: "inherit",
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  child.stdout?.on("data", (chunk) => {
+    stdoutTail.append(chunk);
+    process.stdout.write(chunk);
+  });
+  child.stderr?.on("data", (chunk) => {
+    stderrTail.append(chunk);
+    process.stderr.write(chunk);
   });
   const sampler = startProcessSampler({
     rootPid: child.pid || process.pid,
@@ -345,7 +370,7 @@ async function runProcessTreeSample(sampleArgs = []) {
   });
   const result = await new Promise((resolve) => {
     child.on("error", (error) => resolve({ error, status: 1, signal: "" }));
-    child.on("close", (status, signal) => resolve({ status, signal: signal || "" }));
+    child.on("close", (status, signal) => resolve({ status: status ?? 0, signal: signal || "" }));
   });
   const samples = sampler.stop();
   const summary = summarizeProcessSamples({
@@ -366,6 +391,16 @@ async function runProcessTreeSample(sampleArgs = []) {
       signal: result.signal || "",
       error: result.error?.message || "",
     },
+    wrappedCommand: {
+      command,
+      args,
+      rootPid: child.pid || 0,
+      exitCode: result.status ?? 0,
+      signal: result.signal || "",
+      error: result.error?.message || "",
+      stdoutTail: stdoutTail.text(),
+      stderrTail: stderrTail.text(),
+    },
     durationMs: Date.now() - startedAt,
     samplesPath: outputPath,
     summaryPath: summaryOutputPath,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kungfu-tech/buildchain",
-  "version": "2.5.1-alpha.0",
+  "version": "2.5.1",
   "private": false,
   "description": "Buildchain Release Passport, release governance, CLI toolkit, and site facts.",
   "repository": "https://github.com/kungfu-systems/buildchain",

package/packages/core/diagnostics.js

@@ -637,7 +637,9 @@ function processCommandFromLine(commandLine = "", fallback = "") {
 
 function normalizeProcessRows({ rootPid, platform, rows = [] }) {
   const byParent = new Map();
+  const byPid = new Map();
   for (const row of rows) {
+    byPid.set(row.pid, row);
     byParent.set(row.ppid, [...(byParent.get(row.ppid) || []), row]);
   }
   const seen = new Set();
@@ -654,20 +656,32 @@ function normalizeProcessRows({ rootPid, platform, rows = [] }) {
       stack.push(child.pid);
     }
   }
-  return { rootPid: String(rootPid), platform, processes };
+  return { rootPid: String(rootPid), platform, rootProcess: byPid.get(String(rootPid)) || undefined, processes };
 }
 
 function collectWindowsProcessRows({ cwd, runCommand }) {
   const script = [
-    "$ErrorActionPreference = 'Stop'",
+    "$ErrorActionPreference = 'Stop';",
     "Get-CimInstance Win32_Process |",
     "Select-Object ProcessId,ParentProcessId,Name,CommandLine |",
     "ConvertTo-Json -Compress",
-  ].join("; ");
-  const output = runCommand("powershell", ["-NoProfile", "-Command", script], {
-    cwd,
-    timeoutMs: 5000,
-  });
+  ].join(" ");
+  const errors = [];
+  let output = "";
+  for (const command of ["powershell.exe", "powershell", "pwsh"]) {
+    try {
+      output = runCommand(command, ["-NoProfile", "-NonInteractive", "-Command", script], {
+        cwd,
+        timeoutMs: 5000,
+      });
+      break;
+    } catch (error) {
+      errors.push(`${command}: ${error.message}`);
+    }
+  }
+  if (!output) {
+    throw new Error(`Windows process sampler unavailable: ${errors.join("; ") || "no process query output"}`);
+  }
   const parsed = JSON.parse(String(output || "[]"));
   const entries = Array.isArray(parsed) ? parsed : [parsed];
   return entries.map((entry) => {
@@ -696,8 +710,14 @@ export function collectProcessTreeSnapshot({
         platform,
         rows: collectWindowsProcessRows({ cwd, runCommand }),
       });
-    } catch {
-      return { rootPid: pid, platform, processes: [] };
+    } catch (error) {
+      return {
+        rootPid: pid,
+        platform,
+        processes: [],
+        samplerUnavailable: true,
+        samplerUnavailableReason: error.message,
+      };
     }
   }
   let lines = [];
@@ -706,8 +726,14 @@ export function collectProcessTreeSnapshot({
       cwd,
       timeoutMs: 5000,
     }).split(/\r?\n/).filter(Boolean);
-  } catch {
-    return { rootPid: pid, platform, processes: [] };
+  } catch (error) {
+    return {
+      rootPid: pid,
+      platform,
+      processes: [],
+      samplerUnavailable: true,
+      samplerUnavailableReason: error.message,
+    };
   }
   const rows = lines.map((line) => {
     const match = line.trim().match(/^(\d+)\s+(\d+)\s+([0-9.]+)\s+(.*)$/);
@@ -904,6 +930,7 @@ export function summarizeProcessSamples({
   activeCpuThreshold = 0.1,
 } = {}) {
   const normalizedSamples = Array.isArray(samples) ? samples : [];
+  const unavailableSamples = normalizedSamples.filter((sample) => sample?.samplerUnavailable);
   const activeCounts = [];
   const cpuTotals = [];
   const categoryMax = {};
@@ -972,6 +999,15 @@ export function summarizeProcessSamples({
     schemaVersion: 1,
     contract: BUILDCHAIN_PROCESS_SAMPLE_SUMMARY_CONTRACT,
     sampleCount: normalizedSamples.length,
+    sampler: {
+      unavailable: unavailableSamples.length > 0,
+      unavailableSamples: unavailableSamples.length,
+      unavailableReasons: [...new Set(
+        unavailableSamples
+          .map((sample) => String(sample.samplerUnavailableReason || "").trim())
+          .filter(Boolean),
+      )].slice(0, 5),
+    },
     activeCpuThreshold: threshold,
     requestedParallelism: requested,
     requestedParallelismSource: requestedSource,
@@ -1023,10 +1059,16 @@ export function startProcessSampler({
     return snapshot;
   };
   sample();
-  const timer = setInterval(sample, Math.max(1000, Number(intervalMs || 15000)));
+  const interval = Math.max(1000, Number(intervalMs || 15000));
+  const earlyDelay = Math.min(1000, interval);
+  const earlyTimer = interval > earlyDelay ? setTimeout(sample, earlyDelay) : undefined;
+  const timer = setInterval(sample, interval);
   return {
     samples,
     stop() {
+      if (earlyTimer) {
+        clearTimeout(earlyTimer);
+      }
       clearInterval(timer);
       return samples;
     },

package/scripts/run-lifecycle-core.mjs

@@ -1,5 +1,5 @@
 import crypto from "node:crypto";
-import { execFileSync, execSync } from "node:child_process";
+import { execFileSync, execSync, spawnSync } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -73,12 +73,28 @@ function manifestPathFor(root, filePath) {
 }
 
 function lifecycleErrorAttributes(error, extra = {}) {
-  return {
+  const attributes = {
     ...extra,
     errorName: error.name,
     status: error.status ?? "",
     signal: error.signal || "",
   };
+  if (error.stdoutTail) {
+    attributes.stdoutTail = error.stdoutTail;
+  }
+  if (error.stderrTail) {
+    attributes.stderrTail = error.stderrTail;
+  }
+  if (error.wrappedCommand) {
+    attributes.wrappedCommand = error.wrappedCommand;
+    attributes.wrappedCommandExitCode = error.wrappedCommand.exitCode ?? "";
+    attributes.wrappedCommandSignal = error.wrappedCommand.signal || "";
+    attributes.wrappedCommandError = error.wrappedCommand.error || "";
+  }
+  if (error.samplerUnavailable !== undefined) {
+    attributes.samplerUnavailable = error.samplerUnavailable;
+  }
+  return attributes;
 }
 
 function collectArtifactFiles(root, patterns) {
@@ -122,6 +138,30 @@ function readProcessSummaryArtifact(filePath) {
   throw new Error(`process summary file has unsupported contract: ${artifact?.contract || "unknown"}`);
 }
 
+function readOptionalProcessSummaryArtifact(filePath) {
+  try {
+    return readProcessSummaryArtifact(filePath);
+  } catch {
+    return undefined;
+  }
+}
+
+function attachProcessSampleFailureEvidence(error, processSummaryPath) {
+  const artifact = readOptionalProcessSummaryArtifact(processSummaryPath)?.artifact;
+  const wrappedCommand = artifact?.wrappedCommand;
+  if (wrappedCommand) {
+    error.wrappedCommand = wrappedCommand;
+    error.stdoutTail = wrappedCommand.stdoutTail || "";
+    error.stderrTail = wrappedCommand.stderrTail || "";
+    error.status = wrappedCommand.exitCode ?? error.status;
+    error.signal = wrappedCommand.signal || error.signal || "";
+  }
+  if (artifact?.summary?.sampler) {
+    error.samplerUnavailable = Boolean(artifact.summary.sampler.unavailable);
+  }
+  return error;
+}
+
 function shellCommandArgs(command, shell) {
   if (typeof shell === "string" && shell.trim()) {
     return [shell, "-c", command];
@@ -170,12 +210,19 @@ function executeSampledShellCommand({
     args.push("--requested-parallelism", String(Number(requestedParallelism)));
   }
   args.push("--", ...shellCommandArgs(command, shell));
-  execFileSync(process.execPath, args, {
+  const result = spawnSync(process.execPath, args, {
     cwd,
     env,
     stdio: "inherit",
     timeout,
   });
+  if (result.error || result.status !== 0 || result.signal) {
+    const error = result.error || new Error(`sampled lifecycle command failed with status ${result.status ?? ""}`);
+    error.status = result.status ?? error.status ?? 1;
+    error.signal = result.signal || error.signal || "";
+    attachProcessSampleFailureEvidence(error, processSummaryPath);
+    throw error;
+  }
 }
 
 function stageCommandText(stage) {