@shello/bin 0.1.0 → 0.2.0

package/bin/shello.js

@@ -1,13 +1,35 @@
 #!/usr/bin/env node
 const { execFileSync } = require('child_process')
-const fs = require('fs')
 const path = require('path')
 
-const binary = path.join(__dirname, 'shello')
+const PLATFORMS = {
+  'darwin-arm64': '@shello/bin-darwin-arm64',
+  'darwin-x64': '@shello/bin-darwin-x64',
+  'linux-arm64': '@shello/bin-linux-arm64',
+  'linux-x64': '@shello/bin-linux-x64',
+}
+
+const platformKey = `${process.platform}-${process.arch}`
+const pkg = PLATFORMS[platformKey]
+
+if (!pkg) {
+  console.error(`Unsupported platform: ${platformKey}`)
+  console.error('Supported: darwin-arm64, darwin-x64, linux-arm64, linux-x64')
+  console.error('Install manually: curl -fsSL https://get.shello.to | sh')
+  process.exit(1)
+}
 
-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')
+let binary
+try {
+  binary = path.join(
+    path.dirname(require.resolve(`${pkg}/package.json`)),
+    'bin',
+    'shello',
+  )
+} catch {
+  console.error(`Platform package ${pkg} is not installed.`)
+  console.error('Try reinstalling: npm install -g @shello/bin')
+  console.error('Or install manually: curl -fsSL https://get.shello.to | sh')
   process.exit(1)
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shello/bin",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "P2P terminal access — no ports, no cloud, just connect",
   "license": "MIT",
   "repository": {
@@ -21,21 +21,15 @@
     "shello": "./bin/shello.js"
   },
   "files": [
-    "bin/shello.js",
-    "postinstall.js"
-  ],
-  "scripts": {
-    "postinstall": "node postinstall.js"
-  },
-  "os": [
-    "darwin",
-    "linux"
-  ],
-  "cpu": [
-    "arm64",
-    "x64"
+    "bin/shello.js"
   ],
   "engines": {
     "node": ">=16"
+  },
+  "optionalDependencies": {
+    "@shello/bin-darwin-arm64": "0.2.0",
+    "@shello/bin-darwin-x64": "0.2.0",
+    "@shello/bin-linux-arm64": "0.2.0",
+    "@shello/bin-linux-x64": "0.2.0"
   }
 }

package/postinstall.js

@@ -1,139 +0,0 @@
-#!/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)
-})