terminfo.dev 3.0.0 → 3.1.0

package/package.json

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

package/src/index.ts

@@ -238,6 +238,67 @@ program
     }
   })
 
+program
+  .command("serve")
+  .description("Start daemon — accepts remote probe requests from other sessions")
+  .option("-p, --port <port>", "Port to listen on (default: auto)", parseInt)
+  .action(async (opts) => {
+    const { startDaemon } = await import("./serve.ts")
+    await startDaemon(opts.port ?? 0)
+  })
+
+program
+  .command("test-all")
+  .description("Run probes on all running daemons (started with 'serve')")
+  .action(async () => {
+    const { listDaemons } = await import("./serve.ts")
+    const daemons = listDaemons()
+
+    if (daemons.length === 0) {
+      console.log(`\x1b[33mNo daemons found.\x1b[0m`)
+      console.log(`Start a daemon in each terminal: \x1b[1mnpx terminfo.dev serve\x1b[0m`)
+      return
+    }
+
+    console.log(`\x1b[1mterminfo.dev\x1b[0m — testing ${daemons.length} terminal(s)\n`)
+
+    for (const d of daemons) {
+      const label = `${d.terminal}${d.terminalVersion ? ` ${d.terminalVersion}` : ""}`
+      process.stdout.write(`  ${label.padEnd(25)} `)
+
+      try {
+        const res = await fetch(`http://127.0.0.1:${d.port}/probe`, { signal: AbortSignal.timeout(120000) })
+        if (!res.ok) {
+          console.log(`\x1b[31m✗ HTTP ${res.status}\x1b[0m`)
+          continue
+        }
+        const data = await res.json() as any
+        const passed = Object.values(data.results).filter((v: any) => v).length
+        const total = Object.keys(data.results).length
+        const pct = Math.round(passed / total * 100)
+        const color = pct >= 98 ? "\x1b[32m" : pct >= 90 ? "\x1b[33m" : "\x1b[31m"
+        console.log(`${color}${passed}/${total} (${pct}%)\x1b[0m`)
+
+        // Save results
+        const { mkdirSync, writeFileSync } = await import("node:fs")
+        const dir = "docs/data/results/app"
+        mkdirSync(dir, { recursive: true })
+        const name = data.terminal.replace(/[^a-z0-9-]/g, "-")
+        const ver = (data.terminalVersion || "unknown").replace(/[^a-z0-9.-]/g, "-")
+        writeFileSync(`${dir}/${name}-${ver}-${data.os}.json`, JSON.stringify(data, null, 2))
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err)
+        if (msg.includes("ECONNREFUSED")) {
+          console.log(`\x1b[31m✗ not running (stale daemon file)\x1b[0m`)
+        } else {
+          console.log(`\x1b[31m✗ ${msg}\x1b[0m`)
+        }
+      }
+    }
+
+    console.log(`\nResults saved to docs/data/results/app/`)
+  })
+
 // Default action: show terminal info + help
 program.action(() => {
   const terminal = detectTerminal()
@@ -248,12 +309,14 @@ program.action(() => {
   console.log(`submitted to the community database at terminfo.dev.\x1b[0m`)
   console.log(``)
   console.log(`Commands:`)
-  console.log(`  \x1b[1mprobe\x1b[0m    Run all probes and display results`)
-  console.log(`  \x1b[1msubmit\x1b[0m   Run probes and submit to terminfo.dev`)
+  console.log(`  \x1b[1mprobe\x1b[0m      Run all probes and display results`)
+  console.log(`  \x1b[1msubmit\x1b[0m     Run probes and submit to terminfo.dev`)
+  console.log(`  \x1b[1mserve\x1b[0m      Start daemon for remote testing`)
+  console.log(`  \x1b[1mtest-all\x1b[0m   Run probes on all daemons`)
   console.log(``)
   console.log(`Options:`)
-  console.log(`  \x1b[1m--json\x1b[0m   Output results as JSON (with probe command)`)
-  console.log(`  \x1b[1m--help\x1b[0m   Show this help`)
+  console.log(`  \x1b[1m--json\x1b[0m     Output results as JSON (with probe command)`)
+  console.log(`  \x1b[1m--help\x1b[0m     Show this help`)
 })
 
 program.parse()

package/src/probes/index.ts

@@ -1352,35 +1352,28 @@ export const ALL_PROBES: Probe[] = [
     },
   } satisfies Probe,
 
-  // Reflow: write long line, resize terminal smaller, check if text wraps
+  // Reflow: test if terminal supports text reflow by writing a long line,
+  // wrapping naturally, then checking cursor position is consistent.
+  // Can't programmatically resize (some terminals block it or need permission),
+  // so we test the prerequisite: auto-wrap + cursor tracking across wraps.
   {
     id: "extensions.reflow",
     name: "Text reflow on resize",
     async run() {
-      // Use XTWINOPS to query current size, resize smaller, check cursor, resize back
-      // CSI 18 t reports terminal size: ESC [ 8 ; rows ; cols t
+      // Check if terminal reports its size (needed for reflow to work)
       const sizeMatch = await query("\x1b[18t", /\x1b\[8;(\d+);(\d+)t/, 1000)
-      if (!sizeMatch) return { pass: false, note: "Terminal doesn't report size (XTWINOPS 18)" }
-      const origRows = parseInt(sizeMatch[1]!, 10)
-      const origCols = parseInt(sizeMatch[2]!, 10)
-      // Write a line that's exactly origCols wide
-      const testLine = "R".repeat(Math.min(origCols, 40))
-      process.stdout.write("\x1b[1;1H\x1b[2J") // clear
-      process.stdout.write(testLine)
-      // Resize to half width
-      const halfCols = Math.floor(origCols / 2)
-      process.stdout.write(`\x1b[8;${origRows};${halfCols}t`)
-      await new Promise(r => setTimeout(r, 200)) // wait for resize
-      // Query cursor — if reflow happened, cursor should be on row 2+
+      if (!sizeMatch) return { pass: false, note: "No XTWINOPS 18 response (can't report size)" }
+      const cols = parseInt(sizeMatch[2]!, 10)
+      // Write a line longer than terminal width — verify it wraps correctly
+      process.stdout.write("\x1b[1;1H\x1b[2J")
+      const longLine = "W".repeat(cols + 5) // 5 chars past the edge
+      process.stdout.write(longLine)
       const pos = await queryCursorPosition()
-      // Restore original size
-      process.stdout.write(`\x1b[8;${origRows};${origCols}t`)
-      await new Promise(r => setTimeout(r, 100))
-      if (!pos) return { pass: false, note: "No cursor response after resize" }
-      // If text reflowed to half width, cursor or content should span 2+ rows
+      if (!pos) return { pass: false, note: "No cursor response" }
+      // If auto-wrap works and terminal tracks wrapped content, cursor is on row 2, col 6
       return {
-        pass: pos[0] >= 2,
-        note: pos[0] >= 2 ? undefined : "Text didn't reflow after resize",
+        pass: pos[0] === 2 && pos[1] === 6,
+        note: pos[0] === 2 && pos[1] === 6 ? undefined : `cursor at ${pos[0]};${pos[1]}, expected 2;6`,
       }
     },
   } satisfies Probe,
@@ -1390,17 +1383,23 @@ export const ALL_PROBES: Probe[] = [
     id: "scrollback.accumulate",
     name: "Scrollback accumulates",
     async run() {
+      // Get terminal height first
+      const sizeMatch = await query("\x1b[18t", /\x1b\[8;(\d+);(\d+)t/, 1000)
+      const rows = sizeMatch ? parseInt(sizeMatch[1]!, 10) : 24
       process.stdout.write("\x1b[2J\x1b[H") // clear + home
-      // Write 30 lines (more than typical 24-row screen)
-      for (let i = 0; i < 30; i++) {
+      // Write more lines than the screen can hold
+      const lineCount = rows + 10
+      for (let i = 0; i < lineCount; i++) {
         process.stdout.write(`line-${i}\n`)
       }
-      // Query cursor — should be near bottom
       const pos = await queryCursorPosition()
       if (!pos) return { pass: false, note: "No cursor response" }
-      // If scrollback works, cursor row should be <= screen height (content scrolled up)
-      // The fact that we wrote 30 lines and cursor isn't at row 31 means scrollback absorbed some
-      return { pass: pos[0] <= 25, note: pos[0] <= 25 ? undefined : `cursor at row ${pos[0]}` }
+      // Cursor should be at or near the bottom row (content scrolled into scrollback)
+      // NOT at lineCount+1 (which would mean terminal expanded instead of scrolling)
+      return {
+        pass: pos[0] <= rows,
+        note: pos[0] <= rows ? undefined : `cursor at row ${pos[0]}, expected <= ${rows}`,
+      }
     },
   } satisfies Probe,
 

package/src/serve.ts

@@ -0,0 +1,210 @@
+/**
+ * Daemon mode — run inside a terminal, accept remote probe commands.
+ *
+ * Usage: npx terminfo.dev serve
+ *
+ * Starts an HTTP server that accepts probe requests. Run this in each
+ * terminal you want to test, then use `terminfo.dev test-all` or
+ * curl to run probes remotely.
+ *
+ * Discovery: writes terminal info + port to ~/.terminfo-dev/daemons/
+ * so clients can find all running daemons automatically.
+ */
+
+import { createServer, type IncomingMessage, type ServerResponse } from "node:http"
+import { mkdirSync, writeFileSync, unlinkSync, readdirSync, readFileSync } from "node:fs"
+import { join } from "node:path"
+import { homedir } from "node:os"
+import { detectTerminal } from "./detect.ts"
+import { ALL_PROBES } from "./probes/index.ts"
+import { withRawMode, drainStdin } from "./tty.ts"
+
+const DAEMON_DIR = join(homedir(), ".terminfo-dev", "daemons")
+
+interface DaemonInfo {
+  pid: number
+  port: number
+  terminal: string
+  terminalVersion: string
+  os: string
+  osVersion: string
+  started: string
+}
+
+function register(info: DaemonInfo): string {
+  mkdirSync(DAEMON_DIR, { recursive: true })
+  const filename = `${info.terminal}-${info.pid}.json`
+  const filepath = join(DAEMON_DIR, filename)
+  writeFileSync(filepath, JSON.stringify(info, null, 2))
+  return filepath
+}
+
+function unregister(filepath: string) {
+  try { unlinkSync(filepath) } catch {}
+}
+
+export function listDaemons(): DaemonInfo[] {
+  try {
+    const files = readdirSync(DAEMON_DIR).filter(f => f.endsWith(".json"))
+    const daemons: DaemonInfo[] = []
+    for (const f of files) {
+      try {
+        const data = JSON.parse(readFileSync(join(DAEMON_DIR, f), "utf-8"))
+        daemons.push(data)
+      } catch {}
+    }
+    return daemons
+  } catch {
+    return []
+  }
+}
+
+export async function startDaemon(port = 0): Promise<void> {
+  const terminal = detectTerminal()
+
+  // Run all probes once synchronously, then serve results
+  // For live probing, we need the server to run probes on-demand in the terminal context
+  const server = createServer(async (req: IncomingMessage, res: ServerResponse) => {
+    res.setHeader("Content-Type", "application/json")
+    res.setHeader("Access-Control-Allow-Origin", "*")
+
+    const url = new URL(req.url ?? "/", `http://localhost`)
+
+    if (url.pathname === "/info") {
+      res.end(JSON.stringify({
+        terminal: terminal.name,
+        terminalVersion: terminal.version,
+        os: terminal.os,
+        osVersion: terminal.osVersion,
+        probeCount: ALL_PROBES.length,
+      }))
+      return
+    }
+
+    if (url.pathname === "/probe") {
+      // Run all probes in this terminal
+      console.log(`\x1b[2m[${new Date().toISOString()}] Running ${ALL_PROBES.length} probes...\x1b[0m`)
+
+      const results: Record<string, boolean> = {}
+      const notes: Record<string, string> = {}
+      const responses: Record<string, string> = {}
+
+      await withRawMode(async () => {
+        for (const probe of ALL_PROBES) {
+          process.stdout.write("\x1b[0m\x1b[2J\x1b[H")
+          try {
+            const result = await probe.run()
+            results[probe.id] = result.pass
+            if (result.note) notes[probe.id] = result.note
+            if (result.response) responses[probe.id] = result.response
+          } catch (err) {
+            results[probe.id] = false
+            notes[probe.id] = `error: ${err instanceof Error ? err.message : String(err)}`
+          }
+        }
+        process.stdout.write("\x1b[0m\x1b[2J\x1b[H")
+        await drainStdin(1000)
+      })
+
+      // Reset terminal after probes
+      process.stdout.write("\x1bc")
+
+      const passed = Object.values(results).filter(v => v).length
+      const total = Object.keys(results).length
+      console.log(`\x1b[32m✓\x1b[0m ${passed}/${total} (${Math.round(passed / total * 100)}%)`)
+
+      res.end(JSON.stringify({
+        terminal: terminal.name,
+        terminalVersion: terminal.version,
+        os: terminal.os,
+        osVersion: terminal.osVersion,
+        source: "daemon",
+        generated: new Date().toISOString(),
+        results,
+        notes,
+        responses,
+      }))
+      return
+    }
+
+    if (url.pathname === "/probe/single") {
+      const probeId = url.searchParams.get("id")
+      if (!probeId) {
+        res.statusCode = 400
+        res.end(JSON.stringify({ error: "Missing ?id= parameter" }))
+        return
+      }
+      const probe = ALL_PROBES.find(p => p.id === probeId)
+      if (!probe) {
+        res.statusCode = 404
+        res.end(JSON.stringify({ error: `Unknown probe: ${probeId}` }))
+        return
+      }
+
+      await withRawMode(async () => {
+        process.stdout.write("\x1b[0m\x1b[2J\x1b[H")
+        try {
+          const result = await probe.run()
+          process.stdout.write("\x1b[0m\x1b[2J\x1b[H")
+          await drainStdin(500)
+          res.end(JSON.stringify({ id: probeId, ...result }))
+        } catch (err) {
+          process.stdout.write("\x1b[0m\x1b[2J\x1b[H")
+          await drainStdin(500)
+          res.end(JSON.stringify({ id: probeId, pass: false, note: String(err) }))
+        }
+      })
+      process.stdout.write("\x1bc")
+      return
+    }
+
+    // Default: show help
+    res.end(JSON.stringify({
+      endpoints: {
+        "/info": "Terminal info",
+        "/probe": "Run all probes",
+        "/probe/single?id=sgr.bold": "Run single probe",
+      },
+      terminal: terminal.name,
+      version: terminal.version,
+    }))
+  })
+
+  server.listen(port, "127.0.0.1", () => {
+    const addr = server.address()
+    if (!addr || typeof addr === "string") return
+    const actualPort = addr.port
+
+    const info: DaemonInfo = {
+      pid: process.pid,
+      port: actualPort,
+      terminal: terminal.name,
+      terminalVersion: terminal.version,
+      os: terminal.os,
+      osVersion: terminal.osVersion,
+      started: new Date().toISOString(),
+    }
+
+    const filepath = register(info)
+
+    console.log(`\x1b[1mterminfo.dev\x1b[0m daemon running\n`)
+    console.log(`  Terminal:  \x1b[1m${terminal.name}\x1b[0m ${terminal.version}`)
+    console.log(`  Port:      \x1b[1m${actualPort}\x1b[0m`)
+    console.log(`  Probes:    ${ALL_PROBES.length}`)
+    console.log(``)
+    console.log(`  Test:   curl http://localhost:${actualPort}/probe`)
+    console.log(`  Info:   curl http://localhost:${actualPort}/info`)
+    console.log(`  Single: curl http://localhost:${actualPort}/probe/single?id=sgr.bold`)
+    console.log(``)
+    console.log(`\x1b[2mPress Ctrl+C to stop.\x1b[0m`)
+
+    // Clean up on exit
+    const cleanup = () => {
+      unregister(filepath)
+      server.close()
+      process.exit(0)
+    }
+    process.on("SIGINT", cleanup)
+    process.on("SIGTERM", cleanup)
+  })
+}