@briancray/belte 0.1.0 → 0.2.1

package/bin/belte.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env bun
 import { build } from '../src/build.ts'
 import { buildCli } from '../src/buildCli.ts'
+import { bundleApp } from '../src/bundleApp.ts'
 import { compile } from '../src/compile.ts'
 import { normalizeTarget } from '../src/lib/shared/normalizeTarget.ts'
 import { scaffold } from '../src/scaffold.ts'
@@ -68,17 +69,16 @@ async function compileCmd(): Promise<void> {
     })
 }
 
-// Builds the standalone CLI binary. Defaults to full (backend embedded, runs
-// locally); `--thin` builds the remote client (manifest only, needs APP_URL
-// at runtime). Discovery walks the rpc registry to bake the manifest in.
-// `--platforms a,b,c` cross-compiles per target — thin binaries land in
-// dist/cli-thin/<platform>/ (the layout the /__belte/cli download endpoint
-// streams), full binaries in dist/cli/<platform>/.
+// Builds the standalone CLI binary — a thin remote client that talks to a
+// running server (manifest baked in, needs APP_URL at runtime). Discovery
+// walks the rpc registry to bake the manifest in. `--platforms a,b,c`
+// cross-compiles per target into dist/cli-thin/<platform>/ — the layout the
+// /__belte/cli download endpoint streams. For an embedded backend, use
+// `belte compile` (standalone server binary) instead.
 async function cliCmd(): Promise<void> {
     const targetFlag = parseFlag('target')
     const outFlag = parseFlag('out')
     const platformsFlag = parseFlag('platforms')
-    const thin = rest.includes('--thin')
     const platforms = platformsFlag
         ? platformsFlag.split(',').map((value) => normalizeTarget(value.trim()))
         : undefined
@@ -87,10 +87,17 @@ async function cliCmd(): Promise<void> {
         target: targetFlag ? normalizeTarget(targetFlag) : undefined,
         outfile: outFlag,
         platforms,
-        thin,
     })
 }
 
+// Assembles a movable, self-contained app bundle for the host platform —
+// the server binary, the launcher, and the webview lib together (a .app on
+// macOS, a flat directory elsewhere). Unsigned; for distribution to other
+// users the bundle still needs platform signing/notarization.
+async function bundleCmd(): Promise<void> {
+    await bundleApp({ cwd })
+}
+
 // Scaffolds the bundled template into a new project directory.
 async function scaffoldCmd(): Promise<void> {
     const name = rest.find((arg) => !arg.startsWith('--'))
@@ -111,10 +118,14 @@ function usage(): never {
             '  belte start                          run the production server against dist/\n' +
             '  belte compile [--target=<bun-...>] [--out=<path>]\n' +
             '                                       build a standalone server executable\n' +
-            '  belte cli [--thin] [--target=<bun-...>] [--out=<path>] [--platforms=<a,b,c>]\n' +
-            '                                       build the cli binary (full by default — runs\n' +
-            '                                       locally; --thin builds the remote client;\n' +
-            '                                       --platforms cross-compiles per platform)',
+            '  belte cli [--target=<bun-...>] [--out=<path>] [--platforms=<a,b,c>]\n' +
+            '                                       build the cli binary — a thin remote client\n' +
+            '                                       that talks to a running server (needs APP_URL;\n' +
+            '                                       --platforms cross-compiles per platform)\n' +
+            '  belte bundle                         build a movable, self-contained app\n' +
+            '                                       bundle for this platform (unsigned). Boots\n' +
+            '                                       into a connect screen — start the embedded\n' +
+            '                                       server or connect to a remote one',
     )
     process.exit(1)
 }
@@ -131,6 +142,8 @@ if (command === 'scaffold') {
     await compileCmd()
 } else if (command === 'cli') {
     await cliCmd()
+} else if (command === 'bundle') {
+    await bundleCmd()
 } else {
     usage()
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@briancray/belte",
-    "version": "0.1.0",
+    "version": "0.2.1",
     "type": "module",
     "description": "Isomorphic multimodal HTTP framework built for humans and machines in a single Bun runtime",
     "license": "MIT",
@@ -43,6 +43,7 @@
         "./browser/HttpError": "./src/lib/server/HttpError.ts",
         "./mcp/*": "./src/lib/mcp/*.ts",
         "./cli/*": "./src/lib/cli/*.ts",
+        "./bundle/*": "./src/lib/bundle/*.ts",
         "./shared/*": "./src/lib/shared/*.ts",
         "./build": "./src/build.ts",
         "./compile": "./src/compile.ts",

package/src/appEntry.ts

@@ -0,0 +1,124 @@
+// @ts-expect-error virtual module resolved by belteResolverPlugin
+import { disconnectedHtml } from './_virtual/bundle-disconnected.ts'
+// @ts-expect-error virtual module resolved by belteResolverPlugin
+import bundleWindow from './_virtual/bundle-window.ts'
+// @ts-expect-error virtual module resolved by belteResolverPlugin
+import programName from './_virtual/cli-name.ts'
+import type { BundleMenu } from './lib/bundle/BundleMenu.ts'
+import type { BundleWindow } from './lib/bundle/BundleWindow.ts'
+import { openWebview } from './lib/bundle/openWebview.ts'
+import { log } from './lib/shared/log.ts'
+
+/*
+Compiled bundle launcher entry — the executable a bundle runs. Instead of a blank
+window it boots into a connect screen, letting the user either connect to a remote
+server by URL or start the embedded server binary that ships beside this launcher.
+
+The connect screen is served by a tiny control server, but that server can't live
+on this main thread: `openWebview` calls `webview_run`, a native UI loop that
+blocks the thread (and its JS event loop) until the window closes, so an
+in-process `Bun.serve` would never answer. The control server runs in a Worker
+instead (see controlServerWorker.ts) and hands back the origin to point the window
+at; it also owns the embedded-server child and the native menu flag, since neither
+can be driven from a main thread frozen inside webview_run.
+
+Bun doesn't apply this build's plugins to the worker entry, so the worker can't
+import belte's virtual modules; this entry imports them (the connect-screen HTML,
+the app title) and passes them in the worker's `init` message.
+
+The window owns the main thread; on close we tell the worker to reap its child.
+*/
+const window = bundleWindow as BundleWindow
+const title = window.title ?? programName
+
+/*
+Spawn the control server worker. `__BELTE_WORKER_ENTRY__` is the worker's absolute
+path, injected by bundleApp via Bun's `define` so the specifier is a static literal
+at build time — that's what makes `bun build --compile` embed the worker module
+into the standalone binary. A relative specifier resolves against the build's cwd
+(the consumer project), not this file, so it isn't found; a
+`new URL(..., import.meta.url)` specifier isn't embedded at all.
+*/
+declare const __BELTE_WORKER_ENTRY__: string
+const worker = new Worker(__BELTE_WORKER_ENTRY__)
+
+worker.addEventListener('error', (event: ErrorEvent) => {
+    log.error(`control server worker failed: ${event.message}`)
+})
+
+// Hand the worker the plugin-resolved data it can't import itself, then start it.
+worker.postMessage({
+    type: 'init',
+    init: { disconnectedHtml: disconnectedHtml as string, title, programName },
+})
+
+// The worker posts its control-server origin once bound; the window points here.
+const origin = await new Promise<string>((resolve) => {
+    worker.addEventListener('message', (event: MessageEvent) => {
+        const data = event.data as { type: string; origin?: string }
+        if (data.type === 'ready' && data.origin) {
+            resolve(data.origin)
+        }
+    })
+})
+
+/*
+The built-in File menu (Start / Disconnect), placed before Edit. Each item is a
+`navigate` repointing the window at a control-server URL the connect screen
+interprets; the internal `role` drives the native validateMenuItem: gating (Start
+when disconnected, Disconnect when connected). There's no Connect item — Disconnect
+already returns to the connect screen, whose form is the place to point at another
+server. Roled items are launcher-only, so they carry an extra field the public
+BundleMenuItem type doesn't advertise — modelled here with a local type and bridged
+to BundleMenu when handed to openWebview (which only serialises the menu to JSON).
+*/
+type FileMenuItem =
+    | { separator: true }
+    | {
+          label: string
+          shortcut?: string
+          navigate: string
+          role: 'start' | 'disconnect'
+      }
+const fileMenu: { label: string; items: FileMenuItem[] } = {
+    label: 'File',
+    items: [
+        { label: 'Start Server', navigate: `${origin}/?action=start`, role: 'start' },
+        { separator: true },
+        { label: 'Disconnect', navigate: `${origin}/?action=disconnect`, role: 'disconnect' },
+    ],
+}
+
+log.info(`opening ${title} connect screen at ${origin}`)
+await openWebview({
+    url: origin,
+    title,
+    width: window.width,
+    height: window.height,
+    menu: window.menu,
+    fileMenu: fileMenu as unknown as BundleMenu,
+    // Forward the window handle so the worker can bounce it back to the connect
+    // screen if the connected server stops responding.
+    onWindow: (handle) => {
+        if (handle) {
+            worker.postMessage({ type: 'window', handle: Number(handle) })
+        }
+    },
+})
+
+/*
+Window closed — have the worker reap the embedded server child and stop its
+control server before we exit, since both live on the worker thread. Bounded by a
+timeout so a wedged worker can't keep the launcher alive.
+*/
+await new Promise<void>((resolve) => {
+    worker.addEventListener('message', (event: MessageEvent) => {
+        if ((event.data as { type?: string }).type === 'shutdownDone') {
+            resolve()
+        }
+    })
+    worker.postMessage({ type: 'shutdown' })
+    setTimeout(resolve, 1000)
+})
+worker.terminate()
+process.exit(0)