bare-stow 0.1.9 → 0.3.0

package/lib/rpc/bare-rpc.js

@@ -1,24 +1,156 @@
 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.rpc.Transport
+import to.holepunch.bare.stow.host.Ipc
+
+typealias Handlers = CommandRouter.() -> Unit
+
+internal fun attach(ipc: Ipc, handlers: Handlers): Rpc {
+  val router = CommandRouter().apply(handlers)
+
+  return Rpc(
+    Transport(ipc.data, ipc::write, ipc::close),
+    CoroutineScope(Dispatchers.Default),
+    router,
+  )
+}
+`
+
+  return {
+    source,
+    dependencies: {
+      'com.github.holepunchto.bare-rpc-kotlin:bare-rpc-kotlin': 'v0.5.0',
+      'com.github.holepunchto.bare-stow-host-kotlin:bare-stow-host-kotlin': 'v0.2.1'
+    }
+  }
+}
+
+function swift() {
+  const source = `\
+import BareRPC
+import BareStowHost
+import Foundation
 
-  const esm = opts.module === 'esm'
+public typealias Handlers = (CommandRouter) -> Void
 
-  return [
-    {
-      source: `\
-${esm ? "const { default: RPC } = await import('bare-rpc')" : "const RPC = require('bare-rpc')"}
+extension BareStowHost.IPC: @retroactive BareRPC.Transport {}
 
-const router = new RPC.CommandRouter()
-const ${rpc} = new RPC(${ipc}, router)
+func attach(_ ipc: IPC, _ handlers: Handlers?) -> RPC {
+  let router = CommandRouter()
 
-${rpc}.respond = router.respond.bind(router)
+  handlers?(router)
+
+  return RPC(ipc, handler: router)
+}
 `
-    },
-    {
-      extension: '.d.ts',
-      source: "import('bare-rpc')"
+
+  return {
+    source,
+    dependencies: {
+      'bare-rpc-swift': {
+        url: 'https://github.com/holepunchto/bare-rpc-swift',
+        from: '2.0.0',
+        products: ['BareRPC']
+      },
+      'bare-stow-host-swift': {
+        url: 'https://github.com/holepunchto/bare-stow-host-swift',
+        from: '0.2.0',
+        products: ['BareStowHost']
+      }
     }
-  ]
+  }
+}
+
+function python() {
+  const source = `\
+from collections.abc import Callable
+
+from bare_rpc import RPC, CommandRouter
+from bare_stow_host import IPC
+
+Handlers = Callable[[CommandRouter], None]
+
+
+def attach(ipc: IPC, handlers: Handlers) -> RPC:
+    router = CommandRouter()
+
+    handlers(router)
+
+    return RPC(ipc, handler=router)
+`
+
+  return {
+    source,
+    dependencies: {
+      'bare-rpc': '~=0.2.0',
+      'bare-stow-host': '~=0.2.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.5.0' } }
 }

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,238 @@
+const path = require('path')
+const swift = require('./swift')
+
+exports.name = 'bare-kit'
+exports.isolation = 'thread'
+exports.linked = (context) => !isJvm(context)
+exports.linking = linking
+exports.offload = isJvm
+exports.format = 'bundle'
+exports.encoding = null
+exports.extension = '.bundle'
+exports.hosts = (context) => (isJvm(context) ? desktop : hosts[context.language])
+
+// On the JVM, the harness extracts the bundle from the resources of its module,
+// so the addons and assets of the bundle are offloaded beside it rather than
+// linked.
+function isJvm({ language, options }) {
+  return language === 'kotlin' && options.platform === 'jvm'
+}
+
+function linking(context) {
+  const { targetOptions } = context
+
+  if (isJvm(context) && targetOptions.linking === 'app') {
+    throw new Error("Option 'linking' must be 'package' for the JVM")
+  }
+
+  return targetOptions.linking
+}
+
+// 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.2.0',
+  products: ['BareKit']
+}
+
+const bareKitKotlin = {
+  'com.github.holepunchto.bare-kit-kotlin:bare-kit-kotlin': 'v0.2.2'
+}
+
+const desktop = [
+  'darwin-arm64',
+  'darwin-x64',
+  'linux-arm64',
+  'linux-x64',
+  'win32-arm64',
+  'win32-x64'
+]
+
+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 BareStowHost.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(context) {
+  const { client, options } = context
+
+  const platform = options.platform === 'jvm' ? jvm(context) : android(context)
+
+  const imports = [
+    ...platform.imports,
+    'kotlin.time.Duration',
+    'kotlinx.coroutines.CoroutineScope',
+    'kotlinx.coroutines.Dispatchers',
+    'kotlinx.coroutines.launch',
+    'to.holepunch.bare.kit.Ipc as WorkletIpc',
+    'to.holepunch.bare.kit.Worklet',
+    'to.holepunch.bare.stow.host.Ipc',
+    ...(client ? ['to.holepunch.bare.rpc.Rpc'] : [])
+  ].sort()
+
+  const source = `\
+package ${options.package}
+
+${imports.map((name) => 'import ' + name).join('\n')}
+
+class Started(val worklet: Worklet, val ipc: Ipc${client ? ', val rpc: Rpc' : ''})
+${platform.declarations}
+suspend fun start(
+${platform.params}\
+  options: Worklet.Options = Worklet.Options(),
+  timeout: Duration? = null,
+  grace: Duration = Ipc.DEFAULT_GRACE,${client ? '\n  handlers: Handlers = {},' : ''}
+): Started {
+  val worklet = ${platform.worklet}
+
+  val transport =
+    try {
+      WorkletIpc(worklet)
+    } catch (error: Throwable) {
+      worklet.close()
+      throw error
+    }
+
+  try {
+    ${platform.start}
+  } catch (error: Throwable) {
+    transport.close()
+    worklet.close()
+    throw error
+  }
+
+  val ipc =
+    Ipc(
+      transport.data,
+      transport::write,
+      kill = { worklet.terminate() },
+      timeout = timeout,
+      grace = grace,
+    )
+
+  CoroutineScope(Dispatchers.Default).launch {
+    ipc.exited(worklet.wait())
+
+    transport.close()
+    worklet.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.2.1'
+    }
+  }
+}
+
+function android({ bundle, resources }) {
+  return {
+    imports: ['android.content.Context'],
+    declarations: '',
+    params: '  context: Context,\n',
+    worklet: 'Worklet(context, options)',
+    start: resources
+      ? `worklet.start(${JSON.stringify(resources + '.bundle')}, context.assets.open(${JSON.stringify(bundle)}).use { it.readBytes() })`
+      : `worklet.start(${JSON.stringify(bundle)})`
+  }
+}
+
+// The bundle and the files listed beside it are extracted once per process, to
+// a directory of its own that is removed on exit.
+function jvm({ bundle }) {
+  const dir = path.posix.dirname(bundle)
+  const name = '/' + path.posix.basename(bundle)
+
+  return {
+    imports: ['java.io.File', 'java.nio.file.Files', 'kotlinx.coroutines.withContext'],
+    declarations: `
+private val bundle: File by lazy {
+  val dir = Files.createTempDirectory("bare-stow").toFile()
+
+  Runtime.getRuntime().addShutdownHook(Thread { dir.deleteRecursively() })
+
+  val loader = Started::class.java.classLoader
+
+  fun open(name: String) = loader.getResourceAsStream(${JSON.stringify(dir)} + name)!!
+
+  val listed = open(${JSON.stringify(name + '.files')}).bufferedReader().use { it.readLines() }
+
+  for (name in listOf(${JSON.stringify(name)}) + listed) {
+    val file = File(dir, name)
+
+    file.parentFile.mkdirs()
+
+    open(name).use { input -> file.outputStream().use { input.copyTo(it) } }
+  }
+
+  File(dir, ${JSON.stringify(name)})
+}
+`,
+    params: '',
+    worklet: 'Worklet(options)',
+    start: 'worklet.start(withContext(Dispatchers.IO) { bundle }.path)'
+  }
+}

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.15',
+        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 BareStowHost.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.2',
+            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} }`
+${client ? 'from bare_rpc import RPC\n' : ''}from bare_sidecar import spawn
+from bare_stow_host import DEFAULT_GRACE, IPC, wrap
+${client ? `\nfrom ${client} import 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: RPC' : ''}
 
-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.3',
+      'bare-stow-host': '~=0.2.0'
     }
-  ]
-}
-
-function indent(source, spaces) {
-  const pad = ' '.repeat(spaces)
-  return source
-    .split('\n')
-    .map((line) => (line.length === 0 ? line : pad + line))
-    .join('\n')
+  }
 }