pear-install 1.0.3 → 1.0.5

package/README.md

@@ -1,14 +1,104 @@
-# pear-install
-
 > Install Pear and Pear Applications
 
-# CLI
+## CLI
+
+The published binary. With no `link`, installs the Pear platform. With a `pear://` link, installs that application and/or its binaries.
 
 ```sh
 npx pear-install [link]
 ```
 
-Install `pear` binary onto system, if a link is supplied, installs any Pear application or binary onto system.
+### Flags
+
+- `--to <dir>` — target directory (overrides platform default)
+- `--only <paths>` — comma-separated filenames to install
+- `--timeout <seconds>` — network timeout (default `30`)
+- `--dht-bootstrap <nodes>` — comma-separated `host:port`
+- `--json` — newline-delimited JSON output (one `{ cmd: 'install', tag, data }` per line)
+
+### Default install destinations
+
+- **macOS** — apps to `/Applications`, bins to `/usr/local/bin`
+- **Linux** — apps to `~/Applications`, `~/AppImages`, or `~/.local/bin`; bins to `~/.local/bin`
+- **Windows** — apps and bins installed as MSIX packages
+
+## API
+
+```js
+const Install = require('pear-install')
+```
+
+### `const install = new Install(opts)`
+
+- `link` _(string)_ — `pear://` link
+- `to` _(string, optional)_ — target directory
+- `only` _(string, optional)_ — comma-separated filenames
+- `bootstrap` _(array, optional)_ — `[{ host, port }, ...]` DHT nodes
+- `timeout` _(number, optional)_ — milliseconds, default `30000`
+- `corestore` _(Corestore, optional)_ — inject an existing corestore; not closed by `install.close()`
+- `swarm` _(Hyperswarm, optional)_ — inject an existing swarm; not destroyed by `install.close()`
+
+If `corestore` or `swarm` is omitted, `Install` creates and owns its own.
+
+### `await install.ready()`
+
+Runs the install. Throws on failure.
+
+### `await install.close()`
+
+Releases the drive, the owned swarm and corestore, and removes the temp dir.
+
+### Reusing a corestore and swarm
+
+```js
+const corestore = new Corestore('./store')
+const swarm = new Hyperswarm()
+swarm.on('connection', (c) => corestore.replicate(c))
+
+for (const link of links) {
+  const install = new Install({ link, corestore, swarm })
+  await install.ready()
+  await install.close()
+}
+
+await swarm.destroy()
+await corestore.close()
+```
+
+### Events
+
+- `installing` → `{ link, host }`
+- `app` → `{ app, name, version, upgrade, key, dest }`
+- `stats` → `{ download, upload, peers }`
+- `final` → `{ success, installed, exists }`
+
+## CMD
+
+For embedding in another CLI. Wraps `Install` as a `pear-opstream` of `{ tag, data }` records with stdout formatters.
+
+```js
+const InstallCmd = require('pear-install/cmd')
+
+const stream = new InstallCmd({ link, to, only, bootstrap, timeout })
+await InstallCmd.output(json, stream)
+```
+
+### Tags
+
+- `installing` → `{ link, host }`
+- `app` → `{ app, name, version, upgrade, key, dest }`
+- `stats` → `{ download, upload, peers }`
+- `error` → `{ code, message, stack, info, success: false }`
+- `final` → `{ success, installed, exists }`
+
+### `InstallCmd.output(json, stream)`
+
+Drains `stream` to STDOUT.
+
+- `json` truthy — emits each record as `{ cmd: 'install', tag, data }`, newline-delimited.
+- `json` falsy — formats per-tag; `stats` updates in place via ANSI; static tags stack above.
+
+Returns the `final` record.
 
 ## License
 

package/bin.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+const pkg = require('./package.json')
+const { isWindows } = require('which-runtime')
+const { command, arg, bail } = require('paparam')
+const InstallCmd = require('./cmd')
+
+const program = command(
+  'install',
+  arg('[link]', 'Pear link origin to install from'),
+  async (cmd) => {
+    const { json, only, to, dhtBootstrap } = cmd.flags
+    const timeout = (cmd.flags.timeout || 30) * 1000
+    const link = cmd.args.link ?? pkg.pear.platform.key
+    const bootstrap = dhtBootstrap
+      ? dhtBootstrap.split(',').map((tuple) => {
+          const [host, port] = tuple.split(':')
+          const int = +port
+          if (Number.isInteger(int) === false) throw new Error(`Invalid port: ${port}`)
+          return { host, port: int }
+        })
+      : undefined
+    const stream = new InstallCmd({ link, only, to, bootstrap, timeout })
+    await InstallCmd.output(json, stream)
+  },
+  pkg.command,
+  bail((info = {}) => {
+    process.exitCode = 1
+    let message
+    if (info.reason === 'UNKNOWN_FLAG') message = 'Unrecognized Flag: --' + info.flag.name
+    else if (info.reason === 'UNKNOWN_ARG') {
+      message = `Unrecognized Argument at index ${info.arg.index} with value ${info.arg.value}`
+    } else message = info.err?.message ?? 'Failed'
+    const cross = isWindows ? 'x' : '\x1B[31m✖\x1B[39m'
+    console.error(cross, message)
+    if (info.reason === 'UNKNOWN_FLAG' || info.reason === 'UNKNOWN_ARG') {
+      console.error('\n' + info.command.usage())
+    }
+  })
+)
+
+program.parse(process.argv.slice(2))

package/cmd.js

@@ -1,30 +1,75 @@
-#!/usr/bin/env node
-const pkg = require('./package.json')
+'use strict'
+const process = require('process')
+const Opstream = require('pear-opstream')
+const byteSize = require('tiny-byte-size')
 const { isWindows } = require('which-runtime')
-const { command, arg, bail } = require('paparam')
-const install = require('.')
+const Install = require('.')
 
-const program = command(
-  'install',
-  arg('[link]', 'Pear link origin to install from'),
-  async (cmd) => {
-    if (!cmd.args.link) cmd.args.link = pkg.pear.platform.key
-    await install(cmd)
-  },
-  pkg.command,
-  bail((info = {}) => {
-    process.exitCode = 1
-    let message
-    if (info.reason === 'UNKNOWN_FLAG') message = 'Unrecognized Flag: --' + info.flag.name
-    else if (info.reason === 'UNKNOWN_ARG') {
-      message = `Unrecognized Argument at index ${info.arg.index} with value ${info.arg.value}`
-    } else message = info.err?.message ?? 'Failed'
-    const cross = isWindows ? 'x' : '\x1B[31m✖\x1B[39m'
-    console.error(cross, message)
-    if (info.reason === 'UNKNOWN_FLAG' || info.reason === 'UNKNOWN_ARG') {
-      console.error('\n' + info.command.usage())
+const down = isWindows ? '↓' : '⬇'
+
+class InstallCmd extends Opstream {
+  static outputs = {
+    installing: ({ link }) => `Installing... ${link}`,
+    app: ({ app, version, upgrade, dest, key }) =>
+      `App: ${app}\nVersion: ${version}\nLink: ${upgrade}\nPathname: ${key}\nTarget: ${dest}`,
+    stats({ download, peers }) {
+      const dl =
+        download.bytes + download.speed === 0
+          ? ''
+          : ` [ ${down} ${byteSize(download.bytes)} - ${byteSize(download.speed)}/s ] `
+      return `[ Peers: ${peers} ]${dl}`
+    },
+    error: ({ message }) => message,
+    final({ success, message }) {
+      if (success) return 'Installed'
+      return message ?? 'Failed'
+    }
+  }
+  static async output(json, stream) {
+    let status = false
+    for await (const { tag, data } of stream) {
+      if (json) {
+        process.stdout.write(JSON.stringify({ cmd: 'install', tag, data }) + '\n')
+        continue
+      }
+      if (!this.outputs[tag]) continue
+      const line = this.outputs[tag](data)
+      const clear = status ? '\r\x1B[2K' : ''
+      if (tag === 'stats') {
+        process.stdout.write('\r\x1B[2K' + line)
+        status = true
+        continue
+      }
+      process.stdout.write(clear + line + '\n')
+      status = false
+      if (tag === 'final') return data
+    }
+  }
+
+  constructor(params) {
+    super((...args) => this.#op(...args), params)
+  }
+
+  async #op(opts) {
+    const install = new Install(opts)
+    install.on('installing', (data) => {
+      this.push({ tag: 'installing', data })
+    })
+    install.on('app', (data) => {
+      this.push({ tag: 'app', data })
+    })
+    install.on('stats', (data) => {
+      this.push({ tag: 'stats', data })
+    })
+    install.on('final', (data) => {
+      this.final = data
+    })
+    try {
+      await install.ready()
+    } finally {
+      await install.close()
     }
-  })
-)
+  }
+}
 
-program.parse(process.argv.slice(2))
+module.exports = InstallCmd

package/index.js

@@ -11,9 +11,8 @@ const Corestore = require('corestore')
 const Hyperdrive = require('hyperdrive')
 const Hyperswarm = require('hyperswarm')
 const plink = require('pear-link')
-const Opstream = require('pear-opstream')
 const PearError = require('pear-errors')
-const byteSize = require('tiny-byte-size')
+const ReadyResource = require('ready-resource')
 const { ERR_INVALID_MANIFEST, ERR_NOT_FOUND, ERR_PERMISSION_REQUIRED, ERR_UNKNOWN } = PearError
 
 function ERR_NETWORK_TIMEOUT(msg, info = null) {
@@ -30,245 +29,220 @@ const PEAR_DIR = isMac
     ? path.join(os.homedir(), '.config', 'pear')
     : path.join(os.homedir(), 'AppData', 'Roaming', 'pear')
 
-class Install extends Opstream {
-  static outputs = {
-    installing: ({ link }) => `Installing... ${link}`,
-    app: ({ app, version, upgrade, dest, key }) =>
-      `App: ${app}\nVersion: ${version}\nLink: ${upgrade}\nPathname: ${key}\nTarget: ${dest}`,
-    stats({ upload, download, peers }) {
-      const dl =
-        download.bytes + download.speed === 0
-          ? ''
-          : `[ down ${byteSize(download.bytes)} - ${byteSize(download.speed)}/s ] `
-      const ul =
-        upload.bytes + upload.speed === 0
-          ? ''
-          : `[ up ${byteSize(upload.bytes)} - ${byteSize(upload.speed)}/s ] `
-      return `[ Peers: ${peers} ] ${dl}${ul}`
-    },
-    error: ({ message }) => message,
-    final({ success, message }) {
-      if (success) return 'Installed'
-      return message ?? 'Failed'
-    }
-  }
-
-  constructor(params) {
-    super((...args) => this.#op(...args), params)
+class Install extends ReadyResource {
+  constructor({ link, only, to, bootstrap, timeout = 30_000, corestore = null, swarm = null }) {
+    super()
+    this.doneFinding = null
+    this.link = link
+    this.only = only
+    this.to = to
+    this.bootstrap = bootstrap
+    this.timeout = timeout
     this.targets = []
+    this.base = null
+    this.drive = null
+    this.corestore = corestore
+    this.swarm = swarm
+    this._ownCorestore = corestore === null
+    this._ownSwarm = swarm === null
   }
-
-  async #op({ link, only, to, bootstrap, timeout = 30_000 }) {
+  async _open() {
+    try {
+      await this._install()
+    } catch (err) {
+      await this._teardown()
+      throw err
+    }
+  }
+  async _install() {
+    const { link, only, to, bootstrap, timeout = 30_000 } = this
     const parsed = plink.parse(link)
     if (parsed.pathname) throw new Error('Link must not have pathname')
     const host = process.platform + '-' + process.arch
-    this.push({ tag: 'installing', data: { link, host } })
+    this.emit('installing', { link, host })
 
     const rand = crypto.randomBytes(16).toString('hex')
-    const base = path.join(PEAR_DIR, 'gc', rand)
-    fs.mkdirSync(base, { recursive: true })
-
-    const corestore = new Corestore(base)
-    const drive = new Hyperdrive(corestore, parsed.drive.key)
-    const swarm = new Hyperswarm({ bootstrap })
-
-    let findingDone = null
-    try {
-      await drive.ready()
-      findingDone = drive.findingPeers()
-      const topic = swarm.join(drive.discoveryKey, { server: false, client: true })
-      swarm.on('connection', (c) => corestore.replicate(c))
-
-      let serving = false
-      swarm.dht.on('nat-update', () => {
-        if (!swarm.dht.randomized && !serving) {
-          serving = true
-          swarm
-            .join(drive.discoveryKey, { server: true, client: false })
-            .flushed()
-            .then(() => topic.destroy())
-        }
-      })
-      const deferred = Promise.withResolvers()
-      const countdown = setTimeout(() => {
-        deferred.reject(ERR_NETWORK_TIMEOUT('Network Timeout ' + timeout / 1000 + 's'))
-      }, timeout)
-      await Promise.race([drive.core.update({ wait: true }), deferred.promise])
-      clearTimeout(countdown)
-      const pkg = await drive.get('/package.json')
-      if (pkg === null) throw ERR_INVALID_MANIFEST('Unable to read application package.json')
-      const manifest = JSON.parse(pkg.toString())
-
-      const { name, productName, version, upgrade, bin } = manifest
-      const appName = productName ?? name
-      const home = os.homedir()
-
-      if (bin) {
-        const bins = typeof bin === 'string' ? { [name]: bin } : bin
-        for (const binName of Object.keys(bins)) {
-          const ext = isWindows ? '.msix' : ''
-          const dest = isWindows
-            ? null
-            : to
-              ? path.join(to, binName + ext)
-              : isMac
-                ? path.join('/', 'usr', 'local', 'bin', binName)
-                : path.join(home, '.local', 'bin', binName)
-          this.targets.push({ filename: binName, ext, dest, isBin: true })
-        }
+    this.base = path.join(PEAR_DIR, 'gc', rand)
+    fs.mkdirSync(this.base, { recursive: true })
+
+    if (this._ownCorestore) this.corestore = new Corestore(this.base)
+    if (this._ownSwarm) this.swarm = new Hyperswarm({ bootstrap })
+
+    this.drive = new Hyperdrive(this.corestore.session(), parsed.drive.key)
+
+    await this.drive.ready()
+    this.doneFinding = this.drive.findingPeers()
+    const topic = this.swarm.join(this.drive.discoveryKey, { server: false, client: true })
+    this.swarm.on('connection', (c) => this.corestore.replicate(c))
+
+    let serving = false
+    this.swarm.dht.on('nat-update', () => {
+      if (!this.swarm.dht.randomized && !serving) {
+        serving = true
+        this.swarm
+          .join(this.drive.discoveryKey, { server: true, client: false })
+          .flushed()
+          .then(() => topic.destroy())
       }
-
-      const ext = isMac ? '.app' : isWindows ? '.msix' : '.AppImage'
-      const dest = isWindows
-        ? null
-        : to
-          ? path.join(to, appName + ext)
-          : isMac
-            ? path.join('/', 'Applications', appName + ext)
-            : fs.existsSync(path.join(home, 'Applications'))
-              ? path.join(home, 'Applications', appName + ext)
-              : fs.existsSync(path.join(home, 'AppImages'))
-                ? path.join(home, 'AppImages', appName + ext)
-                : path.join(home, '.local', 'bin', appName + ext)
-
-      this.targets.push({ filename: appName, ext, dest, isBin: false })
-
-      const present = new Set()
-      const appPath = '/by-arch/' + host + '/app/'
-      for await (const name of drive.readdir(appPath)) present.add(name)
-
-      const required = only
-        ? only
-            .split(',')
-            .map((s) => s.trim())
-            .filter(Boolean)
-        : this.targets.filter((t) => t.isBin || !bin).map((t) => t.filename + t.ext)
-      const missing = required
-        .filter((r) => !present.has(r))
-        .map((name) => plink.serialize({ ...parsed, pathname: appPath + name }))
-      if (missing.length) {
-        throw ERR_NOT_FOUND('Not found: ' + missing.join(', '))
+    })
+    const deferred = Promise.withResolvers()
+    const countdown = setTimeout(() => {
+      deferred.reject(ERR_NETWORK_TIMEOUT('Network Timeout ' + timeout / 1000 + 's'))
+    }, timeout)
+    await Promise.race([this.drive.core.update({ wait: true }), deferred.promise])
+    clearTimeout(countdown)
+    const pkg = await this.drive.get('/package.json')
+    if (pkg === null) throw ERR_INVALID_MANIFEST('Unable to read application package.json')
+    const manifest = JSON.parse(pkg.toString())
+
+    const { name, productName, version, upgrade, bin } = manifest
+    const appName = productName ?? name
+    const home = os.homedir()
+
+    if (bin) {
+      const bins = typeof bin === 'string' ? { [name]: bin } : bin
+      for (const binName of Object.keys(bins)) {
+        const ext = isWindows ? '.msix' : ''
+        const dest = isWindows
+          ? null
+          : to
+            ? path.join(to, binName + ext)
+            : isMac
+              ? path.join('/', 'usr', 'local', 'bin', binName)
+              : path.join(home, '.local', 'bin', binName)
+        this.targets.push({ filename: binName, ext, dest, isBin: true })
       }
+    }
 
-      this.targets = this.targets.filter(({ filename, ext }) => present.has(filename + ext))
-
-      const exists = []
-      const installs = []
-      for (const target of this.targets) {
-        if (isWindows) {
-          const ps = spawnSync('powershell', [
-            '-NoProfile',
-            '-Command',
-            `(Get-AppxPackage '${target.filename}') -ne $null`
-          ])
-          if (ps.stdout.toString().trim() === 'True') {
-            exists.push({ filename: target.filename, dest: target.dest })
-            continue
-          }
-        } else if (fs.existsSync(target.dest)) {
+    const ext = isMac ? '.app' : isWindows ? '.msix' : '.AppImage'
+    const dest = isWindows
+      ? null
+      : to
+        ? path.join(to, appName + ext)
+        : isMac
+          ? path.join('/', 'Applications', appName + ext)
+          : fs.existsSync(path.join(home, 'Applications'))
+            ? path.join(home, 'Applications', appName + ext)
+            : fs.existsSync(path.join(home, 'AppImages'))
+              ? path.join(home, 'AppImages', appName + ext)
+              : path.join(home, '.local', 'bin', appName + ext)
+
+    this.targets.push({ filename: appName, ext, dest, isBin: false })
+
+    const present = new Set()
+    const appPath = '/by-arch/' + host + '/app/'
+    for await (const name of this.drive.readdir(appPath)) present.add(name)
+
+    const required = only
+      ? only
+          .split(',')
+          .map((s) => s.trim())
+          .filter(Boolean)
+      : this.targets.filter((t) => t.isBin || !bin).map((t) => t.filename + t.ext)
+    const missing = required
+      .filter((r) => !present.has(r))
+      .map((name) => plink.serialize({ ...parsed, pathname: appPath + name }))
+    if (missing.length) {
+      throw ERR_NOT_FOUND('Not found: ' + missing.join(', '))
+    }
+
+    this.targets = this.targets.filter(({ filename, ext }) => present.has(filename + ext))
+
+    const exists = []
+    const installs = []
+    for (const target of this.targets) {
+      if (isWindows) {
+        const ps = spawnSync('powershell', [
+          '-NoProfile',
+          '-Command',
+          `(Get-AppxPackage '${target.filename}') -ne $null`
+        ])
+        if (ps.stdout.toString().trim() === 'True') {
           exists.push({ filename: target.filename, dest: target.dest })
           continue
         }
-        installs.push(target)
+      } else if (fs.existsSync(target.dest)) {
+        exists.push({ filename: target.filename, dest: target.dest })
+        continue
       }
+      installs.push(target)
+    }
 
-      if (installs.length === 0) {
-        const message = isWindows
-          ? `Already installed:\n${exists.map(({ filename }) => '  ' + filename).join('\n')}\n  Manually uninstall first to reinstall`
-          : `Refusing to overwrite existing:\n${exists.map(({ dest }) => '  ' + dest).join('\n')}\n  Manually remove first to reinstall`
-        throw ERR_EXISTS(message)
-      }
+    if (installs.length === 0) {
+      const message = isWindows
+        ? `Already installed:\n${exists.map(({ filename }) => '  ' + filename).join('\n')}\n  Manually uninstall first to reinstall`
+        : `Refusing to overwrite existing:\n${exists.map(({ dest }) => '  ' + dest).join('\n')}\n  Manually remove first to reinstall`
+      throw ERR_EXISTS(message)
+    }
 
-      const tmp = path.join(base, 'targets')
-      fs.mkdirSync(tmp, { recursive: true })
-      const prefixes = installs.map(({ filename, ext }) => appPath + filename + ext)
-      const mirror = drive.mirror(new LocalDrive(tmp), {
-        prefix: prefixes,
-        prune: false,
-        progress: true,
-        dedup: true
-      })
-      const monitor = mirror.monitor()
-      monitor.on('update', (stats) => this.push({ tag: 'stats', data: stats }))
-      await mirror.done()
-      monitor.destroy()
-
-      let installed = 0
-      for (const { filename, ext, dest, isBin } of installs) {
-        const key = appPath + filename + ext
-        this.push({ tag: 'app', data: { app: filename, name, version, upgrade, key, tmp, dest } })
-
-        const from = path.join(tmp, 'by-arch', host, 'app', filename + ext)
-
-        if (fs.existsSync(from) === false) {
-          throw ERR_NOT_FOUND(plink.serialize({ ...parsed, pathname: key }))
-        }
+    const tmp = path.join(this.base, 'targets')
+    fs.mkdirSync(tmp, { recursive: true })
+    const prefixes = installs.map(({ filename, ext }) => appPath + filename + ext)
+    const mirror = this.drive.mirror(new LocalDrive(tmp), {
+      prefix: prefixes,
+      prune: false,
+      progress: true,
+      dedup: true
+    })
+    const monitor = mirror.monitor()
+    monitor.on('update', (stats) => this.emit('stats', stats))
+    await mirror.done()
+    monitor.destroy()
 
-        if (isWindows) {
-          const MSIXManager = require('msix-manager')
-          await new MSIXManager().addPackage(from)
-          installed++
-          continue
-        }
+    let installed = 0
+    for (const { filename, ext, dest, isBin } of installs) {
+      const key = appPath + filename + ext
+      this.emit('app', { app: filename, name, version, upgrade, key, tmp, dest })
 
-        if (isBin) {
-          try {
-            if (!to) fs.mkdirSync(path.dirname(dest), { recursive: true })
-            this._move(from, dest)
-          } catch (err) {
-            if (err.code === 'EACCES' || err.code === 'EPERM') {
-              const dir = path.dirname(dest)
-              const fix = isMac
-                ? `sudo chgrp admin ${dir} && sudo chmod g+w ${dir}`
-                : `sudo chown -R "$(id -un):$(id -gn)" ${dir}`
-              throw ERR_PERMISSION_REQUIRED(`Permission denied: ${dest}\n  Fix: ${fix}`)
-            }
-            throw err
-          }
-          fs.chmodSync(dest, 0o755)
-        } else {
-          try {
-            await fs.promises.rename(from, dest)
-          } catch (err) {
-            if (err.code === 'EACCES' || err.code === 'EPERM') {
-              const dir = path.dirname(dest)
-              const fix = isMac
-                ? `sudo chgrp admin ${dir} && sudo chmod g+w ${dir}`
-                : `sudo chown -R "$(id -un):$(id -gn)" ${dir}`
-              throw ERR_PERMISSION_REQUIRED(`Permission denied: ${dest}\n  Fix: ${fix}`)
-            }
-            throw err
-          }
-          if (isLinux) await this._linux(dest, filename, tmp, home)
-        }
-        installed++
-      }
-      if (installed === 0) {
-        throw ERR_UNKNOWN('Failed to install')
+      const from = path.join(tmp, 'by-arch', host, 'app', filename + ext)
+
+      if (fs.existsSync(from) === false) {
+        throw ERR_NOT_FOUND(plink.serialize({ ...parsed, pathname: key }))
       }
-      this.final = { success: true, installed, exists }
-    } finally {
-      if (findingDone) findingDone()
-      await drive.close()
-      await swarm.destroy()
-      await corestore.close()
-      fs.rmSync(base, { recursive: true, force: true })
-    }
-  }
 
-  static async output(json, stream) {
-    for await (const { tag, data } of stream) {
-      if (json) {
-        process.stdout.write(JSON.stringify({ cmd: 'install', tag, data }) + '\n')
+      if (isWindows) {
+        const MSIXManager = require('msix-manager')
+        await new MSIXManager().addPackage(from)
+        installed++
         continue
       }
-      if (tag === 'final') {
-        process.stdout.write('\r\x1B[2K' + this.outputs.final(data) + '\n')
-        return data
-      } else if (this.outputs[tag]) {
-        process.stdout.write('\r\x1B[2K' + this.outputs[tag](data) + '\n')
+
+      if (isBin) {
+        try {
+          if (!to) fs.mkdirSync(path.dirname(dest), { recursive: true })
+          this._move(from, dest)
+        } catch (err) {
+          if (err.code === 'EACCES' || err.code === 'EPERM') {
+            const dir = path.dirname(dest)
+            const fix = isMac
+              ? `sudo chgrp admin ${dir} && sudo chmod g+w ${dir}`
+              : `sudo chown -R "$(id -un):$(id -gn)" ${dir}`
+            throw ERR_PERMISSION_REQUIRED(`Permission denied: ${dest}\n  Fix: ${fix}`)
+          }
+          throw err
+        }
+        fs.chmodSync(dest, 0o755)
+      } else {
+        try {
+          await fs.promises.rename(from, dest)
+        } catch (err) {
+          if (err.code === 'EACCES' || err.code === 'EPERM') {
+            const dir = path.dirname(dest)
+            const fix = isMac
+              ? `sudo chgrp admin ${dir} && sudo chmod g+w ${dir}`
+              : `sudo chown -R "$(id -un):$(id -gn)" ${dir}`
+            throw ERR_PERMISSION_REQUIRED(`Permission denied: ${dest}\n  Fix: ${fix}`)
+          }
+          throw err
+        }
+        if (isLinux) await this._linux(dest, filename, tmp, home)
       }
+      installed++
     }
+    if (installed === 0) {
+      throw ERR_UNKNOWN('Failed to install')
+    }
+    this.emit('final', { success: true, installed, exists })
   }
 
   async _linux(dest, appName, tmp, home) {
@@ -324,20 +298,35 @@ class Install extends Opstream {
       fs.rmSync(src)
     }
   }
-}
 
-module.exports = async function (cmd) {
-  const { json, only, to, dhtBootstrap } = cmd.flags
-  const timeout = (cmd.flags.timeout || 30) * 1000
-  const link = cmd.args.link
-  const bootstrap = dhtBootstrap
-    ? dhtBootstrap.split(',').map((tuple) => {
-        const [host, port] = tuple.split(':')
-        const int = +port
-        if (Number.isInteger(int) === false) throw new Error(`Invalid port: ${port}`)
-        return { host, port: int }
-      })
-    : undefined
-  const stream = new Install({ link, only, to, bootstrap, timeout })
-  await Install.output(json, stream)
+  async _close() {
+    await this._teardown()
+  }
+
+  async _teardown() {
+    if (this.doneFinding) {
+      this.doneFinding()
+      this.doneFinding = null
+    }
+    if (this.drive) {
+      await this.drive.close()
+      this.drive = null
+    }
+    if (this.swarm && this._ownSwarm) {
+      await this.swarm.destroy()
+      this.swarm = null
+    }
+    if (this.corestore && this._ownCorestore) {
+      await this.corestore.close()
+      this.corestore = null
+    }
+    if (this.base) {
+      try {
+        fs.rmSync(this.base, { recursive: true, force: true })
+      } catch {}
+      this.base = null
+    }
+  }
 }
+
+module.exports = Install

package/package.json

@@ -1,13 +1,18 @@
 {
   "name": "pear-install",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "main": "index.js",
   "type": "commonjs",
   "description": "Install Pear and Pear Applications",
   "author": "Holepunch Inc",
   "license": "Apache-2.0",
-  "bin": {
-    "pear-install": "cmd.js"
+  "files": [
+    "cmd.js"
+  ],
+  "bin": "bin.js",
+  "exports": {
+    ".": "./index.js",
+    "./cmd": "./cmd.js"
   },
   "imports": {
     "process": {

package/.gitattributes

@@ -1 +0,0 @@
-* text=auto eol=lf

package/.github/workflows/publish.yml

@@ -1,17 +0,0 @@
-name: Publish
-on:
-  push:
-    tags:
-      - v*
-permissions:
-  id-token: write
-  contents: write
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    environment:
-      name: npm
-    name: Publish
-    steps:
-      - uses: holepunchto/actions/node-base@v1
-      - uses: holepunchto/actions/publish@v1

package/.github/workflows/test.yml

@@ -1,32 +0,0 @@
-name: Test
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-    branches: [main]
-
-jobs:
-  lint:
-    runs-on: ubuntu-latest
-    name: Lint
-    steps:
-      - uses: holepunchto/actions/node-base@v1
-      - run: npm run lint
-
-  test:
-    strategy:
-      matrix:
-        include:
-          - os: ubuntu-latest
-            platform: linux
-          - os: macos-latest
-            platform: darwin
-          - os: windows-latest
-            platform: win32
-    runs-on: ${{ matrix.os }}
-    name: Test / ${{ matrix.platform }}
-    timeout-minutes: 2
-    steps:
-      - uses: holepunchto/actions/bare-base@v1
-      - run: npm test

package/.prettierignore

@@ -1 +0,0 @@
-template/appling/package.json

package/.prettierrc

@@ -1 +0,0 @@
-"prettier-config-holepunch"

package/NOTICE

@@ -1,13 +0,0 @@
-Copyright 2026 Holepunch Inc
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.

package/test/all.js

@@ -1,13 +0,0 @@
-// This runner is auto-generated by Brittle
-
-runTests()
-
-async function runTests() {
-  const test = (await import('brittle')).default
-
-  test.pause()
-
-  await import('./index.test.js')
-
-  test.resume()
-}

package/test/helper.js

@@ -1,80 +0,0 @@
-'use strict'
-const Corestore = require('corestore')
-const Hyperdrive = require('hyperdrive')
-const Hyperswarm = require('hyperswarm')
-const tmp = require('test-tmp')
-const { command, arg, bail } = require('paparam')
-const pkg = require('../package.json')
-const install = require('..')
-const process = require('process')
-const arch = `${process.platform}-${process.arch}`
-
-async function seed(t, { bootstrap, manifest, files }) {
-  const storage = await tmp(t)
-  const corestore = new Corestore(storage)
-  const drive = new Hyperdrive(corestore)
-  await drive.ready()
-  await drive.put('/package.json', Buffer.from(JSON.stringify(manifest)))
-  for (const [p, content] of Object.entries(files)) {
-    await drive.put(p, Buffer.from(content))
-  }
-  const swarm = new Hyperswarm({ bootstrap })
-  swarm.on('connection', (c) => corestore.replicate(c))
-  swarm.join(drive.discoveryKey, { server: true, client: false })
-  await swarm.flush()
-  t.teardown(async () => {
-    await swarm.destroy()
-    await drive.close()
-    await corestore.close()
-  })
-  return drive.key
-}
-
-async function run(args) {
-  const lines = []
-  let buf = ''
-  const origWrite = process.stdout.write
-  const origExitCode = process.exitCode
-  process.stdout.write = function (chunk) {
-    buf += chunk.toString()
-    let i
-    while ((i = buf.indexOf('\n')) !== -1) {
-      lines.push(buf.slice(0, i))
-      buf = buf.slice(i + 1)
-    }
-    return true
-  }
-  let bailInfo = null
-  let exitCode
-  try {
-    const program = command(
-      'install',
-      arg('[link]', 'Pear link'),
-      pkg.command,
-      install,
-      bail((info) => {
-        bailInfo = info
-      })
-    )
-    const c = program.parse(args, { run: true })
-    if (c?.running) await c.running.catch(() => {})
-  } finally {
-    process.stdout.write = origWrite
-    exitCode = process.exitCode
-    process.exitCode = origExitCode
-  }
-  const events = lines.flatMap((l) => {
-    try {
-      return [JSON.parse(l)]
-    } catch {
-      return []
-    }
-  })
-  return { events, bail: bailInfo, stdout: lines.join('\n') + buf, exitCode }
-}
-
-function bootstrapArg(testnet) {
-  return testnet.bootstrap.map((b) => `${b.host}:${b.port}`).join(',')
-}
-
-module.exports = { seed, run, arch, bootstrapArg }

package/test/index.test.js

@@ -1,238 +0,0 @@
-'use strict'
-const test = require('brittle')
-const path = require('path')
-const fs = require('fs')
-const createTestnet = require('hyperdht/testnet')
-const hypercoreCrypto = require('hypercore-crypto')
-const hid = require('hypercore-id-encoding')
-const plink = require('pear-link')
-const { isWindows } = require('which-runtime')
-const tmp = require('test-tmp')
-const { seed, run, arch, bootstrapArg } = require('./helper')
-
-test('successful bin install via testnet', { skip: isWindows }, async function (t) {
-  t.timeout(60000)
-  const testnet = await createTestnet(3, t.teardown)
-  const key = await seed(t, {
-    bootstrap: testnet.bootstrap,
-    manifest: { name: 'tbin', version: '1.0.0', upgrade: 'pear://x', bin: 'cli.js' },
-    files: { ['/by-arch/' + arch + '/app/tbin']: 'BIN' }
-  })
-  const link = plink.serialize({ drive: { key } })
-  const target = await tmp(t)
-  const { events } = await run([
-    '--json',
-    '--to',
-    target,
-    '--dht-bootstrap',
-    bootstrapArg(testnet),
-    link
-  ])
-  const final = events.find((e) => e.tag === 'final')
-  t.ok(final, 'final event emitted')
-  t.is(final.data.success, true, 'success')
-  t.is(fs.readFileSync(path.join(target, 'tbin'), 'utf8'), 'BIN', 'bin written to target')
-})
-
-test('notFound emits full pear:// link when platform binary missing', async function (t) {
-  t.timeout(60000)
-  const testnet = await createTestnet(3, t.teardown)
-  const key = await seed(t, {
-    bootstrap: testnet.bootstrap,
-    manifest: { name: 'tbin', version: '1.0.0', upgrade: 'pear://x', bin: 'cli.js' },
-    files: {}
-  })
-  const link = plink.serialize({ drive: { key } })
-  const target = await tmp(t)
-  const { events } = await run([
-    '--json',
-    '--to',
-    target,
-    '--dht-bootstrap',
-    bootstrapArg(testnet),
-    link
-  ])
-  const final = events.find((e) => e.tag === 'final')
-  const error = events.find((e) => e.tag === 'error')
-  t.ok(final, 'final event emitted')
-  t.is(final.data.success, false, 'failure')
-  t.is(error?.data.code, 'ERR_NOT_FOUND', 'ERR_NOT_FOUND emitted')
-  t.ok(error?.data.message.includes('pear://'), 'error message includes pear link')
-  t.ok(
-    error?.data.message.includes('/by-arch/' + arch + '/app/tbin'),
-    'error message includes platform path'
-  )
-})
-
-test('refuses to overwrite an existing install', { skip: isWindows }, async function (t) {
-  t.timeout(60000)
-  const testnet = await createTestnet(3, t.teardown)
-  const key = await seed(t, {
-    bootstrap: testnet.bootstrap,
-    manifest: { name: 'tbin', version: '1.0.0', upgrade: 'pear://x', bin: 'cli.js' },
-    files: { ['/by-arch/' + arch + '/app/tbin']: 'NEW' }
-  })
-  const link = plink.serialize({ drive: { key } })
-  const target = await tmp(t)
-  fs.writeFileSync(path.join(target, 'tbin'), 'EXISTING')
-  const { events } = await run([
-    '--json',
-    '--to',
-    target,
-    '--dht-bootstrap',
-    bootstrapArg(testnet),
-    link
-  ])
-  const final = events.find((e) => e.tag === 'final')
-  const error = events.find((e) => e.tag === 'error')
-  t.ok(final, 'final event emitted')
-  t.is(final.data.success, false, 'failure')
-  t.is(error?.data.code, 'ERR_EXISTS', 'ERR_EXISTS emitted')
-  t.ok(
-    error?.data.message.includes('Refusing to overwrite existing'),
-    'error message reports refusal'
-  )
-  t.ok(
-    error?.data.message.includes(path.join(target, 'tbin')),
-    'error message lists existing target path'
-  )
-  t.is(fs.readFileSync(path.join(target, 'tbin'), 'utf8'), 'EXISTING', 'existing file untouched')
-})
-
-test('invalid port in --dht-bootstrap reaches bail handler', async function (t) {
-  const { bail: info } = await run([
-    '--dht-bootstrap',
-    '127.0.0.1:nope',
-    'pear://aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
-  ])
-  t.ok(info, 'bail handler invoked')
-  t.is(info.err?.message, 'Invalid port: nope')
-})
-
-test('link with pathname emits error event', async function (t) {
-  const key = hid.encode(hypercoreCrypto.keyPair().publicKey)
-  const link = `pear://${key}/some/path`
-  const { events } = await run(['--json', link])
-  const error = events.find((e) => e.tag === 'error')
-  t.ok(error, 'error event emitted')
-  t.is(error.data.message, 'Link must not have pathname')
-})
-
-test(
-  'non-json output prints installing, app and Installed',
-  { skip: isWindows },
-  async function (t) {
-    t.timeout(60000)
-    const testnet = await createTestnet(3, t.teardown)
-    const key = await seed(t, {
-      bootstrap: testnet.bootstrap,
-      manifest: { name: 'tbin', version: '1.0.0', upgrade: 'pear://x', bin: 'cli.js' },
-      files: { ['/by-arch/' + arch + '/app/tbin']: 'BIN' }
-    })
-    const link = plink.serialize({ drive: { key } })
-    const target = await tmp(t)
-    const { stdout } = await run(['--to', target, '--dht-bootstrap', bootstrapArg(testnet), link])
-    t.ok(stdout.includes('Installing...'), 'installing message printed')
-    t.ok(stdout.includes('App: tbin'), 'app message printed')
-    t.ok(stdout.includes('Installed'), 'final installed message printed')
-  }
-)
-
-test(
-  'non-json output prints Not found for missing platform binary',
-  { skip: isWindows },
-  async function (t) {
-    t.timeout(60000)
-    const testnet = await createTestnet(3, t.teardown)
-    const key = await seed(t, {
-      bootstrap: testnet.bootstrap,
-      manifest: { name: 'tbin', version: '1.0.0', upgrade: 'pear://x', bin: 'cli.js' },
-      files: {}
-    })
-    const link = plink.serialize({ drive: { key } })
-    const target = await tmp(t)
-    const { stdout } = await run(['--to', target, '--dht-bootstrap', bootstrapArg(testnet), link])
-    t.ok(stdout.includes('Not found: pear://'), 'not found message printed')
-  }
-)
-
-test(
-  'non-json output prints Refusing to overwrite for existing target',
-  { skip: isWindows },
-  async function (t) {
-    t.timeout(60000)
-    const testnet = await createTestnet(3, t.teardown)
-    const key = await seed(t, {
-      bootstrap: testnet.bootstrap,
-      manifest: { name: 'tbin', version: '1.0.0', upgrade: 'pear://x', bin: 'cli.js' },
-      files: { ['/by-arch/' + arch + '/app/tbin']: 'BIN' }
-    })
-    const link = plink.serialize({ drive: { key } })
-    const target = await tmp(t)
-    fs.writeFileSync(path.join(target, 'tbin'), 'EXISTING')
-    const { stdout } = await run(['--to', target, '--dht-bootstrap', bootstrapArg(testnet), link])
-    t.ok(stdout.includes('Refusing to overwrite existing'), 'refusing message printed')
-    t.ok(stdout.includes('Manually remove first'), 'fix hint printed')
-  }
-)
-
-test('_move falls back to copy+rm on EXDEV', { skip: isWindows }, async function (t) {
-  t.timeout(60000)
-  const testnet = await createTestnet(3, t.teardown)
-  const key = await seed(t, {
-    bootstrap: testnet.bootstrap,
-    manifest: { name: 'tbin', version: '1.0.0', upgrade: 'pear://x', bin: 'cli.js' },
-    files: { ['/by-arch/' + arch + '/app/tbin']: 'BIN' }
-  })
-  const link = plink.serialize({ drive: { key } })
-  const target = await tmp(t)
-  const renameSync = fs.renameSync
-  fs.renameSync = function () {
-    const err = new Error('cross-device link not permitted')
-    err.code = 'EXDEV'
-    throw err
-  }
-  t.teardown(() => {
-    fs.renameSync = renameSync
-  })
-  const { events } = await run([
-    '--json',
-    '--to',
-    target,
-    '--dht-bootstrap',
-    bootstrapArg(testnet),
-    link
-  ])
-  const final = events.find((e) => e.tag === 'final')
-  t.is(final?.data?.success, true, 'install succeeded via copy+rm fallback')
-  t.is(fs.readFileSync(path.join(target, 'tbin'), 'utf8'), 'BIN', 'bin content copied to target')
-})
-
-test('permission denied when target dir is read-only', { skip: isWindows }, async function (t) {
-  t.timeout(60000)
-  const testnet = await createTestnet(3, t.teardown)
-  const key = await seed(t, {
-    bootstrap: testnet.bootstrap,
-    manifest: { name: 'tbin', version: '1.0.0', upgrade: 'pear://x', bin: 'cli.js' },
-    files: { ['/by-arch/' + arch + '/app/tbin']: 'BIN' }
-  })
-  const link = plink.serialize({ drive: { key } })
-  const target = await tmp(t)
-  fs.chmodSync(target, 0o555)
-  t.teardown(() => {
-    try {
-      fs.chmodSync(target, 0o755)
-    } catch {}
-  })
-  const { events, stdout } = await run([
-    '--to',
-    target,
-    '--dht-bootstrap',
-    bootstrapArg(testnet),
-    link
-  ])
-  // since no --json, events is empty; assert via stdout
-  t.is(events.length, 0, 'no json events (non-json mode)')
-  t.ok(stdout.includes('Permission denied'), 'permission message printed')
-  t.ok(stdout.includes('Fix:'), 'fix hint printed')
-})