@shello/bin 0.1.0

package/bin/shello.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+const { execFileSync } = require('child_process')
+const fs = require('fs')
+const path = require('path')
+
+const binary = path.join(__dirname, 'shello')
+
+if (!fs.existsSync(binary)) {
+  console.error('shello binary not found. Run: npm rebuild shello')
+  console.error('Or install directly: curl -fsSL https://get.shello.to | sh')
+  process.exit(1)
+}
+
+try {
+  execFileSync(binary, process.argv.slice(2), { stdio: 'inherit' })
+} catch (err) {
+  process.exit(err.status || 1)
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@shello/bin",
+  "version": "0.1.0",
+  "description": "P2P terminal access — no ports, no cloud, just connect",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/shelloto/shello.git",
+    "directory": "packages/shello-npm"
+  },
+  "homepage": "https://say.shello.to",
+  "keywords": [
+    "terminal",
+    "ssh",
+    "p2p",
+    "remote",
+    "webrtc",
+    "peer-to-peer"
+  ],
+  "bin": {
+    "shello": "./bin/shello.js"
+  },
+  "files": [
+    "bin/shello.js",
+    "postinstall.js"
+  ],
+  "scripts": {
+    "postinstall": "node postinstall.js"
+  },
+  "os": [
+    "darwin",
+    "linux"
+  ],
+  "cpu": [
+    "arm64",
+    "x64"
+  ],
+  "engines": {
+    "node": ">=16"
+  }
+}

package/postinstall.js

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+const fs = require('fs')
+const path = require('path')
+const https = require('https')
+const crypto = require('crypto')
+
+const REPO = 'shelloto/shello'
+const BINARY = 'shello'
+
+const PLATFORM_MAP = { darwin: 'darwin', linux: 'linux' }
+const ARCH_MAP = { arm64: 'arm64', x64: 'amd64' }
+
+const platform = PLATFORM_MAP[process.platform]
+const arch = ARCH_MAP[process.arch]
+
+if (process.env.SHELLO_SKIP_INSTALL) {
+  console.log('Skipping shello binary download (SHELLO_SKIP_INSTALL set)')
+  process.exit(0)
+}
+
+if (!platform || !arch) {
+  console.error(`Unsupported platform: ${process.platform}/${process.arch}`)
+  console.error('Supported: darwin/arm64, darwin/x64, linux/arm64, linux/x64')
+  process.exit(1)
+}
+
+const binDir = path.join(__dirname, 'bin')
+const binPath = path.join(binDir, BINARY)
+
+function httpsGet(url) {
+  return new Promise((resolve, reject) => {
+    https.get(url, { headers: { 'User-Agent': 'shello-npm' } }, (res) => {
+      if (res.statusCode === 301 || res.statusCode === 302) {
+        return httpsGet(res.headers.location).then(resolve).catch(reject)
+      }
+      if (res.statusCode !== 200) {
+        return reject(new Error(`HTTP ${res.statusCode} from ${url}`))
+      }
+      resolve(res)
+    }).on('error', reject)
+  })
+}
+
+function fetchJSON(url) {
+  return new Promise((resolve, reject) => {
+    httpsGet(url).then((res) => {
+      let data = ''
+      res.on('data', (chunk) => (data += chunk))
+      res.on('end', () => {
+        try {
+          resolve(JSON.parse(data))
+        } catch (e) {
+          reject(new Error(`Failed to parse JSON from ${url}: ${e.message}`))
+        }
+      })
+    }).catch(reject)
+  })
+}
+
+function fetchText(url) {
+  return new Promise((resolve, reject) => {
+    httpsGet(url).then((res) => {
+      let data = ''
+      res.on('data', (chunk) => (data += chunk))
+      res.on('end', () => resolve(data))
+    }).catch(reject)
+  })
+}
+
+function download(url, dest) {
+  return new Promise((resolve, reject) => {
+    httpsGet(url).then((res) => {
+      const file = fs.createWriteStream(dest)
+      res.pipe(file)
+      file.on('finish', () => {
+        file.close()
+        resolve()
+      })
+      file.on('error', (err) => {
+        fs.unlink(dest, () => {})
+        reject(err)
+      })
+    }).catch(reject)
+  })
+}
+
+async function main() {
+  const release = await fetchJSON(
+    `https://api.github.com/repos/${REPO}/releases/latest`
+  )
+  const tag = release.tag_name
+  if (!tag) {
+    throw new Error('No releases found. Install manually: https://say.shello.to')
+  }
+
+  const binaryName = `${BINARY}-${platform}-${arch}`
+  const binaryURL = `https://github.com/${REPO}/releases/download/${tag}/${binaryName}`
+
+  console.log(`Downloading ${BINARY} ${tag} (${platform}/${arch})...`)
+
+  fs.mkdirSync(binDir, { recursive: true })
+  await download(binaryURL, binPath)
+  fs.chmodSync(binPath, 0o755)
+
+  // Verify checksum if available
+  try {
+    const checksums = await fetchText(
+      `https://github.com/${REPO}/releases/download/${tag}/checksums.txt`
+    )
+    const expected = checksums
+      .split('\n')
+      .find((line) => line.includes(binaryName))
+    if (expected) {
+      const hash = crypto
+        .createHash('sha256')
+        .update(fs.readFileSync(binPath))
+        .digest('hex')
+      const expectedHash = expected.split(/\s+/)[0]
+      if (hash !== expectedHash) {
+        fs.unlinkSync(binPath)
+        throw new Error(
+          `Checksum mismatch: expected ${expectedHash}, got ${hash}`
+        )
+      }
+      console.log('Checksum verified.')
+    }
+  } catch (e) {
+    if (e.message.includes('Checksum mismatch')) throw e
+    // Checksums file not available — that's OK
+  }
+
+  console.log(`Installed ${BINARY} ${tag} to ${binPath}`)
+}
+
+main().catch((err) => {
+  console.error(`Failed to install shello: ${err.message}`)
+  console.error('You can install manually: curl -fsSL https://get.shello.to | sh')
+  process.exit(1)
+})