mixdog 0.9.95 → 0.9.97

package/src/standalone/{channel-daemon-transport.mjs → channel-transport.mjs}

@@ -1,4 +1,4 @@
-// Machine-global channels daemon — HTTP + SSE transport (server side).
+// Machine-global channel front door — HTTP + SSE transport (server side).
 //
 // Replaces the per-TUI fork + node-IPC (`{type:'call'|'notify'}`) plumbing with
 // ONE local HTTP server that many TUIs attach to. Design mirrors the memory
@@ -8,16 +8,17 @@
 // (targeted routing, never broadcast — see routeNotify below).
 //
 // This module owns ONLY the transport (sockets, client registry, notify
-// routing, discovery file, lifecycle). The channels runtime (tool dispatch,
-// Discord backend, transcript bind/steal) is injected via `handleCall` so the
+// routing and lifecycle). The channels runtime (tool dispatch,
+// Discord provider, transcript bind/steal) is injected via `handleCall` so the
 // same transport is exercised by the real daemon entry AND the smoke harness
 // (stub runtime, no Discord token).
 import http from 'node:http';
 import { randomUUID } from 'node:crypto';
 import { readFileSync, rmSync } from 'node:fs';
-import { basename, dirname, join } from 'node:path';
+import { basename } from 'node:path';
 import { writeJsonAtomicSync } from '../runtime/shared/atomic-file.mjs';
 import { readBody, sendJson, sendError } from '../runtime/memory/lib/http-wire.mjs';
+import { createFairCallScheduler } from './fair-call-scheduler.mjs';
 
 function parsePid(value) {
   const n = Number(value);
@@ -35,9 +36,8 @@ const ACTIVATE_TOOL = 'activate_channel_bridge';
 const REBIND_TOOL = 'rebind_current_transcript';
 const BINDING_TOOLS = new Set([ACTIVATE_TOOL, REBIND_TOOL]);
 
-export function createChannelDaemonTransport({
+export function createChannelTransport({
   handleCall,
-  discoveryPath,
   serverToken = randomUUID(),
   log = () => {},
   clientGraceMs = 10_000,
@@ -49,13 +49,12 @@ export function createChannelDaemonTransport({
   remoteStatePath = null,
   remoteIntentPath = null,
   onClientRegistered = null,
+  agentBroker = null,
 } = {}) {
   if (typeof handleCall !== 'function') throw new Error('handleCall is required');
 
-  const resolvedRemoteStatePath = remoteStatePath
-    || (discoveryPath ? join(dirname(discoveryPath), 'channel-remote-state.json') : null);
-  const resolvedRemoteIntentPath = remoteIntentPath
-    || (discoveryPath ? join(dirname(discoveryPath), 'channel-remote-intent.json') : null);
+  const resolvedRemoteStatePath = remoteStatePath;
+  const resolvedRemoteIntentPath = remoteIntentPath;
   // token -> { token, leadPid, cwd, sse, lastSeen, registeredAt }
   const clients = new Map();
   // The routing pointer is set ONLY by an explicit manual Remote ON. Client
@@ -81,6 +80,23 @@ export function createChannelDaemonTransport({
   // retry never double-runs a non-idempotent tool (e.g. reply). Short TTL.
   const callCache = new Map();
   const CALL_CACHE_TTL_MS = 60_000;
+  const configuredLaneLimit = (name) => {
+    const parsed = Math.floor(Number(process.env[name]));
+    return Number.isFinite(parsed) && parsed >= 1 ? parsed : Infinity;
+  };
+  const CALL_QUEUE_MAX = Math.max(256, Number(process.env.MIXDOG_CHANNEL_CALL_QUEUE) || 256);
+  const channelCalls = createFairCallScheduler({
+    name: 'channel call',
+    activeMax: configuredLaneLimit('MIXDOG_CHANNEL_ACTIVE_CALLS'),
+    queueMax: CALL_QUEUE_MAX,
+    minOwnerQueue: Math.max(8, Math.floor(CALL_QUEUE_MAX / 16)),
+  });
+  const channelControlCalls = createFairCallScheduler({
+    name: 'channel control call',
+    activeMax: configuredLaneLimit('MIXDOG_CHANNEL_CONTROL_RESERVE'),
+    queueMax: Math.max(16, Math.min(64, CALL_QUEUE_MAX)),
+    minOwnerQueue: 4,
+  });
   // Reconnect register replay: a server may commit replacement just before its
   // HTTP response is lost. The retry supplies this stable id and receives the
   // already-created fresh token instead of creating an orphan replacement.
@@ -91,6 +107,7 @@ export function createChannelDaemonTransport({
   let sweepTimer = null;
   let everHadClient = false;
   let closed = false;
+  let drainingReason = '';
 
   function nowMs() { return Date.now(); }
 
@@ -251,7 +268,7 @@ export function createChannelDaemonTransport({
     for (const [token, c] of clients) {
       // A client is dead when its lead pid is gone OR its SSE stream closed and
       // it has not re-registered within a grace window. pid death is the
-      // authoritative signal (mirrors memory daemon pruneDeadClients).
+      // authoritative signal for client liveness.
       if (!isPidAlive(c.leadPid)) {
         dropClient(token, 'pid dead');
       }
@@ -275,7 +292,7 @@ export function createChannelDaemonTransport({
     if (pointerToken === token) pointerToken = null;
     log(`client ${token} (lead=${c.leadPid}) removed: ${reason}`);
     // Owner removal always means Remote OFF. Never auto-select or rebind a
-    // survivor; explicitly deactivate the shared backend if the owner vanished
+    // survivor; explicitly deactivate the shared provider if the owner vanished
     // without first sending its normal active:false command.
     if (wasPointer) {
       remoteAcquired = false;
@@ -298,6 +315,14 @@ export function createChannelDaemonTransport({
     maybeArmGrace('client removed');
   }
 
+  function beginDrain(reason = 'daemon replacement') {
+    if (drainingReason) return false;
+    drainingReason = String(reason || 'daemon replacement');
+    cancelGrace();
+    for (const token of [...clients.keys()]) dropClient(token, drainingReason);
+    return true;
+  }
+
   function removeRegistrationReplay(registrationId, replay = registrationReplays.get(registrationId)) {
     if (!replay || registrationReplays.get(registrationId) !== replay) return;
     registrationReplays.delete(registrationId);
@@ -406,7 +431,7 @@ export function createChannelDaemonTransport({
   }
 
   // Manual ON is the only ownership transition. It may temporarily point at
-  // the claimant before backend activation so a synchronous acquired notify is
+  // the claimant before provider activation so a synchronous acquired notify is
   // routed correctly; the displaced owner is notified only after activation
   // succeeds.
   function movePointer(newToken, reason, { notifyDisplaced = true } = {}) {
@@ -489,10 +514,10 @@ export function createChannelDaemonTransport({
     }
   }
 
-  function registerClient({ leadPid, cwd, reattach = false, replaceToken = null, registrationId = null }) {
+  function registerClient({ leadPid, cwd, passive = false, replaceToken = null, registrationId = null }) {
     const pid = parsePid(leadPid) ?? 0;
     const replacementToken = replaceToken ? String(replaceToken) : null;
-    const replayId = reattach && registrationId ? String(registrationId).slice(0, 200) : null;
+    const replayId = passive && registrationId ? String(registrationId).slice(0, 200) : null;
     const existingReplay = replayId ? registrationReplays.get(replayId) : null;
     if (existingReplay) {
       if (existingReplay.leadPid === pid && existingReplay.cwd === (cwd || null) &&
@@ -522,9 +547,9 @@ export function createChannelDaemonTransport({
     cancelGrace();
     startSweep();
     log(`client registered token=${token} lead=${pid} cwd=${cwd || '-'}`);
-    // The unified backend starts the channels runtime (automation, webhooks,
-    // messaging backend) only once a CHANNELS client is actually present — an
-    // engine-only daemon must not run tunnels nobody asked for.
+    // The unified daemon starts the channels runtime (automation, webhooks,
+    // messaging provider) only once a CHANNELS client is actually present — an
+    // session runtime-only daemon must not run tunnels nobody asked for.
     if (typeof onClientRegistered === 'function') {
       try { onClientRegistered({ token, leadPid: pid, cwd: cwd || null }); } catch {}
     }
@@ -543,7 +568,7 @@ export function createChannelDaemonTransport({
     // not the pointer: retaining a non-owner old token would let it later call,
     // steal ownership, or accumulate a buffered frame after the fresh client
     // has gone away. Token replacement never crosses leadPid boundaries.
-    const replaced = reattach && replacementToken ? clients.get(replacementToken) : null;
+    const replaced = passive && replacementToken ? clients.get(replacementToken) : null;
     if (replaced && replaced.leadPid === pid) {
       const fresh = clients.get(token);
       const replacedWasPointer = pointerToken === replaced.token;
@@ -615,19 +640,33 @@ export function createChannelDaemonTransport({
     const pathName = url.pathname;
     try {
       if (req.method === 'GET' && pathName === '/health') {
-        sendJson(res, { status: 'ok', pid: process.pid, clients: clients.size, ...getStatus() });
+        sendJson(res, {
+          status: 'ok',
+          pid: process.pid,
+          clients: clients.size,
+          activeCalls: channelCalls.active + channelControlCalls.active,
+          queuedCalls: channelCalls.queued + channelControlCalls.queued,
+          callOwners: channelCalls.snapshot().owners,
+          draining: drainingReason || null,
+          ...(agentBroker?.snapshot ? { agentBroker: agentBroker.snapshot() } : {}),
+          ...getStatus(),
+        });
         return;
       }
       const token = req.headers['x-mixdog-daemon-token'] || url.searchParams.get('server_token');
       if (token !== serverToken) { sendError(res, 'forbidden', 403); return; }
 
       if (req.method === 'POST' && pathName === '/client/register') {
+        if (drainingReason) {
+          sendError(res, `daemon is draining: ${drainingReason}`, 503);
+          return;
+        }
         const body = await readBody(req);
         const clientToken = registerClient({
-          leadPid: body.leadPid, cwd: body.cwd, reattach: body.reattach === true,
+          leadPid: body.leadPid, cwd: body.cwd, passive: body.passive === true,
           replaceToken: body.replaceToken, registrationId: body.registrationId,
         });
-        const replayId = body.reattach === true && body.registrationId ? String(body.registrationId).slice(0, 200) : null;
+        const replayId = body.passive === true && body.registrationId ? String(body.registrationId).slice(0, 200) : null;
         res.once('finish', () => markRegistrationResponseFinished(replayId, clientToken));
         sendJson(res, { token: clientToken, pid: process.pid });
         return;
@@ -649,6 +688,45 @@ export function createChannelDaemonTransport({
         if (!attachSse(clientToken, res)) { sendError(res, 'unknown client token', 404); return; }
         return; // stream stays open
       }
+      // Internal memory -> session LLM bridge. It is authenticated with the
+      // daemon discovery token but deliberately does NOT register as a channel
+      // client: background memory work must not acquire remote ownership or
+      // keep the channels client registry alive. The broker itself owns a
+      // parallel fair scheduler and per-call cancellation.
+      if (req.method === 'POST' && pathName === '/agent/dispatch') {
+        if (!agentBroker?.dispatch) { sendError(res, 'agent broker unavailable', 503); return; }
+        const body = await readBody(req);
+        const callId = String(body.callId || '').trim();
+        if (!callId) { sendError(res, 'callId required', 400); return; }
+        res.on('close', () => {
+          if (res.writableFinished) return;
+          try { agentBroker.cancel(callId, 'agent broker client disconnected'); } catch {}
+        });
+        try {
+          const result = await agentBroker.dispatch(body.params || {}, { callId });
+          sendJson(res, { ok: true, result });
+        } catch (error) {
+          sendJson(res, { ok: false, error: error?.message || String(error) }, 200);
+        }
+        return;
+      }
+      if (req.method === 'POST' && pathName === '/agent/cancel') {
+        if (!agentBroker?.cancel) { sendError(res, 'agent broker unavailable', 503); return; }
+        const body = await readBody(req);
+        const callId = String(body.callId || '').trim();
+        if (!callId) { sendError(res, 'callId required', 400); return; }
+        const cancelled = agentBroker.cancelAndWait
+          ? await agentBroker.cancelAndWait(
+              callId,
+              String(body.reason || 'memory agent dispatch canceled'),
+            )
+          : agentBroker.cancel(callId, String(body.reason || 'memory agent dispatch canceled'));
+        sendJson(res, {
+          ok: true,
+          cancelled,
+        });
+        return;
+      }
       if (req.method === 'POST' && pathName === '/call') {
         const body = await readBody(req);
         const clientToken = body.token || null;
@@ -660,13 +738,21 @@ export function createChannelDaemonTransport({
         c.lastSeen = nowMs();
         const name = String(body.name || '');
         const callId = body.callId ? String(body.callId) : null;
+        const addressedSessionId = String(body.args?.sessionId || '').trim()
+          || remoteSessionIdFromBinding(name, body.args || {});
+        const ownerKey = addressedSessionId
+          ? `session:${addressedSessionId}`
+          : c.leadPid
+            ? `pid:${c.leadPid}`
+            : `client:${clientToken}`;
+        const cacheKey = callId ? `${ownerKey}\u0000${callId}` : null;
         let dispatch;
-        if (callId && callCache.has(callId)) {
+        if (cacheKey && callCache.has(cacheKey)) {
           // Replay of a retried call — dedup to the original run (exactly one
           // side-effect) instead of dispatching handleCall a second time.
-          dispatch = callCache.get(callId).promise;
+          dispatch = callCache.get(cacheKey).promise;
         } else {
-          dispatch = Promise.resolve().then(async () => {
+          const run = async () => {
             const args = body.args || {};
             const activationCall = name === ACTIVATE_TOOL;
             const activating = activationCall && args.active === true;
@@ -748,15 +834,20 @@ export function createChannelDaemonTransport({
               }
               throw err;
             }
-          });
-          if (callId) {
-            callCache.set(callId, { promise: dispatch, at: nowMs() });
+          };
+          const scheduler = BINDING_TOOLS.has(name) ? channelControlCalls : channelCalls;
+          dispatch = scheduler.enqueue(ownerKey, run);
+          if (cacheKey) {
+            const record = { promise: dispatch, at: nowMs() };
+            callCache.set(cacheKey, record);
             // Start the TTL only once the call SETTLES: an in-flight call can
             // outlive a fixed-from-dispatch TTL (e.g. a slow reply upload past
             // 60s), and expiring its entry mid-flight would let a transport
             // retry replay-miss and dispatch a second real side-effect.
             dispatch.then(() => {}, () => {}).then(() => {
-              const t = setTimeout(() => callCache.delete(callId), CALL_CACHE_TTL_MS);
+              const t = setTimeout(() => {
+                if (callCache.get(cacheKey) === record) callCache.delete(cacheKey);
+              }, CALL_CACHE_TTL_MS);
               t.unref?.();
             });
           }
@@ -780,20 +871,6 @@ export function createChannelDaemonTransport({
     }
   }
 
-  function writeDiscovery() {
-    if (!discoveryPath) return;
-    try {
-      writeJsonAtomicSync(discoveryPath, {
-        pid: process.pid,
-        port: boundPort,
-        token: serverToken,
-        startedAt: Date.now(),
-      }, { compact: true });
-    } catch (err) {
-      log(`discovery write failed: ${err?.message || err}`);
-    }
-  }
-
   function start() {
     return new Promise((resolve, reject) => {
       server = http.createServer(handleRequest);
@@ -803,7 +880,6 @@ export function createChannelDaemonTransport({
         server.removeListener('error', reject);
         boundPort = server.address().port;
         server.on('error', (err) => log(`server error: ${err?.message || err}`));
-        writeDiscovery();
         publishRemoteOwnerState();
         log(`daemon transport listening on 127.0.0.1:${boundPort} pid=${process.pid}`);
         resolve({ port: boundPort, token: serverToken });
@@ -813,6 +889,8 @@ export function createChannelDaemonTransport({
 
   async function stop() {
     closed = true;
+    channelCalls.close('channel transport is closed');
+    channelControlCalls.close('channel transport is closed');
     cancelGrace();
     if (sweepTimer) { try { clearInterval(sweepTimer); } catch {} sweepTimer = null; }
     for (const [token] of clients) dropClient(token, 'transport stop');
@@ -820,7 +898,6 @@ export function createChannelDaemonTransport({
     pointerToken = null;
     publishRemoteOwnerState();
     clearRegistrationReplays();
-    if (discoveryPath) { try { rmSync(discoveryPath, { force: true }); } catch {} }
     if (server) {
       await new Promise((resolve) => { try { server.close(() => resolve()); } catch { resolve(); } });
       server = null;
@@ -831,11 +908,15 @@ export function createChannelDaemonTransport({
     start,
     stop,
     notify,
+    beginDrain,
     get port() { return boundPort; },
     get token() { return serverToken; },
-    // The unified daemon hosts channels AND engines: it may only self-shutdown
+    // The unified daemon hosts channels AND session runtimes: it may only self-shutdown
     // when BOTH sides are empty, so each transport has to expose its liveness.
     get clientCount() { return clients.size; },
+    get activeCount() { return channelCalls.active + channelControlCalls.active; },
+    get queuedCount() { return channelCalls.queued + channelControlCalls.queued; },
+    get draining() { return Boolean(drainingReason); },
     _clientsForTest: clients,
     _registrationReplaysForTest: registrationReplays,
     _resolveTargetForTest: resolveTarget,