@osvaldoandrade/tikti-cli 0.2.4

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Osvaldo Andrade
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,19 @@
+# @osvaldoandrade/tikti-cli
+
+Tikti admin CLI distributed as a prebuilt Go binary downloaded from GitHub Releases during `npm install`.
+
+## Install
+
+```sh
+npm install -g @osvaldoandrade/tikti-cli
+```
+
+## Upgrade
+
+```sh
+npm install -g @osvaldoandrade/tikti-cli@latest
+```
+
+## Notes
+
+- If the repository is private, you may need `GITHUB_TOKEN`/`GH_TOKEN` set so the postinstall binary download can authenticate.

package/bin/tikti-cli

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+'use strict';
+
+const { spawnSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const ext = process.platform === 'win32' ? '.exe' : '';
+const binPath = path.join(__dirname, `tikti-cli-bin${ext}`);
+
+try {
+  fs.accessSync(binPath, fs.constants.X_OK);
+} catch {
+  console.error('tikti-cli: binary is missing. Try reinstalling the package.');
+  process.exit(1);
+}
+
+const res = spawnSync(binPath, process.argv.slice(2), { stdio: 'inherit' });
+if (res.error) {
+  console.error(`tikti-cli: failed to run binary: ${res.error.message}`);
+  process.exit(1);
+}
+process.exit(res.status == null ? 1 : res.status);
+

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@osvaldoandrade/tikti-cli",
+  "version": "0.2.4",
+  "description": "Tikti admin CLI (installs a prebuilt Go binary from GitHub Releases)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/osvaldoandrade/tikti.git",
+    "directory": "npm/tikti-cli"
+  },
+  "bugs": {
+    "url": "https://github.com/osvaldoandrade/tikti/issues"
+  },
+  "homepage": "https://github.com/osvaldoandrade/tikti#readme",
+  "bin": {
+    "tikti-cli": "bin/tikti-cli"
+  },
+  "files": [
+    "bin/",
+    "scripts/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/scripts/postinstall.js

@@ -0,0 +1,191 @@
+/* eslint-disable no-console */
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const https = require('https');
+const path = require('path');
+
+function log(msg) {
+  console.log(`[tikti-cli] ${msg}`);
+}
+
+function warn(msg) {
+  console.warn(`[tikti-cli] warning: ${msg}`);
+}
+
+function fail(msg) {
+  console.error(`[tikti-cli] error: ${msg}`);
+  process.exit(1);
+}
+
+function getGoOS() {
+  switch (process.platform) {
+    case 'darwin':
+      return 'darwin';
+    case 'linux':
+      return 'linux';
+    case 'win32':
+      return 'windows';
+    default:
+      return null;
+  }
+}
+
+function getGoArch() {
+  switch (process.arch) {
+    case 'x64':
+      return 'amd64';
+    case 'arm64':
+      return 'arm64';
+    default:
+      return null;
+  }
+}
+
+function authHeaders() {
+  const token = process.env.GITHUB_TOKEN || process.env.GH_TOKEN || '';
+  const headers = {
+    'User-Agent': '@osvaldoandrade/tikti-cli postinstall',
+    Accept: '*/*',
+  };
+  if (token) {
+    headers.Authorization = `token ${token}`;
+  }
+  return headers;
+}
+
+function request(url, headers, redirectsLeft) {
+  return new Promise((resolve, reject) => {
+    const req = https.request(url, { headers }, (res) => {
+      const code = res.statusCode || 0;
+      const location = res.headers.location;
+
+      if (code >= 300 && code < 400 && location && redirectsLeft > 0) {
+        // GitHub release downloads redirect to a signed URL.
+        res.resume();
+        resolve(request(location, headers, redirectsLeft - 1));
+        return;
+      }
+
+      if (code < 200 || code >= 300) {
+        let body = '';
+        res.setEncoding('utf8');
+        res.on('data', (d) => {
+          body += d;
+        });
+        res.on('end', () => {
+          reject(new Error(`HTTP ${code} for ${url}${body ? `: ${body.slice(0, 200)}` : ''}`));
+        });
+        return;
+      }
+
+      resolve(res);
+    });
+
+    req.on('error', reject);
+    req.end();
+  });
+}
+
+async function downloadText(url) {
+  const res = await request(url, authHeaders(), 5);
+  return await new Promise((resolve, reject) => {
+    let out = '';
+    res.setEncoding('utf8');
+    res.on('data', (d) => {
+      out += d;
+    });
+    res.on('end', () => resolve(out));
+    res.on('error', reject);
+  });
+}
+
+function parseExpectedSha256(sumText, assetName) {
+  const lines = sumText.split(/\r?\n/);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const parts = trimmed.split(/\s+/);
+    if (parts.length < 2) continue;
+    const sha = parts[0];
+    const file = parts[1].replace(/^dist\//, '');
+    if (file === assetName) {
+      return sha.toLowerCase();
+    }
+  }
+  return null;
+}
+
+async function downloadFileWithSha256(url, outPath, expectedSha256) {
+  const res = await request(url, authHeaders(), 5);
+
+  await fs.promises.mkdir(path.dirname(outPath), { recursive: true });
+  const tmpPath = `${outPath}.tmp`;
+
+  const hash = crypto.createHash('sha256');
+  const ws = fs.createWriteStream(tmpPath, { mode: 0o755 });
+
+  await new Promise((resolve, reject) => {
+    res.on('data', (chunk) => hash.update(chunk));
+    res.pipe(ws);
+    res.on('error', reject);
+    ws.on('error', reject);
+    ws.on('finish', resolve);
+  });
+
+  const got = hash.digest('hex').toLowerCase();
+  if (expectedSha256 && got !== expectedSha256) {
+    await fs.promises.rm(tmpPath, { force: true });
+    throw new Error(`sha256 mismatch for ${path.basename(outPath)}: expected ${expectedSha256}, got ${got}`);
+  }
+
+  await fs.promises.rename(tmpPath, outPath);
+}
+
+async function main() {
+  const goos = getGoOS();
+  const goarch = getGoArch();
+  if (!goos) fail(`unsupported platform: ${process.platform}`);
+  if (!goarch) fail(`unsupported arch: ${process.arch}`);
+
+  const pkgPath = path.join(__dirname, '..', 'package.json');
+  // eslint-disable-next-line global-require, import/no-dynamic-require
+  const pkg = require(pkgPath);
+  const version = pkg.version;
+
+  if (!version || typeof version !== 'string') fail('missing package version');
+
+  const owner = process.env.TIKTI_GH_OWNER || 'osvaldoandrade';
+  const repo = process.env.TIKTI_GH_REPO || 'tikti';
+  const tag = `v${version}`;
+
+  const ext = goos === 'windows' ? '.exe' : '';
+  const assetName = `tikti-cli-${goos}-${goarch}${ext}`;
+  const base = `https://github.com/${owner}/${repo}/releases/download/${tag}`;
+  const checksumUrl = `${base}/SHA256SUMS.txt`;
+  const binUrl = `${base}/${assetName}`;
+
+  const outPath = path.join(__dirname, '..', 'bin', `tikti-cli-bin${ext}`);
+  log(`downloading ${assetName} (${tag})`);
+
+  let expected = null;
+  try {
+    const txt = await downloadText(checksumUrl);
+    expected = parseExpectedSha256(txt, assetName);
+    if (!expected) warn(`checksum entry not found for ${assetName}; continuing without verification`);
+  } catch (e) {
+    warn(`failed to download checksums (${e.message}); continuing without verification`);
+  }
+
+  await downloadFileWithSha256(binUrl, outPath, expected);
+
+  if (goos !== 'windows') {
+    await fs.promises.chmod(outPath, 0o755);
+  }
+
+  log(`installed ${path.relative(process.cwd(), outPath)}`);
+}
+
+main().catch((e) => fail(e.message));
+