@kud/gtv-cli 0.1.0

package/README.md

@@ -0,0 +1,80 @@
+# gtv-cli
+
+Control your Google TV from the terminal with the Android TV Remote protocol.
+
+## Features
+
+- **Pair-on-first-run** - run `gtv`, pair once, then jump straight into the remote.
+- **Fullscreen remote** - Ink-powered alternate-screen interface centred in your terminal.
+- **One-shot controls** - send common keys like `home`, `back`, `select`, volume, and media controls directly from the CLI.
+- **Device discovery** - find Google TV devices on the local network via mDNS.
+- **Health checks** - inspect saved pairing, discovery, and protocol connectivity with `gtv status` or `gtv doctor`.
+
+## Quick Start
+
+```console
+npm install -g @kud/gtv-cli
+gtv
+```
+
+On first launch, `gtv` asks whether to pair a TV. Type the PIN shown on the TV into the terminal, press Enter, and the fullscreen remote opens automatically.
+
+## CLI Reference
+
+```console
+gtv                 # open the fullscreen remote, pairing first if needed
+gtv pair            # pair or re-pair with a Google TV
+gtv unpair          # forget the saved local pairing
+gtv status          # check config, discovery, and remote protocol connectivity
+gtv doctor          # alias for status
+gtv discover        # scan the network for Google TV devices
+gtv discover --select
+```
+
+### Remote Keys
+
+```console
+gtv home
+gtv back
+gtv up
+gtv down
+gtv left
+gtv right
+gtv select
+gtv power
+gtv play
+gtv stop
+gtv next
+gtv prev
+gtv fwd
+gtv rwd
+gtv mute
+gtv vol up
+gtv vol down
+gtv vol mute
+gtv key settings
+gtv app https://www.netflix.com/
+```
+
+## Development
+
+```console
+npm install
+npm run dev          # run the CLI from source
+npm run dev:pair     # run the pairing flow
+npm run dev:discover # scan for devices
+npm run typecheck
+npm run build
+```
+
+## Tech Stack
+
+- TypeScript
+- React + Ink
+- Commander
+- androidtv-remote
+- tsup
+
+## Notes
+
+`gtv unpair` removes the local CLI config and certificate from `~/.config/gtv/config.json`. If your TV keeps its own trusted-device entry, remove it from the TV's remote device settings as well.

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,698 @@
+#!/usr/bin/env node
+
+// src/index.tsx
+import { Command } from "commander";
+import { render } from "ink";
+import chalk4 from "chalk";
+import inquirer3 from "inquirer";
+
+// src/app.tsx
+import { useState as useState2 } from "react";
+import { Box as Box3, useApp, useInput, useStdout } from "ink";
+
+// src/hooks/use-remote.ts
+import { useEffect, useRef, useState } from "react";
+import { AndroidRemote, RemoteDirection } from "androidtv-remote";
+
+// src/lib/config.ts
+import fs from "fs";
+import path from "path";
+var CONFIG_PATH = path.join(
+  process.env["HOME"] ?? "~",
+  ".config",
+  "gtv",
+  "config.json"
+);
+var readConfig = () => {
+  if (!fs.existsSync(CONFIG_PATH)) return null;
+  return JSON.parse(fs.readFileSync(CONFIG_PATH, "utf8"));
+};
+var writeConfig = (config) => {
+  fs.mkdirSync(path.dirname(CONFIG_PATH), { recursive: true });
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n");
+};
+var deleteConfig = () => {
+  if (!fs.existsSync(CONFIG_PATH)) return false;
+  fs.unlinkSync(CONFIG_PATH);
+  return true;
+};
+
+// src/lib/remote.ts
+var stopRemote = (remote) => {
+  const typedRemote = remote;
+  const clients = [
+    typedRemote.pairingManager?.client,
+    typedRemote.remoteManager?.client
+  ].filter((client) => Boolean(client));
+  try {
+    for (const client of clients) {
+      client.removeAllListeners("close");
+      client.destroy();
+    }
+  } catch {
+    try {
+      remote.stop();
+    } catch {
+    }
+  }
+};
+
+// src/hooks/use-remote.ts
+var useRemote = () => {
+  const [state, setState] = useState({
+    connected: false,
+    powered: null,
+    volume: null,
+    currentApp: null,
+    error: null
+  });
+  const remoteRef = useRef(null);
+  useEffect(() => {
+    const config = readConfig();
+    if (!config) {
+      setState((s) => ({
+        ...s,
+        error: "No TV configured. Run `gtv pair` first."
+      }));
+      return;
+    }
+    const remote = new AndroidRemote(config.host, {
+      pairing_port: 6467,
+      remote_port: config.port ?? 6466,
+      service_name: config.name ?? "gtv-cli",
+      ...config.cert ? { cert: config.cert } : {}
+    });
+    remoteRef.current = remote;
+    remote.on(
+      "ready",
+      () => setState((s) => ({ ...s, connected: true, error: null }))
+    );
+    remote.on(
+      "powered",
+      (powered) => setState((s) => ({ ...s, powered }))
+    );
+    remote.on(
+      "volume",
+      (volume) => setState((s) => ({ ...s, volume }))
+    );
+    remote.on(
+      "current_app",
+      (app) => setState((s) => ({ ...s, currentApp: app }))
+    );
+    remote.on(
+      "error",
+      (err) => setState((s) => ({ ...s, connected: false, error: err.message }))
+    );
+    remote.on(
+      "unpaired",
+      () => setState((s) => ({
+        ...s,
+        connected: false,
+        error: "TV rejected the saved pairing. Run `gtv pair` again."
+      }))
+    );
+    remote.start().catch((err) => setState((s) => ({ ...s, error: err.message })));
+    return () => {
+      stopRemote(remote);
+    };
+  }, []);
+  const sendKey2 = (keyCode, direction = RemoteDirection.SHORT) => {
+    remoteRef.current?.sendKey(keyCode, direction);
+  };
+  return { state, sendKey: sendKey2 };
+};
+
+// src/components/status-bar.tsx
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+var APP_NAMES = {
+  "com.netflix.ninja": "Netflix",
+  "com.google.android.youtube.tv": "YouTube",
+  "com.spotify.tv.android": "Spotify",
+  "com.apple.atve.androidtv.appletv": "Apple TV+",
+  "com.disney.disneyplus": "Disney+",
+  "tv.twitch.android.app": "Twitch",
+  "com.amazon.amazonvideo.livingroom": "Prime Video",
+  "com.google.android.tvlauncher": "Home",
+  "com.google.android.leanbacklauncher": "Home",
+  "com.plexapp.android": "Plex",
+  "com.mubi": "MUBI"
+};
+var StatusBar = ({ state, lastKey }) => {
+  const appName = state.currentApp ? APP_NAMES[state.currentApp] ?? state.currentApp.split(".").pop() ?? "\u2013" : "\u2013";
+  const volDisplay = state.volume ? state.volume.muted ? "muted" : `${state.volume.level}/${state.volume.maximum}` : "\u2013";
+  return /* @__PURE__ */ jsxs(Box, { justifyContent: "space-between", marginBottom: 1, gap: 2, children: [
+    /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: "GTV" }),
+    /* @__PURE__ */ jsx(Text, { color: state.connected ? "green" : "yellow", children: state.connected ? "\u25CF connected" : "\u25CB connecting\u2026" }),
+    /* @__PURE__ */ jsxs(Text, { children: [
+      "app: ",
+      /* @__PURE__ */ jsx(Text, { color: "yellow", children: appName })
+    ] }),
+    /* @__PURE__ */ jsxs(Text, { children: [
+      "vol: ",
+      /* @__PURE__ */ jsx(Text, { color: state.volume?.muted ? "red" : "white", children: volDisplay })
+    ] }),
+    lastKey && /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+      "\u21A9 ",
+      lastKey
+    ] }),
+    state.error && /* @__PURE__ */ jsx(Text, { color: "red", children: state.error })
+  ] });
+};
+
+// src/components/remote-layout.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var Btn = ({
+  label,
+  hint,
+  width = 9
+}) => /* @__PURE__ */ jsxs2(
+  Box2,
+  {
+    borderStyle: "single",
+    width,
+    height: 3,
+    alignItems: "center",
+    justifyContent: "center",
+    children: [
+      /* @__PURE__ */ jsx2(Text2, { children: label }),
+      /* @__PURE__ */ jsx2(Text2, { color: "gray", dimColor: true, children: ` ${hint}` })
+    ]
+  }
+);
+var Row = ({ children }) => /* @__PURE__ */ jsx2(Box2, { columnGap: 1, justifyContent: "center", children });
+var RemoteLayout = () => /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", alignItems: "center", width: 58, children: [
+  /* @__PURE__ */ jsxs2(Row, { children: [
+    /* @__PURE__ */ jsx2(Btn, { label: "PWR", hint: "p" }),
+    /* @__PURE__ */ jsx2(Btn, { label: "HOME", hint: "h", width: 10 }),
+    /* @__PURE__ */ jsx2(Btn, { label: "BACK", hint: "esc", width: 10 }),
+    /* @__PURE__ */ jsx2(Btn, { label: "MENU", hint: "e", width: 10 }),
+    /* @__PURE__ */ jsx2(Btn, { label: "SEARCH", hint: "s", width: 12 })
+  ] }),
+  /* @__PURE__ */ jsxs2(Box2, { marginTop: 1, flexDirection: "column", alignItems: "center", children: [
+    /* @__PURE__ */ jsx2(Btn, { label: "UP", hint: "\u2191" }),
+    /* @__PURE__ */ jsxs2(Row, { children: [
+      /* @__PURE__ */ jsx2(Btn, { label: "LEFT", hint: "\u2190" }),
+      /* @__PURE__ */ jsx2(Btn, { label: "OK", hint: "\u21B5" }),
+      /* @__PURE__ */ jsx2(Btn, { label: "RIGHT", hint: "\u2192" })
+    ] }),
+    /* @__PURE__ */ jsx2(Btn, { label: "DOWN", hint: "\u2193" })
+  ] }),
+  /* @__PURE__ */ jsxs2(Box2, { marginTop: 1, flexDirection: "column", alignItems: "center", children: [
+    /* @__PURE__ */ jsxs2(Row, { children: [
+      /* @__PURE__ */ jsx2(Btn, { label: "PREV", hint: "," }),
+      /* @__PURE__ */ jsx2(Btn, { label: "PLAY", hint: "spc", width: 10 }),
+      /* @__PURE__ */ jsx2(Btn, { label: "STOP", hint: "." }),
+      /* @__PURE__ */ jsx2(Btn, { label: "NEXT", hint: "/" })
+    ] }),
+    /* @__PURE__ */ jsxs2(Row, { children: [
+      /* @__PURE__ */ jsx2(Btn, { label: "REW", hint: "[" }),
+      /* @__PURE__ */ jsx2(Btn, { label: "MUTE", hint: "m", width: 10 }),
+      /* @__PURE__ */ jsx2(Btn, { label: "FWD", hint: "]" })
+    ] })
+  ] }),
+  /* @__PURE__ */ jsx2(Box2, { marginTop: 1, children: /* @__PURE__ */ jsxs2(Row, { children: [
+    /* @__PURE__ */ jsx2(Btn, { label: "VOL-", hint: "-", width: 11 }),
+    /* @__PURE__ */ jsx2(Btn, { label: "VOL+", hint: "=", width: 11 })
+  ] }) }),
+  /* @__PURE__ */ jsx2(Box2, { marginTop: 1, children: /* @__PURE__ */ jsx2(Text2, { color: "gray", dimColor: true, children: "q quit" }) })
+] });
+
+// src/lib/keycodes.ts
+import { RemoteKeyCode } from "androidtv-remote";
+var KEYS = {
+  home: RemoteKeyCode.KEYCODE_HOME,
+  back: RemoteKeyCode.KEYCODE_BACK,
+  power: RemoteKeyCode.KEYCODE_POWER,
+  up: RemoteKeyCode.KEYCODE_DPAD_UP,
+  down: RemoteKeyCode.KEYCODE_DPAD_DOWN,
+  left: RemoteKeyCode.KEYCODE_DPAD_LEFT,
+  right: RemoteKeyCode.KEYCODE_DPAD_RIGHT,
+  select: RemoteKeyCode.KEYCODE_DPAD_CENTER,
+  play: RemoteKeyCode.KEYCODE_MEDIA_PLAY_PAUSE,
+  stop: RemoteKeyCode.KEYCODE_MEDIA_STOP,
+  next: RemoteKeyCode.KEYCODE_MEDIA_NEXT,
+  prev: RemoteKeyCode.KEYCODE_MEDIA_PREVIOUS,
+  fwd: RemoteKeyCode.KEYCODE_MEDIA_FAST_FORWARD,
+  rwd: RemoteKeyCode.KEYCODE_MEDIA_REWIND,
+  "vol-up": RemoteKeyCode.KEYCODE_VOLUME_UP,
+  "vol-down": RemoteKeyCode.KEYCODE_VOLUME_DOWN,
+  mute: RemoteKeyCode.KEYCODE_VOLUME_MUTE,
+  menu: RemoteKeyCode.KEYCODE_MENU,
+  search: RemoteKeyCode.KEYCODE_SEARCH,
+  sleep: RemoteKeyCode.KEYCODE_SLEEP,
+  wakeup: RemoteKeyCode.KEYCODE_WAKEUP,
+  input: RemoteKeyCode.KEYCODE_TV_INPUT,
+  enter: RemoteKeyCode.KEYCODE_ENTER,
+  "channel-up": RemoteKeyCode.KEYCODE_CHANNEL_UP,
+  "channel-down": RemoteKeyCode.KEYCODE_CHANNEL_DOWN,
+  info: RemoteKeyCode.KEYCODE_INFO,
+  guide: RemoteKeyCode.KEYCODE_GUIDE,
+  settings: RemoteKeyCode.KEYCODE_SETTINGS
+};
+
+// src/app.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var CHAR_MAP = {
+  " ": "play",
+  h: "home",
+  p: "power",
+  m: "mute",
+  e: "menu",
+  s: "search",
+  ".": "stop",
+  ",": "prev",
+  "/": "next",
+  "[": "rwd",
+  "]": "fwd",
+  "=": "vol-up",
+  "-": "vol-down"
+};
+var App = () => {
+  const [lastKey, setLastKey] = useState2("");
+  const { exit } = useApp();
+  const { stdout } = useStdout();
+  const { state, sendKey: sendKey2 } = useRemote();
+  useInput((input, key2) => {
+    if (input === "q" || key2.ctrl && input === "c") {
+      exit();
+      return;
+    }
+    const keyName = key2.upArrow ? "up" : key2.downArrow ? "down" : key2.leftArrow ? "left" : key2.rightArrow ? "right" : key2.return ? "select" : key2.escape || key2.backspace ? "back" : CHAR_MAP[input] ?? null;
+    if (!keyName) return;
+    const keyCode = KEYS[keyName];
+    if (!keyCode) return;
+    setLastKey(keyName);
+    sendKey2(keyCode);
+  });
+  return /* @__PURE__ */ jsxs3(
+    Box3,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: "blue",
+      width: stdout.columns,
+      height: stdout.rows,
+      paddingX: 2,
+      paddingY: 1,
+      children: [
+        /* @__PURE__ */ jsx3(StatusBar, { state, lastKey }),
+        /* @__PURE__ */ jsx3(Box3, { flexGrow: 1, alignItems: "center", justifyContent: "center", children: /* @__PURE__ */ jsx3(RemoteLayout, {}) })
+      ]
+    }
+  );
+};
+
+// src/commands/pair.ts
+import { AndroidRemote as AndroidRemote2 } from "androidtv-remote";
+import inquirer2 from "inquirer";
+import ora2 from "ora";
+import chalk2 from "chalk";
+
+// src/commands/discover.ts
+import { spawn } from "child_process";
+import dns from "dns/promises";
+import ora from "ora";
+import chalk from "chalk";
+import inquirer from "inquirer";
+var browseServices = (timeout) => new Promise((resolve) => {
+  const names = [];
+  const proc = spawn("dns-sd", ["-B", "_androidtvremote2._tcp", "local"]);
+  proc.stdout.on("data", (data) => {
+    for (const line of data.toString().split("\n")) {
+      const match = line.match(
+        /Add\s+\d+\s+\d+\s+\S+\s+_androidtvremote2\._tcp\.\s+(.+)$/
+      );
+      if (match) names.push(match[1].trim());
+    }
+  });
+  setTimeout(() => {
+    proc.kill();
+    resolve([...new Set(names)]);
+  }, timeout);
+});
+var resolveService = (name) => new Promise((resolve) => {
+  const proc = spawn("dns-sd", [
+    "-L",
+    name,
+    "_androidtvremote2._tcp",
+    "local"
+  ]);
+  let output = "";
+  proc.stdout.on("data", (data) => {
+    output += data.toString();
+    const match = output.match(/can be reached at ([^:]+):(\d+)/);
+    if (match) {
+      proc.kill();
+      resolve({ hostname: match[1], port: parseInt(match[2], 10) });
+    }
+  });
+  setTimeout(() => {
+    proc.kill();
+    resolve(null);
+  }, 3e3);
+});
+var discover = async (opts = {}) => {
+  const timeout = opts.timeout ?? 5e3;
+  const spinner = opts.quiet ? null : ora("Scanning for Google TV devices\u2026").start();
+  const names = await browseServices(timeout);
+  if (names.length === 0) {
+    spinner?.fail("No Google TV devices found on the network.");
+    return [];
+  }
+  if (spinner) spinner.text = `Resolving ${names.length} device(s)\u2026`;
+  const resolved = await Promise.all(
+    names.map(async (name) => {
+      const service = await resolveService(name);
+      if (!service) return null;
+      const { address } = await dns.lookup(service.hostname, { family: 4 });
+      return {
+        name,
+        host: address,
+        hostname: service.hostname,
+        port: service.port
+      };
+    })
+  );
+  const found = resolved.filter((d) => d !== null);
+  if (found.length === 0) {
+    spinner?.fail("Found devices but could not resolve their addresses.");
+    return [];
+  }
+  if (spinner) {
+    spinner.succeed(`Found ${found.length} device(s):`);
+    found.forEach((d) => {
+      process.stdout.write(
+        `  ${chalk.cyan(d.name)}  ${chalk.gray(`${d.host}:${d.port}`)}
+`
+      );
+    });
+  }
+  if (opts.select) {
+    const existing = readConfig();
+    const selected = found.length === 1 ? found[0] : await inquirer.prompt([
+      {
+        type: "list",
+        name: "device",
+        message: "Which TV do you want to use?",
+        choices: found.map((d) => ({
+          name: `${d.name}  (${d.host})`,
+          value: d.host
+        })),
+        default: existing?.host
+      }
+    ]).then(({ device }) => found.find((d) => d.host === device));
+    writeConfig({ ...existing, host: selected.host, name: selected.name });
+    process.stdout.write(
+      chalk.green(`\u2714 TV set to ${selected.name} (${selected.host})
+`)
+    );
+  }
+  return found;
+};
+
+// src/commands/pair.ts
+var pairWithDevice = async (device) => {
+  const spinner = ora2("Connecting to TV\u2026").start();
+  const remote = new AndroidRemote2(device.hostname, {
+    pairing_port: 6467,
+    service_name: "gtv-cli"
+  });
+  await new Promise((resolve, reject) => {
+    const fail2 = (msg) => {
+      spinner.fail(msg);
+      try {
+        stopRemote(remote);
+      } catch {
+      }
+      reject(new Error(msg));
+    };
+    remote.on("secret", async () => {
+      spinner.stop();
+      process.stdout.write(
+        chalk2.cyan(
+          "A PIN is now shown on your TV. Type that PIN here in the terminal, then press Enter.\n"
+        )
+      );
+      const { pin } = await inquirer2.prompt([
+        { type: "input", name: "pin", message: "TV PIN:" }
+      ]);
+      remote.sendCode(pin);
+      spinner.start("Pairing\u2026");
+    });
+    remote.on("ready", () => {
+      const cert = remote.getCertificate();
+      writeConfig({
+        host: device.host,
+        port: device.port,
+        name: device.name ?? "gtv-cli",
+        cert
+      });
+      spinner.succeed("Paired! Config saved to ~/.config/gtv/config.json");
+      try {
+        stopRemote(remote);
+      } catch {
+      }
+      resolve();
+    });
+    remote.on("unpaired", () => fail2("TV rejected the pairing request."));
+    remote.on("error", (err) => fail2(err.message));
+    remote.start().then((paired) => {
+      if (!paired)
+        fail2(
+          "Could not connect to TV. Check that 'Remote Device Settings \u2192 Control remotely' is enabled."
+        );
+    }).catch((err) => fail2(err.message));
+  });
+};
+var pair = async () => {
+  const devices = await discover({ timeout: 4e3 });
+  if (devices.length === 0) {
+    process.stdout.write(
+      chalk2.yellow("No devices found via mDNS. Enter IP manually.\n")
+    );
+    const { host } = await inquirer2.prompt([
+      { type: "input", name: "host", message: "TV IP address:" }
+    ]);
+    await pairWithDevice({ host, hostname: host });
+    return;
+  }
+  if (devices.length === 1) {
+    await pairWithDevice(devices[0]);
+    return;
+  }
+  const choices = [
+    ...devices.map((d) => ({
+      name: `${d.name}  (${d.host})`,
+      value: d
+    })),
+    { name: "Enter IP manually", value: null }
+  ];
+  const { device } = await inquirer2.prompt(
+    [
+      {
+        type: "list",
+        name: "device",
+        message: "Which TV to pair with?",
+        choices
+      }
+    ]
+  );
+  if (!device) {
+    const { host } = await inquirer2.prompt([
+      { type: "input", name: "host", message: "TV IP address:" }
+    ]);
+    await pairWithDevice({ host, hostname: host });
+    return;
+  }
+  await pairWithDevice(device);
+};
+
+// src/commands/status.ts
+import chalk3 from "chalk";
+import ora3 from "ora";
+
+// src/lib/client.ts
+import { AndroidRemote as AndroidRemote3, RemoteDirection as RemoteDirection2 } from "androidtv-remote";
+var CONNECT_TIMEOUT_MS = 8e3;
+var connect = () => {
+  const config = readConfig();
+  if (!config) throw new Error("No TV configured. Run `gtv pair` first.");
+  const remote = new AndroidRemote3(config.host, {
+    pairing_port: 6467,
+    remote_port: config.port ?? 6466,
+    service_name: config.name ?? "gtv-cli",
+    ...config.cert ? { cert: config.cert } : {}
+  });
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      stopRemote(remote);
+      reject(
+        new Error(
+          `Timed out connecting to ${config.host}. Run \`gtv pair\` again if the TV is online.`
+        )
+      );
+    }, CONNECT_TIMEOUT_MS);
+    const fail2 = (error) => {
+      clearTimeout(timeout);
+      stopRemote(remote);
+      reject(error);
+    };
+    remote.once("ready", () => {
+      clearTimeout(timeout);
+      resolve(remote);
+    });
+    remote.once(
+      "unpaired",
+      () => fail2(new Error("TV rejected the saved pairing. Run `gtv pair` again."))
+    );
+    remote.once("error", fail2);
+    remote.start().then((started) => {
+      if (!started)
+        fail2(
+          new Error(
+            `Could not connect to ${config.host}. Check that remote control is enabled on the TV.`
+          )
+        );
+    }).catch(fail2);
+  });
+};
+var withRemote = async (fn) => {
+  const remote = await connect();
+  try {
+    fn(remote);
+    await new Promise((r) => setTimeout(r, 300));
+  } finally {
+    stopRemote(remote);
+  }
+};
+var sendKey = (keyCode) => withRemote((remote) => {
+  remote.sendKey(keyCode, RemoteDirection2.SHORT);
+});
+var launchApp = (deeplink) => withRemote((remote) => {
+  remote.sendAppLink(deeplink);
+});
+
+// src/commands/status.ts
+var ok = (text) => `${chalk3.green("\u2714")} ${text}
+`;
+var warn = (text) => `${chalk3.yellow("!")} ${text}
+`;
+var fail = (text) => `${chalk3.red("\u2716")} ${text}
+`;
+var status = async () => {
+  process.stdout.write(chalk3.bold("Google TV status\n\n"));
+  const config = readConfig();
+  if (!config) {
+    process.stdout.write(fail(`No saved pairing at ${CONFIG_PATH}`));
+    process.stdout.write(warn("Run `gtv` to pair and open the remote."));
+    return;
+  }
+  process.stdout.write(ok(`Config: ${config.name ?? "Google TV"} at ${config.host}:${config.port ?? 6466}`));
+  process.stdout.write(
+    config.cert ? ok("Pairing certificate: present") : fail("Pairing certificate: missing")
+  );
+  const discoverySpinner = ora3("Discovering Google TV devices\u2026").start();
+  const devices = await discover({ timeout: 2500, quiet: true });
+  const matchingDevice = devices.find((device) => device.host === config.host);
+  if (matchingDevice) {
+    discoverySpinner.succeed(
+      `Discovery: found ${matchingDevice.name} at ${matchingDevice.host}:${matchingDevice.port}`
+    );
+  } else if (devices.length > 0) {
+    discoverySpinner.warn(
+      `Discovery: found ${devices.length} Google TV device(s), but not ${config.host}`
+    );
+  } else {
+    discoverySpinner.warn("Discovery: no Google TV devices found via mDNS");
+  }
+  const connectSpinner = ora3("Testing Android TV Remote protocol\u2026").start();
+  try {
+    const remote = await connect();
+    stopRemote(remote);
+    connectSpinner.succeed("Remote protocol: connected");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    connectSpinner.fail(`Remote protocol: ${message}`);
+    process.exitCode = 1;
+  }
+};
+
+// src/index.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+var program = new Command().name("gtv").description("Control your Google TV").version("0.1.0");
+program.command("pair").description("Pair or re-pair with your Google TV").action(pair);
+program.command("unpair").description("Forget the saved Google TV pairing").action(() => {
+  const removed = deleteConfig();
+  process.stdout.write(
+    removed ? chalk4.green(`Unpaired. Removed ${CONFIG_PATH}
+`) : chalk4.yellow("No saved Google TV pairing found.\n")
+  );
+});
+program.command("discover").description("Scan network for Google TV devices").option("-s, --select", "Select and save a TV as default").option("-t, --timeout <ms>", "Scan duration in ms", "5000").action(async (opts) => {
+  await discover({ select: opts.select, timeout: parseInt(opts.timeout, 10) });
+});
+program.command("status").description("Check Google TV pairing and connectivity").action(status);
+program.command("doctor").description("Alias for status").action(status);
+var key = (name) => async () => {
+  const k = KEYS[name];
+  if (!k) throw new Error(`Unknown key: ${name}`);
+  await sendKey(k);
+};
+program.command("home").description("Go home").action(key("home"));
+program.command("back").description("Go back").action(key("back"));
+program.command("up").description("D-pad up").action(key("up"));
+program.command("down").description("D-pad down").action(key("down"));
+program.command("left").description("D-pad left").action(key("left"));
+program.command("right").description("D-pad right").action(key("right"));
+program.command("select").description("Select / OK").action(key("select"));
+program.command("power").description("Toggle power").action(key("power"));
+program.command("play").description("Play / Pause").action(key("play"));
+program.command("stop").description("Stop").action(key("stop"));
+program.command("next").description("Next track").action(key("next"));
+program.command("prev").description("Previous track").action(key("prev"));
+program.command("fwd").description("Fast forward").action(key("fwd"));
+program.command("rwd").description("Rewind").action(key("rwd"));
+program.command("mute").description("Toggle mute").action(key("mute"));
+program.command("menu").description("Open menu").action(key("menu"));
+program.command("search").description("Open search").action(key("search"));
+program.command("input").description("Switch input").action(key("input"));
+program.command("sleep").description("Sleep").action(key("sleep"));
+program.command("wakeup").description("Wake up").action(key("wakeup"));
+program.command("vol").argument("<action>", "up, down, or mute").description("Volume control").action(async (action) => {
+  const keyName = action === "up" ? "vol-up" : action === "down" ? "vol-down" : "mute";
+  await key(keyName)();
+});
+program.command("app").argument("<deeplink>", "App deep link URL (e.g. https://www.netflix.com/)").description("Launch an app by deep link").action(launchApp);
+program.command("key").argument("<name>", "Key name").description(`Send a key by name. Available: ${Object.keys(KEYS).join(", ")}`).action(async (name) => {
+  const keyCode = KEYS[name];
+  if (!keyCode) {
+    process.stderr.write(
+      `${chalk4.red("error:")} Unknown key "${name}". Available: ${Object.keys(KEYS).join(", ")}
+`
+    );
+    process.exit(1);
+  }
+  await sendKey(keyCode);
+});
+var ensurePaired = async () => {
+  if (readConfig()) return true;
+  const { shouldPair } = await inquirer3.prompt([
+    {
+      type: "confirm",
+      name: "shouldPair",
+      message: "No Google TV is paired yet. Pair one now?",
+      default: true
+    }
+  ]);
+  if (!shouldPair) return false;
+  await pair();
+  return Boolean(readConfig());
+};
+if (process.argv.length <= 2) {
+  if (!await ensurePaired()) process.exit(0);
+  render(/* @__PURE__ */ jsx4(App, {}), { alternateScreen: true });
+} else {
+  await program.parseAsync(process.argv);
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@kud/gtv-cli",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Control your Google TV from the CLI",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kud/gtv-cli.git"
+  },
+  "bin": {
+    "gtv": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "dev": "tsx src/index.tsx",
+    "dev:pair": "tsx src/index.tsx pair",
+    "dev:discover": "tsx src/index.tsx discover --select",
+    "dev:tui": "tsx src/index.tsx",
+    "build": "tsup src/index.tsx --format esm --dts",
+    "build:watch": "tsup src/index.tsx --format esm --dts --watch",
+    "clean": "rm -rf dist",
+    "typecheck": "tsc --noEmit",
+    "link": "npm run build && npm link",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "androidtv-remote": "^1.0.10",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "ink": "7.1.0",
+    "ink-spinner": "^5.0.0",
+    "inquirer": "^13.3.2",
+    "ora": "^9.3.0",
+    "react": "^19.2.4"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "@types/react": "^19.2.14",
+    "tsup": "^8.5.1",
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.2"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  }
+}