mixdog 0.9.2 → 0.9.4

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

@@ -203,6 +203,13 @@ export function createStandaloneMemoryRuntime({
           MIXDOG_OWNER_LEAD_PID: String(process.pid),
           MIXDOG_MEMORY_SECONDARY: '0',
           MIXDOG_PG_ATTACH_ONLY: '0',
+          // seeds.mjs defaults MIXDOG_EMBED_WARMUP to '0' for the HOST process
+          // (TUI boot must not pay the ONNX session-create cost). The daemon is
+          // the long-lived embed owner, so warmup is force-enabled here like the
+          // secondary/attach flags above — otherwise the daemon boots cold and
+          // every recall runs lexical-only until the first fallback flush
+          // lazily loads the model (observed 1.5h '(no results)' windows).
+          MIXDOG_EMBED_WARMUP: '1',
           MIXDOG_MEMORY_DISABLE_CYCLES: process.env.MIXDOG_MEMORY_DISABLE_CYCLES ?? '0',
           MIXDOG_MEMORY_DISABLE_LLM_WORKER: process.env.MIXDOG_MEMORY_DISABLE_LLM_WORKER ?? '0',
           MIXDOG_QUIET_SESSION_LOG: process.env.MIXDOG_QUIET_SESSION_LOG ?? '1',

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

@@ -0,0 +1,125 @@
+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,
+      // Google blocks sign-in on automation-flagged browsers ("Couldn't sign
+      // you in / This browser may not be secure"). Strip the automation
+      // banner/flag so the OAuth login can complete.
+      ignoreDefaultArgs: ['--enable-automation'],
+      args: ['--disable-dev-shm-usage', '--disable-blink-features=AutomationControlled', '--no-first-run', '--no-default-browser-check'],
+    });
+
+    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

@@ -40,7 +40,7 @@ export const API_PROVIDERS = Object.freeze([
 export const OAUTH_PROVIDERS = Object.freeze([
   Object.freeze({ id: 'openai-oauth', name: 'OpenAI OAuth', desc: 'Mixdog OAuth credentials', has: hasOpenAIOAuthCredentials, describe: describeOpenAIOAuthCredentials, forget: forgetOpenAIOAuthCredentials, begin: beginOpenAIOAuthLogin, login: loginOpenAIOAuth }),
   Object.freeze({ id: 'anthropic-oauth', name: 'Anthropic OAuth', desc: 'Mixdog OAuth credentials', has: hasAnthropicOAuthCredentials, describe: describeAnthropicOAuthCredentials, forget: forgetAnthropicOAuthCredentials, begin: beginAnthropicOAuthLogin, login: loginAnthropicOAuth }),
-  Object.freeze({ id: 'grok-oauth', name: 'Grok', desc: 'Mixdog OAuth credentials (Grok Build)', has: hasGrokOAuthCredentials, describe: describeGrokOAuthCredentials, forget: forgetGrokOAuthCredentials, begin: beginGrokOAuthLogin, login: loginGrokOAuth }),
+  Object.freeze({ id: 'grok-oauth', name: 'Grok OAuth', desc: 'Mixdog OAuth credentials (Grok Build)', has: hasGrokOAuthCredentials, describe: describeGrokOAuthCredentials, forget: forgetGrokOAuthCredentials, begin: beginGrokOAuthLogin, login: loginGrokOAuth }),
 ]);
 
 export const LOCAL_PROVIDERS = Object.freeze([
@@ -314,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);
@@ -349,18 +360,3 @@ export function forgetProviderAuth(cfgModOrProvider, maybeProvider) {
   if (cfgMod) updateConfigProvider(cfgMod, id, { enabled: false });
   return { provider: id, type: 'api-key', forgotten: true };
 }
-
-export const PROVIDER_STATUS_TOOL = {
-  name: 'provider_status',
-  title: 'Provider Status',
-  annotations: {
-    title: 'Provider Status',
-    readOnlyHint: true,
-    destructiveHint: false,
-    idempotentHint: true,
-    openWorldHint: false,
-    agentHidden: true,
-  },
-  description: 'List provider auth/config status. No secrets.',
-  inputSchema: { type: 'object', properties: {}, additionalProperties: false },
-};

package/src/standalone/usage-dashboard.mjs

@@ -198,7 +198,9 @@ function applyApiUnavailable(row, id, snapshot) {
   row.status = 'hidden';
   row.source = snapshotUnavailable(snapshot) ? 'provider-api-unavailable' : 'provider-hidden';
   row.sourceLabel = 'unavailable';
-  row.primary = '';
+  // Balance cannot be accurately refreshed for this provider: show an explicit
+  // "-" instead of hiding the row's value or faking a $0 credit.
+  row.primary = '-';
   row.detail = apiUnavailableDetail(id, snapshot);
   return row;
 }