@link-assistant/hive-mind 1.56.4 → 1.56.6

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @link-assistant/hive-mind
 
+## 1.56.6
+
+### Patch Changes
+
+- e4037e1: Support Telegram solve and hive commands when options are placed before the GitHub URL.
+
+## 1.56.5
+
+### Patch Changes
+
+- 0447110: Treat structured Codex error events as failed tool executions even when the Codex process exits with code 0.
+
 ## 1.56.4
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.56.4",
+  "version": "1.56.6",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",
@@ -15,7 +15,7 @@
     "hive-telegram-bot": "./src/telegram-bot.mjs"
   },
   "scripts": {
-    "test": "node tests/solve-queue.test.mjs && node tests/limits-display.test.mjs && node tests/test-usage-limit.mjs && node tests/test-codex-support.mjs && node tests/test-build-cost-info-string.mjs && node tests/test-claude-code-install-method.mjs && node tests/test-claude-quiet-config.mjs && node tests/test-configure-claude-bin.mjs && node tests/test-docker-release-order.mjs && node tests/test-docker-box-migration.mjs && node tests/test-hive-screens.mjs && node tests/test-issue-1616-pr-issue-link-preservation.mjs && node tests/test-pre-pr-failure-notifier-1640.mjs && node tests/test-ready-to-merge-pagination-1645.mjs && node tests/test-require-gh-paginate-rule.mjs && node tests/test-telegram-message-filters.mjs && node tests/test-telegram-bot-command-aliases.mjs && node tests/test-telegram-bot-configuration-isolation-links-notation.mjs && node tests/test-extract-isolation-from-args.mjs && node tests/test-solve-queue-command.mjs && node tests/test-queue-display-1267.mjs && node tests/test-telegram-bot-launcher.mjs",
+    "test": "node tests/solve-queue.test.mjs && node tests/limits-display.test.mjs && node tests/test-usage-limit.mjs && node tests/test-codex-support.mjs && node tests/test-build-cost-info-string.mjs && node tests/test-claude-code-install-method.mjs && node tests/test-claude-quiet-config.mjs && node tests/test-configure-claude-bin.mjs && node tests/test-docker-release-order.mjs && node tests/test-docker-box-migration.mjs && node tests/test-hive-screens.mjs && node tests/test-issue-1616-pr-issue-link-preservation.mjs && node tests/test-pre-pr-failure-notifier-1640.mjs && node tests/test-ready-to-merge-pagination-1645.mjs && node tests/test-require-gh-paginate-rule.mjs && node tests/test-telegram-message-filters.mjs && node tests/test-telegram-bot-command-aliases.mjs && node tests/test-telegram-options-before-url.mjs && node tests/test-telegram-bot-configuration-isolation-links-notation.mjs && node tests/test-extract-isolation-from-args.mjs && node tests/test-solve-queue-command.mjs && node tests/test-queue-display-1267.mjs && node tests/test-telegram-bot-launcher.mjs",
     "test:queue": "node tests/solve-queue.test.mjs",
     "test:limits-display": "node tests/limits-display.test.mjs",
     "test:usage-limit": "node tests/test-usage-limit.mjs",

package/src/codex.lib.mjs

@@ -183,6 +183,57 @@ const upsertCodexItemError = (itemErrors, item) => {
   });
 };
 
+const unwrapCodexErrorMessage = value => {
+  if (!value) return '';
+  if (typeof value !== 'string') {
+    if (typeof value?.error?.message === 'string') return unwrapCodexErrorMessage(value.error.message);
+    if (typeof value?.message === 'string') return unwrapCodexErrorMessage(value.message);
+    return String(value);
+  }
+
+  let text = value.trim();
+  for (let i = 0; i < 3; i++) {
+    if (!text.startsWith('{') && !text.startsWith('[')) break;
+    try {
+      const parsed = JSON.parse(text);
+      if (typeof parsed?.error?.message === 'string') return unwrapCodexErrorMessage(parsed.error.message);
+      if (typeof parsed?.message === 'string') {
+        text = parsed.message.trim();
+        continue;
+      }
+      return JSON.stringify(parsed);
+    } catch {
+      break;
+    }
+  }
+  return text;
+};
+
+export const getCodexErrorEventSummary = codexJsonState => {
+  const events = [];
+  const addEvents = (type, items = []) => {
+    for (const item of items) {
+      const message = unwrapCodexErrorMessage(item?.message);
+      events.push({ type, message: message || 'Codex emitted an error event' });
+    }
+  };
+
+  addEvents('item', codexJsonState?.itemErrors);
+  addEvents('turn', codexJsonState?.turnFailures);
+  addEvents('stream', codexJsonState?.streamErrors);
+
+  return {
+    hasError: events.length > 0,
+    message: events[0]?.message || null,
+    events,
+    counts: {
+      item: codexJsonState?.itemErrors?.length || 0,
+      turn: codexJsonState?.turnFailures?.length || 0,
+      stream: codexJsonState?.streamErrors?.length || 0,
+    },
+  };
+};
+
 export const parseCodexExecJsonOutput = (output, state = {}, requestedModelId = null) => {
   const nextState = {
     sessionId: state.sessionId || null,
@@ -597,7 +648,7 @@ export const executeCodex = async params => {
 };
 
 export const executeCodexCommand = async params => {
-  const { tempDir, branchName, prompt, systemPrompt, argv, log, formatAligned, getResourceSnapshot, forkedRepo, feedbackLines, codexPath, $, owner, repo, prNumber } = params;
+  const { tempDir, branchName, prompt, systemPrompt, argv, log, formatAligned, getResourceSnapshot, forkedRepo, feedbackLines, codexPath, $, owner, repo, prNumber, calculatePricing = calculateCodexPricing } = params;
 
   const shellQuote = value => `"${String(value).replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`;
 
@@ -852,7 +903,7 @@ export const executeCodexCommand = async params => {
       }
 
       const firstActualModelId = mappedModel;
-      const pricingInfo = firstActualModelId ? await calculateCodexPricing(firstActualModelId, codexJsonState.tokenUsage.stepCount > 0 ? codexJsonState.tokenUsage : null) : null;
+      const pricingInfo = firstActualModelId ? await calculatePricing(firstActualModelId, codexJsonState.tokenUsage.stepCount > 0 ? codexJsonState.tokenUsage : null) : null;
       if (pricingInfo?.totalCostUSD !== null && pricingInfo?.totalCostUSD !== undefined) {
         await log(`💰 Codex public pricing estimate: $${new Decimal(pricingInfo.totalCostUSD).toFixed(6)}`, { verbose: true });
         if (pricingInfo.usesLongContextPricing) {
@@ -876,6 +927,49 @@ export const executeCodexCommand = async params => {
         throw error;
       }
 
+      const codexErrorSummary = getCodexErrorEventSummary(codexJsonState);
+      if (codexErrorSummary.hasError) {
+        const limitInfo = detectUsageLimit(codexErrorSummary.message || lastMessage);
+        if (limitInfo.isUsageLimit) {
+          limitReached = true;
+          limitResetTime = limitInfo.resetTime;
+
+          const messageLines = formatUsageLimitMessage({
+            tool: 'OpenAI Codex',
+            resetTime: limitInfo.resetTime,
+            sessionId,
+            resumeCommand: sessionId ? `${process.argv[0]} ${process.argv[1]} ${argv.url} --resume ${sessionId}` : null,
+          });
+
+          for (const line of messageLines) {
+            await log(line, { level: 'warning' });
+          }
+        } else {
+          await log(`\n\n❌ Codex emitted error event: ${codexErrorSummary.message}`, { level: 'error' });
+          await log(`   Error events: item=${codexErrorSummary.counts.item}, turn=${codexErrorSummary.counts.turn}, stream=${codexErrorSummary.counts.stream}`, { level: 'error' });
+        }
+
+        const resourcesAfter = await getResourceSnapshot();
+        await log('\n📈 System resources after execution:', { verbose: true });
+        await log(`   Memory: ${resourcesAfter.memory.split('\n')[1]}`, { verbose: true });
+        await log(`   Load: ${resourcesAfter.load}`, { verbose: true });
+
+        return {
+          success: false,
+          sessionId,
+          limitReached,
+          limitResetTime,
+          pricingInfo,
+          publicPricingEstimate: pricingInfo?.totalCostUSD ?? null,
+          resultModelUsage,
+          subAgentCalls: codexJsonState.subAgentCalls.length > 0 ? codexJsonState.subAgentCalls : null,
+          codexJsonDetails: codexJsonState,
+          errorInfo: codexErrorSummary,
+          result: codexErrorSummary.message,
+          resultSummary: lastTextContent || null, // Issue #1263: Use last text content from JSON output stream
+        };
+      }
+
       if (exitCode !== 0) {
         // Check for usage limit errors first (more specific)
         const limitInfo = detectUsageLimit(lastMessage);
@@ -915,6 +1009,7 @@ export const executeCodexCommand = async params => {
           resultModelUsage,
           subAgentCalls: codexJsonState.subAgentCalls.length > 0 ? codexJsonState.subAgentCalls : null,
           codexJsonDetails: codexJsonState,
+          errorInfo: getCodexErrorEventSummary(codexJsonState),
           resultSummary: lastTextContent || null, // Issue #1263: Use last text content from JSON output stream
         };
       }
@@ -965,6 +1060,8 @@ export const executeCodexCommand = async params => {
         limitResetTime: null,
         pricingInfo: null,
         publicPricingEstimate: null,
+        errorInfo: { hasError: true, message: error.message, events: [{ type: 'exception', message: error.message }], counts: { item: 0, turn: 0, stream: 0 } },
+        result: error.message,
         resultSummary: null, // Issue #1263: No result summary available on error
       };
     } finally {

package/src/telegram-bot.mjs

@@ -45,7 +45,7 @@ const { formatUsageMessage, formatCodexLimitsSection, getAllCachedLimits } = awa
 const { getVersionInfo, formatVersionMessage } = await import('./version-info.lib.mjs');
 const { escapeMarkdown, escapeMarkdownV2, cleanNonPrintableChars, makeSpecialCharsVisible } = await import('./telegram-markdown.lib.mjs');
 const { getSolveQueue, createQueueExecuteCallback } = await import('./telegram-solve-queue.lib.mjs');
-const { applySolveToolAlias, getSolveCommandNameFromText, getSolveToolAliasFromText, parseCommandArgs, SOLVE_COMMAND_NAMES } = await import('./telegram-solve-command.lib.mjs');
+const { applySolveToolAlias, getFirstParsedPositionalArg, getSolveCommandNameFromText, getSolveToolAliasFromText, moveArgumentToFront, parseArgsWithYargs, parseCommandArgs, SOLVE_COMMAND_NAMES } = await import('./telegram-solve-command.lib.mjs');
 const { isChatStopped, getChatStopInfo, getStoppedChatRejectMessage, DEFAULT_STOP_REASON } = await import('./telegram-start-stop-command.lib.mjs');
 const { isOldMessage: _isOldMessage, isGroupChat: _isGroupChat, isChatAuthorized: _isChatAuthorized, isForwardedOrReply: _isForwardedOrReply, extractCommandFromText, extractGitHubUrl: _extractGitHubUrl } = await import('./telegram-message-filters.lib.mjs');
 const { launchBotWithRetry } = await import('./telegram-bot-launcher.lib.mjs');
@@ -500,11 +500,18 @@ function mergeArgsWithOverrides(userArgs, overrides) {
 }
 
 /** Validate GitHub URL for Telegram bot commands. Returns { valid, error?, parsed?, normalizedUrl? } */
-function validateGitHubUrl(args, options = {}) {
-  const { allowedTypes = ['issue', 'pull'], commandName = 'solve' } = options;
-  if (args.length === 0) return { valid: false, error: `Missing GitHub URL. Usage: /${commandName} <github-url> [options]` };
+async function getCommandUrlArg(args, createYargsConfig, positionalNames) {
+  const parsedUrl = createYargsConfig ? await getFirstParsedPositionalArg(args, yargs, createYargsConfig, positionalNames) : null;
+  if (parsedUrl) return parsedUrl;
+  return args.find(arg => cleanNonPrintableChars(arg).includes('github.com')) || (args[0] && !args[0].startsWith('-') ? args[0] : null);
+}
+
+async function validateGitHubUrl(args, options = {}) {
+  const { allowedTypes = ['issue', 'pull'], commandName = 'solve', createYargsConfig = null, positionalNames = [] } = options;
+  const rawUrl = await getCommandUrlArg(args, createYargsConfig, positionalNames);
+  if (!rawUrl) return { valid: false, error: `Missing GitHub URL. Usage: /${commandName} <github-url> [options]` };
   // Issue #1102: Clean non-printable chars (Zero-Width Space, BOM, etc.) from URLs
-  const url = cleanNonPrintableChars(args[0]);
+  const url = cleanNonPrintableChars(rawUrl);
   if (!url.includes('github.com')) return { valid: false, error: 'First argument must be a GitHub URL' };
   const parsed = parseGitHubUrl(url);
   if (!parsed.valid) return { valid: false, error: parsed.error || 'Invalid GitHub URL', suggestion: parsed.suggestion };
@@ -842,11 +849,12 @@ async function handleSolveCommand(ctx) {
   // Issue #1325: Support all options via /solve command when replying (e.g., "/solve --model opus")
   const isReply = message.reply_to_message && message.reply_to_message.message_id && !message.reply_to_message.forum_topic_created;
 
-  // Check if the first argument looks like a GitHub URL
-  // If not, we should try to extract the URL from the replied message
-  const firstArgIsUrl = userArgs.length > 0 && (userArgs[0].includes('github.com') || userArgs[0].match(/^https?:\/\//));
+  // Check if yargs sees a command URL. If not, try to extract it from the replied message.
+  const commandUrlArg = await getCommandUrlArg(userArgs, createSolveYargsConfig, ['issue-url']);
+  const commandUrlText = commandUrlArg ? cleanNonPrintableChars(commandUrlArg) : '';
+  const commandHasUrl = commandUrlText.includes('github.com') || /^https?:\/\//.test(commandUrlText);
 
-  if (isReply && !firstArgIsUrl) {
+  if (isReply && !commandHasUrl) {
     if (VERBOSE) {
       console.log('[VERBOSE] /solve is a reply without URL in args, extracting from replied message...');
       console.log('[VERBOSE] User args:', userArgs);
@@ -883,7 +891,13 @@ async function handleSolveCommand(ctx) {
 
   userArgs = applySolveToolAlias(userArgs, solveToolAlias);
 
-  const validation = validateGitHubUrl(userArgs);
+  const { malformed, errors: malformedErrors } = detectMalformedFlags(userArgs);
+  if (malformed.length > 0) {
+    await safeReply(ctx, `❌ ${escapeMarkdown(malformedErrors.join('\n'))}\n\nPlease check your option syntax.`, { reply_to_message_id: ctx.message.message_id });
+    return;
+  }
+
+  const validation = await validateGitHubUrl(userArgs, { createYargsConfig: createSolveYargsConfig, positionalNames: ['issue-url'] });
   if (!validation.valid) {
     let errorMsg = `❌ ${validation.error}`;
     if (validation.suggestion) {
@@ -893,6 +907,7 @@ async function handleSolveCommand(ctx) {
     await safeReply(ctx, errorMsg, { reply_to_message_id: ctx.message.message_id });
     return;
   }
+  userArgs = moveArgumentToFront(userArgs, validation.normalizedUrl, cleanNonPrintableChars);
   const { backend: solvePerCommandIsolation, filteredArgs: userArgsWithoutIsolation } = extractIsolationFromArgs(userArgs); // issue #1534
   if (solvePerCommandIsolation && !isValidPerCommandIsolation(solvePerCommandIsolation)) {
     await safeReply(ctx, `❌ Invalid --isolation value '${escapeMarkdown(solvePerCommandIsolation)}'. Must be: screen, tmux, or docker`, { reply_to_message_id: ctx.message.message_id });
@@ -928,27 +943,14 @@ async function handleSolveCommand(ctx) {
     await safeReply(ctx, `❌ ${escapeMarkdown(branchError)}`, { reply_to_message_id: ctx.message.message_id });
     return;
   }
-  // Issue #1092: Detect malformed flag patterns like "-- model" (space after --)
-  const { malformed, errors: malformedErrors } = detectMalformedFlags(args);
-  if (malformed.length > 0) {
-    await safeReply(ctx, `❌ ${escapeMarkdown(malformedErrors.join('\n'))}\n\nPlease check your option syntax.`, { reply_to_message_id: ctx.message.message_id });
+  const { malformed: mergedMalformed, errors: mergedMalformedErrors } = detectMalformedFlags(args);
+  if (mergedMalformed.length > 0) {
+    await safeReply(ctx, `❌ ${escapeMarkdown(mergedMalformedErrors.join('\n'))}\n\nPlease check your option syntax.`, { reply_to_message_id: ctx.message.message_id });
     return;
   }
   // Validate merged arguments using solve's yargs config
   try {
-    // Use .parse() instead of yargs(args).parseSync() to ensure .strict() mode works
-    const testYargs = createSolveYargsConfig(yargs());
-
-    // Configure yargs to throw errors instead of trying to exit the process
-    // This prevents confusing error messages when validation fails but execution continues
-    let failureMessage = null;
-    testYargs.exitProcess(false).fail((msg, err) => {
-      // Capture the failure message instead of letting yargs print it
-      failureMessage = msg || (err && err.message) || 'Unknown validation error';
-      throw new Error(failureMessage);
-    });
-
-    testYargs.parse(args);
+    await parseArgsWithYargs(args, yargs, createSolveYargsConfig);
   } catch (error) {
     await safeReply(ctx, `❌ Invalid options: ${escapeMarkdown(error.message || String(error))}\n\nUse /help to see available options`, {
       reply_to_message_id: ctx.message.message_id,
@@ -1095,7 +1097,7 @@ async function handleHiveCommand(ctx) {
   const userArgs = parseCommandArgs(ctx.message.text);
 
   // Issue #1102: Allow issues_list/pulls_list URLs and normalize to repo URLs
-  const validation = validateGitHubUrl(userArgs, { allowedTypes: ['repo', 'organization', 'user', 'issues_list', 'pulls_list'], commandName: 'hive' });
+  const validation = await validateGitHubUrl(userArgs, { allowedTypes: ['repo', 'organization', 'user', 'issues_list', 'pulls_list'], commandName: 'hive', createYargsConfig: createHiveYargsConfig, positionalNames: ['github-url'] });
   if (!validation.valid) {
     let errorMsg = `❌ ${validation.error}`;
     if (validation.suggestion) errorMsg += `\n\n💡 Did you mean: \`${escapeMarkdown(validation.suggestion)}\``;
@@ -1104,7 +1106,7 @@ async function handleHiveCommand(ctx) {
     return;
   }
   // Normalize issues_list/pulls_list to base repo URL, or use cleaned URL
-  let normalizedArgs = [...userArgs];
+  let normalizedArgs = moveArgumentToFront(userArgs, validation.normalizedUrl, cleanNonPrintableChars);
   const p = validation.parsed;
   if (p && (p.type === 'issues_list' || p.type === 'pulls_list')) {
     normalizedArgs[0] = `https://github.com/${p.owner}/${p.repo}`;
@@ -1149,19 +1151,7 @@ async function handleHiveCommand(ctx) {
 
   // Validate merged arguments using hive's yargs config
   try {
-    // Use .parse() instead of yargs(args).parseSync() to ensure .strict() mode works
-    const testYargs = createHiveYargsConfig(yargs());
-
-    // Configure yargs to throw errors instead of trying to exit the process
-    // This prevents confusing error messages when validation fails but execution continues
-    let failureMessage = null;
-    testYargs.exitProcess(false).fail((msg, err) => {
-      // Capture the failure message instead of letting yargs print it
-      failureMessage = msg || (err && err.message) || 'Unknown validation error';
-      throw new Error(failureMessage);
-    });
-
-    testYargs.parse(args);
+    await parseArgsWithYargs(args, yargs, createHiveYargsConfig);
   } catch (error) {
     await safeReply(ctx, `❌ Invalid options: ${escapeMarkdown(error.message || String(error))}\n\nUse /help to see available options`, {
       reply_to_message_id: ctx.message.message_id,

package/src/telegram-solve-command.lib.mjs

@@ -59,6 +59,64 @@ export function parseCommandArgs(text) {
   return args;
 }
 
+function toCamelCaseOptionName(name) {
+  return name.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+}
+
+export function getYargsPositionalArg(argv, positionalNames = []) {
+  if (!argv || typeof argv !== 'object') return null;
+
+  for (const name of positionalNames) {
+    const aliases = [name, toCamelCaseOptionName(name)];
+    for (const alias of aliases) {
+      if (typeof argv[alias] === 'string' && argv[alias].trim()) return argv[alias];
+    }
+  }
+
+  if (Array.isArray(argv._)) {
+    return argv._.find(value => typeof value === 'string' && value.trim()) || null;
+  }
+
+  return null;
+}
+
+export async function parseArgsWithYargs(args, yargsFactory, createYargsConfig) {
+  const originalStderrWrite = process.stderr.write;
+  process.stderr.write = (_chunk, encoding, callback) => {
+    if (typeof encoding === 'function') encoding();
+    else if (typeof callback === 'function') callback();
+    return true;
+  };
+  try {
+    const parser = createYargsConfig(yargsFactory());
+    parser
+      .exitProcess(false)
+      .showHelpOnFail(false)
+      .fail((msg, err) => {
+        throw err || new Error(msg || 'Invalid arguments');
+      });
+    return await parser.parse(args);
+  } finally {
+    process.stderr.write = originalStderrWrite;
+  }
+}
+
+export async function getFirstParsedPositionalArg(args, yargsFactory, createYargsConfig, positionalNames = []) {
+  try {
+    return getYargsPositionalArg(await parseArgsWithYargs(args, yargsFactory, createYargsConfig), positionalNames);
+  } catch {
+    return null;
+  }
+}
+
+export function moveArgumentToFront(args, target, normalize = value => value) {
+  if (!target) return [...args];
+  const normalizedTarget = normalize(target);
+  const index = args.findIndex(arg => normalize(arg) === normalizedTarget);
+  if (index < 0) return [normalizedTarget, ...args];
+  return [normalizedTarget, ...args.slice(0, index), ...args.slice(index + 1)];
+}
+
 export function getSolveCommandNameFromText(text) {
   if (!text || typeof text !== 'string') {
     return null;