lystn-cli 0.2.0 → 0.3.2

package/README.md

@@ -1,35 +1,50 @@
-# lystn (npm package)
+# lystn-cli
 
-Listen to AI coding assistants instead of reading them. This is the npm
-distribution of the [Lystn](https://github.com/burakayener/Lystn) CLI.
+Listen to your AI coding assistant. **Lystn** speaks the replies from **Claude
+Code** and **Codex** aloud — short spoken summaries so you can keep moving
+instead of reading walls of text.
+
+## Install
 
 ```bash
-npm install -g lystn-cli     # or: pnpm add -g lystn-cli
-lystn config set server https://api.lystn.space
-lystn config set api_key <your key>
-lystn install            # wires the Claude Code hook automatically
-lystn test               # you should hear a voice
+npm install -g lystn-cli
+lystn wire        # wires Claude Code + Codex
+lystn login       # sign in (Google)
 ```
 
-## How this package works
+That's it
+
+## Commands
+
+- `lystn wire` / `lystn unwire` — wire (or remove) the hook for Claude Code and Codex
+- `lystn login` / `lystn logout` — sign in / clear your key
+- `lystn config show` / `lystn config set <key> <value>`
+- `lystn mute` / `lystn unmute` · `lystn speed <0.5–3.0>` · `lystn volume <0–100>`
+
+Learn more: https://lystn.space
+
+---
 
-The Lystn CLI is Python. This npm package is a thin launcher: on install
-(or on first run) it creates a private Python virtualenv inside the
-package directory and installs the matching `lystn` release from PyPI
-into it. Nothing touches your global Python or site-packages.
+## For maintainers — how this package works
 
-- Requires **Python 3.10+** on the machine (macOS ships it; on Windows
-  install from python.org with "Add to PATH").
-- **pnpm users:** pnpm v10+ skips install scripts by default — that's
-  fine; the launcher sets itself up on the first `lystn` command instead.
-- Uninstall with `npm uninstall -g lystn-cli` (the venv lives inside the
-  package dir and is removed with it). Run `lystn uninstall` first to
-  remove the Claude Code hooks.
+This npm package is a thin launcher. On install, `scripts/postinstall.js`
+downloads the matching prebuilt **Rust** binary from this repo's GitHub Release
+(`lystn-<target>`), and `bin/lystn.js` runs it.
+
+**Repo layout** (this is the public `lystn-cli` repo):
+
+```
+lystn-cli/
+├── cli-rs/                     # Rust source (the actual client)
+├── bin/lystn.js                # launcher → runs the downloaded binary
+├── scripts/postinstall.js      # downloads the binary for this OS
+├── package.json
+└── .github/workflows/release.yml   # builds + uploads the binaries on a tag
+```
 
-## Releasing (maintainers)
+**Cutting a release**
 
-1. Publish the new version to PyPI first (see `docs/ops/INSTALL-BREW.md`
-   section 1 — same artifact serves brew and npm).
-2. Bump `version` in `packaging/npm/package.json` to the **same** version
-   (the bootstrap pins `lystn==<version>` from PyPI).
-3. `cd packaging/npm && npm publish`.
+1. Bump `version` in `package.json` (e.g. `0.3.0`).
+2. `git tag v0.3.0 && git push --tags` → CI builds all 4 binaries and attaches
+   them to the `v0.3.0` Release.
+3. `npm publish` (the postinstall pulls from the `v0.3.0` Release).

package/bin/lystn.js

@@ -1,28 +1,37 @@
-#!/usr/bin/env node
-/*
- * `lystn` launcher for the npm package.
- *
- * Delegates every invocation to the real Python CLI living in the
- * package-private venv (.venv/). If the venv is missing (e.g. pnpm
- * skipped postinstall), it bootstraps on the spot, then runs the command.
- */
-"use strict";
-
-const { spawnSync } = require("child_process");
-const fs = require("fs");
-const path = require("path");
-
-const { bootstrap, venvLystn } = require(path.join(
-  __dirname,
-  "..",
-  "scripts",
-  "bootstrap.js"
-));
-
-const exe = venvLystn();
-if (!fs.existsSync(exe) && !bootstrap()) {
-  process.exit(1);
-}
-
-const res = spawnSync(exe, process.argv.slice(2), { stdio: "inherit" });
-process.exit(res.status === null ? 1 : res.status);
+#!/usr/bin/env node
+/*
+ * `lystn` launcher for the npm package.
+ *
+ * Runs the prebuilt Rust binary downloaded by scripts/postinstall.js. If it's
+ * missing (e.g. pnpm skipped postinstall), fetch it on the spot, then exec.
+ */
+"use strict";
+
+const { spawnSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+
+const { download, binaryPath } = require(path.join(
+  __dirname,
+  "..",
+  "scripts",
+  "postinstall.js"
+));
+
+async function main() {
+  const exe = binaryPath();
+  if (!fs.existsSync(exe)) {
+    const ok = await download();
+    if (!ok || !fs.existsSync(exe)) {
+      console.error(
+        "[lystn] The lystn binary isn't installed and couldn't be downloaded.\n" +
+          "[lystn] Check your network and run any `lystn` command again."
+      );
+      process.exit(1);
+    }
+  }
+  const res = spawnSync(exe, process.argv.slice(2), { stdio: "inherit" });
+  process.exit(res.status === null ? 1 : res.status);
+}
+
+main();

package/package.json

@@ -1,30 +1,27 @@
-{
-  "name": "lystn-cli",
-  "version": "0.2.0",
-  "description": "Listen to AI coding assistant responses through your speakers.",
-  "homepage": "https://github.com/burakayener/Lystn",
-  "license": "SEE LICENSE IN LICENSE",
-  "bin": {
-    "lystn": "bin/lystn.js"
-  },
-  "scripts": {
-    "postinstall": "node scripts/bootstrap.js || exit 0"
-  },
-  "files": [
-    "bin/",
-    "scripts/",
-    "README.md"
-  ],
-  "engines": {
-    "node": ">=18"
-  },
-  "keywords": [
-    "tts",
-    "claude-code",
-    "codex",
-    "ai-agents",
-    "voice",
-    "accessibility",
-    "adhd"
-  ]
-}
+{
+  "name": "lystn-cli",
+  "version": "0.3.2",
+  "description": "Listen to your AI coding assistant — speaks Claude Code & Codex replies aloud.",
+  "homepage": "https://lystn.space",
+  "repository": { "type": "git", "url": "https://github.com/burakayener/lystn-cli" },
+  "license": "Apache-2.0",
+  "bin": { "lystn": "bin/lystn.js" },
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js || exit 0"
+  },
+  "files": [
+    "bin/",
+    "scripts/",
+    "README.md"
+  ],
+  "engines": { "node": ">=18" },
+  "keywords": [
+    "tts",
+    "claude-code",
+    "codex",
+    "ai-agents",
+    "voice",
+    "accessibility",
+    "adhd"
+  ]
+}

package/scripts/postinstall.js

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+/*
+ * Download the prebuilt Lystn (Rust) binary for this OS/arch.
+ *
+ * Runs at `npm install -g lystn-cli` (postinstall) AND lazily from bin/lystn.js
+ * if the binary is missing (pnpm v10+ skips postinstall by default, so the
+ * launcher must be able to self-fetch on first run).
+ *
+ * No Python, no compiler — just downloads the matching binary from the
+ * lystn-cli GitHub Release that matches this package version.
+ */
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const https = require("https");
+
+const PKG_ROOT = path.join(__dirname, "..");
+const VERSION = require(path.join(PKG_ROOT, "package.json")).version;
+const REPO = "burakayener/lystn-cli";
+const BIN_DIR = path.join(PKG_ROOT, "binary");
+
+// Map Node's platform/arch to the Rust target triple used in the release asset
+// names (see .github/workflows/release.yml). `lystn-<triple>` (+ .exe on Windows).
+function target() {
+  const p = process.platform;
+  const a = process.arch;
+  if (p === "win32" && a === "x64") return { asset: "lystn-x86_64-pc-windows-msvc.exe", ext: ".exe" };
+  // macOS: Apple Silicon only. Serve the arm64 binary for any darwin — an
+  // M-series Mac running an x64 Node under Rosetta still runs arm64 natively.
+  if (p === "darwin") return { asset: "lystn-aarch64-apple-darwin", ext: "" };
+  if (p === "linux" && a === "x64") return { asset: "lystn-x86_64-unknown-linux-gnu", ext: "" };
+  if (p === "linux" && a === "arm64") return { asset: "lystn-aarch64-unknown-linux-gnu", ext: "" };
+  return null;
+}
+
+function binaryPath() {
+  const ext = process.platform === "win32" ? ".exe" : "";
+  return path.join(BIN_DIR, "lystn" + ext);
+}
+
+// GET with redirect following (GitHub release assets 302 to a CDN host).
+function get(url, cb, redirects) {
+  redirects = redirects || 0;
+  if (redirects > 10) return cb(new Error("too many redirects"));
+  https
+    .get(url, { headers: { "User-Agent": "lystn-cli-installer" } }, (res) => {
+      if ([301, 302, 303, 307, 308].includes(res.statusCode) && res.headers.location) {
+        res.resume();
+        return get(res.headers.location, cb, redirects + 1);
+      }
+      if (res.statusCode !== 200) {
+        res.resume();
+        return cb(new Error("HTTP " + res.statusCode + " for " + url));
+      }
+      cb(null, res);
+    })
+    .on("error", cb);
+}
+
+function download() {
+  return new Promise((resolve) => {
+    const t = target();
+    if (!t) {
+      console.error("[lystn] Unsupported platform: " + process.platform + "/" + process.arch);
+      return resolve(false);
+    }
+    const url = `https://github.com/${REPO}/releases/download/v${VERSION}/${t.asset}`;
+    const dest = binaryPath();
+    const tmp = dest + ".download";
+    try {
+      fs.mkdirSync(BIN_DIR, { recursive: true });
+    } catch (_) {}
+    console.error("[lystn] Downloading the speech engine for your system ...");
+    get(url, (err, res) => {
+      if (err) {
+        console.error("[lystn] Could not download the binary: " + err.message);
+        return resolve(false);
+      }
+      const file = fs.createWriteStream(tmp);
+      res.pipe(file);
+      file.on("finish", () =>
+        file.close(() => {
+          try {
+            fs.renameSync(tmp, dest);
+            if (process.platform !== "win32") fs.chmodSync(dest, 0o755);
+            resolve(true);
+          } catch (e) {
+            console.error("[lystn] Could not install the binary: " + e.message);
+            resolve(false);
+          }
+        })
+      );
+      file.on("error", (e) => {
+        console.error("[lystn] Download failed: " + e.message);
+        try {
+          fs.unlinkSync(tmp);
+        } catch (_) {}
+        resolve(false);
+      });
+    });
+  });
+}
+
+module.exports = { download, binaryPath };
+
+if (require.main === module) {
+  // Postinstall: NEVER fail the npm install — the launcher self-fetches later.
+  download().then((ok) => {
+    if (ok) console.error("[lystn] Ready. Run: lystn install && lystn login");
+    process.exit(0);
+  });
+}

package/scripts/bootstrap.js

@@ -1,129 +0,0 @@
-#!/usr/bin/env node
-/*
- * Bootstrap the private Python environment for the lystn npm package.
- *
- * Runs at `npm install -g lystn-cli` (postinstall) AND lazily from bin/lystn.js
- * if the venv is missing — pnpm v10+ skips postinstall scripts by default,
- * so the launcher must be able to self-bootstrap on first run.
- *
- * What it does:
- *   1. Find a Python >= 3.10 (python3.13..3.10, python3, python, py -3).
- *   2. Create a venv inside the package directory (.venv/).
- *   3. pip install lystn==<version from package.json> into it.
- */
-"use strict";
-
-const { spawnSync } = require("child_process");
-const fs = require("fs");
-const path = require("path");
-
-const PKG_ROOT = path.join(__dirname, "..");
-const VENV_DIR = path.join(PKG_ROOT, ".venv");
-const IS_WIN = process.platform === "win32";
-const PYPI_VERSION = require(path.join(PKG_ROOT, "package.json")).version;
-
-function run(cmd, args, opts) {
-  return spawnSync(cmd, args, { encoding: "utf-8", ...opts });
-}
-
-function pythonVersionOk(exe, viaLauncherArgs) {
-  const args = (viaLauncherArgs || []).concat([
-    "-c",
-    "import sys; print('%d.%d' % sys.version_info[:2])",
-  ]);
-  const res = run(exe, args);
-  if (res.status !== 0 || !res.stdout) return false;
-  const [maj, min] = res.stdout.trim().split(".").map(Number);
-  return maj === 3 && min >= 10;
-}
-
-function findPython() {
-  const candidates = IS_WIN
-    ? [
-        ["py", ["-3"]],
-        ["python", []],
-        ["python3", []],
-      ]
-    : [
-        ["python3.13", []],
-        ["python3.12", []],
-        ["python3.11", []],
-        ["python3.10", []],
-        ["python3", []],
-        ["python", []],
-      ];
-  for (const [exe, extraArgs] of candidates) {
-    if (pythonVersionOk(exe, extraArgs)) return { exe, extraArgs };
-  }
-  return null;
-}
-
-function venvPython() {
-  return IS_WIN
-    ? path.join(VENV_DIR, "Scripts", "python.exe")
-    : path.join(VENV_DIR, "bin", "python");
-}
-
-function venvLystn() {
-  return IS_WIN
-    ? path.join(VENV_DIR, "Scripts", "lystn.exe")
-    : path.join(VENV_DIR, "bin", "lystn");
-}
-
-function bootstrap() {
-  if (fs.existsSync(venvLystn())) return true; // already done
-
-  const py = findPython();
-  if (!py) {
-    console.error(
-      "[lystn] Python 3.10+ was not found on this system.\n" +
-        "[lystn] The lystn CLI runs on Python. Install it from:\n" +
-        "[lystn]   macOS:   brew install python  (or use: brew install burakayener/lystn/lystn)\n" +
-        "[lystn]   Windows: https://www.python.org/downloads/ (check 'Add to PATH')\n" +
-        "[lystn]   Linux:   your package manager, e.g. apt install python3\n" +
-        "[lystn] Then run any `lystn` command again — setup resumes automatically."
-    );
-    return false;
-  }
-
-  console.error("[lystn] First-run setup: preparing the speech engine ...");
-  let res = run(py.exe, py.extraArgs.concat(["-m", "venv", VENV_DIR]), {
-    stdio: ["ignore", "inherit", "inherit"],
-  });
-  if (res.status !== 0) {
-    console.error("[lystn] Failed to create a Python environment.");
-    return false;
-  }
-
-  res = run(
-    venvPython(),
-    ["-m", "pip", "install", "--quiet", `lystn==${PYPI_VERSION}`],
-    { stdio: ["ignore", "inherit", "inherit"] }
-  );
-  if (res.status !== 0 || !fs.existsSync(venvLystn())) {
-    console.error(
-      "[lystn] Failed to install the lystn engine from PyPI.\n" +
-        "[lystn] Check your network and try again with any `lystn` command."
-    );
-    // Leave no half-built venv behind so the next run retries cleanly.
-    try {
-      fs.rmSync(VENV_DIR, { recursive: true, force: true });
-    } catch (_) {}
-    return false;
-  }
-
-  console.error("[lystn] Ready. Try: lystn config set api_key <key> && lystn test");
-  return true;
-}
-
-module.exports = { bootstrap, venvLystn };
-
-if (require.main === module) {
-  // Postinstall context: never fail the npm install — the launcher
-  // self-bootstraps later if this didn't complete.
-  try {
-    bootstrap();
-  } catch (err) {
-    console.error(`[lystn] Setup deferred to first run (${err.message}).`);
-  }
-}