@kisuke/cli 1.1.12-dev.21.2

package/README.md

@@ -0,0 +1,14 @@
+# @kisuke/cli
+
+Staging npm installer for the Kisuke CLI. This package downloads a prebuilt CLI bundle from the public R2 bucket during install and exposes the `kisuke` command.
+
+## Install (dev)
+
+```
+npm install -g @kisuke/cli@dev
+```
+
+## Notes
+
+- Artifacts are pulled from the staging R2 prefix.
+- The binary itself remains named `kisuke`.

package/bin/kisuke.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+import { getBaseVersion, getPlatformTag } from '../scripts/platform.mjs';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const pkgRoot = path.resolve(__dirname, '..');
+const pkgJson = JSON.parse(fs.readFileSync(path.join(pkgRoot, 'package.json'), 'utf8'));
+
+const baseVersion = getBaseVersion(pkgJson.version);
+const platformTag = getPlatformTag();
+const bundleName = `kisuke-cli-${baseVersion}-${platformTag}`;
+const bundleDir = path.join(pkgRoot, '.vendor', baseVersion, platformTag, bundleName);
+
+const executable = process.platform === 'win32'
+  ? path.join(bundleDir, 'kisuke.cmd')
+  : path.join(bundleDir, 'kisuke');
+
+if (!fs.existsSync(executable)) {
+  console.error('Kisuke CLI bundle is not installed. Try reinstalling @kisuke/cli.');
+  process.exit(1);
+}
+
+const child = spawn(executable, process.argv.slice(2), {
+  stdio: 'inherit',
+  shell: process.platform === 'win32',
+});
+
+child.on('exit', (code) => process.exit(code ?? 0));
+child.on('error', (err) => {
+  console.error(err?.message || err);
+  process.exit(1);
+});

package/config.example.json

@@ -0,0 +1,5 @@
+{
+  "accountId": "YOUR_R2_ACCOUNT_ID",
+  "bucket": "YOUR_R2_BUCKET",
+  "prefix": "connect/"
+}

package/config.json

@@ -0,0 +1,5 @@
+{
+  "accountId": "6a348304da22f29510e4479f02a7fa33",
+  "bucket": "releases",
+  "prefix": "connect/"
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@kisuke/cli",
+  "version": "1.1.12-dev.21.2",
+  "private": false,
+  "description": "Kisuke CLI (dev) installer",
+  "type": "module",
+  "bin": {
+    "kisuke": "./bin/kisuke.js"
+  },
+  "files": [
+    "bin",
+    "scripts",
+    "config.json",
+    "config.example.json",
+    "README.md",
+    "package.json"
+  ],
+  "scripts": {
+    "postinstall": "node scripts/download.mjs"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/scripts/download.mjs

@@ -0,0 +1,159 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { createHash } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import https from 'node:https';
+
+import { getArchiveExt, getBaseVersion, getPlatformTag } from './platform.mjs';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const pkgRoot = path.resolve(__dirname, '..');
+
+const workspaceMarker = path.resolve(pkgRoot, '..', '..', 'pnpm-workspace.yaml');
+if (fs.existsSync(workspaceMarker)) {
+  process.exit(0);
+}
+
+const pkgJson = JSON.parse(fs.readFileSync(path.join(pkgRoot, 'package.json'), 'utf8'));
+
+const baseVersion = getBaseVersion(pkgJson.version);
+const platformTag = getPlatformTag();
+const archiveExt = getArchiveExt(platformTag);
+const bundleName = `kisuke-cli-${baseVersion}-${platformTag}`;
+const archiveName = `${bundleName}.${archiveExt}`;
+
+const configPath = path.join(pkgRoot, 'config.json');
+const config = fs.existsSync(configPath)
+  ? JSON.parse(fs.readFileSync(configPath, 'utf8'))
+  : {};
+
+const accountId = config.accountId || process.env.R2_ACCOUNT_ID;
+const bucket = config.bucket || process.env.R2_BUCKET;
+let prefix = config.prefix || process.env.R2_PREFIX || 'connect/';
+
+if (!accountId || !bucket) {
+  throw new Error('Missing R2 configuration. Provide config.json or R2_ACCOUNT_ID/R2_BUCKET env vars.');
+}
+
+if (prefix && !prefix.endsWith('/')) prefix = `${prefix}/`;
+
+const baseUrl = `https://${accountId}.r2.cloudflarestorage.com/${bucket}/${prefix}`;
+const folderUrl = `${baseUrl}${baseVersion}/cli/${platformTag}/`;
+const archiveUrl = `${folderUrl}${archiveName}`;
+const sumsUrl = `${folderUrl}SHA256SUMS`;
+
+const vendorRoot = path.join(pkgRoot, '.vendor', baseVersion, platformTag);
+const bundleDir = path.join(vendorRoot, bundleName);
+
+if (fs.existsSync(bundleDir)) {
+  process.exit(0);
+}
+
+fs.mkdirSync(vendorRoot, { recursive: true });
+
+const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kisuke-cli-'));
+const archivePath = path.join(tmpDir, archiveName);
+const sumsPath = path.join(tmpDir, 'SHA256SUMS');
+
+await downloadFile(sumsUrl, sumsPath);
+await downloadFile(archiveUrl, archivePath);
+
+const expectedSha = findSha256(sumsPath, archiveName);
+if (!expectedSha) {
+  throw new Error(`SHA256SUMS missing entry for ${archiveName}`);
+}
+
+const actualSha = sha256File(archivePath);
+if (actualSha !== expectedSha) {
+  throw new Error(`SHA256 mismatch for ${archiveName}: expected ${expectedSha}, got ${actualSha}`);
+}
+
+extractArchive(archivePath, vendorRoot, archiveExt);
+
+if (!fs.existsSync(bundleDir)) {
+  throw new Error(`Extraction failed: ${bundleDir} not found`);
+}
+
+cleanup(tmpDir);
+
+function downloadFile(url, dest, retries = 3) {
+  return new Promise((resolve, reject) => {
+    const request = https.get(url, (res) => {
+      if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        return downloadFile(res.headers.location, dest, retries).then(resolve).catch(reject);
+      }
+      if (res.statusCode !== 200) {
+        reject(new Error(`Failed to download ${url} (status ${res.statusCode})`));
+        return;
+      }
+      const file = fs.createWriteStream(dest);
+      res.pipe(file);
+      file.on('finish', () => file.close(resolve));
+    });
+    request.on('error', reject);
+  }).catch((err) => {
+    if (retries <= 1) throw err;
+    const delay = (4 - retries) * 1000;
+    console.warn(`Download failed (${err.message}), retrying in ${delay / 1000}s... (${retries - 1} left)`);
+    return new Promise((r) => setTimeout(r, delay)).then(() => downloadFile(url, dest, retries - 1));
+  });
+}
+
+function sha256File(filePath) {
+  const hash = createHash('sha256');
+  const data = fs.readFileSync(filePath);
+  hash.update(data);
+  return hash.digest('hex');
+}
+
+function findSha256(sumsFile, filename) {
+  const lines = fs.readFileSync(sumsFile, 'utf8').split('\n');
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const match = trimmed.match(/^([a-f0-9]{64})\s+(.+)$/i);
+    if (!match) continue;
+    if (match[2] === filename) return match[1];
+  }
+  return null;
+}
+
+function extractArchive(archivePath, destDir, ext) {
+  if (ext === 'tar.gz') {
+    const result = spawnSync('tar', ['-xzf', archivePath, '-C', destDir], { stdio: 'inherit' });
+    if (result.status !== 0) throw new Error('tar extraction failed');
+    return;
+  }
+
+  if (ext === 'zip') {
+    if (process.platform === 'win32') {
+      const result = spawnSync(
+        'powershell',
+        [
+          '-NoProfile',
+          '-Command',
+          `Expand-Archive -LiteralPath \"${archivePath}\" -DestinationPath \"${destDir}\" -Force`,
+        ],
+        { stdio: 'inherit' },
+      );
+      if (result.status !== 0) throw new Error('zip extraction failed');
+      return;
+    }
+
+    const result = spawnSync('unzip', ['-o', archivePath, '-d', destDir], { stdio: 'inherit' });
+    if (result.status !== 0) throw new Error('unzip extraction failed');
+    return;
+  }
+
+  throw new Error(`Unsupported archive type: ${ext}`);
+}
+
+function cleanup(dir) {
+  try {
+    fs.rmSync(dir, { recursive: true, force: true });
+  } catch {
+    // ignore cleanup errors
+  }
+}

package/scripts/platform.mjs

@@ -0,0 +1,35 @@
+import { arch, platform, report } from 'node:process';
+
+export function getBaseVersion(version) {
+  return version.replace(/-dev\..+$/, '');
+}
+
+function isMusl() {
+  if (platform !== 'linux') return false;
+  try {
+    const glibc = report?.getReport?.()?.header?.glibcVersionRuntime;
+    return !glibc;
+  } catch {
+    return true;
+  }
+}
+
+export function getPlatformTag() {
+  if (platform === 'darwin') {
+    if (arch === 'arm64') return 'darwin-arm64';
+    if (arch === 'x64') return 'darwin-x64';
+  }
+
+  if (platform === 'linux') {
+    if (arch === 'arm64') return 'linux-arm64';
+    if (arch === 'x64') return isMusl() ? 'linux-musl-x64' : 'linux-x64';
+  }
+
+  if (platform === 'win32' && arch === 'x64') return 'windows-x64';
+
+  throw new Error(`Unsupported platform/arch: ${platform}/${arch}`);
+}
+
+export function getArchiveExt(platformTag) {
+  return platformTag.startsWith('windows-') ? 'zip' : 'tar.gz';
+}