mixdog 0.7.18 → 0.8.0

package/src/standalone/channel-worker.mjs

@@ -0,0 +1,353 @@
+import { execFile, fork, spawnSync } from 'node:child_process';
+import { appendFileSync, mkdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { startChildGuardian } from '../runtime/shared/child-guardian.mjs';
+
+const CHANNEL_TOOLS = new Set([
+  'reply',
+  'fetch',
+  'react',
+  'edit_message',
+  'download_attachment',
+  'schedule_status',
+  'trigger_schedule',
+  'schedule_control',
+  'activate_channel_bridge',
+  'reload_config',
+  'inject_command',
+]);
+
+const WORKER_PRELOAD = fileURLToPath(new URL('./channel-worker-preload.cjs', import.meta.url));
+
+function logLine(path, line) {
+  try {
+    mkdirSync(dirname(path), { recursive: true });
+    appendFileSync(path, `[${new Date().toISOString()}] ${line}\n`);
+  } catch {
+    // Logging must never break the TUI.
+  }
+}
+
+export function createStandaloneChannelWorker({
+  entry,
+  rootDir,
+  dataDir,
+  cwd = process.cwd(),
+  onNotify,
+} = {}) {
+  if (!entry) throw new Error('channels runtime entry is required');
+  if (!rootDir) throw new Error('channels runtime rootDir is required');
+  if (!dataDir) throw new Error('channels runtime dataDir is required');
+
+  let child = null;
+  let readyPromise = null;
+  let readyResolve = null;
+  let readyReject = null;
+  let stopPromise = null;
+  let inProcessMod = null;
+  let inProcessStartPromise = null;
+  let nextCallId = 1;
+  let parentExitHookInstalled = false;
+  const pending = new Map();
+  const ownedChildPids = new Set();
+  const logPath = join(dataDir, 'channels-worker-standalone.log');
+  const useProcessWorker = process.env.MIXDOG_CHANNEL_WORKER_PROCESS !== '0';
+
+  function status() {
+    if (!useProcessWorker) {
+      return {
+        running: Boolean(inProcessMod),
+        pid: inProcessMod ? process.pid : null,
+        pending: 0,
+        mode: 'in-process',
+      };
+    }
+    return {
+      running: Boolean(child && child.exitCode == null && !child.killed),
+      pid: child?.pid || null,
+      pending: pending.size,
+      mode: 'runtime',
+    };
+  }
+
+  function rejectPending(error) {
+    for (const [, item] of pending) {
+      clearTimeout(item.timer);
+      item.reject(error);
+    }
+    pending.clear();
+  }
+
+  function start() {
+    if (!useProcessWorker) return startInProcess();
+    if (stopPromise) {
+      return stopPromise.then(() => start());
+    }
+    if (child && child.exitCode == null && !child.killed) return readyPromise || Promise.resolve(status());
+    readyPromise = new Promise((resolve, reject) => {
+      readyResolve = resolve;
+      readyReject = reject;
+    });
+
+    child = fork(entry, [], {
+      cwd,
+      execArgv: ['--require', WORKER_PRELOAD],
+      stdio: ['ignore', 'ignore', 'pipe', 'ipc'],
+      env: {
+        ...process.env,
+        MIXDOG_ROOT: rootDir,
+        MIXDOG_DATA_DIR: dataDir,
+        MIXDOG_STANDALONE: '1',
+        MIXDOG_WORKER_MODE: '1',
+        MIXDOG_CLI_OWNED: '1',
+        MIXDOG_CHANNELS_AUTO_BOOT: '0',
+        MIXDOG_CHANNEL_FLAG: '1',
+        MIXDOG_QUIET_SESSION_LOG: process.env.MIXDOG_QUIET_SESSION_LOG ?? '1',
+      },
+      windowsHide: true,
+    });
+    const spawnedPid = child.pid;
+    startChildGuardian({ childPid: spawnedPid, label: 'channel-worker', orphanGraceMs: 8000, forceGraceMs: 3000 });
+    if (spawnedPid) ownedChildPids.add(spawnedPid);
+    installParentExitHook();
+
+    child.stderr?.on('data', (chunk) => {
+      const text = String(chunk || '').trimEnd();
+      if (text) logLine(logPath, text);
+    });
+
+    child.on('message', (msg) => {
+      if (!msg || typeof msg !== 'object') return;
+      if (msg.type === 'ready') {
+        readyResolve?.(status());
+        readyResolve = null;
+        readyReject = null;
+        return;
+      }
+      if (msg.type === 'result' && msg.callId) {
+        const item = pending.get(msg.callId);
+        if (!item) return;
+        pending.delete(msg.callId);
+        clearTimeout(item.timer);
+        if (msg.error) item.reject(new Error(msg.error));
+        else item.resolve(msg.result);
+        return;
+      }
+      if (msg.type === 'notify') {
+        try { onNotify?.(msg); } catch {}
+      }
+    });
+
+    child.on('exit', (code, signal) => {
+      if (spawnedPid) ownedChildPids.delete(spawnedPid);
+      const error = new Error(`channels runtime exited (${signal || (code ?? 'unknown')})`);
+      if (readyReject) readyReject(error);
+      readyResolve = null;
+      readyReject = null;
+      rejectPending(error);
+      child = null;
+      readyPromise = null;
+    });
+
+    child.on('error', (error) => {
+      logLine(logPath, `runtime error: ${error?.message || error}`);
+      if (readyReject) readyReject(error);
+      readyResolve = null;
+      readyReject = null;
+      rejectPending(error);
+    });
+
+    return readyPromise;
+  }
+
+  async function startInProcess() {
+    if (inProcessMod) return status();
+    if (inProcessStartPromise) return inProcessStartPromise;
+    inProcessStartPromise = (async () => {
+      process.env.MIXDOG_ROOT = rootDir;
+      process.env.MIXDOG_DATA_DIR = dataDir;
+      process.env.MIXDOG_STANDALONE ??= '1';
+      process.env.MIXDOG_CHANNEL_FLAG ??= '1';
+      process.env.MIXDOG_CHANNELS_AUTO_BOOT = '0';
+      process.env.MIXDOG_CLI_OWNED = '1';
+      const mod = await import(pathToFileURL(entry).href);
+      if (typeof mod?.start !== 'function') throw new Error('channels runtime does not export start()');
+      await mod.start();
+      inProcessMod = mod;
+      return status();
+    })().finally(() => {
+      inProcessStartPromise = null;
+    });
+    return inProcessStartPromise;
+  }
+
+  async function execute(name, args = {}, { timeoutMs = 120_000 } = {}) {
+    if (!CHANNEL_TOOLS.has(name)) throw new Error(`unknown channel tool: ${name}`);
+    await start();
+    if (!useProcessWorker) {
+      const call = inProcessMod?.handleToolCallWithBridgeRetry || inProcessMod?.handleToolCall;
+      if (typeof call !== 'function') throw new Error('channels runtime is not running');
+      let timer = null;
+      try {
+        return await Promise.race([
+          call(name, args || {}),
+          new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new Error(`channels tool timed out: ${name}`)), timeoutMs);
+          }),
+        ]);
+      } finally {
+        if (timer) clearTimeout(timer);
+      }
+    }
+    if (!child || !child.send) throw new Error('channels worker is not running');
+    const callId = `ch_${nextCallId++}`;
+    return await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        pending.delete(callId);
+        reject(new Error(`channels tool timed out: ${name}`));
+      }, timeoutMs);
+      pending.set(callId, { resolve, reject, timer });
+      child.send({ type: 'call', callId, name, args: args || {} }, (error) => {
+        if (!error) return;
+        pending.delete(callId);
+        clearTimeout(timer);
+        reject(error);
+      });
+    });
+  }
+
+  function forceKillTree(pid) {
+    if (!pid) return;
+    if (process.platform === 'win32') {
+      execFile('taskkill.exe', ['/PID', String(pid), '/T', '/F'], { windowsHide: true }, () => {});
+      return;
+    }
+    try { process.kill(pid, 'SIGKILL'); } catch {}
+  }
+
+  function forceKillTreeSync(pid) {
+    if (!pid) return;
+    if (process.platform === 'win32') {
+      try {
+        spawnSync('taskkill.exe', ['/PID', String(pid), '/T', '/F'], {
+          stdio: 'ignore',
+          windowsHide: true,
+        });
+      } catch {}
+      return;
+    }
+    try { process.kill(pid, 'SIGKILL'); } catch {}
+  }
+
+  function installParentExitHook() {
+    if (parentExitHookInstalled) return;
+    parentExitHookInstalled = true;
+    process.once('exit', () => {
+      for (const pid of Array.from(ownedChildPids)) {
+        forceKillTreeSync(pid);
+      }
+      ownedChildPids.clear();
+    });
+  }
+
+  function unrefChildHandles(target) {
+    try { target?.unref?.(); } catch {}
+    try { target?.stderr?.unref?.(); } catch {}
+    try { target?.stdout?.unref?.(); } catch {}
+    try { target?.stdin?.unref?.(); } catch {}
+    try { target?.channel?.unref?.(); } catch {}
+  }
+
+  function stop(reason = 'standalone shutdown', options = {}) {
+    const waitForExit = options?.waitForExit !== false;
+    if (stopPromise) return stopPromise;
+    if (!useProcessWorker) {
+      if (!inProcessMod && !inProcessStartPromise) return Promise.resolve(false);
+      stopPromise = Promise.resolve(inProcessStartPromise)
+        .catch(() => null)
+        .then(async () => {
+          try { await inProcessMod?.stop?.(reason); } catch {}
+          inProcessMod = null;
+          return true;
+        })
+        .finally(() => {
+          stopPromise = null;
+        });
+      return stopPromise;
+    }
+    if (!child) return Promise.resolve(false);
+    const target = child;
+    const targetPid = target.pid;
+    child = null;
+    if (!waitForExit) {
+      rejectPending(new Error(`channels runtime shutdown requested (${reason})`));
+      if (targetPid) ownedChildPids.delete(targetPid);
+      stopPromise = new Promise((resolve) => {
+        let settled = false;
+        const finish = (ok) => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(sendTimer);
+          stopPromise = null;
+          unrefChildHandles(target);
+          resolve(ok);
+        };
+        const sendTimer = setTimeout(() => finish(false), 250);
+        try {
+          target.send?.({ type: 'shutdown', reason }, () => {
+            try { target.disconnect?.(); } catch {}
+            finish(true);
+          });
+        } catch {
+          try { target.disconnect?.(); } catch {}
+          finish(false);
+        }
+      });
+      return stopPromise;
+    }
+    stopPromise = new Promise((resolve) => {
+      let settled = false;
+      const finish = (ok) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(termTimer);
+        clearTimeout(killTimer);
+        stopPromise = null;
+        resolve(ok);
+      };
+      const termTimer = setTimeout(() => {
+        try {
+          if (target.exitCode == null && !target.killed) target.kill('SIGTERM');
+        } catch {}
+      }, 1500);
+      const killTimer = setTimeout(() => {
+        try {
+          if (target.exitCode == null) forceKillTree(targetPid);
+        } catch {}
+        try {
+          if (target.exitCode == null && !target.killed) target.kill('SIGKILL');
+        } catch {}
+        finish(false);
+      }, 5000);
+      target.once('exit', () => finish(true));
+      target.once('error', () => finish(false));
+      try {
+        target.send?.({ type: 'shutdown', reason }, () => {
+          try { target.disconnect?.(); } catch {}
+        });
+      } catch {
+        try { target.disconnect?.(); } catch {}
+      }
+    });
+    return stopPromise;
+  }
+
+  return {
+    start,
+    execute,
+    stop,
+    status,
+    isChannelTool: (name) => CHANNEL_TOOLS.has(name),
+  };
+}

package/src/standalone/explore-tool.mjs

@@ -0,0 +1,233 @@
+import { isAbsolute, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import {
+  TOOL_ASYNC_EXECUTION_CONTRACT,
+  TOOL_SYNC_EXECUTION_CONTRACT,
+  cancelBackgroundTask,
+  executionModeSchemaDescription,
+  getBackgroundTask,
+  renderBackgroundTask,
+  renderBackgroundTaskList,
+  resolveExecutionMode,
+  startBackgroundTask,
+  taskIdFromArgs,
+} from '../runtime/shared/background-tasks.mjs';
+import { makeBridgeLlm } from '../runtime/agent/orchestrator/smart-bridge/bridge-llm.mjs';
+
+// Ported from the original mixdog tool-defs.mjs `explore` entry.
+// `aiWrapped` is dropped: in the standalone build there is no aiWrapped
+// dispatch hub — execution is wired directly in the runtime executor below
+// via makeBridgeLlm. The standalone surface is synchronous: it returns a
+// bounded locator result in this tool call.
+export const EXPLORE_TOOL = {
+  name: 'explore',
+  title: 'Explore',
+  annotations: { title: 'Explore', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+  description: `Broad-scope locator only; returns unverified leads. Prefer mode=async for broad exploration that can continue in parallel; use sync only when the next step must block on this locator result. ${TOOL_SYNC_EXECUTION_CONTRACT} ${TOOL_ASYNC_EXECUTION_CONTRACT} Use code_graph/grep/glob first when any symbol, term, file kind, or config clue exists. Use explore only after direct narrowing fails or topics are unrelated. One short location question.`,
+  inputSchema: {
+    type: 'object',
+    properties: {
+      query: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }], description: 'One short location question, or an array only for unrelated topics. Do not use for a known symbol/term/config key; use code_graph/grep first. Never pass a whole brief/context dump.' },
+      cwd: { type: 'string', description: 'Project/root directory to explore; narrow to the relevant repo or subtree.' },
+      mode: { type: 'string', enum: ['async', 'sync'], description: `${executionModeSchemaDescription('sync')} Prefer async for non-trivial exploration; choose sync only for an explicit blocking lookup.` },
+      action: { type: 'string', enum: ['run', 'list', 'status', 'read', 'cancel'], description: 'Default run. list/status/read/cancel are manual recovery controls for async explore tasks.' },
+      task_id: { type: 'string', description: 'Shared background task id for manual status/read/cancel recovery.' },
+      background: { type: 'boolean', description: 'Legacy alias for mode=async.' },
+    },
+    required: [],
+    additionalProperties: false,
+  },
+};
+
+// Total merged-output character cap. The original source uses a very large cap
+// (50MB) plus a smart-read summariser downstream; the standalone path returns
+// the merged text in-turn, so we keep a sane bound to protect the Lead context.
+export const EXPLORE_OUTPUT_CHAR_CAP = 24_000;
+const EXPLORE_TRUNCATION_MARKER = '\n\n[explore: output truncated; narrow cwd or split queries to see more]';
+// Bound fan-out so a hostile/poisoned query array cannot spawn unbounded subs.
+export const MAX_FANOUT_QUERIES = 8;
+
+function escapeXml(str) {
+  return String(str).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+
+// Mirrors buildExplorerPrompt from the original ai-wrapped-dispatch: each
+// explorer receives ONLY its own query, with a trailing descriptive-only
+// reminder. The full no-verdict contract lives at system level
+// (rules/bridge/30-explorer.md).
+export function buildExplorerPrompt(query) {
+  return `<query>${escapeXml(query)}</query>\nReminder: describe with file:line evidence; no verdicts, ratings, or recommendations.`;
+}
+
+export function normalizeExploreQueries(rawQuery) {
+  let raw = rawQuery;
+  // Some clients JSON-stringify arrays when the schema field is loosely typed.
+  if (typeof raw === 'string') {
+    const trimmed = raw.trim();
+    if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+      try {
+        const parsed = JSON.parse(trimmed);
+        if (Array.isArray(parsed)) raw = parsed;
+      } catch { /* not a JSON array — keep as plain string */ }
+    }
+  }
+  const list = Array.isArray(raw) ? raw : [raw];
+  return list
+    .map((q) => (typeof q === 'string' ? q.trim() : ''))
+    .filter(Boolean);
+}
+
+function resolveExploreCwd(input, callerCwd) {
+  const base = (typeof callerCwd === 'string' && callerCwd) ? callerCwd : process.cwd();
+  if (typeof input === 'string' && input.trim()) {
+    const trimmed = input.trim();
+    const expanded = trimmed.startsWith('~') ? trimmed.replace(/^~/, homedir()) : trimmed;
+    return isAbsolute(expanded) ? expanded : resolve(base, expanded);
+  }
+  return base;
+}
+
+function settledExplorerResult(result) {
+  if (result?.status !== 'fulfilled') {
+    return { ok: false, text: `[explorer error] ${result?.reason?.message || String(result?.reason)}` };
+  }
+  const text = typeof result.value === 'string' ? result.value.trim() : responseText(result.value).trim();
+  if (!text) return { ok: false, text: '[explorer error] empty response' };
+  return { ok: true, text };
+}
+
+function mergeSettled(settled, queries) {
+  const single = queries.length === 1;
+  if (single) {
+    const { text: body } = settledExplorerResult(settled[0]);
+    return body.length > EXPLORE_OUTPUT_CHAR_CAP
+      ? body.slice(0, EXPLORE_OUTPUT_CHAR_CAP) + EXPLORE_TRUNCATION_MARKER
+      : body;
+  }
+  const parts = [];
+  let total = 0;
+  const sep = '\n\n';
+  let truncated = false;
+  for (let i = 0; i < settled.length; i++) {
+    const header = `## Q${i + 1}: ${String(queries[i] ?? '').replace(/\s+/g, ' ').slice(0, 60)}`;
+    const { text: body } = settledExplorerResult(settled[i]);
+    const piece = `${header}\n${body}`;
+    const addLen = (parts.length === 0 ? 0 : sep.length) + piece.length;
+    if (total + addLen > EXPLORE_OUTPUT_CHAR_CAP) {
+      const remaining = EXPLORE_OUTPUT_CHAR_CAP - total - (parts.length === 0 ? 0 : sep.length);
+      if (remaining > 0) parts.push(piece.slice(0, remaining));
+      truncated = true;
+      break;
+    }
+    parts.push(piece);
+    total += addLen;
+  }
+  const merged = parts.join(sep);
+  return truncated ? merged + EXPLORE_TRUNCATION_MARKER : merged;
+}
+
+function ok(text) {
+  return { content: [{ type: 'text', text }], isError: false };
+}
+
+function fail(msg) {
+  return { content: [{ type: 'text', text: `[explore error] ${msg}` }], isError: true };
+}
+
+function clean(value) {
+  return String(value ?? '').trim();
+}
+
+function responseText(response) {
+  if (typeof response === 'string') return response;
+  const parts = Array.isArray(response?.content) ? response.content : [];
+  const text = parts
+    .filter((part) => part?.type === 'text')
+    .map((part) => part.text)
+    .join('\n');
+  return text || JSON.stringify(response, null, 2);
+}
+
+function controlExploreTask(action, args, ctx = {}) {
+  if (action === 'list') return ok(renderBackgroundTaskList({ surface: 'explore', context: ctx }));
+  const taskId = taskIdFromArgs(args);
+  if (!taskId) return fail('task_id is required');
+  const task = getBackgroundTask(taskId, { surface: 'explore', context: ctx });
+  if (!task) return fail(`task not found: ${taskId}`);
+  if (action === 'cancel') {
+    cancelBackgroundTask(taskId, 'cancelled by explore control');
+    return ok(renderBackgroundTask(task, { includeResult: true }));
+  }
+  return ok(renderBackgroundTask(task, { includeResult: action === 'read' }));
+}
+
+/**
+ * Standalone explore executor.
+ *
+ * Dispatches the hidden `explorer` read-only filesystem role (one ephemeral
+ * sub-session per query) via makeBridgeLlm — the same path recall/search-style
+ * hidden roles use. Runs query items concurrently (Promise.allSettled), then
+ * aggregates the findings into one bounded text result.
+ *
+ * Runs synchronously by default. With mode=async/background:true, registers a
+ * shared background task and delivers completion to the owner session.
+ *
+ * @param {object} args         — tool args ({ query, cwd, background }).
+ * @param {object} ctx          — { callerCwd, callerSessionId }.
+ */
+export async function runExplore(args = {}, ctx = {}) {
+  const action = clean(args.action || 'run').toLowerCase();
+  if (['list', 'status', 'read', 'cancel'].includes(action)) return controlExploreTask(action, args, ctx);
+
+  const mode = resolveExecutionMode(args, 'sync');
+  if (mode === 'async') {
+    const queries = normalizeExploreQueries(args.query);
+    if (queries.length === 0) return fail('query is required (one or more non-empty strings)');
+    const task = startBackgroundTask({
+      surface: 'explore',
+      operation: 'explore',
+      label: queries[0].replace(/\s+/g, ' ').slice(0, 120),
+      input: { query: args.query, cwd: args.cwd || null },
+      context: ctx,
+      resultType: 'explore_task_result',
+      renderResult: responseText,
+      run: async () => {
+        const response = await runExploreSync(args, ctx);
+        if (response?.isError) throw new Error(responseText(response));
+        return response;
+      },
+    });
+    return ok(renderBackgroundTask(task));
+  }
+  return runExploreSync(args, ctx);
+}
+
+async function runExploreSync(args = {}, ctx = {}) {
+  const queries = normalizeExploreQueries(args.query);
+  if (queries.length === 0) return fail('query is required (one or more non-empty strings)');
+
+  let working = queries;
+  let capNotice = '';
+  if (working.length > MAX_FANOUT_QUERIES) {
+    capNotice = `[capped ${working.length}->${MAX_FANOUT_QUERIES} queries]\n`;
+    working = working.slice(0, MAX_FANOUT_QUERIES);
+  }
+
+  const resolvedCwd = resolveExploreCwd(args.cwd, ctx.callerCwd);
+
+  const settled = await Promise.allSettled(working.map((q) => {
+    const llm = makeBridgeLlm({
+      role: 'explorer',
+      cwd: resolvedCwd,
+      brief: true,
+      parentSessionId: ctx.callerSessionId || null,
+      clientHostPid: ctx.clientHostPid || null,
+    });
+    return llm({ prompt: buildExplorerPrompt(q) });
+  }));
+
+  const merged = mergeSettled(settled, working);
+  const allFailed = settled.every((r) => !settledExplorerResult(r).ok);
+  const out = capNotice + merged;
+  return allFailed ? fail(out) : ok(out);
+}