Pear

https://docs.pears.com
Admin
Pear is an installable peer-to-peer runtime, development, and deployment platform for building,...
Tokens:968,975
Snippets:9,021
Trust Score:7.8
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Quickstart: server and client

Source: https://docs.pears.com/p2p/reference/building-blocks/hyperswarm

Quickstart example showing how to create a server and client swarm, join a topic, and handle connections.

```js
import Hyperswarm from 'hyperswarm'

const server = new Hyperswarm()
const client = new Hyperswarm()

server.on('connection', socket => {
  socket.end('hello from the server')
})

client.on('connection', socket => {
  socket.once('data', async buf => {
    console.log(buf.toString())
    await Promise.all([client.destroy(), server.destroy()])
  })
})

const topic = Buffer.alloc(32).fill('pear-docs-topic')
const discovery = server.join(topic, { server: true, client: false })
await discovery.flushed()

client.join(topic, { server: false, client: true })
await client.flush()
```

--------------------------------

### MirrorDrive quickstart

Source: https://docs.pears.com/p2p/reference/helpers/mirrordrive

Quickstart example: creates a MirrorDrive from a Localdrive source to a Hyperdrive destination, enables pruning, and iterates to apply diffs.

```js
import Corestore from 'corestore'
import Hyperdrive from 'hyperdrive'
import Localdrive from 'localdrive'
import MirrorDrive from 'mirror-drive'

const store = new Corestore('./storage')
const src = new Localdrive('./site')
const dst = new Hyperdrive(store)

await dst.ready()

const mirror = new MirrorDrive(src, dst, { prune: true })

for await (const diff of mirror) {
  console.log(diff)
}
```

--------------------------------

### Hypercore quickstart

Source: https://docs.pears.com/p2p/reference/building-blocks/hypercore

Quickstart example showing how to create a Hypercore instance, append blocks, read them, stream all blocks, and close the core.

```js
import Hypercore from 'hypercore'

const core = new Hypercore('./my-first-core', { valueEncoding: 'utf-8' })
await core.ready()

await core.append('hello')
await core.append('from hypercore')

console.log('length:', core.length)
console.log('first block:', await core.get(0))
console.log('second block:', await core.get(1))

for await (const block of core.createReadStream()) {
  console.log('streamed:', block)
}

await core.close()
```

--------------------------------

### Autobee quickstart with corestore

Source: https://docs.pears.com/p2p/reference/building-blocks/autobee

Quickstart example that creates a new Autobee, appends a JSON operation, updates the view, and reads back the value. The output is 'hello'.

```js
import Corestore from 'corestore'
import Autobee from 'autobee'
import b4a from 'b4a'

const store = new Corestore('./autobee-demo')
const db = new Autobee(store, null, {
  async apply (nodes, view) {
    for (const node of nodes) {
      const op = JSON.parse(b4a.toString(node.value))
      const batch = view.write()
      batch.tryPut(b4a.from(op.key), b4a.from(op.value))
      await batch.flush()
    }
  }
})

await db.ready()
await db.append(b4a.from(JSON.stringify({ key: 'greeting', value: 'hello' })))
await db.update()

const entry = await db.view.get(b4a.from('greeting'))
console.log(b4a.toString(entry.value))
// hello
```

--------------------------------

### Quickstart: create a drive, put and get a file

Source: https://docs.pears.com/p2p/reference/building-blocks/hyperdrive

Creates a Hyperdrive instance, writes a file with metadata, reads it back, and closes the drive.

```js
import Corestore from 'corestore'
import Hyperdrive from 'hyperdrive'

const store = new Corestore('./storage')
const drive = new Hyperdrive(store)

await drive.ready()

await drive.put('/hello.txt', Buffer.from('hello world'), {
  metadata: { type: 'text/plain' }
})

const buffer = await drive.get('/hello.txt')
const entry = await drive.entry('/hello.txt')

console.log(buffer.toString())
console.log(entry?.value.metadata)

await drive.close()
```

--------------------------------

### Quickstart: create a Localdrive and put/get files

Source: https://docs.pears.com/p2p/reference/helpers/localdrive

Creates a Localdrive instance for the './site' directory, writes an HTML file, reads it back, and logs the content and entry. Demonstrates basic put, get, and entry usage.

```js
import Localdrive from 'localdrive'

const drive = new Localdrive('./site')

await drive.put('/index.html', Buffer.from('<h1>Hello</h1>'))
const html = await drive.get('/index.html')

console.log(html?.toString())
console.log(await drive.entry('/index.html'))
```

--------------------------------

### Corestore quickstart example

Source: https://docs.pears.com/p2p/reference/helpers/corestore

Creates a Corestore instance, loads a named core, appends a message, and reads it back. Demonstrates the basic usage pattern.

```js
import Corestore from 'corestore'

const store = new Corestore('./app-storage')
await store.ready()

const messages = store.get({
  name: 'messages',
  valueEncoding: 'json'
})

await messages.ready()
await messages.append({ text: 'hello from corestore' })

console.log(await messages.get(0))

await store.close()
```

--------------------------------

### Install and start blind-peer-cli

Source: https://docs.pears.com/p2p/explanation/blind-peering

Install the blind-peer-cli package globally and start the blind peer server. On startup, the process logs a `Listening at <key>` line (ndjson) that identifies the blind peer's public key, used by clients as one of their configured `keys`. The default disk budget is 100 GB; cap it with `-m <size>` (megabytes).

```bash
npm i -g blind-peer-cli
blind-peer
```

--------------------------------

### Install bare-os with npm

Source: https://docs.pears.com/bare/reference/bare/modules/bare-os

Install the bare-os package using npm. This is the required setup step before using the module.

```sh
npm i bare-os
```

--------------------------------

### Start a blind peer with blind-peer-cli

Source: https://docs.pears.com/p2p/how-to/blind-peering/add-blind-peering-to-a-chat-app

Install and run a blind peer with blind-peer-cli. On startup it logs a `Listening at <key>` line; copy that key to pass to both users as `--blind-peer-key`.

```bash
npm install -g blind-peer-cli
blind-peer
# {"level":30, ... ,"msg":"Listening at es4n7ty45odd1udfqyi9xz58mrbheuhdnxgdufsn9gz6e5uhsqco"}
```

--------------------------------

### Clone and build the pear-chat example

Source: https://docs.pears.com/p2p/getting-started/build-a-peer-to-peer-chat/reshape-into-a-production-app

Clone the pear-docs repository, switch to the published branch, and install dependencies. Then run `npm run build` to generate the spec/ directory and compile Tailwind CSS before the first `npm start`.

```bash
git clone https://github.com/holepunchto/pear-docs
cd pear-docs
git switch published
cd examples/getting-started/pear-chat
npm install
npm run build

```

--------------------------------

### Setup commands for multicore-writer-app

Source: https://docs.pears.com/p2p/how-to/store-and-replicate/work-with-many-hypercores-using-corestore

Commands to create the project directory, initialize npm, set module type, and install dependencies: bare-process, corestore, hyperswarm, and b4a.

```sh
mkdir multicore-writer-app
cd multicore-writer-app
npm init -y
npm pkg set type="module"
npm install bare-process corestore hyperswarm b4a
```

--------------------------------

### Setup reader-app: create directory and install dependencies

Source: https://docs.pears.com/p2p/how-to/store-and-replicate/replicate-and-persist-with-hypercore

Creates the reader-app directory, initializes an npm project, sets the module type, and installs the required dependencies: bare-path, bare-process, hypercore, and hyperswarm.

```sh
mkdir reader-app
cd reader-app
npm init -y
npm pkg set type="module"
npm install bare-path bare-process hypercore hyperswarm
```

--------------------------------

### Install Flatpak tools and Flatpak Builder

Source: https://docs.pears.com/pear/how-to/operate-an-app/build-and-package/submit-to-app-stores

Install Flatpak tools and add the Flathub remote, then install the Flatpak Builder.

```sh
sudo apt install flatpak
flatpak remote-add --if-not-exists --user flathub https://dl.flathub.org/repo/flathub.flatpakrepo
flatpak install flathub org.flatpak.Builder
```

--------------------------------

### install(opts?: InstallOptions): Promise<void>

Source: https://docs.pears.com/bare/reference/bare/modules/bare-make

Installs the built native module. This function installs the module to a specified prefix, with options for linking and stripping.

```APIDOC
## [POST] /install

### Description
Installs the built native module. This function installs the module to a specified prefix, with options for linking and stripping.

### Method
POST

### Endpoint
/install

### Parameters
#### Query Parameters
- **opts** (InstallOptions) - Optional - Options for installation. `build` defaults to `'build'`, `prefix` to `'prebuilds'`, and `link`, `strip`, and `verbose` to `false`.

### Request Example
{
  "build": "build",
  "prefix": "prebuilds",
  "link": false,
  "strip": false,
  "verbose": false
}

### Response
#### Success Response (200)
- **void** - No response body.

#### Response Example
{}

### Error Handling
- **INSTALL_FAILED** - The install exits with a non-zero status.
```

--------------------------------

### Install Pear CLI with curl

Source: https://docs.pears.com/

Installs the Pear CLI from install.pears.com. Run this command in a terminal to get the `pear` CLI. See the Getting started guide for Windows, npx, and Docker installs.

```bash
curl https://install.pears.com/pear.sh | sh
```

--------------------------------

### Install react-native-bare-kit and b4a

Source: https://docs.pears.com/bare/how-to/run-on-native/embed-bare-in-react-native

Install the react-native-bare-kit and b4a packages. For Expo, follow the bare-expo example for the config-plugin setup.

```sh
npm i react-native-bare-kit b4a
```

--------------------------------

### Mark and sweep example

Source: https://docs.pears.com/p2p/reference/building-blocks/hypercore

Demonstrates the mark-and-sweep workflow: start marking, get blocks to mark them, then sweep to clear all unmarked blocks.

```javascript
await core.startMarking()
await core.get(2)
await core.get(4)
await core.sweep() // All blocks but blocks 2 & 4 are cleared
```

--------------------------------

### Build and start the creator

Source: https://docs.pears.com/p2p/how-to/stream-and-share-media/stream-a-live-camera-in-a-peer-to-peer-app

Build the app and start the creator instance with a storage directory and a name. The invite is printed to stdout.

```bash
npm run build

# creator
npm start -- --storage /tmp/cam-creator --name camera-host
```

--------------------------------

### HyperDHT quickstart: create server and connect

Source: https://docs.pears.com/p2p/reference/building-blocks/hyperdht

Shows how to create a DHT node, a server, and connect a client to it. The server sends a message and the client logs the response.

```js
import DHT from 'hyperdht'
import { once } from 'node:events'

const serverNode = new DHT()
const clientNode = new DHT()
const keyPair = DHT.keyPair()

const server = serverNode.createServer(socket => {
  socket.end('hello from hyperdht')
})

await server.listen(keyPair)
const socket = clientNode.connect(keyPair.publicKey)

await once(socket, 'open')
socket.write('ping')

for await (const chunk of socket) {
  console.log(chunk.toString())
}

await server.close()
await Promise.all([serverNode.destroy(), clientNode.destroy()])
```

--------------------------------

### Install hypertele

Source: https://docs.pears.com/p2p/reference/tools/hyperssh

Install hypertele globally for end-to-end setups, as the remote side needs it to expose SSH, SSHFS-backed traffic, or RDP over HyperDHT.

```sh
npm i -g hypertele
```

--------------------------------

### Example: start a tunnel-only server with host and port allowlist

Source: https://docs.pears.com/p2p/reference/tools/hypershell

Start a Hypershell server restricted to the tunnel protocol, allowing only connections to 127.0.0.1 on port 3000.

```sh
hypershell-server --protocol tunnel --tunnel-host 127.0.0.1 --tunnel-port 3000
```

--------------------------------

### Build and start host peer

Source: https://docs.pears.com/p2p/how-to/stream-and-share-media/stream-stored-video-in-a-peer-to-peer-app

Builds the app and starts the host peer with a storage directory and name. The host is the first peer that shares the video.

```bash
npm run build

# host
npm start -- --storage /tmp/video-host --name host
```

--------------------------------

### Usage example for bare-vm

Source: https://docs.pears.com/bare/reference/bare/modules/bare-vm

Shows how to create a context and run code in it, and how to run code in a new context directly.

```js
const vm = require('bare-vm')

const context = vm.createContext()
vm.runInContext('x = 40; x += 2', context) // 42

vm.runInNewContext('x = 40; x += 2') // 42
```

--------------------------------

### Protomux quickstart: create channel and send message

Source: https://docs.pears.com/p2p/reference/helpers/protomux

Shows how to create a Protomux instance, open a channel, add a message handler, and send a message. Requires a framed encrypted stream (e.g., from Secretstream) and uses compact-encoding for message schemas.

```js
import Protomux from 'protomux'
import cenc from 'compact-encoding'

const mux = new Protomux(aFramedEncryptedStream)

const channel = mux.createChannel({
  protocol: 'chat',
  onopen() {
    console.log('chat channel opened')
  }
})

const message = channel.addMessage({
  encoding: cenc.string,
  onmessage(text) {
    console.log(text)
  }
})

channel.open()
message.send('hello')
```

--------------------------------

### Fetch JSON with bare-fetch

Source: https://docs.pears.com/bare/reference/bare/modules/bare-fetch

Import bare-fetch and perform a GET request to fetch JSON data from an example URL.

```js
const fetch = require('bare-fetch')

const res = await fetch('https://example.com/data')

console.log(await res.json())
```

--------------------------------

### Central usage example

Source: https://docs.pears.com/bare/reference/bare/modules/bare-bluetooth-android

Basic usage example for the Central class. It listens for state changes, starts scanning for the Heart Rate service UUID '180D' when Bluetooth is on, stops scanning and connects on discovery, and then discovers services after connection.

```js
const { Central } = require('bare-bluetooth-android')

const central = new Central()

central.on('stateChange', (state) => {
  if (state === 'on') {
    central.startScan(['180D']) // Heart Rate service UUID
  }
})

central.on('discover', (peripheral) => {
  console.log('Found:', peripheral.name, peripheral.id)
  central.stopScan()
  central.connect(peripheral)
})

central.on('connect', (peripheral) => {
  peripheral.discoverServices()

  peripheral.on('servicesDiscover', (services) => {
    // Discover characteristics for each service
  })
})
```

--------------------------------

### Quickstart: encode and decode with state

Source: https://docs.pears.com/p2p/reference/helpers/compact-encoding

Shows the basic usage of compact-encoding: create a state, preencode and encode values, then decode them. Demonstrates the state-based workflow.

```javascript
import cenc from 'compact-encoding'

const state = cenc.state()

cenc.uint.preencode(state, 42)
cenc.string.preencode(state, 'hello')

state.buffer = Buffer.allocUnsafe(state.end)
state.start = 0

cenc.uint.encode(state, 42)
cenc.string.encode(state, 'hello')

state.start = 0

console.log(cenc.uint.decode(state))
console.log(cenc.string.decode(state))
```

--------------------------------

### Entry module exporting start function

Source: https://docs.pears.com/bare/reference/bare/modules/bare-stow

Example entry module for a Bare bundle. Exports a `start` function that receives the IPC stream and an optional `ready` callback. The function may optionally return a function that runs before the bundle exits.

```js
module.exports = async function start(ipc, ready) {
  ipc.on('data', (data) => {
    // Handle messages from the host.
  })

  // Optionally call `ready()` to signal readiness early. Otherwise it is
  // signaled automatically when `start()` resolves.
  ready()

  return async function stop() {
    // Clean up before the bundle exits.
  }
}
```

--------------------------------

### Start user1 (creates the room)

Source: https://docs.pears.com/p2p/how-to/blind-peering/add-blind-peering-to-a-chat-app

Build and start user1, which creates the room. Pass the blind-peer key so the room's Autobase is mirrored. The app prints an `Invite:` line on stdout—copy it for user2.

```bash
npm run build
npm start -- --storage /tmp/bp-user1 --name user1 --blind-peer-key <BLIND_PEER_KEY>
```

--------------------------------

### Hyperbee Quickstart

Source: https://docs.pears.com/p2p/reference/building-blocks/hyperbee

Create a Hyperbee instance backed by a Hypercore, put a JSON value, read it back, and close the database.

```js
import Hypercore from 'hypercore'
import Hyperbee from 'hyperbee'

const core = new Hypercore('./bee-storage')
const db = new Hyperbee(core, {
  keyEncoding: 'utf-8',
  valueEncoding: 'json'
})

await db.ready()
await db.put('config', { theme: 'dark', retries: 3 })

const entry = await db.get('config')
console.log(entry.value.theme)

await db.close()
```

--------------------------------

### cursorPreviousLine(n?: number): string

Source: https://docs.pears.com/bare/reference/bare/modules/bare-ansi-escapes

Function to get the ANSI escape sequence for moving the cursor to the start of the line `n` lines up.

```APIDOC
## cursorPreviousLine(n?: number): string

### Description
Return the ANSI escape sequence that moves the cursor to the start of the line `n` lines up.

### Parameters
- `n?` (number) - Optional - Number of lines up to move; defaults to `1`.

### Returns
- `string` - The ANSI escape sequence.
```

--------------------------------

### Build and start first user

Source: https://docs.pears.com/p2p/how-to/connect-to-peers/host-multiple-rooms-in-one-chat-app

Builds and starts the app for the first user. Use this to create a room and copy its invite.

```bash
npm run build
npm start -- --storage /tmp/multi-user1 --name user1
```

--------------------------------

### cursorNextLine(n?: number): string

Source: https://docs.pears.com/bare/reference/bare/modules/bare-ansi-escapes

Function to get the ANSI escape sequence for moving the cursor to the start of the line `n` lines down.

```APIDOC
## cursorNextLine(n?: number): string

### Description
Return the ANSI escape sequence that moves the cursor to the start of the line `n` lines down.

### Parameters
- `n?` (number) - Optional - Number of lines down to move; defaults to `1`.

### Returns
- `string` - The ANSI escape sequence.
```

--------------------------------

### await store.ready()

Source: https://docs.pears.com/p2p/reference/helpers/corestore

Initializes the Corestore instance.

```APIDOC
## await store.ready()

### Description
A promise that resolves once the storage seed is loaded and properties such as `store.primaryKey` are available.

```

--------------------------------

### Create the client project

Source: https://docs.pears.com/p2p/how-to/connect-to-peers/connect-two-peers-by-key-with-hyperdht

Creates the client project and installs the required dependencies: hyperdht, b4a, and bare-process.

```sh
mkdir client-app
cd client-app
npm init -y
npm pkg set type="module"
npm install hyperdht b4a bare-process
```

--------------------------------

### Provision a server key and start the server

Source: https://docs.pears.com/p2p/reference/tools/hypershell

Create a server identity and start the server with a custom firewall file. The server will create the firewall file if it does not exist and watch it live for changes.

```sh
hypershell-keygen -f ~/.hypershell/server
hypershell-server -f ~/.hypershell/server --firewall ~/.hypershell/authorized_peers
```

--------------------------------

### Set up base-peer-app project

Source: https://docs.pears.com/p2p/how-to/store-and-replicate/build-a-multiwriter-app-with-autobase

Creates the base-peer-app directory, initializes an npm project, and installs autobase, corestore, hyperswarm, b4a, and bare-process.

```sh
mkdir base-peer-app
cd base-peer-app
npm init -y
npm pkg set type="module"
npm install autobase corestore hyperswarm b4a bare-process
```

--------------------------------

### Clone and run hello-pear-electron boilerplate

Source: https://docs.pears.com/pear/how-to/operate-an-app/migration

Clone the hello-pear-electron boilerplate, install dependencies, and start the app. This is the fastest migration path: scaffold a fresh Electron app with pear-runtime integrated, then move your code into it.

```bash
git clone https://github.com/holepunchto/hello-pear-electron
cd hello-pear-electron
npm install
npm start
```

--------------------------------

### Build and run two peer-to-peer file sharing instances

Source: https://docs.pears.com/p2p/how-to/stream-and-share-media/share-files-in-a-peer-to-peer-app

Build the app, then run two instances: user1 creates a room and prints an invite, user2 joins with the invite. Drop files into the path printed as 'My drive:' to share them.

```bash
npm run build

# user1: create room + print invite + watch folder
npm start -- --storage /tmp/files-user1 --name user1
```

```bash
npm start -- --storage /tmp/files-user2 --name user2 --invite <invite>
```

--------------------------------

### Setup drive-reader-app project and dependencies

Source: https://docs.pears.com/p2p/how-to/stream-and-share-media/create-a-full-peer-to-peer-filesystem-with-hyperdrive

Creates the drive-reader-app project, initializes npm, sets the module type to ESM, and installs the necessary dependencies: bare-process, hyperswarm, hyperdrive, localdrive, corestore, debounceify, b4a.

```sh
mkdir drive-reader-app
cd drive-reader-app
npm init -y
npm pkg set type="module"
npm install corestore localdrive hyperswarm hyperdrive debounceify b4a bare-process
```

--------------------------------

### drives touch example

Source: https://docs.pears.com/p2p/reference/tools/drives

Example of running `drives touch` to create a new Hyperdrive and print its public key.

```sh
drives touch
```

--------------------------------

### writer-app/index.js: Hypercore writer with Hyperswarm replication

Source: https://docs.pears.com/p2p/how-to/store-and-replicate/replicate-and-persist-with-hypercore

Writer app that creates a Hypercore, logs its key, appends stdin data as blocks, and replicates over Hyperswarm connections. Requires the dependencies installed via the setup commands.

```javascript
import path from 'bare-path'
import process from 'bare-process'
import Hyperswarm from 'hyperswarm'
import Hypercore from 'hypercore'
import b4a from 'b4a'

const swarm = new Hyperswarm()
process.once('SIGINT', () => swarm.destroy().then(() => process.exit(0), () => process.exit(0)))

const core = new Hypercore(path.join('./storage', 'writer-storage'))

// core.key and core.discoveryKey will only be set after core.ready resolves
await core.ready()
console.log('hypercore key:', b4a.toString(core.key, 'hex'))

// Append all stdin data as separate blocks to the core
process.stdin.on('data', (data) => core.append(data))

// core.discoveryKey is *not* a read capability for the core
// It's only used to discover other peers who *might* have the core
swarm.join(core.discoveryKey)
swarm.on('connection', conn => core.replicate(conn))
```

--------------------------------

### Example output: db key and initial view

Source: https://docs.pears.com/p2p/how-to/store-and-replicate/build-a-multiwriter-database-with-autobee

Illustrative output from running bee-base-writer-app: prints the database id and the initial view containing the greeting record written on startup.

```text
db key: 9fa71efyo1am3xzaarpkx9n46nqahgutygmdhokaegfpinjadd7y
view (1 entries):
  greeting: hello from the first writer
```

--------------------------------

### pear install <link>

Source: https://docs.pears.com/pear/reference/pear/cli

Install a Pear application or the Pear platform itself from a `pear://` link.

```APIDOC
## pear install <link>

### Description
Install a Pear application—or the Pear platform itself—from a `pear://` link. It pulls the application from the swarm and wires it up locally so it can be launched and kept up to date over the air.

### Method
CLI

### Endpoint
`pear install <link>`

### Parameters
#### Options
- `--only <paths>` (string) - Optional - Advanced. Filter by app filenames.
- `--timeout <seconds>` (number) - Optional - Advanced. Override network timeout (default 30s).
- `--to <dir>` (string) - Optional - Advanced. Override install target directory.
- `--dht-bootstrap <nodes>` (string) - Optional - Advanced. Custom DHT bootstrap.
- `--json` (boolean) - Optional - Newline delimited JSON output.
- `--help|-h` (boolean) - Optional - Show help.

### Request Example
```
pear install pear://<key>
```

### Response
#### Success Response
Installs the application and wires it up locally. On non-Windows, installing a binary also appends `~/.local/bin` to your `PATH` by editing your shell config.

### Notes
- Applications go to `~/Applications` on macOS, `~/Applications` or `~/AppImages` on Linux (fallback `~/.local/bin`), and on Windows install as a registered MSIX package.
- Binaries go to `%LOCALAPPDATA%\Programs\<app>\` on Windows and `~/.local/bin` elsewhere.
- `--to <dir>` overrides the default target, except for Windows application installs which always use MSIX.
```

--------------------------------

### Hyperblobs put/get example

Source: https://docs.pears.com/p2p/explanation/from-logs-to-files

Shows how to store and retrieve a large opaque object with Hyperblobs. Creates a Hypercore, wraps it in Hyperblobs, then puts a buffer and gets it back by id. Use when you need object storage without file paths.

```javascript
import Hypercore from 'hypercore'
import Hyperblobs from 'hyperblobs'

const core = new Hypercore('./blob-core')
const blobs = new Hyperblobs(core)
await blobs.ready()

const id = await blobs.put(Buffer.from('hello world', 'utf-8'))
const data = await blobs.get(id)
```

--------------------------------

### renderer/app.js — worker IPC

Source: https://docs.pears.com/p2p/getting-started/build-a-peer-to-peer-chat/reshape-into-a-production-app

Entrypoint IPC setup in renderer/app.js. Starts the worker and listens for worker IPC frames, parsing them as JSON and dispatching on message type: 'messages', 'peers', or 'invite'. The invite frame caches the invite and enables the copy button.

```js
bridge.startWorker(SPECIFIER)

const offWorkerIPC = bridge.onWorkerIPC(SPECIFIER, (data) => {
  let message
  try {
    message = JSON.parse(decoder.decode(data))
  } catch {
    return
  }
  if (message.type === 'messages') renderMessages(message.messages)
  else if (message.type === 'peers') renderPeers(message.count)
  else if (message.type === 'invite') {
    invite = message.invite
    copyEl.disabled = false
  }
})
```

--------------------------------

### Install over the air with pear install

Source: https://docs.pears.com/p2p/getting-started/from-a-template/start-from-hello-pear-bare

Installs the standalone binary peer-to-peer using the pear install command with the upgrade link key. After the first install, new releases reach users through the swarm without reinstallation.

```bash
pear install pear://<key>
```

--------------------------------

### Install Snap tools (snapcraft, lxd)

Source: https://docs.pears.com/pear/how-to/operate-an-app/build-and-package/submit-to-app-stores

Install Snap tools: snapcraft and lxd, add the user to the lxd group, and initialize lxd with automatic defaults. Required before building a Snap package.

```sh
snap install snapcraft --classic
snap install lxd
sudo usermod -a -G lxd $USER
sudo lxd init --auto
```

--------------------------------

### install.install(opts?: InstallOptions): Promise<void>

Source: https://docs.pears.com/bare/reference/bare/modules/bare-make

Installs the built artifacts. Throws INSTALL_FAILED on non-zero exit.

```APIDOC
## install.install(opts?: InstallOptions): Promise<void>

### Description
Installs the built artifacts. Throws `INSTALL_FAILED` if the install exits with a non-zero status.

### Parameters
- **opts?** (InstallOptions) - Optional - Options; `build` defaults to `'build'`, `prefix` to `'prebuilds'`, and `link`, `strip`, and `verbose` to `false`.

### Throws
- **INSTALL_FAILED** - The install exits with a non-zero status.

### InstallOptions
```ts
interface InstallOptions {
  build?: string
  component?: string
  cwd?: string
  link?: boolean
  parallel?: boolean
  prefix?: string
  stdio?: Pipe
  strip?: boolean
  verbose?: boolean
}
```

```

--------------------------------

### bare-make install [flags]

Source: https://docs.pears.com/bare/reference/bare/modules/bare-make

The `bare-make install` command installs the built project.

```APIDOC
## bare-make install [flags]

### Description
Installs the built project. Flags include `--build`, `--prefix`, `--component`, `--link`, `--strip`, `--parallel`, `--verbose`, and `--help`.

### Method
CLI Command

### Flags
- `--build|-b <path>` - The path to the build tree
- `--prefix|-p <path>` - The prefix to install to
- `--component|-c <name>` - The component to install
- `--link|-l` - Link rather than copy the files
- `--strip|-s` - Strip before installing
- `--parallel|-j <number>` - Install in parallel using the given number of jobs
- `--verbose` - Enable verbose output
- `--help|-h` - Show help
```

--------------------------------

### Install a Pear application with pear install

Source: https://docs.pears.com/pear/explanation/storage-and-distribution

Installs a Pear application from the swarm using the pear install command. This replaces the removed pear run command and works for both applications and standalone binaries.

```bash
# install an application peer-to-peer
pear install pear://<key>
```

--------------------------------

### Install bare-fs, bare-path, bare-process

Source: https://docs.pears.com/bare/how-to/migrate-a-nodejs-app-to-bare

Install the bare-* equivalents for fs, path, and process. These are opt-in modules, not bundled with Bare.

```sh
cd app
npm install bare-fs bare-path bare-process
```
Tokens:
Raw