terminfo.dev 1.4.0 → 1.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "terminfo.dev",
-  "version": "1.4.0",
+  "version": "1.6.0",
   "description": "Test your terminal's feature support and contribute to terminfo.dev",
   "keywords": [
     "ansi",

package/src/detect.ts

@@ -52,15 +52,19 @@ export function detectTerminal(): TerminalInfo {
   let name = "unknown"
   let version = ""
 
-  // Check specific env vars first
-  for (const { env, name: n } of ENV_DETECTORS) {
-    if (process.env[env]) {
-      name = n
-      break
+  // On macOS, __CFBundleIdentifier is the most reliable — set by the actual running app
+  const bundleId = process.env.__CFBundleIdentifier
+  if (bundleId && os === "macos") {
+    for (const [termName, bid] of Object.entries(BUNDLE_IDS)) {
+      if (bundleId === bid) { name = termName; break }
+    }
+    // If bundle ID didn't match known terminals, use it as-is
+    if (name === "unknown" && bundleId) {
+      name = bundleId.split(".").pop() ?? bundleId
     }
   }
 
-  // Check $TERM_PROGRAM
+  // Check $TERM_PROGRAM (more reliable than env var detectors for cross-app scenarios)
   if (name === "unknown") {
     const termProgram = process.env.TERM_PROGRAM
     if (termProgram) {
@@ -69,6 +73,16 @@ export function detectTerminal(): TerminalInfo {
     }
   }
 
+  // Check specific env vars (may be inherited from parent, so lower priority)
+  if (name === "unknown") {
+    for (const { env, name: n } of ENV_DETECTORS) {
+      if (process.env[env]) {
+        name = n
+        break
+      }
+    }
+  }
+
   // Check $TERMINAL_EMULATOR (Linux)
   if (name === "unknown") {
     const termEmu = process.env.TERMINAL_EMULATOR

package/src/index.ts

@@ -18,7 +18,7 @@ import { dirname, join } from "node:path"
 import { fileURLToPath } from "node:url"
 import { detectTerminal } from "./detect.ts"
 import { ALL_PROBES } from "./probes/index.ts"
-import { withRawMode } from "./tty.ts"
+import { withRawMode, drainStdin } from "./tty.ts"
 import { submitResults } from "./submit.ts"
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
@@ -76,21 +76,11 @@ async function runProbes(): Promise<ProbeResults> {
         notes[probe.id] = `error: ${err instanceof Error ? err.message : String(err)}`
       }
     }
+    // Drain all pending responses before exiting alt screen (still in raw mode)
+    await drainStdin(500)
     process.stdout.write("\x1b[?1049l")
   })
 
-  // Drain any late-arriving escape sequence responses before output
-  await new Promise<void>((resolve) => {
-    process.stdin.resume()
-    const timer = setTimeout(() => {
-      process.stdin.pause()
-      process.stdin.removeAllListeners("readable")
-      resolve()
-    }, 100)
-    process.stdin.on("readable", () => { while (process.stdin.read() !== null) {} })
-    timer.unref()
-  })
-
   return { terminal, results, notes, responses, passed, total: ALL_PROBES.length }
 }
 
@@ -183,21 +173,45 @@ program
 program
   .command("submit")
   .description("Run all probes and submit results to terminfo.dev via GitHub issue")
-  .action(async () => {
+  .option("--terminal-name <name>", "Override detected terminal name")
+  .option("--terminal-version <version>", "Override detected terminal version")
+  .action(async (opts) => {
+    // Confirm details BEFORE probes (stdin is still clean)
+    const terminal = detectTerminal()
+    const name = opts.terminalName ?? terminal.name
+    const version = opts.terminalVersion ?? terminal.version
+
+    printHeader(terminal)
+    console.log(``)
+    console.log(`  Will submit results for \x1b[1m${name}${version ? ` ${version}` : ""}\x1b[0m on ${terminal.os}`)
+    if (!version) {
+      console.log(`  \x1b[33m⚠ No version detected. Use --terminal-version to specify.\x1b[0m`)
+    }
+
+    const { createInterface } = await import("node:readline")
+    const rl = createInterface({ input: process.stdin, output: process.stdout })
+    const proceed = await new Promise<string>((resolve) => {
+      rl.question(`\n  Press Enter to run probes and submit (or Ctrl+C to cancel) `, (answer) => {
+        rl.close()
+        resolve(answer)
+      })
+    })
+
+    // Now run probes (stdin goes to raw mode, no conflict)
     const data = await runProbes()
     printResults(data)
 
     console.log(`\nSubmitting results to terminfo.dev...`)
     const url = await submitResults({
-      terminal: data.terminal.name,
-      terminalVersion: data.terminal.version,
+      terminal: name,
+      terminalVersion: version,
       os: data.terminal.os,
       osVersion: data.terminal.osVersion,
       results: data.results,
       notes: data.notes,
       responses: data.responses,
       generated: new Date().toISOString(),
-      cliVersion: "1.3.0",
+      cliVersion: "1.6.0",
       probeCount: ALL_PROBES.length,
     })
     if (url) {

package/src/submit.ts

@@ -6,7 +6,6 @@ import { writeFileSync, unlinkSync } from "node:fs"
 import { tmpdir } from "node:os"
 import { join } from "node:path"
 import { execFileSync } from "node:child_process"
-import { createInterface } from "node:readline"
 
 const REPO = "beorn/terminfo.dev"
 
@@ -23,65 +22,28 @@ interface SubmitData {
   probeCount?: number
 }
 
-/** Drain any leftover bytes from stdin (e.g., late-arriving escape sequence responses) */
-async function drainStdin(): Promise<void> {
-  return new Promise((resolve) => {
-    if (!process.stdin.readable) { resolve(); return }
-    process.stdin.resume()
-    const timer = setTimeout(() => {
-      process.stdin.pause()
-      process.stdin.removeAllListeners("readable")
-      resolve()
-    }, 200)
-    process.stdin.on("readable", () => {
-      while (process.stdin.read() !== null) {} // discard
-    })
-    timer.unref()
-  })
-}
-
-async function prompt(question: string, defaultValue?: string): Promise<string> {
-  await drainStdin()
-  const rl = createInterface({ input: process.stdin, output: process.stdout })
-  const suffix = defaultValue ? ` [${defaultValue}]` : ""
-  return new Promise((resolve) => {
-    rl.question(`${question}${suffix}: `, (answer) => {
-      rl.close()
-      resolve(answer.trim() || defaultValue || "")
-    })
-  })
-}
-
 export async function submitResults(data: SubmitData): Promise<string | null> {
-  // Confirm/fill terminal info
-  console.log(`\n\x1b[1mConfirm submission details:\x1b[0m`)
-  data.terminal = await prompt("  Terminal name", data.terminal)
-  data.terminalVersion = await prompt("  Terminal version", data.terminalVersion || undefined)
-  data.os = await prompt("  Operating system", data.os)
+  const passed = Object.values(data.results).filter(Boolean).length
+  const total = Object.keys(data.results).length
+  const pct = Math.round((passed / total) * 100)
+  const ver = data.terminalVersion ? ` ${data.terminalVersion}` : ""
+
+  console.log(`\n  Submitting: \x1b[1m${data.terminal}${ver}\x1b[0m on ${data.os} — ${pct}% (${passed}/${total})`)
 
   if (!data.terminalVersion) {
-    console.log(`\x1b[33m  ⚠ No version specified — results will be less useful\x1b[0m`)
+    console.log(`  \x1b[33m⚠ No version detected — use --terminal-version to specify\x1b[0m`)
   }
 
   // Check for duplicates
   if (hasGhCli()) {
     const existing = checkDuplicate(data.terminal, data.terminalVersion, data.os)
     if (existing) {
-      console.log(`\n\x1b[33m⚠ A submission already exists for ${data.terminal}${data.terminalVersion ? ` ${data.terminalVersion}` : ""} on ${data.os}:\x1b[0m`)
-      console.log(`  ${existing}`)
-      const proceed = await prompt("  Submit anyway? (y/N)", "N")
-      if (proceed.toLowerCase() !== "y") {
-        console.log(`Skipped.`)
-        return null
-      }
+      console.log(`  \x1b[33m⚠ Similar submission exists: ${existing}\x1b[0m`)
+      console.log(`  Submitting anyway (different probe version may have new results)`)
     }
   }
 
-  const passed = Object.values(data.results).filter(Boolean).length
-  const total = Object.keys(data.results).length
-  const pct = Math.round((passed / total) * 100)
-
-  const title = `[census] ${data.terminal}${data.terminalVersion ? ` ${data.terminalVersion}` : ""} on ${data.os} — ${pct}% (${passed}/${total})`
+  const title = `[census] ${data.terminal}${ver} on ${data.os} — ${pct}% (${passed}/${total})`
 
   const body = `## Community Census Result
 
@@ -114,8 +76,8 @@ ${JSON.stringify(data, null, 2)}
   if (!hasGhCli()) {
     const filename = `terminfo-${data.terminal}-${data.os}-${Date.now()}.json`
     writeFileSync(filename, JSON.stringify(data, null, 2))
-    console.log(`\n\x1b[33mgh CLI not found. Results saved to ${filename}\x1b[0m`)
-    console.log(`To submit: https://github.com/${REPO}/issues/new`)
+    console.log(`\n  \x1b[33mgh CLI not found. Results saved to ${filename}\x1b[0m`)
+    console.log(`  To submit: https://github.com/${REPO}/issues/new`)
     return null
   }
 
@@ -130,8 +92,8 @@ ${JSON.stringify(data, null, 2)}
     ], { encoding: "utf-8", timeout: 30000 })
     return result.trim()
   } catch (err) {
-    console.error(`\x1b[31mFailed to create issue\x1b[0m`)
-    console.error(err instanceof Error ? err.message : String(err))
+    console.error(`  \x1b[31mFailed to create issue\x1b[0m`)
+    console.error(`  ${err instanceof Error ? err.message : String(err)}`)
     return null
   } finally {
     try { unlinkSync(bodyFile) } catch {}
@@ -159,8 +121,7 @@ function checkDuplicate(terminal: string, version: string, os: string): string |
       "--json", "url,title",
       "--jq", ".[0] | .title + \" \" + .url",
     ], { encoding: "utf-8", timeout: 10000 })
-    const trimmed = result.trim()
-    return trimmed || null
+    return result.trim() || null
   } catch {
     return null
   }

package/src/tty.ts

@@ -89,6 +89,28 @@ export async function queryMode(modeNumber: number): Promise<"set" | "reset" | "
   }
 }
 
+/**
+ * Drain all pending bytes from stdin (late-arriving escape sequence responses).
+ * Waits up to `ms` milliseconds for bytes to stop arriving.
+ */
+export async function drainStdin(ms = 300): Promise<void> {
+  return new Promise((resolve) => {
+    if (!process.stdin.readable) { resolve(); return }
+    process.stdin.resume()
+    let timer = setTimeout(done, ms)
+    function onData() {
+      while (process.stdin.read() !== null) {} // discard
+      clearTimeout(timer)
+      timer = setTimeout(done, ms) // reset timer on each new data
+    }
+    function done() {
+      process.stdin.removeListener("readable", onData)
+      resolve()
+    }
+    process.stdin.on("readable", onData)
+  })
+}
+
 /**
  * Run a function with stdin in raw mode.
  * Restores original mode on exit.