mixdog 0.9.1 → 0.9.3

package/src/standalone/hook-bus.mjs

@@ -86,7 +86,7 @@ const PLAIN_STDOUT_CONTEXT_EVENTS = new Set([
   'UserPromptExpansion',
 ]);
 
-const SUPPORTED_HANDLER_TYPES = new Set(['command', 'http']);
+const SUPPORTED_HANDLER_TYPES = new Set(['command', 'http', 'mcp_tool', 'prompt']);
 
 function compactValue(value) {
   if (value == null) return value;
@@ -349,6 +349,7 @@ function buildEventPayload(eventName, input = {}) {
     'expansion_type',
     'stop_reason',
     'error_type',
+    'agent_type',
   ]) {
     if (input[key] != null) payload[key] = input[key];
   }
@@ -374,6 +375,7 @@ function handlerTimeoutS(handler, eventName) {
   if (Number.isFinite(handler.timeout) && handler.timeout > 0) return handler.timeout;
   if (handler.type === 'prompt') return DEFAULT_PROMPT_TIMEOUT_S;
   if (handler.type === 'agent') return DEFAULT_AGENT_TIMEOUT_S;
+  if (handler.type === 'mcp_tool') return DEFAULT_COMMAND_TIMEOUT_S;
   if (eventName === 'UserPromptSubmit') return USER_PROMPT_TIMEOUT_S;
   if (eventName === 'MessageDisplay') return MESSAGE_DISPLAY_TIMEOUT_S;
   return DEFAULT_COMMAND_TIMEOUT_S;
@@ -427,7 +429,7 @@ function hookEnv(projectDir, pluginData, payload, pluginRoot = null) {
   return env;
 }
 
-function runCommandHandler(handler, payload, eventName, pluginData, onSpawnError = null) {
+function runCommandHandler(handler, payload, eventName, pluginData, onSpawnError = null, onRewake = null) {
   const projectDir = payload.cwd || process.cwd();
   const effectivePluginData = handler._pluginData || pluginData || null;
   const stdin = JSON.stringify(payload);
@@ -440,7 +442,58 @@ function runCommandHandler(handler, payload, eventName, pluginData, onSpawnError
     stdio: ['pipe', 'pipe', 'pipe'],
   };
 
-  if (handler.async === true || handler.asyncRewake === true) {
+  if (handler.asyncRewake === true) {
+    try {
+      const child = spawn(spec.command, spec.args, {
+        ...baseOpts,
+      });
+      let bgStdout = '';
+      let bgStderr = '';
+      let bgStdoutBytes = 0;
+      let bgStderrBytes = 0;
+      let killed = false;
+      child.stdout?.on('data', (chunk) => {
+        bgStdoutBytes += chunk.length;
+        if (bgStdoutBytes <= MAX_BUFFER_BYTES) bgStdout += chunk.toString('utf8');
+      });
+      child.stderr?.on('data', (chunk) => {
+        bgStderrBytes += chunk.length;
+        if (bgStderrBytes <= MAX_BUFFER_BYTES) bgStderr += chunk.toString('utf8');
+      });
+      const killTimer = setTimeout(() => {
+        killed = true;
+        try { child.stdout?.removeAllListeners('data'); } catch {}
+        try { child.stderr?.removeAllListeners('data'); } catch {}
+        try { child.kill('SIGTERM'); } catch {}
+      }, timeoutMs);
+      killTimer.unref?.();
+      child.on('error', (error) => {
+        clearTimeout(killTimer);
+        if (typeof onSpawnError === 'function') onSpawnError(error);
+      });
+      child.on('close', (code) => {
+        clearTimeout(killTimer);
+        try {
+          if (!killed && code === 2 && typeof onRewake === 'function') {
+            const text = (bgStderr || '').trim() || (bgStdout || '').trim();
+            onRewake({ eventName, payload, text });
+          }
+        } catch {}
+      });
+      child.stdin?.end(stdin);
+      return Promise.resolve({ exitCode: 0, stdout: '', stderr: '', async: true });
+    } catch (error) {
+      return Promise.resolve({
+        exitCode: -1,
+        stdout: '',
+        stderr: error?.message || String(error),
+        timedOut: false,
+        spawnError: error,
+      });
+    }
+  }
+
+  if (handler.async === true) {
     try {
       const child = spawn(spec.command, spec.args, {
         ...baseOpts,
@@ -584,6 +637,78 @@ async function runHttpHandler(handler, payload, eventName) {
   }
 }
 
+async function runMcpToolHandler(handler, payload, eventName, mcpToolRunner) {
+  const timeoutMs = Math.round(handlerTimeoutS(handler, eventName) * 1000);
+  let name = String(handler.tool || '').trim();
+  if (handler.server && !name.startsWith('mcp__')) {
+    name = `mcp__${String(handler.server).trim()}__${name}`;
+  }
+  if (!name) {
+    return { exitCode: -1, stdout: '', stderr: 'mcp_tool handler missing tool name', timedOut: false, spawnError: null };
+  }
+  let timer = null;
+  try {
+    const runPromise = Promise.resolve(mcpToolRunner({ name, args: payload }));
+    const text = await Promise.race([
+      runPromise,
+      new Promise((_r, reject) => {
+        timer = setTimeout(() => reject(new Error(`mcp_tool hook timed out: ${name}`)), timeoutMs);
+        // No unref: this timer must keep the event loop alive so the race can
+        // settle even when the runner promise never resolves. Cleared in finally.
+      }),
+    ]);
+    return { exitCode: 0, stdout: limitText(String(text ?? '')), stderr: '', timedOut: false, spawnError: null };
+  } catch (error) {
+    const timedOut = /timed out/i.test(error?.message || '');
+    return { exitCode: -1, stdout: '', stderr: error?.message || String(error), timedOut, spawnError: null };
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
+async function runPromptHandler(handler, payload, eventName, promptRunner) {
+  const timeoutMs = Math.round(handlerTimeoutS(handler, eventName) * 1000);
+  const prompt = String(handler.prompt || '');
+  if (!prompt) {
+    return { exitCode: -1, stdout: '', stderr: 'prompt handler missing prompt', timedOut: false, spawnError: null };
+  }
+  let timer = null;
+  try {
+    const runPromise = Promise.resolve(promptRunner({ prompt, payload, timeoutMs }));
+    const text = await Promise.race([
+      runPromise,
+      new Promise((_r, reject) => {
+        timer = setTimeout(() => reject(new Error(`prompt hook timed out: ${eventName}`)), timeoutMs);
+        // No unref: this timer must keep the event loop alive so the race can
+        // settle even when the runner promise never resolves. Cleared in finally.
+      }),
+    ]);
+    const raw = String(text ?? '').trim();
+    const deny = (reason) => ({ exitCode: 2, stdout: '', stderr: reason, timedOut: false, spawnError: null });
+    const allow = () => ({ exitCode: 0, stdout: '', stderr: '', timedOut: false, spawnError: null });
+    let verdict = null;
+    try {
+      verdict = JSON.parse(raw);
+    } catch {
+      verdict = undefined;
+    }
+    if (verdict && typeof verdict === 'object') {
+      if (verdict.ok === false) return deny(String(verdict.reason || `blocked by ${eventName} prompt hook`));
+      return allow();
+    }
+    // plain-text response
+    const lowered = raw.toLowerCase();
+    if (!raw || ['yes', 'true', 'allow', 'ok'].includes(lowered)) return allow();
+    if (['no', 'false', 'deny', 'block'].includes(lowered)) return deny(raw || `blocked by ${eventName} prompt hook`);
+    return allow();
+  } catch (error) {
+    const timedOut = /timed out/i.test(error?.message || '');
+    return { exitCode: -1, stdout: '', stderr: error?.message || String(error), timedOut, spawnError: null };
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
 function limitText(text) {
   const value = String(text || '');
   if (value.length <= MAX_OUTPUT_CHARS) return value;
@@ -727,10 +852,13 @@ function summarizeRule(rule, index) {
 
 function handlerDedupeKey(handler) {
   if (!handler || typeof handler !== 'object') return '';
+  const ifKey = handler.if != null ? `|if:${JSON.stringify(handler.if)}` : '';
   if (handler.type === 'command') {
-    return `command:${handler._pluginRoot || ''}:${handler.command || ''}:${JSON.stringify(handler.args || null)}`;
+    return `command:${handler._pluginRoot || ''}:${handler.command || ''}:${JSON.stringify(handler.args || null)}${ifKey}`;
   }
-  if (handler.type === 'http') return `http:${handler.url || ''}`;
+  if (handler.type === 'http') return `http:${handler.url || ''}${ifKey}`;
+  if (handler.type === 'mcp_tool') return `mcp_tool:${handler.server || ''}:${handler.tool || ''}${ifKey}`;
+  if (handler.type === 'prompt') return `prompt:${handler.prompt || ''}${ifKey}`;
   return `${handler.type || 'unknown'}:${JSON.stringify(handler)}`;
 }
 
@@ -742,11 +870,12 @@ function shellCountFor(handler) {
   return handler?.type || 'unknown';
 }
 
-export function createStandaloneHookBus({ maxEvents = 80, dataDir = null } = {}) {
+export function createStandaloneHookBus({ maxEvents = 80, dataDir = null, promptRunner = null, mcpToolRunner = null } = {}) {
   const recent = [];
   const counts = new Map(DEFAULT_EVENTS.map((name) => [name, 0]));
   const rulesPath = hookRulesPath(dataDir);
   const pluginData = dataDir || null;
+  let rewakeHandler = null;
   let rulesCache = { mtimeMs: -1, rules: [] };
   let configCache = {
     key: '',
@@ -883,12 +1012,35 @@ export function createStandaloneHookBus({ maxEvents = 80, dataDir = null } = {})
           error: `hook spawn failed: ${error?.message || error}`,
         });
       };
-      return await runCommandHandler(handler, payload, eventName, pluginData, reportSpawnError);
+      const reportRewake = ({ eventName: en, payload: pl, text }) => {
+        try {
+          if (typeof rewakeHandler === 'function') {
+            rewakeHandler({ eventName: en, payload: pl, text });
+          } else {
+            emit('hook:rewake', { name: pl?.tool_name || en, text: text || null });
+          }
+        } catch {}
+      };
+      return await runCommandHandler(handler, payload, eventName, pluginData, reportSpawnError, reportRewake);
     }
     if (type === 'http') {
       if (!handler.url) return null;
       return await runHttpHandler(handler, payload, eventName);
     }
+    if (type === 'mcp_tool') {
+      if (typeof mcpToolRunner !== 'function') {
+        emit('hook:error', { name: payload.tool_name || eventName, error: 'handler type mcp_tool not configured' });
+        return null;
+      }
+      return await runMcpToolHandler(handler, payload, eventName, mcpToolRunner);
+    }
+    if (type === 'prompt') {
+      if (typeof promptRunner !== 'function') {
+        emit('hook:error', { name: payload.tool_name || eventName, error: 'handler type prompt not configured' });
+        return null;
+      }
+      return await runPromptHandler(handler, payload, eventName, promptRunner);
+    }
     return null;
   }
 
@@ -1118,5 +1270,10 @@ export function createStandaloneHookBus({ maxEvents = 80, dataDir = null } = {})
     };
   }
 
-  return { addRule, beforeTool, deleteRule, dispatch, emit, listRules, setRuleEnabled, status };
+  function setRewakeHandler(fn) {
+    rewakeHandler = typeof fn === 'function' ? fn : null;
+    return rewakeHandler;
+  }
+
+  return { addRule, beforeTool, deleteRule, dispatch, emit, listRules, setRewakeHandler, setRuleEnabled, status };
 }

package/src/standalone/memory-runtime-proxy.mjs

@@ -188,12 +188,14 @@ export function createStandaloneMemoryRuntime({
         releaseOwnerIfSelf();
       }
 
+      const daemonEnv = { ...process.env };
+      delete daemonEnv.MIXDOG_QUIET_MEMORY_LOG;
       child = fork(entry, [], {
         cwd,
         stdio: ['ignore', 'ignore', 'pipe', 'ipc'],
         detached: true,
         env: {
-          ...process.env,
+          ...daemonEnv,
           MIXDOG_DATA_DIR: dataDir,
           MIXDOG_WORKER_MODE: '1',
           MIXDOG_STANDALONE: '1',

package/src/standalone/opencode-go-login.mjs

@@ -0,0 +1,121 @@
+import fs from 'node:fs';
+
+const COMMON_BROWSER_PATHS = (() => {
+  const platform = process.platform;
+  if (platform === 'win32') {
+    const localAppData = process.env.LOCALAPPDATA;
+    const programFiles = process.env.PROGRAMFILES || 'C:/Program Files';
+    const programFilesX86 = process.env['PROGRAMFILES(X86)'] || 'C:/Program Files (x86)';
+    return [
+      `${programFiles}/Google/Chrome/Application/chrome.exe`,
+      `${programFilesX86}/Google/Chrome/Application/chrome.exe`,
+      localAppData && `${localAppData}/Google/Chrome/Application/chrome.exe`,
+      `${programFiles}/Microsoft/Edge/Application/msedge.exe`,
+      `${programFilesX86}/Microsoft/Edge/Application/msedge.exe`,
+      localAppData && `${localAppData}/Microsoft/Edge/Application/msedge.exe`,
+    ].filter(Boolean);
+  }
+  if (platform === 'linux') {
+    return [
+      '/usr/bin/google-chrome',
+      '/usr/bin/google-chrome-stable',
+      '/usr/bin/chromium',
+      '/usr/bin/chromium-browser',
+      '/snap/bin/chromium',
+      '/usr/bin/microsoft-edge',
+    ];
+  }
+  return [
+    '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+    '/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary',
+    '/Applications/Chromium.app/Contents/MacOS/Chromium',
+    '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
+  ];
+})();
+
+function resolveExecutablePath() {
+  if (process.env.PUPPETEER_EXECUTABLE_PATH && fs.existsSync(process.env.PUPPETEER_EXECUTABLE_PATH)) {
+    return process.env.PUPPETEER_EXECUTABLE_PATH;
+  }
+  for (const executablePath of COMMON_BROWSER_PATHS) {
+    if (fs.existsSync(executablePath)) return executablePath;
+  }
+  return null;
+}
+
+let _inflight = null;
+
+export async function loginOpenCodeGoConsoleWithBrowser({ timeoutMs = 300_000, onStatus } = {}) {
+  if (_inflight) return _inflight;
+  _inflight = _run({ timeoutMs, onStatus }).finally(() => { _inflight = null; });
+  return _inflight;
+}
+
+async function _run({ timeoutMs, onStatus }) {
+  const status = (msg) => { try { if (typeof onStatus === 'function') onStatus(msg); } catch {} };
+  const executablePath = resolveExecutablePath();
+  if (!executablePath) {
+    throw new Error('No Chrome/Edge browser found. Set PUPPETEER_EXECUTABLE_PATH to a Chrome or Edge executable.');
+  }
+
+  const puppeteer = (await import('puppeteer-core')).default;
+  let browser = null;
+  let closed = false;
+  const closeBrowser = async () => {
+    if (closed) return;
+    closed = true;
+    try { if (browser) await browser.close(); } catch {}
+  };
+
+  try {
+    status('Launching browser…');
+    browser = await puppeteer.launch({
+      headless: false,
+      executablePath,
+      defaultViewport: null,
+      args: ['--disable-dev-shm-usage'],
+    });
+
+    let disconnected = false;
+    browser.on('disconnected', () => { disconnected = true; });
+
+    const page = (await browser.pages())[0] || (await browser.newPage());
+    status('Opening opencode.ai/auth — please sign in…');
+    await page.goto('https://opencode.ai/auth', { waitUntil: 'domcontentloaded' }).catch(() => {});
+
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      if (disconnected || page.isClosed()) {
+        throw new Error('Browser was closed before login completed.');
+      }
+      let cookies;
+      try {
+        cookies = await page.cookies('https://opencode.ai');
+      } catch {
+        throw new Error('Browser was closed before login completed.');
+      }
+      const auth = cookies.find(c => c.name === 'auth');
+      const url = page.url();
+      const wsMatch = url.match(/\/workspace\/(wrk_[a-zA-Z0-9]+)/);
+      // Only treat the login as complete on an authenticated console page.
+      // A pre-existing/stale auth cookie on a marketing or docs page must not
+      // short-circuit the flow with workspaceId:null.
+      const onWorkspace = (() => {
+        try {
+          const parsed = new URL(url);
+          return parsed.hostname.endsWith('opencode.ai') && /^\/(?:[a-z-]+\/)?workspace(\/|$)/.test(parsed.pathname);
+        } catch {
+          return false;
+        }
+      })();
+      if (auth && auth.value && (wsMatch || onWorkspace)) {
+        status('Auth cookie captured.');
+        return { authCookie: auth.value, workspaceId: wsMatch?.[1] || null };
+      }
+      await new Promise(r => setTimeout(r, 1000));
+    }
+    throw new Error(`Timed out after ${Math.round(timeoutMs / 1000)}s waiting for OpenCode Go login.`);
+  } finally {
+    await closeBrowser();
+  }
+}

package/src/standalone/provider-admin.mjs

@@ -52,6 +52,17 @@ const API_PROVIDER_IDS = new Set(API_PROVIDERS.map((p) => p.id));
 const OAUTH_BY_ID = new Map(OAUTH_PROVIDERS.map((p) => [p.id, p]));
 const LOCAL_BY_ID = new Map(LOCAL_PROVIDERS.map((p) => [p.id, p]));
 
+const ALL_PROVIDER_IDS = new Set([
+  ...API_PROVIDERS.map((p) => p.id),
+  ...OAUTH_PROVIDERS.map((p) => p.id),
+  ...LOCAL_PROVIDERS.map((p) => p.id),
+]);
+
+export function isKnownProvider(provider) {
+  const id = String(provider || '').trim();
+  return id !== '' && ALL_PROVIDER_IDS.has(id);
+}
+
 async function detectLocalProvider(baseURL) {
   const url = String(baseURL || '').replace(/\/+$/, '') + '/models';
   const controller = new AbortController();
@@ -303,12 +314,23 @@ export function saveOpenCodeGoUsageAuth(cfgMod, { workspaceId, authCookie } = {}
   if (!cookie) throw new Error('OpenCode auth cookie is required for usage lookup');
   const authMatch = /(?:^|;\s*)auth=([^;]+)/.exec(cookie);
   saveSecret(SECRET_ACCOUNTS.opencodeGoAuthCookie, authMatch ? authMatch[1] : cookie);
-  updateConfigProvider(cfgMod, 'opencode-go', workspace
-    ? { enabled: true, workspaceId: workspace }
-    : { enabled: true });
+  // Usage auth is a console cookie, not a model API key. Only flip the model
+  // provider on when a key actually exists; otherwise cookie-only setups get
+  // routed to the provider with apiKey 'no-key' and fail with 401s.
+  const hasApiKey = Boolean(getAgentApiKey('opencode-go'));
+  updateConfigProvider(cfgMod, 'opencode-go', {
+    ...(hasApiKey ? { enabled: true } : {}),
+    ...(workspace ? { workspaceId: workspace } : {}),
+  });
   return { provider: 'opencode-go', type: 'usage-auth', authenticated: true, workspaceId: workspace || null };
 }
 
+export async function loginOpenCodeGoUsage(cfgMod) {
+  const { loginOpenCodeGoConsoleWithBrowser } = await import('./opencode-go-login.mjs');
+  const { workspaceId, authCookie } = await loginOpenCodeGoConsoleWithBrowser();
+  return saveOpenCodeGoUsageAuth(cfgMod, { workspaceId, authCookie });
+}
+
 export function setLocalProvider(cfgMod, provider, { enabled, baseURL } = {}) {
   const id = String(provider || '').trim();
   const local = LOCAL_BY_ID.get(id);

package/src/standalone/usage-dashboard.mjs

@@ -29,7 +29,7 @@ function clean(value) {
 
 function money(value) {
   const n = Number(value);
-  if (!Number.isFinite(n)) return 'n/a';
+  if (!Number.isFinite(n)) return 'N/A';
   if (n === 0) return '$0';
   if (n >= 10) return `$${n.toFixed(0)}`;
   if (n >= 1) return `$${n.toFixed(2)}`;