@elizaos/app-core 2.0.0-beta.3 → 2.0.11-beta.6

package/platforms/electrobun/remotes/surface/src/web/state.ts

@@ -0,0 +1,427 @@
+import type {
+  AgentMessageStreamEvent,
+  AgentSummary,
+  ApiDiscoveryResult,
+  ConversationSummary,
+  FileListResult,
+  FileReadTextResult,
+  FileRoot,
+  FileSearchResult,
+  GitBranch,
+  GitLogEntry,
+  GitOperation,
+  GitRemote,
+  GitRepoInfo,
+  GitStatusResult,
+  Eliza1BundleTier,
+  Eliza1VoiceComponent,
+  LocalModelActiveSnapshot,
+  LocalModelCatalogEntry,
+  LocalModelDownloadJob,
+  LocalModelHardwareSnapshot,
+  LocalModelHubSnapshot,
+  LocalModelInstalledEntry,
+  PtyOutputEntry,
+  PtySession,
+  PtyStatus,
+  LogEntry,
+  RuntimeState,
+} from "../protocol/event-types.ts";
+
+export type SurfaceRuntimeStatus = {
+  runtimeState: RuntimeState | null;
+  health: unknown | null;
+  apiDiscovery: ApiDiscoveryResult | null;
+  agents: AgentSummary[];
+  conversations: ConversationSummary[];
+  plugins: unknown[];
+  config: unknown | null;
+  fileStatus: unknown | null;
+  fileRoots: FileRoot[];
+  fileList: FileListResult | null;
+  fileText: FileReadTextResult | null;
+  fileSearch: FileSearchResult | null;
+  ptyStatus: PtyStatus | null;
+  ptySessions: PtySession[];
+  activePtySessionId: string | null;
+  ptyOutput: PtyOutputEntry[];
+  ptyNextSequence: number;
+  gitStatus: GitStatusResult | null;
+  gitRepo: GitRepoInfo | null;
+  gitRepoStatus: GitStatusResult | null;
+  gitBranches: GitBranch[];
+  gitRemotes: GitRemote[];
+  gitLog: GitLogEntry[];
+  gitDiff: string;
+  gitShow: string;
+  gitOperations: GitOperation[];
+  modelHub: LocalModelHubSnapshot | null;
+  modelCatalog: LocalModelCatalogEntry[];
+  modelEliza1Tiers: Eliza1BundleTier[];
+  modelVoiceComponents: Eliza1VoiceComponent[];
+  modelHfMetadata: unknown | null;
+  modelProviders: unknown[];
+  modelHardware: LocalModelHardwareSnapshot | null;
+  modelInstalled: LocalModelInstalledEntry[];
+  modelDownloads: LocalModelDownloadJob[];
+  modelActive: LocalModelActiveSnapshot | null;
+  modelAssignments: Record<string, string>;
+  modelRouting: unknown | null;
+  logs: LogEntry[];
+  selectedAgentId: string | null;
+  selectedConversationId: string | null;
+  activeStreamId: string | null;
+  chatMessages: SurfaceChatMessage[];
+  actionTimeline: SurfaceActionEvent[];
+  errors: SurfaceError[];
+  output: unknown | null;
+};
+
+export type SurfaceChatMessage = {
+  id: string;
+  role: "user" | "assistant" | "system";
+  text: string;
+  streamId?: string;
+  status?: "pending" | "streaming" | "done" | "cancelled" | "error";
+  createdAt: string;
+  updatedAt: string;
+};
+
+export type SurfaceActionEvent = {
+  id: string;
+  streamId?: string;
+  kind: "snapshot" | "action" | "error" | "done" | "cancelled";
+  title?: string;
+  text?: string;
+  payload?: unknown;
+  createdAt: string;
+};
+
+export type SurfaceError = {
+  id: string;
+  message: string;
+  details?: unknown;
+  createdAt: string;
+};
+
+export function createInitialState(): SurfaceRuntimeStatus {
+  return {
+    runtimeState: null,
+    health: null,
+    apiDiscovery: null,
+    agents: [],
+    conversations: [],
+    plugins: [],
+    config: null,
+    fileStatus: null,
+    fileRoots: [],
+    fileList: null,
+    fileText: null,
+    fileSearch: null,
+    ptyStatus: null,
+    ptySessions: [],
+    activePtySessionId: null,
+    ptyOutput: [],
+    ptyNextSequence: 0,
+    gitStatus: null,
+    gitRepo: null,
+    gitRepoStatus: null,
+    gitBranches: [],
+    gitRemotes: [],
+    gitLog: [],
+    gitDiff: "",
+    gitShow: "",
+    gitOperations: [],
+    modelHub: null,
+    modelCatalog: [],
+    modelEliza1Tiers: [],
+    modelVoiceComponents: [],
+    modelHfMetadata: null,
+    modelProviders: [],
+    modelHardware: null,
+    modelInstalled: [],
+    modelDownloads: [],
+    modelActive: null,
+    modelAssignments: {},
+    modelRouting: null,
+    logs: [],
+    selectedAgentId: null,
+    selectedConversationId: null,
+    activeStreamId: null,
+    chatMessages: [],
+    actionTimeline: [],
+    errors: [],
+    output: null,
+  };
+}
+
+export function addUserMessage(
+  state: SurfaceRuntimeStatus,
+  text: string,
+): SurfaceChatMessage {
+  const now = new Date().toISOString();
+  const message = {
+    id: createId("user"),
+    role: "user" as const,
+    text,
+    status: "done" as const,
+    createdAt: now,
+    updatedAt: now,
+  };
+  state.chatMessages.push(message);
+  return message;
+}
+
+export function addAssistantStreamMessage(
+  state: SurfaceRuntimeStatus,
+  streamId: string,
+): SurfaceChatMessage {
+  const now = new Date().toISOString();
+  const message = {
+    id: createId("assistant"),
+    role: "assistant" as const,
+    text: "",
+    streamId,
+    status: "streaming" as const,
+    createdAt: now,
+    updatedAt: now,
+  };
+  state.activeStreamId = streamId;
+  state.chatMessages.push(message);
+  return message;
+}
+
+function applyRuntimeStateEvent(
+  state: SurfaceRuntimeStatus,
+  eventName: string,
+  payload: unknown,
+): boolean {
+  if (
+    (eventName === "runtime.statusChanged" ||
+      eventName === "runtime.started" ||
+      eventName === "runtime.stopped") &&
+    isRuntimeState(payload)
+  ) {
+    state.runtimeState = payload;
+    return true;
+  }
+  return false;
+}
+
+function clearActiveStream(
+  state: SurfaceRuntimeStatus,
+  streamId: string,
+): void {
+  if (state.activeStreamId === streamId) state.activeStreamId = null;
+}
+
+function applyStreamEvent(
+  state: SurfaceRuntimeStatus,
+  eventName: string,
+  payload: AgentMessageStreamEvent,
+): void {
+  if (eventName === "agent.message.stream.started") {
+    state.activeStreamId = payload.streamId;
+    ensureAssistantStreamMessage(state, payload.streamId);
+    return;
+  }
+  if (eventName === "agent.message.stream.delta") {
+    appendDelta(state, payload);
+    return;
+  }
+  if (eventName === "agent.message.stream.snapshot") {
+    addTimelineEvent(state, payload, "snapshot");
+    return;
+  }
+  if (eventName === "agent.message.stream.action") {
+    addTimelineEvent(state, payload, "action");
+    return;
+  }
+  if (eventName === "agent.message.stream.done") {
+    setAssistantStatus(state, payload.streamId, "done");
+    addTimelineEvent(state, payload, "done");
+    clearActiveStream(state, payload.streamId);
+    return;
+  }
+  if (eventName === "agent.message.stream.cancelled") {
+    setAssistantStatus(state, payload.streamId, "cancelled");
+    addTimelineEvent(state, payload, "cancelled");
+    clearActiveStream(state, payload.streamId);
+    return;
+  }
+  if (eventName !== "agent.message.stream.error") return;
+  setAssistantStatus(state, payload.streamId, "error");
+  addTimelineEvent(state, payload, "error");
+  addError(state, payload.text ?? "Streaming message failed.", payload);
+  clearActiveStream(state, payload.streamId);
+}
+
+export function applyRuntimeEvent(
+  state: SurfaceRuntimeStatus,
+  eventName: string,
+  payload: unknown,
+): void {
+  if (applyRuntimeStateEvent(state, eventName, payload)) return;
+  if (eventName === "runtime.log" && isLogEntry(payload)) {
+    state.logs = [...state.logs.slice(-199), payload];
+    return;
+  }
+
+  if (eventName === "runtime.error") {
+    addError(state, "Runtime Remote error.", payload);
+    return;
+  }
+
+  if (!isStreamEvent(payload)) return;
+  applyStreamEvent(state, eventName, payload);
+}
+
+export function addError(
+  state: SurfaceRuntimeStatus,
+  message: string,
+  details?: unknown,
+): void {
+  state.errors = [
+    {
+      id: createId("error"),
+      message,
+      details,
+      createdAt: new Date().toISOString(),
+    },
+    ...state.errors,
+  ].slice(0, 20);
+}
+
+export function selectAgent(
+  state: SurfaceRuntimeStatus,
+  agentId: string | null,
+): void {
+  state.selectedAgentId = agentId && agentId.length > 0 ? agentId : null;
+}
+
+export function selectConversation(
+  state: SurfaceRuntimeStatus,
+  conversationId: string | null,
+): void {
+  state.selectedConversationId =
+    conversationId && conversationId.length > 0 ? conversationId : null;
+}
+
+export function setPtySession(
+  state: SurfaceRuntimeStatus,
+  session: PtySession,
+): void {
+  const existingIndex = state.ptySessions.findIndex(
+    (existing) => existing.id === session.id,
+  );
+  if (existingIndex === -1) state.ptySessions.push(session);
+  else state.ptySessions[existingIndex] = session;
+  state.activePtySessionId = session.id;
+}
+
+export function setPtyOutput(
+  state: SurfaceRuntimeStatus,
+  entries: PtyOutputEntry[],
+  nextSequence: number,
+): void {
+  state.ptyOutput = entries;
+  state.ptyNextSequence = nextSequence;
+}
+
+export function appendPtyOutput(
+  state: SurfaceRuntimeStatus,
+  entries: PtyOutputEntry[],
+  nextSequence: number,
+): void {
+  state.ptyOutput = [...state.ptyOutput, ...entries].slice(-1000);
+  state.ptyNextSequence = nextSequence;
+}
+
+function appendDelta(
+  state: SurfaceRuntimeStatus,
+  event: AgentMessageStreamEvent,
+): void {
+  const message = ensureAssistantStreamMessage(state, event.streamId);
+  message.text += event.delta ?? "";
+  message.updatedAt = event.timestamp;
+}
+
+function ensureAssistantStreamMessage(
+  state: SurfaceRuntimeStatus,
+  streamId: string,
+): SurfaceChatMessage {
+  const existing = state.chatMessages.find(
+    (message) => message.role === "assistant" && message.streamId === streamId,
+  );
+  if (existing) return existing;
+  return addAssistantStreamMessage(state, streamId);
+}
+
+function setAssistantStatus(
+  state: SurfaceRuntimeStatus,
+  streamId: string,
+  status: NonNullable<SurfaceChatMessage["status"]>,
+): void {
+  const message = ensureAssistantStreamMessage(state, streamId);
+  message.status = status;
+  message.updatedAt = new Date().toISOString();
+}
+
+function addTimelineEvent(
+  state: SurfaceRuntimeStatus,
+  event: AgentMessageStreamEvent,
+  kind: SurfaceActionEvent["kind"],
+): void {
+  const title =
+    event.actionName ??
+    event.toolName ??
+    (kind === "snapshot" ? "Callback snapshot" : kind);
+  state.actionTimeline = [
+    {
+      id: createId(kind),
+      streamId: event.streamId,
+      kind,
+      title,
+      text: event.text,
+      payload: event.payload ?? event.raw,
+      createdAt: event.timestamp,
+    },
+    ...state.actionTimeline,
+  ].slice(0, 100);
+}
+
+function isRuntimeState(value: unknown): value is RuntimeState {
+  if (!isRecord(value)) return false;
+  return (
+    typeof value.mode === "string" &&
+    typeof value.cwd === "string" &&
+    Array.isArray(value.command)
+  );
+}
+
+function isLogEntry(value: unknown): value is LogEntry {
+  if (!isRecord(value)) return false;
+  return (
+    typeof value.timestamp === "string" &&
+    typeof value.stream === "string" &&
+    typeof value.line === "string"
+  );
+}
+
+function isStreamEvent(value: unknown): value is AgentMessageStreamEvent {
+  if (!isRecord(value)) return false;
+  return typeof value.streamId === "string" && typeof value.kind === "string";
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function createId(prefix: string): string {
+  const cryptoApi = globalThis.crypto;
+  const random =
+    cryptoApi && "randomUUID" in cryptoApi
+      ? cryptoApi.randomUUID()
+      : Math.random().toString(36).slice(2);
+  return `${prefix}-${random}`;
+}

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

@@ -25,7 +25,11 @@ xcrun clang++ \
   -framework Cocoa \
   -framework ApplicationServices \
   -framework AVFoundation \
+  -framework Contacts \
   -framework CoreGraphics \
+  -framework CoreLocation \
+  -framework EventKit \
+  -framework UserNotifications \
   "$SRC_FILE" \
   -o "$OUT_FILE"
 echo "Built native macOS effects: $OUT_FILE"

package/platforms/electrobun/scripts/ensure-build-folder.ts

@@ -0,0 +1,28 @@
+import fs from "node:fs";
+import path from "node:path";
+
+const platformNames: Record<string, string> = {
+  darwin: "macos",
+  linux: "linux",
+  win32: "windows",
+};
+
+const archNames: Record<string, string> = {
+  arm64: "arm64",
+  x64: "x64",
+};
+
+const envName = process.env.ELECTROBUN_ENV?.trim() || "dev";
+const osName =
+  process.env.ELECTROBUN_OS?.trim() || platformNames[process.platform];
+const archName = process.env.ELECTROBUN_ARCH?.trim() || archNames[process.arch];
+
+if (!osName || !archName) {
+  throw new Error(
+    `Unsupported Electrobun build target: ${process.platform}/${process.arch}`,
+  );
+}
+
+fs.mkdirSync(path.join("build", `${envName}-${osName}-${archName}`), {
+  recursive: true,
+});

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

@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+# Fetch a ggml-format whisper.cpp model from HuggingFace.
+#
+# Replaces the previous OpenVINO IR install path. The whisper.cpp ggml
+# format is the on-disk representation our libwhisper_eliza_adapter loads
+# via the upstream `whisper_init_from_file_with_params` entrypoint — it's
+# the same file ggerganov/whisper.cpp ships at
+# https://huggingface.co/ggerganov/whisper.cpp.
+#
+# Usage:
+#   bash ensure-whisper-gguf.sh [model_name]
+#     model_name defaults to "base.en". Recognised names match upstream:
+#       tiny[.en], base[.en], small[.en], medium[.en], large-v1, large-v2,
+#       large-v3, large-v3-turbo[-q5_0].
+#
+# Env knobs:
+#   ELIZA_WHISPER_MODEL_DIR   override download cache root
+#                             (default: ~/.cache/eliza/whisper)
+#   ELIZA_WHISPER_MODEL_URL   override download URL (default:
+#                             https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-${MODEL_NAME}.bin)
+#
+# Exit codes:
+#   0  - model already present or downloaded successfully
+#   1  - download tool missing or fetch failed
+#   2  - unknown / unsupported model name (best-effort: only fails when
+#        the resolved URL returns 404 because the file does not exist)
+set -euo pipefail
+
+MODEL_NAME="${1:-base.en}"
+CACHE_DIR="${ELIZA_WHISPER_MODEL_DIR:-$HOME/.cache/eliza/whisper}"
+MODEL_FILE="$CACHE_DIR/ggml-${MODEL_NAME}.bin"
+MODEL_URL="${ELIZA_WHISPER_MODEL_URL:-https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-${MODEL_NAME}.bin}"
+
+mkdir -p "$CACHE_DIR"
+
+if [[ -s "$MODEL_FILE" ]]; then
+  echo "Whisper GGUF/GGML model already present: $MODEL_FILE"
+  exit 0
+fi
+
+TMP_FILE="${MODEL_FILE}.tmp"
+rm -f "$TMP_FILE"
+
+echo "Downloading whisper.cpp ggml model ${MODEL_NAME}..."
+if command -v curl >/dev/null 2>&1; then
+  curl --fail --location --retry 3 --output "$TMP_FILE" "$MODEL_URL"
+elif command -v wget >/dev/null 2>&1; then
+  wget --tries=3 --output-document="$TMP_FILE" "$MODEL_URL"
+else
+  echo "curl or wget is required to download $MODEL_URL" >&2
+  exit 1
+fi
+
+mv "$TMP_FILE" "$MODEL_FILE"
+echo "Whisper GGUF/GGML model ready: $MODEL_FILE"

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

@@ -1,93 +1,35 @@
 #!/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)"
+model="${1:-base.en}"
+whisper_pkg="${WHISPER_NODE_PACKAGE_DIR:-}"
 
-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
+if [ -z "$whisper_pkg" ]; then
+  whisper_pkg="$(node -e 'const { createRequire } = require("node:module"); const path = require("node:path"); const req = createRequire(process.cwd() + "/"); console.log(path.dirname(req.resolve("whisper-node/package.json")));')"
 fi
 
-mkdir -p "$WHISPER_MODEL_DIR"
-mkdir -p "$WHISPER_MODEL_CACHE_DIR"
+models_dir="$whisper_pkg/lib/whisper.cpp/models"
+model_file="$models_dir/ggml-$model.bin"
+cache_dir="${ELIZA_WHISPER_MODEL_CACHE_DIR:-}"
+cache_file=""
 
-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
+if [ -n "$cache_dir" ]; then
+  cache_file="$cache_dir/ggml-$model.bin"
+fi
 
-    echo "==> Download failed; retrying in ${RETRY_DELAY_SECONDS}s" >&2
-    sleep "$RETRY_DELAY_SECONDS"
-  done
+if [ -n "$cache_file" ] && [ -f "$cache_file" ]; then
+  mkdir -p "$models_dir"
+  cp "$cache_file" "$model_file"
+  exit 0
 fi
 
-if [ ! -f "$WHISPER_MODEL_PATH" ]; then
-  echo "Error: whisper model missing after restore/download: $WHISPER_MODEL_PATH" >&2
-  exit 1
+if [ -f "$model_file" ]; then
+  exit 0
 fi
 
-cp "$WHISPER_MODEL_PATH" "$WHISPER_MODEL_CACHE_PATH"
+bash "$models_dir/download-ggml-model.sh" "$model"
 
-echo "==> Whisper model ready: $WHISPER_MODEL_PATH"
-echo "    Cache: $WHISPER_MODEL_CACHE_PATH"
+if [ -n "$cache_file" ]; then
+  mkdir -p "$cache_dir"
+  cp "$model_file" "$cache_file"
+fi