@cnrai/pave 0.3.33 → 0.3.35

package/test/ghostty-term.test.js

@@ -0,0 +1,202 @@
+/**
+ * Tests for TERM=xterm-ghostty TUI crash fix (Issue #125).
+ *
+ * Verifies:
+ * 1. resolveTerminal() remaps xterm-ghostty to xterm-256color
+ * 2. resolveTerminal() passes known terminals through unchanged
+ * 3. resolveTerminal() falls back to xterm-256color for unknown terminals
+ * 4. resolveTerminal() leaves 'unknown' as-is (special case)
+ * 5. _internal.REMAP_TERMINALS and _internal.KNOWN_TERMINALS are exported and correct
+ * 6. Catch-block retry with xterm-256color fallback exists in source
+ *
+ * Uses checkmark/X format so run-all.js correctly counts results.
+ */
+
+let passed = 0;
+let failed = 0;
+
+function assert(cond, msg) {
+  if (cond) {
+    passed++;
+    console.log('\u2705 ' + msg);
+  } else {
+    failed++;
+    console.log('\u274c ' + msg);
+  }
+}
+
+const fs = require('fs');
+const path = require('path');
+const child_process = require('child_process');
+const os = require('os');
+
+const projDir = path.resolve(__dirname, '../../../..');
+
+// Counter for unique temp file names (avoids Date.now() collisions in parallel)
+let tmpCounter = 0;
+
+// Helper to run a script via temp file and get JSON output
+function runScript(code) {
+  tmpCounter++;
+  const tmp = path.join(os.tmpdir(), '_test_ghostty_' + Date.now() + '_' + tmpCounter + '.js');
+  try {
+    fs.writeFileSync(tmp, code, 'utf8');
+    const out = child_process.execFileSync(process.execPath, [tmp], {
+      cwd: projDir, encoding: 'utf8', timeout: 5000,
+    }).trim();
+    return JSON.parse(out);
+  } catch (e) {
+    const errMsg = (e.stderr || e.message || '').slice(0, 200);
+    // Known sandbox limitation: execFileSync not available in SpiderMonkey sandbox
+    if (errMsg.indexOf('execFileSync is not a function') !== -1) {
+      console.log('SKIP (sandbox limitation): ' + errMsg.slice(0, 120));
+      return null;
+    }
+    // Unexpected error - report as failure
+    failed++;
+    console.log('\u274c Unexpected subprocess error: ' + errMsg);
+    return null;
+  } finally {
+    try { fs.unlinkSync(tmp); } catch (e2) {}
+  }
+}
+
+// Try to load the resolveTerminal function via subprocess (avoids sandbox #shebang issue)
+const resolveResult = runScript([
+  'var tui = require(process.cwd() + "/src/packages/tui/index.js");',
+  'var r = tui.resolveTerminal;',
+  'var tests = [',
+  '  r("xterm-ghostty"),',
+  '  r("xterm-Ghostty"),',
+  '  r("xterm-256color"),',
+  '  r("linux"),',
+  '  r("screen-256color"),',
+  '  r("tmux-256color"),',
+  '  r("totally-unknown"),',
+  '  r("unknown"),',
+  '  r("xterm"),',
+  '  r("xterm-color"),',
+  '  r("rxvt-unicode-256color"),',
+  '  r("putty-256color"),',
+  '  r("kitty"),',
+  '  r("alacritty"),',
+  '  r(undefined),',
+  '  r(null),',
+  '  r("")',
+  '];',
+  'var int = tui._internal || {};',
+  'var hasRemap = typeof int.REMAP_TERMINALS === "object";',
+  'var hasKnown = Array.isArray(int.KNOWN_TERMINALS);',
+  'var remapGhostty = hasRemap ? int.REMAP_TERMINALS["xterm-ghostty"] : null;',
+  'var knownHasGhostty = hasKnown ? int.KNOWN_TERMINALS.indexOf("xterm-ghostty") !== -1 : null;',
+  'console.log(JSON.stringify({tests:tests,hasRemap:hasRemap,hasKnown:hasKnown,remapGhostty:remapGhostty,knownHasGhostty:knownHasGhostty}));',
+].join('\n'));
+
+if (resolveResult) {
+  const t = resolveResult.tests;
+
+  // ---- 1. resolveTerminal() remapping ----
+  assert(t[0].effectiveTerm === 'xterm-256color' && t[0].wasRemapped === true,
+    'resolveTerminal: xterm-ghostty -> xterm-256color (remapped)');
+  assert(t[1].effectiveTerm === 'xterm-256color' && t[1].wasRemapped === true,
+    'resolveTerminal: xterm-Ghostty -> xterm-256color (case-insensitive)');
+
+  // ---- 2. Known terminals pass through ----
+  assert(t[2].effectiveTerm === 'xterm-256color' && !t[2].wasRemapped && !t[2].wasUnknown,
+    'resolveTerminal: xterm-256color -> unchanged');
+  assert(t[3].effectiveTerm === 'linux' && !t[3].wasRemapped,
+    'resolveTerminal: linux -> unchanged');
+  assert(t[4].effectiveTerm === 'screen-256color' && !t[4].wasRemapped,
+    'resolveTerminal: screen-256color -> unchanged');
+  assert(t[5].effectiveTerm === 'tmux-256color' && !t[5].wasRemapped,
+    'resolveTerminal: tmux-256color -> unchanged');
+
+  // ---- 3. Unknown terminals -> xterm-256color ----
+  assert(t[6].effectiveTerm === 'xterm-256color' && t[6].wasUnknown === true,
+    'resolveTerminal: totally-unknown -> xterm-256color (unknown fallback)');
+
+  // ---- 4. 'unknown' is special - left as-is ----
+  assert(t[7].effectiveTerm === 'unknown' && !t[7].wasUnknown,
+    'resolveTerminal: unknown -> unchanged (special case)');
+
+  // ---- 5. More known terminals ----
+  assert(t[8].effectiveTerm === 'xterm' && !t[8].wasRemapped,
+    'resolveTerminal: xterm -> unchanged');
+  assert(t[9].effectiveTerm === 'xterm-color' && !t[9].wasRemapped,
+    'resolveTerminal: xterm-color -> unchanged');
+  assert(t[10].effectiveTerm === 'rxvt-unicode-256color' && !t[10].wasRemapped,
+    'resolveTerminal: rxvt-unicode-256color -> unchanged');
+  assert(t[11].effectiveTerm === 'putty-256color' && !t[11].wasRemapped,
+    'resolveTerminal: putty-256color -> unchanged');
+
+  // ---- 6. Other unknown terminals ----
+  assert(t[12].effectiveTerm === 'xterm-256color' && t[12].wasUnknown === true,
+    'resolveTerminal: kitty -> xterm-256color (unknown fallback)');
+  assert(t[13].effectiveTerm === 'xterm-256color' && t[13].wasUnknown === true,
+    'resolveTerminal: alacritty -> xterm-256color (unknown fallback)');
+
+  // ---- 7. Non-string input guard ----
+  assert(t[14].effectiveTerm === 'unknown' && !t[14].wasRemapped && !t[14].wasUnknown,
+    'resolveTerminal: undefined -> unknown (guard)');
+  assert(t[15].effectiveTerm === 'unknown' && !t[15].wasRemapped && !t[15].wasUnknown,
+    'resolveTerminal: null -> unknown (guard)');
+  assert(t[16].effectiveTerm === 'xterm-256color' && t[16].wasUnknown === true,
+    'resolveTerminal: empty string -> xterm-256color (unknown fallback)');
+
+  // ---- 8. Exported constants ----
+  assert(resolveResult.hasRemap === true,
+    'export: _internal.REMAP_TERMINALS is exported');
+  assert(resolveResult.hasKnown === true,
+    'export: _internal.KNOWN_TERMINALS is exported');
+  assert(resolveResult.remapGhostty === 'xterm-256color',
+    'export: _internal.REMAP_TERMINALS["xterm-ghostty"] = xterm-256color');
+  assert(resolveResult.knownHasGhostty === false,
+    'export: xterm-ghostty NOT in _internal.KNOWN_TERMINALS');
+} else {
+  console.log('SKIP: resolveTerminal subprocess not available - running source checks only');
+}
+
+// ---- 9. Source-level structural checks (minimal, verifying key patterns) ----
+// resolveTerminal was extracted from index.js into lib/terminal-utils.js
+const tuiSrc = fs.readFileSync(path.resolve(__dirname, '../../tui/index.js'), 'utf8');
+const termUtilsSrc = fs.readFileSync(path.resolve(__dirname, '../../tui/lib/terminal-utils.js'), 'utf8');
+
+// Verify resolveTerminal function is defined in terminal-utils.js
+assert(/function resolveTerminal/.test(termUtilsSrc),
+  'source: resolveTerminal function defined');
+// Verify resolveTerminal is re-exported from index.js
+assert(/module\.exports[\s\S]*resolveTerminal/.test(tuiSrc),
+  'source: resolveTerminal is exported');
+assert(/_internal:\s*\{[\s\S]*KNOWN_TERMINALS[\s\S]*REMAP_TERMINALS/.test(tuiSrc) ||
+       /_internal:\s*\{[\s\S]*REMAP_TERMINALS[\s\S]*KNOWN_TERMINALS/.test(tuiSrc),
+'source: KNOWN_TERMINALS and REMAP_TERMINALS under _internal namespace');
+
+// Verify catch block retries with xterm-256color fallback
+assert(/catch\s*\(err\)[\s\S]*?effectiveTerm\s*!==\s*'xterm-256color'/.test(tuiSrc),
+  'source: catch block checks effectiveTerm !== xterm-256color');
+assert(/catch\s*\(err\)[\s\S]*?blessed\.screen\(/.test(tuiSrc),
+  'source: catch block retries blessed.screen()');
+
+// Verify error output helper exists (reduces duplication)
+assert(/function printTerminalInitFailure/.test(tuiSrc),
+  'source: printTerminalInitFailure helper extracted');
+
+// Verify non-string guard in resolveTerminal (now in terminal-utils.js)
+assert(/term\s*==\s*null/.test(termUtilsSrc) || /String\(term\)/.test(termUtilsSrc),
+  'source: resolveTerminal guards against non-string input');
+
+// Verify effectiveTerm is normalized to lowercase for terminfo compatibility (now in terminal-utils.js)
+assert(/effectiveTerm\s*=\s*effectiveTerm\.toLowerCase\(\)/.test(termUtilsSrc),
+  'source: effectiveTerm normalized to lowercase');
+
+// Verify error helper handles non-Error objects
+assert(/String\(error\)/.test(tuiSrc),
+  'source: printTerminalInitFailure handles non-Error objects');
+
+// Verify error messages show both original and effective TERM
+assert(/Original TERM/.test(tuiSrc) && /Effective TERM/.test(tuiSrc),
+  'source: error messages show both Original and Effective TERM');
+
+console.log('');
+console.log(passed + ' passed, ' + failed + ' failed');
+if (failed > 0) throw new Error(failed + ' test(s) failed');