@link-assistant/hive-mind 1.50.9 → 1.50.10

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @link-assistant/hive-mind
 
+## 1.50.10
+
+### Patch Changes
+
+- 0dc1613: Fix log upload raw URL resolution so gist metadata lookups do not mirror full gist contents to stdout, and harden stdio handling when the terminal pipe is already broken.
+
 ## 1.50.9
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.50.9",
+  "version": "1.50.10",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",

package/src/lib.mjs

@@ -188,16 +188,107 @@ export const setupVerboseLogInterceptor = () => {
  */
 let stdioInterceptorInstalled = false;
 let _writingFromLog = false; // Guard flag to prevent double-logging from log()
+let stdoutBroken = false;
+let stderrBroken = false;
+let brokenPipeDiagnosticsWritten = false;
+
+const isBrokenPipeError = error => {
+  return error?.code === 'EPIPE' || error?.code === 'ERR_STREAM_DESTROYED';
+};
+
+const invokeWriteCallback = (callback, error = null) => {
+  if (typeof callback === 'function') {
+    callback(error);
+  }
+};
+
+const appendInternalDiagnostic = async message => {
+  if (!logFile) return;
+  const prefix = `[${new Date().toISOString()}] [INTERNAL]`;
+  await fs.appendFile(logFile, `${prefix} ${message}\n`).catch(() => {
+    // Silent fail to avoid recursive logging errors
+  });
+};
+
+const formatStreamDiagnostic = stream => {
+  return JSON.stringify({
+    isTTY: Boolean(stream?.isTTY),
+    destroyed: Boolean(stream?.destroyed),
+    writable: stream?.writable,
+    writableEnded: Boolean(stream?.writableEnded),
+    writableFinished: Boolean(stream?.writableFinished),
+    errored: stream?.errored?.code || stream?.errored?.message || null,
+    fd: typeof stream?.fd === 'number' ? stream.fd : null,
+  });
+};
+
+const normalizeWriteCallback = (encoding, callback) => {
+  return typeof encoding === 'function' ? encoding : callback;
+};
+
+const safeTerminalWrite = ({ originalWrite, chunk, encoding, callback, streamName }) => {
+  const isStdout = streamName === 'stdout';
+  const normalizedCallback = normalizeWriteCallback(encoding, callback);
+  if ((isStdout && stdoutBroken) || (!isStdout && stderrBroken)) {
+    invokeWriteCallback(normalizedCallback);
+    return false;
+  }
+
+  try {
+    return originalWrite(chunk, encoding, callback);
+  } catch (error) {
+    if (!isBrokenPipeError(error)) {
+      throw error;
+    }
+
+    if (isStdout) {
+      stdoutBroken = true;
+    } else {
+      stderrBroken = true;
+    }
+
+    invokeWriteCallback(normalizedCallback, error);
+    return false;
+  }
+};
+
+const installBrokenPipeGuard = (stream, streamName) => {
+  stream.on('error', error => {
+    if (isBrokenPipeError(error)) {
+      if (streamName === 'stdout') {
+        stdoutBroken = true;
+      } else {
+        stderrBroken = true;
+      }
+      if (!brokenPipeDiagnosticsWritten) {
+        brokenPipeDiagnosticsWritten = true;
+        void appendInternalDiagnostic(`Detected broken ${streamName} stream (${error.code || 'unknown'}). Stream state=${formatStreamDiagnostic(stream)}. Further terminal writes will be skipped when possible.`);
+      }
+      return;
+    }
+
+    throw error;
+  });
+};
+
 export const setupStdioLogInterceptor = () => {
   if (stdioInterceptorInstalled) return;
   stdioInterceptorInstalled = true;
 
   const originalStdoutWrite = process.stdout.write.bind(process.stdout);
   const originalStderrWrite = process.stderr.write.bind(process.stderr);
+  installBrokenPipeGuard(process.stdout, 'stdout');
+  installBrokenPipeGuard(process.stderr, 'stderr');
 
   process.stdout.write = (chunk, encoding, callback) => {
-    // Always write to terminal first
-    const result = originalStdoutWrite(chunk, encoding, callback);
+    // Always write to terminal first, unless the output pipe is already broken.
+    const result = safeTerminalWrite({
+      originalWrite: originalStdoutWrite,
+      chunk,
+      encoding,
+      callback,
+      streamName: 'stdout',
+    });
 
     // Also append to log file if set, but skip if this write originated from log()
     if (logFile && !_writingFromLog) {
@@ -214,8 +305,14 @@ export const setupStdioLogInterceptor = () => {
   };
 
   process.stderr.write = (chunk, encoding, callback) => {
-    // Always write to terminal first
-    const result = originalStderrWrite(chunk, encoding, callback);
+    // Always write to terminal first, unless the output pipe is already broken.
+    const result = safeTerminalWrite({
+      originalWrite: originalStderrWrite,
+      chunk,
+      encoding,
+      callback,
+      streamName: 'stderr',
+    });
 
     // Also append to log file if set, but skip if this write originated from log()
     if (logFile && !_writingFromLog) {

package/src/log-upload.lib.mjs

@@ -11,6 +11,7 @@ const use = globalThis.use;
 
 // Use command-stream for consistent $ behavior across runtimes
 const { $ } = await use('command-stream');
+const $silent = $({ mirror: false, capture: true });
 
 // Import shared library functions
 const lib = await import('./lib.mjs');
@@ -20,6 +21,12 @@ const { log } = lib;
 const sentryLib = await import('./sentry.lib.mjs');
 const { reportError } = sentryLib;
 
+const summarizeCommandOutput = value => {
+  const text = value?.toString()?.trim() || '';
+  if (!text) return '';
+  return text.length > 500 ? `${text.slice(0, 500)}... [truncated ${text.length - 500} chars]` : text;
+};
+
 /**
  * Upload a log file using gh-upload-log command
  * @param {Object} options - Upload options
@@ -92,12 +99,18 @@ export const uploadLogWithGhUploadLog = async ({ logFile, isPublic, description,
         // For gist: get raw URL from gist API
         const gistId = result.url.split('/').pop();
         try {
-          const gistDetailsResult = await $`gh api gists/${gistId} --jq '{owner: .owner.login, files: .files, history: .history}'`;
+          if (verbose) {
+            await log(`  🔍 Fetching gist metadata for raw URL resolution (gistId=${gistId})`, { verbose: true });
+          }
+          const gistDetailsResult = await $silent`gh api gists/${gistId} --jq '{owner: .owner.login, history: .history, fileNames: (.files | keys)}'`;
+          if (verbose) {
+            await log(`  📥 Gist metadata fetch completed (code=${gistDetailsResult.code ?? 'unknown'})`, { verbose: true });
+          }
           if (gistDetailsResult.code === 0) {
             const gistDetails = JSON.parse(gistDetailsResult.stdout.toString());
             const gistOwner = gistDetails.owner;
             const commitSha = gistDetails.history?.[0]?.version;
-            const fileNames = gistDetails.files ? Object.keys(gistDetails.files) : [];
+            const fileNames = Array.isArray(gistDetails.fileNames) ? gistDetails.fileNames : [];
             const fileName = fileNames.length > 0 ? fileNames[0] : 'log.txt';
 
             if (commitSha) {
@@ -105,6 +118,18 @@ export const uploadLogWithGhUploadLog = async ({ logFile, isPublic, description,
             } else {
               result.rawUrl = `https://gist.githubusercontent.com/${gistOwner}/${gistId}/raw/${fileName}`;
             }
+            if (verbose) {
+              await log(`  🧩 Gist metadata resolved owner=${gistOwner}, commitSha=${commitSha || 'latest'}, fileName=${fileName}`, { verbose: true });
+            }
+          } else if (verbose) {
+            const stderrSummary = summarizeCommandOutput(gistDetailsResult.stderr);
+            const stdoutSummary = summarizeCommandOutput(gistDetailsResult.stdout);
+            if (stderrSummary) {
+              await log(`  ⚠️  Gist metadata stderr: ${stderrSummary}`, { verbose: true });
+            }
+            if (stdoutSummary) {
+              await log(`  ⚠️  Gist metadata stdout: ${stdoutSummary}`, { verbose: true });
+            }
           }
         } catch (apiError) {
           if (verbose) {
@@ -121,7 +146,13 @@ export const uploadLogWithGhUploadLog = async ({ logFile, isPublic, description,
           try {
             const repoUrl = result.url;
             const repoPath = repoUrl.replace('https://github.com/', '');
-            const contentsResult = await $`gh api repos/${repoPath}/contents --jq '.[].name'`;
+            if (verbose) {
+              await log(`  🔍 Fetching repository contents for raw URL resolution (repoPath=${repoPath})`, { verbose: true });
+            }
+            const contentsResult = await $silent`gh api repos/${repoPath}/contents --jq '.[].name'`;
+            if (verbose) {
+              await log(`  📥 Repository contents fetch completed (code=${contentsResult.code ?? 'unknown'})`, { verbose: true });
+            }
             if (contentsResult.code === 0) {
               const files = contentsResult.stdout
                 .toString()
@@ -131,6 +162,18 @@ export const uploadLogWithGhUploadLog = async ({ logFile, isPublic, description,
               if (files.length > 0) {
                 const fileName = files[0];
                 result.rawUrl = `${repoUrl}/raw/main/${fileName}`;
+                if (verbose) {
+                  await log(`  🧩 Repository contents resolved fileName=${fileName}`, { verbose: true });
+                }
+              }
+            } else if (verbose) {
+              const stderrSummary = summarizeCommandOutput(contentsResult.stderr);
+              const stdoutSummary = summarizeCommandOutput(contentsResult.stdout);
+              if (stderrSummary) {
+                await log(`  ⚠️  Repository contents stderr: ${stderrSummary}`, { verbose: true });
+              }
+              if (stdoutSummary) {
+                await log(`  ⚠️  Repository contents stdout: ${stdoutSummary}`, { verbose: true });
               }
             }
           } catch (apiError) {