Quickstart: join the mesh and ship your first feature

# with npm
npm install @offline-protocol/mesh-sdk

# or with yarn
yarn add @offline-protocol/mesh-sdk

target 'YourAppName' do
  use_expo_modules!
  # add the Mesh SDK pod
  pod 'MeshSdk', :path => '../node_modules/@offline-protocol/mesh-sdk/ios'
end

import com.offlineprotocol.OfflineProtocolPackage

// inside getPackages()
override fun getPackages(): List<ReactPackage> =
  PackageList(this).packages.apply {
    add(OfflineProtocolPackage())
  }

import { OfflineProtocol, MessagePriority } from '@offline-protocol/mesh-sdk';

const protocol = new OfflineProtocol({
  appId: 'my-app',
  userId: 'user123',
  // encryption is on by default with auto key exchange
});

// register listeners before you start, so no early event is missed
protocol.on('neighbor_discovered', (event) =>
  console.log(`peer ${event.peer_id} via ${event.transport}, rssi ${event.rssi}`));

protocol.on('secure_session_established', (event) =>
  console.log(`secure session with ${event.peer_id}`));

// start scanning and advertising; DORS picks the transport
await protocol.start();

// receive
protocol.on('message_received', (event) => {
  console.log(`from ${event.sender}: ${event.content}`);
  console.log(`encrypted: ${event.encrypted}, hops: ${event.hop_count}`);
});

// send
const messageId = await protocol.sendMessage({
  recipient: 'user456',
  content: 'Hello!',
  priority: MessagePriority.High,
});

// confirm delivery across the mesh
protocol.on('message_delivered', (event) =>
  console.log(`delivered ${event.message_id} in ${event.latency_ms}ms, ${event.hop_count} hops`));

import { MeshServices } from '@offline-protocol/mesh-sdk';

const services = new MeshServices();

// advertise a capability with optional metadata
await services.registerService('translate.v1', '1.0', {
  languages: 'en,es,fr,de',
});

// answer incoming requests
protocol.on('service_request_received', async (event) => {
  const { text, targetLang } = JSON.parse(event.body);
  const translated = await translateLocally(text, targetLang);
  await services.respondToServiceRequest(
    event.request_id, event.sender, event.service_id,
    'ok', JSON.stringify({ translated }),
  );
});

// discover providers across the mesh (pass null for all services)
await services.discoverServices('translate.v1');

protocol.on('service_discovered', (event) => {
  console.log(`found ${event.service_id} v${event.version}, ${event.hop_count} hops away`);
  // invoke it request / response
  services.sendServiceRequest(
    event.provider_peer_id, event.service_id, 'translate',
    JSON.stringify({ text: 'Hello world', targetLang: 'es' }),
  );
});

protocol.on('service_response_received', (event) => {
  if (event.status === 'ok') {
    const { translated } = JSON.parse(event.body);
    console.log(`result: ${translated}`);
  }
});