mixdog 0.9.151 → 0.9.152

package/src/standalone/session-runtime-agent-control-client.mjs

@@ -0,0 +1,133 @@
+'use strict';
+
+// Runtime-shard client for distributed Agent control.
+//
+// A Lead runtime and every Subagent it creates used to share one worker
+// process even after top-level session sharding. Agent control now crosses the
+// existing shard IPC link: the daemon chooses a target shard, while the target
+// keeps the ordinary persistent Agent tool/tag/session implementation.
+import { safeIpcSend } from '../runtime/shared/safe-ipc-send.mjs';
+import { isSessionRuntimeWorkerProcess } from '../runtime/shared/child-spawn-remote.mjs';
+
+const pending = new Map();
+let sequence = 0;
+let listening = false;
+
+function remoteError(body) {
+  const error = new Error(String(body?.message || 'remote agent control failed'));
+  if (body?.name) error.name = String(body.name);
+  if (body?.stack) error.stack = String(body.stack);
+  if (body?.code) error.code = String(body.code);
+  return error;
+}
+
+function ensureListener() {
+  if (listening) return;
+  listening = true;
+  process.on('message', (message) => {
+    if (!message || message.type !== 'agent-control-result') return;
+    const controlId = String(message.controlId || '');
+    const request = pending.get(controlId);
+    if (!request) return;
+    pending.delete(controlId);
+    request.cleanup();
+    if (message.ok === false) request.reject(remoteError(message.error));
+    else request.resolve(message.value);
+  });
+  process.on('disconnect', () => {
+    for (const [controlId, request] of pending) {
+      pending.delete(controlId);
+      request.cleanup();
+      request.reject(new Error('runtime shard disconnected during agent control'));
+    }
+  });
+}
+
+export function remoteAgentControlEnabled(env = process.env) {
+  return isSessionRuntimeWorkerProcess(env)
+    && typeof process.send === 'function'
+    && process.connected === true;
+}
+
+export function executeRemoteAgentControl(args = {}, context = {}) {
+  if (!remoteAgentControlEnabled()) {
+    return Promise.reject(new Error('remote agent control is unavailable'));
+  }
+  ensureListener();
+  const controlId = `agent-control-${process.pid}-${++sequence}`;
+  const signal = context?.signal || null;
+  if (signal?.aborted) {
+    return Promise.reject(signal.reason instanceof Error
+      ? signal.reason
+      : new Error(String(signal.reason || 'agent control canceled')));
+  }
+  return new Promise((resolve, reject) => {
+    let timer = null;
+    let onAbort = null;
+    const cleanup = () => {
+      if (timer) clearTimeout(timer);
+      timer = null;
+      if (onAbort && signal) {
+        try { signal.removeEventListener('abort', onAbort); } catch {}
+      }
+      onAbort = null;
+    };
+    pending.set(controlId, { resolve, reject, cleanup });
+    if (signal) {
+      onAbort = () => {
+        safeIpcSend(process, {
+          type: 'agent-control-cancel',
+          controlId,
+          reason: String(signal.reason?.message || signal.reason || 'agent control canceled'),
+        }, { onError: () => {} });
+        const request = pending.get(controlId);
+        if (!request) return;
+        pending.delete(controlId);
+        cleanup();
+        reject(signal.reason instanceof Error
+          ? signal.reason
+          : new Error(String(signal.reason || 'agent control canceled')));
+      };
+      signal.addEventListener('abort', onAbort, { once: true });
+    }
+    timer = setTimeout(() => {
+      const request = pending.get(controlId);
+      if (!request) return;
+      pending.delete(controlId);
+      cleanup();
+      reject(new Error('remote agent control timed out'));
+    }, 180_000);
+    timer.unref?.();
+    const sent = safeIpcSend(process, {
+      type: 'agent-control',
+      controlId,
+      args: args && typeof args === 'object' ? args : {},
+      context: {
+        callerCwd: typeof context?.callerCwd === 'string' ? context.callerCwd : null,
+        invocationSource: typeof context?.invocationSource === 'string'
+          ? context.invocationSource
+          : null,
+        callerSessionId: typeof context?.callerSessionId === 'string'
+          ? context.callerSessionId
+          : null,
+        clientHostPid: Number(context?.clientHostPid) || null,
+      },
+    }, {
+      onError: (error) => {
+        const request = pending.get(controlId);
+        if (!request) return;
+        pending.delete(controlId);
+        cleanup();
+        reject(error);
+      },
+    });
+    if (!sent) {
+      const request = pending.get(controlId);
+      if (request) {
+        pending.delete(controlId);
+        cleanup();
+        reject(new Error('runtime shard IPC is unavailable'));
+      }
+    }
+  });
+}

package/src/standalone/session-runtime-agent-control-client.test.mjs

@@ -0,0 +1,71 @@
+import assert from 'node:assert/strict';
+import { fork } from 'node:child_process';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+
+const CLIENT_URL = new URL('./session-runtime-agent-control-client.mjs', import.meta.url).href;
+
+test('runtime shard Agent client sends serializable context and receives the routed result', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'mixdog-agent-control-client-'));
+  const entry = join(dir, 'client.mjs');
+  await writeFile(entry, `
+process.env.MIXDOG_SESSION_RUNTIME_WORKER_PID = String(process.pid);
+const client = await import(${JSON.stringify(CLIENT_URL)});
+const value = await client.executeRemoteAgentControl(
+  { type: 'spawn', tag: 'routed', agent: 'worker', prompt: 'run' },
+  {
+    callerCwd: 'C:/Project/test',
+    invocationSource: 'model-tool',
+    callerSessionId: 'sess_lead',
+    clientHostPid: 4242,
+  },
+);
+process.send({ type: 'report', value });
+`, 'utf8');
+
+  try {
+    const observed = await new Promise((resolve, reject) => {
+      const child = fork(entry, [], {
+        stdio: ['ignore', 'ignore', 'pipe', 'ipc'],
+        env: { ...process.env },
+      });
+      const timer = setTimeout(() => {
+        try { child.kill(); } catch {}
+        reject(new Error('agent control client test timed out'));
+      }, 10_000);
+      child.on('message', (message) => {
+        if (message?.type === 'agent-control') {
+          assert.deepEqual(message.args, {
+            type: 'spawn',
+            tag: 'routed',
+            agent: 'worker',
+            prompt: 'run',
+          });
+          assert.deepEqual(message.context, {
+            callerCwd: 'C:/Project/test',
+            invocationSource: 'model-tool',
+            callerSessionId: 'sess_lead',
+            clientHostPid: 4242,
+          });
+          child.send({
+            type: 'agent-control-result',
+            controlId: message.controlId,
+            ok: true,
+            value: 'agent task: task_routed',
+          });
+          return;
+        }
+        if (message?.type !== 'report') return;
+        clearTimeout(timer);
+        try { child.kill(); } catch {}
+        resolve(message.value);
+      });
+      child.on('error', reject);
+    });
+    assert.equal(observed, 'agent task: task_routed');
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});

package/src/standalone/session-runtime-dispatch-cancel.test.mjs

@@ -0,0 +1,139 @@
+// Cold-start cancellation contract, exercised against the REAL runtime worker
+// child (no stub): a cancel that arrives before or during the dispatch's
+// module/provider cold start must never be answered "not running" and then let
+// the dispatch run anyway.
+import assert from 'node:assert/strict';
+import { fork } from 'node:child_process';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import test from 'node:test';
+
+const WORKER_ENTRY = fileURLToPath(new URL('./session-runtime-worker.mjs', import.meta.url));
+const REPO_ROOT = join(dirname(WORKER_ENTRY), '..', '..');
+
+function startWorker(runtimeRoot) {
+  const child = fork(WORKER_ENTRY, [], {
+    cwd: REPO_ROOT,
+    execArgv: [],
+    stdio: ['ignore', 'ignore', 'pipe', 'ipc'],
+    env: {
+      ...process.env,
+      MIXDOG_RUNTIME_ROOT: runtimeRoot,
+      MIXDOG_DATA_DIR: runtimeRoot,
+      MIXDOG_SESSION_RUNTIME_SHARD: '0',
+      MIXDOG_SESSION_RUNTIME_SHARD_COUNT: '2',
+    },
+  });
+  const responses = new Map();
+  const waiters = new Map();
+  child.on('message', (message) => {
+    if (message?.type !== 'response') return;
+    const id = String(message.requestId || '');
+    const waiter = waiters.get(id);
+    if (waiter) {
+      waiters.delete(id);
+      waiter(message);
+      return;
+    }
+    responses.set(id, message);
+  });
+  const send = (payload) => child.send(payload);
+  const wait = (requestId, timeoutMs = 30_000) => new Promise((resolve, reject) => {
+    const settled = responses.get(requestId);
+    if (settled) {
+      responses.delete(requestId);
+      resolve(settled);
+      return;
+    }
+    const timer = setTimeout(
+      () => reject(new Error(`timed out waiting for ${requestId}`)),
+      timeoutMs,
+    );
+    waiters.set(requestId, (message) => { clearTimeout(timer); resolve(message); });
+  });
+  return { child, send, wait };
+}
+
+async function stopWorker(worker) {
+  try {
+    worker.send({ type: 'shutdown', requestId: 'shutdown-1', reason: 'test complete' });
+    await worker.wait('shutdown-1', 8_000).catch(() => {});
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  } finally {
+    try { worker.child.kill(); } catch {}
+  }
+}
+
+test('a cancel that arrives before the dispatch is retained and aborts it', async () => {
+  const runtimeRoot = await mkdtemp(join(tmpdir(), 'mixdog-dispatch-cancel-'));
+  const worker = startWorker(runtimeRoot);
+  try {
+    worker.send({
+      type: 'agent-dispatch-cancel',
+      requestId: 'cancel-early',
+      dispatchId: 'dispatch-cold',
+      reason: 'user aborted during cold start',
+    });
+    const cancel = await worker.wait('cancel-early', 15_000);
+    assert.equal(cancel.ok, true);
+    // Never "cancelled: false": an unknown id means not-registered-YET.
+    assert.equal(cancel.value.cancelled, true);
+    assert.equal(cancel.value.retained, true);
+
+    const startedAt = Date.now();
+    worker.send({
+      type: 'agent-dispatch',
+      requestId: 'dispatch-cold-1',
+      dispatchId: 'dispatch-cold',
+      agent: 'memory',
+      params: { prompt: 'must never run' },
+    });
+    const dispatch = await worker.wait('dispatch-cold-1', 20_000);
+    assert.equal(dispatch.ok, false);
+    assert.match(String(dispatch.error?.message || ''), /user aborted during cold start/);
+    // The abort is adopted at registration — before the orchestrator/provider
+    // cold start, which alone takes seconds in this worker.
+    assert.ok(
+      Date.now() - startedAt < 3_000,
+      'aborted dispatch never entered module/provider setup',
+    );
+  } finally {
+    await stopWorker(worker);
+    await rm(runtimeRoot, { recursive: true, force: true });
+  }
+});
+
+test('a cancel racing a cold-start dispatch is never answered "not running"', async () => {
+  const runtimeRoot = await mkdtemp(join(tmpdir(), 'mixdog-dispatch-cancel-warm-'));
+  const worker = startWorker(runtimeRoot);
+  try {
+    worker.send({
+      type: 'agent-dispatch',
+      requestId: 'dispatch-warm-1',
+      dispatchId: 'dispatch-warm',
+      agent: 'memory',
+      params: { prompt: 'cancelled while importing' },
+    });
+    // The cold start compiles the orchestrator graph and blocks this loop, so
+    // the cancel frame can only be handled once that window closes. Whichever
+    // side wins, the abort must be honoured or retained — never dropped with
+    // `cancelled: false`, which is what let a canceled dispatch keep running.
+    worker.send({
+      type: 'agent-dispatch-cancel',
+      requestId: 'cancel-warm',
+      dispatchId: 'dispatch-warm',
+      reason: 'aborted mid cold start',
+    });
+    const cancel = await worker.wait('cancel-warm', 60_000);
+    assert.equal(cancel.ok, true);
+    assert.equal(cancel.value.cancelled, true);
+
+    const dispatch = await worker.wait('dispatch-warm-1', 60_000);
+    assert.equal(dispatch.ok, false);
+  } finally {
+    await stopWorker(worker);
+    await rm(runtimeRoot, { recursive: true, force: true });
+  }
+});

package/src/standalone/session-runtime-host-factory.mjs

@@ -0,0 +1,17 @@
+import { createInlineSessionRuntimeHost } from './session-runtime-inline-host.mjs';
+import { createSessionRuntimeHost } from './session-runtime-host.mjs';
+
+export function resolveSessionRuntimeMode(value = process.env.MIXDOG_SESSION_RUNTIME_MODE) {
+  const mode = String(value || 'inline').trim().toLowerCase();
+  if (mode === 'inline') return 'inline';
+  if (mode === 'process') return 'process';
+  throw new Error(`unsupported MIXDOG_SESSION_RUNTIME_MODE=${JSON.stringify(value)}`);
+}
+
+export function createDaemonSessionRuntimeHost(options = {}, {
+  createInline = createInlineSessionRuntimeHost,
+  createProcess = createSessionRuntimeHost,
+  mode = resolveSessionRuntimeMode(),
+} = {}) {
+  return mode === 'process' ? createProcess(options) : createInline(options);
+}

package/src/standalone/session-runtime-host-factory.test.mjs

@@ -0,0 +1,31 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import {
+  createDaemonSessionRuntimeHost,
+  resolveSessionRuntimeMode,
+} from './session-runtime-host-factory.mjs';
+
+test('session runtime mode defaults to inline and accepts only explicit canonical names', () => {
+  assert.equal(resolveSessionRuntimeMode(undefined), 'inline');
+  assert.equal(resolveSessionRuntimeMode('process'), 'process');
+  assert.throws(() => resolveSessionRuntimeMode('in-process'), /unsupported/);
+  assert.throws(() => resolveSessionRuntimeMode('worker'), /unsupported/);
+  assert.throws(() => resolveSessionRuntimeMode('unknown'), /unsupported/);
+});
+
+test('session runtime factory selects exactly one host implementation', () => {
+  const calls = [];
+  const createInline = (options) => { calls.push(['inline', options]); return { mode: 'inline' }; };
+  const createProcess = (options) => { calls.push(['process', options]); return { mode: 'process' }; };
+  assert.equal(createDaemonSessionRuntimeHost({ cwd: 'A' }, {
+    mode: 'inline', createInline, createProcess,
+  }).mode, 'inline');
+  assert.equal(createDaemonSessionRuntimeHost({ cwd: 'B' }, {
+    mode: 'process', createInline, createProcess,
+  }).mode, 'process');
+  assert.deepEqual(calls, [
+    ['inline', { cwd: 'A' }],
+    ['process', { cwd: 'B' }],
+  ]);
+});

package/src/standalone/session-runtime-host-health.test.mjs

@@ -68,10 +68,13 @@ test('an unhealthy runtime worker is replaced and every runtime is recovered', a
   const logs = [];
   await writeFile(workerEntry, WORKER_STUB, 'utf8');
 
+  // Single shard: this covers the recycle/recovery contract INSIDE one shard.
+  // Cross-shard routing and isolation live in session-runtime-shard-host.test.mjs.
   const host = createSessionRuntimeHost({
     workerEntry,
     cwd: dir,
     env: { ...process.env },
+    shardCount: 1,
     log: (line) => logs.push(line),
   });
   try {
@@ -111,6 +114,7 @@ test('omitted trailing arguments stay omitted across the runtime wire', async ()
     workerEntry,
     cwd: dir,
     env: { ...process.env },
+    shardCount: 1,
     log: () => {},
   });
   try {
@@ -139,6 +143,7 @@ test('RSS telemetry never schedules a destructive runtime recycle', async () =>
       MIXDOG_SESSION_WORKER_RECYCLE_RSS_MB: '1',
       MIXDOG_SESSION_WORKER_RECYCLE_INTERVAL_MS: '1',
     },
+    shardCount: 1,
     log: () => {},
   });
   try {