sparkbun 0.1.0

package/dist-macos-arm64/preload-sandboxed.js

@@ -0,0 +1,111 @@
+(function(){// src/bun/preload/events.ts
+function emitWebviewEvent(eventName, detail) {
+  setTimeout(() => {
+    const bridge = window.__electrobunEventBridge || window.__electrobunInternalBridge;
+    bridge?.postMessage(JSON.stringify({
+      id: "webviewEvent",
+      type: "message",
+      payload: {
+        id: window.__electrobunWebviewId,
+        eventName,
+        detail
+      }
+    }));
+  });
+}
+function initLifecycleEvents() {
+  window.addEventListener("load", () => {
+    if (window === window.top) {
+      emitWebviewEvent("dom-ready", document.location.href);
+    }
+  });
+  window.addEventListener("popstate", () => {
+    emitWebviewEvent("did-navigate-in-page", window.location.href);
+  });
+  window.addEventListener("hashchange", () => {
+    emitWebviewEvent("did-navigate-in-page", window.location.href);
+  });
+}
+var cmdKeyHeld = false;
+var cmdKeyTimestamp = 0;
+var CMD_KEY_THRESHOLD_MS = 500;
+function isCmdHeld() {
+  if (cmdKeyHeld)
+    return true;
+  return Date.now() - cmdKeyTimestamp < CMD_KEY_THRESHOLD_MS && cmdKeyTimestamp > 0;
+}
+function initCmdClickHandling() {
+  window.addEventListener("keydown", (event) => {
+    if (event.key === "Meta" || event.metaKey) {
+      cmdKeyHeld = true;
+      cmdKeyTimestamp = Date.now();
+    }
+  }, true);
+  window.addEventListener("keyup", (event) => {
+    if (event.key === "Meta") {
+      cmdKeyHeld = false;
+      cmdKeyTimestamp = Date.now();
+    }
+  }, true);
+  window.addEventListener("blur", () => {
+    cmdKeyHeld = false;
+  });
+  window.addEventListener("click", (event) => {
+    if (event.metaKey || event.ctrlKey) {
+      const anchor = event.target?.closest?.("a");
+      if (anchor && anchor.href) {
+        event.preventDefault();
+        event.stopPropagation();
+        event.stopImmediatePropagation();
+        emitWebviewEvent("new-window-open", JSON.stringify({
+          url: anchor.href,
+          isCmdClick: true,
+          isSPANavigation: false
+        }));
+      }
+    }
+  }, true);
+}
+function initSPANavigationInterception() {
+  const originalPushState = history.pushState;
+  const originalReplaceState = history.replaceState;
+  history.pushState = function(state, title, url) {
+    if (isCmdHeld() && url) {
+      const resolvedUrl = new URL(String(url), window.location.href).href;
+      emitWebviewEvent("new-window-open", JSON.stringify({
+        url: resolvedUrl,
+        isCmdClick: true,
+        isSPANavigation: true
+      }));
+      return;
+    }
+    return originalPushState.apply(this, [state, title, url]);
+  };
+  history.replaceState = function(state, title, url) {
+    if (isCmdHeld() && url) {
+      const resolvedUrl = new URL(String(url), window.location.href).href;
+      emitWebviewEvent("new-window-open", JSON.stringify({
+        url: resolvedUrl,
+        isCmdClick: true,
+        isSPANavigation: true
+      }));
+      return;
+    }
+    return originalReplaceState.apply(this, [state, title, url]);
+  };
+}
+function initOverscrollPrevention() {
+  document.addEventListener("DOMContentLoaded", () => {
+    const style = document.createElement("style");
+    style.type = "text/css";
+    style.appendChild(document.createTextNode("html, body { overscroll-behavior: none; }"));
+    document.head.appendChild(style);
+  });
+}
+
+// src/bun/preload/index-sandboxed.ts
+initLifecycleEvents();
+initCmdClickHandling();
+initSPANavigationInterception();
+initOverscrollPrevention();
+})();

package/package.json

@@ -0,0 +1,47 @@
+{
+	"name": "sparkbun",
+	"version": "0.1.0",
+	"description": "Build fast, lightweight, cross-platform desktop apps with TypeScript and Bun.",
+	"license": "MIT",
+	"author": "SparkBun Contributors",
+	"keywords": [
+		"bun",
+		"desktop",
+		"app",
+		"cross-platform",
+		"typescript",
+		"electron-alternative",
+		"webview"
+	],
+	"exports": {
+		".": "./src/bun/index.ts",
+		"./bun": "./src/bun/index.ts",
+		"./view": "./src/browser/index.ts"
+	},
+	"type": "module",
+	"bin": {
+		"sparkbun": "./bin/sparkbun.cjs"
+	},
+	"homepage": "https://github.com/gruntlord5/SparkBun",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gruntlord5/SparkBun.git"
+	},
+	"scripts": {
+		"start": "bun src/bun/index.ts",
+		"build:dev": "bun build.ts",
+		"build:release": "bun build.ts --release",
+		"dev": "bun install && bun build:dev && cd ../kitchen && bun install && bun dev",
+		"dev:clean": "cd ../kitchen && rm -rf node_modules && rm -rf vendors/cef && cd ../package && bun dev",
+		"typecheck": "bunx tsc --noEmit && cd ../kitchen && bunx tsc --noEmit",
+		"test:unit": "bun test src/shared src/bun",
+		"bump-cef": "bun scripts/update-cef-version.ts"
+	},
+	"devDependencies": {
+		"typescript": "^5.9.3"
+	},
+	"dependencies": {
+		"@types/bun": "^1.3.8",
+		"png-to-ico": "^2.1.8"
+	}
+}

package/scripts/build-and-upload-artifacts.js

@@ -0,0 +1,207 @@
+#!/usr/bin/env bun
+
+import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Check if gh CLI is installed
+function checkGhInstalled() {
+	try {
+		execSync("gh --version", { stdio: "pipe" });
+		return true;
+	} catch (error) {
+		return false;
+	}
+}
+
+// Install gh CLI if needed
+function installGhCli() {
+	console.log("\n⚠️  GitHub CLI (gh) is not installed.");
+	console.log("Please install it using one of these methods:\n");
+
+	const platform = process.platform;
+
+	if (platform === "darwin") {
+		console.log("macOS:");
+		console.log("  brew install gh");
+	} else if (platform === "linux") {
+		console.log("Ubuntu/Debian:");
+		console.log(
+			"  curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | sudo dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg",
+		);
+		console.log(
+			'  echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null',
+		);
+		console.log("  sudo apt update && sudo apt install gh\n");
+
+		console.log("Fedora/CentOS/RHEL:");
+		console.log("  sudo dnf install gh\n");
+
+		console.log("Arch Linux:");
+		console.log("  sudo pacman -S github-cli");
+	} else if (platform === "win32") {
+		console.log("Windows:");
+		console.log("  winget install --id GitHub.cli");
+		console.log("  # or");
+		console.log("  choco install gh");
+	}
+
+	console.log("\nAfter installation, authenticate with:");
+	console.log("  gh auth login\n");
+
+	console.log("Or set GITHUB_TOKEN environment variable:");
+	console.log('  export GITHUB_TOKEN="your-personal-access-token"\n');
+
+	process.exit(1);
+}
+
+// Check for gh CLI
+if (!checkGhInstalled()) {
+	installGhCli();
+}
+
+// Read package.json to get the version
+const packageJsonPath = path.join(__dirname, "..", "package.json");
+const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+const version = packageJson.version;
+const tagName = `v${version}`;
+
+console.log(
+	`Building and uploading artifacts for version ${version} (tag: ${tagName})`,
+);
+
+// Get platform and architecture info
+const platform = process.platform;
+const arch = process.arch;
+
+// Map Node.js platform/arch to our naming
+const platformMap = {
+	darwin: "darwin",
+	linux: "linux",
+	win32: "win",
+};
+
+const archMap = {
+	x64: "x64",
+	arm64: "arm64",
+};
+
+const platformName = platformMap[platform] || platform;
+// Always use x64 for Windows since we only build x64 Windows binaries
+const archName = platform === "win32" ? "x64" : archMap[arch] || arch;
+
+console.log(`Platform: ${platformName}, Architecture: ${archName}`);
+
+// Step 1: Build the release artifacts
+console.log("\n1. Building release artifacts...");
+try {
+	execSync("bun scripts/package-release.js", { stdio: "inherit" });
+} catch (error) {
+	console.error("Build failed:", error.message);
+	process.exit(1);
+}
+
+// Step 2: Check if the artifacts exist
+const artifacts = [
+	`electrobun-cli-${platformName}-${archName}.tar.gz`,
+	`electrobun-core-${platformName}-${archName}.tar.gz`,
+	`electrobun-cef-${platformName}-${archName}.tar.gz`,
+];
+
+const existingArtifacts = artifacts.filter((artifact) =>
+	fs.existsSync(path.join(__dirname, "..", artifact)),
+);
+
+if (existingArtifacts.length === 0) {
+	console.error("No artifacts found to upload");
+	process.exit(1);
+}
+
+console.log("\nFound artifacts:");
+existingArtifacts.forEach((artifact) => console.log(`  - ${artifact}`));
+
+// Step 3: Check if release exists
+console.log(`\n2. Checking if release ${tagName} exists...`);
+try {
+	// First check if we're authenticated
+	execSync("gh auth status", { stdio: "pipe" });
+
+	// Try to view the release with more details for debugging
+	const releaseInfo = execSync(`gh release view ${tagName} --json tagName`, {
+		encoding: "utf8",
+	});
+	console.log(`Release ${tagName} found`);
+} catch (error) {
+	// Try listing releases to see what's available
+	console.log("Failed to find release, listing available releases:");
+	try {
+		const releases = execSync("gh release list --limit 5", {
+			encoding: "utf8",
+		});
+		console.log(releases);
+	} catch (listError) {
+		console.error(
+			"Failed to list releases. Check your gh CLI authentication with: gh auth status",
+		);
+	}
+
+	console.error(
+		`\nRelease ${tagName} not found. Please create the release first with:`,
+	);
+	console.error(`  git tag ${tagName} && git push origin ${tagName}`);
+	console.error(`  gh release create ${tagName}`);
+	console.error("\nOr wait for CI to create it automatically");
+	process.exit(1);
+}
+
+// Step 4: Upload artifacts
+console.log("\n3. Uploading artifacts to release...");
+for (const artifact of existingArtifacts) {
+	const artifactPath = path.join(__dirname, "..", artifact);
+	console.log(`Uploading ${artifact}...`);
+
+	try {
+		// Upload the artifact (--clobber will overwrite if it exists)
+		execSync(`gh release upload ${tagName} "${artifactPath}" --clobber`, {
+			stdio: "inherit",
+		});
+		console.log(`  ✓ Uploaded ${artifact}`);
+	} catch (error) {
+		console.error(`  ✗ Failed to upload ${artifact}:`, error.message);
+		console.error("Command failed:", error.message);
+
+		// Try to get more details about the error
+		try {
+			const releaseDetails = execSync(`gh release view ${tagName}`, {
+				encoding: "utf8",
+			});
+			console.error("\nCurrent release details:");
+			console.error(releaseDetails);
+		} catch (e) {
+			// Ignore
+		}
+
+		process.exit(1);
+	}
+}
+
+// Step 5: Clean up local artifacts
+console.log("\n4. Cleaning up local artifacts...");
+for (const artifact of existingArtifacts) {
+	const artifactPath = path.join(__dirname, "..", artifact);
+	try {
+		fs.unlinkSync(artifactPath);
+		console.log(`  ✓ Removed ${artifact}`);
+	} catch (error) {
+		console.error(`  ✗ Failed to remove ${artifact}:`, error.message);
+	}
+}
+
+console.log("\n✅ Successfully built and uploaded artifacts!");
+console.log(
+	`\nView the release at: https://github.com/blackboardsh/electrobun/releases/tag/${tagName}`,
+);

package/scripts/gen-webgpu-ffi.mjs

@@ -0,0 +1,162 @@
+import { readFileSync, writeFileSync, existsSync, readdirSync } from "fs";
+import { resolve, join, dirname } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const root = resolve(__dirname, "..");
+function resolveHeaderPath() {
+	const base = resolve(root, "vendors", "wgpu");
+	if (!existsSync(base)) return null;
+
+	const entries = readdirSync(base, { withFileTypes: true });
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		const candidate = join(base, entry.name, "include", "dawn", "webgpu.h");
+		if (existsSync(candidate)) return candidate;
+	}
+
+	return null;
+}
+
+const headerPath = resolveHeaderPath();
+if (!headerPath) {
+	throw new Error("Could not find vendors/wgpu/*/include/dawn/webgpu.h");
+}
+
+const header = readFileSync(headerPath, "utf8");
+
+const callbackTypes = new Set();
+const callbackRegex = /typedef\s+[^;]*\(\s*\*\s*(WGPU[A-Za-z0-9_]+)\s*\)\s*\(/g;
+let cbMatch;
+while ((cbMatch = callbackRegex.exec(header))) {
+	callbackTypes.add(cbMatch[1]);
+}
+
+const typedefMap = new Map();
+const scalarTypedefRegex = /typedef\s+(uint32_t|uint64_t|int32_t|int64_t|size_t|intptr_t|uintptr_t|float|double|int|unsigned int)\s+(WGPU[A-Za-z0-9_]+)\s*;/g;
+let tdMatch;
+while ((tdMatch = scalarTypedefRegex.exec(header))) {
+	typedefMap.set(tdMatch[2], tdMatch[1]);
+}
+
+const enumRegex = /typedef\s+enum\s+WGPU[A-Za-z0-9_]+\s*\{[\s\S]*?\}\s*(WGPU[A-Za-z0-9_]+)(?:\s+WGPU_[A-Z_]+)*\s*;/g;
+let enumMatch;
+while ((enumMatch = enumRegex.exec(header))) {
+	if (!typedefMap.has(enumMatch[1])) {
+		typedefMap.set(enumMatch[1], "uint32_t");
+	}
+}
+
+const aliasTypedefRegex = /typedef\s+(WGPU[A-Za-z0-9_]+)\s+(WGPU[A-Za-z0-9_]+)\s*;/g;
+let aliasMatch;
+while ((aliasMatch = aliasTypedefRegex.exec(header))) {
+	const from = aliasMatch[1];
+	const to = aliasMatch[2];
+	if (typedefMap.has(from) && !typedefMap.has(to)) {
+		typedefMap.set(to, typedefMap.get(from));
+	}
+}
+
+const structValueMap = new Map([
+	["WGPUFuture", "uint64_t"],
+	["WGPUStringView", "ptr"],
+]);
+
+const typeToFFI = (type, isReturn = false) => {
+	let t = type
+		.replace(/\bconst\b/g, "")
+		.replace(/\bstruct\b/g, "")
+		.replace(/\bWGPU_NULLABLE\b/g, "")
+		.replace(/\bWGPU_NONNULL\b/g, "")
+		.replace(/\s+/g, " ")
+		.trim();
+
+	if (t === "void") return "FFIType.void";
+
+	const isPtr = t.includes("*");
+	const base = t.replace(/\*/g, "").trim();
+
+	if (callbackTypes.has(base)) {
+		return isReturn ? "FFIType.ptr" : "FFIType.function";
+	}
+
+	if (structValueMap.has(base)) {
+		const mapped = structValueMap.get(base);
+		if (mapped === "ptr") return "FFIType.ptr";
+		if (mapped === "uint64_t") return "FFIType.u64";
+	}
+
+	if (isPtr) {
+		if (base === "char") return "FFIType.cstring";
+		return "FFIType.ptr";
+	}
+
+	const scalar = typedefMap.get(base) || base;
+	switch (scalar) {
+		case "uint32_t":
+			return "FFIType.u32";
+		case "uint64_t":
+			return "FFIType.u64";
+		case "int32_t":
+			return "FFIType.i32";
+		case "int64_t":
+			return "FFIType.i64";
+		case "size_t":
+		case "uintptr_t":
+		case "intptr_t":
+			return "FFIType.u64";
+		case "float":
+			return "FFIType.f32";
+		case "double":
+			return "FFIType.f64";
+		case "int":
+			return "FFIType.i32";
+		case "unsigned int":
+			return "FFIType.u32";
+		default:
+			if (base.startsWith("WGPU")) return "FFIType.ptr";
+			if (base === "char") return "FFIType.u8";
+			return "FFIType.ptr";
+	}
+};
+
+const funcRegex = /WGPU_EXPORT\s+([\s\S]*?)\s*\(([^;]*?)\)\s*(?:WGPU_FUNCTION_ATTRIBUTE\s*)?;/g;
+const symbols = [];
+let funcMatch;
+while ((funcMatch = funcRegex.exec(header))) {
+	const beforeParen = funcMatch[1].trim().replace(/\s+/g, " ");
+	const argsRaw = funcMatch[2].trim();
+
+	const nameMatch = beforeParen.match(/^(.*)\s+([A-Za-z_][A-Za-z0-9_]*)$/);
+	if (!nameMatch) continue;
+
+	const returnType = nameMatch[1].trim();
+	const funcName = nameMatch[2].trim();
+
+	if (!funcName.startsWith("wgpu")) {
+		continue;
+	}
+
+	const args = [];
+	if (argsRaw && argsRaw !== "void") {
+		const parts = argsRaw.split(",");
+		for (const partRaw of parts) {
+			const part = partRaw.trim();
+			if (!part) continue;
+			const paramMatch = part.match(/^(.*?)([A-Za-z_][A-Za-z0-9_]*)$/);
+			const typePart = paramMatch ? paramMatch[1].trim() : part;
+			args.push(typeToFFI(typePart, false));
+		}
+	}
+
+	const returns = typeToFFI(returnType, true);
+	const argsList = args.length ? args.join(", ") : "";
+	symbols.push(`\t${funcName}: { args: [${argsList}], returns: ${returns} },`);
+}
+
+const output = `import { existsSync } from "fs";\nimport { join } from "path";\nimport { dlopen, suffix, FFIType } from "bun:ffi";\n\n// NOTE: WGPUStringView is passed by value in the C API. Bun FFI does not support\n// by-value structs, so WGPUStringView parameters are exposed as pointers for now.\n// If you need these calls, add a small C shim that accepts a pointer and\n// forwards by value. WGPUFuture is a single u64 and is mapped to FFIType.u64.\nconst WGPU_SYMBOLS = {\n${symbols.join("\n")}\n} as const;\n\nconst WGPU_LIB_NAMES: Record<string, string[]> = {\n\tdarwin: ["libwebgpu_dawn.dylib"],\n\twin32: ["webgpu_dawn.dll", "libwebgpu_dawn.dll"],\n\tlinux: ["libwebgpu_dawn.so"],\n};\n\nfunction findWgpuLibraryPath(): string | null {\n\tconst envPath = process.env.ELECTROBUN_WGPU_PATH;\n\tif (envPath && existsSync(envPath)) return envPath;\n\n\tconst names = WGPU_LIB_NAMES[process.platform] ?? ["libwebgpu_dawn." + suffix];\n\tfor (const name of names) {\n\t\tconst cwdCandidate = join(process.cwd(), name);\n\t\tif (existsSync(cwdCandidate)) return cwdCandidate;\n\t\tconst execDir = dirname(process.execPath);\n\t\tconst macCandidate = join(execDir, "..", "MacOS", name);\n\t\tif (existsSync(macCandidate)) return macCandidate;\n\t\tconst resCandidate = join(execDir, "..", "Resources", name);\n\t\tif (existsSync(resCandidate)) return resCandidate;\n\t\tconst execCandidate = join(execDir, name);\n\t\tif (existsSync(execCandidate)) return execCandidate;\n\t}\n\n\treturn null;\n}\n\nexport const native = (() => {\n\tconst libPath = findWgpuLibraryPath();\n\tif (!libPath) {\n\t\treturn {\n\t\t\tavailable: false,\n\t\t\tpath: null as string | null,\n\t\t\tsymbols: {} as Record<string, never>,\n\t\t\tclose: () => {},\n\t\t};\n\t}\n\n\ttry {\n\t\tconst lib = dlopen(libPath, WGPU_SYMBOLS);\n\t\treturn {\n\t\t\tavailable: true,\n\t\t\tpath: libPath,\n\t\t\tsymbols: lib.symbols,\n\t\t\tclose: lib.close,\n\t\t};\n\t} catch {\n\t\treturn {\n\t\t\tavailable: false,\n\t\t\tpath: libPath,\n\t\t\tsymbols: {} as Record<string, never>,\n\t\t\tclose: () => {},\n\t\t};\n\t}\n})();\n\nconst WGPU = {\n\tnative,\n};\n\nexport default WGPU;\n`;
+
+const outPath = resolve(root, "src/bun/webGPU.ts");
+writeFileSync(outPath, output, "utf8");
+
+console.log(`Generated ${outPath}`);

package/scripts/install-windows-deps.ps1

@@ -0,0 +1,80 @@
+Param(
+    [switch]$Quiet
+)
+
+function Ensure-RunningAsAdmin {
+    $current = [Security.Principal.WindowsIdentity]::GetCurrent()
+    $principal = New-Object Security.Principal.WindowsPrincipal($current)
+    if (-not $principal.IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)) {
+        Write-Host "Requesting elevation..."
+        $psi = New-Object System.Diagnostics.ProcessStartInfo
+        $psi.FileName = 'powershell'
+        $args = @('-ExecutionPolicy','Bypass','-NoProfile','-File', $MyInvocation.MyCommand.Path)
+        if ($Quiet) { $args += '-Quiet' }
+        $psi.Arguments = $args -join ' '
+        $psi.Verb = 'runas'
+        try {
+            [System.Diagnostics.Process]::Start($psi) | Out-Null
+            exit
+        } catch {
+            Write-Error "Elevation requested but was cancelled. Please run this script as Administrator."
+            exit 1
+        }
+    }
+}
+
+function Download-File($url, $outPath) {
+    Write-Host "Downloading $url to $outPath"
+    try {
+        Invoke-WebRequest -Uri $url -OutFile $outPath -UseBasicParsing -ErrorAction Stop
+        return $true
+    } catch {
+        Write-Error "Download failed: $_"
+        return $false
+    }
+}
+
+Ensure-RunningAsAdmin
+
+$temp = [IO.Path]::GetTempPath()
+$vsInstaller = Join-Path $temp 'vs_BuildTools.exe'
+$vsUrl = 'https://aka.ms/vs/17/release/vs_BuildTools.exe'
+
+if (-not (Test-Path $vsInstaller)) {
+    if (-not (Download-File $vsUrl $vsInstaller)) {
+        Write-Error "Failed to download Visual Studio Build Tools. Please download manually from https://visualstudio.microsoft.com/downloads/"
+        exit 1
+    }
+}
+
+if ($Quiet) {
+    Write-Host "Installing Visual Studio Build Tools (quiet). This may take some time..."
+    $args = @(
+        '--add', 'Microsoft.VisualStudio.Workload.VCTools',
+        '--add', 'Microsoft.VisualStudio.Component.VC.Tools.x86.x64',
+        '--add', 'Microsoft.VisualStudio.Component.Windows10SDK.19041',
+        '--includeRecommended',
+        '--quiet',
+        '--wait',
+        '--norestart'
+    )
+    & $vsInstaller $args
+} else {
+    Write-Host "Launching Visual Studio Build Tools installer GUI. Please select 'Desktop development with C++' and install."
+    Start-Process -FilePath $vsInstaller -Wait
+}
+
+# Install CMake via winget if available
+if (Get-Command winget -ErrorAction SilentlyContinue) {
+    Write-Host "Installing CMake via winget..."
+    try {
+        winget install --id Kitware.CMake -e --accept-package-agreements --accept-source-agreements
+    } catch {
+        Write-Warning "winget install failed or was interrupted. Please install CMake from https://cmake.org/download/"
+    }
+} else {
+    Write-Host "winget not found. Please install CMake manually from https://cmake.org/download/ or install winget and re-run this script."
+}
+
+Write-Host "Installation steps finished. Please restart your shell (or log out/in) and re-run the build script if necessary."
+Exit 0