@elizaos/plugin-capacitor-bridge 2.0.3-beta.2 → 2.0.3-beta.4

package/README.md

@@ -82,6 +82,9 @@ Note: iOS connections are rejected with close code `4003`. iOS uses native IPC,
 
 | Slot | Model ID | HuggingFace path |
 |---|---|---|
-| TEXT_SMALL | `eliza-1-0_8b` | `elizaos/eliza-1` — `bundles/0_8b/text/eliza-1-0_8b-128k.gguf` |
-| TEXT_LARGE | `eliza-1-2b` | `elizaos/eliza-1` — `bundles/2b/text/eliza-1-2b-128k.gguf` |
+| TEXT_SMALL | `eliza-1-4b` | `elizaos/eliza-1` — `bundles/4b/text/eliza-1-4b-128k.gguf` |
+| TEXT_LARGE | `eliza-1-4b` | `elizaos/eliza-1` — `bundles/4b/text/eliza-1-4b-128k.gguf` |
 | TEXT_EMBEDDING | `eliza-1-embedding` | `elizaos/eliza-1` — `bundles/4b/embedding/eliza-1-embedding.gguf` |
+
+The 4B tier is the shipped mobile default for both chat slots; `eliza-1-2b` is
+the smallest/entry tier (the small-phone floor) but is not a recommended default.

package/dist/android/bridge.d.ts

@@ -0,0 +1,39 @@
+/**
+ * android-mobile-bridge.ts — Android counterpart to ios-bridge.ts.
+ *
+ * On Android, the elizaOS agent runs as a Bun child process managed by
+ * `ElizaAgentService`. Unlike the iOS path (which uses a stdio JSON-RPC
+ * bridge to a JSContext host), the Android Bun process boots the full
+ * elizaOS backend as an HTTP server listening on 127.0.0.1:31337.
+ *
+ * The agent bundle entry-point (`serve` / `start` command) already binds
+ * the server when `ELIZA_DISABLE_DIRECT_RUN` is unset.  This module:
+ *   1. Sets Android-specific environment variables before any module import.
+ *   2. Installs the mobile fs sandbox shim.
+ *   3. Boots the elizaOS runtime via the canonical `startEliza` path.
+ *   4. Wires the `ELIZA_DEVICE_BRIDGE_ENABLED` inference delegation layer
+ *      so the Capacitor WebView's llama-cpp plugin routes through the
+ *      on-device agent over loopback.
+ *
+ * This module is imported by the agent bundle's `android-bridge` CLI command:
+ *   `bun agent-bundle.js android-bridge`
+ *
+ * Environment variables set here mirror those set by `ElizaAgentService`:
+ *   - ELIZA_PLATFORM=android
+ *   - ELIZA_MOBILE_PLATFORM=android
+ *   - ELIZA_ANDROID_LOCAL_BACKEND=1   (Android-specific backend flag)
+ *   - ELIZA_HEADLESS=1                (no terminal UI)
+ *   - ELIZA_API_BIND=127.0.0.1        (loopback only)
+ *   - ELIZA_VAULT_BACKEND=file
+ *   - ELIZA_DISABLE_VAULT_PROFILE_RESOLVER=1
+ *   - ELIZA_DISABLE_AGENT_WALLET_BOOTSTRAP=1
+ *   - LOG_LEVEL=error                 (quiet on-device)
+ *
+ * All values use the `||=` pattern so that values pre-set by the
+ * `ElizaAgentService` environment take precedence over these defaults.
+ * The service sets richer values (e.g. `ELIZA_API_TOKEN`, port, state dir)
+ * before spawning the bundle; this module only fills gaps for direct runs.
+ */
+declare function runAndroidBridgeCli(): Promise<void>;
+
+export { runAndroidBridgeCli };

package/dist/android/bridge.js

@@ -0,0 +1,151 @@
+import {
+  installMobileFsShim
+} from "../chunk-E7Y447TQ.js";
+import "../chunk-MLKGABMK.js";
+
+// src/android/bridge.ts
+import process from "process";
+import * as nodeFs from "fs";
+import nodePath from "path";
+process.env.ELIZA_PLATFORM ||= "android";
+process.env.ELIZA_MOBILE_PLATFORM ||= "android";
+process.env.ELIZA_ANDROID_LOCAL_BACKEND ||= "1";
+process.env.ELIZA_DISABLE_DIRECT_RUN ||= "1";
+process.env.ELIZA_HEADLESS ||= "1";
+process.env.ELIZA_API_BIND ||= "127.0.0.1";
+process.env.ELIZA_VAULT_BACKEND ||= "file";
+process.env.ELIZA_DISABLE_VAULT_PROFILE_RESOLVER ||= "1";
+process.env.ELIZA_DISABLE_AGENT_WALLET_BOOTSTRAP ||= "1";
+process.env.LOG_LEVEL ||= "error";
+process.env.ELIZA_DISABLE_AUTO_BOOTSTRAP ||= "1";
+process.env.ELIZA_DISABLE_TRAJECTORY_LOGGING ||= "1";
+async function loadStartEliza() {
+  const mod = await import(
+    /* @vite-ignore */
+    "@elizaos/agent"
+  );
+  return mod.startEliza;
+}
+var _logPath = "";
+function setupAndroidBridgeEnvironment() {
+  const rawHome = process.env.HOME || nodePath.dirname(
+    process.env.ELIZA_STATE_DIR || process.env.ELIZA_STATE_DIR || "/data/local/tmp/.eliza"
+  );
+  let canonicalHome;
+  try {
+    canonicalHome = nodeFs.realpathSync(rawHome);
+  } catch {
+    canonicalHome = rawHome;
+  }
+  if (canonicalHome !== rawHome) {
+    if (process.env.HOME) process.env.HOME = canonicalHome;
+    for (const key of [
+      "ELIZA_STATE_DIR",
+      "ELIZA_STATE_DIR",
+      "ELIZA_WORKSPACE_DIR",
+      "ELIZA_WORKSPACE_DIR",
+      "TMPDIR"
+    ]) {
+      const val = process.env[key];
+      if (val?.startsWith(rawHome)) {
+        process.env[key] = canonicalHome + val.slice(rawHome.length);
+      }
+    }
+  }
+  const stateDir = process.env.ELIZA_STATE_DIR || process.env.ELIZA_STATE_DIR || `${canonicalHome}/.eliza`;
+  installMobileFsShim(canonicalHome);
+  _logPath = `${stateDir}/android-bridge.log`;
+  try {
+    nodeFs.mkdirSync(stateDir, { recursive: true });
+  } catch {
+  }
+  _logToFile(`[android-bridge] process started, stateDir=${stateDir}`);
+  return stateDir;
+}
+function _logToFile(line) {
+  if (!_logPath) return;
+  try {
+    nodeFs.appendFileSync(_logPath, `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
+`);
+  } catch {
+  }
+}
+async function runAndroidBridgeCli() {
+  setupAndroidBridgeEnvironment();
+  process.on("exit", (code) => {
+    _logToFile(`[android-bridge] process.exit code=${code}`);
+  });
+  const _origConsoleError = console.error.bind(console);
+  console.error = (...args) => {
+    _logToFile(`[console.error] ${args.map(String).join(" ")}`);
+    _origConsoleError(...args);
+  };
+  const _origConsoleWarn = console.warn.bind(console);
+  console.warn = (...args) => {
+    const msg = args.map(String).join(" ");
+    if (msg.includes("Error") || msg.includes("error") || msg.includes("fail")) {
+      _logToFile(`[console.warn] ${msg}`);
+    }
+    _origConsoleWarn(...args);
+  };
+  process.on("unhandledRejection", (reason) => {
+    const msg = reason instanceof Error ? reason.stack || reason.message : String(reason);
+    _logToFile(`[android-bridge] unhandledRejection: ${msg}`);
+    console.error("[android-bridge] unhandled rejection:", msg);
+  });
+  process.on("uncaughtException", (error) => {
+    _logToFile(
+      `[android-bridge] uncaughtException: ${error.stack || error.message}`
+    );
+    console.error(
+      "[android-bridge] uncaught exception:",
+      error.stack || error.message
+    );
+  });
+  _logToFile("[android-bridge] importing startEliza...");
+  const startEliza = await loadStartEliza();
+  _logToFile("[android-bridge] calling startEliza({ serverOnly: true })...");
+  const _hb = setInterval(() => {
+    _logToFile("[android-bridge] startEliza still running...");
+  }, 1e4);
+  let runtime;
+  try {
+    runtime = await startEliza({ serverOnly: true });
+  } catch (err) {
+    const msg = err instanceof Error ? err.stack || err.message : String(err);
+    _logToFile(`[android-bridge] startEliza THREW: ${msg}`);
+    throw err;
+  } finally {
+    clearInterval(_hb);
+  }
+  _logToFile(
+    `[android-bridge] startEliza returned: ${runtime ? "present" : "null"}`
+  );
+  _logToFile(
+    `[android-bridge] startEliza returned: runtime=${runtime ? "present" : "null"}, ELIZA_ANDROID_LOCAL_BACKEND=${process.env.ELIZA_ANDROID_LOCAL_BACKEND ?? "(unset)"}`
+  );
+  if (runtime && process.env.ELIZA_DEVICE_BRIDGE_ENABLED?.trim() === "1") {
+    _logToFile("[android-bridge] importing mobile-device-bridge-bootstrap\u2026");
+    const { ensureMobileDeviceBridgeInferenceHandlers } = await import("../mobile-device-bridge-bootstrap.js");
+    await ensureMobileDeviceBridgeInferenceHandlers(runtime);
+    try {
+      const { installRouterHandler } = await import("@elizaos/plugin-local-inference/runtime");
+      installRouterHandler(runtime, {});
+      _logToFile(
+        "[android-bridge] installed prefer-local cross-provider router"
+      );
+    } catch (err) {
+      _logToFile(
+        `[android-bridge] router install failed (local routing may defer to priority): ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  await new Promise((resolve) => {
+    process.once("SIGINT", resolve);
+    process.once("SIGTERM", resolve);
+  });
+  _logToFile("[android-bridge] shutdown signal received, exiting.");
+}
+export {
+  runAndroidBridgeCli
+};