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

package/platforms/electrobun/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@elizaos/electrobun",
+  "version": "2.0.0-beta.1",
+  "type": "module",
+  "files": [
+    "assets",
+    "entitlements",
+    "scripts",
+    "src",
+    "electrobun.config.ts",
+    "README.md",
+    "tsconfig.json"
+  ],
+  "scripts": {
+    "dev": "bun run build:preload && PATH=\"$PWD/scripts/bin:$PATH\" bunx electrobun dev",
+    "build": "bun run build:preload && ELECTROBUN_SKIP_CODESIGN=1 PATH=\"$PWD/scripts/bin:$PATH\" bunx electrobun build",
+    "typecheck": "tsc --noEmit",
+    "test": "bunx vitest run --config vitest.electrobun.config.ts --passWithNoTests",
+    "lint": "bunx @biomejs/biome check src",
+    "build:preload": "node ../../scripts/build-electrobun-preload.mjs",
+    "build:whisper": "bash scripts/build-whisper.sh",
+    "build:whisper:universal": "bash scripts/build-whisper-universal.sh",
+    "build:native-effects": "bash scripts/build-macos-effects.sh"
+  },
+  "dependencies": {
+    "@elizaos/app-core": "2.0.0-beta.1",
+    "@elizaos/plugin-browser": "2.0.0-beta.1",
+    "@elizaos/shared": "2.0.0-beta.1",
+    "bonjour-service": "1.3.0",
+    "electrobun": "^1.16.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.14",
+    "@types/bun": "^1.3.8",
+    "rcedit": "4.0.1",
+    "typescript": "^6.0.3",
+    "vitest": "^4.0.18"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/platforms/electrobun/scripts/bin/zip

@@ -0,0 +1,2 @@
+#!/bin/bash
+/usr/bin/zip -q "$@" > /dev/null

package/platforms/electrobun/scripts/build-macos-effects.sh

@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+SRC_FILE="$ROOT_DIR/native/macos/window-effects.mm"
+OUT_FILE="$ROOT_DIR/src/libMacWindowEffects.dylib"
+
+if [[ "$(uname -s)" != "Darwin" ]]; then
+	mkdir -p "$(dirname "$OUT_FILE")"
+	: >"$OUT_FILE"
+	echo "Created placeholder native macOS effects dylib: $OUT_FILE"
+	exit 0
+fi
+
+if [[ ! -f "$SRC_FILE" ]]; then
+	echo "Missing source file: $SRC_FILE"
+	exit 1
+fi
+
+mkdir -p "$(dirname "$OUT_FILE")"
+xcrun clang++ \
+  -dynamiclib \
+  -std=c++17 \
+  -fobjc-arc \
+  -framework Cocoa \
+  -framework ApplicationServices \
+  -framework AVFoundation \
+  -framework CoreGraphics \
+  "$SRC_FILE" \
+  -o "$OUT_FILE"
+echo "Built native macOS effects: $OUT_FILE"

package/platforms/electrobun/scripts/build-whisper-universal.sh

@@ -0,0 +1,137 @@
+#!/usr/bin/env bash
+#
+# build-whisper-universal.sh
+#
+# Builds whisper.cpp's `main` binary as a macOS universal binary (arm64 + x86_64).
+# This ensures whisper-based features (swabble wake-word, talkmode) work on both
+# Apple Silicon and Intel Macs.
+#
+# Usage: bash apps/app/electrobun/scripts/build-whisper-universal.sh [model]
+#
+# model: tiny.en | base.en (default) | small.en | medium.en | large-v3
+#
+set -euo pipefail
+
+MODEL="${1:-base.en}"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+resolve_whisper_dir() {
+  local candidates=()
+
+  if [ -n "${ELIZA_WHISPER_CPP_DIR:-}" ]; then
+    candidates+=("$ELIZA_WHISPER_CPP_DIR")
+  fi
+
+  candidates+=(
+    "$PWD/node_modules/whisper-node/lib/whisper.cpp"
+    "$(cd "$SCRIPT_DIR/../../../../../.." && pwd)/node_modules/whisper-node/lib/whisper.cpp"
+    "$(cd "$SCRIPT_DIR/../../../../.." && pwd)/node_modules/whisper-node/lib/whisper.cpp"
+    "$(cd "$SCRIPT_DIR/../../../.." && pwd)/node_modules/whisper-node/lib/whisper.cpp"
+  )
+
+  for candidate in "${candidates[@]}"; do
+    if [ -d "$candidate" ]; then
+      printf '%s\n' "$candidate"
+      return 0
+    fi
+  done
+
+  printf '%s\n' "${candidates[0]}"
+  return 1
+}
+
+WHISPER_CPP_DIR="$(resolve_whisper_dir || true)"
+WHISPER_MODEL_DIR="$WHISPER_CPP_DIR/models"
+WHISPER_MODEL_FILENAME="ggml-${MODEL}.bin"
+WHISPER_MODEL_PATH="$WHISPER_MODEL_DIR/$WHISPER_MODEL_FILENAME"
+WHISPER_MODEL_CACHE_DIR="${ELIZA_WHISPER_MODEL_CACHE_DIR:-${XDG_CACHE_HOME:-$HOME/.cache}/eliza/whisper}"
+WHISPER_MODEL_CACHE_PATH="$WHISPER_MODEL_CACHE_DIR/$WHISPER_MODEL_FILENAME"
+
+patch_whisper_makefile() {
+  local makefile_path="$WHISPER_CPP_DIR/Makefile"
+
+  if [ ! -f "$makefile_path" ]; then
+    return
+  fi
+
+  MAKEFILE_PATH="$makefile_path" node <<'NODE'
+const fs = require("node:fs");
+
+const makefilePath = process.env.MAKEFILE_PATH;
+if (!makefilePath) {
+  process.exit(0);
+}
+
+const original = fs.readFileSync(makefilePath, "utf8");
+const patched = original
+  .replace(
+    "SYSCTL_M := $(shell sysctl -n hw.optional.arm64)",
+    "SYSCTL_M := $(shell sysctl -n hw.optional.arm64 2>/dev/null || echo 0)",
+  )
+  .replace(
+    "CFLAGS  += -DGGML_USE_ACCELERATE",
+    "CFLAGS  += -DGGML_USE_ACCELERATE -Wno-deprecated-declarations",
+  );
+
+if (patched !== original) {
+  fs.writeFileSync(makefilePath, patched, "utf8");
+}
+NODE
+}
+
+if [ ! -d "$WHISPER_CPP_DIR" ]; then
+  echo "[whisper-universal] whisper.cpp directory not found at $WHISPER_CPP_DIR"
+  echo "[whisper-universal] Checked \$PWD and the Eliza/eliza workspace node_modules paths."
+  echo "[whisper-universal] Run 'bun install' first."
+  exit 1
+fi
+
+cd "$WHISPER_CPP_DIR"
+NCPU=$(sysctl -n hw.ncpu 2>/dev/null || echo 4)
+patch_whisper_makefile
+
+echo "[whisper-universal] Building whisper.cpp universal binary (arm64 + x86_64)..."
+echo "[whisper-universal] Directory: $WHISPER_CPP_DIR"
+echo ""
+
+# --- arm64 build (native on Apple Silicon, or cross-compile on Intel) ---
+echo "[whisper-universal] === Building arm64 ==="
+make clean 2>/dev/null || true
+make main -j"$NCPU" 2>&1
+cp main main_arm64
+echo "[whisper-universal] arm64 build OK: $(file main_arm64)"
+echo ""
+
+# --- x86_64 build (via Rosetta on Apple Silicon, or native on Intel) ---
+# Disable Metal for x86_64 since older Intel Macs may lack GPU support.
+echo "[whisper-universal] === Building x86_64 ==="
+make clean 2>/dev/null || true
+arch -x86_64 make main -j"$NCPU" WHISPER_NO_METAL=1 2>&1
+cp main main_x86_64
+echo "[whisper-universal] x86_64 build OK: $(file main_x86_64)"
+echo ""
+
+# --- Combine into universal (fat) binary ---
+echo "[whisper-universal] === Creating universal binary with lipo ==="
+lipo -create main_arm64 main_x86_64 -output main
+rm -f main_arm64 main_x86_64
+
+echo "[whisper-universal] Result: $(file main)"
+lipo -detailed_info main
+echo ""
+
+# --- Ensure model is available ---
+bash "$SCRIPT_DIR/ensure-whisper-model.sh" "$MODEL"
+
+# --- Verify both slices execute ---
+echo "[whisper-universal] === Verifying arm64 execution ==="
+./main -h >/dev/null 2>&1 && echo "[whisper-universal] arm64 OK" || echo "[whisper-universal] arm64 FAILED"
+
+echo "[whisper-universal] === Verifying x86_64 execution ==="
+arch -x86_64 ./main -h >/dev/null 2>&1 && echo "[whisper-universal] x86_64 OK" || echo "[whisper-universal] x86_64 FAILED"
+
+echo ""
+echo "[whisper-universal] Done."
+echo "    Binary: $WHISPER_CPP_DIR/main"
+echo "    Model:  $WHISPER_MODEL_PATH"
+echo "    Cache:  $WHISPER_MODEL_CACHE_PATH"

package/platforms/electrobun/scripts/build-whisper.sh

@@ -0,0 +1,95 @@
+#!/usr/bin/env bash
+# Build whisper.cpp binary and download the base.en model.
+# Run once after `bun install`, and again after upgrading whisper-node.
+#
+# Usage:
+#   bash apps/app/electrobun/scripts/build-whisper.sh [model]
+#
+# model: tiny.en | base.en (default) | small.en | medium.en | large-v3
+#
+set -euo pipefail
+
+MODEL="${1:-base.en}"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+resolve_whisper_dir() {
+  local candidates=()
+
+  if [ -n "${ELIZA_WHISPER_CPP_DIR:-}" ]; then
+    candidates+=("$ELIZA_WHISPER_CPP_DIR")
+  fi
+
+  candidates+=(
+    "$PWD/node_modules/whisper-node/lib/whisper.cpp"
+    "$(cd "$SCRIPT_DIR/../../../../../.." && pwd)/node_modules/whisper-node/lib/whisper.cpp"
+    "$(cd "$SCRIPT_DIR/../../../../.." && pwd)/node_modules/whisper-node/lib/whisper.cpp"
+    "$(cd "$SCRIPT_DIR/../../../.." && pwd)/node_modules/whisper-node/lib/whisper.cpp"
+  )
+
+  for candidate in "${candidates[@]}"; do
+    if [ -d "$candidate" ]; then
+      printf '%s\n' "$candidate"
+      return 0
+    fi
+  done
+
+  printf '%s\n' "${candidates[0]}"
+  return 1
+}
+
+WHISPER_DIR="$(resolve_whisper_dir || true)"
+WHISPER_MODEL_DIR="$WHISPER_DIR/models"
+WHISPER_MODEL_FILENAME="ggml-${MODEL}.bin"
+WHISPER_MODEL_PATH="$WHISPER_MODEL_DIR/$WHISPER_MODEL_FILENAME"
+WHISPER_MODEL_CACHE_DIR="${ELIZA_WHISPER_MODEL_CACHE_DIR:-${XDG_CACHE_HOME:-$HOME/.cache}/eliza/whisper}"
+WHISPER_MODEL_CACHE_PATH="$WHISPER_MODEL_CACHE_DIR/$WHISPER_MODEL_FILENAME"
+
+patch_whisper_makefile() {
+  local makefile_path="$WHISPER_DIR/Makefile"
+
+  if [ ! -f "$makefile_path" ]; then
+    return
+  fi
+
+  MAKEFILE_PATH="$makefile_path" node <<'NODE'
+const fs = require("node:fs");
+
+const makefilePath = process.env.MAKEFILE_PATH;
+if (!makefilePath) {
+  process.exit(0);
+}
+
+const original = fs.readFileSync(makefilePath, "utf8");
+const patched = original
+  .replace(
+    "SYSCTL_M := $(shell sysctl -n hw.optional.arm64)",
+    "SYSCTL_M := $(shell sysctl -n hw.optional.arm64 2>/dev/null || echo 0)",
+  )
+  .replace(
+    "CFLAGS  += -DGGML_USE_ACCELERATE",
+    "CFLAGS  += -DGGML_USE_ACCELERATE -Wno-deprecated-declarations",
+  );
+
+if (patched !== original) {
+  fs.writeFileSync(makefilePath, patched, "utf8");
+}
+NODE
+}
+
+if [ ! -d "$WHISPER_DIR" ]; then
+  echo "Error: whisper.cpp not found at $WHISPER_DIR" >&2
+  echo "Checked \$PWD and the Eliza/eliza workspace node_modules paths." >&2
+  echo "Run 'bun install' first." >&2
+  exit 1
+fi
+
+echo "==> Building whisper.cpp in $WHISPER_DIR"
+cd "$WHISPER_DIR"
+patch_whisper_makefile
+make main -j"$(nproc 2>/dev/null || sysctl -n hw.logicalcpu 2>/dev/null || echo 4)"
+
+bash "$SCRIPT_DIR/ensure-whisper-model.sh" "$MODEL"
+
+echo "==> Done. Binary: $WHISPER_DIR/main"
+echo "    Model:  $WHISPER_MODEL_PATH"
+echo "    Cache:  $WHISPER_MODEL_CACHE_PATH"

package/platforms/electrobun/scripts/ensure-whisper-model.sh

@@ -0,0 +1,93 @@
+#!/usr/bin/env bash
+#
+# Ensure the requested whisper.cpp model exists in both the working tree and the
+# shared Eliza cache. This is intentionally separate from the native binary
+# build so CI can prepare the model once and fan it out to all desktop jobs.
+#
+# Usage:
+#   bash apps/app/electrobun/scripts/ensure-whisper-model.sh [model]
+#
+set -euo pipefail
+
+MODEL="${1:-base.en}"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+resolve_whisper_dir() {
+  local candidates=()
+
+  if [ -n "${ELIZA_WHISPER_CPP_DIR:-}" ]; then
+    candidates+=("$ELIZA_WHISPER_CPP_DIR")
+  fi
+
+  candidates+=(
+    "$PWD/node_modules/whisper-node/lib/whisper.cpp"
+    "$(cd "$SCRIPT_DIR/../../../../../.." && pwd)/node_modules/whisper-node/lib/whisper.cpp"
+    "$(cd "$SCRIPT_DIR/../../../../.." && pwd)/node_modules/whisper-node/lib/whisper.cpp"
+    "$(cd "$SCRIPT_DIR/../../../.." && pwd)/node_modules/whisper-node/lib/whisper.cpp"
+  )
+
+  for candidate in "${candidates[@]}"; do
+    if [ -d "$candidate" ]; then
+      printf '%s\n' "$candidate"
+      return 0
+    fi
+  done
+
+  printf '%s\n' "${candidates[0]}"
+  return 1
+}
+
+WHISPER_DIR="$(resolve_whisper_dir || true)"
+WHISPER_MODEL_DIR="$WHISPER_DIR/models"
+WHISPER_MODEL_FILENAME="ggml-${MODEL}.bin"
+WHISPER_MODEL_PATH="$WHISPER_MODEL_DIR/$WHISPER_MODEL_FILENAME"
+WHISPER_MODEL_CACHE_DIR="${ELIZA_WHISPER_MODEL_CACHE_DIR:-${XDG_CACHE_HOME:-$HOME/.cache}/eliza/whisper}"
+WHISPER_MODEL_CACHE_PATH="$WHISPER_MODEL_CACHE_DIR/$WHISPER_MODEL_FILENAME"
+DOWNLOAD_ATTEMPTS="${ELIZA_WHISPER_DOWNLOAD_ATTEMPTS:-4}"
+RETRY_DELAY_SECONDS="${ELIZA_WHISPER_DOWNLOAD_RETRY_DELAY_SECONDS:-15}"
+
+if [ ! -d "$WHISPER_DIR" ]; then
+  echo "Error: whisper.cpp not found at $WHISPER_DIR" >&2
+  echo "Checked \$PWD and the Eliza/eliza workspace node_modules paths." >&2
+  echo "Run 'bun install' first." >&2
+  exit 1
+fi
+
+mkdir -p "$WHISPER_MODEL_DIR"
+mkdir -p "$WHISPER_MODEL_CACHE_DIR"
+
+if [ -f "$WHISPER_MODEL_PATH" ]; then
+  echo "==> Whisper model already present: $WHISPER_MODEL_PATH"
+elif [ -f "$WHISPER_MODEL_CACHE_PATH" ]; then
+  echo "==> Restoring whisper model from cache: $WHISPER_MODEL_CACHE_PATH"
+  cp "$WHISPER_MODEL_CACHE_PATH" "$WHISPER_MODEL_PATH"
+else
+  cd "$WHISPER_DIR"
+
+  for attempt in $(seq 1 "$DOWNLOAD_ATTEMPTS"); do
+    echo "==> Downloading model attempt ${attempt}/${DOWNLOAD_ATTEMPTS}: $WHISPER_MODEL_FILENAME"
+    rm -f "$WHISPER_MODEL_PATH"
+
+    if bash models/download-ggml-model.sh "$MODEL"; then
+      break
+    fi
+
+    if [ "$attempt" -eq "$DOWNLOAD_ATTEMPTS" ]; then
+      echo "Error: failed to download $WHISPER_MODEL_FILENAME after ${DOWNLOAD_ATTEMPTS} attempts" >&2
+      exit 1
+    fi
+
+    echo "==> Download failed; retrying in ${RETRY_DELAY_SECONDS}s" >&2
+    sleep "$RETRY_DELAY_SECONDS"
+  done
+fi
+
+if [ ! -f "$WHISPER_MODEL_PATH" ]; then
+  echo "Error: whisper model missing after restore/download: $WHISPER_MODEL_PATH" >&2
+  exit 1
+fi
+
+cp "$WHISPER_MODEL_PATH" "$WHISPER_MODEL_CACHE_PATH"
+
+echo "==> Whisper model ready: $WHISPER_MODEL_PATH"
+echo "    Cache: $WHISPER_MODEL_CACHE_PATH"

package/platforms/electrobun/scripts/hdiutil-wrapper.sh

@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+REAL_HDIUTIL="${ELECTROBUN_REAL_HDIUTIL:-/usr/bin/hdiutil}"
+
+if [[ "${1:-}" == "create" ]]; then
+  attempts=5
+  delay=5
+  last_status=0
+  last_output=""
+
+  for ((attempt=1; attempt<=attempts; attempt++)); do
+    if output="$("$REAL_HDIUTIL" "$@" 2>&1)"; then
+      [[ -n "$output" ]] && printf '%s\n' "$output"
+      exit 0
+    fi
+
+    last_status=$?
+    last_output="$output"
+    printf '%s\n' "$output" >&2
+
+    if [[ "$output" != *"Resource busy"* || "$attempt" -eq "$attempts" ]]; then
+      break
+    fi
+
+    echo "hdiutil create attempt $attempt/$attempts failed with Resource busy; retrying in ${delay}s..." >&2
+    sleep "$delay"
+  done
+
+  exit "$last_status"
+fi
+
+exec "$REAL_HDIUTIL" "$@"

package/platforms/electrobun/scripts/lib/app-dir.mjs

@@ -0,0 +1,74 @@
+import fs from "node:fs";
+import path from "node:path";
+
+function hasPackageJson(dir) {
+  return fs.existsSync(path.join(dir, "package.json"));
+}
+
+function firstExistingPackage(candidates) {
+  return candidates.find(hasPackageJson) ?? candidates[0];
+}
+
+export function resolveMainAppDir(repoRoot, appName = "app") {
+  const cwd = path.resolve(process.cwd());
+  const elizaRoot = path.join(repoRoot, "eliza");
+  const cwdIsInsideNestedEliza =
+    hasPackageJson(elizaRoot) &&
+    (cwd === path.resolve(elizaRoot) ||
+      cwd.startsWith(`${path.resolve(elizaRoot)}${path.sep}`));
+
+  const isOuterMonorepo = hasPackageJson(path.join(repoRoot, "eliza"));
+  if (appName === "app") {
+    const localCandidates = [
+      path.join(repoRoot, "packages", "app"),
+      path.join(repoRoot, "apps", "app"),
+    ];
+    const outerCandidates = [
+      path.join(repoRoot, "eliza", "packages", "app"),
+      path.join(repoRoot, "eliza", "apps", "app"),
+      path.join(repoRoot, "apps", "app"),
+    ];
+    return firstExistingPackage(
+      isOuterMonorepo && !cwdIsInsideNestedEliza
+        ? [
+            path.join(repoRoot, "apps", "app"),
+            path.join(repoRoot, "packages", "app"),
+            path.join(repoRoot, "eliza", "packages", "app"),
+            path.join(repoRoot, "eliza", "apps", "app"),
+          ]
+        : isOuterMonorepo
+          ? outerCandidates
+          : localCandidates,
+    );
+  }
+
+  const candidates = [
+    path.join(repoRoot, "apps", appName),
+    path.join(repoRoot, "packages", appName),
+    path.join(repoRoot, "eliza", "apps", appName),
+    path.join(repoRoot, "eliza", "packages", appName),
+  ];
+  return firstExistingPackage(candidates);
+}
+
+export function relativeAppDir(repoRoot, appDir) {
+  return path.relative(repoRoot, appDir).replaceAll(path.sep, "/");
+}
+
+export function resolveElectrobunDir(repoRoot) {
+  const candidates = [
+    path.join(repoRoot, "packages", "app-core", "platforms", "electrobun"),
+    path.join(
+      repoRoot,
+      "eliza",
+      "packages",
+      "app-core",
+      "platforms",
+      "electrobun",
+    ),
+  ];
+  const match = candidates.find((candidate) =>
+    fs.existsSync(path.join(candidate, "electrobun.config.ts")),
+  );
+  return match ?? candidates[0];
+}

package/platforms/electrobun/scripts/lib/repo-root.mjs

@@ -0,0 +1,77 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+function looksLikeElizaSubrepoRoot(dir) {
+  return (
+    existsSync(path.join(dir, "package.json")) &&
+    (existsSync(path.join(dir, "packages", "app", "package.json")) ||
+      existsSync(path.join(dir, "apps", "app", "package.json"))) &&
+    existsSync(path.join(dir, "eliza", "packages", "app-core", "package.json"))
+  );
+}
+
+function looksLikeFlatMonorepoRoot(dir) {
+  const flat =
+    existsSync(path.join(dir, "package.json")) &&
+    existsSync(path.join(dir, "packages", "app-core", "package.json")) &&
+    existsSync(path.join(dir, "packages", "agent", "package.json"));
+  if (!flat) return false;
+  // When the elizaOS workspace is bundled as the `eliza/` subrepo of a
+  // consumer like Eliza, the inner `eliza/` directory itself satisfies the
+  // flat-monorepo shape. Resolving repoRoot to the inner directory would
+  // then cause `scripts/<name>` step paths in run-repo-setup.mjs to look
+  // under `eliza/scripts/…` instead of the consumer's own `scripts/…`.
+  // Prefer the outer subrepo container in that case.
+  if (path.basename(dir) === "eliza") {
+    const parent = path.dirname(dir);
+    if (parent !== dir && looksLikeElizaSubrepoRoot(parent)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function looksLikeRepoRoot(dir) {
+  return looksLikeFlatMonorepoRoot(dir) || looksLikeElizaSubrepoRoot(dir);
+}
+
+export function resolveRepoRoot(startDir = process.cwd()) {
+  let current = path.resolve(startDir);
+
+  while (true) {
+    if (looksLikeRepoRoot(current)) {
+      return current;
+    }
+
+    const parent = path.dirname(current);
+    if (parent === current) {
+      throw new Error(
+        `Could not resolve repository root starting from ${startDir}`,
+      );
+    }
+    current = parent;
+  }
+}
+
+export function resolveRepoRootFromCwd({ cwd = process.cwd() } = {}) {
+  try {
+    return resolveRepoRoot(cwd);
+  } catch {
+    return path.resolve(cwd);
+  }
+}
+
+export function resolveRepoRootFromImportMeta(
+  importMetaUrl,
+  { fallbackToCwd = false, cwd = process.cwd() } = {},
+) {
+  try {
+    return resolveRepoRoot(path.dirname(fileURLToPath(importMetaUrl)));
+  } catch (error) {
+    if (fallbackToCwd) {
+      return resolveRepoRootFromCwd({ cwd });
+    }
+    throw error;
+  }
+}