@briancray/belte 0.5.0 → 0.5.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@briancray/belte",
-    "version": "0.5.0",
+    "version": "0.5.2",
     "type": "module",
     "description": "Isomorphic multimodal HTTP framework built for humans and machines in a single Bun runtime",
     "license": "MIT",

package/src/bundleApp.ts

@@ -1,3 +1,4 @@
+import { dirname } from 'node:path'
 import { buildDisconnected } from './buildDisconnected.ts'
 import { compile } from './compile.ts'
 import { ensureWebviewLib } from './lib/bundle/ensureWebviewLib.ts'
@@ -11,6 +12,7 @@ import { exitOnBuildFailure } from './lib/shared/exitOnBuildFailure.ts'
 import { loadSvelteConfig } from './lib/shared/loadSvelteConfig.ts'
 import { log } from './lib/shared/log.ts'
 import { programNameForPackage } from './lib/shared/programNameForPackage.ts'
+import { shippedEnvPath } from './lib/shared/shippedEnvPath.ts'
 import { serverBuildPlugins } from './serverBuildPlugins.ts'
 
 const APP_ENTRY = new URL('./appEntry.ts', import.meta.url).pathname
@@ -57,15 +59,19 @@ export async function bundleApp({ cwd = process.cwd() }: { cwd?: string } = {}):
     await compile({ cwd, target, outfile: `${binDir}/${serverBinaryFilename()}` })
 
     /*
-    Opt-in: ship the project's `.env.bundle` as the binary-dir `.env`, which the
+    Opt-in: ship the project's `.env.bundle` as the shipped `.env`, which the
     server loads at boot (loadEnvFromBinaryDir) as its default config layer. A
     dedicated file, never the working `.env` — a compiled bundle is extractable,
     so only ship-safe defaults belong here; user-specific/secret values come from
-    the data-dir `.env` instead. Skipped when absent.
+    the data-dir `.env` instead. shippedEnvPath places it under Contents/Resources
+    in a macOS `.app` (sealed as a resource, so it survives codesign) and beside
+    the binaries otherwise. Skipped when absent.
     */
     const bundleEnv = Bun.file(`${cwd}/.env.bundle`)
     if (await bundleEnv.exists()) {
-        await Bun.write(`${binDir}/.env`, bundleEnv)
+        const envPath = shippedEnvPath(binDir)
+        await Bun.$`mkdir -p ${dirname(envPath)}`.quiet()
+        await Bun.write(envPath, bundleEnv)
     }
 
     // 2. Connect screen — bake dist/bundle-disconnected.html before the launcher

package/src/controlServerWorker.ts

@@ -9,10 +9,12 @@ import { resolveServerBinary } from './lib/bundle/resolveServerBinary.ts'
 import { resolveWebviewLib } from './lib/bundle/resolveWebviewLib.ts'
 import { stableLocalPort } from './lib/bundle/stableLocalPort.ts'
 import { waitForServer } from './lib/bundle/waitForServer.ts'
+import { parsePort } from './lib/server/runtime/parsePort.ts'
 import { appDataDir } from './lib/shared/appDataDir.ts'
 import { log } from './lib/shared/log.ts'
 import { readEnvFile } from './lib/shared/readEnvFile.ts'
 import { serializeEnv } from './lib/shared/serializeEnv.ts'
+import { shippedEnvPath } from './lib/shared/shippedEnvPath.ts'
 
 /*
 The bundle's control server, run in a Worker so it owns its own thread.
@@ -160,9 +162,26 @@ Spawns the sibling server binary on a free port and waits for it to answer,
 returning the URL to point the window at. Any previous child is reaped first so
 only one embedded server runs at a time.
 */
+/*
+The port the embedded server binds. A `PORT` configured in the data-dir `.env`
+(where the config form writes), the shipped binary-dir `.env`, or the launcher's
+own env is honored — so the server answers at a fixed, known address another
+machine can reliably connect to. With none set, a free port is chosen (the
+historical behaviour). Precedence matches the server's own env stack: shell >
+data-dir > binary-dir. A configured port is used as-is and not second-guessed —
+if it's taken, the bind failure surfaces rather than silently moving.
+*/
+async function resolveEmbeddedPort(): Promise<number> {
+    const [dataDirEnv, binaryDirEnv] = await Promise.all([
+        readEnvFile(dataDirEnvPath()),
+        readEnvFile(binaryDirEnvPath()),
+    ])
+    return parsePort(process.env.PORT ?? dataDirEnv.PORT ?? binaryDirEnv.PORT) ?? findFreePort()
+}
+
 async function startEmbeddedServer(timeoutMs?: number): Promise<string> {
     killServerChild()
-    const port = findFreePort()
+    const port = await resolveEmbeddedPort()
     const url = `http://localhost:${port}`
     serverChild = Bun.spawn({
         cmd: [resolveServerBinary()],
@@ -267,6 +286,13 @@ function dataDirEnvPath(): string {
     return join(appDataDir(programName), '.env')
 }
 
+// The bundle's shipped `.env` (its default config layer), resolved from the binary
+// directory — same source loadEnvFromBinaryDir reads at boot (dirname of the running
+// binary): beside the binary in the flat layout, under Resources in a `.app`.
+function binaryDirEnvPath(): string {
+    return shippedEnvPath(dirname(process.execPath))
+}
+
 /*
 Resolves the value to pre-fill each config field with, following the same
 precedence the server applies below the shell: the user's saved data-dir `.env`,
@@ -279,7 +305,7 @@ async function resolveConfigValues(): Promise<Record<string, string>> {
     // Independent reads — fetch together; precedence is applied in the merge below.
     const [dataDirEnv, binaryDirEnv] = await Promise.all([
         readEnvFile(dataDirEnvPath()),
-        readEnvFile(join(dirname(resolveServerBinary()), '.env')),
+        readEnvFile(binaryDirEnvPath()),
     ])
     return Object.fromEntries(
         Object.keys(properties).map((key) => {

package/src/lib/cli/loadEnvFromBinaryDir.ts

@@ -1,14 +1,16 @@
 import { dirname } from 'node:path'
 import { loadEnvFile } from '../shared/loadEnvFile.ts'
+import { shippedEnvPath } from '../shared/shippedEnvPath.ts'
 
 /*
-Loads a `.env` sitting next to the running binary (resolved via
-`process.execPath`) into `process.env`. This is the file the install tarball
-ships beside the executable — and, for a bundle, the one `bundleApp` copies
-from the project's `.env.bundle`. It carries the app's shipped defaults; the
+Loads the bundle's shipped `.env` into `process.env`, resolved from the running
+binary's directory (`process.execPath`) via shippedEnvPath — beside the binary in
+the flat layout, under `Contents/Resources` in a macOS `.app`. This is the file the
+install tarball ships beside the executable — and, for a bundle, the one `bundleApp`
+copies from the project's `.env.bundle`. It carries the app's shipped defaults; the
 fill-when-unset merge (see loadEnvFile) lets per-shell exports, Bun's CWD
 `.env`, and the user's data-dir config all override it.
 */
 export async function loadEnvFromBinaryDir(): Promise<void> {
-    await loadEnvFile(`${dirname(process.execPath)}/.env`)
+    await loadEnvFile(shippedEnvPath(dirname(process.execPath)))
 }

package/src/lib/shared/shippedEnvPath.ts

@@ -0,0 +1,21 @@
+import { basename, dirname, join } from 'node:path'
+
+/*
+Path of the bundle's shipped `.env` — the default config layer written at build
+time and read back at boot. Given the directory holding the binaries, returns
+where that `.env` lives.
+
+A macOS `.app` nests binaries under `Contents/MacOS`, but `codesign` seals that
+directory as *code*: a data file there can't survive signing and reloading. So
+for the `.app` layout the `.env` belongs beside the icon in `Contents/Resources`,
+which is sealed as a resource. Every other platform keeps the flat layout, with
+the `.env` next to the binaries. Pure: computes the path, never touches disk.
+*/
+export function shippedEnvPath(binaryDir: string): string {
+    const isMacAppBinaryDir =
+        basename(binaryDir) === 'MacOS' && basename(dirname(binaryDir)) === 'Contents'
+    if (isMacAppBinaryDir) {
+        return join(dirname(binaryDir), 'Resources', '.env')
+    }
+    return join(binaryDir, '.env')
+}