fraim 2.0.135 → 2.0.136

package/dist/src/ai-hub/hosts.js

@@ -207,6 +207,7 @@ function extractSignalFromArgs(args) {
 const EMPLOYEE_LABELS = {
     codex: 'Codex',
     claude: 'Claude Code',
+    gemini: 'Gemini CLI',
 };
 const executableName = (command) => command;
 function quoteWindowsArg(value) {
@@ -237,9 +238,7 @@ const availableByVersionProbe = (command) => {
 };
 function detectEmployees() {
     return Object.keys(EMPLOYEE_LABELS).map((id) => {
-        const available = id === 'codex'
-            ? availableByVersionProbe(executableName('codex'))
-            : availableByVersionProbe(executableName('claude'));
+        const available = availableByVersionProbe(executableName(id));
         return {
             id,
             label: EMPLOYEE_LABELS[id],
@@ -256,6 +255,13 @@ function buildStartPlan(hostId, message) {
             stdin: message,
         };
     }
+    if (hostId === 'gemini') {
+        return {
+            command: executableName('gemini'),
+            args: ['--yolo'],
+            stdin: message,
+        };
+    }
     return {
         command: executableName('claude'),
         args: ['-p', '--verbose', '--output-format', 'stream-json', '--dangerously-skip-permissions'],
@@ -270,6 +276,15 @@ function buildContinuePlan(hostId, sessionId, message) {
             stdin: message,
         };
     }
+    if (hostId === 'gemini') {
+        // Gemini CLI does not have a native session-resume flag; each message
+        // is sent as a fresh invocation. The Hub still tracks state client-side.
+        return {
+            command: executableName('gemini'),
+            args: ['--yolo'],
+            stdin: message,
+        };
+    }
     return {
         command: executableName('claude'),
         args: ['-p', '--verbose', '--output-format', 'stream-json', '--dangerously-skip-permissions', '-r', sessionId],
@@ -307,6 +322,18 @@ function parseHostLine(hostId, line) {
             return withSignal({ raw: trimmed });
         }
     }
+    // Gemini CLI output: if the line is valid JSON, apply signal scanning and
+    // capture the raw line. Plain-text output (non-JSON) is captured as a raw
+    // message so it still surfaces in the Hub timeline.
+    if (hostId === 'gemini') {
+        try {
+            JSON.parse(trimmed); // validate JSON — if this throws, fall through to plain text
+            return withSignal({ raw: trimmed });
+        }
+        catch {
+            return withSignal({ message: trimmed, raw: trimmed });
+        }
+    }
     try {
         const parsed = JSON.parse(trimmed);
         if (parsed.type === 'system' && parsed.session_id) {
@@ -385,6 +412,7 @@ class FakeHostRuntime {
         this.employees = [
             { id: 'codex', label: 'Codex', available: true, detail: 'Test double employee.' },
             { id: 'claude', label: 'Claude Code', available: true, detail: 'Test double employee.' },
+            { id: 'gemini', label: 'Gemini CLI', available: true, detail: 'Test double employee.' },
         ];
     }
     detectEmployees() {
@@ -444,6 +472,7 @@ class ScriptedHostRuntime {
         this.employees = [
             { id: 'codex', label: 'Codex', available: true, detail: 'Scripted test double.' },
             { id: 'claude', label: 'Claude Code', available: true, detail: 'Scripted test double.' },
+            { id: 'gemini', label: 'Gemini CLI', available: true, detail: 'Scripted test double.' },
         ];
         // Track each active run so the test can emit signals at it. Key is the
         // sessionId we hand back on startRun; mapping sessionId → handlers

package/dist/src/ai-hub/server.js

@@ -9,8 +9,10 @@ const express_1 = __importDefault(require("express"));
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const net_1 = __importDefault(require("net"));
+const os_1 = __importDefault(require("os"));
 const crypto_1 = require("crypto");
 const child_process_1 = require("child_process");
+const types_1 = require("../first-run/types");
 const catalog_1 = require("./catalog");
 const agent_token_prices_1 = require("../local-mcp-server/agent-token-prices");
 const hosts_1 = require("./hosts");
@@ -233,6 +235,77 @@ function deriveStages(run, projectPath) {
         return { phaseId: phase.id, label: phase.label, state };
     });
 }
+// ---------------------------------------------------------------------------
+// Agent install helpers (shared with first-run; duplicated here to avoid
+// the session-key dependency in that module's public API).
+// ---------------------------------------------------------------------------
+const HUB_TO_FIRST_RUN_ID = {
+    claude: 'claude-code',
+    codex: 'codex',
+    gemini: 'gemini-cli',
+};
+function hubAgentOption(hubId) {
+    const frId = HUB_TO_FIRST_RUN_ID[hubId];
+    return frId ? types_1.FIRST_RUN_AGENT_OPTIONS.find((o) => o.id === frId) : undefined;
+}
+function hubCommandVersion(command) {
+    const executable = process.platform === 'win32' ? 'cmd.exe' : command;
+    const args = process.platform === 'win32'
+        ? ['/d', '/s', '/c', `${command} --version`]
+        : ['--version'];
+    const result = (0, child_process_1.spawnSync)(executable, args, { encoding: 'utf8', timeout: 5000 });
+    if (result.status !== 0 || result.error)
+        return null;
+    const raw = (result.stdout || result.stderr || '').trim();
+    return raw || null;
+}
+function hubRunProcess(command, args, env) {
+    return new Promise((resolve, reject) => {
+        const executable = process.platform === 'win32' && command === 'npm' ? 'npm.cmd' : command;
+        const child = (0, child_process_1.spawn)(executable, args, {
+            env: { ...process.env, ...env },
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (d) => { stdout += d.toString(); });
+        child.stderr.on('data', (d) => { stderr += d.toString(); });
+        child.on('close', (code) => {
+            if (code === 0)
+                resolve({ stdout, stderr });
+            else
+                reject(new Error(stderr || `Process exited with code ${code}`));
+        });
+        child.on('error', reject);
+    });
+}
+function hubOpenTerminal(command) {
+    if (process.platform === 'win32') {
+        (0, child_process_1.spawn)('cmd.exe', ['/c', 'start', 'cmd.exe', '/k', command], { detached: true, stdio: 'ignore' }).unref();
+        return;
+    }
+    if (process.platform === 'darwin') {
+        const script = `tell application "Terminal" to do script "${command.replace(/"/g, '\\"')}"`;
+        (0, child_process_1.spawn)('osascript', ['-e', script], { detached: true, stdio: 'ignore' }).unref();
+        return;
+    }
+    const linux = [
+        ['gnome-terminal', ['--', 'bash', '-c', `${command}; exec bash`]],
+        ['xterm', ['-e', `bash -c '${command}; exec bash'`]],
+        ['konsole', ['--noclose', '-e', 'bash', '-c', command]],
+        ['x-terminal-emulator', ['-e', `bash -c '${command}; exec bash'`]],
+    ];
+    for (const [term, args] of linux) {
+        if ((0, child_process_1.spawnSync)('which', [term], { encoding: 'utf8' }).status === 0) {
+            (0, child_process_1.spawn)(term, args, { detached: true, stdio: 'ignore' }).unref();
+            return;
+        }
+    }
+    (0, child_process_1.spawn)('bash', ['-c', command], { detached: true, stdio: 'ignore' }).unref();
+}
+function getUserHubDir() {
+    return path_1.default.join(os_1.default.homedir(), '.fraim');
+}
 function ensureDirectoryPath(projectPath) {
     const trimmed = (projectPath || '').trim();
     if (!trimmed) {
@@ -335,13 +408,76 @@ class AiHubServer {
                 return res.status(500).json({ error: error instanceof Error ? error.message : 'Could not open the folder picker.' });
             }
         });
+        this.app.post('/api/ai-hub/install-agent', async (req, res) => {
+            const { hubId } = req.body;
+            if (!hubId)
+                return res.status(400).json({ error: 'hubId is required.' });
+            const option = hubAgentOption(hubId);
+            if (!option)
+                return res.status(400).json({ error: `Unknown agent: ${hubId}` });
+            try {
+                const prefix = path_1.default.join(getUserHubDir(), 'node');
+                fs_1.default.mkdirSync(prefix, { recursive: true });
+                await hubRunProcess('npm', ['install', '-g', option.installPackage], { npm_config_prefix: prefix });
+                return res.json({
+                    ok: true,
+                    message: `${option.label} installed successfully.`,
+                    needsLogin: true,
+                    loginCommand: option.loginCommand,
+                    loginHint: `Sign in to ${option.label} to activate it. A terminal window will open — complete sign-in there, then click "Check if Ready".`,
+                });
+            }
+            catch (error) {
+                const detail = error instanceof Error ? error.message : 'Unknown error';
+                return res.status(500).json({ ok: false, error: `Failed to install ${option.label}: ${detail}` });
+            }
+        });
+        this.app.post('/api/ai-hub/trigger-agent-login', (req, res) => {
+            const { hubId } = req.body;
+            if (!hubId)
+                return res.status(400).json({ error: 'hubId is required.' });
+            const option = hubAgentOption(hubId);
+            if (!option)
+                return res.status(400).json({ error: `Unknown agent: ${hubId}` });
+            try {
+                hubOpenTerminal(option.loginCommand);
+                return res.json({
+                    ok: true,
+                    message: `A terminal window opened with the ${option.label} sign-in command. Complete sign-in there, then return here.`,
+                });
+            }
+            catch (error) {
+                const detail = error instanceof Error ? error.message : 'Unknown error';
+                return res.json({
+                    ok: false,
+                    message: `Could not open a terminal automatically: ${detail}. Run \`${option.loginCommand}\` in a terminal to sign in.`,
+                });
+            }
+        });
+        this.app.post('/api/ai-hub/check-agent', (req, res) => {
+            const { hubId } = req.body;
+            if (!hubId)
+                return res.status(400).json({ error: 'hubId is required.' });
+            const option = hubAgentOption(hubId);
+            if (!option)
+                return res.status(400).json({ error: `Unknown agent: ${hubId}` });
+            const ver = hubCommandVersion(option.launchCommand);
+            if (ver) {
+                return res.json({ ok: true, ready: true, message: `${option.label} is ready.` });
+            }
+            return res.json({
+                ok: true,
+                ready: false,
+                message: `${option.label} is not detected yet. Make sure sign-in is complete and try again.`,
+            });
+        });
         this.app.post('/api/ai-hub/runs', (req, res) => {
             try {
                 const projectPath = ensureDirectoryPath(req.body.projectPath || this.projectPath);
                 const hostId = req.body.hostId;
                 const jobId = req.body.jobId;
                 const message = (req.body.message || '').trim();
-                if (hostId !== 'codex' && hostId !== 'claude') {
+                if (hostId !== 'codex' && hostId !== 'claude' && hostId !== 'gemini') {
                     throw new Error('Choose an available employee before starting a job.');
                 }
                 if (!jobId) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fraim",
-  "version": "2.0.135",
+  "version": "2.0.136",
   "description": "FRAIM CLI - Framework for Rigor-based AI Management (alias for fraim-framework)",
   "main": "index.js",
   "bin": {

package/public/ai-hub/index.html

@@ -159,6 +159,7 @@
             <span class="employee-label">Employee:</span>
             <select id="employee-select" class="employee-select"></select>
           </div>
+          <div id="agent-install-panel"></div>
         </div>
         <div class="modal-footer">
           <span class="left">You can coach the employee with more detail after they start.</span>

package/public/ai-hub/script.js

@@ -40,7 +40,7 @@ function gatherElements() {
     'cancel1', 'next1', 'back2', 'start',
     'job-search', 'job-catalog', 'job-pick-status',
     'picked-name', 'picked-desc', 'instructions',
-    'employee-select',
+    'employee-select', 'agent-install-panel',
     // Issue #347 additions: tracker, template picker, totals.
     'tracker', 'tracker-rows', 'tracker-note',
     'template-picker-btn', 'template-popover',
@@ -891,6 +891,153 @@ function renderEmployeeSelect() {
     if (state.selectedEmployeeId === emp.id) opt.selected = true;
     els['employee-select'].appendChild(opt);
   }
+  renderAgentInstallPanel();
+}
+
+// ---------------------------------------------------------------------------
+// Agent install panel — shown in Step 2 for unavailable agents
+// ---------------------------------------------------------------------------
+
+// Per-agent install state tracked within the modal session.
+const agentInstallState = {};
+
+function renderAgentInstallPanel() {
+  const panel = els['agent-install-panel'];
+  if (!panel) return;
+  panel.innerHTML = '';
+
+  const employees = state.bootstrap?.employees || [];
+  const unavailable = employees.filter((e) => !e.available);
+  if (unavailable.length === 0) return;
+
+  const heading = document.createElement('div');
+  heading.className = 'install-panel-heading';
+  heading.textContent = 'Install missing agents';
+  panel.appendChild(heading);
+
+  for (const emp of unavailable) {
+    const row = document.createElement('div');
+    row.className = 'install-row';
+    row.id = `install-row-${emp.id}`;
+
+    const label = document.createElement('span');
+    label.className = 'install-label';
+    label.textContent = emp.label;
+    row.appendChild(label);
+
+    const status = document.createElement('span');
+    status.className = 'install-status';
+    status.id = `install-status-${emp.id}`;
+    status.textContent = agentInstallState[emp.id]?.statusText || '';
+    row.appendChild(status);
+
+    const btn = document.createElement('button');
+    btn.className = 'secondary small';
+    btn.id = `install-btn-${emp.id}`;
+    btn.dataset.hubId = emp.id;
+
+    const st = agentInstallState[emp.id] || {};
+    if (!st.phase) {
+      btn.textContent = `Install ${emp.label}`;
+      btn.addEventListener('click', () => startAgentInstall(emp.id));
+    } else if (st.phase === 'installing') {
+      btn.textContent = 'Installing…';
+      btn.disabled = true;
+    } else if (st.phase === 'needs-login') {
+      btn.textContent = 'Sign In';
+      btn.addEventListener('click', () => triggerAgentLogin(emp.id));
+    } else if (st.phase === 'login-triggered') {
+      const checkBtn = document.createElement('button');
+      checkBtn.className = 'secondary small';
+      checkBtn.textContent = 'Check if Ready';
+      checkBtn.addEventListener('click', () => checkAgentReady(emp.id));
+      row.appendChild(checkBtn);
+
+      const skipBtn = document.createElement('button');
+      skipBtn.className = 'ghost small';
+      skipBtn.textContent = 'Skip for now';
+      skipBtn.style.marginLeft = '6px';
+      skipBtn.addEventListener('click', () => {
+        delete agentInstallState[emp.id];
+        renderAgentInstallPanel();
+      });
+      row.appendChild(skipBtn);
+      panel.appendChild(row);
+      continue;
+    } else if (st.phase === 'ready') {
+      btn.textContent = '✓ Ready';
+      btn.disabled = true;
+      btn.style.color = 'var(--accent)';
+    } else if (st.phase === 'error') {
+      btn.textContent = 'Retry';
+      btn.addEventListener('click', () => startAgentInstall(emp.id));
+    }
+
+    row.appendChild(btn);
+    panel.appendChild(row);
+  }
+}
+
+function setInstallState(hubId, phase, statusText) {
+  agentInstallState[hubId] = { phase, statusText: statusText || '' };
+  renderAgentInstallPanel();
+}
+
+async function startAgentInstall(hubId) {
+  setInstallState(hubId, 'installing', 'Installing…');
+  try {
+    const result = await requestJson('/api/ai-hub/install-agent', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ hubId }),
+    });
+    if (result.ok) {
+      setInstallState(hubId, 'needs-login', result.loginHint || 'Installed. Sign in to activate.');
+    } else {
+      setInstallState(hubId, 'error', result.message || 'Install failed.');
+    }
+  } catch (err) {
+    setInstallState(hubId, 'error', err.message || 'Install failed.');
+  }
+}
+
+async function triggerAgentLogin(hubId) {
+  try {
+    const result = await requestJson('/api/ai-hub/trigger-agent-login', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ hubId }),
+    });
+    setInstallState(hubId, 'login-triggered', result.message || 'Sign-in terminal opened.');
+  } catch (err) {
+    setInstallState(hubId, 'error', err.message || 'Could not open terminal.');
+  }
+}
+
+async function checkAgentReady(hubId) {
+  try {
+    const result = await requestJson('/api/ai-hub/check-agent', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ hubId }),
+    });
+    if (result.ready) {
+      setInstallState(hubId, 'ready', `${result.message}`);
+      await refreshEmployees();
+    } else {
+      setInstallState(hubId, 'login-triggered', result.message || 'Not ready yet — complete sign-in and try again.');
+    }
+  } catch (err) {
+    setInstallState(hubId, 'error', err.message || 'Check failed.');
+  }
+}
+
+async function refreshEmployees() {
+  try {
+    const bootstrap = await requestJson(`/api/ai-hub/bootstrap?projectPath=${encodeURIComponent(state.projectPath)}`);
+    state.bootstrap = bootstrap;
+    renderEmployeeSelect();
+  } catch { /* best-effort */ }
 }
 
 // ---------------------------------------------------------------------------
@@ -937,6 +1084,7 @@ function deriveTitle(jobTitle, instructions) {
 const FRAIM_INVOCATION_SYMBOL = {
   codex: '$fraim',
   claude: '/fraim',
+  gemini: '/fraim',
 };
 
 function fraimInvocationFor(employeeId, jobId, kind) {

package/public/ai-hub/styles.css

@@ -662,6 +662,27 @@ button { font: inherit; cursor: pointer; }
 }
 .employee-select:focus { outline: none; border-color: var(--accent); }
 
+/* Agent install panel */
+#agent-install-panel { margin-top: 10px; }
+.install-panel-heading {
+  font-size: 12px;
+  font-weight: 600;
+  color: var(--muted);
+  text-transform: uppercase;
+  letter-spacing: .04em;
+  margin-bottom: 6px;
+}
+.install-row {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 6px 0;
+  font-size: 13px;
+}
+.install-label { font-weight: 500; min-width: 90px; }
+.install-status { color: var(--muted); flex: 1; font-size: 12px; }
+button.small { padding: 4px 10px; font-size: 12px; }
+
 @media (max-width: 820px) {
   /* Single-column reflow — the rigid 100vh layout doesn't make sense at
      mobile width because the rail stacks above the conversation. Let the