amicus 1.0.0

package/electron/ipc-setup.js

@@ -0,0 +1,176 @@
+/**
+ * IPC Setup Handlers
+ *
+ * Extracted from main.js to keep file sizes under 300 lines.
+ * Registers all setup-mode IPC handlers: validate-key, save-key,
+ * remove-key, setup-done, save-config, get-config, get-api-keys,
+ * fetch-models, get-catalog, and refresh-catalog.
+ */
+
+const { logger } = require('../src/utils/logger');
+
+/**
+ * Register all setup-related IPC handlers
+ * @param {Electron.IpcMain} ipcMain - Electron IPC main
+ * @param {function} getMainWindow - Returns the current main BrowserWindow
+ */
+function registerSetupHandlers(ipcMain, getMainWindow) {
+  ipcMain.handle('sidecar:validate-key', async (_event, provider, key) => {
+    try {
+      const { validateApiKey } = require('../src/utils/api-key-store');
+      return await validateApiKey(provider, key);
+    } catch (err) {
+      logger.error('validate-key handler error', { error: err.message });
+      return { valid: false, error: err.message };
+    }
+  });
+
+  ipcMain.handle('sidecar:save-key', async (_event, provider, key) => {
+    try {
+      const { saveApiKey } = require('../src/utils/api-key-store');
+      const result = saveApiKey(provider, key);
+      // F5: warm the model catalog as soon as a key lands so the Step 2
+      // picker renders instantly. Fire-and-forget; failures are silent
+      // (a failed warm-up never clobbers the cache; Step 2's get-catalog or
+      // the refresh button retry it).
+      if (result && result.success !== false) {
+        setImmediate(() => {
+          try {
+            require('../src/utils/model-catalog').refreshCatalog().catch(() => {});
+          } catch { /* best-effort */ }
+        });
+      }
+      return result;
+    } catch (err) {
+      logger.error('save-key handler error', { error: err.message });
+      return { success: false, error: err.message };
+    }
+  });
+
+  ipcMain.handle('sidecar:remove-key', async (_event, provider) => {
+    try {
+      const { removeApiKey } = require('../src/utils/api-key-store');
+      const { removeFromAuthJson } = require('../src/utils/auth-json');
+      const result = removeApiKey(provider);
+      // Always clean auth.json too — prevents auto-import from re-adding the key
+      if (result.alsoInAuthJson) {
+        removeFromAuthJson(provider);
+        result.alsoInAuthJson = false;
+      }
+      return result;
+    } catch (err) {
+      logger.error('remove-key handler error', { error: err.message });
+      return { success: false, error: err.message };
+    }
+  });
+
+  ipcMain.handle('sidecar:remove-from-opencode', async (_event, provider) => {
+    try {
+      const { removeFromAuthJson } = require('../src/utils/auth-json');
+      removeFromAuthJson(provider);
+      return { success: true };
+    } catch (err) {
+      logger.error('remove-from-opencode handler error', { error: err.message });
+      return { success: false, error: err.message };
+    }
+  });
+
+  ipcMain.handle('sidecar:setup-done', (_event, defaultModel, keyCount) => {
+    const { BrowserWindow } = require('electron');
+    const senderWindow = BrowserWindow.fromWebContents(_event.sender);
+    const mainWin = getMainWindow();
+
+    // If sent from main window → stdout + close (CLI setup flow)
+    // If sent from child window → just close it (settings flow)
+    if (senderWindow === mainWin) {
+      const result = JSON.stringify({
+        status: 'complete',
+        default: defaultModel || undefined,
+        keyCount: keyCount || undefined
+      });
+      process.stdout.write(result + '\n');
+      if (mainWin) { mainWin.close(); }
+    } else if (senderWindow) {
+      senderWindow.close();
+    }
+  });
+
+  ipcMain.handle('sidecar:save-config', (_event, defaultModel, aliasOverrides) => {
+    const { saveConfig, getDefaultAliases } = require('../src/utils/config');
+    const aliases = getDefaultAliases();
+    if (aliasOverrides && typeof aliasOverrides === 'object') {
+      Object.assign(aliases, aliasOverrides);
+    }
+    saveConfig({ default: defaultModel, aliases });
+    return { success: true };
+  });
+
+  ipcMain.handle('sidecar:get-config', () => {
+    const { loadConfig } = require('../src/utils/config');
+    return loadConfig();
+  });
+
+  ipcMain.handle('sidecar:get-api-keys', () => {
+    try {
+      const { readApiKeys, readApiKeyHints, saveApiKey } = require('../src/utils/api-key-store');
+      const { importFromAuthJson } = require('../src/utils/auth-json');
+      const status = readApiKeys();
+      const hints = readApiKeyHints();
+
+      // Auto-import keys from auth.json that sidecar doesn't have yet
+      const { imported } = importFromAuthJson(status);
+      for (const entry of imported) {
+        const result = saveApiKey(entry.provider, entry.key);
+        if (result && result.success !== false) {
+          status[entry.provider] = true;
+          const visible = entry.key.slice(0, 8);
+          hints[entry.provider] = visible + '\u2022'.repeat(Math.max(0, Math.min(entry.key.length - 8, 12)));
+        }
+      }
+
+      return { status, hints, imported: imported.map(e => e.provider) };
+    } catch (err) {
+      logger.error('get-api-keys handler error', { error: err.message });
+      return { status: {}, hints: {}, imported: [] };
+    }
+  });
+
+  ipcMain.handle('sidecar:fetch-models', async () => {
+    try {
+      const { readApiKeyValues } = require('../src/utils/api-key-store');
+      const { fetchAllModels, groupModelsByFamily } = require('../src/utils/model-fetcher');
+      const keys = readApiKeyValues();
+      const models = await fetchAllModels(keys);
+      return groupModelsByFamily(models);
+    } catch (err) {
+      logger.error('fetch-models handler error', { error: err.message });
+      return [];
+    }
+  });
+
+  // F5: wizard Step 2 reads the catalog CACHE (self-refreshing when stale).
+  ipcMain.handle('sidecar:get-catalog', async () => {
+    try {
+      const { getCatalogInfo } = require('../src/utils/model-catalog');
+      return await getCatalogInfo();
+    } catch (err) {
+      logger.error('get-catalog handler error', { error: err.message });
+      return { models: [], fetchedAt: null };
+    }
+  });
+
+  ipcMain.handle('sidecar:refresh-catalog', async () => {
+    try {
+      const { refreshCatalog, getCatalogInfo } = require('../src/utils/model-catalog');
+      await refreshCatalog();
+      // maxAgeMs: Infinity — report whatever the cache now holds without
+      // re-triggering a second fetch when the refresh just failed.
+      return await getCatalogInfo({ maxAgeMs: Number.POSITIVE_INFINITY });
+    } catch (err) {
+      logger.error('refresh-catalog handler error', { error: err.message });
+      return { models: [], fetchedAt: null };
+    }
+  });
+}
+
+module.exports = { registerSetupHandlers };

package/electron/load-failsafe.js

@@ -0,0 +1,85 @@
+/**
+ * Load Failsafe
+ *
+ * The Amicus window is created hidden and only shown after the OpenCode UI
+ * finishes loading (main.js did-finish-load -> rebrand -> show). If that load
+ * fails or stalls, nothing would ever show the window: the process sits as an
+ * invisible, silent hang (the historical "Starting up... | 0 messages" bug).
+ *
+ * attachLoadFailsafe watches a webContents and fires onFail exactly once when
+ * the main frame definitively fails to load, or when nothing has resolved
+ * within timeoutMs. The caller decides how to surface it (show the window,
+ * render an error page, log). cancel() disarms it on the success path.
+ */
+
+'use strict';
+
+const DEFAULT_TIMEOUT_MS = 15000;
+const ERR_ABORTED = -3; // benign: fires on in-page redirects/navigation replacement
+
+/**
+ * Watch a webContents for startup load failure or stall.
+ * @param {{ webContents: object, timeoutMs?: number, onFail: Function }} opts
+ * @returns {{ cancel: Function }} call cancel() once the window is shown
+ */
+function attachLoadFailsafe({ webContents, timeoutMs = DEFAULT_TIMEOUT_MS, onFail }) {
+  let settled = false;
+
+  const fire = (detail) => {
+    if (settled) { return; }
+    settled = true;
+    clearTimeout(timer);
+    onFail(detail);
+  };
+
+  const timer = setTimeout(() => fire({ reason: 'timeout' }), timeoutMs);
+
+  webContents.on('did-fail-load', (_event, errorCode, errorDescription, validatedURL, isMainFrame) => {
+    if (!isMainFrame || errorCode === ERR_ABORTED) { return; }
+    fire({ reason: 'load-failed', errorCode, errorDescription, validatedURL });
+  });
+
+  return {
+    cancel() {
+      settled = true;
+      clearTimeout(timer);
+    }
+  };
+}
+
+/** @param {*} value @returns {string} HTML-escaped text */
+function escapeHTML(value) {
+  return String(value)
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
+}
+
+/**
+ * Error page shown in the content area when the OpenCode UI fails to load.
+ * @param {{ url: string, errorCode: number|string, errorDescription: string }} info
+ * @returns {string} full HTML document
+ */
+function buildLoadErrorHTML({ url, errorCode, errorDescription }) {
+  return `<!DOCTYPE html>
+<html><head><style>
+  body { background: #2D2B2A; color: #D4D0CC; font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+         display: flex; align-items: center; justify-content: center; height: 100vh; margin: 0; }
+  .box { max-width: 440px; padding: 24px; }
+  h1 { color: #D97757; font-size: 16px; margin: 0 0 12px; }
+  p { font-size: 13px; line-height: 1.5; color: #A09B96; margin: 0 0 10px; }
+  code { font-family: 'SF Mono', Menlo, Consolas, monospace; font-size: 11px; color: #D4D0CC;
+         word-break: break-all; }
+</style></head><body>
+  <div class="box">
+    <h1>Amicus could not load the conversation UI</h1>
+    <p><code>${escapeHTML(errorDescription)} (${escapeHTML(errorCode)})</code></p>
+    <p>Failed URL: <code>${escapeHTML(url)}</code></p>
+    <p>The OpenCode server may have stopped. Close this window and rerun the
+       command, or use <code>--no-ui</code> for headless mode.</p>
+  </div>
+</body></html>`;
+}
+
+module.exports = { attachLoadFailsafe, buildLoadErrorHTML, DEFAULT_TIMEOUT_MS };