@obedience-corp/tcount 0.3.0

package/README.md

@@ -0,0 +1,34 @@
+# @obedience-corp/tcount
+
+npm distribution wrapper for the `tcount` CLI — a fast, zero-network token counter for LLM workflows.
+
+This package provides the `tcount` command via npm / pnpm / bun.
+
+## Installation
+
+```bash
+npm install -g @obedience-corp/tcount
+# or
+pnpm add -g @obedience-corp/tcount
+# or
+bun add -g @obedience-corp/tcount
+```
+
+After installation, the `tcount` command will be available in your PATH.
+
+## How it works
+
+The package is a lightweight wrapper. On first `postinstall` (or when the binary is missing), it downloads the matching platform-specific release archive from the [tcount GitHub releases](https://github.com/lancekrogers/tcount/releases) and verifies the checksum.
+
+This keeps the npm package small while ensuring you always get the official, signed-off binaries produced by the Go release process.
+
+## Supported Platforms
+
+- macOS (Intel + Apple Silicon)
+- Linux (x64 + arm64)
+
+Windows users: use `go install github.com/lancekrogers/tcount/cmd/tcount@latest` or download the `.zip` from the releases page.
+
+## License
+
+MIT

package/bin/tcount

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+const { runBinary } = require("../lib/run");
+
+runBinary("tcount").catch((err) => {
+  console.error(`Failed to run tcount: ${err.message}`);
+  process.exit(1);
+});

package/install.js

@@ -0,0 +1,257 @@
+#!/usr/bin/env node
+
+const crypto = require("crypto");
+const fs = require("fs");
+const https = require("https");
+const path = require("path");
+const { spawnSync } = require("child_process");
+
+const REPO = "lancekrogers/tcount";
+const BINARY = "tcount";
+const DOWNLOAD_ATTEMPTS = 3;
+const DOWNLOAD_TIMEOUT_MS = 60_000;
+const RETRY_BASE_DELAY_MS = 750;
+
+const PLATFORM_MAP = {
+  darwin: "darwin",
+  linux: "linux",
+};
+
+const ARCH_MAP = {
+  x64: "amd64",
+  arm64: "arm64",
+};
+
+function packageVersion() {
+  const packageJSON = require("./package.json");
+  return packageJSON.version;
+}
+
+function releaseTag(version = packageVersion()) {
+  return `v${version}`;
+}
+
+function targetForCurrentPlatform() {
+  const platform = PLATFORM_MAP[process.platform];
+  const arch = ARCH_MAP[process.arch];
+
+  if (!platform || !arch) {
+    throw new Error(
+      `Unsupported platform: ${process.platform}/${process.arch}. @obedience-corp/tcount currently supports macOS and Linux on x64/arm64. Use 'go install' or download binaries from https://github.com/lancekrogers/tcount/releases for other platforms.`,
+    );
+  }
+
+  return `${platform}_${arch}`;
+}
+
+function archiveName(version = packageVersion()) {
+  return `tcount_${version}_${targetForCurrentPlatform()}.tar.gz`;
+}
+
+function releaseURL(asset, version = packageVersion()) {
+  return `https://github.com/${REPO}/releases/download/${releaseTag(version)}/${asset}`;
+}
+
+function binaryPath() {
+  // We store the real binary as tcount-bin (unix) so the small launcher in bin/tcount can find it.
+  return path.join(__dirname, "bin", "tcount-bin");
+}
+
+function haveBinary() {
+  return fs.existsSync(binaryPath());
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function downloadOnce(url, dest) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+
+    const fail = (err) => {
+      if (settled) return;
+      settled = true;
+      fs.rmSync(dest, { force: true });
+      reject(err);
+    };
+
+    const done = () => {
+      if (settled) return;
+      settled = true;
+      resolve();
+    };
+
+    const follow = (nextURL, redirects = 0) => {
+      if (redirects > 10) {
+        fail(new Error("too many redirects"));
+        return;
+      }
+
+      const request = https
+        .get(nextURL, (response) => {
+          if (
+            response.statusCode >= 300 &&
+            response.statusCode < 400 &&
+            response.headers.location
+          ) {
+            response.resume();
+            follow(response.headers.location, redirects + 1);
+            return;
+          }
+
+          if (response.statusCode !== 200) {
+            response.resume();
+            fail(new Error(`failed to download ${url}: HTTP ${response.statusCode}`));
+            return;
+          }
+
+          const file = fs.createWriteStream(dest);
+          response.pipe(file);
+          file.on("finish", () => {
+            file.close(done);
+          });
+          file.on("error", fail);
+        })
+        .on("error", fail);
+
+      request.setTimeout(DOWNLOAD_TIMEOUT_MS, () => {
+        request.destroy(new Error(`download timeout after ${DOWNLOAD_TIMEOUT_MS / 1000}s`));
+      });
+    };
+
+    follow(url);
+  });
+}
+
+async function download(url, dest, attempts = DOWNLOAD_ATTEMPTS) {
+  let lastErr;
+
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    try {
+      await downloadOnce(url, dest);
+      return;
+    } catch (err) {
+      lastErr = err;
+
+      if (attempt === attempts) {
+        break;
+      }
+
+      const delay = RETRY_BASE_DELAY_MS * 2 ** (attempt - 1);
+      console.warn(
+        `Download failed (${attempt}/${attempts}) for ${path.basename(dest)}: ${err.message}. Retrying in ${delay}ms...`,
+      );
+      await sleep(delay);
+    }
+  }
+
+  throw lastErr;
+}
+
+function sha256(filePath) {
+  const hash = crypto.createHash("sha256");
+  hash.update(fs.readFileSync(filePath));
+  return hash.digest("hex");
+}
+
+function expectedChecksum(checksumsPath, filename) {
+  const checksums = fs.readFileSync(checksumsPath, "utf8").split(/\r?\n/);
+
+  for (const line of checksums) {
+    const parts = line.trim().split(/\s+/);
+    if (parts.length >= 2 && parts[1] === filename) {
+      return parts[0];
+    }
+  }
+
+  throw new Error(`checksum for ${filename} not found in checksums.txt`);
+}
+
+function verifyChecksum(archivePath, checksumsPath, filename) {
+  const expected = expectedChecksum(checksumsPath, filename);
+  const actual = sha256(archivePath);
+
+  if (actual !== expected) {
+    throw new Error(`checksum mismatch for ${filename}: expected ${expected}, got ${actual}`);
+  }
+}
+
+function extractArchive(archivePath, destDir) {
+  const result = spawnSync("tar", ["-xzf", archivePath, "-C", destDir], {
+    stdio: "inherit",
+  });
+
+  if (result.error) {
+    throw result.error;
+  }
+  if (result.status !== 0) {
+    throw new Error(`tar exited with status ${result.status}`);
+  }
+}
+
+async function install(options = {}) {
+  const force = options.force === true;
+
+  if (!force && haveBinary()) {
+    return;
+  }
+
+  const version = packageVersion();
+  const filename = archiveName(version);
+  const binDir = path.join(__dirname, "bin");
+  const tempDir = path.join(__dirname, ".tmp-extract");
+  const archivePath = path.join(__dirname, filename);
+  const checksumsPath = path.join(__dirname, "checksums.txt");
+
+  console.log(`Installing tcount ${version} (${targetForCurrentPlatform()})...`);
+
+  fs.mkdirSync(binDir, { recursive: true });
+  fs.rmSync(tempDir, { recursive: true, force: true });
+  fs.mkdirSync(tempDir, { recursive: true });
+
+  try {
+    await download(releaseURL(filename, version), archivePath);
+    await download(releaseURL("checksums.txt", version), checksumsPath);
+    verifyChecksum(archivePath, checksumsPath, filename);
+    extractArchive(archivePath, tempDir);
+
+    const extractedPath = path.join(tempDir, BINARY);
+    const targetPath = binaryPath();
+
+    if (!fs.existsSync(extractedPath)) {
+      throw new Error(`${BINARY} not found in ${filename}`);
+    }
+
+    fs.renameSync(extractedPath, targetPath);
+    if (process.platform !== "win32") {
+      fs.chmodSync(targetPath, 0o755);
+    }
+
+    console.log("Installed tcount successfully");
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+    fs.rmSync(archivePath, { force: true });
+    fs.rmSync(checksumsPath, { force: true });
+  }
+}
+
+async function main() {
+  try {
+    await install({ force: false });
+  } catch (err) {
+    console.error(`Failed to install tcount: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  archiveName,
+  binaryPath,
+  install,
+  targetForCurrentPlatform,
+};

package/lib/run.js

@@ -0,0 +1,27 @@
+const fs = require("fs");
+const { spawnSync } = require("child_process");
+
+const { binaryPath, install } = require("../install");
+
+async function runBinary(name) {
+  const target = binaryPath(name);
+
+  if (!fs.existsSync(target)) {
+    await install();
+  }
+
+  const result = spawnSync(target, process.argv.slice(2), {
+    stdio: "inherit",
+    shell: false,
+  });
+
+  if (result.error) {
+    throw result.error;
+  }
+
+  process.exit(result.status ?? 1);
+}
+
+module.exports = {
+  runBinary,
+};

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@obedience-corp/tcount",
+  "version": "0.3.0",
+  "description": "Fast, zero-network token counter for LLM workflows (tcount CLI)",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lancekrogers/tcount.git"
+  },
+  "homepage": "https://github.com/lancekrogers/tcount",
+  "bugs": {
+    "url": "https://github.com/lancekrogers/tcount/issues"
+  },
+  "license": "MIT",
+  "bin": {
+    "tcount": "bin/tcount"
+  },
+  "scripts": {
+    "postinstall": "node install.js"
+  },
+  "files": [
+    "README.md",
+    "bin",
+    "install.js",
+    "lib"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "os": [
+    "darwin",
+    "linux"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
+  "keywords": [
+    "cli",
+    "llm",
+    "token",
+    "tokenizer",
+    "tiktoken",
+    "claude",
+    "llama",
+    "count",
+    "cost-estimate"
+  ]
+}