mixdog 1.4.0 → 1.4.2

package/src/standalone/session-frame-stream.mjs

@@ -1,6 +1,8 @@
-// Session snapshots are latest-wins under backpressure; terminal byte streams
-// concatenate instead. Keep socket ownership and bounded backlog policy here.
+// Session snapshots are latest-wins under backpressure; a session patch chains
+// onto the queued frame it builds on, and terminal byte streams concatenate.
+// Keep socket ownership and bounded backlog policy here.
 const TERMINAL_BACKLOG_MAX_CHARS = 256 * 1024;
+const KEEPALIVE_MS = 15_000;
 
 function terminalDataFrame(frame) {
   return frame?.type === 'desktop-event' &&
@@ -26,13 +28,28 @@ function mergePendingFrame(existing, frame, json) {
 }
 
 function pendingEntry(frame, json, queuedAt) {
-  return { frame, json, bytes: Buffer.byteLength(json) + 8, queuedAt };
+  const sse = `data: ${json}\n\n`;
+  return { frame, sse, bytes: Buffer.byteLength(sse), queuedAt };
 }
 
 function isResyncMarker(frame) {
   return frame?.resyncRequired === true || frame?.message?.resyncRequired === true;
 }
 
+// A patch builds on the frame queued before it for the same key. Replacing
+// that frame hands the receiver a lane it cannot decode, and the resync it
+// asks for re-sends the full snapshot into the same backlog.
+function isPatchFrame(frame) {
+  if (isResyncMarker(frame)) return false;
+  if (frame?.type === 'session-state') return Boolean(frame.patch) && Number.isSafeInteger(frame.baseRevision);
+  const wire = frame?.type === 'desktop-event' && frame.message?.kind === 'session-state' ? frame.message.wire : null;
+  return Boolean(wire?.__itemsPatch);
+}
+
+function readTraceIdOf(frame) {
+  return frame?.readTraceId ?? frame?.message?.readTraceId;
+}
+
 function resyncEntry(frame) {
   if (frame?.type === 'desktop-event' && frame.message?.kind === 'session-state' && frame.message.sessionId) {
     // The desktop decoder cannot apply a patch against base -2, so it resets
@@ -116,13 +133,39 @@ export function createSessionFrameStream({ clients, maxPendingBytes, nowMs, onAt
     } catch {}
   }
 
+  function pause(client) {
+    if (!client.paused) client.pausedAt = nowMs();
+    client.paused = true;
+  }
+
+  // A stream paused across a keepalive period: bytes still buffered mean the
+  // consumer stopped reading; none buffered means a drain that never fired.
+  function reportStall(client, res) {
+    if (typeof onDiagnostic !== 'function') return;
+    const atMs = nowMs();
+    if (atMs - client.pausedAt < KEEPALIVE_MS) return;
+    try {
+      onDiagnostic({
+        stage: 'stream-stalled',
+        atMs,
+        pausedMs: atMs - client.pausedAt,
+        bufferedBytes: res.writableLength,
+        needDrain: res.writableNeedDrain,
+        pendingBytes: client.pendingBytes || 0,
+        maxPendingBytes,
+      });
+    } catch {
+      /* A diagnostic failure cannot change backpressure. */
+    }
+  }
+
   function flushPending(client) {
     while (client.sse && !client.paused && client.pending.size > 0) {
       const [key, entry] = client.pending.entries().next().value;
       client.pending.delete(key);
       client.pendingBytes = Math.max(0, client.pendingBytes - (entry.bytes || 0));
       try {
-        if (client.sse.write(`data: ${entry.json}\n\n`) === false) client.paused = true;
+        if (client.sse.write(entry.sse) === false) pause(client);
         traceFrame(client, entry.frame, 'stream-write', entry);
       } catch {
         traceFrame(client, entry.frame, 'stream-write-failed', entry, true);
@@ -144,13 +187,18 @@ export function createSessionFrameStream({ clients, maxPendingBytes, nowMs, onAt
     client.pending.set(key, entry);
     client.pendingBytes += entry.bytes || 0;
     traceFrame(client, entry.frame, 'stream-queued', entry);
+    boundPending(client, key);
+  }
+
+  function boundPending(client, key) {
     // The cap bounds accumulated backlog: older entries collapse to resync
     // markers or drop, oldest first. The newest frame is always admitted, so a
     // snapshot larger than the cap still reaches a client with no backlog, and
     // markers are kept so a receiver always learns what it missed.
     for (const [oldestKey, oldest] of client.pending) {
       if (client.pendingBytes <= maxPendingBytes) break;
-      if (oldestKey === key || isResyncMarker(oldest.frame)) continue;
+      // Only a single newest frame is exempt: a patch chain is backlog too.
+      if ((oldestKey === key && !oldest.chained) || isResyncMarker(oldest.frame)) continue;
       const marker = resyncEntry(oldest.frame);
       if (marker && marker.bytes < oldest.bytes) {
         traceFrame(client, oldest.frame, 'stream-resync-marker', oldest, true);
@@ -166,7 +214,26 @@ export function createSessionFrameStream({ clients, maxPendingBytes, nowMs, onAt
   }
 
   function queueFrame(client, key, frame, json) {
-    const merged = mergePendingFrame(client.pending.get(key), frame, json);
+    const existing = client.pending.get(key);
+    if (existing && isPatchFrame(frame)) {
+      // A queued marker already makes the receiver fetch a fresh full
+      // snapshot, which supersedes every patch issued before it.
+      if (isResyncMarker(existing.frame)) return;
+      const next = pendingEntry(frame, json, nowMs());
+      // Map.set on a present key keeps its place: the chain leaves with its base.
+      client.pending.set(key, {
+        frame: readTraceIdOf(existing.frame) ? existing.frame : frame,
+        sse: existing.sse + next.sse,
+        bytes: existing.bytes + next.bytes,
+        queuedAt: existing.queuedAt,
+        chained: true,
+      });
+      client.pendingBytes += next.bytes;
+      traceFrame(client, frame, 'stream-queued', next);
+      boundPending(client, key);
+      return;
+    }
+    const merged = mergePendingFrame(existing, frame, json);
     setPending(client, key, pendingEntry(merged.frame, merged.json, nowMs()));
   }
 
@@ -177,7 +244,7 @@ export function createSessionFrameStream({ clients, maxPendingBytes, nowMs, onAt
       return;
     }
     try {
-      if (client.sse.write(`data: ${json}\n\n`) === false) client.paused = true;
+      if (client.sse.write(`data: ${json}\n\n`) === false) pause(client);
       traceFrame(client, frame, 'stream-write');
     } catch {
       traceFrame(client, frame, 'stream-write-failed', {}, true);
@@ -221,7 +288,8 @@ export function createSessionFrameStream({ clients, maxPendingBytes, nowMs, onAt
     const paused = res.write(': attached\n\n') === false;
     const previous = client.sse;
     client.sse = res;
-    client.paused = paused;
+    client.paused = false;
+    if (paused) pause(client);
     client.lastSeen = nowMs();
     // Replacement transfers ownership before closing the old stream, so its
     // close/error callbacks cannot detach the new response.
@@ -252,13 +320,17 @@ export function createSessionFrameStream({ clients, maxPendingBytes, nowMs, onAt
     res.on('close', cleanup);
     res.on('error', cleanup);
     keepAlive = setInterval(() => {
-      if (client.sse !== res || client.paused) return;
+      if (client.sse !== res) return;
+      if (client.paused) {
+        reportStall(client, res);
+        return;
+      }
       try {
-        if (res.write(': ka\n\n') === false) client.paused = true;
+        if (res.write(': ka\n\n') === false) pause(client);
       } catch {
         retireStream(res);
       }
-    }, 15_000);
+    }, KEEPALIVE_MS);
     keepAlive.unref?.();
     flushPending(client);
     return true;

package/src/standalone/session-protocol.mjs

@@ -16,6 +16,7 @@ export const SESSION_READ_ACTIONS = Object.freeze([
   'getAgentConnectors',
   'getProjectConnectors',
   'getAgentAlwaysAllowedTools',
+  'getAgentConnectorTools',
   'getAgentPermissions',
   'listConnectors',
   'listConnectorTools',
@@ -94,6 +95,7 @@ export const SESSION_READ_ACTIONS = Object.freeze([
   'listWebSearchModels',
   'listThemes',
   'listShellJobs',
+  'listStoppableShellJobs',
   'listWorkflows',
   'mcpStatus',
   'pluginsStatus',
@@ -107,6 +109,7 @@ export const SESSION_READ_ACTIONS = Object.freeze([
 export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'addHookRule',
   'addMcpServer',
+  'addConnectorAccount',
   'addPlugin',
   'addSkill',
   'agentControl',
@@ -269,6 +272,7 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'startConversationImport',
   'startMediaJob',
   'stopShellJob',
+  'stopShellJobs',
   'releaseShellJob',
   'switchContext',
   'taskControl',

package/src/standalone/session-service/agent-tree/agent-turns.mjs

@@ -5,8 +5,12 @@ import { randomUUID } from 'node:crypto';
 import { createAgentChildFactory } from './agent-child.mjs';
 import { partialHandoffTextFromSession } from '../../../runtime/agent/orchestrator/agent-runtime/agent-progress-watchdog.mjs';
 import { attachmentsForIntake } from '../../../runtime/attachments/store.mjs';
-import { artifactLines } from '../../../runtime/shared/handoff-artifacts.mjs';
-import { collectTurnArtifacts, handoffContent, sessionRoots } from '../../../session-runtime/handoff-attachments.mjs';
+import { producedFileLines } from '../../../runtime/shared/handoff-artifacts.mjs';
+import {
+  collectUnreportedWrites,
+  handoffContent,
+  sessionRoots,
+} from '../../../session-runtime/handoff-attachments.mjs';
 
 /** An agent turn's prompt: text, or text with forwarded attachment parts
  *  (handoff-attachments.mjs), never any other shape. */
@@ -25,18 +29,19 @@ export function agentTurnTranscriptMeta(content) {
   return { sender: 'lead', ...(attachments.length ? { attachments } : {}) };
 }
 
-/** The artifact lines of the turn that began at `messageStart`; [] on any
- *  failure to read it (the handoff still goes out). */
-async function turnArtifactLines(runtime, messageStart, descriptor) {
+/** The lines for files the turn that began at `messageStart` created or
+ *  modified and `report` does not already name; [] on any failure to read it
+ *  (the handoff still goes out). */
+async function turnArtifactLines(runtime, messageStart, descriptor, report) {
   try {
     const { messages } = await runtime.readModelMessages(messageStart);
     const session = runtime.session || descriptor;
-    const { files, omitted } = collectTurnArtifacts(messages, {
+    const { files, omitted } = collectUnreportedWrites(messages, {
       cwd: descriptor.cwd,
       roots: sessionRoots(session, descriptor.cwd),
+      report,
     });
-    // Text only: the caller forwards these by path (an id in text is never trusted).
-    return artifactLines(files, omitted, { ids: false });
+    return producedFileLines(files, omitted);
   } catch {
     return [];
   }
@@ -131,10 +136,9 @@ export function createAgentTurns({
       }
       let result = detail?.result || { content: '' };
       // The files the turn produced reach the owner with its handoff.
-      const files = await turnArtifactLines(entry.runtime, messageStart, descriptor);
-      if (files.length) {
-        result = { ...result, content: [String(result.content || ''), files.join('\n')].join('\n\n') };
-      }
+      const report = String(result.content || '');
+      const files = await turnArtifactLines(entry.runtime, messageStart, descriptor, report);
+      if (files.length) result = { ...result, content: [report, files.join('\n')].join('\n\n') };
       descriptor.status = 'idle';
       descriptor.stage = 'idle';
       descriptor.lastHandoff = typeof result?.content === 'string' ? result.content : '';

package/src/standalone/session-service/agent-tree.mjs

@@ -47,18 +47,51 @@ export function createAgentTree({
     cancelTranscripts.delete(sessionId);
     return messages;
   };
+  // How each session's last snapshot was obtained. A wire-safe runtime is read
+  // asynchronously and the watchdog judges the cached result, so a failed or
+  // hung read leaves old clocks that the watchdog row must be able to flag.
+  const progressObservation = new Map();
+  const observationOf = (sessionId) => {
+    let observation = progressObservation.get(sessionId);
+    if (!observation) {
+      observation = { source: null, lastReadOkAt: null, readPendingSince: null, lastReadError: null };
+      progressObservation.set(sessionId, observation);
+    }
+    return observation;
+  };
   function getSessionProgressSnapshot(sessionId) {
     const runtime = sessionOwner(sessionId)?.runtime;
     if (typeof runtime?.getTurnLiveness !== 'function') return null;
-    if (runtime.isWireSafe !== true) return runtime.getTurnLiveness();
+    const observation = observationOf(sessionId);
+    if (runtime.isWireSafe !== true) {
+      const snapshot = runtime.getTurnLiveness();
+      observation.source = snapshot ? 'direct' : null;
+      if (snapshot) observation.lastReadOkAt = Date.now();
+      return snapshot;
+    }
     if (!progressReads.has(sessionId)) {
       progressReads.add(sessionId);
-      Promise.resolve(runtime.getTurnLiveness())
-        .then((snapshot) => progress.set(sessionId, snapshot))
-        .catch((error) => log(`agent progress read failed session=${sessionId}: ${error?.message || error}`))
-        .finally(() => progressReads.delete(sessionId));
+      observation.readPendingSince = Date.now();
+      // A synchronous throw must settle like a rejected read; otherwise the
+      // session stays in progressReads and is never read again.
+      new Promise((resolve) => resolve(runtime.getTurnLiveness()))
+        .then((snapshot) => {
+          progress.set(sessionId, snapshot);
+          observation.lastReadOkAt = Date.now();
+          observation.lastReadError = null;
+        })
+        .catch((error) => {
+          observation.lastReadError = String(error?.code || error?.name || 'Error').slice(0, 40);
+          log(`agent progress read failed session=${sessionId}: ${error?.message || error}`);
+        })
+        .finally(() => {
+          progressReads.delete(sessionId);
+          observation.readPendingSince = null;
+        });
     }
-    return progress.get(sessionId) || null;
+    const cached = progress.get(sessionId) || null;
+    observation.source = cached ? 'cache' : null;
+    return cached;
   }
   const { rehydrateAgentSessions } = createAgentRehydration({ registry, listSessions, readStoredSession, log });
   const { createAgentChild, runAgentTurn } = createAgentTurns({
@@ -169,14 +202,17 @@ export function createAgentTree({
         : null;
     },
     getSessionProgressSnapshot,
+    getSessionProgressObservation: (sessionId) => ({ ...observationOf(sessionId) }),
     linkParentSignalToSession(sessionId, signal) {
       const runtime = sessionOwner(sessionId)?.runtime;
       if (typeof runtime?.abort !== 'function') throw new Error(`agent runtime cannot abort session ${sessionId}`);
       const abort = () => {
         watchdogStops.set(sessionId, signal.reason);
-        Promise.resolve(runtime.abort({ restorePrompt: false, reason: 'agent-watchdog' })).catch((error) => {
-          log(`agent watchdog abort failed session=${sessionId}: ${error?.message || error}`);
-        });
+        Promise.resolve(runtime.abort({ restorePrompt: false, reason: 'agent-watchdog', timeout: true })).catch(
+          (error) => {
+            log(`agent watchdog abort failed session=${sessionId}: ${error?.message || error}`);
+          }
+        );
       };
       if (signal.aborted) abort();
       else signal.addEventListener('abort', abort, { once: true });