mixdog 0.8.0 → 0.9.0

package/src/standalone/channel-worker.mjs

@@ -1,8 +1,11 @@
 import { execFile, fork, spawnSync } from 'node:child_process';
-import { appendFileSync, mkdirSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { appendFileSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import http from 'node:http';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { startChildGuardian } from '../runtime/shared/child-guardian.mjs';
+import { claimSingletonOwner, readSingletonOwner, releaseSingletonOwner } from '../runtime/shared/singleton-owner.mjs';
 
 const CHANNEL_TOOLS = new Set([
   'reply',
@@ -29,6 +32,91 @@ function logLine(path, line) {
   }
 }
 
+const CHANNEL_WORKER_EXIT_CLEANUPS = new Set();
+let channelWorkerExitHookInstalled = false;
+
+function registerChannelWorkerExitCleanup(cleanup) {
+  if (typeof cleanup !== 'function') return () => {};
+  CHANNEL_WORKER_EXIT_CLEANUPS.add(cleanup);
+  if (!channelWorkerExitHookInstalled) {
+    channelWorkerExitHookInstalled = true;
+    process.once('exit', () => {
+      for (const fn of Array.from(CHANNEL_WORKER_EXIT_CLEANUPS)) {
+        try { fn(); } catch {}
+      }
+      CHANNEL_WORKER_EXIT_CLEANUPS.clear();
+    });
+  }
+  return () => {
+    CHANNEL_WORKER_EXIT_CLEANUPS.delete(cleanup);
+  };
+}
+
+function runtimeRoot() {
+  return process.env.MIXDOG_RUNTIME_ROOT ? resolve(process.env.MIXDOG_RUNTIME_ROOT) : join(tmpdir(), 'mixdog');
+}
+
+function readJson(path) {
+  try { return JSON.parse(readFileSync(path, 'utf8')); } catch { return null; }
+}
+
+function parsePort(value) {
+  const port = Number(value);
+  return Number.isInteger(port) && port > 0 && port < 65536 ? port : null;
+}
+
+function readActiveInstance() {
+  return readJson(join(runtimeRoot(), 'active-instance.json'));
+}
+
+function readOwnerSecret(instanceId) {
+  const parsed = readJson(join(runtimeRoot(), `owner-secret-${String(instanceId)}.json`));
+  return typeof parsed?.secret === 'string' ? parsed.secret : '';
+}
+
+function requestJson({ port, method = 'GET', path = '/', body = null, headers = {}, timeoutMs = 120_000 }) {
+  return new Promise((resolvePromise, reject) => {
+    const payload = body == null ? null : JSON.stringify(body);
+    const req = http.request({
+      hostname: '127.0.0.1',
+      port,
+      path,
+      method,
+      headers: {
+        ...headers,
+        ...(payload
+          ? { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) }
+          : {}),
+      },
+      timeout: timeoutMs,
+    }, (res) => {
+      let data = '';
+      res.setEncoding('utf8');
+      res.on('data', chunk => { data += chunk; });
+      res.on('end', () => {
+        let parsed = null;
+        try { parsed = data ? JSON.parse(data) : null; } catch {}
+        if (res.statusCode && res.statusCode >= 400) {
+          reject(new Error(parsed?.error || data || `HTTP ${res.statusCode}`));
+          return;
+        }
+        resolvePromise(parsed ?? { raw: data });
+      });
+    });
+    req.on('error', reject);
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error(`channel owner request timed out: ${method} ${path}`));
+    });
+    if (payload) req.write(payload);
+    req.end();
+  });
+}
+
+function textResult(text, isError = false) {
+  return { content: [{ type: 'text', text: String(text ?? '') }], ...(isError ? { isError: true } : {}) };
+}
+
 export function createStandaloneChannelWorker({
   entry,
   rootDir,
@@ -48,13 +136,106 @@ export function createStandaloneChannelWorker({
   let inProcessMod = null;
   let inProcessStartPromise = null;
   let nextCallId = 1;
-  let parentExitHookInstalled = false;
+  let parentExitCleanup = null;
   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';
+  const singletonEnabled = process.env.MIXDOG_CHANNEL_SINGLETON !== '0';
+  const daemonEnabled = process.env.MIXDOG_CHANNEL_DAEMON !== '0';
+  const ownerPath = join(dataDir, 'channels-worker-owner.json');
+  const notifyBusPath = join(runtimeRoot(), 'channel-notifications.jsonl');
+  const clientDir = join(runtimeRoot(), 'channel-clients');
+  const clientPath = join(clientDir, `${process.pid}.json`);
+  let ownerClaim = null;
+  let ownerPid = process.pid;
+  let notifyBusTimer = null;
+  let notifyBusOffset = 0;
+  let clientHeartbeatTimer = null;
+  let clientHeartbeatExitCleanup = null;
+
+  function writeClientHeartbeat() {
+    try {
+      mkdirSync(clientDir, { recursive: true });
+      writeFileSync(clientPath, JSON.stringify({
+        pid: process.pid,
+        cwd,
+        updatedAt: Date.now(),
+      }));
+    } catch {}
+  }
+
+  function startClientHeartbeat() {
+    if (clientHeartbeatTimer) return;
+    writeClientHeartbeat();
+    clientHeartbeatTimer = setInterval(writeClientHeartbeat, 5000);
+    clientHeartbeatTimer.unref?.();
+    clientHeartbeatExitCleanup ||= registerChannelWorkerExitCleanup(stopClientHeartbeat);
+  }
+
+  function stopClientHeartbeat() {
+    if (clientHeartbeatExitCleanup) {
+      const unregister = clientHeartbeatExitCleanup;
+      clientHeartbeatExitCleanup = null;
+      unregister();
+    }
+    if (clientHeartbeatTimer) {
+      clearInterval(clientHeartbeatTimer);
+      clientHeartbeatTimer = null;
+    }
+    try { rmSync(clientPath, { force: true }); } catch {}
+  }
+
+  function startNotifyBus() {
+    if (!onNotify || notifyBusTimer) return;
+    try { notifyBusOffset = statSync(notifyBusPath).size; } catch { notifyBusOffset = 0; }
+    notifyBusTimer = setInterval(pollNotifyBus, 500);
+    notifyBusTimer.unref?.();
+  }
+
+  function stopNotifyBus() {
+    if (!notifyBusTimer) return;
+    clearInterval(notifyBusTimer);
+    notifyBusTimer = null;
+  }
+
+  function pollNotifyBus() {
+    let size = 0;
+    try { size = statSync(notifyBusPath).size; } catch { return; }
+    if (size < notifyBusOffset) notifyBusOffset = 0;
+    if (size === notifyBusOffset) return;
+    let chunk;
+    try {
+      const data = readFileSync(notifyBusPath);
+      chunk = data.subarray(notifyBusOffset, size).toString('utf8');
+      notifyBusOffset = size;
+    } catch {
+      return;
+    }
+    for (const line of chunk.split(/\r?\n/)) {
+      if (!line.trim()) continue;
+      try {
+        const msg = JSON.parse(line);
+        if (!msg || typeof msg !== 'object') continue;
+        onNotify({ type: 'notify', method: msg.method, params: msg.params, busId: msg.id, busPid: msg.pid });
+      } catch {}
+    }
+  }
+
+  startNotifyBus();
+  startClientHeartbeat();
 
   function status() {
+    const external = externalOwner();
+    if (external) {
+      return {
+        running: false,
+        pid: null,
+        pending: pending.size,
+        mode: 'external-owner',
+        ownerPid: Number(external.pid) || null,
+      };
+    }
     if (!useProcessWorker) {
       return {
         running: Boolean(inProcessMod),
@@ -71,6 +252,36 @@ export function createStandaloneChannelWorker({
     };
   }
 
+  function externalOwner() {
+    if (!singletonEnabled || ownerClaim?.owned) return null;
+    const current = readSingletonOwner(ownerPath);
+    if (current.alive && current.owner?.pid && Number(current.owner.pid) !== process.pid) return current.owner;
+    return null;
+  }
+
+  function ensureOwner() {
+    if (!singletonEnabled || ownerClaim?.owned) return true;
+    ownerClaim = claimSingletonOwner(ownerPath, {
+      kind: 'channel-worker-host',
+      pid: process.pid,
+      meta: { cwd },
+    });
+    if (!ownerClaim.owned) {
+      logLine(logPath, `runtime owned by pid ${ownerClaim.owner?.pid || 'unknown'}; skipping local channel worker`);
+      return false;
+    }
+    installParentExitHook();
+    return true;
+  }
+
+  function releaseOwner() {
+    if (!singletonEnabled || !ownerClaim?.owned) return;
+    releaseSingletonOwner(ownerPath, ownerPid);
+    ownerClaim = null;
+    ownerPid = process.pid;
+    uninstallParentExitHook();
+  }
+
   function rejectPending(error) {
     for (const [, item] of pending) {
       clearTimeout(item.timer);
@@ -81,6 +292,7 @@ export function createStandaloneChannelWorker({
 
   function start() {
     if (!useProcessWorker) return startInProcess();
+    if (!ensureOwner()) return Promise.resolve(status());
     if (stopPromise) {
       return stopPromise.then(() => start());
     }
@@ -94,13 +306,15 @@ export function createStandaloneChannelWorker({
       cwd,
       execArgv: ['--require', WORKER_PRELOAD],
       stdio: ['ignore', 'ignore', 'pipe', 'ipc'],
+      detached: daemonEnabled,
       env: {
         ...process.env,
         MIXDOG_ROOT: rootDir,
         MIXDOG_DATA_DIR: dataDir,
         MIXDOG_STANDALONE: '1',
         MIXDOG_WORKER_MODE: '1',
-        MIXDOG_CLI_OWNED: '1',
+        MIXDOG_CLI_OWNED: daemonEnabled ? '0' : '1',
+        MIXDOG_CHANNEL_DAEMON: daemonEnabled ? '1' : '0',
         MIXDOG_CHANNELS_AUTO_BOOT: '0',
         MIXDOG_CHANNEL_FLAG: '1',
         MIXDOG_QUIET_SESSION_LOG: process.env.MIXDOG_QUIET_SESSION_LOG ?? '1',
@@ -108,8 +322,19 @@ export function createStandaloneChannelWorker({
       windowsHide: true,
     });
     const spawnedPid = child.pid;
-    startChildGuardian({ childPid: spawnedPid, label: 'channel-worker', orphanGraceMs: 8000, forceGraceMs: 3000 });
-    if (spawnedPid) ownedChildPids.add(spawnedPid);
+    if (daemonEnabled && spawnedPid && singletonEnabled) {
+      releaseSingletonOwner(ownerPath, process.pid);
+      ownerClaim = claimSingletonOwner(ownerPath, {
+        kind: 'channel-worker-daemon',
+        pid: spawnedPid,
+        meta: { cwd, launcherPid: process.pid },
+      });
+      ownerPid = spawnedPid;
+    }
+    if (!daemonEnabled) {
+      startChildGuardian({ childPid: spawnedPid, label: 'channel-worker', orphanGraceMs: 8000, forceGraceMs: 3000 });
+      if (spawnedPid) ownedChildPids.add(spawnedPid);
+    }
     installParentExitHook();
 
     child.stderr?.on('data', (chunk) => {
@@ -135,12 +360,19 @@ export function createStandaloneChannelWorker({
         return;
       }
       if (msg.type === 'notify') {
-        try { onNotify?.(msg); } catch {}
+        if (!daemonEnabled) {
+          try { onNotify?.(msg); } catch {}
+        }
       }
     });
 
     child.on('exit', (code, signal) => {
       if (spawnedPid) ownedChildPids.delete(spawnedPid);
+      if (daemonEnabled && spawnedPid) releaseSingletonOwner(ownerPath, spawnedPid);
+      if (daemonEnabled && ownerPid === spawnedPid) {
+        ownerClaim = null;
+        ownerPid = process.pid;
+      }
       const error = new Error(`channels runtime exited (${signal || (code ?? 'unknown')})`);
       if (readyReject) readyReject(error);
       readyResolve = null;
@@ -162,6 +394,7 @@ export function createStandaloneChannelWorker({
   }
 
   async function startInProcess() {
+    if (!ensureOwner()) return status();
     if (inProcessMod) return status();
     if (inProcessStartPromise) return inProcessStartPromise;
     inProcessStartPromise = (async () => {
@@ -184,6 +417,9 @@ export function createStandaloneChannelWorker({
 
   async function execute(name, args = {}, { timeoutMs = 120_000 } = {}) {
     if (!CHANNEL_TOOLS.has(name)) throw new Error(`unknown channel tool: ${name}`);
+    if (!ensureOwner()) {
+      return await executeViaOwnerHttp(name, args || {}, timeoutMs);
+    }
     await start();
     if (!useProcessWorker) {
       const call = inProcessMod?.handleToolCallWithBridgeRetry || inProcessMod?.handleToolCall;
@@ -217,6 +453,91 @@ export function createStandaloneChannelWorker({
     });
   }
 
+  async function executeViaOwnerHttp(name, args, timeoutMs) {
+    const active = readActiveInstance();
+    const port = parsePort(active?.httpPort);
+    const instanceId = active?.instanceId;
+    const token = readOwnerSecret(instanceId);
+    if (!port || !token) {
+      const owner = externalOwner();
+      throw new Error(`channels runtime is owned by pid ${owner?.pid || 'unknown'} but owner HTTP is unavailable`);
+    }
+    const headers = {
+      'x-owner-token': token,
+      'x-owner-instance': String(instanceId || ''),
+    };
+    const post = (path, body) => requestJson({ port, method: 'POST', path, body, headers, timeoutMs });
+    const get = (path) => requestJson({ port, method: 'GET', path, headers, timeoutMs });
+
+    switch (name) {
+      case 'reply': {
+        const result = await post('/send', {
+          chatId: args.chat_id,
+          text: args.text,
+          opts: {
+            replyTo: args.reply_to,
+            files: args.files ?? [],
+            embeds: args.embeds ?? [],
+            components: args.components ?? [],
+          },
+        });
+        const ids = Array.isArray(result?.sentIds) ? result.sentIds : [];
+        return textResult(ids.length === 1 ? `sent (id: ${ids[0]})` : `sent ${ids.length} parts (ids: ${ids.join(', ')})`);
+      }
+      case 'fetch': {
+        const channel = encodeURIComponent(String(args.channel || ''));
+        const limit = Math.max(1, Number(args.limit) || 20);
+        const result = await get(`/fetch?channel=${channel}&limit=${limit}`);
+        const msgs = Array.isArray(result?.messages) ? result.messages : [];
+        const text = msgs.length === 0 ? '(no messages)' : msgs.map((m) => {
+          const atts = Number(m.attachmentCount) > 0 ? ` +${m.attachmentCount}att` : '';
+          return `[${m.ts}] ${m.user}: ${m.text}  (id: ${m.id}${atts})`;
+        }).join('\n');
+        return textResult(text);
+      }
+      case 'react':
+        await post('/react', { chatId: args.chat_id, messageId: args.message_id, emoji: args.emoji });
+        return textResult('reacted');
+      case 'edit_message': {
+        const result = await post('/edit', {
+          chatId: args.chat_id,
+          messageId: args.message_id,
+          text: args.text,
+          opts: { embeds: args.embeds ?? [], components: args.components ?? [] },
+        });
+        return textResult(`edited (id: ${result?.id ?? ''})`);
+      }
+      case 'download_attachment': {
+        const result = await post('/download', { chatId: args.chat_id, messageId: args.message_id });
+        const files = Array.isArray(result?.files) ? result.files : [];
+        if (files.length === 0) return textResult('message has no attachments');
+        return textResult(`downloaded ${files.length} attachment(s):\n${files.map((f) => `  ${f.path}  (${f.name}, ${f.contentType}, ${(Number(f.size || 0) / 1024).toFixed(0)}KB)`).join('\n')}`);
+      }
+      case 'schedule_status': {
+        const result = await get('/schedule-status');
+        return result?.result ?? textResult('no schedules configured');
+      }
+      case 'trigger_schedule': {
+        const result = await post('/trigger-schedule', { name: args.name });
+        return textResult(result?.result == null ? '' : String(result.result));
+      }
+      case 'schedule_control': {
+        const result = await post('/schedule-control', { name: args.name, action: args.action, minutes: args.minutes });
+        return result?.result ?? textResult(`unknown action: ${args.action}`, true);
+      }
+      case 'activate_channel_bridge':
+        await post('/bridge/activate', { active: args.active === true });
+        return textResult(`channel bridge ${args.active ? 'activated' : 'deactivated'}`);
+      case 'inject_command':
+        await post('/inject', { content: `/${String(args.command || '').trim()}`, source: 'mixdog-agent', type: 'command' });
+        return textResult(`queued /${String(args.command || '').trim()} via channel owner`);
+      case 'reload_config':
+        return textResult('reload_config must run in the channel owner process', true);
+      default:
+        return textResult(`unknown channel tool: ${name}`, true);
+    }
+  }
+
   function forceKillTree(pid) {
     if (!pid) return;
     if (process.platform === 'win32') {
@@ -241,16 +562,26 @@ export function createStandaloneChannelWorker({
   }
 
   function installParentExitHook() {
-    if (parentExitHookInstalled) return;
-    parentExitHookInstalled = true;
-    process.once('exit', () => {
-      for (const pid of Array.from(ownedChildPids)) {
-        forceKillTreeSync(pid);
+    if (parentExitCleanup) return;
+    parentExitCleanup = registerChannelWorkerExitCleanup(() => {
+      parentExitCleanup = null;
+      if (!daemonEnabled) {
+        for (const pid of Array.from(ownedChildPids)) {
+          forceKillTreeSync(pid);
+        }
+        releaseOwner();
       }
       ownedChildPids.clear();
     });
   }
 
+  function uninstallParentExitHook() {
+    if (!parentExitCleanup) return;
+    const unregister = parentExitCleanup;
+    parentExitCleanup = null;
+    unregister();
+  }
+
   function unrefChildHandles(target) {
     try { target?.unref?.(); } catch {}
     try { target?.stderr?.unref?.(); } catch {}
@@ -261,14 +592,20 @@ export function createStandaloneChannelWorker({
 
   function stop(reason = 'standalone shutdown', options = {}) {
     const waitForExit = options?.waitForExit !== false;
+    stopNotifyBus();
+    stopClientHeartbeat();
     if (stopPromise) return stopPromise;
     if (!useProcessWorker) {
-      if (!inProcessMod && !inProcessStartPromise) return Promise.resolve(false);
+      if (!inProcessMod && !inProcessStartPromise) {
+        releaseOwner();
+        return Promise.resolve(false);
+      }
       stopPromise = Promise.resolve(inProcessStartPromise)
         .catch(() => null)
         .then(async () => {
           try { await inProcessMod?.stop?.(reason); } catch {}
           inProcessMod = null;
+          releaseOwner();
           return true;
         })
         .finally(() => {
@@ -276,10 +613,24 @@ export function createStandaloneChannelWorker({
         });
       return stopPromise;
     }
-    if (!child) return Promise.resolve(false);
+    if (!child) {
+      stopNotifyBus();
+      releaseOwner();
+      return Promise.resolve(false);
+    }
     const target = child;
     const targetPid = target.pid;
     child = null;
+    if (daemonEnabled && options?.force !== true) {
+      rejectPending(new Error(`channels runtime detached (${reason})`));
+      if (targetPid) ownedChildPids.delete(targetPid);
+      try { target.disconnect?.(); } catch {}
+      unrefChildHandles(target);
+      ownerClaim = null;
+      ownerPid = process.pid;
+      uninstallParentExitHook();
+      return Promise.resolve(true);
+    }
     if (!waitForExit) {
       rejectPending(new Error(`channels runtime shutdown requested (${reason})`));
       if (targetPid) ownedChildPids.delete(targetPid);
@@ -291,6 +642,8 @@ export function createStandaloneChannelWorker({
           clearTimeout(sendTimer);
           stopPromise = null;
           unrefChildHandles(target);
+          releaseOwner();
+          uninstallParentExitHook();
           resolve(ok);
         };
         const sendTimer = setTimeout(() => finish(false), 250);
@@ -314,6 +667,9 @@ export function createStandaloneChannelWorker({
         clearTimeout(termTimer);
         clearTimeout(killTimer);
         stopPromise = null;
+        stopNotifyBus();
+        releaseOwner();
+        uninstallParentExitHook();
         resolve(ok);
       };
       const termTimer = setTimeout(() => {