@elizaos/app-core 2.0.0-alpha.85 → 2.0.0-beta.2

package/platforms/electrobun/src/native/whisper.ts

@@ -0,0 +1,280 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export interface WhisperResult {
+	text: string;
+	segments: WhisperSegment[];
+	language?: string;
+	duration?: number;
+}
+
+export interface WhisperSegment {
+	text: string;
+	start: number; // seconds
+	end: number; // seconds
+	tokens?: WhisperToken[];
+}
+
+export interface WhisperToken {
+	text: string;
+	start: number;
+	end: number;
+	probability: number;
+}
+
+// Resolution order (first existing path wins):
+//   1. ELIZA_WHISPER_BIN / ELIZA_WHISPER_MODEL env vars
+//   2. Relative to import.meta.dir
+//   3. Relative to process.cwd()
+function resolveWhisperPath(
+	envVar: string,
+	relativeFromMeta: string,
+	relativeFromCwd: string,
+): string {
+	const envValue = process.env[envVar];
+	if (envValue && fs.existsSync(envValue)) {
+		return envValue;
+	}
+	const fromMeta = path.resolve(import.meta.dir, relativeFromMeta);
+	if (fs.existsSync(fromMeta)) return fromMeta;
+	return path.resolve(process.cwd(), relativeFromCwd);
+}
+
+// Windows whisper.cpp binary has a .exe extension; other platforms do not.
+const WHISPER_BIN_NAME = process.platform === "win32" ? "main.exe" : "main";
+const WHISPER_BIN = resolveWhisperPath(
+	"ELIZA_WHISPER_BIN",
+	`../../../../node_modules/whisper-node/lib/whisper.cpp/${WHISPER_BIN_NAME}`,
+	`node_modules/whisper-node/lib/whisper.cpp/${WHISPER_BIN_NAME}`,
+);
+const WHISPER_MODEL = resolveWhisperPath(
+	"ELIZA_WHISPER_MODEL",
+	"../../../../node_modules/whisper-node/lib/whisper.cpp/models/ggml-base.en.bin",
+	"node_modules/whisper-node/lib/whisper.cpp/models/ggml-base.en.bin",
+);
+
+let whisperBinaryChecked = false;
+let whisperBinaryResult = false;
+
+export function isWhisperBinaryAvailable(): boolean {
+	if (!whisperBinaryChecked) {
+		whisperBinaryResult =
+			fs.existsSync(WHISPER_BIN) && fs.existsSync(WHISPER_MODEL);
+		whisperBinaryChecked = true;
+	}
+	return whisperBinaryResult;
+}
+
+/** Reset the cached result — only for testing. */
+export function _resetWhisperCache(): void {
+	whisperBinaryChecked = false;
+	whisperBinaryResult = false;
+}
+
+/**
+ * Write Float32 PCM samples to a 16-bit PCM RIFF WAV file.
+ * whisper.cpp requires 16kHz mono 16-bit PCM WAV input.
+ */
+export function writeWavFile(
+	filePath: string,
+	pcmFloat32: Float32Array,
+	sampleRate = 16000,
+	channels = 1,
+): void {
+	const numSamples = pcmFloat32.length;
+	const bytesPerSample = 2; // 16-bit
+	const dataSize = numSamples * bytesPerSample;
+	const bufferSize = 44 + dataSize;
+	const buffer = Buffer.allocUnsafe(bufferSize);
+
+	// RIFF header
+	buffer.write("RIFF", 0, "ascii");
+	buffer.writeUInt32LE(36 + dataSize, 4);
+	buffer.write("WAVE", 8, "ascii");
+
+	// fmt  chunk
+	buffer.write("fmt ", 12, "ascii");
+	buffer.writeUInt32LE(16, 16); // chunk size
+	buffer.writeUInt16LE(1, 20); // PCM format
+	buffer.writeUInt16LE(channels, 22);
+	buffer.writeUInt32LE(sampleRate, 24);
+	buffer.writeUInt32LE(sampleRate * channels * bytesPerSample, 28); // byte rate
+	buffer.writeUInt16LE(channels * bytesPerSample, 32); // block align
+	buffer.writeUInt16LE(16, 34); // bits per sample
+
+	// data chunk
+	buffer.write("data", 36, "ascii");
+	buffer.writeUInt32LE(dataSize, 40);
+
+	// Convert Float32 [-1, 1] to Int16
+	for (let i = 0; i < numSamples; i++) {
+		const s = Math.max(-1, Math.min(1, pcmFloat32[i]));
+		const int16 = s < 0 ? s * 32768 : s * 32767;
+		buffer.writeInt16LE(Math.round(int16), 44 + i * 2);
+	}
+
+	fs.writeFileSync(filePath, buffer);
+}
+
+/**
+ * Parse whisper.cpp stdout into a WhisperResult.
+ *
+ * whisper.cpp output format (with --output-txt):
+ *   [00:00:00.000 --> 00:00:01.230]   Hello world
+ *   [00:00:01.230 --> 00:00:02.500]   How are you
+ */
+export function parseWhisperOutput(stdout: string): WhisperResult {
+	const lines = stdout.split("\n");
+	const segments: WhisperSegment[] = [];
+	const textParts: string[] = [];
+
+	// Pattern: [HH:MM:SS.mmm --> HH:MM:SS.mmm]   text
+	const linePattern =
+		/\[\s*(\d+:\d+:\d+\.\d+)\s*-->\s*(\d+:\d+:\d+\.\d+)\s*\]\s*(.*)/;
+
+	for (const line of lines) {
+		const match = line.match(linePattern);
+		if (!match) continue;
+
+		const start = parseTimestamp(match[1]);
+		const end = parseTimestamp(match[2]);
+		const text = match[3].trim();
+
+		if (text) {
+			segments.push({ text, start, end });
+			textParts.push(text);
+		}
+	}
+
+	return {
+		text: textParts.join(" "),
+		segments,
+	};
+}
+
+function parseTimestamp(ts: string): number {
+	// HH:MM:SS.mmm → seconds
+	const parts = ts.split(":");
+	const hours = Number.parseInt(parts[0], 10);
+	const minutes = Number.parseInt(parts[1], 10);
+	const secs = Number.parseFloat(parts[2]);
+	return hours * 3600 + minutes * 60 + secs;
+}
+
+/**
+ * Transcribe an audio file using the whisper.cpp binary directly.
+ * Returns null if the binary is not available.
+ */
+export async function transcribeBunSpawn(
+	audioPath: string,
+): Promise<WhisperResult | null> {
+	if (!isWhisperBinaryAvailable()) {
+		return null;
+	}
+
+	try {
+		const proc = Bun.spawn(
+			[WHISPER_BIN, "-m", WHISPER_MODEL, "-f", audioPath, "-l", "en"],
+			{
+				stdout: "pipe",
+				stderr: "pipe",
+				cwd: path.dirname(WHISPER_BIN),
+			},
+		);
+
+		const [stdout] = await Promise.all([
+			new Response(proc.stdout).text(),
+			proc.exited,
+		]);
+
+		return parseWhisperOutput(stdout);
+	} catch (err) {
+		console.error("[Whisper] transcribeBunSpawn failed:", err);
+		return null;
+	}
+}
+
+let whisperAvailable = false;
+let whisperModule: Record<string, unknown> | null = null;
+let whisperLoadPromise: Promise<boolean> | null = null;
+
+async function tryLoadWhisper(): Promise<boolean> {
+	if (whisperAvailable && whisperModule) {
+		return true;
+	}
+	if (whisperLoadPromise) {
+		return whisperLoadPromise;
+	}
+
+	const packages = [
+		"whisper-node",
+		"@nicksellen/whisper-node",
+		"whisper.cpp",
+		"@nicksellen/whispercpp",
+	];
+
+	whisperLoadPromise = (async () => {
+		for (const pkg of packages) {
+			try {
+				whisperModule = await import(pkg);
+				console.log(`[Whisper] Loaded ${pkg}`);
+				whisperAvailable = true;
+				return true;
+			} catch {}
+		}
+
+		console.warn(
+			"[Whisper] No whisper module available in Bun runtime. " +
+				"STT will fall back to Web Speech API in renderer.",
+		);
+		return false;
+	})();
+
+	try {
+		return await whisperLoadPromise;
+	} finally {
+		if (!whisperAvailable) {
+			whisperLoadPromise = null;
+		}
+	}
+}
+
+export function isWhisperAvailable(): boolean {
+	return whisperAvailable || isWhisperBinaryAvailable();
+}
+
+export function getWhisperModule(): Record<string, unknown> | null {
+	return whisperModule;
+}
+
+export async function transcribe(
+	_audioPath: string,
+	_options?: Record<string, unknown>,
+): Promise<WhisperResult | null> {
+	// Try Bun.spawn path first (more reliable in Bun runtime)
+	const bunResult = await transcribeBunSpawn(_audioPath);
+	if (bunResult) return bunResult;
+
+	// Fallback to dynamic import path
+	if (!whisperAvailable || !whisperModule) {
+		const loaded = await tryLoadWhisper();
+		if (!loaded || !whisperModule) {
+			return null;
+		}
+	}
+
+	try {
+		const whisper =
+			(whisperModule as { default?: unknown }).default ?? whisperModule;
+		if (typeof (whisper as { whisper?: unknown }).whisper === "function") {
+			const result = await (
+				whisper as { whisper: (...args: unknown[]) => Promise<unknown> }
+			).whisper(_audioPath, _options);
+			return result as WhisperResult;
+		}
+		return null;
+	} catch (err) {
+		console.error("[Whisper] Transcription failed:", err);
+		return null;
+	}
+}

package/platforms/electrobun/src/preload-validation.ts

@@ -0,0 +1,65 @@
+import fs from "node:fs";
+import path from "node:path";
+
+type FsLike = Pick<typeof fs, "existsSync" | "readFileSync" | "statSync">;
+
+export interface ElectrobunPreloadStatus {
+	preloadPath: string;
+	sourcePath: string;
+	preloadExists: boolean;
+	sourceExists: boolean;
+	stale: boolean;
+}
+
+export function getElectrobunPreloadStatus(
+	baseDir: string,
+	fileSystem: FsLike = fs,
+): ElectrobunPreloadStatus {
+	const preloadPath = path.join(baseDir, "preload.js");
+	const sourcePath = path.join(baseDir, "bridge", "electrobun-preload.ts");
+	const preloadExists = fileSystem.existsSync(preloadPath);
+	const sourceExists = fileSystem.existsSync(sourcePath);
+
+	let stale = false;
+	if (preloadExists && sourceExists) {
+		stale =
+			fileSystem.statSync(preloadPath).mtimeMs <
+			fileSystem.statSync(sourcePath).mtimeMs;
+	}
+
+	return {
+		preloadPath,
+		sourcePath,
+		preloadExists,
+		sourceExists,
+		stale,
+	};
+}
+
+export function readBuiltPreloadScript(
+	baseDir: string,
+	fileSystem: FsLike = fs,
+): string {
+	const status = getElectrobunPreloadStatus(baseDir, fileSystem);
+
+	if (!status.preloadExists) {
+		throw new Error(
+			`[Main] preload.js is missing at ${status.preloadPath}. From the repo root run \`bun run build:preload\` (or \`cd apps/app/electrobun && bun run build:preload\`).`,
+		);
+	}
+
+	if (status.stale) {
+		throw new Error(
+			`[Main] preload.js is stale relative to ${status.sourcePath}. From the repo root run \`bun run build:preload\` (or \`cd apps/app/electrobun && bun run build:preload\`).`,
+		);
+	}
+
+	const preload = fileSystem.readFileSync(status.preloadPath, "utf8");
+	if (!preload.trim()) {
+		throw new Error(
+			`[Main] preload.js is empty at ${status.preloadPath}. From the repo root run \`bun run build:preload\` (or \`cd apps/app/electrobun && bun run build:preload\`).`,
+		);
+	}
+
+	return preload;
+}

package/platforms/electrobun/src/preload.js

@@ -0,0 +1 @@
+(()=>{function T(w,b){let f=w.map((_)=>`"${_}"`).join(", ");return Error(`This RPC instance cannot ${b} because the transport did not provide one or more of these methods: ${f}`)}function y(w={}){let b={},f={},_=void 0;function A(Y){if(f.unregisterHandler)f.unregisterHandler();f=Y,f.registerHandler?.(o)}function G(Y){if(typeof Y==="function"){_=Y;return}_=(S,Z)=>{let J=Y[S];if(J)return J(Z);let V=Y._;if(!V)throw Error(`The requested method has no handler: ${String(S)}`);return V(S,Z)}}let{maxRequestTime:B=1000}=w;if(w.transport)A(w.transport);if(w.requestHandler)G(w.requestHandler);if(w._debugHooks)b=w._debugHooks;let X=0;function W(){if(X<=10000000000)return++X;return X=0}let $=new Map,Q=new Map;function C(Y,...S){let Z=S[0];return new Promise((J,V)=>{if(!f.send)throw T(["send"],"make requests");let z=W(),R={type:"request",id:z,method:Y,params:Z};if($.set(z,{resolve:J,reject:V}),B!==1/0)Q.set(z,setTimeout(()=>{Q.delete(z),$.delete(z),V(Error("RPC request timed out."))},B));b.onSend?.(R),f.send(R)})}let j=new Proxy(C,{get:(Y,S,Z)=>{if(S in Y)return Reflect.get(Y,S,Z);return(J)=>C(S,J)}}),M=j;function D(Y,...S){let Z=S[0];if(!f.send)throw T(["send"],"send messages");let J={type:"message",id:Y,payload:Z};b.onSend?.(J),f.send(J)}let H=new Proxy(D,{get:(Y,S,Z)=>{if(S in Y)return Reflect.get(Y,S,Z);return(J)=>D(S,J)}}),L=H,I=new Map,x=new Set;function d(Y,S){if(!f.registerHandler)throw T(["registerHandler"],"register message listeners");if(Y==="*"){x.add(S);return}if(!I.has(Y))I.set(Y,new Set);I.get(Y).add(S)}function l(Y,S){if(Y==="*"){x.delete(S);return}if(I.get(Y)?.delete(S),I.get(Y)?.size===0)I.delete(Y)}async function o(Y){if(b.onReceive?.(Y),!("type"in Y))throw Error("Message does not contain a type.");if(Y.type==="request"){if(!f.send||!_)throw T(["send","requestHandler"],"handle requests");let{id:S,method:Z,params:J}=Y,V;try{V={type:"response",id:S,success:!0,payload:await _(Z,J)}}catch(z){if(!(z instanceof Error))throw z;V={type:"response",id:S,success:!1,error:z.message}}b.onSend?.(V),f.send(V);return}if(Y.type==="response"){let S=Q.get(Y.id);if(S!=null)clearTimeout(S);Q.delete(Y.id);let{resolve:Z,reject:J}=$.get(Y.id)??{};if($.delete(Y.id),!Y.success)J?.(Error(Y.error));else Z?.(Y.payload);return}if(Y.type==="message"){for(let Z of x)Z(Y.id,Y.payload);let S=I.get(Y.id);if(!S)return;for(let Z of S)Z(Y.payload);return}throw Error(`Unexpected RPC message type: ${Y.type}`)}return{setTransport:A,setRequestHandler:G,request:j,requestProxy:M,send:H,sendProxy:L,addMessageListener:d,removeMessageListener:l,proxy:{send:L,request:M}}}function O(w,b){let f={maxRequestTime:b.maxRequestTime,requestHandler:{...b.handlers.requests,...b.extraRequestHandlers},transport:{registerHandler:()=>{}}},_=y(f),A=b.handlers.messages;if(A)_.addMessageListener("*",(G,B)=>{let X=A["*"];if(X)X(G,B);let W=A[G];if(W)W(B)});return _}var{__electrobunWebviewId:h,__electrobunRpcSocketPort:N}=window;class F{bunSocket;rpc;rpcHandler;constructor(w){this.rpc=w.rpc,this.init()}init(){if(this.initSocketToBun(),window.__electrobun.receiveMessageFromBun=this.receiveMessageFromBun.bind(this),this.rpc)this.rpc.setTransport(this.createTransport())}initSocketToBun(){if(!N||!h)return;let w=new WebSocket(`ws://localhost:${N}/socket?webviewId=${h}`);this.bunSocket=w,w.addEventListener("open",()=>{}),w.addEventListener("message",async(b)=>{let f=b.data;if(typeof f==="string")try{let _=JSON.parse(f),A=await window.__electrobun_decrypt(_.encryptedData,_.iv,_.tag);this.rpcHandler?.(JSON.parse(A))}catch(_){console.error("Error parsing bun message:",_)}else if(f instanceof Blob);else console.error("UNKNOWN DATA TYPE RECEIVED:",b.data)}),w.addEventListener("error",(b)=>{console.error("Socket error:",b)}),w.addEventListener("close",(b)=>{})}createTransport(){let w=this;return{send(b){try{let f=JSON.stringify(b);w.bunBridge(f)}catch(f){console.error("bun: failed to serialize message to webview",f)}},registerHandler(b){w.rpcHandler=b}}}async bunBridge(w){if(this.bunSocket?.readyState===WebSocket.OPEN)try{let{encryptedData:b,iv:f,tag:_}=await window.__electrobun_encrypt(w),G=JSON.stringify({encryptedData:b,iv:f,tag:_});this.bunSocket.send(G);return}catch(b){console.error("Error sending message to bun via socket:",b)}window.__electrobunBunBridge?.postMessage(w)}receiveMessageFromBun(w){if(this.rpcHandler)this.rpcHandler(w)}static defineRPC(w){return O("webview",{...w,extraRequestHandlers:{evaluateJavascriptWithResponse:({script:b})=>{return new Promise((f)=>{try{let A=Function(b)();if(A instanceof Promise)A.then((G)=>{f(G)}).catch((G)=>{console.error("bun: async script execution failed",G),f(String(G))});else f(A)}catch(_){console.error("bun: failed to eval script",_),f(String(_))}})}}})}}var q={evaluate:async(w)=>({ok:!1,error:`BrowserWorkspaceView is not mounted — cannot evaluate tab ${w}`}),getTabRect:async()=>null};function E(){if(typeof window>"u")return q;return window.__ELIZA_BROWSER_TABS_REGISTRY__??q}function c(){if(typeof window.__electrobun>"u")window.__electrobun={receiveMessageFromBun:(w)=>{},receiveInternalMessageFromBun:(w)=>{}}}var K={},n=Symbol.for("elizaos.app.boot-config"),u="__ELIZA_APP_BOOT_CONFIG__",v="__ELIZA_ELECTROBUN_LOG_MIRROR__";function i(w){if(!w||typeof w!=="object")throw Error("Electrobun RPC params must be an object");return w}function P(w,b){let f=w[b];if(typeof f!=="string")throw Error(`Electrobun RPC param "${b}" must be a string`);return f}function p(w,b){let f=w[b];if(typeof f!=="number"||!Number.isFinite(f))throw Error(`Electrobun RPC param "${b}" must be a finite number`);return f}c();function m(w){let b=window,_={...b[u]??b[n]?.current??{},...w};b[u]=_,b[n]={current:_}}function g(w,b){if(w==="apiBaseUpdate"){let _=b;if(window.__ELIZA_API_BASE__=_.base,_.token)Object.defineProperty(window,"__ELIZA_API_TOKEN__",{value:_.token,configurable:!0,writable:!0,enumerable:!1});m({apiBase:_.base,..._.token?{apiToken:_.token}:{}})}let f=K[w];if(!f)return;for(let _ of Array.from(f))try{_(b)}catch(A){console.error(`[ElectrobunBridge] Listener error for ${w}:`,A)}}function t(w,b){if(typeof w==="string")g(w,b)}var U=F.defineRPC({maxRequestTime:600000,handlers:{requests:{browserWorkspaceRendererEvaluate:async(w)=>{let b=i(w),f=P(b,"id"),_=P(b,"script"),A=p(b,"timeoutMs");E().evaluate(f,_,A)},browserWorkspaceRendererGetTabRect:async(w)=>{let b=i(w);return E().getTabRect(P(b,"id"))}},messages:{"*":t}}});new F({rpc:U});function k(w){if(w instanceof Error)return{name:w.name,message:w.message,stack:w.stack};return w}var r=new Proxy(U.request,{get(w,b,f){let _=Reflect.get(w,b,f);if(typeof _!=="function")return _;return async(A)=>{try{return await _.call(w,A)}catch(G){throw U.request.rendererReportDiagnostic({level:"error",source:"rpc",message:`Electrobun RPC request failed: ${String(b)}`,details:k(G)}).catch(()=>{}),G}}}}),a={request:r,onMessage:(w,b)=>{if(!K[w])K[w]=new Set;K[w].add(b)},offMessage:(w,b)=>{if(K[w]?.delete(b),K[w]?.size===0)delete K[w]}};window.__ELIZA_ELECTROBUN_RPC__=a;function s(){let w=window;if(w[v])return;w[v]=!0;let b=(_,A,G,B)=>{U.request.rendererReportDiagnostic({level:_,source:A,message:G,details:B}).catch(()=>{})},f=["log","info","warn","error"];for(let _ of f){let A=console[_].bind(console);console[_]=(...G)=>{A(...G),b(_,"console",G.map((B)=>{if(typeof B==="string")return B;try{return JSON.stringify(B)}catch{return String(B)}}).join(" "))}}if(window.addEventListener("error",(_)=>{let A=_.target;if(A&&(A.src||A.href)){b("error","resource","Failed to load resource",{tagName:A.tagName,src:A.src,href:A.href});return}b("error","window.onerror",_.message||"Unhandled window error",{filename:_.filename,lineno:_.lineno,colno:_.colno})},!0),window.addEventListener("unhandledrejection",(_)=>{b("error","unhandledrejection","Unhandled promise rejection",k(_.reason))}),typeof window.fetch==="function"){let _=window.fetch.bind(window);window.fetch=async(...A)=>{let G=Date.now(),B=A[0],X=A[1],W=typeof B==="string"?B:B instanceof Request?B.url:String(B),$=X?.method??(B instanceof Request?B.method:void 0)??"GET";try{let Q=await _(...A);if(!Q.ok)b(Q.status>=500?"error":"warn","fetch",`HTTP ${Q.status} ${Q.statusText}`,{url:W,method:$,durationMs:Date.now()-G});return Q}catch(Q){throw b("error","fetch","Fetch failed",{url:W,method:$,durationMs:Date.now()-G,error:k(Q)}),Q}}}if(typeof XMLHttpRequest<"u"){let _=XMLHttpRequest.prototype.open,A=XMLHttpRequest.prototype.send;XMLHttpRequest.prototype.open=function(G,B,...X){return this.__elizaDiag={method:G,url:String(B),startedAt:Date.now()},_.call(this,G,B,...X)},XMLHttpRequest.prototype.send=function(...G){let B=this,X=()=>{let $=B.__elizaDiag;if(!$)return;if(B.status>=400)b(B.status>=500?"error":"warn","xhr",`HTTP ${B.status}`,{url:$.url,method:$.method,durationMs:Date.now()-$.startedAt})},W=()=>{let $=B.__elizaDiag;b("error","xhr","XMLHttpRequest failed",{url:$?.url,method:$?.method,durationMs:$?Date.now()-$.startedAt:void 0})};return B.addEventListener("loadend",X,{once:!0}),B.addEventListener("error",W,{once:!0}),A.call(this,...G)}}}s();})();

package/platforms/electrobun/src/print-electrobun-dev-settings-banner.ts

@@ -0,0 +1,140 @@
+import {
+	colorizeDevSettingsStartupBanner,
+	type DevSettingsRow,
+	firstWinningEnvString,
+	formatDevSettingsTable,
+	prependDevSubsystemFigletHeading,
+	resolveDesktopApiPortPreference,
+} from "@elizaos/shared";
+import { resolveDesktopRuntimeMode } from "./api-base";
+import { resolveMainWindowPartition } from "./main-window-session";
+
+function shouldPrintElectrobunDevSettingsBanner(): boolean {
+	if (process.env.NODE_ENV === "test") return false;
+	if (process.env.ELECTROBUN_DEV) return true;
+	if (process.env.NODE_ENV === "production") return false;
+	const dir = import.meta.dir.replace(/\\/g, "/");
+	return dir.includes("/electrobun/src/");
+}
+
+/**
+ * Electrobun main process — env reads for desktop dev (printed once at startup).
+ */
+export function printElectrobunDevSettingsBanner(
+	env: Record<string, string | undefined>,
+): void {
+	if (!shouldPrintElectrobunDevSettingsBanner()) return;
+
+	const runtime = resolveDesktopRuntimeMode(env);
+	const apiPref = resolveDesktopApiPortPreference(env);
+	const partition = resolveMainWindowPartition(env);
+
+	const rendererWin = firstWinningEnvString(env, [
+		"ELIZA_RENDERER_URL",
+		"VITE_DEV_SERVER_URL",
+	]);
+
+	const browserPort = env.ELIZA_BROWSER_WORKSPACE_PORT?.trim();
+	const browserTok = env.ELIZA_BROWSER_WORKSPACE_TOKEN?.trim();
+
+	const shotOpt = env.ELIZA_DESKTOP_SCREENSHOT_SERVER?.trim().toLowerCase();
+	const screenshotOff =
+		shotOpt === "0" ||
+		shotOpt === "false" ||
+		shotOpt === "no" ||
+		shotOpt === "off";
+
+	const rows: DevSettingsRow[] = [
+		{
+			setting: "desktopRuntimeMode",
+			effective: runtime.mode,
+			source:
+				runtime.mode === "external" && runtime.externalApi.source
+					? `env set — ${runtime.externalApi.source}`
+					: runtime.mode === "disabled"
+						? "env set — ELIZA_DESKTOP_SKIP_EMBEDDED_AGENT"
+						: "default (local embedded agent)",
+			change:
+				"set ELIZA_DESKTOP_TEST_API_BASE / ELIZA_DESKTOP_API_BASE / ELIZA_API_BASE_URL / ELIZA_API_BASE for external; ELIZA_DESKTOP_SKIP_EMBEDDED_AGENT=1 for disabled",
+		},
+		{
+			setting: "ELIZA_RENDERER_URL / VITE_DEV_SERVER_URL",
+			effective: rendererWin?.value ?? "—",
+			source: rendererWin
+				? `env set — ${rendererWin.key}`
+				: "default (unset — static dist)",
+			change:
+				"export ELIZA_RENDERER_URL=http://127.0.0.1:<vite>/ (or VITE_DEV_SERVER_URL)",
+		},
+		{
+			setting: "API port (preference)",
+			effective: String(apiPref.port),
+			source: apiPref.sourceLabel,
+			change: apiPref.changeLabel,
+		},
+		{
+			setting: "ELIZA_DESKTOP_TEST_PARTITION",
+			effective: env.ELIZA_DESKTOP_TEST_PARTITION?.trim() || "—",
+			source: env.ELIZA_DESKTOP_TEST_PARTITION?.trim()
+				? "env set — ELIZA_DESKTOP_TEST_PARTITION"
+				: "default (unset)",
+			change: "export ELIZA_DESKTOP_TEST_PARTITION=<id> for test profile",
+		},
+		{
+			setting: "ELIZA_DESKTOP_TEST_API_BASE",
+			effective: env.ELIZA_DESKTOP_TEST_API_BASE?.trim() || "—",
+			source: env.ELIZA_DESKTOP_TEST_API_BASE?.trim()
+				? "env set — ELIZA_DESKTOP_TEST_API_BASE"
+				: "default (unset)",
+			change:
+				"export ELIZA_DESKTOP_TEST_API_BASE=https://… for partition tests",
+		},
+		{
+			setting: "resolveMainWindowPartition",
+			effective: partition ?? "—",
+			source: "derived — main-window-session.ts",
+			change:
+				"export ELIZA_DESKTOP_TEST_PARTITION or ELIZA_DESKTOP_TEST_API_BASE (see source)",
+		},
+		{
+			setting: "ELIZA_BROWSER_WORKSPACE_PORT",
+			effective: browserPort || "—",
+			source: browserPort
+				? "env set — ELIZA_BROWSER_WORKSPACE_PORT"
+				: "default (unset)",
+			change: "export ELIZA_BROWSER_WORKSPACE_PORT=<port>",
+		},
+		{
+			setting: "ELIZA_BROWSER_WORKSPACE_TOKEN",
+			effective: browserTok ? "set (redacted)" : "—",
+			source: browserTok
+				? "env set — ELIZA_BROWSER_WORKSPACE_TOKEN"
+				: "default (unset)",
+			change: "export ELIZA_BROWSER_WORKSPACE_TOKEN=<secret> or unset",
+		},
+		{
+			setting: "ELIZA_DESKTOP_SCREENSHOT_SERVER",
+			effective: screenshotOff ? "off" : "on",
+			source: screenshotOff
+				? "env set — opt-out (0/false/no/off)"
+				: "default (on)",
+			change:
+				"export ELIZA_DESKTOP_SCREENSHOT_SERVER=0 to disable; ELIZA_SCREENSHOT_SERVER_PORT for port",
+		},
+		{
+			setting: "NODE_ENV",
+			effective: env.NODE_ENV ?? "—",
+			source: env.NODE_ENV ? "env set — NODE_ENV" : "default (unset)",
+			change: "export NODE_ENV=development|production",
+		},
+	];
+
+	console.log(
+		colorizeDevSettingsStartupBanner(
+			prependDevSubsystemFigletHeading(
+				"electrobun",
+				formatDevSettingsTable("Electrobun shell — effective settings", rows),
+			),
+		),
+	);
+}

package/platforms/electrobun/src/renderer-static.ts

@@ -0,0 +1,77 @@
+import path from "node:path";
+
+type ExistsSyncLike = (filePath: string) => boolean;
+type StatSyncLike = (filePath: string) => { isDirectory(): boolean };
+
+export type ResolvedRendererAsset = {
+	filePath: string;
+	isGzipped: boolean;
+	mimeExt: string;
+};
+
+type ResolveRendererAssetOptions = {
+	rendererDir: string;
+	urlPath: string;
+	existsSync: ExistsSyncLike;
+	statSync: StatSyncLike;
+};
+
+function stripGzipSuffix(filePath: string): string {
+	return filePath.toLowerCase().endsWith(".gz")
+		? filePath.slice(0, -3)
+		: filePath;
+}
+
+function resolveMimeExtension(filePath: string): string {
+	const uncompressedPath = stripGzipSuffix(filePath);
+	return (
+		path.extname(uncompressedPath).toLowerCase() ||
+		path.extname(filePath).toLowerCase()
+	);
+}
+
+export function resolveRendererAsset({
+	rendererDir,
+	urlPath,
+	existsSync,
+	statSync,
+}: ResolveRendererAssetOptions): ResolvedRendererAsset {
+	const relativePath = urlPath.replace(/^\/+/, "") || "index.html";
+	let filePath = path.join(rendererDir, relativePath);
+	const bundledIndexPath = path.join(rendererDir, "index.html");
+
+	if (
+		!filePath.startsWith(rendererDir + path.sep) &&
+		filePath !== rendererDir
+	) {
+		filePath = bundledIndexPath;
+	}
+
+	let isGzipped = false;
+
+	if (!existsSync(filePath) && filePath.toLowerCase().endsWith(".gz")) {
+		const plainPath = filePath.slice(0, -3);
+		if (existsSync(plainPath)) {
+			filePath = plainPath;
+		}
+	}
+
+	if (!existsSync(filePath) && existsSync(`${filePath}.gz`)) {
+		filePath = `${filePath}.gz`;
+		isGzipped = true;
+	}
+
+	if (!existsSync(filePath) || statSync(filePath).isDirectory()) {
+		return {
+			filePath: bundledIndexPath,
+			isGzipped: false,
+			mimeExt: ".html",
+		};
+	}
+
+	return {
+		filePath,
+		isGzipped,
+		mimeExt: resolveMimeExtension(filePath),
+	};
+}