mixdog 0.9.23 → 0.9.25

package/src/runtime/agent/orchestrator/tools/shell-command.mjs

@@ -37,7 +37,7 @@ import { startChildGuardian } from '../../../shared/child-guardian.mjs';
 // transition). shell-jobs.mjs imports stripAnsi from this module, so this is
 // a static cycle — safe because neither binding is touched at module-eval
 // time, only when the respective functions actually run.
-import { adoptForegroundShellJob } from './builtin/shell-jobs.mjs';
+import { adoptForegroundShellJob, killShellJob } from './builtin/shell-jobs.mjs';
 import {
   _maybeEncodePowerShellCommand,
   extractPowerShellCommandInner,
@@ -494,6 +494,7 @@ export function execShellCommand({
   autoBackgroundMs,
   onProgress,
   clientHostPid,
+  backgroundOnTimeout,
 }) {
   return new Promise(async (resolve) => {
     const taskId = `shell_${randomUUID().slice(0, 8)}`;
@@ -723,16 +724,20 @@ export function execShellCommand({
       if (grace.unref) grace.unref();
     });
 
-    // Auto-background transition (CC ASSISTANT_BLOCKING_BUDGET_MS +
-    // startBackgrounding analogue). Fires once, autoBackgroundMs after spawn,
-    // IFF the child is still running and the run has not already settled /
-    // been killed / timed out. It adopts the child into the shell-jobs
-    // registry while keeping it owned by this CLI process, then resolves the
-    // call immediately with a 'backgrounded' result so the tool stops hanging.
-    // The 600 s timeoutMs upper bound is carried into the adopted job detail
-    // so refreshShellJob still enforces it. Mutually exclusive with settle()
-    // via the autoBackgrounded flag set synchronously at the top before any await.
-    const _autoBackground = async () => {
+    // Auto-background transition (CC startBackgrounding analogue). Two triggers
+    // resolve the call immediately with a 'backgrounded' result while the
+    // child keeps running, adopted into the shell-jobs registry but still
+    // owned by this CLI process:
+    //   1. the optional autoBackgroundMs soft threshold (MIXDOG_SHELL_AUTO_
+    //      BACKGROUND_MS opt-in) — an EARLIER promotion before the timeout, and
+    //   2. the foreground timeout deadline (backgroundOnTimeout) — the default
+    //      promote-on-timeout that replaces the old tree-kill.
+    // Either way the adopted job runs UNLIMITED (timeoutMs 0, matching the
+    // async default): the original foreground timeout no longer bounds it, and
+    // the adopted-job cap poll still enforces the 100 MB output ceiling.
+    // Mutually exclusive with settle() via the autoBackgrounded flag set
+    // synchronously at the top before any await.
+    const _autoBackground = async ({ reason = 'threshold' } = {}) => {
       // Win the race: bail if a terminal transition already happened, and
       // claim the transition synchronously so a concurrently-queued settle()
       // (which checks autoBackgrounded) becomes inert.
@@ -740,16 +745,18 @@ export function execShellCommand({
       if (child.exitCode != null || child.signalCode != null) return;
       autoBackgrounded = true;
       // The foreground capture is over; stop the local watchdogs/timers so
-      // they cannot treeKill the now-adopted child. The 600 s bound lives
-      // on in the adopted job detail (timeoutMs) for refreshShellJob.
+      // they cannot treeKill the now-adopted child. The adopted job runs
+      // unlimited; refreshShellJob only enforces the output cap.
       if (timer) { clearTimeout(timer); timer = null; }
       _clearProgressTimer();
       if (sizeWatchdog) { clearInterval(sizeWatchdog); sizeWatchdog = null; }
       if (autoBgTimer) { clearTimeout(autoBgTimer); autoBgTimer = null; }
-      if (abortSignal && abortHandler) {
-        try { abortSignal.removeEventListener('abort', abortHandler); } catch {}
-        abortHandler = null;
-      }
+      // Keep the abort handler ATTACHED through the promotion window. A user
+      // cancel racing in after promotion starts must still bring the adopted
+      // child down — the handler's treeKill(child) does exactly that (settle()
+      // is inert once autoBackgrounded, but the kill itself still lands, and
+      // refreshShellJob then flags the job failed). We only detach on a real
+      // settle() or on the adoption-failure fallback below.
       // Every subsequent stdout/stderr chunk must hit disk — the call is
       // about to resolve and nobody will drain the in-memory buffers again.
       try { taskOutput.forceSpill(); } catch {}
@@ -766,7 +773,9 @@ export function execShellCommand({
           command,
           cwd,
           pid: child.pid,
-          timeoutMs,
+          // Unlimited: the promoted job is no longer bounded by the foreground
+          // timeout (matches the async omitted-default behavior).
+          timeoutMs: 0,
           mergeStderr: false,
           stdoutPath,
           stderrPath,
@@ -777,6 +786,18 @@ export function execShellCommand({
       } catch {
         job = null;
       }
+      // Adoption failed AFTER the foreground timers/size-watchdog were already
+      // torn down. Do NOT resolve as backgrounded — that would leave the child
+      // running unlimited with no task_id and no watcher. Release the claim and
+      // fall back to the old kill path so the command never outlives a failed
+      // promotion. (The abort handler is still attached, so an in-flight cancel
+      // is honored by the kill path too.)
+      if (!job) {
+        autoBackgrounded = false;
+        if (reason === 'timeout') timedOut = true; else killed = true;
+        _treeKillForceSettle();
+        return;
+      }
       // Wire the lifecycle: on close, write the exit-code file FIRST then
       // touch donePath STRICTLY AFTER — the exact ordering refreshShellJob()
       // gates completion on (donePath visible ⇒ exit file fully flushed).
@@ -787,6 +808,14 @@ export function execShellCommand({
           try { writeFileSync(job.donePath, ''); } catch {}
         });
       }
+      // Adoption committed. If a cancel already fired (before or during the
+      // adoption window), bring the now-adopted child down via its jobId so the
+      // promotion can't outlive a user abort. Idempotent with the still-attached
+      // abort handler's treeKill.
+      if (abortSignal && abortSignal.aborted) {
+        try { killShellJob(job.jobId); } catch {}
+        try { treeKill(child); } catch {}
+      }
       // Snapshot the partial output captured so far for the immediate result.
       let stdout = '';
       let stderr = '';
@@ -795,7 +824,10 @@ export function execShellCommand({
       try { stderr = await taskOutput.getStderr(); }
       catch (err) { taskOutput.writeError = taskOutput.writeError || err; }
       const jobId = job ? job.jobId : null;
-      const secs = Math.round(autoBackgroundMs / 1000);
+      const secs = Math.max(0, Math.round((Date.now() - _startMs) / 1000));
+      const _verb = reason === 'timeout'
+        ? `moved to background at timeout after ${secs}s`
+        : `auto-backgrounded after ${secs}s`;
       resolve(
         new ExecResult({
           stdout,
@@ -814,14 +846,31 @@ export function execShellCommand({
           backgrounded: true,
           jobId,
           backgroundMessage: jobId
-            ? `auto-backgrounded after ${secs}s; still running — completion will be delivered as a background task notification. Use task with task_id:${jobId} only for manual wait/status/read/cancel.`
-            : `auto-backgrounded after ${secs}s; still running`,
+            ? `${_verb}; still running — completion will be delivered as a background task notification. Use task with task_id:${jobId} only for manual wait/status/read/cancel.`
+            : `${_verb}; still running`,
         }),
       );
     };
 
     if (timeoutMs > 0) {
       timer = setTimeout(() => {
+        // Promote-on-timeout: if the caller allows backgrounding and the child
+        // is still running (not a trailing-`&` detach), adopt it as a tracked
+        // background job instead of tree-killing it. Falls through to the old
+        // kill path for disallowed/opted-out commands (backgroundOnTimeout
+        // false) or when a terminal transition already won the race.
+        if (
+          backgroundOnTimeout &&
+          !_isBackground &&
+          !settled &&
+          !autoBackgrounded &&
+          !killed &&
+          child.exitCode == null &&
+          child.signalCode == null
+        ) {
+          _autoBackground({ reason: 'timeout' });
+          return;
+        }
         timedOut = true;
         _treeKillForceSettle();
       }, timeoutMs);

package/src/runtime/channels/backends/discord.mjs

@@ -435,14 +435,21 @@ class DiscordBackend {
     const msg = await ch.messages.fetch(messageId);
     if (msg.attachments.size === 0) return [];
     const results = [];
+    // Optional filter bounds what gets fetched (e.g. image/* only) so a
+    // caller after images never pulls unrelated large attachments.
+    const filter = typeof opts.filter === "function" ? opts.filter : null;
     for (const att of msg.attachments.values()) {
-      const path = await this.downloadSingleAttachment(att, opts);
-      results.push({
+      const meta = {
         id: att.id,
-        path,
         name: safeAttName(att),
         contentType: att.contentType ?? "unknown",
         size: att.size
+      };
+      if (filter && !filter(meta)) continue;
+      const path = await this.downloadSingleAttachment(att, opts);
+      results.push({
+        ...meta,
+        path
       });
     }
     return results;

package/src/runtime/channels/lib/crash-log.mjs

@@ -23,8 +23,9 @@ function isChannelsDegraded() { return _channelsDegraded; }
 try {
   process.stderr.on('error', (e) => {
     if (e && (e.code === 'EPIPE' || /EPIPE/.test(String(e.message || '')))) {
+      // Parent stdio pipe loss stops stderr writes only. It is NOT runtime
+      // corruption, so it must not degrade tool dispatch (_channelsDegraded).
       _stderrBroken = true;
-      _channelsDegraded = true;
     }
   });
 } catch {}
@@ -75,7 +76,8 @@ ${err instanceof Error ? err.stack : ""}
     _writeCrashLine(crashLog, msg);
   }
   if (err instanceof Error && err.message.includes("EPIPE")) {
-    _channelsDegraded = true;
+    // EPIPE = a broken pipe (parent stdio/IPC gone), not corrupted runtime
+    // state. Stop writing to the dead pipe but keep serving tool calls.
     _stderrBroken = true;
   }
   crashLogging = false;

package/src/runtime/channels/lib/inbound-handler.mjs

@@ -10,6 +10,9 @@ import { isNetworkError, retryOnNetwork } from "./network-retry.mjs";
 // preserving): serial inbound queue, backend.onMessage transcript (re)bind +
 // steal logic, and handleInbound voice-transcription + parent notify. Bound to
 // live runtime getters and shared primitives.
+function isImageAttachment(contentType) {
+  return typeof contentType === "string" && contentType.toLowerCase().startsWith("image/");
+}
 export function createInboundHandler({
   getBackend,
   getConfig,
@@ -283,6 +286,46 @@ async function handleInbound(msg, route, options = {}) {
     }
   }
   const hasVoiceAtt = voiceAtts.length > 0;
+  // ── Inbound image attachments → downloaded local paths (vision) ──────
+  // Mirror the voice path: download image/* attachments to the inbox and
+  // hand their local paths downstream so the agent session can attach them
+  // as real image content blocks. A short per-attempt timeout bounds the
+  // serial inboundQueue against a slow/broken image; on failure we degrade
+  // to the metadata-only marker (attMeta below) instead of dropping.
+  const imageAtts = msg.attachments.filter((a) => isImageAttachment(a.contentType));
+  let imagePaths = [];
+  if (imageAtts.length > 0) {
+    try {
+      const files = (await retryOnNetwork(
+        () => getBackend().downloadAttachment(msg.chatId, msg.messageId, {
+          timeoutMs: 20_000,
+          filter: (a) => isImageAttachment(a.contentType),
+        }),
+        { label: "image.download" }
+      )) || [];
+      imagePaths = imageAtts
+        .map((a) => files.find((df) => df.id === a.id) ?? null)
+        .filter(Boolean)
+        .map((f) => f.path)
+        .filter((p) => typeof p === "string" && p.length > 0);
+      if (imagePaths.length > 0) {
+        process.stderr.write(`mixdog: inbound images downloaded (${imagePaths.length})\n`);
+      }
+    } catch (err) {
+      const netFail = isNetworkError(err);
+      process.stderr.write(`mixdog: image.download error${netFail ? " (network, retries exhausted)" : ""}: ${err}\n`);
+      const marker = netFail
+        ? "[attachment: image download failed (network)]"
+        : "[attachment: image download failed]";
+      text = text ? `${text} ${marker}` : marker;
+    }
+  }
+  // An image-only message can arrive with empty text; channelNotificationModelContent
+  // drops empty content (runtime-core), which would strip meta.image_paths and lose
+  // the image. Give it a non-empty marker so the notification (and its images) flow.
+  if (imagePaths.length > 0 && !String(text || "").trim()) {
+    text = "[image]";
+  }
   const attMeta = msg.attachments.length > 0 && !hasVoiceAtt ? {
     attachment_count: String(msg.attachments.length),
     attachments: msg.attachments.map((a) => `${a.name} (${a.contentType}, ${(a.size / 1024).toFixed(0)}KB)`).join("; ")
@@ -300,7 +343,8 @@ async function handleInbound(msg, route, options = {}) {
       ...route.sourceLabel ? { source_label: route.sourceLabel } : {}
     } : {},
     ...attMeta,
-    ...msg.imagePath ? { image_path: msg.imagePath } : {}
+    ...msg.imagePath ? { image_path: msg.imagePath } : {},
+    ...imagePaths.length > 0 ? { image_paths: JSON.stringify(imagePaths) } : {}
   };
   const notificationContent = messageBody;
   sendNotifyToParent("notifications/claude/channel", {

package/src/runtime/channels/lib/output-forwarder.mjs

@@ -6,6 +6,7 @@ import {
   formatToolSurface,
   isExplorerSurface,
   isMemorySurface,
+  stripToolPrefix,
 } from "../../shared/tool-surface.mjs";
 import {
   cwdToProjectSlug,
@@ -726,7 +727,7 @@ ${_bt.trim()}` : _bt.trim();
     // The non-set checks are inlined rather than delegated to the imported
     // isHidden, because that helper would re-consult the module-local
     // HIDDEN_TOOLS Set and ignore the OutputForwarder static.
-    if (OutputForwarder.HIDDEN_TOOLS.has(name)) return true;
+    if (OutputForwarder.HIDDEN_TOOLS.has(name) || OutputForwarder.HIDDEN_TOOLS.has(stripToolPrefix(name))) return true;
     if (name === "reply" || name === "fetch") return true;
     return false;
   };