@openagents-org/agent-launcher 0.1.16 → 0.2.1

package/src/tui.js

@@ -37,18 +37,24 @@ const COLORS = {
 };
 
 const STATE_DISPLAY = {
-  online:        { sym: '\u25CF', color: COLORS.stateRunning },
-  running:       { sym: '\u25CF', color: COLORS.stateRunning },
-  starting:      { sym: '\u25D0', color: COLORS.stateStarting },
-  reconnecting:  { sym: '\u25D0', color: COLORS.stateStarting },
-  stopped:       { sym: '\u25CB', color: COLORS.stateStopped },
-  'not configured': { sym: '\u25CB', color: COLORS.stateStopped },
-  error:         { sym: '\u2717', color: COLORS.stateError },
+  online:        { sym: '\u25CF', color: COLORS.stateRunning, label: 'connected' },
+  running:       { sym: '\u25CF', color: COLORS.stateRunning, label: 'connected' },
+  idle:          { sym: '\u25CB', color: COLORS.stateStarting, label: 'ready' },
+  starting:      { sym: '\u25D0', color: COLORS.stateStarting, label: 'starting' },
+  reconnecting:  { sym: '\u25D0', color: COLORS.stateStarting, label: 'reconnecting' },
+  stopped:       { sym: '\u25CB', color: COLORS.stateStopped, label: 'stopped' },
+  'not configured': { sym: '\u25CB', color: COLORS.stateStopped, label: 'not configured' },
+  error:         { sym: '\u2717', color: COLORS.stateError, label: 'error' },
 };
 
-function stateMarkup(state) {
-  const d = STATE_DISPLAY[state] || { sym: '?', color: 'white' };
-  return `{${d.color}-fg}${d.sym} ${state}{/${d.color}-fg}`;
+function stateMarkup(state, hasWorkspace) {
+  const d = STATE_DISPLAY[state] || { sym: '?', color: 'white', label: state };
+  let label = d.label;
+  // For running/connected agents, clarify workspace status
+  if ((state === 'running' || state === 'online') && !hasWorkspace) {
+    label = 'running';
+  }
+  return `{${d.color}-fg}${d.sym} ${label}{/${d.color}-fg}`;
 }
 
 // ── Data helpers ────────────────────────────────────────────────────────────
@@ -79,6 +85,39 @@ function loadAgentRows(connector) {
         workspace = agent.network;
       }
     }
+    // Check if agent type needs configuration (API key etc.)
+    let notReadyMsg = '';
+    try {
+      const agentType = agent.type || 'openclaw';
+      const entry = connector.registry.getEntry(agentType);
+      if (entry && entry.check_ready) {
+        const cr = entry.check_ready;
+        let isReady = false;
+        // Check saved env
+        if (cr.saved_env_key) {
+          const saved = connector.env.load(agentType);
+          if (saved[cr.saved_env_key]) isReady = true;
+        }
+        // Check process env vars
+        if (!isReady && cr.env_vars) {
+          for (const v of cr.env_vars) {
+            if (process.env[v]) { isReady = true; break; }
+          }
+        }
+        // Check creds file (for claude)
+        if (!isReady && cr.creds_file) {
+          const credsPath = cr.creds_file.replace('~', process.env.HOME || process.env.USERPROFILE || '');
+          try {
+            if (fs.existsSync(credsPath)) {
+              const creds = JSON.parse(fs.readFileSync(credsPath, 'utf-8'));
+              if (cr.creds_key && creds[cr.creds_key]) isReady = true;
+            }
+          } catch {}
+        }
+        if (!isReady) notReadyMsg = cr.not_ready_message || 'Not configured';
+      }
+    } catch {}
+
     return {
       name: agent.name,
       type: agent.type || 'openclaw',
@@ -87,6 +126,7 @@ function loadAgentRows(connector) {
       path: agent.path || '',
       network: agent.network || '',
       lastError: info.last_error || '',
+      notReadyMsg,
       configured: true,
     };
   });
@@ -299,10 +339,11 @@ function createTUI() {
       agentList.setItems(['  {gray-fg}No agents configured. Press {bold}i{/bold} to install, {bold}n{/bold} to create.{/gray-fg}']);
     } else {
       const items = agentRows.map(r => {
-        const state = stateMarkup(r.state);
+        const state = stateMarkup(r.state, !!r.workspace);
         const ws = r.workspace || '{gray-fg}-{/gray-fg}';
         const pathInfo = r.path ? `{gray-fg} ${r.path}{/gray-fg}` : '';
-        return `  ${r.name.padEnd(22)} ${r.type.padEnd(14)} ${state.padEnd(30)} ${ws}${pathInfo}`;
+        const warning = r.notReadyMsg ? ` {yellow-fg}⚠ ${r.notReadyMsg}{/yellow-fg}` : '';
+        return `  ${r.name.padEnd(22)} ${r.type.padEnd(14)} ${state.padEnd(30)} ${ws}${pathInfo}${warning}`;
       });
       agentList.setItems(items);
     }
@@ -322,7 +363,20 @@ function createTUI() {
     const dot = pid ? `{green-fg}\u25CF{/green-fg}` : `{gray-fg}\u25CB{/gray-fg}`;
     const state = pid ? 'Daemon running' : 'Daemon idle';
     const count = agentRows.length;
-    header.setContent(`  ${dot} ${state}  {gray-fg}|{/gray-fg}  ${count} agent${count !== 1 ? 's' : ''} configured`);
+
+    // Show installed runtimes
+    let installed = [];
+    try {
+      const catalog = loadCatalog(connector);
+      installed = catalog.filter(e => e.installed).map(e => e.name);
+    } catch {}
+    const installedStr = installed.length
+      ? `  {gray-fg}|{/gray-fg}  {green-fg}${installed.join(', ')}{/green-fg} installed`
+      : '';
+
+    header.setContent(
+      `  ${dot} ${state}  {gray-fg}|{/gray-fg}  ${count} agent${count !== 1 ? 's' : ''} configured${installedStr}`
+    );
   }
 
   // Update footer when selection changes
@@ -536,6 +590,8 @@ function createTUI() {
     }).then(() => {
       installLog.log('');
       installLog.log(`{green-fg}\u2713 ${entry.name} installed successfully!{/green-fg}`);
+      installLog.log('');
+      installLog.log(`{cyan-fg}Press c to create a ${entry.name} agent, or Esc to go back.{/cyan-fg}`);
       logPanel.setLabel(` {bold}{green-fg}Install Complete{/green-fg}{/bold} `);
       log(`{green-fg}\u2713{/green-fg} ${entry.name} installed`);
       const idx = catalog.findIndex(c => c.name === entry.name);
@@ -544,6 +600,36 @@ function createTUI() {
       onDone();
       list.focus();
       screen.render();
+
+      // Listen for 'c' to create agent from just-installed type
+      const onCreateKey = (ch) => {
+        if (ch === 'c') {
+          screen.unkey(['c', 'escape'], onCreateKey);
+          // Go back to main and start agent creation flow
+          list.emit('keypress', null, { name: 'escape' });
+          setTimeout(() => {
+            showStartAgentScreen(entry.name, (result) => {
+              try {
+                connector.addAgent({ name: result.name, type: result.type, path: result.path });
+                log(`{green-fg}\u2713{/green-fg} Created agent {cyan-fg}${result.name}{/cyan-fg} (${result.type})`);
+                const pid = connector.getDaemonPid();
+                if (!pid) {
+                  connector.startDaemon();
+                  log('{green-fg}\u2713{/green-fg} Daemon starting...');
+                } else {
+                  signalDaemonReload();
+                }
+              } catch (e) {
+                log(`{red-fg}\u2717{/red-fg} ${e.message}`);
+              }
+              setTimeout(refreshAgentTable, 3000);
+            });
+          }, 200);
+        } else {
+          screen.unkey(['c', 'escape'], onCreateKey);
+        }
+      };
+      screen.key(['c', 'escape'], onCreateKey);
     }).catch((e) => {
       installLog.log('');
       installLog.log(`{red-fg}\u2717 Failed: ${e.message}{/red-fg}`);
@@ -646,6 +732,7 @@ function createTUI() {
     const pathInput = blessed.textbox({
       parent: dialog, top: 6, left: 2, width: 50, height: 3,
       border: { type: 'line' }, inputOnFocus: true,
+      value: defaultPath,
       style: { fg: 'white', bg: COLORS.surface, focus: { border: { fg: COLORS.accent } }, border: { fg: 'grey' } },
     });
 
@@ -661,6 +748,18 @@ function createTUI() {
     nameInput.focus();
     screen.render();
 
+    // Override _listener on textboxes to intercept Tab before it's inserted
+    const origNameListener = nameInput._listener.bind(nameInput);
+    nameInput._listener = function(ch, key) {
+      if (key.name === 'tab') { nameInput._done(null, nameInput.value); pathInput.focus(); return; }
+      return origNameListener(ch, key);
+    };
+    const origPathListener = pathInput._listener.bind(pathInput);
+    pathInput._listener = function(ch, key) {
+      if (key.name === 'tab') { pathInput._done(null, pathInput.value); nameInput.focus(); return; }
+      return origPathListener(ch, key);
+    };
+
     const close = () => {
       screen.remove(dialog);
       dialog.destroy();
@@ -762,7 +861,7 @@ function createTUI() {
       parent: box, bottom: 0, left: 0, width: '100%', height: 1,
       tags: true,
       style: { bg: COLORS.footerBg, fg: COLORS.footerFg },
-      content: ' {cyan-fg}Enter{/cyan-fg} Next field  {cyan-fg}Ctrl+S{/cyan-fg} Save  {cyan-fg}Ctrl+T{/cyan-fg} Test  {cyan-fg}Esc{/cyan-fg} Back',
+      content: ' {cyan-fg}Tab{/cyan-fg} Next  {cyan-fg}Ctrl+U{/cyan-fg} Clear  {cyan-fg}Ctrl+S{/cyan-fg} Save  {cyan-fg}Ctrl+T{/cyan-fg} Test  {cyan-fg}Esc{/cyan-fg} Back',
     });
 
     screen.append(box);
@@ -780,6 +879,35 @@ function createTUI() {
       });
     }
 
+    // Override _listener on textboxes to intercept Tab and Escape
+    for (let i = 0; i < inputs.length; i++) {
+      const orig = inputs[i]._listener.bind(inputs[i]);
+      const idx = i;
+      inputs[i]._listener = function(ch, key) {
+        if (key.name === 'tab' && inputs.length > 1) {
+          inputs[idx]._done(null, inputs[idx].value);
+          inputs[(idx + 1) % inputs.length].focus();
+          return;
+        }
+        if (key.name === 'escape') {
+          inputs[idx]._done(null, inputs[idx].value);
+          closeConfig();
+          return;
+        }
+        // Ctrl+U to clear field
+        if (key.ctrl && key.name === 'u') {
+          inputs[idx].value = '';
+          inputs[idx].setValue('');
+          screen.render();
+          return;
+        }
+        // Ctrl+S to save, Ctrl+T to test
+        if (key.ctrl && key.name === 's') { inputs[idx]._done(null, inputs[idx].value); doSave(); return; }
+        if (key.ctrl && key.name === 't') { inputs[idx]._done(null, inputs[idx].value); doTest(); return; }
+        return orig(ch, key);
+      };
+    }
+
     function gatherEnv() {
       const env = {};
       for (const input of inputs) {
@@ -1128,15 +1256,17 @@ function createTUI() {
       opened = true;
     } catch {}
 
-    // Show URL in a dialog
+    // Show URL in a dialog — full width, auto-height for long URLs
+    const innerW = screen.width - 4;
+    const urlLines = Math.ceil(url.length / innerW);
     const dialog = blessed.box({
-      top: 'center', left: 'center',
-      width: 70, height: 7,
+      top: 'center', left: 0,
+      width: '100%', height: 4 + urlLines + 2,
       border: { type: 'line' },
       tags: true,
       label: ' {bold}Workspace URL{/bold} ',
       style: { border: { fg: COLORS.accent }, bg: COLORS.surface },
-      content: `\n  ${url}\n\n  {gray-fg}${opened ? 'Opened in browser.' : 'Copy the URL above.'} Press Esc to close.{/gray-fg}`,
+      content: `\n {bold}${url}{/bold}\n\n {gray-fg}${opened ? 'Opened in browser.' : 'Copy the URL above.'} Press Esc to close.{/gray-fg}`,
     });
 
     screen.append(dialog);
@@ -1333,6 +1463,21 @@ function createTUI() {
   agentList.focus();
   refreshAgentTable();
   log('Welcome to {bold}OpenAgents{/bold}. Press {cyan-fg}i{/cyan-fg} to install agents, {cyan-fg}n{/cyan-fg} to create one.');
+
+  // Show installed runtimes that don't have any agent instances yet
+  try {
+    const catalog = loadCatalog(connector);
+    const installed = catalog.filter(e => e.installed).map(e => e.name);
+    const configuredTypes = new Set(agentRows.map(r => r.type));
+    const unused = installed.filter(t => !configuredTypes.has(t));
+    if (unused.length > 0) {
+      log(`{green-fg}\u2713{/green-fg} Installed: {bold}${unused.join(', ')}{/bold} — press {cyan-fg}n{/cyan-fg} to create an agent`);
+    }
+    if (installed.length === 0) {
+      log('{yellow-fg}!{/yellow-fg} No agent runtimes installed. Press {cyan-fg}i{/cyan-fg} to install one.');
+    }
+  } catch {}
+
   setInterval(refreshAgentTable, 5000);
   screen.render();
 }