bare-stow 0.1.9 → 0.2.0

package/lib/rpc/bare-rpc.js

@@ -1,24 +1,229 @@
 exports.name = 'bare-rpc'
 
-exports.generate = function generate(opts) {
-  const { ipc, rpc } = opts
+exports.languages = {
+  javascript: { generate: javascript },
+  kotlin: { generate: kotlin },
+  python: { generate: python },
+  swift: { generate: swift }
+}
+
+function kotlin({ options }) {
+  const source = `\
+package ${options.package}
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import to.holepunch.bare.rpc.CommandRouter
+import to.holepunch.bare.rpc.Rpc
+import to.holepunch.bare.stow.host.Ipc
+
+typealias Client = Rpc
+
+typealias Handlers = CommandRouter.() -> Unit
+
+internal fun attach(ipc: Ipc, handlers: Handlers): Client {
+  val router = CommandRouter().apply(handlers)
+
+  return Rpc(
+    ipc.data,
+    ipc::write,
+    CoroutineScope(Dispatchers.Default),
+    onEvent = router::dispatch,
+    onRequest = router::dispatch,
+  )
+}
+`
+
+  return {
+    source,
+    dependencies: {
+      'com.github.holepunchto.bare-rpc-kotlin:bare-rpc-kotlin': 'v0.4.0',
+      'com.github.holepunchto.bare-stow-host-kotlin:bare-stow-host-kotlin': 'v0.1.1'
+    }
+  }
+}
+
+function swift() {
+  const source = `\
+import BareRPC
+import BareStowHost
+import Foundation
+
+public final class Client: @unchecked Sendable {
+  public let rpc: RPC
+
+  private let delegate: Delegate
+
+  fileprivate init(rpc: RPC, delegate: Delegate) {
+    self.rpc = rpc
+    self.delegate = delegate
+  }
+
+  public func request(_ command: UInt, data: Data? = nil) async throws -> Data? {
+    try await rpc.request(command, data: data)
+  }
 
-  const esm = opts.module === 'esm'
+  public func event(_ command: UInt, data: Data? = nil) async {
+    await rpc.event(command, data: data)
+  }
+}
+
+public typealias Handlers = (CommandRouter) -> Void
+
+func attach(_ ipc: IPC, _ handlers: Handlers?) -> Client {
+  let router = CommandRouter()
 
-  return [
-    {
-      source: `\
-${esm ? "const { default: RPC } = await import('bare-rpc')" : "const RPC = require('bare-rpc')"}
+  handlers?(router)
 
-const router = new RPC.CommandRouter()
-const ${rpc} = new RPC(${ipc}, router)
+  let delegate = Delegate(router: router)
+  let rpc = RPC(delegate: delegate)
+
+  Task {
+    for await frame in delegate.frames {
+      try? await ipc.write(frame)
+    }
+  }
+
+  Task {
+    do {
+      for try await data in ipc {
+        await rpc.receive(data)
+      }
+    } catch {}
+
+    delegate.finish()
+  }
+
+  return Client(rpc: rpc, delegate: delegate)
+}
 
-${rpc}.respond = router.respond.bind(router)
+private final class Delegate: RPCDelegate, @unchecked Sendable {
+  let router: CommandRouter
+  let frames: AsyncStream<Data>
+
+  private let continuation: AsyncStream<Data>.Continuation
+
+  init(router: CommandRouter) {
+    self.router = router
+    (frames, continuation) = AsyncStream.makeStream()
+  }
+
+  func rpc(_ rpc: RPC, send data: Data) {
+    continuation.yield(data)
+  }
+
+  func rpc(_ rpc: RPC, didReceiveRequest request: IncomingRequest) async throws {
+    await router.dispatch(request)
+  }
+
+  func rpc(_ rpc: RPC, didReceiveEvent event: IncomingEvent) async {
+    await router.dispatch(event)
+  }
+
+  func finish() {
+    continuation.finish()
+  }
+}
 `
-    },
-    {
-      extension: '.d.ts',
-      source: "import('bare-rpc')"
+
+  return {
+    source,
+    dependencies: {
+      'bare-rpc-swift': {
+        url: 'https://github.com/holepunchto/bare-rpc-swift',
+        from: '1.1.0',
+        products: ['BareRPC']
+      },
+      'bare-stow-host-swift': {
+        url: 'https://github.com/holepunchto/bare-stow-host-swift',
+        from: '0.1.0',
+        products: ['BareStowHost']
+      }
     }
-  ]
+  }
+}
+
+function python() {
+  const source = `\
+from collections.abc import Callable
+
+from bare_rpc import RPC, CommandRouter
+from bare_stow_host import IPC
+
+Client = RPC
+
+Handlers = Callable[[CommandRouter], None]
+
+
+def attach(ipc: IPC, handlers: Handlers) -> Client:
+    router = CommandRouter()
+
+    handlers(router)
+
+    return RPC(
+        ipc,
+        on_request=router.dispatch_request,
+        on_event=router.dispatch_event,
+    )
+`
+
+  return {
+    source,
+    dependencies: {
+      'bare-rpc': '~=0.1.0',
+      'bare-stow-host': '~=0.1.0'
+    }
+  }
+}
+
+function javascript({ role, options }) {
+  const esm = options.module === 'esm'
+
+  // The bundle registers its handlers in `start()`, before it signals ready.
+  const server = role === 'server'
+
+  const params = server ? 'ipc' : 'ipc, handlers'
+
+  const body = server
+    ? `\
+  const router = new RPC.CommandRouter()
+  const rpc = new RPC(ipc, router)
+
+  rpc.respond = router.respond.bind(router)
+
+  return rpc
+}
+`
+    : `\
+  const router = new RPC.CommandRouter()
+
+  handlers(router)
+
+  return new RPC(ipc, router)
+}
+`
+
+  const source = esm
+    ? `\
+import RPC from 'bare-rpc'
+
+export function attach(${params}) {
+${body}`
+    : `\
+const RPC = require('bare-rpc')
+
+exports.attach = function attach(${params}) {
+${body}`
+
+  const types = server
+    ? `\
+export function attach(ipc: import('bare-stow-host').IPC): import('bare-rpc')
+`
+    : `\
+export type Handlers = (router: import('bare-rpc').CommandRouter) => void
+
+export function attach(ipc: import('bare-stow-host').IPC, handlers: Handlers): import('bare-rpc')
+`
+
+  return { source, types, dependencies: { 'bare-rpc': '^1.3.9' } }
 }

package/lib/rpc.js

@@ -1,23 +1,11 @@
-const registry = {
-  'bare-rpc': () => require('./rpc/bare-rpc')
-}
-
-module.exports = function rpc(name, resolve) {
-  if (typeof name !== 'string') return validate(name)
-
-  const load = registry[name]
+const { registry, validateLanguages } = require('./provider')
 
-  if (load) return load()
-
-  if (resolve) return validate(resolve(name))
-
-  throw new Error(`Unknown RPC library '${name}'`)
+const providers = {
+  'bare-rpc': () => require('./rpc/bare-rpc')
 }
 
-function validate(rpc) {
-  if (!rpc || typeof rpc.generate !== 'function') {
-    throw new Error('RPC library must provide a generate() function')
-  }
+module.exports = registry('RPC library', providers, function validate(rpc) {
+  validateLanguages('RPC library', rpc?.languages)
 
   return rpc
-}
+})

package/lib/shim.js

@@ -1,40 +1,33 @@
-const path = require('path')
-const { fileURLToPath } = require('url')
+const javascript = require('./language/javascript')
+const { select } = require('./provider')
 
-module.exports = exports = function shim(entry, shimURL, opts = {}) {
-  // `server` is a pre-rendered RPC server setup fragment (binding `rpc`), or
-  // null. The bundler resolves the RPC library and renders it; the shim only
-  // decides where the fragment goes.
-  const { server = null } = opts
+// The bundle runs in Bare, so its side of every provider is JavaScript.
+module.exports = function shim(entry, isolation, server = null) {
+  if (server) server = select('RPC library', server, javascript.name)
 
-  const specifier = relativeSpecifier(shimURL, entry)
+  const dir = new URL('./', entry)
+  const url = new URL('__main__.mjs', dir)
+  const serverURL = server ? new URL('__server__.mjs', dir) : null
 
-  const arg = server ? '{ rpc, ipc }' : 'ipc'
+  const modules = new Map()
 
-  return `\
-import runtime from 'bare-stow/runtime'
+  if (server) {
+    modules.set(
+      serverURL.href,
+      server.generate({ role: 'server', options: { module: 'esm' } }).source
+    )
+  }
 
+  modules.set(
+    url.href,
+    `\
+import runtime from '${isolation === 'process' ? 'bare-stow-runtime/process' : 'bare-stow-runtime'}'
+${server ? `import * as server from ${JSON.stringify(javascript.reference(url, serverURL))}\n` : ''}
 const ipc = runtime.attach(Bare.IPC)
-${server ? '\n' + server : ''}
-ipc.run(() => import(${JSON.stringify(specifier)}), ${arg})
+${server ? '\nconst rpc = server.attach(ipc)\n' : ''}
+ipc.run(() => import(${JSON.stringify(javascript.reference(url, entry))}), ${server ? '{ rpc, ipc }' : 'ipc'})
 `
-}
-
-exports.url = function url(base) {
-  return new URL('__main__.mjs', base)
-}
-
-function relativeSpecifier(from, to) {
-  if (from.protocol === 'file:' && to.protocol === 'file:') {
-    const fromPath = path.dirname(fileURLToPath(from))
-    const toPath = fileURLToPath(to)
-
-    let relative = path.relative(fromPath, toPath).split(path.sep).join('/')
-
-    if (!relative.startsWith('.')) relative = './' + relative
-
-    return relative
-  }
+  )
 
-  return to.href
+  return { url, modules }
 }

package/lib/target/bare-kit.js

@@ -0,0 +1,144 @@
+const swift = require('./swift')
+
+exports.name = 'bare-kit'
+exports.isolation = 'thread'
+exports.linked = true
+exports.linking = ({ targetOptions }) => targetOptions.linking
+exports.offload = false
+exports.format = 'bundle'
+exports.encoding = null
+exports.extension = '.bundle'
+exports.hosts = ({ language }) => hosts[language]
+
+// Applications with several bundles link their addons once with `link()`.
+exports.options = function options(given = {}) {
+  const { linking = 'package', ...unknown } = given
+
+  for (const option of Object.keys(unknown)) {
+    throw new Error(`Unknown option '${option}' for target 'bare-kit'`)
+  }
+
+  if (linking !== 'package' && linking !== 'app') {
+    throw new Error(`Option 'linking' must be 'package' or 'app', got '${linking}'`)
+  }
+
+  return { linking }
+}
+
+const bareKitSwift = {
+  url: 'https://github.com/holepunchto/bare-kit-swift',
+  from: '2.0.0',
+  products: ['BareKit']
+}
+
+const bareKitKotlin = {
+  'com.github.holepunchto.bare-kit-kotlin:bare-kit-kotlin': 'v0.1.1'
+}
+
+const hosts = {
+  kotlin: ['android-arm64', 'android-arm', 'android-x64', 'android-ia32'],
+  swift: ['darwin-arm64', 'darwin-x64', 'ios-arm64', 'ios-arm64-simulator', 'ios-x64-simulator']
+}
+
+exports.languages = {
+  kotlin: {
+    generate: kotlin,
+    link() {
+      return { source: null, dependencies: bareKitKotlin }
+    }
+  },
+  swift: {
+    // Re-exports Bare Kit, so that code linking the module can run worklets.
+    link() {
+      return {
+        source: '@_exported import BareKit\n',
+        dependencies: { 'bare-kit-swift': bareKitSwift }
+      }
+    },
+    generate(context) {
+      const start = context.resources
+        ? `try worklet.start(${JSON.stringify(context.resources + '.bundle')}, source: Data(contentsOf: bundle))`
+        : 'try worklet.start(bundle)'
+
+      return swift(context, {
+        module: 'BareKit',
+        conformance: 'extension BareKit.IPC: @retroactive Transport {}',
+        fields: { worklet: 'Worklet' },
+        params: ['options: Worklet.Options = Worklet.Options()'],
+        setup: `\
+let worklet = try Worklet(options: options)
+
+let transport = try BareKit.IPC(worklet: worklet)
+
+${start}
+
+let ipc = BareStowHost.IPC(
+  transport, kill: { worklet.terminate() }, timeout: timeout, grace: grace)
+
+Task { ipc.exited(code: await worklet.wait()) }`,
+        dependencies: { 'bare-kit-swift': bareKitSwift }
+      })
+    }
+  }
+}
+
+function kotlin({ bundle, client, resources, options }) {
+  const start = resources
+    ? `worklet.start(${JSON.stringify(resources + '.bundle')}, context.assets.open(${JSON.stringify(bundle)}).use { it.readBytes() })`
+    : `worklet.start(${JSON.stringify(bundle)})`
+
+  const source = `\
+package ${options.package}
+
+import android.content.Context
+import kotlin.time.Duration
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import to.holepunch.bare.kit.Ipc as WorkletIpc
+import to.holepunch.bare.kit.Worklet
+import to.holepunch.bare.stow.host.Ipc
+
+class Started(val worklet: Worklet, val ipc: Ipc${client ? ', val rpc: Client' : ''})
+
+suspend fun start(
+  context: Context,
+  options: Worklet.Options = Worklet.Options(),
+  timeout: Duration? = null,
+  grace: Duration = Ipc.DEFAULT_GRACE,${client ? '\n  handlers: Handlers = {},' : ''}
+): Started {
+  val worklet = Worklet(context, options)
+
+  val transport = WorkletIpc(worklet)
+
+  ${start}
+
+  val ipc =
+    Ipc(
+      transport.data,
+      transport::write,
+      kill = { worklet.terminate() },
+      timeout = timeout,
+      grace = grace,
+    )
+
+  CoroutineScope(Dispatchers.Default).launch {
+    ipc.exited(worklet.wait())
+
+    transport.close()
+  }
+${client ? '\n  val rpc = attach(ipc, handlers)\n' : ''}
+  ipc.ready()
+
+  return Started(worklet, ipc${client ? ', rpc' : ''})
+}
+`
+
+  return {
+    source,
+    dependencies: {
+      ...bareKitKotlin,
+      'com.github.holepunchto.bare-stow-host-kotlin:bare-stow-host-kotlin': 'v0.1.1'
+    }
+  }
+}

package/lib/target/bare-sidecar.js

@@ -1,4 +1,8 @@
+const harness = require('./javascript')
+const swift = require('./swift')
+
 exports.name = 'bare-sidecar'
+exports.isolation = 'process'
 exports.linked = false
 exports.offload = true
 exports.format = 'bundle'
@@ -13,74 +17,103 @@ exports.hosts = [
   'win32-x64'
 ]
 
-exports.generate = function generate(opts) {
-  const { bundleSpecifier, ipc, rpc, module = 'cjs', client = null } = opts
+exports.languages = {
+  javascript: {
+    generate(context) {
+      return harness(context, {
+        name: 'bare-sidecar',
+        version: '^0.5.12',
+        binding: 'Sidecar',
+        url: true,
+        setup: `\
+const sidecar = new Sidecar(bundle, { stdio: 'inherit', ...opts })
+
+const ipc = stow.wrap(sidecar, { kill: () => sidecar.kill('SIGKILL'), timeout, grace })
+
+sidecar.on('exit', (code, signal) => ipc.exited(code, signal))`,
+        types: "import('bare-sidecar').SidecarOptions"
+      })
+    }
+  },
+  python: { generate: python },
+  swift: {
+    generate(context) {
+      return swift(context, {
+        module: 'BareSidecar',
+        conformance: 'extension Sidecar: @retroactive Transport {}',
+        setup: `\
+let sidecar = try await Sidecar.spawn(bundle)
+
+let ipc = BareStowHost.IPC(sidecar, kill: { sidecar.kill() }, timeout: timeout, grace: grace)
+
+Task {
+  switch await sidecar.wait() {
+  case .exit(let code): ipc.exited(code: code)
+  case .signal(let signal): ipc.exited(code: nil, signal: signal)
+  }
+}`,
+        dependencies: {
+          'bare-sidecar-swift': {
+            url: 'https://github.com/holepunchto/bare-sidecar-swift',
+            from: '0.1.0',
+            products: ['BareSidecar']
+          }
+        }
+      })
+    }
+  }
+}
 
-  const esm = module === 'esm'
+function python({ bundle, client }) {
+  const source = `\
+import asyncio
+from pathlib import Path
+from typing import NamedTuple
 
-  const returned = client ? `{ ${ipc}, ${rpc} }` : `{ ${ipc} }`
+from bare_sidecar import spawn
+from bare_stow_host import DEFAULT_GRACE, IPC, wrap
+${client ? `\nfrom ${client} import Client, Handlers, attach\n` : ''}
+bundle = Path(__file__).parent / ${JSON.stringify(bundle)}
 
-  const handle = client
-    ? `{ ${ipc}: import('bare-stow/host').IPC; ${rpc}: ${client.type} }`
-    : `{ ${ipc}: import('bare-stow/host').IPC }`
+_watching = set()
 
-  const source = esm
-    ? `\
-import Sidecar from 'bare-sidecar'
-import stow from 'bare-stow/host'
 
-const bundle = new URL(import.meta.resolve(${JSON.stringify(bundleSpecifier)}))
+class Started(NamedTuple):
+    ipc: IPC${client ? '\n    rpc: Client' : ''}
 
-export async function start({ timeout, grace, ...opts } = {}) {
-  const sidecar = new Sidecar(bundle, { stdio: 'inherit', ...opts })
 
-  const ${ipc} = stow.wrap(sidecar, { kill: () => sidecar.kill('SIGKILL'), timeout, grace })
+async def start(
+    *,
+    timeout=None,
+    grace=DEFAULT_GRACE,${client ? '\n    handlers: Handlers = lambda router: None,' : ''}
+    **opts,
+) -> Started:
+    sidecar = await spawn(bundle, **opts)
 
-  sidecar.on('exit', (code, signal) => ${ipc}.exited(code, signal))
-${client ? '\n' + indent(client.source, 2) : ''}
-  await ${ipc}.ready
+    ipc = wrap(sidecar, kill=sidecar.kill, timeout=timeout, grace=grace)
 
-  return ${returned}
-}
-`
-    : `\
-const Sidecar = require('bare-sidecar')
-const stow = require('bare-stow/host')
+    watching = asyncio.ensure_future(_watch(sidecar, ipc))
+    _watching.add(watching)
+    watching.add_done_callback(_watching.discard)
+${client ? '\n    rpc = attach(ipc, handlers)\n' : ''}
+    await ipc.ready
 
-const bundle = require.resolve(${JSON.stringify(bundleSpecifier)})
+    return Started(ipc${client ? ', rpc' : ''})
 
-module.exports = {
-  async start({ timeout, grace, ...opts } = {}) {
-    const sidecar = new Sidecar(bundle, { stdio: 'inherit', ...opts })
 
-    const ${ipc} = stow.wrap(sidecar, { kill: () => sidecar.kill('SIGKILL'), timeout, grace })
+async def _watch(sidecar, ipc):
+    await sidecar.wait()
 
-    sidecar.on('exit', (code, signal) => ${ipc}.exited(code, signal))
-${client ? '\n' + indent(client.source, 4) : ''}
-    await ${ipc}.ready
+    ipc.exited(sidecar.exit_code, sidecar.signal_code)
 
-    return ${returned}
-  }
-}
+    await sidecar.close()
 `
 
-  return [
-    { source },
-    {
-      extension: '.d.ts',
-      source: `\
-export function start(
-  opts?: import('bare-sidecar').SidecarOptions & Omit<import('bare-stow/host').IPCOptions, 'kill'>
-): Promise<${handle}>
-`
+  return {
+    source,
+    dependencies: {
+      'bare-sidecar': '~=0.1.0',
+      'bare-stow-host': '~=0.1.0'
     }
-  ]
-}
-
-function indent(source, spaces) {
-  const pad = ' '.repeat(spaces)
-  return source
-    .split('\n')
-    .map((line) => (line.length === 0 ? line : pad + line))
-    .join('\n')
+  }
 }