pear-mobile 1.0.0-rc → 1.0.1

package/README.md

@@ -6,75 +6,103 @@ Embeddable Pear runtime for mobile applications. Provides storage path and bare
 npm install pear-mobile
 ```
 
-```sh
-npm install react-native-bare-kit --save
-```
+This module integrates Pear into React-Native-based Mobile applications.
 
-Requires `react-native-bare-kit` to be listed in project dependencies.
+See [pear-runtime](https://github.com/holepunchto/pear-runtime) for Pear's embeddable runtime module for Desktop Devices.
 
-## Usage
+## MVP - EXPERIMENTAL
 
-```js
-/* React Native */
-import PearRuntime from 'pear-mobile'
-import bundle from './worker.bundle.js'
-import { version, upgrade } from './package.json'
+This boilerplate is MVP and Experimental.
 
-const runtime = new PearRuntime()
-const IPC = runtime.run('/worker.bundle', bundle, [runtime.dir])
+## Usage
 
-/* Bare Worklet */
-const PearRuntime = require('pear-runtime')
+```js
+const PearRuntime = require('pear-mobile')
 const { version, upgrade } = require('./package.json')
 
-const dir = Bare.argv[0]
+const dir = Bare.argv[0] // pass the /Documents storage dir
 
-const runtime = new PearRuntime({version, upgrade, dir})
-runtime.on('updated', () => {
-    runtime.applyUpdate()
-    conosle.log('restart for update')
+const runtime = new PearRuntime({ version, upgrade, dir })
+runtime.updater.on('updated', async () => {
+  await runtime.updater.applyUpdate()
+  conosle.log('restart for update')
 })
 ```
 
+## Quick Starts
+
+### Expo
+
+```sh
+git clone https://github.com/holepunchto/hello-pear-react-native
+```
+
+For end-to-end instructions from building to deploying with [Pear](https://docs.pears.com) see [hello-pear-react-native](https://github.com/holepunchto/hello-pear-react-native) `README.md`.
+
+## Features
+
+- Peer-to-Peer Over-the-Air (P2P OTA) updates (via [pear-runtime-updater](https://www.github.com/holepunchto/pear-runtime-updater))
+- Application storage management
+
 ## API
 
-#### `const runtime = new PearRuntime(...)`
+#### `const pear = new PearRuntime(opts)`
+
+Create a runtime. `opts` may include:
 
-Create a runtime.
+- **`dir`** (required) Directory to store data (e.g. app data dir).
+- **`upgrade`** – (required) Pear link for OTA updates (e.g. from `package.json` `upgrade` field).
+- **`version`** – Current app version (e.g. from `package.json`); used for update checks.
+- **`app`** – Path to the native boot bundle override; required for `applyUpdate()` to swap in the new build. Defaults to `path/to/Documents/pear-runtime/upgrades`
+- **`updates`** – Set to `false` to disable P2P OTA updates.
+- **`storage`** – Saves the app storage path.
 
-#### `runtime.storage`
+#### `pear.storage`
 
-Absolute path to the runtime app storage directory.
+Suggested storage folder for app storage.
 
-#### `runtime.on(event, callback)`
+#### `pear.updater`
 
-Subscribe to an event. Returns `runtime` for chaining.
+Instance of [pear-runtime-updater](https://www.github.com/holepunchto/pear-runtime-updater)
 
-#### `runtime.off(event, callback?)`
+#### `await updater.ready()`
 
-Unsubscribe: remove `callback` for `event`, or remove all listeners for `event` if `callback` is omitted. Returns `runtime`.
+Awaits the open of the updater (p2p connections, drive open ...)
 
-#### `runtime.once(event, callback)`
+#### `await pear.close()`
 
-Subscribe to an event once; listener is removed after the first emit. Returns `runtime`.
+Shut it down. You should do this when closing your app for best performance.
 
-#### `IPC = runtime.run(filename, bundle, argv)`
+## Making updates
 
-Start a bare worker (worklet). Returns an IPC duplex stream. `filename` is a virtual path, `bundle` is the worklet bundle, `argv` is an array of string arguments.
+VERY EXPERIMENTAL, MOST DEFINITELY WILL CHANGE.
 
-`Bare.argv` in worker to access `argv`.
+Update listening and apply logic lives in [pear-runtime-updater](https://www.github.com/holepunchto/pear-runtime-updater).
 
-#### `runtime.ready()`
+First allocate a pear link if you haven't using [`pear`](https://github.com/holepunchto/pear):
 
-Returns a Promise. No-op on mobile; for API compatibility.
+```sh
+pear touch
+```
 
-#### `runtime.close()`
+Store this link in the `package.json` `upgrade` field of a project.
 
-Returns a Promise. No-op on mobile; for API compatibility.
+bundle your JS frontend. Take the distributable (e.g react-native bundle and assets) produced and make a deployment folder with the following structure:
 
-#### `runtime.applyUpdate()`
+```
+/package.json
+/by-arch
+  /[...platform-arch]
+    /app
+```
+
+Now go to this folder and stage this onto the link with `pear stage`
+
+```sh
+pear stage {link-from-touch}
+```
 
-Returns a Promise. On mobile this is not supported and only logs a warning; for API compatibility.
+Now seed it. Any build out there on a lower version will trigger the update flow.
 
 ## LICENSE
 

package/index.js

@@ -1,126 +1,31 @@
-/* global BareKit */
-
-const Hyperswarm = require('hyperswarm')
-const Hyperdrive = require('hyperdrive')
-const Corestore = require('corestore')
+const PearRuntimeUpdater = require('pear-runtime-updater')
+const ReadyResouce = require('ready-resource')
 const path = require('bare-path')
 const fs = require('bare-fs')
-const fsx = require('fs-native-extensions')
-const ReadyResource = require('ready-resource')
-const plink = require('pear-link')
-const hid = require('hypercore-id-encoding')
-const Localdrive = require('localdrive')
-const { isIOS } = require('which-runtime')
+const dir = require('bare-storage')
 
-module.exports = class PearRuntime extends ReadyResource {
-  constructor(config) {
+module.exports = class PearRuntime extends ReadyResouce {
+  constructor(opts = {}) {
     super()
-    if (!config.dir) throw new Error('PearRuntime needs "dir" to /Documents Sandbox')
-    const { drive: upgrade } = plink.parse(config.upgrade)
-    this.dir = config.dir
-    this.version = config.version || 0
-    this.app = path.join(this.dir, 'pear-runtime/upgrade', isIOS ? 'runtime.ios.bundle' : 'runtime.android.bundle')
-    this.name = isIOS ? 'runtime.ios.bundle' : 'runtime.android.bundle'
-    this.key = hid.decode(upgrade.key)
-    this.length = upgrade.length || 0
-    this.fork = upgrade.fork || 0
-    this.link = plink.serialize({ drive: { fork: this.fork, length: this.length, key: this.key }})
-    this.store = config.store || new Corestore(path.join(this.dir, 'pear-runtime/corestore'))
-    this.drive = new Hyperdrive(this.store, this.key)
-    this.swarm = config.swarm || null
-    this.next = null
-    this.checkout = null
-
-    this.updating = false
-    this.updated = false
+    if (!opts.dir) opts.dir = dir.persistent()
+    const appPath = opts.app || path.join(opts.dir, 'pear-runtime', 'upgrade')
+    if (!fs.existsSync(appPath)) fs.mkdirSync(appPath, { recursive: true, force: true })
+    if (fs.existsSync(path.join(appPath, 'package.json'))) {
+      const manifest = fs.readFileSync(path.join(appPath, 'package.json'))
+      opts.version = JSON.parse(manifest).version
+    }
+    opts = { app: appPath, ...opts }
+    this.dir = opts.dir
+    this.storage = opts.storage || path.join(this.dir, 'app-storage')
 
-    this.ready().catch(noop)
+    this.updater = new PearRuntimeUpdater(opts)
   }
 
   async _open() {
-    await this.drive.ready()
-    await fs.rm(path.join(this.dir, 'pear-runtime/next'), {
-        recursive: true,
-        force: true
-      })
-    await fs.mkdir(path.join(this.dir, 'pear-runtime/next'), { recursive: true, force: true })
-    if (!this.swarm) {
-      const keyPair = await this.store.createKeyPair('pear-container')
-      this.swarm = new Hyperswarm({ keyPair })
-    }
-    
-    this.swarm.on('connection', (connection) => this.store.replicate(connection))
-    this.swarm.join(this.drive.core.discoveryKey, { client: true, server: false })
-    
-    this._updateBackground()
-    this.drive.core.on('append', () => this._updateBackground())
+    await this.updater.ready()
   }
 
   async _close() {
-    await this.drive.close()
-    if (this.checkout) await this.checkout.close()
-    await this.store.destroy()
-    await this.swarm.destroy()
-  }
-
-  async applyUpdate() {
-    // we apply the update the same way bc react-native will always try to boot (e.g) upgrade/runtime.ios.bundle first
-    if (!this.updated || this.applied || !this.dir) return
-    this.applied = true
-    if (!await fs.exists(this.app)) {
-      await fs.mkdir(path.join(this.dir, 'pear-runtime/upgrade'), { recursive: true, force: true })
-      await fs.writeFile(this.app, '')
-    }
-
-    await fsx.swap(path.join(this.next, this.name), this.app)
-    await fs.promises.rm(this.next, { recursive: true, force: true })
-  }
-
-  _updateBackground() {
-    this._update().catch(noop)
-  }
-
-  async _update() {
-    if (this.updating) return
-    this.updating = true
-
-    const length = this.drive.core.length
-    const id = length + '.' + this.drive.core.fork
-    const next = path.join(this.dir, 'pear-runtime/next', id)
-    const co = this.drive.checkout(length)
-
-    this.checkout = co
-
-    const manifest = await co.get('/package.json')
-    const version = manifest && JSON.parse(manifest).version
-    if (!manifest || version === this.version) {
-      this.updating = false
-      this.checkout = null
-      await co.close()
-      return
-    }
-
-    const local = new Localdrive(next)
-
-    this.emit('updating')
-
-    for await (const data of co.mirror(local)) {
-      this.emit('updating-delta', data)
-    }
-
-    await co.close()
-    await local.close()
-
-    this.checkout = null
-    this.length = length
-    this.next = next
-
-    this.updating = false
-    this.updated = true
-    this.emit('updated', version)
-
-    if (this.drive.core.length > length) this._updateBackground()
+    await this.updater.close()
   }
 }
-
-function noop() {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pear-mobile",
-  "version": "1.0.0-rc",
+  "version": "1.0.1",
   "description": "Embeddable Pear runtime for mobile applications",
   "main": "index.js",
   "exports": {
@@ -38,18 +38,10 @@
     "prettier-config-holepunch": "^2.0.0"
   },
   "dependencies": {
+    "bare-fs": "^4.5.4",
     "bare-path": "^3.0.0",
-    "corestore": "^7.8.0",
-    "fs-native-extensions": "^1.4.5",
-    "hypercore-id-encoding": "^1.3.0",
-    "hyperdrive": "^13.2.1",
-    "hyperswarm": "^4.16.0",
-    "localdrive": "^2.2.0",
-    "pear-link": "^4.2.1",
-    "ready-resource": "^1.2.0",
-    "which-runtime": "^1.3.2"
-  },
-  "peerDependencies": {
-    "react-native-bare-kit": "*"
+    "bare-storage": "^1.0.1",
+    "pear-runtime-updater": "^0.0.13",
+    "ready-resource": "^1.2.0"
   }
 }