@pellux/goodvibes-tui 0.20.2 → 0.20.3

package/CHANGELOG.md

@@ -4,6 +4,12 @@ All notable changes to GoodVibes TUI.
 
 ---
 
+## [0.20.3] — 2026-05-13
+
+### Fixes
+- Changed `/sandbox qemu bootstrap` to run image build and guest provisioning asynchronously so the TUI can clear the prompt, render progress, and remain responsive while long QEMU setup steps run.
+- Updated generated QEMU wrappers to fail fast when the QEMU process exits before SSH is available, including a tail of the QEMU log for port conflicts and startup failures.
+
 ## [0.20.2] — 2026-05-12
 
 ### Changes

package/README.md

@@ -2,7 +2,7 @@
 
 [![CI](https://github.com/mgd34msu/goodvibes-tui/actions/workflows/ci.yml/badge.svg)](https://github.com/mgd34msu/goodvibes-tui/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Version](https://img.shields.io/badge/version-0.20.2-blue.svg)](https://github.com/mgd34msu/goodvibes-tui)
+[![Version](https://img.shields.io/badge/version-0.20.3-blue.svg)](https://github.com/mgd34msu/goodvibes-tui)
 
 A terminal-native AI coding, operations, automation, knowledge, and integration console with a typed runtime, omnichannel surfaces, structured memory/knowledge, and a raw ANSI renderer.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-tui",
-  "version": "0.20.2",
+  "version": "0.20.3",
   "description": "Terminal-native GoodVibes product for coding, operations, automation, knowledge, channels, and daemon-backed control-plane workflows.",
   "type": "module",
   "main": "src/main.ts",

package/src/input/commands/platform-sandbox-qemu.ts

@@ -1,5 +1,5 @@
 import { existsSync, readFileSync } from 'node:fs';
-import { spawnSync } from 'node:child_process';
+import { spawn } from 'node:child_process';
 import type { CommandContext } from '../command-registry.ts';
 import {
   applySandboxQemuSetupManifest,
@@ -72,7 +72,17 @@ function tailText(value: string, maxLines = 40): string {
   return lines.slice(Math.max(0, lines.length - maxLines)).join('\n');
 }
 
-function runQemuBootstrapStep(
+function appendBounded(current: string, chunk: Buffer | string, maxLength = 40_000): string {
+  const next = current + chunk.toString();
+  return next.length > maxLength ? next.slice(next.length - maxLength) : next;
+}
+
+function printProgress(ctx: CommandContext, message: string): void {
+  ctx.print(message);
+  ctx.renderRequest();
+}
+
+async function runQemuBootstrapStep(
   label: string,
   command: string,
   args: readonly string[],
@@ -82,23 +92,57 @@ function runQemuBootstrapStep(
     readonly input?: string;
     readonly timeoutMs: number;
   },
-): void {
-  const result = spawnSync(command, [...args], {
+): Promise<void> {
+  let stdout = '';
+  let stderr = '';
+  let timedOut = false;
+  const child = spawn(command, [...args], {
     cwd: options.cwd,
     env: { ...process.env, ...options.env },
-    input: options.input,
-    timeout: options.timeoutMs,
-    encoding: 'utf8',
+    stdio: ['pipe', 'pipe', 'pipe'],
     windowsHide: true,
   });
+
+  child.stdout?.on('data', (chunk) => {
+    stdout = appendBounded(stdout, chunk);
+  });
+  child.stderr?.on('data', (chunk) => {
+    stderr = appendBounded(stderr, chunk);
+  });
+
+  if (options.input !== undefined) {
+    child.stdin?.end(options.input);
+  } else {
+    child.stdin?.end();
+  }
+
+  let killTimer: NodeJS.Timeout | undefined;
+  const timeout = setTimeout(() => {
+    timedOut = true;
+    child.kill('SIGTERM');
+    killTimer = setTimeout(() => child.kill('SIGKILL'), 5_000);
+  }, options.timeoutMs);
+
+  const result = await new Promise<{ status: number | null; signal: NodeJS.Signals | null }>((resolve, reject) => {
+    child.once('error', reject);
+    child.once('close', (status, signal) => resolve({ status, signal }));
+  }).finally(() => {
+    clearTimeout(timeout);
+    if (killTimer) clearTimeout(killTimer);
+  });
+
   if (result.status === 0) return;
-  const stderr = tailText(result.stderr || '');
-  const stdout = tailText(result.stdout || '');
-  const reason = result.error instanceof Error ? result.error.message : `exit ${result.status ?? 'unknown'}`;
+  const stderrTail = tailText(stderr);
+  const stdoutTail = tailText(stdout);
+  const reason = timedOut
+    ? `timed out after ${Math.round(options.timeoutMs / 1000)}s`
+    : result.signal
+      ? `signal ${result.signal}`
+      : `exit ${result.status ?? 'unknown'}`;
   throw new Error([
     `${label} failed (${reason}).`,
-    stderr ? `stderr:\n${stderr}` : '',
-    stdout ? `stdout:\n${stdout}` : '',
+    stderrTail ? `stderr:\n${stderrTail}` : '',
+    stdoutTail ? `stdout:\n${stdoutTail}` : '',
   ].filter(Boolean).join('\n'));
 }
 
@@ -158,8 +202,8 @@ export async function handleSandboxQemuCommand(args: string[], ctx: CommandConte
         '  applied: backend=qemu, qemu binary, wrapper path, image path, launch-per-command guest settings, shared VM isolation',
       ];
       if (parsed.buildImage) {
-        ctx.print(`Building QEMU image at ${bundle.imagePath} (${parsed.sizeGb}G). This can download the Debian cloud image on first run.`);
-        runQemuBootstrapStep('QEMU image build', bundle.imageCreateScriptPath, [bundle.imagePath, `${parsed.sizeGb}G`], {
+        printProgress(ctx, `Building QEMU image at ${bundle.imagePath} (${parsed.sizeGb}G). This can download the Debian cloud image on first run.`);
+        await runQemuBootstrapStep('QEMU image build', bundle.imageCreateScriptPath, [bundle.imagePath, `${parsed.sizeGb}G`], {
           cwd: bundle.directory,
           timeoutMs: 30 * 60 * 1000,
         });
@@ -173,8 +217,8 @@ export async function handleSandboxQemuCommand(args: string[], ctx: CommandConte
           lines.push('  guest provisioning: skipped because image does not exist');
           lines.push(`  next: ${bundle.imageCreateScriptPath} ${bundle.imagePath} ${parsed.sizeGb}G`);
         } else {
-          ctx.print(`Provisioning guest runtimes through ${bundle.wrapperPath}. First boot can take several minutes.`);
-          runQemuBootstrapStep('QEMU guest runtime provisioning', bundle.wrapperPath, ['bash', '-s'], {
+          printProgress(ctx, `Provisioning guest runtimes through ${bundle.wrapperPath}. First boot can take several minutes.`);
+          await runQemuBootstrapStep('QEMU guest runtime provisioning', bundle.wrapperPath, ['bash', '-s'], {
             cwd: bundle.directory,
             env: {
               GV_SANDBOX_SYNC_WORKSPACE: '0',

package/src/runtime/sandbox-qemu-templates.ts

@@ -49,6 +49,18 @@ wait_for_ssh() {
   local start now
   start="$(date +%s)"
   while true; do
+    if [[ -n "\${GV_SANDBOX_ACTIVE_QEMU_PIDFILE:-}" && -f "\${GV_SANDBOX_ACTIVE_QEMU_PIDFILE:-}" ]]; then
+      local qemu_pid
+      qemu_pid="$(<"\${GV_SANDBOX_ACTIVE_QEMU_PIDFILE:-}")"
+      if [[ -n "$qemu_pid" ]] && ! kill -0 "$qemu_pid" 2>/dev/null; then
+        echo "QEMU process exited before SSH became available." >&2
+        if [[ -n "\${GV_SANDBOX_ACTIVE_QEMU_LOG:-}" && -f "\${GV_SANDBOX_ACTIVE_QEMU_LOG:-}" ]]; then
+          echo "QEMU log tail:" >&2
+          tail -80 "\${GV_SANDBOX_ACTIVE_QEMU_LOG:-}" >&2 || true
+        fi
+        return 1
+      fi
+    fi
     if ssh "\${ssh_opts[@]}" "$user@$host" "true" >/dev/null 2>&1; then
       return 0
     fi
@@ -85,6 +97,9 @@ start_qemu() {
   local serial_log="$logs_dir/serial-$port.log"
   local qemu_log="$logs_dir/qemu-$port.log"
   local monitor_sock="$run_dir/monitor-$port.sock"
+  GV_SANDBOX_ACTIVE_QEMU_PIDFILE="$pidfile"
+  GV_SANDBOX_ACTIVE_QEMU_LOG="$qemu_log"
+  export GV_SANDBOX_ACTIVE_QEMU_PIDFILE GV_SANDBOX_ACTIVE_QEMU_LOG
   rm -f "$monitor_sock"
   if [[ -f "$pidfile" ]]; then
     local old_pid

package/src/version.ts

@@ -6,7 +6,7 @@ import { join } from 'node:path';
 // The prebuild script updates the fallback value before compilation.
 // Uses import.meta.dir (Bun) to locate package.json relative to this file,
 // which is correct regardless of the process working directory.
-let _version = '0.20.2';
+let _version = '0.20.3';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8'));
   _version = pkg.version ?? _version;