@briancray/belte 0.1.0 → 0.2.0

package/src/lib/bundle/onMenu.ts

@@ -0,0 +1,26 @@
+/*
+Subscribes to bundle menu clicks. Each custom menu item declared in the bundle
+window config dispatches a `belte:menu` CustomEvent into the page when clicked;
+this registers `handler`, called with the item's `emit` name. Returns an
+unsubscribe function, so it drops straight into a Svelte `$effect`:
+
+    $effect(() =>
+        onMenu((name) => {
+            if (name === 'reload') location.reload()
+        }),
+    )
+
+Inert during SSR and in a plain browser tab — `$effect` only runs client-side,
+the native menu that fires the event exists only in the bundled desktop app,
+and `window` is guarded so importing the module never assumes a DOM.
+*/
+export function onMenu(handler: (name: string) => void): () => void {
+    if (typeof window === 'undefined') {
+        return () => {}
+    }
+    function listener(event: Event) {
+        handler((event as CustomEvent<{ name: string }>).detail.name)
+    }
+    window.addEventListener('belte:menu', listener)
+    return () => window.removeEventListener('belte:menu', listener)
+}

package/src/lib/bundle/openWebview.ts

@@ -0,0 +1,81 @@
+import { dlopen, FFIType, type Pointer } from 'bun:ffi'
+import type { BundleMenu } from './BundleMenu.ts'
+import { installMacMenu } from './installMacMenu.ts'
+import { resolveWebviewLib } from './resolveWebviewLib.ts'
+
+// WEBVIEW_HINT_NONE — the window is freely resizable (the only hint we need).
+const WEBVIEW_HINT_NONE = 0
+
+/*
+Encodes a string as a NUL-terminated UTF-8 buffer for the C ABI. bun:ffi
+passes a TypedArray to a `ptr` argument as a raw pointer, and the webview
+C functions expect NUL-terminated `const char *`.
+*/
+function cString(value: string): Uint8Array {
+    return new TextEncoder().encode(`${value}\0`)
+}
+
+/*
+Opens a native OS webview window pointed at `url` and blocks until the
+user closes it. This drives the platform UI run loop (WebKit on macOS,
+WebView2 on Windows, WebKitGTK on Linux) via FFI against the webview C
+library — no Chromium is bundled. Because `webview_run` enters a blocking
+native event loop on the calling thread, the belte server must already be
+running in a separate process; this call owns the main thread until the
+window closes, then destroys the handle and releases the library.
+*/
+export async function openWebview({
+    url,
+    title,
+    width = 1024,
+    height = 768,
+    menu,
+    fileMenu,
+    onWindow,
+}: {
+    url: string
+    title: string
+    width?: number
+    height?: number
+    menu?: BundleMenu[]
+    // The File menu, inserted before Edit — the launcher's Start/Disconnect.
+    fileMenu?: BundleMenu
+    /*
+    Hands back the window handle once it exists, before the run loop blocks the
+    thread. The launcher forwards it to its control-server worker so the worker
+    can navigate the window from off-thread (e.g. bounce back to the connect
+    screen when the connected server dies).
+    */
+    onWindow?: (handle: Pointer | null) => void
+}): Promise<void> {
+    const libPath = await resolveWebviewLib()
+    const { symbols, close } = dlopen(libPath, {
+        webview_create: { args: [FFIType.i32, FFIType.ptr], returns: FFIType.ptr },
+        webview_set_title: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.void },
+        webview_set_size: {
+            args: [FFIType.ptr, FFIType.i32, FFIType.i32, FFIType.i32],
+            returns: FFIType.void,
+        },
+        webview_navigate: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.void },
+        webview_run: { args: [FFIType.ptr], returns: FFIType.void },
+        webview_destroy: { args: [FFIType.ptr], returns: FFIType.void },
+    })
+
+    // The second arg is an optional parent window handle; null means a fresh window.
+    const handle = symbols.webview_create(0, null)
+    symbols.webview_set_title(handle, cString(title))
+    symbols.webview_set_size(handle, width, height, WEBVIEW_HINT_NONE)
+    /*
+    Install the macOS menu bar (no-op off macOS) after the application exists
+    but before the run loop starts, so Quit and the Edit shortcuts work — the
+    upstream webview omits the menu entirely — plus the bundle's custom menus.
+    */
+    installMacMenu(libPath, handle, title, menu, fileMenu)
+    onWindow?.(handle)
+
+    symbols.webview_navigate(handle, cString(url))
+    // Blocks here, running the native UI loop, until the window is closed.
+    symbols.webview_run(handle)
+    symbols.webview_destroy(handle)
+    close()
+}

package/src/lib/bundle/pngToIcns.ts

@@ -0,0 +1,47 @@
+import { log } from '../shared/log.ts'
+
+/*
+The conventional macOS `.iconset` contents — each variant is a square PNG
+at the named pixel size. `iconutil` packs a directory of exactly these
+into a multi-resolution `.icns`. @2x entries are the retina variants.
+*/
+const ICONSET_VARIANTS = [
+    { name: 'icon_16x16.png', size: 16 },
+    { name: 'icon_16x16@2x.png', size: 32 },
+    { name: 'icon_32x32.png', size: 32 },
+    { name: 'icon_32x32@2x.png', size: 64 },
+    { name: 'icon_128x128.png', size: 128 },
+    { name: 'icon_128x128@2x.png', size: 256 },
+    { name: 'icon_256x256.png', size: 256 },
+    { name: 'icon_256x256@2x.png', size: 512 },
+    { name: 'icon_512x512.png', size: 512 },
+    { name: 'icon_512x512@2x.png', size: 1024 },
+]
+
+/*
+Converts a PNG into a macOS `.icns` using the system `sips` + `iconutil`
+tools, which ship with macOS. `sips` resizes the source into each iconset
+variant; `iconutil` packs the iconset directory into the `.icns`. Returns
+true on success. On any failure (tools missing, unreadable source) it logs
+a warning and returns false so the bundle still completes without an icon
+rather than aborting the whole build.
+*/
+export async function pngToIcns(pngPath: string, outPath: string): Promise<boolean> {
+    const iconset = `${outPath}.iconset`
+    try {
+        await Bun.$`mkdir -p ${iconset}`.quiet()
+        await Promise.all(
+            ICONSET_VARIANTS.map(({ name, size }) =>
+                Bun.$`sips -z ${size} ${size} ${pngPath} --out ${`${iconset}/${name}`}`.quiet(),
+            ),
+        )
+        await Bun.$`iconutil -c icns ${iconset} -o ${outPath}`.quiet()
+        return true
+    } catch (error) {
+        log.warn(`could not convert ${pngPath} to .icns — bundling without an icon`)
+        log.error(error)
+        return false
+    } finally {
+        await Bun.$`rm -rf ${iconset}`.quiet()
+    }
+}

package/src/lib/bundle/probeBelteServer.ts

@@ -0,0 +1,34 @@
+// The identity shape a belte server returns from GET /__belte/identity.
+export type BelteIdentity = { name: string; version: string }
+
+/*
+Confirms a URL points at a belte server before the launcher navigates the app
+window there, by fetching its unauthenticated identity endpoint. Returns the
+server's identity on success, or undefined when nothing belte answers — a network
+error, the wrong port, or a non-belte page (a bare 403/404, a different app). The
+endpoint bypasses the app's own middleware, so an auth-guarded belte app still
+verifies here even though its pages would later redirect to a login.
+*/
+export async function probeBelteServer(target: string): Promise<BelteIdentity | undefined> {
+    try {
+        const base = target.replace(/\/+$/, '')
+        const response = await fetch(`${base}/__belte/identity`, {
+            headers: { accept: 'application/json' },
+            signal: AbortSignal.timeout(5000),
+        })
+        if (!response.ok) {
+            return undefined
+        }
+        const body = (await response.json()) as {
+            belte?: boolean
+            name?: string
+            version?: string
+        }
+        if (body.belte !== true) {
+            return undefined
+        }
+        return { name: body.name ?? 'belte app', version: body.version ?? '0.0.0' }
+    } catch {
+        return undefined
+    }
+}

package/src/lib/bundle/resolveServerBinary.ts

@@ -0,0 +1,12 @@
+import { dirname, join } from 'node:path'
+import { serverBinaryFilename } from './serverBinaryFilename.ts'
+
+/*
+Locates the embedded server binary that ships beside the launcher inside a
+bundle. The launcher's own path is `process.execPath` (the compiled binary
+itself), so the server sits in the same directory — true for both the
+flat-directory layout and a macOS `.app`'s `Contents/MacOS/`.
+*/
+export function resolveServerBinary(): string {
+    return join(dirname(process.execPath), serverBinaryFilename())
+}

package/src/lib/bundle/resolveWebviewLib.ts

@@ -0,0 +1,51 @@
+import { dirname, join } from 'node:path'
+import { webviewCachePath } from './webviewCachePath.ts'
+import { webviewLibName } from './webviewLibName.ts'
+
+/*
+Locates the native webview shared library to load over FFI, without ever
+compiling — this runs in the compiled launcher too, where no toolchain is
+present. Resolution order:
+
+  1. BELTE_WEBVIEW_LIB — explicit path, the escape hatch for any layout.
+  2. inside a bundle — beside the launcher binary (flat layout) or in
+     `../Frameworks` (macOS `.app`), so a shipped bundle is self-contained.
+  3. belte's own build cache — the library compiled from the vendored
+     header by buildWebviewLib (populated at build time via ensureWebviewLib).
+
+belte ships the vendored source rather than a prebuilt binary, so the
+toolchain path (`belte bundle`) calls ensureWebviewLib to build-on-miss;
+this resolver only reports what already exists. Throws with
+guidance when nothing resolves rather than letting dlopen fail opaquely.
+*/
+export async function resolveWebviewLib(cwd: string = process.cwd()): Promise<string> {
+    const fromEnv = process.env.BELTE_WEBVIEW_LIB
+    if (fromEnv) {
+        return fromEnv
+    }
+
+    const libName = webviewLibName()
+
+    /*
+    Bundle-relative candidates. In dev `process.execPath` is the `bun`
+    binary, so these miss and we fall through to the build cache; in a
+    shipped bundle the launcher's own directory holds the lib.
+    */
+    const binDir = dirname(process.execPath)
+    const bundledCandidates = [join(binDir, libName), join(binDir, '..', 'Frameworks', libName)]
+    for (const candidate of bundledCandidates) {
+        if (await Bun.file(candidate).exists()) {
+            return candidate
+        }
+    }
+
+    const cached = webviewCachePath()
+    if (await Bun.file(cached).exists()) {
+        return cached
+    }
+
+    throw new Error(
+        '[belte] no native webview library found. Run `belte bundle` to ' +
+            'build it from the vendored source, or set BELTE_WEBVIEW_LIB to a prebuilt one.',
+    )
+}

package/src/lib/bundle/serverBinaryFilename.ts

@@ -0,0 +1,8 @@
+/*
+Filename of the embedded server binary that ships beside the launcher
+inside a bundle. Both the bundler (which writes it) and the launcher
+(which spawns it) derive the name here so they can't drift apart.
+*/
+export function serverBinaryFilename(platform: NodeJS.Platform = process.platform): string {
+    return platform === 'win32' ? 'server.exe' : 'server'
+}

package/src/lib/bundle/stableLocalPort.ts

@@ -0,0 +1,19 @@
+/*
+Derives a deterministic localhost port from the program name so the connect
+screen's origin (and thus its localStorage) stays stable across launches — a
+remembered server URL survives a relaunch only if the page is reloaded from the
+same origin. Hashes the name with FNV-1a (32-bit) and maps it into the
+dynamic/private range (49152–65535). The caller probes availability and falls
+back to a random free port on collision, so determinism is a best effort, not a
+guarantee.
+*/
+export function stableLocalPort(programName: string): number {
+    // FNV-1a 32-bit: offset basis 2166136261, prime 16777619. Math.imul keeps
+    // the multiply in 32-bit space; `>>> 0` reads the result back as unsigned.
+    let hash = 0x811c9dc5
+    for (const character of programName) {
+        hash ^= character.charCodeAt(0)
+        hash = Math.imul(hash, 0x01000193)
+    }
+    return 49152 + ((hash >>> 0) % 16384)
+}

package/src/lib/bundle/waitForServer.ts

@@ -0,0 +1,23 @@
+/*
+Polls an HTTP URL until it answers (any status) or the deadline passes.
+The spawned server child binds asynchronously, so the launcher can't open
+the webview until a request round-trips. A connection refusal throws and
+is swallowed; once Bun.serve is listening the fetch resolves and we
+return. Throws on timeout so the launcher can report a failed boot rather
+than open a blank window.
+*/
+export async function waitForServer(
+    url: string,
+    { timeoutMs = 10_000, intervalMs = 50 }: { timeoutMs?: number; intervalMs?: number } = {},
+): Promise<void> {
+    const deadline = Bun.nanoseconds() + timeoutMs * 1e6
+    while (Bun.nanoseconds() < deadline) {
+        try {
+            await fetch(url)
+            return
+        } catch {
+            await Bun.sleep(intervalMs)
+        }
+    }
+    throw new Error(`[belte] server did not become ready at ${url} within ${timeoutMs}ms`)
+}

package/src/lib/bundle/webviewBuildRevision.ts

@@ -0,0 +1,9 @@
+/*
+Revision of belte's own contribution to the compiled webview library — the
+native shim sources linked in beside the vendored header (e.g. belteMenu.mm)
+and the flags buildWebviewLib compiles them with. It participates in the build
+cache key alongside the upstream version, so changing belte's native build
+selects a fresh cache path and bypasses any library built before the change.
+Bump this whenever the shim sources or their compile invocation change.
+*/
+export const webviewBuildRevision = 8

package/src/lib/bundle/webviewCachePath.ts

@@ -0,0 +1,23 @@
+import { join } from 'node:path'
+import { webviewBuildRevision } from './webviewBuildRevision.ts'
+import { webviewLibName } from './webviewLibName.ts'
+import { webviewVersion } from './webviewVersion.ts'
+
+/*
+Absolute path where the locally built webview library is cached. belte
+compiles the vendored `native/webview.h` once per host and reuses the
+result; both buildWebviewLib (the writer) and resolveWebviewLib (a reader)
+derive the location here so they never drift.
+
+The cache sits next to the vendored source inside the belte package, so it
+is shared across every project on the machine that uses this belte install
+and survives independently of any consumer's `cwd`. Namespacing by
+platform + arch + upstream version keeps a single cache correct across
+architectures and makes a header bump — or a belte native-build bump — select
+a fresh path automatically.
+*/
+export function webviewCachePath(): string {
+    const nativeDir = new URL('./native', import.meta.url).pathname
+    const key = `${process.platform}-${process.arch}-${webviewVersion}-${webviewBuildRevision}`
+    return join(nativeDir, '.cache', key, webviewLibName())
+}

package/src/lib/bundle/webviewLibName.ts

@@ -0,0 +1,11 @@
+import { suffix } from 'bun:ffi'
+
+/*
+Native webview shared-library filename for a platform. `suffix` is Bun's
+host shared-library extension (`dylib`/`so`/`dll`). The bundler copies a
+file under this name and the loader looks for it under the same name, so
+both derive it here.
+*/
+export function webviewLibName(platform: NodeJS.Platform = process.platform): string {
+    return platform === 'win32' ? `webview.${suffix}` : `libwebview.${suffix}`
+}

package/src/lib/bundle/webviewVersion.ts

@@ -0,0 +1,7 @@
+/*
+Upstream `webview/webview` release the vendored `native/webview.h` is taken
+from (https://github.com/webview/webview, MIT). Used to namespace the build
+cache so bumping the header naturally bypasses any previously built library.
+Bump this whenever `native/webview.h` is re-vendored.
+*/
+export const webviewVersion = '0.12.0'

package/src/lib/cli/createClient.ts

@@ -1,10 +1,9 @@
+import { findVerbByCommandName } from '../server/rpc/findVerbByCommandName.ts'
 import type { HttpVerb } from '../server/rpc/types/HttpVerb.ts'
 import { verbRegistry } from '../server/rpc/verbRegistry.ts'
 import { buildRpcRequest } from '../shared/buildRpcRequest.ts'
-import { commandNameForUrl } from '../shared/commandNameForUrl.ts'
 import { decodeResponse } from '../shared/decodeResponse.ts'
 import type { CliManifest } from './types/CliManifest.ts'
-import type { CliManifestEntry } from './types/CliManifestEntry.ts'
 
 type AnyApi = Record<string, (args?: unknown) => Promise<unknown>>
 
@@ -23,8 +22,11 @@ decided at construction:
 
 The `manifest` is the bundler-emitted CLI manifest baked into the thin
 binary. In in-process mode it's optional (registry is the source of
-truth). Both can be supplied to support a binary that talks remote by
-default but falls back to in-process when APP_URL is unset.
+truth); in remote mode it supplies the method + url per command without
+needing the rpc modules loaded. The mode is chosen solely by whether
+`url` is set — the shipped CLI binary (see runCli) always passes `url`,
+so it runs remote-only; in-process mode is for same-project scripts and
+tests that import this directly without a `url`.
 */
 export function createClient<Api extends AnyApi = AnyApi>(opts?: {
     url?: string
@@ -45,55 +47,45 @@ export function createClient<Api extends AnyApi = AnyApi>(opts?: {
         if (entry) {
             return { method: entry.method, url: entry.url }
         }
-        for (const value of verbRegistry.values()) {
-            if (commandNameForUrl(value.remote.url) === name) {
-                return { method: value.remote.method, url: value.remote.url }
-            }
-        }
-        return undefined
+        const found = findVerbByCommandName(name)
+        return found ? { method: found.remote.method, url: found.remote.url } : undefined
     }
 
-    async function callRemote(
+    /*
+    Single call path for both modes — only the base URL and how the Request
+    is dispatched differ. Remote mode fetches over the network; in-process
+    mode looks the verb up in the registry and runs verb.fetch (no hop).
+    */
+    async function call(
         method: HttpVerb,
         path: string,
         args: unknown,
         baseUrl: string,
+        dispatch: (request: Request) => Promise<Response>,
     ): Promise<unknown> {
         const headers = new Headers()
         if (token) {
             headers.set('authorization', `Bearer ${token}`)
         }
         const request = buildRpcRequest({ method, url: path, args, baseUrl, headers })
-        const response = await fetch(request)
+        const response = await dispatch(request)
         if (!response.ok) {
             throw new Error(`${method} ${path} failed: ${response.status} ${response.statusText}`)
         }
         return decodeResponse(response)
     }
 
-    async function callInProcess(method: HttpVerb, path: string, args: unknown): Promise<unknown> {
-        const entry = verbRegistry.get(path)
-        if (!entry) {
-            throw new Error(
-                `RPC ${path} not loaded — import the module first or set APP_URL to use remote mode`,
-            )
-        }
-        const headers = new Headers()
-        if (token) {
-            headers.set('authorization', `Bearer ${token}`)
-        }
-        const request = buildRpcRequest({
-            method,
-            url: path,
-            args,
-            baseUrl: 'http://localhost/',
-            headers,
-        })
-        const response = await entry.remote.fetch(request)
-        if (!response.ok) {
-            throw new Error(`${method} ${path} failed: ${response.status} ${response.statusText}`)
+    // In-process dispatch: resolve the verb from the registry and run its fetch.
+    function inProcessDispatch(path: string): (request: Request) => Promise<Response> {
+        return (request) => {
+            const entry = verbRegistry.get(path)
+            if (!entry) {
+                throw new Error(
+                    `RPC ${path} not loaded — import the module first or set APP_URL to use remote mode`,
+                )
+            }
+            return entry.remote.fetch(request)
         }
-        return decodeResponse(response)
     }
 
     /*
@@ -116,8 +108,14 @@ export function createClient<Api extends AnyApi = AnyApi>(opts?: {
             const invoker = resolved
                 ? (args?: unknown) =>
                       url
-                          ? callRemote(resolved.method, resolved.url, args, url)
-                          : callInProcess(resolved.method, resolved.url, args)
+                          ? call(resolved.method, resolved.url, args, url, fetch)
+                          : call(
+                                resolved.method,
+                                resolved.url,
+                                args,
+                                'http://localhost/',
+                                inProcessDispatch(resolved.url),
+                            )
                 : undefined
             invokerCache.set(prop, invoker)
             return invoker

package/src/lib/cli/printHelp.ts

@@ -1,4 +1,28 @@
 import type { CliManifest } from './types/CliManifest.ts'
+import type { CliManifestEntry } from './types/CliManifestEntry.ts'
+
+/*
+Compact one-line flag signature for the top-level listing: required
+flags are shown bare, optional flags wrapped in `[ ]`. Booleans drop the
+value placeholder; arrays show `<value...>` to hint repetition. Full
+per-flag types + descriptions live in `<cmd> --help`.
+*/
+function flagSignature(jsonSchema: CliManifestEntry['jsonSchema']): string {
+    const properties =
+        (jsonSchema?.properties as Record<string, { type?: string }> | undefined) ?? {}
+    const required = new Set((jsonSchema?.required as string[] | undefined) ?? [])
+    return Object.entries(properties)
+        .map(([key, value]) => {
+            const placeholder =
+                value.type === 'boolean'
+                    ? `--${key}`
+                    : value.type === 'array'
+                      ? `--${key} <value...>`
+                      : `--${key} <${value.type ?? 'value'}>`
+            return required.has(key) ? placeholder : `[${placeholder}]`
+        })
+        .join(' ')
+}
 
 /*
 Top-level help (no subcommand) lists every available command with a
@@ -24,12 +48,27 @@ export function printTopLevelHelp(
         if (!entry) {
             continue
         }
-        console.log(`  ${name.padEnd(20)} ${entry.method} ${entry.url}`)
+        /*
+        Summary line favours the schema's top-level description (carried
+        through by the vendor's JSON Schema conversion); falls back to
+        `method url` when the schema has none. The detail line below
+        always shows the args, plus method/url when it isn't already the
+        summary.
+        */
+        const description = entry.jsonSchema?.description as string | undefined
+        console.log(`  ${name.padEnd(20)} ${description ?? `${entry.method} ${entry.url}`}`)
+        const signature = flagSignature(entry.jsonSchema)
+        const detail = [description && `${entry.method} ${entry.url}`, signature]
+            .filter(Boolean)
+            .join('  ')
+        if (detail) {
+            console.log(`  ${' '.repeat(20)} ${detail}`)
+        }
     }
     console.log(`\n  --help, -h           show this help`)
     console.log(`  <command> --help     show help for a specific command`)
     console.log(`\nenv:`)
-    console.log(`  APP_URL              remote server URL (unset → in-process)`)
+    console.log(`  APP_URL              remote server URL (required)`)
     console.log(`  APP_TOKEN            sent as Authorization: Bearer <value>`)
     if (footer.trim()) {
         console.log('')
@@ -46,6 +85,10 @@ export function printCommandHelp(programName: string, name: string, manifest: Cl
     console.log(`usage: ${programName} ${name} [--flags]\n`)
     console.log(`  ${entry.method} ${entry.url}\n`)
     const schema = entry.jsonSchema
+    const commandDescription = schema?.description as string | undefined
+    if (commandDescription) {
+        console.log(`${commandDescription}\n`)
+    }
     const properties =
         (schema?.properties as
             | Record<string, { type?: string; description?: string }>

package/src/lib/cli/runCli.ts

@@ -6,14 +6,17 @@ import type { CliManifest } from './types/CliManifest.ts'
 
 /*
 Top-level CLI driver. Loaded by the standalone binary's entry; expects
-the bundler-emitted manifest plus the raw argv tail. Flow:
+the bundler-emitted manifest plus the raw argv tail. The binary is a
+thin remote client — it carries no handler code, so it always talks to a
+running server over HTTP and APP_URL must be set. Flow:
 
   1. Read .env next to the binary so APP_URL / APP_TOKEN are picked up
      for the common install-tarball case.
   2. Pull the first positional as the subcommand.
   3. --help and `<cmd> --help` print and exit zero.
-  4. Otherwise parse the rest of the argv against the manifest entry's
-     JSON Schema and dispatch via createClient.
+  4. Require APP_URL before dispatching a command.
+  5. Otherwise parse the rest of the argv against the manifest entry's
+     JSON Schema and dispatch via createClient against APP_URL.
 
 Streaming responses aren't a thing at this layer yet — every RPC tool
 goes through decodeResponse (text/JSON). Streaming verbs (jsonl/sse)
@@ -62,6 +65,12 @@ export async function runCli({
     }
 
     const appUrl = process.env.APP_URL
+    if (!appUrl) {
+        console.error(
+            `${programName}: APP_URL is not set — the cli talks to a running server, so point it at one (e.g. APP_URL=http://localhost:3000)`,
+        )
+        return 1
+    }
     const appToken = process.env.APP_TOKEN
     const client = createClient({ url: appUrl, token: appToken, manifest })
 

package/src/lib/mcp/createMcpResourceServer.ts

@@ -89,7 +89,7 @@ export function createMcpResourceServer({
                 if (!compressed) {
                     return undefined
                 }
-                return contentsFor(relativePath, Bun.zstdDecompressSync(compressed))
+                return contentsFor(relativePath, await Bun.zstdDecompress(compressed))
             }
             const file = Bun.file(`${resourcesDir}/${relativePath}`)
             if (!(await file.exists())) {