@lardexx/arenacode 2.8.0 → 2.10.0

package/src/local.js

@@ -48,22 +48,110 @@ function relativize(root, abs) {
 // Local terminal (local-exec)
 // --------------------------------------------------------------------------- //
 
-function shellCommand(shell, command) {
-  if (process.platform === 'win32') {
-    switch (shell) {
+// Every shell the client can drive. The bridge may ask for one by name (`shell` in the
+// local-exec request), the user can pin one (`arenacode config set shell zsh`, `/shell`),
+// and otherwise the client takes the user's login shell, like a terminal would.
+const UNIX_SHELLS = {
+  sh: '/bin/sh',
+  bash: '/bin/bash',
+  zsh: '/bin/zsh',
+  fish: '/usr/bin/fish',
+  dash: '/bin/dash',
+  ksh: '/bin/ksh',
+};
+
+const WINDOWS_SHELLS = ['powershell', 'pwsh', 'cmd', 'wsl', 'bash'];
+
+function shellExists(file) {
+  try {
+    fs.accessSync(file, fs.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** sh/bash/zsh/dash/ksh: -l login, -c command. fish spells the same as -l -c. */
+function unixShell(name) {
+  const wanted = String(name || '').toLowerCase().replace(/\.exe$/, '');
+  const alias = { 'git-bash': 'bash', gitbash: 'bash' }[wanted] || wanted;
+  let file = UNIX_SHELLS[alias];
+  if (!file && (alias === 'sh' || alias.startsWith('/'))) file = alias === 'sh' ? '/bin/sh' : alias;
+  if (!file) file = whichPath(alias);
+  if (!file) file = UNIX_SHELLS[alias] || null;
+  if (!file) return null;
+  const base = path.basename(file);
+  const args = base === 'fish' ? ['-l', '-c', null] : ['-lc', null];
+  return { file, args };
+}
+
+function whichPath(name) {
+  for (const dir of ['/bin', '/usr/bin', '/usr/local/bin', '/opt/homebrew/bin']) {
+    const file = path.join(dir, name);
+    if (shellExists(file)) return file;
+  }
+  return null;
+}
+
+/** The shell to use when nobody asked for a specific one. */
+function detectShell(platform = process.platform) {
+  if (platform === 'win32') {
+    if (shellExists('pwsh.exe') || whichPath('pwsh')) return 'pwsh';
+    return 'powershell';
+  }
+  const login = path.basename(process.env.SHELL || '');
+  if (login && (UNIX_SHELLS[login] || whichPath(login))) return login;
+  return 'sh';
+}
+
+/** What the client can offer on this machine — for `sysinfo`, `/shell` and the help. */
+function availableShells(platform = process.platform) {
+  if (platform === 'win32') {
+    return WINDOWS_SHELLS.filter((name) => name === 'powershell' || name === 'cmd' || Boolean(whichPath(name)));
+  }
+  const found = Object.keys(UNIX_SHELLS).filter((name) => shellExists(UNIX_SHELLS[name]) || Boolean(whichPath(name)));
+  return found.length ? found : ['sh'];
+}
+
+/**
+ * Command template for one shell. `command` is passed as its own argv entry, never
+ * through a second round of quoting, so quotes and `$` survive.
+ */
+function shellCommand(shell, command, platform = process.platform) {
+  const name = String(shell || detectShell(platform)).toLowerCase().replace(/\.exe$/, '');
+  if (platform === 'win32') {
+    switch (name) {
       case 'cmd':
         return { file: 'cmd.exe', args: ['/d', '/s', '/c', command] };
       case 'wsl':
         return { file: 'wsl.exe', args: ['sh', '-lc', command] };
+      case 'bash': {
+        // Git Bash when it is installed, otherwise the WSL bash
+        const gitBash = [
+          'C:\\Program Files\\Git\\bin\\bash.exe',
+          'C:\\Program Files (x86)\\Git\\bin\\bash.exe',
+        ].find((file) => {
+          try {
+            return fs.existsSync(file);
+          } catch {
+            return false;
+          }
+        });
+        return gitBash
+          ? { file: gitBash, args: ['-lc', command] }
+          : { file: 'wsl.exe', args: ['bash', '-lc', command] };
+      }
+      case 'pwsh':
+        return { file: 'pwsh.exe', args: ['-NoProfile', '-NonInteractive', '-Command', command] };
       case 'powershell':
+      case 'ps':
       default:
-        return {
-          file: shell === 'pwsh' ? 'pwsh.exe' : 'powershell.exe',
-          args: ['-NoProfile', '-NonInteractive', '-Command', command],
-        };
+        return { file: 'powershell.exe', args: ['-NoProfile', '-NonInteractive', '-Command', command] };
     }
   }
-  return { file: '/bin/sh', args: ['-lc', command] };
+  const template = unixShell(name) || unixShell('sh');
+  const args = template.args.map((arg) => (arg === null ? command : arg));
+  return { file: template.file, args };
 }
 
 /** Runs a command and collects stdout+stderr and the exit code. */
@@ -96,9 +184,12 @@ async function handleLocalExec(bridge, taskId, request, opts) {
   const { rid, command, cwd: reqCwd, shell, admin, sandbox_reason: sandboxReason } = request;
   const lang = opts.lang;
   const dir = reqCwd ? resolveInRoot(opts.folder, reqCwd) : opts.folder;
+  // the bridge names the shell it wrote the command for; otherwise the user's choice
+  // from `arenacode config set shell …` / `/shell`, otherwise the login shell
+  const chosenShell = shell || opts.shell || detectShell();
 
   write('');
-  write(`  ${c.bold(c.yellow('⌘ terminal'))} ${c.dim('·')} ${c.cyan(shell || 'shell')} ${c.dim('·')} ${c.gray(dir)}`);
+  write(`  ${c.bold(c.yellow('⌘ terminal'))} ${c.dim('·')} ${c.cyan(chosenShell)} ${c.dim('·')} ${c.gray(dir)}`);
   write(indentLines(command, '    '));
   if (admin) write(`  ${c.yellow('!')} ${t(lang, 'Richiede i permessi di amministratore: qui il comando gira senza UAC.', 'Needs administrator rights: here it runs without UAC.', 'Necesita permisos de administrador: aquí se ejecuta sin UAC.')}`);
   if (sandboxReason) write(`  ${c.yellow('!')} ${t(lang, 'L’agente chiede di installare sul PC', 'The agent asks to install on the PC', 'El agente pide instalar en el PC')}: ${c.gray(sandboxReason)}`);
@@ -125,7 +216,7 @@ async function handleLocalExec(bridge, taskId, request, opts) {
     return true;
   }
 
-  const { output, code } = await runShell(command, { cwd: dir, shell });
+  const { output, code } = await runShell(command, { cwd: dir, shell: chosenShell });
   await bridge.localResult(taskId, { rid, output, code });
   write(`  ${code === 0 ? c.green('✓') : c.red('✗')} ${c.gray(`exit ${code}`)}`);
   return true;
@@ -495,7 +586,8 @@ async function handleLocalUi(bridge, taskId, request, opts) {
       cpus: os.cpus().length,
       memory_mb: Math.round(os.totalmem() / 1048576),
       node: process.version,
-      shell: require('./meta').which('pwsh') ? 'pwsh' : process.platform === 'win32' ? 'powershell' : 'sh',
+      shell: detectShell(),
+      shells: availableShells(),
     };
     await bridge.localResult(taskId, { rid, output: JSON.stringify(info), code: 0 });
     write(`  ${c.green('✓')} ${c.gray('sysinfo')}`);
@@ -683,6 +775,9 @@ async function handleLocalFile(bridge, taskId, request, opts) {
 
 module.exports = {
   runUiAction,
+  shellCommand,
+  detectShell,
+  availableShells,
   REFUSED,
   resolveInRoot,
   runShell,

package/src/tui/app.js

@@ -14,7 +14,7 @@ const { getTheme, themeNames } = require('./theme');
 
 const { Bridge } = require('../bridge');
 const { buildMeta, readProjectContext } = require('../meta');
-const { runShell, runFsOp, resolveInRoot } = require('../local');
+const { runShell, runFsOp, resolveInRoot, detectShell, availableShells, shellCommand } = require('../local');
 const { readConfig, patchConfig, deviceId, resolveUrl, resolveKey, openFolder, VERSION } = require('../config');
 
 const { MODE_LINES, modeLabel, nextMode, normaliseMode } = require('../modes');
@@ -49,6 +49,7 @@ class App {
     this.autoApprove = Boolean(opts.yes);
     this.confirmWrites = Boolean(opts.confirmWrites);
     this.approval = normaliseApproval(opts.approval);
+    this.shell = String(opts.shell || cfg.shell || '').trim() || detectShell();
 
     this.state = {
       mode: normaliseMode(opts.mode || cfg.mode || 'agent'),
@@ -493,6 +494,7 @@ class App {
       { slash: '/ask', title: 'Ask and Proceed: ask before commands, files and plans', hint: '', group: 'Session', run: () => this.setApproval('ask') },
       { slash: '/proceed', title: 'Proceed: approve the plan and run everything without asking', hint: '', group: 'Session', run: () => this.setApproval('proceed') },
       { slash: '/theme', title: 'Cycle the colour theme', hint: 'ctrl+x t', group: 'Session', run: by('Theme') },
+      { slash: '/shell', title: 'Show or change the shell commands run in', hint: '', group: 'Session', run: () => this.pickShell() },
       { slash: '/status', title: 'Ping the bridge', hint: '', group: 'Session', run: by('Bridge status') },
       { slash: '/help', title: 'Every keybinding', hint: 'f1', group: 'Session', run: () => this.openHelp() },
       { slash: '/quit', title: 'Leave arenacode', hint: 'ctrl+x q', group: 'Session', run: () => this.quit() },
@@ -538,6 +540,42 @@ class App {
     this.toast(`approval: ${next === 'proceed' ? 'Proceed' : 'Ask and Proceed'}`, next === 'proceed' ? 'warn' : 'ok');
   }
 
+  /** `/shell` (and the double-click on a card's shell line): pick from the shells here. */
+  async pickShell(name = '') {
+    const shells = availableShells();
+    const wanted = String(name || '').trim().toLowerCase();
+    if (wanted) {
+      if (!shells.includes(wanted)) {
+        this.toast(`shell: ${wanted} not found (${shells.join(', ')})`, 'warn');
+        return;
+      }
+      this.setShell(wanted);
+      return;
+    }
+    // a free-text prompt instead of a dialog: esc keeps the current shell
+    this.toast(`shell: ${this.shell} (${shells.join(', ')})`);
+    const current = shellCommand(this.shell).file;
+    const answer = String(await this.prompt(`shell [${current}]`)).trim().toLowerCase();
+    if (!answer) return;
+    if (!shells.includes(answer)) {
+      this.toast(`shell: ${answer} not found (${shells.join(', ')})`, 'warn');
+      return;
+    }
+    this.setShell(answer);
+  }
+
+  setShell(name) {
+    this.shell = name;
+    try {
+      patchConfig({ shell: name });
+    } catch {
+      /* a read-only HOME keeps the choice in memory only */
+    }
+    const { file } = shellCommand(name);
+    this.push({ kind: 'system', text: `shell: ${name} · ${file}` });
+    this.toast(`shell: ${name}`, 'ok');
+  }
+
   onOverlayKey(key) {
     const ov = this.state.overlay;
     if (key.name === 'escape') {
@@ -672,7 +710,7 @@ class App {
       const cmd = text.slice(1).trim();
       this.push({ kind: 'user', text: cmd, shell: true });
       const item = this.push({ kind: 'tool', icon: 'terminal', label: cmd, state: 'running', detail: '' });
-      const { output, code } = await runShell(cmd, { cwd: this.folder, shell: undefined, quiet: true });
+      const { output, code } = await runShell(cmd, { cwd: this.folder, shell: this.shell, quiet: true });
       item.state = code === 0 ? 'done' : 'failed';
       item.detail = output.trim();
       item.secs = undefined;