@link-assistant/hive-mind 1.50.9 → 1.50.11

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @link-assistant/hive-mind
 
+## 1.50.11
+
+### Patch Changes
+
+- bf9cf54: Fix prompt template builders crashing when literal `.png` appears in screenshot guidance.
+
+## 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/README.md

@@ -195,25 +195,23 @@ docker attach hive-mind
 
 # --- Persisting auth data across restarts ---
 
-# Extract auth data from a running (or stopped) container to the host:
-mkdir -p ~/.hive-mind
-docker cp hive-mind:/workspace/.claude ~/.hive-mind/claude
-docker cp hive-mind:/workspace/.claude.json ~/.hive-mind/claude.json
-docker cp hive-mind:/workspace/.config/gh ~/.hive-mind/gh
+# On the host, create the directories used by the current Docker workflow:
+mkdir -p /root/.hive-mind/claude /root/.hive-mind/codex /root/.hive-mind/gh
+touch -a /root/.hive-mind/claude.json
 
-# Fix ownership to match the sandbox user inside the container:
-SANDBOX_UID=$(docker exec hive-mind id -u sandbox)
-chown -R $SANDBOX_UID:$SANDBOX_UID ~/.hive-mind/claude ~/.hive-mind/gh
-chown $SANDBOX_UID:$SANDBOX_UID ~/.hive-mind/claude.json
-
-# On subsequent runs, mount the auth data to keep it between restarts:
-docker run -dit \
-  --name hive-mind \
-  --restart unless-stopped \
+# In our Docker images HOME=/workspace, so Codex stores its data in /workspace/.codex.
+# Mount the full Codex directory so auth.json, config.toml, and sessions survive restarts.
+docker run -dit --user sandbox --name hive-mind --restart unless-stopped \
   -v /root/.hive-mind/claude:/workspace/.claude \
+  -v /root/.hive-mind/codex:/workspace/.codex \
   -v /root/.hive-mind/claude.json:/workspace/.claude.json \
   -v /root/.hive-mind/gh:/workspace/.config/gh \
-  konard/hive-mind:latest
+  konard/hive-mind:latest bash -l -c 'bash /workspace/start-bot.sh'
+
+# After the first start, fix ownership to match the sandbox user inside the container:
+SANDBOX_UID=$(docker exec hive-mind id -u sandbox)
+chown -R $SANDBOX_UID:$SANDBOX_UID /root/.hive-mind/claude /root/.hive-mind/codex /root/.hive-mind/gh
+chown $SANDBOX_UID:$SANDBOX_UID /root/.hive-mind/claude.json
 ```
 
 **Benefits of Docker:**

package/package.json

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

package/src/claude.prompts.lib.mjs

@@ -160,7 +160,7 @@ Initial research.
    - When you start, create a detailed plan for yourself and follow your todo list step by step. Add as many relevant points from these guidelines to the todo list as practical so you can track the work clearly.
    - When the user mentions CI failures or asks to investigate logs, consider adding these todos to track the investigation: (1) list recent CI runs with timestamps, (2) download logs from failed runs to the ci-logs/ directory, (3) analyze error messages and identify the root cause, (4) implement a fix, (5) verify that the fix resolves the specific errors found in the logs.
    - When you read the issue, read all details and comments thoroughly.
-   - When you see screenshots or images in issue descriptions, pull request descriptions, comments, or discussions, download the image to a local file first, then use the Read tool to view and analyze it. Before reading downloaded images with the Read tool, verify that the file is a valid image rather than HTML by using a CLI tool such as the 'file' command. When corrupted or non-image files, such as GitHub "Not Found" pages saved as `.png`, are read, they can cause "Could not process image" errors and crash the AI solver process. When the file command shows "HTML", "text", or "ASCII text", the download failed, so do not call Read on that file. Instead: (1) when images are from GitHub issues or PRs, such as URLs containing "github.com/user-attachments", retry with: curl -L -H "Authorization: token $(gh auth token)" -o <filename> "<url>" (2) when the retry still fails, skip the image and note that it was unavailable.
+   - When you see screenshots or images in issue descriptions, pull request descriptions, comments, or discussions, download the image to a local file first, then use the Read tool to view and analyze it. Before reading downloaded images with the Read tool, verify that the file is a valid image rather than HTML by using a CLI tool such as the 'file' command. When corrupted or non-image files, such as GitHub "Not Found" pages saved as \`.png\`, are read, they can cause "Could not process image" errors and crash the AI solver process. When the file command shows "HTML", "text", or "ASCII text", the download failed, so do not call Read on that file. Instead: (1) when images are from GitHub issues or PRs, such as URLs containing "github.com/user-attachments", retry with: curl -L -H "Authorization: token $(gh auth token)" -o <filename> "<url>" (2) when the retry still fails, skip the image and note that it was unavailable.
    - When you need issue details, use gh issue view https://github.com/${owner}/${repo}/issues/${issueNumber}.
    - When you need related code, use gh search code --owner ${owner} [keywords].
    - When you need repo context, read files in your working directory.${

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) {

package/src/opencode.prompts.lib.mjs

@@ -137,7 +137,7 @@ ${workspaceInstructions}
 Initial research.
    - When you start, create a detailed plan for yourself and follow your todo list step by step. Add as many relevant points from these guidelines to the todo list as practical so you can track the work clearly.
    - When you read the issue, read all details and comments thoroughly.
-   - When you see screenshots or images in issue descriptions, pull request descriptions, comments, or discussions, download the image to a local file first, then use the Read tool to view and analyze it. Before reading downloaded images with the Read tool, verify that the file is a valid image rather than HTML by using a CLI tool such as the 'file' command. When corrupted or non-image files, such as GitHub "Not Found" pages saved as `.png`, are read, they can cause "Could not process image" errors and crash the AI solver process. When the file command shows "HTML", "text", or "ASCII text", the download failed, so do not call Read on that file. Instead: (1) when images are from GitHub issues or PRs, such as URLs containing "github.com/user-attachments", retry with: curl -L -H "Authorization: token $(gh auth token)" -o <filename> "<url>" (2) when the retry still fails, skip the image and note that it was unavailable.
+   - When you see screenshots or images in issue descriptions, pull request descriptions, comments, or discussions, download the image to a local file first, then use the Read tool to view and analyze it. Before reading downloaded images with the Read tool, verify that the file is a valid image rather than HTML by using a CLI tool such as the 'file' command. When corrupted or non-image files, such as GitHub "Not Found" pages saved as \`.png\`, are read, they can cause "Could not process image" errors and crash the AI solver process. When the file command shows "HTML", "text", or "ASCII text", the download failed, so do not call Read on that file. Instead: (1) when images are from GitHub issues or PRs, such as URLs containing "github.com/user-attachments", retry with: curl -L -H "Authorization: token $(gh auth token)" -o <filename> "<url>" (2) when the retry still fails, skip the image and note that it was unavailable.
    - When you need issue details, use gh issue view https://github.com/${owner}/${repo}/issues/${issueNumber}.
    - When you need related code, use gh search code --owner ${owner} [keywords].
    - When you need repo context, read files in your working directory.${