@piperace/cli 0.3.5

package/README.md

@@ -0,0 +1,65 @@
+# Piperace NPM Wrapper
+
+NPM wrapper around the Piperace Go binaries.
+
+## Install
+
+```bash
+npm install -g @piperace/cli
+```
+
+## Usage
+
+```bash
+piperace --version
+piperace http 3000 -d myapp
+piperace login
+piperace-gui
+```
+
+## How it works
+
+On `npm install`, the `postinstall` script detects your platform/architecture and either:
+
+1. Copies the matching binary from `../piperace_client/dist/` (when installed inside the Piperace monorepo), or
+2. Downloads it from `https://app.piperace.com/downloads/v<VERSION>/`.
+
+The downloaded binary is stored in `binaries/` inside the package and is launched by the `bin/piperace` Node.js wrapper.
+
+## Supported platforms
+
+| OS       | Arch  | Binary                         |
+|----------|-------|--------------------------------|
+| macOS    | arm64 | `piperace-darwin-arm64`        |
+| macOS    | x64   | `piperace-darwin-amd64`        |
+| Linux    | arm64 | `piperace-linux-arm64`         |
+| Linux    | x64   | `piperace-linux-amd64`         |
+| Windows  | x64   | `piperace-client.exe`          |
+| Windows  | ia32  | `piperace-client-386.exe`      |
+
+## Environment variables
+
+- `PIPERACE_BINARY_PATH` — path to a manually downloaded binary to use instead of downloading.
+- `PIPERACE_DOWNLOAD_URL` — override the base download URL (default: `https://app.piperace.com/downloads`).
+
+## Programmatic API
+
+```js
+const piperace = require('@piperace/cli');
+
+await piperace.run(['http', '3000', '-d', 'myapp'], {
+  env: { PIPERACE_ENV: 'production' }
+});
+```
+
+## Publishing
+
+```bash
+npm version patch
+npm publish --access public
+```
+
+## macOS note
+
+On macOS the downloaded binary may be quarantined. The install script automatically runs `xattr -cr` to remove the quarantine attribute. For a cleaner experience, distribute a code-signed and notarized binary.
+

package/bin/piperace

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+const { run } = require('../lib/index.js');
+
+run(process.argv.slice(2)).catch((err) => {
+  console.error(err.message);
+  process.exit(1);
+});

package/bin/piperace-gui

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+const { run } = require('../lib/index.js');
+
+run(process.argv.slice(2), { gui: true }).catch((err) => {
+  console.error(err.message);
+  process.exit(1);
+});

package/lib/index.js

@@ -0,0 +1,76 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { spawn } = require('child_process');
+
+const ROOT = path.join(__dirname, '..');
+const BIN_DIR = path.join(ROOT, 'binaries');
+
+const BINARY_MAP = {
+  cli: {
+    'darwin arm64': 'piperace-darwin-arm64',
+    'darwin x64':   'piperace-darwin-amd64',
+    'linux arm64':  'piperace-linux-arm64',
+    'linux x64':    'piperace-linux-amd64',
+    'win32 x64':    'piperace-client.exe',
+    'win32 ia32':   'piperace-client-386.exe'
+  },
+  gui: {
+    'darwin arm64': 'piperace-gui-darwin-arm64',
+    'darwin x64':   'piperace-gui-darwin-amd64',
+    'win32 x64':    'piperace-gui.exe'
+  }
+};
+
+function platformKey() {
+  return `${os.platform()} ${os.arch()}`;
+}
+
+function getBinaryPath(kind = 'cli') {
+  const name = kind === 'gui' ? 'piperace-gui' : 'piperace';
+  const binaryPath = path.join(BIN_DIR, name + (os.platform() === 'win32' ? '.exe' : ''));
+
+  if (!fs.existsSync(binaryPath)) {
+    const expectedSource = BINARY_MAP[kind]?.[platformKey()];
+    throw new Error(
+      `Piperace ${kind} binary not found at ${binaryPath}.\n` +
+      `Expected source binary: ${expectedSource || 'none for ' + platformKey()}\n` +
+      `Try running: npm run postinstall\n` +
+      `Or set PIPERACE_BINARY_PATH to the downloaded binary.`
+    );
+  }
+
+  return binaryPath;
+}
+
+function run(args = [], options = {}) {
+  const kind = options.gui ? 'gui' : 'cli';
+  const binaryPath = getBinaryPath(kind);
+  const child = spawn(binaryPath, args, {
+    stdio: options.stdio || 'inherit',
+    env: { ...process.env, ...options.env },
+    cwd: options.cwd || process.cwd()
+  });
+
+  if (options.detach) {
+    child.unref();
+    return child;
+  }
+
+  return new Promise((resolve, reject) => {
+    child.on('error', reject);
+    child.on('exit', (code) => {
+      if (code === 0 || options.noReject) {
+        resolve(code);
+      } else {
+        reject(new Error(`Piperace exited with code ${code}`));
+      }
+    });
+  });
+}
+
+module.exports = {
+  getBinaryPath,
+  run,
+  platformKey
+};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@piperace/cli",
+  "version": "0.3.5",
+  "description": "Piperace — self-hosted ngrok alternative. NPM wrapper for the Go binary.",
+  "main": "lib/index.js",
+  "bin": {
+    "piperace": "bin/piperace",
+    "piperace-gui": "bin/piperace-gui"
+  },
+  "scripts": {
+    "postinstall": "node scripts/install.js",
+    "test": "node -e \"require('./lib/index.js').getBinaryPath(); console.log('ok')\""
+  },
+  "keywords": [
+    "piperace",
+    "tunnel",
+    "ngrok",
+    "localhost",
+    "expose",
+    "cli"
+  ],
+  "author": "Piperace Team",
+  "license": "MIT",
+  "homepage": "https://piperace.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/piperace/piperace-npm.git"
+  },
+  "bugs": {
+    "url": "https://github.com/piperace/piperace-npm/issues"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "scripts/",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/scripts/install.js

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const http = require('http');
+const os = require('os');
+const crypto = require('crypto');
+const { execSync } = require('child_process');
+
+const VERSION = require('../package.json').version;
+const ROOT = path.join(__dirname, '..');
+const BIN_DIR = path.join(ROOT, 'binaries');
+
+// Map Node platform/arch to the binary names produced by the Go build.
+const BINARY_MAP = {
+  cli: {
+    'darwin arm64': 'piperace-darwin-arm64',
+    'darwin x64':   'piperace-darwin-amd64',
+    'linux arm64':  'piperace-linux-arm64',
+    'linux x64':    'piperace-linux-amd64',
+    'win32 x64':    'piperace-client.exe',
+    'win32 ia32':   'piperace-client-386.exe'
+  },
+  gui: {
+    'darwin arm64': 'piperace-gui-darwin-arm64',
+    'darwin x64':   'piperace-gui-darwin-amd64',
+    'win32 x64':    'piperace-gui.exe'
+  }
+};
+
+function platformKey() {
+  return `${os.platform()} ${os.arch()}`;
+}
+
+function binaryName(kind = 'cli') {
+  const map = BINARY_MAP[kind];
+  if (!map) return null;
+  return map[platformKey()] || null;
+}
+
+function finalBinaryName(kind = 'cli') {
+  return kind === 'gui' ? 'piperace-gui' : 'piperace';
+}
+
+function finalBinaryPath(kind = 'cli') {
+  const name = finalBinaryName(kind) + (os.platform() === 'win32' ? '.exe' : '');
+  return path.join(BIN_DIR, name);
+}
+
+function findLocalBinary(sourceName) {
+  // When the package is installed inside the piperace monorepo, the binaries
+  // live at ../piperace_client/dist/<sourceName>.
+  const candidates = [
+    path.join(ROOT, '..', 'piperace_client', 'dist', sourceName),
+    path.join(ROOT, '..', '..', 'piperace_client', 'dist', sourceName),
+    process.env.PIPERACE_BINARY_PATH
+  ];
+
+  for (const candidate of candidates) {
+    if (candidate && fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+
+function downloadFile(url, dest) {
+  return new Promise((resolve, reject) => {
+    const client = url.startsWith('https:') ? https : http;
+    const file = fs.createWriteStream(dest);
+
+    client.get(url, (res) => {
+      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        file.destroy();
+        fs.unlinkSync(dest);
+        return downloadFile(res.headers.location, dest).then(resolve).catch(reject);
+      }
+      if (res.statusCode !== 200) {
+        file.destroy();
+        fs.unlinkSync(dest);
+        return reject(new Error(`HTTP ${res.statusCode} from ${url}`));
+      }
+
+      res.pipe(file);
+      file.on('finish', () => file.close(resolve));
+    }).on('error', (err) => {
+      try { fs.unlinkSync(dest); } catch {}
+      reject(err);
+    });
+  });
+}
+
+async function installBinary(kind = 'cli') {
+  const sourceName = binaryName(kind);
+  if (!sourceName) {
+    console.warn(`[piperace] No prebuilt ${kind} binary for ${platformKey()}.`);
+    console.warn(`[piperace] Supported platforms: ${Object.keys(BINARY_MAP[kind]).join(', ')}`);
+    return;
+  }
+
+  fs.mkdirSync(BIN_DIR, { recursive: true });
+  const target = finalBinaryPath(kind);
+
+  // Avoid re-downloading if binary already exists and looks valid.
+  if (fs.existsSync(target) && fs.statSync(target).size > 1000) {
+    try {
+      fs.chmodSync(target, 0o755);
+    } catch {}
+    console.log(`[piperace] ${kind} binary already installed.`);
+    return;
+  }
+
+  // 1. Try local binary from the monorepo dist folder.
+  const localPath = findLocalBinary(sourceName);
+  if (localPath) {
+    console.log(`[piperace] Installing ${kind} binary from local dist: ${localPath}`);
+    fs.copyFileSync(localPath, target);
+    fs.chmodSync(target, 0o755);
+    removeQuarantine(target);
+    return;
+  }
+
+  // 2. Fall back to downloading from the public CDN.
+  const baseUrl = process.env.PIPERACE_DOWNLOAD_URL || 'https://app.piperace.com/downloads';
+  const url = `${baseUrl}/v${VERSION}/${sourceName}`;
+  console.log(`[piperace] Downloading ${kind} binary from ${url}`);
+
+  try {
+    await downloadFile(url, target);
+    fs.chmodSync(target, 0o755);
+    removeQuarantine(target);
+    console.log(`[piperace] ${kind} binary installed successfully.`);
+  } catch (err) {
+    try { fs.unlinkSync(target); } catch {}
+    console.error(`[piperace] Failed to download ${kind} binary: ${err.message}`);
+    console.error(`[piperace] You can manually download ${sourceName} from ${baseUrl} and place it at ${target}`);
+    // Do not fail npm install; the launcher will print a helpful message later.
+  }
+}
+
+function removeQuarantine(filePath) {
+  if (os.platform() !== 'darwin') return;
+  try {
+    execSync(`xattr -cr "${filePath}"`, { stdio: 'ignore' });
+  } catch {
+    // Ignore — xattr may not be available, or the file may not be quarantined.
+  }
+}
+
+(async () => {
+  await installBinary('cli');
+  await installBinary('gui');
+})();