failproofai 0.0.1-beta.1

package/.next/standalone/src/hooks/hook-logger.ts

@@ -0,0 +1,133 @@
+/**
+ * Lightweight logger for hook processes.
+ *
+ * ALL output goes to stderr (stdout is reserved for the hook JSON response
+ * that Claude Code reads).
+ *
+ * Optionally writes to a log file with size-based rotation.
+ *
+ * Env vars:
+ *   FAILPROOFAI_LOG_LEVEL      — info | warn | error (default: warn)
+ *   FAILPROOFAI_HOOK_LOG_FILE  — enable file logging:
+ *       unset / ""   → disabled (stderr only)
+ *       "1" / "true" → enabled, writes to ~/.failproofai/logs/
+ *       <path>       → enabled, writes to that directory
+ */
+import {
+  appendFileSync,
+  renameSync,
+  mkdirSync,
+  existsSync,
+  statSync,
+} from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+export type LogLevel = "info" | "warn" | "error";
+
+const LEVEL_ORDER: Record<LogLevel, number> = { info: 0, warn: 1, error: 2 };
+const MAX_FILE_SIZE = 512 * 1024; // 500 KB
+const LOG_FILENAME = "hooks.log";
+const DEFAULT_LOG_DIR = join(homedir(), ".failproofai", "logs");
+
+// ── State (lazy-initialized) ──
+
+let resolved = false;
+let currentLevel: LogLevel = "warn";
+let fileLoggingEnabled = false;
+let logDir = DEFAULT_LOG_DIR;
+
+function ensureResolved(): void {
+  if (resolved) return;
+  resolved = true;
+
+  // Log level
+  const rawLevel = (process.env.FAILPROOFAI_LOG_LEVEL ?? "").toLowerCase();
+  if (rawLevel === "info" || rawLevel === "warn" || rawLevel === "error") {
+    currentLevel = rawLevel;
+  }
+
+  // File logging
+  const rawFile = (process.env.FAILPROOFAI_HOOK_LOG_FILE ?? "").trim();
+  if (rawFile) {
+    fileLoggingEnabled = true;
+    if (rawFile !== "1" && rawFile !== "true") {
+      logDir = rawFile;
+    }
+  }
+}
+
+function shouldEmit(level: LogLevel): boolean {
+  ensureResolved();
+  return LEVEL_ORDER[level] >= LEVEL_ORDER[currentLevel];
+}
+
+// ── Stderr output ──
+
+function emitStderr(label: string, msg: string): void {
+  process.stderr.write(`[failproofai:hook] ${label} ${msg}\n`);
+}
+
+// ── File output (synchronous — hook processes are short-lived) ──
+
+function ensureLogDir(): void {
+  if (!existsSync(logDir)) {
+    mkdirSync(logDir, { recursive: true });
+  }
+}
+
+function rotateIfNeeded(filePath: string): void {
+  try {
+    const stats = statSync(filePath);
+    if (stats.size >= MAX_FILE_SIZE) {
+      const archiveName = `hooks-${Date.now()}.log`;
+      renameSync(filePath, join(logDir, archiveName));
+    }
+  } catch {
+    // File doesn't exist yet — nothing to rotate
+  }
+}
+
+function appendToFile(label: string, msg: string): void {
+  if (!fileLoggingEnabled) return;
+
+  try {
+    ensureLogDir();
+    const filePath = join(logDir, LOG_FILENAME);
+    rotateIfNeeded(filePath);
+
+    const timestamp = new Date().toISOString();
+    const line = `[${timestamp}] ${label} ${msg}\n`;
+    appendFileSync(filePath, line, "utf-8");
+  } catch {
+    // File logging is best-effort — never fail the hook
+  }
+}
+
+// ── Public API ──
+
+export function hookLogInfo(msg: string): void {
+  if (!shouldEmit("info")) return;
+  emitStderr("INFO", msg);
+  appendToFile("INFO", msg);
+}
+
+export function hookLogWarn(msg: string): void {
+  if (!shouldEmit("warn")) return;
+  emitStderr("WARN", msg);
+  appendToFile("WARN", msg);
+}
+
+export function hookLogError(msg: string): void {
+  if (!shouldEmit("error")) return;
+  emitStderr("ERROR", msg);
+  appendToFile("ERROR", msg);
+}
+
+/** Reset internal state (for testing only). */
+export function _resetHookLogger(): void {
+  resolved = false;
+  currentLevel = "warn";
+  fileLoggingEnabled = false;
+  logDir = DEFAULT_LOG_DIR;
+}

package/.next/standalone/src/hooks/hook-telemetry.ts

@@ -0,0 +1,43 @@
+/**
+ * Lightweight PostHog telemetry for the compiled hook binary.
+ *
+ * Uses fetch() directly instead of posthog-node, since the binary
+ * doesn't have access to node_modules at runtime.
+ */
+
+import { version } from "../../package.json";
+import { POSTHOG_API_KEY } from "../posthog-key";
+
+const API_KEY = POSTHOG_API_KEY;
+const CAPTURE_URL = "https://us.i.posthog.com/capture/";
+
+export async function trackHookEvent(
+  distinctId: string,
+  event: string,
+  properties?: Record<string, unknown>,
+): Promise<void> {
+  if (process.env.FAILPROOFAI_TELEMETRY_DISABLED === "1") return;
+
+  const body = JSON.stringify({
+    api_key: process.env.FAILPROOFAI_POSTHOG_KEY ?? API_KEY,
+    event,
+    distinct_id: distinctId,
+    properties: { ...properties, $lib: "failproofai-hooks", failproofai_version: version },
+  });
+
+  try {
+    await fetch(
+      process.env.FAILPROOFAI_POSTHOG_HOST
+        ? `${process.env.FAILPROOFAI_POSTHOG_HOST}/capture/`
+        : CAPTURE_URL,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body,
+        signal: AbortSignal.timeout(5000),
+      },
+    );
+  } catch {
+    // Telemetry is best-effort — never fail the hook
+  }
+}

package/.next/standalone/src/hooks/hooks-config.ts

@@ -0,0 +1,121 @@
+/**
+ * Read/write the hooks configuration file at ~/.failproofai/hooks-config.json.
+ */
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { homedir } from "node:os";
+import type { HooksConfig } from "./policy-types";
+import { hookLogInfo, hookLogWarn } from "./hook-logger";
+
+function readConfigAt(path: string): Partial<HooksConfig> {
+  if (!existsSync(path)) return {};
+  try {
+    const raw = readFileSync(path, "utf8");
+    return JSON.parse(raw) as Partial<HooksConfig>;
+  } catch (err) {
+    hookLogWarn(`failed to parse config at ${path}: ${err instanceof Error ? err.message : String(err)}`);
+    return {};
+  }
+}
+
+/**
+ * Read and merge hooks config from three scopes in priority order:
+ *   1. {cwd}/.failproofai/hooks-config.json        (project)
+ *   2. {cwd}/.failproofai/hooks-config.local.json  (local)
+ *   3. ~/.failproofai/hooks-config.json             (global)
+ *
+ * Merge rules:
+ *   enabledPolicies: union + dedup across all three
+ *   policyParams:    per-policy key, first scope that defines it wins entirely
+ *   customHooksPath: first scope that defines it wins
+ *   llm:            first scope that defines it wins
+ */
+export function readMergedHooksConfig(cwd?: string): HooksConfig {
+  const base = cwd ? resolve(cwd) : process.cwd();
+  const projectPath = resolve(base, ".failproofai", "hooks-config.json");
+  const localPath = resolve(base, ".failproofai", "hooks-config.local.json");
+  const globalPath = resolve(homedir(), ".failproofai", "hooks-config.json");
+
+  const project = readConfigAt(projectPath);
+  const local = readConfigAt(localPath);
+  const global_ = readConfigAt(globalPath);
+
+  // enabledPolicies: union + dedup
+  const enabledSet = new Set<string>([
+    ...(project.enabledPolicies ?? []),
+    ...(local.enabledPolicies ?? []),
+    ...(global_.enabledPolicies ?? []),
+  ]);
+
+  // policyParams: per-policy, first scope wins
+  const mergedParams: Record<string, Record<string, unknown>> = {};
+  for (const scope of [project, local, global_]) {
+    if (!scope.policyParams) continue;
+    for (const [policyName, params] of Object.entries(scope.policyParams)) {
+      if (!(policyName in mergedParams)) {
+        mergedParams[policyName] = params;
+      }
+    }
+  }
+
+  // customHooksPath: first scope wins
+  const customHooksPath =
+    project.customHooksPath ?? local.customHooksPath ?? global_.customHooksPath;
+
+  // llm: first scope wins
+  const llm = project.llm ?? local.llm ?? global_.llm;
+
+  return {
+    enabledPolicies: [...enabledSet],
+    ...(Object.keys(mergedParams).length > 0 ? { policyParams: mergedParams } : {}),
+    ...(customHooksPath !== undefined ? { customHooksPath } : {}),
+    ...(llm !== undefined ? { llm } : {}),
+  };
+}
+
+function getConfigPath(): string {
+  return resolve(homedir(), ".failproofai", "hooks-config.json");
+}
+
+export function readHooksConfig(): HooksConfig {
+  const configPath = getConfigPath();
+  if (!existsSync(configPath)) {
+    return { enabledPolicies: [] };
+  }
+  try {
+    const raw = readFileSync(configPath, "utf8");
+    return JSON.parse(raw) as HooksConfig;
+  } catch (err) {
+    hookLogWarn(`failed to parse config at ${configPath}: ${err instanceof Error ? err.message : String(err)}`);
+    return { enabledPolicies: [] };
+  }
+}
+
+export function writeHooksConfig(config: HooksConfig): void {
+  const configPath = getConfigPath();
+  const dir = dirname(configPath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf8");
+}
+
+export interface ResolvedLlmConfig {
+  baseUrl: string;
+  apiKey: string;
+  model: string;
+}
+
+export function readLlmConfig(): ResolvedLlmConfig | null {
+  const config = readHooksConfig();
+  const baseUrl =
+    process.env.FAILPROOFAI_LLM_BASE_URL ?? config.llm?.baseUrl ?? "https://api.openai.com/v1";
+  const apiKey = process.env.FAILPROOFAI_LLM_API_KEY ?? config.llm?.apiKey;
+  const model = process.env.FAILPROOFAI_LLM_MODEL ?? config.llm?.model ?? "gpt-4o-mini";
+  const apiKeySource = process.env.FAILPROOFAI_LLM_API_KEY ? "env" : config.llm?.apiKey ? "file" : "missing";
+  const baseUrlSource = process.env.FAILPROOFAI_LLM_BASE_URL ? "env" : config.llm?.baseUrl ? "file" : "default";
+  const modelSource = process.env.FAILPROOFAI_LLM_MODEL ? "env" : config.llm?.model ? "file" : "default";
+  hookLogInfo(`llm-config: apiKey=${apiKeySource} baseUrl=${baseUrlSource}(${baseUrl}) model=${modelSource}(${model})`);
+  if (!apiKey) return null;
+  return { baseUrl, apiKey, model };
+}

package/.next/standalone/src/hooks/install-prompt.ts

@@ -0,0 +1,357 @@
+/**
+ * Interactive searchable multi-select prompt for choosing hook policies.
+ * Uses raw mode stdin with node:readline for keypress handling.
+ * No external dependencies.
+ *
+ * Rendering strategy: track line count, use cursor-up + clear-to-end-of-screen
+ * (\x1B[NA\x1B[J) to avoid flickering. Lines are truncated to terminal width to
+ * ensure lastLineCount stays accurate when the terminal is narrow.
+ *
+ * Keybindings: ↑↓ navigate · Space toggle · Ctrl+A all · Ctrl+S save · Esc clear search
+ */
+import * as readline from "node:readline";
+import { BUILTIN_POLICIES } from "./builtin-policies";
+
+interface SelectItem {
+  name: string;
+  description: string;
+  category: string;
+  selected: boolean;
+  beta: boolean;
+}
+
+type DisplayRow =
+  | { kind: "header"; category: string; enabledCount: number; totalCount: number }
+  | { kind: "item"; item: SelectItem; filteredIndex: number };
+
+export interface PromptOptions {
+  includeBeta?: boolean;
+}
+
+/**
+ * Show interactive searchable policy selector.
+ * @param preSelected — policy names to pre-check (e.g. from existing config).
+ *                      When omitted, uses each policy's defaultEnabled flag.
+ * @param options     — prompt options (e.g. includeBeta)
+ */
+export async function promptPolicySelection(
+  preSelected?: string[],
+  options: PromptOptions = {},
+): Promise<string[]> {
+  const { includeBeta = false } = options;
+
+  // If stdin is not a TTY (piped/CI), return defaults
+  if (!process.stdin.isTTY) {
+    const available = BUILTIN_POLICIES.filter((p) => includeBeta || !p.beta);
+    if (preSelected) return preSelected.filter((name) => available.some((p) => p.name === name));
+    return available.filter((p) => p.defaultEnabled).map((p) => p.name);
+  }
+
+  const preSelectedSet = preSelected ? new Set(preSelected) : null;
+
+  const items: SelectItem[] = BUILTIN_POLICIES
+    .filter((p) => includeBeta || !p.beta)
+    .map((p) => ({
+      name: p.name,
+      description: p.description,
+      category: p.category,
+      selected: preSelectedSet ? preSelectedSet.has(p.name) : p.defaultEnabled,
+      beta: !!p.beta,
+    }));
+
+  const total = items.length;
+  const WINDOW_SIZE = 8;
+
+  let cursor = 0;
+  let search = "";
+  let lastLineCount = 0;
+  let cursorHidden = false;
+
+  function hideCursor(): void {
+    if (!cursorHidden) {
+      process.stdout.write("\x1B[?25l");
+      cursorHidden = true;
+    }
+  }
+
+  function showCursor(): void {
+    if (cursorHidden) {
+      process.stdout.write("\x1B[?25h");
+      cursorHidden = false;
+    }
+  }
+
+  // Truncate a line to `width` visual columns, skipping ANSI CSI sequences.
+  function truncateLine(line: string, width: number): string {
+    let visual = 0;
+    let result = "";
+    let i = 0;
+    while (i < line.length) {
+      if (line[i] === "\x1B" && line[i + 1] === "[") {
+        let j = i + 2;
+        while (j < line.length && !/[A-Za-z]/.test(line[j])) j++;
+        j++;
+        result += line.slice(i, j);
+        i = j;
+      } else {
+        if (visual >= width) break;
+        result += line[i];
+        visual++;
+        i++;
+      }
+    }
+    return result;
+  }
+
+  function getFiltered(): SelectItem[] {
+    if (!search) return items;
+    const q = search.toLowerCase();
+    return items.filter(
+      (i) => i.name.toLowerCase().includes(q) || i.description.toLowerCase().includes(q),
+    );
+  }
+
+  // Build display rows: category header rows interspersed with item rows.
+  // Categories appear in the order they first appear in BUILTIN_POLICIES.
+  function buildDisplayRows(filtered: SelectItem[]): DisplayRow[] {
+    // Single pass: compute category order, enabled counts, and total counts together.
+    const categoryOrder: string[] = [];
+    const categoryEnabledCount = new Map<string, number>();
+    const categoryTotalCount = new Map<string, number>();
+    for (const p of items) {
+      if (!categoryEnabledCount.has(p.category)) {
+        categoryOrder.push(p.category);
+        categoryEnabledCount.set(p.category, 0);
+        categoryTotalCount.set(p.category, 0);
+      }
+      categoryTotalCount.set(p.category, categoryTotalCount.get(p.category)! + 1);
+      if (p.selected) categoryEnabledCount.set(p.category, categoryEnabledCount.get(p.category)! + 1);
+    }
+
+    const filteredByCategory = new Map<string, SelectItem[]>();
+    for (const item of filtered) {
+      const bucket = filteredByCategory.get(item.category) ?? [];
+      bucket.push(item);
+      filteredByCategory.set(item.category, bucket);
+    }
+
+    const rows: DisplayRow[] = [];
+    let idx = 0;
+    for (const cat of categoryOrder) {
+      const catFiltered = filteredByCategory.get(cat);
+      if (!catFiltered || catFiltered.length === 0) continue;
+      rows.push({ kind: "header", category: cat, enabledCount: categoryEnabledCount.get(cat)!, totalCount: categoryTotalCount.get(cat)! });
+      for (const item of catFiltered) {
+        rows.push({ kind: "item", item, filteredIndex: idx++ });
+      }
+    }
+    return rows;
+  }
+
+  function render(): void {
+    const cols = process.stdout.columns || 120;
+    hideCursor();
+
+    const filtered = getFiltered();
+    const shown = filtered.length;
+
+    // Clamp cursor to filtered list bounds
+    if (shown > 0 && cursor >= shown) cursor = shown - 1;
+
+    const lines: string[] = [];
+
+    // ── Title ────────────────────────────────────────────────────
+    lines.push("  Failproof AI \u2014 Policy Manager");
+    lines.push("");
+
+    // ── Bordered search box ──────────────────────────────────────
+    const innerWidth = Math.max(20, cols - 6);
+    const topBorder = "  \u250c" + "\u2500".repeat(innerWidth + 2) + "\u2510";
+    const botBorder = "  \u2514" + "\u2500".repeat(innerWidth + 2) + "\u2518";
+    const cursorChar = "\x1B[7m \x1B[0m"; // reverse-video block cursor
+    const countPart = search
+      ? ` \x1B[2m(${shown}/${total})\x1B[0m`
+      : ` \x1B[2m(${total} policies)\x1B[0m`;
+    const searchContent = `\x1B[1mSearch:\x1B[0m ${search}${cursorChar}${countPart}`;
+    lines.push(topBorder);
+    lines.push(`  \u2502 ${searchContent}`);
+    lines.push(botBorder);
+    lines.push("");
+
+    // ── Content area ─────────────────────────────────────────────
+    if (shown === 0) {
+      lines.push("  \x1B[2mNo policies match \u201c" + search + "\u201d\x1B[0m");
+      // Pad to stable height: 1 (scroll-up) + WINDOW_SIZE (rows) + 1 (scroll-down)
+      for (let i = 0; i < WINDOW_SIZE + 1; i++) lines.push("");
+    } else {
+      const displayRows = buildDisplayRows(filtered);
+
+      // Find the display row index that corresponds to the current cursor
+      let cursorDisplayRow = 0;
+      for (let i = 0; i < displayRows.length; i++) {
+        const row = displayRows[i];
+        if (row.kind === "item" && row.filteredIndex === cursor) {
+          cursorDisplayRow = i;
+          break;
+        }
+      }
+
+      // Viewport: keep cursor row roughly centred
+      let windowStart = cursorDisplayRow - Math.floor(WINDOW_SIZE / 2);
+      windowStart = Math.max(0, windowStart);
+      windowStart = Math.min(windowStart, Math.max(0, displayRows.length - WINDOW_SIZE));
+      const windowEnd = Math.min(displayRows.length, windowStart + WINDOW_SIZE);
+
+      // Scroll-up indicator (always reserve this line for stable height)
+      const aboveItems = displayRows
+        .slice(0, windowStart)
+        .filter((r) => r.kind === "item").length;
+      if (aboveItems > 0) {
+        lines.push(`  \x1B[2m  \u2191 ${aboveItems} more above\x1B[0m`);
+      } else {
+        lines.push("");
+      }
+
+      // Visible display rows
+      for (let i = windowStart; i < windowEnd; i++) {
+        const row = displayRows[i];
+        if (row.kind === "header") {
+          // ── CATEGORY NAME (enabled/total) ─────
+          const label = ` ${row.category.toUpperCase()} (${row.enabledCount}/${row.totalCount}) `;
+          const prefix = "\u2500\u2500 ";
+          const prefixLen = 3 + label.length;
+          const dashLen = Math.max(2, cols - 2 - prefixLen);
+          lines.push(
+            `  \x1B[2m${prefix}${label}${"\u2500".repeat(dashLen)}\x1B[0m`,
+          );
+        } else {
+          const item = row.item;
+          const isActive = row.filteredIndex === cursor;
+          const pointer = isActive ? "\x1B[36m\u276f\x1B[0m" : " ";
+          const check = item.selected ? "\x1B[32m[\u2713]\x1B[0m" : "[ ]";
+          const namePart = isActive
+            ? `\x1B[1;36m${item.name}\x1B[0m`
+            : item.name;
+          const betaPart = item.beta ? " \x1B[35m[beta]\x1B[0m" : "";
+          const pad = " ".repeat(Math.max(1, 28 - item.name.length));
+          const desc = `\x1B[2m${item.description}\x1B[0m`;
+          lines.push(`  ${pointer} ${check} ${namePart}${betaPart}${pad}${desc}`);
+        }
+      }
+
+      // Pad window to fixed WINDOW_SIZE rows for stable height
+      for (let i = windowEnd - windowStart; i < WINDOW_SIZE; i++) {
+        lines.push("");
+      }
+
+      // Scroll-down indicator (always reserve this line for stable height)
+      const belowItems = displayRows
+        .slice(windowEnd)
+        .filter((r) => r.kind === "item").length;
+      if (belowItems > 0) {
+        lines.push(`  \x1B[2m  \u2193 ${belowItems} more below\x1B[0m`);
+      } else {
+        lines.push("");
+      }
+    }
+
+    // ── Footer ───────────────────────────────────────────────────
+    lines.push("");
+    lines.push("  \x1B[2m" + "\u2500".repeat(cols - 2) + "\x1B[0m");
+    lines.push(
+      "  [\u2191\u2193] Move  [Space] Toggle  [Ctrl+A] All  [Ctrl+S] Save  [Esc] Clear  [^C] Quit",
+    );
+    lines.push("");
+    lines.push(
+      "  \x1B[2mTip: --list-policies for a flat list \u00b7 --install-policies <name\u2026> to skip prompt\x1B[0m",
+    );
+    if (!includeBeta) {
+      lines.push(
+        "  \x1B[2mTip: --install-policies all --beta to include beta policies\x1B[0m",
+      );
+    }
+
+    // ── Repaint: cursor-up by previous line count, clear to end, redraw ──
+    if (lastLineCount > 0) {
+      process.stdout.write(`\x1B[${lastLineCount}A\x1B[J`);
+    }
+    const output =
+      lines.map((l) => (l === "" ? l : truncateLine(l, cols))).join("\n") + "\n";
+    process.stdout.write(output);
+    lastLineCount = lines.length;
+  }
+
+  return new Promise<string[]>((resolve) => {
+    render();
+
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    // Use a single data→keypress pipeline with no readline.Interface.
+    // readline.createInterface would register its own competing data listener
+    // and its close() call would unexpectedly pause stdin, breaking arrow keys.
+    readline.emitKeypressEvents(process.stdin);
+
+    function keypressHandler(_str: string | undefined, key: readline.Key): void {
+      if (!key) return;
+
+      if (key.ctrl && key.name === "c") {
+        cleanup();
+        process.exit(0);
+      }
+
+      const filtered = getFiltered();
+
+      if (key.name === "up") {
+        if (filtered.length > 0) {
+          cursor = cursor > 0 ? cursor - 1 : filtered.length - 1;
+        }
+        render();
+      } else if (key.name === "down") {
+        if (filtered.length > 0) {
+          cursor = cursor < filtered.length - 1 ? cursor + 1 : 0;
+        }
+        render();
+      } else if (key.name === "return" || key.name === "space") {
+        const item = filtered[cursor];
+        if (item) item.selected = !item.selected;
+        render();
+      } else if (key.name === "escape") {
+        // Clear search filter
+        search = "";
+        cursor = 0;
+        render();
+      } else if (key.ctrl && key.name === "a") {
+        // Toggle all visible items
+        const allSelected = filtered.length > 0 && filtered.every((i) => i.selected);
+        for (const item of filtered) item.selected = !allSelected;
+        render();
+      } else if (key.ctrl && key.name === "s") {
+        // Submit
+        cleanup();
+        const selected = items.filter((i) => i.selected).map((i) => i.name);
+        process.stdout.write("\n");
+        resolve(selected);
+      } else if (key.name === "backspace" || key.name === "delete") {
+        if (search.length > 0) {
+          search = search.slice(0, -1);
+          cursor = 0;
+          render();
+        }
+      } else if (_str && _str.length === 1 && !key.ctrl && !key.meta) {
+        // All printable characters (including 'a', 's') go to search
+        search += _str;
+        cursor = 0;
+        render();
+      }
+    }
+
+    function cleanup(): void {
+      showCursor();
+      process.stdin.removeListener("keypress", keypressHandler);
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+    }
+
+    process.stdin.on("keypress", keypressHandler);
+  });
+}