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

package/platforms/electrobun/remotes/runtime/src/web/index.ts

@@ -0,0 +1,192 @@
+import type {
+  AgentMessageStreamEvent,
+  RuntimeMethod,
+  RuntimeWorkerOutboundMessage,
+  RuntimeWorkerRequestMessage,
+} from "../bun/protocol.ts";
+
+const output = document.querySelector<HTMLPreElement>("#output");
+const streamOutput = document.querySelector<HTMLPreElement>("#stream-output");
+const streamSnapshot =
+  document.querySelector<HTMLPreElement>("#stream-snapshot");
+const activeStreamId = document.querySelector<HTMLElement>("#active-stream-id");
+const buttons = Array.from(
+  document.querySelectorAll<HTMLButtonElement>("button[data-method]"),
+);
+const agentIdInput = document.querySelector<HTMLInputElement>("#agent-id");
+const conversationIdInput =
+  document.querySelector<HTMLInputElement>("#conversation-id");
+const messageTextInput =
+  document.querySelector<HTMLInputElement>("#message-text");
+const memoryQueryInput =
+  document.querySelector<HTMLInputElement>("#memory-query");
+const logLimitInput = document.querySelector<HTMLInputElement>("#log-limit");
+const worker = new Worker(new URL("../bun/worker.ts", import.meta.url), {
+  type: "module",
+});
+let nextRequestId = 1;
+let currentStreamId: string | null = null;
+
+function append(value: string): void {
+  if (output === null) return;
+  output.textContent = `${output.textContent ?? ""}\n${value}`.trim();
+  output.scrollTop = output.scrollHeight;
+}
+
+function appendStream(value: string): void {
+  if (streamOutput === null) return;
+  streamOutput.textContent = `${streamOutput.textContent ?? ""}${value}`;
+  streamOutput.scrollTop = streamOutput.scrollHeight;
+}
+
+function setSnapshot(value: string): void {
+  if (streamSnapshot === null) return;
+  streamSnapshot.textContent = value;
+}
+
+function setActiveStreamId(value: string | null): void {
+  currentStreamId = value;
+  if (activeStreamId !== null) activeStreamId.textContent = value ?? "none";
+}
+
+function inputValue(input: HTMLInputElement | null): string {
+  return input?.value.trim() ?? "";
+}
+
+function requestParams(
+  method: RuntimeMethod,
+): RuntimeWorkerRequestMessage["params"] {
+  if (method === "runtime.logs.tail") {
+    const limit = Number.parseInt(inputValue(logLimitInput), 10);
+    return { limit: Number.isFinite(limit) ? limit : 80 };
+  }
+  if (method === "api.discover") return { refresh: true };
+  if (method === "agent.get") return { agentId: inputValue(agentIdInput) };
+  if (method === "agent.message" || method === "agent.message.stream") {
+    const agentId = inputValue(agentIdInput);
+    const conversationId = inputValue(conversationIdInput);
+    return {
+      text: inputValue(messageTextInput),
+      ...(agentId.length > 0 ? { agentId } : {}),
+      ...(conversationId.length > 0 ? { conversationId } : {}),
+    };
+  }
+  if (
+    method === "agent.message.stream.cancel" ||
+    method === "agent.message.stream.status"
+  ) {
+    return { streamId: currentStreamId ?? "" };
+  }
+  if (method === "conversation.get") {
+    return { conversationId: inputValue(conversationIdInput) };
+  }
+  if (method === "memory.search") {
+    return { query: inputValue(memoryQueryInput), limit: 10 };
+  }
+  return undefined;
+}
+
+function send(method: RuntimeMethod): void {
+  const request: RuntimeWorkerRequestMessage = {
+    type: "request",
+    requestId: nextRequestId++,
+    method,
+    ...(requestParams(method) === undefined
+      ? {}
+      : { params: requestParams(method) }),
+  };
+  append(`> ${method}`);
+  worker.postMessage(request);
+}
+
+function handleStreamEvent(event: AgentMessageStreamEvent): void {
+  if (event.kind === "started") {
+    setActiveStreamId(event.streamId);
+    if (streamOutput !== null) streamOutput.textContent = "";
+    setSnapshot("Stream started.");
+    return;
+  }
+  if (event.kind === "delta") {
+    appendStream(event.delta ?? "");
+    return;
+  }
+  if (event.kind === "snapshot") {
+    setSnapshot(
+      event.text ?? JSON.stringify(event.raw ?? event.payload, null, 2),
+    );
+    return;
+  }
+  if (event.kind === "action") {
+    setSnapshot(
+      JSON.stringify(
+        {
+          actionName: event.actionName,
+          toolName: event.toolName,
+          text: event.text,
+          payload: event.payload,
+        },
+        null,
+        2,
+      ),
+    );
+    return;
+  }
+  if (event.kind === "done") {
+    setSnapshot(event.text ?? "Stream complete.");
+    setActiveStreamId(null);
+    return;
+  }
+  if (event.kind === "cancelled") {
+    setSnapshot("Stream cancelled.");
+    setActiveStreamId(null);
+    return;
+  }
+  if (event.kind === "error") {
+    setSnapshot(event.text ?? "Stream error.");
+    setActiveStreamId(null);
+  }
+}
+
+worker.addEventListener(
+  "message",
+  (event: MessageEvent<RuntimeWorkerOutboundMessage>) => {
+    const message = event.data;
+    if (message.type === "ready") {
+      append("Runtime Remote worker ready.");
+      return;
+    }
+    if (message.type === "event") {
+      if (
+        message.name.startsWith("agent.message.stream.") &&
+        typeof message.payload === "object" &&
+        message.payload !== null &&
+        "streamId" in message.payload &&
+        "kind" in message.payload
+      ) {
+        handleStreamEvent(message.payload as AgentMessageStreamEvent);
+      }
+      append(
+        `event ${message.name}: ${JSON.stringify(message.payload, null, 2)}`,
+      );
+      return;
+    }
+    if (
+      message.type === "response" &&
+      message.success &&
+      typeof message.payload === "object" &&
+      message.payload !== null &&
+      "streamId" in message.payload &&
+      typeof message.payload.streamId === "string"
+    ) {
+      setActiveStreamId(message.payload.streamId);
+    }
+    append(JSON.stringify(message, null, 2));
+  },
+);
+
+for (const button of buttons) {
+  button.addEventListener("click", () => {
+    const method = button.dataset.method;
+    if (typeof method === "string") send(method as RuntimeMethod);
+  });
+}

package/platforms/electrobun/remotes/surface/README.md

@@ -0,0 +1,201 @@
+# Eliza Surface Remote
+
+ElizaLaunch is the desktop launcher layer around the existing Bun/TypeScript elizaOS runtime. Eliza Orbit is the runtime environment that coordinates Remotes. Remotes are focused modules that expose one capability through the module boundary.
+
+`eliza.surface` is the first Surface Remote. It provides a control and chat UI backed by `eliza.runtime`.
+
+## Phase 4 Scope
+
+The Surface Remote consumes Runtime Remote methods and events instead of calling local `/api/...` routes directly. It is a dev/control surface for proving the Eliza Orbit boundary and does not replace the production dashboard yet.
+
+It can call:
+
+- `runtime.start`
+- `runtime.stop`
+- `runtime.restart`
+- `runtime.status`
+- `runtime.health`
+- `runtime.logs.tail`
+- `api.discover`
+- `api.status`
+- `agent.list`
+- `agent.get`
+- `agent.message`
+- `agent.message.stream`
+- `agent.message.stream.cancel`
+- `agent.message.stream.status`
+- `conversation.list`
+- `conversation.get`
+- `plugin.list`
+- `memory.search`
+- `config.get`
+- `fs.status`
+- `fs.roots`
+- `fs.stat`
+- `fs.list`
+- `fs.readText`
+- `fs.search`
+- `fs.writeText`
+- `pty.status`
+- `pty.session.create`
+- `pty.session.list`
+- `pty.session.get`
+- `pty.session.write`
+- `pty.session.resize`
+- `pty.session.kill`
+- `pty.session.output.tail`
+- `pty.session.output.clear`
+- `pty.command.run`
+- `git.status`
+- `git.repo.info`
+- `git.branches`
+- `git.remotes`
+- `git.log`
+- `git.diff`
+- `git.show`
+- `git.add`
+- `git.restore`
+- `git.checkout`
+- `git.branch.create`
+- `git.branch.delete`
+- `git.commit`
+- `git.fetch`
+- `git.pull`
+- `git.push`
+- `git.operation.list`
+- `git.operation.get`
+- `git.command.run`
+- `model.status`
+- `model.hub`
+- `model.catalog`
+- `model.catalog.eliza1`
+- `model.eliza1.tiers`
+- `model.eliza1.voice`
+- `model.hf.metadata`
+- `model.providers`
+- `model.hardware`
+- `model.installed`
+- `model.download.start`
+- `model.download.cancel`
+- `model.downloads`
+- `model.active`
+- `model.activate`
+- `model.unload`
+- `model.assignments`
+- `model.assignment.set`
+- `model.routing`
+- `model.routing.set`
+- `model.routing.useLocal`
+- `model.routing.useCloud`
+- `model.generate`
+- `model.embedding`
+- `model.capabilities`
+
+It consumes:
+
+- `runtime.statusChanged`
+- `runtime.log`
+- `runtime.error`
+- `runtime.started`
+- `runtime.stopped`
+- `agent.message.stream.started`
+- `agent.message.stream.delta`
+- `agent.message.stream.snapshot`
+- `agent.message.stream.action`
+- `agent.message.stream.error`
+- `agent.message.stream.done`
+- `agent.message.stream.cancelled`
+
+## Build and Smoke
+
+```sh
+bun run --cwd elizalaunch/remotes/surface build
+bun run --cwd elizalaunch/remotes/surface smoke
+bun run --cwd elizalaunch/remotes/surface smoke:phase4
+```
+
+The smoke test uses a mock module bridge. It verifies that runtime status, API discovery, agent listing, stream start, token deltas, snapshots, action events, and done events update Surface state correctly without requiring a real LLM response.
+
+It also mocks filesystem calls through `eliza.runtime` and verifies roots, listing, text reads, and search results update Surface state.
+
+It also mocks terminal calls through `eliza.runtime` and verifies status, session creation, output tailing, input writes, and kill status update Surface state.
+
+It also mocks Git calls through `eliza.runtime` and verifies repo info, status, branches, log, and operation history update Surface state.
+
+It also mocks model calls through `eliza.runtime` and verifies Eliza-1 catalog, tier, voice, active model, and download state update Surface state.
+
+## Module Manager Compatibility
+
+The current upstream module system still uses packaging names such as `plugin.json`, `build.remote plugin`, and `remote pluginOnly`. Those names remain only at the packaging boundary.
+
+The Surface manifest uses:
+
+- ID: `eliza.surface`
+- Dependency: `eliza.runtime`
+- Mode: `window`
+- Permission: `host:manage-remote-plugins`
+
+`host:manage-remote-plugins` is required by the existing module host for cross-Remote calls through the upstream `invoke-remote-plugin` host request. No filesystem, shell, Git, model-download, or child-process permission is requested by Surface.
+
+The Surface worker implements that module call path. The current host does not expose a completed public view-to-Remote-worker RPC for window-mode Remotes, so the browser UI uses `RuntimeRemoteClient` and can run against a host-provided bridge when available or the smoke-test mock bridge in Phase 4.
+
+## Runtime Dependency
+
+Start or install `eliza.runtime` before using this Surface Remote. The UI calls the Runtime Remote through `RuntimeRemoteClient`; it does not call elizaOS local HTTP routes directly.
+
+## File Panel
+
+The File panel calls Runtime Remote `fs.*` methods only:
+
+```text
+eliza.surface -> eliza.runtime -> eliza.fs
+```
+
+It can load roots, list a scoped directory, read text, search text, and send a gated write request. The write button is disabled until the user enables it in the panel, and `eliza.fs` still rejects writes unless `ELIZA_FS_ENABLE_WRITES=1`.
+
+## Terminal Panel
+
+The Terminal panel calls Runtime Remote `pty.*` methods only:
+
+```text
+eliza.surface -> eliza.runtime -> eliza.pty
+```
+
+It can create a trusted local terminal session, list sessions, tail output, send input, resize, clear output, and kill the active session. The panel does not call `eliza.pty` directly and does not call local process APIs.
+
+## Git Panel
+
+The Git panel calls Runtime Remote `git.*` methods only:
+
+```text
+eliza.surface -> eliza.runtime -> eliza.git
+```
+
+It can inspect repo info, status, branches, remotes, log, diff, and show output. It can also invoke add, restore, checkout, branch create/delete, commit, fetch, pull, and push through the Runtime broker. Operation output is shown through the operation list/detail area. The panel does not call `eliza.git` directly and does not call local Git or process APIs.
+
+## Model Panel
+
+The Model panel calls Runtime Remote `model.*` methods only:
+
+```text
+eliza.surface -> eliza.runtime -> eliza.local-model
+```
+
+It can show the Eliza-1 hub, catalog, HF metadata, tiers, voice components, hardware, providers, installed models, downloads, active model, assignments, and routing. It can request activation, unload, download, cancel download, local/cloud routing, direct generation, and embedding through the Runtime broker. The panel does not call `eliza.local-model`, Hugging Face, local inference routes, or local process APIs directly.
+
+## Event Subscription Status
+
+The existing host supports worker-to-worker request routing and targeted event emission, but Runtime Remote events are not automatically broadcast to `eliza.surface` windows today. The Surface client subscribes to runtime events when the bridge provides them and also polls `runtime.status` and `runtime.logs.tail` as a fallback.
+
+Phase 5 or a later host pass should add a small event-forwarding hook if true cross-Remote push events are required.
+
+## Known Limitations
+
+- This is a Phase 4 control UI, not the production dashboard migration.
+- Cross-Remote event push depends on host support or a Runtime Remote forwarding hook.
+- File panel requests require `eliza.runtime` and `eliza.fs` to be running.
+- Terminal panel requests require `eliza.runtime` and `eliza.pty` to be running.
+- Git panel requests require `eliza.runtime` and `eliza.git` to be running.
+- Model panel requests require `eliza.runtime` and `eliza.local-model` to be running.
+- The UI is intentionally vanilla TypeScript to keep the Remote boundary clear.
+- No Swift or MLX work is included.

package/platforms/electrobun/remotes/surface/electrobun.config.ts

@@ -0,0 +1,38 @@
+const surfaceRemote = {
+  id: "eliza.surface",
+  name: "Eliza Surface",
+  version: "0.1.0",
+  description:
+    "Surface Remote for ElizaLaunch. Provides a control and chat UI backed by eliza.runtime.",
+  mode: "window",
+  permissions: {
+    host: {
+      "manage-remote-plugins": true,
+    },
+    bun: {},
+    isolation: "shared-worker",
+  },
+  view: {
+    relativePath: "src/web/index.html",
+    title: "Eliza Surface Remote",
+    width: 1280,
+    height: 860,
+    titleBarStyle: "hiddenInset",
+    transparent: false,
+  },
+  worker: {
+    relativePath: "src/bun/worker.ts",
+  },
+} as const;
+
+export default {
+  app: {
+    name: "Eliza Surface Remote",
+    identifier: "ai.eliza.launch.surface",
+    version: "0.1.0",
+  },
+  build: {
+    carrot: surfaceRemote,
+    carrotOnly: true,
+  },
+};

package/platforms/electrobun/remotes/surface/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@elizalaunch/surface-remote",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "build": "bun build src/bun/worker.ts src/dev/phase4-smoke.ts --outdir dist --target bun && bun build src/web/index.ts --outdir dist/web --target browser",
+    "smoke": "bun run src/dev/phase4-smoke.ts",
+    "smoke:phase4": "bun run src/dev/phase4-smoke.ts",
+    "typecheck": "tsc --ignoreConfig --noEmit --target ES2022 --module ESNext --moduleResolution Bundler --lib ES2022,DOM,DOM.Iterable --types bun-types --allowImportingTsExtensions src/protocol/event-types.ts src/protocol/runtime-client.ts src/web/state.ts src/web/render.ts src/web/app.ts src/web/index.ts src/bun/worker.ts src/dev/phase4-smoke.ts"
+  }
+}

package/platforms/electrobun/remotes/surface/plugin.json

@@ -0,0 +1,28 @@
+{
+  "id": "eliza.surface",
+  "name": "Eliza Surface",
+  "version": "0.1.0",
+  "description": "Surface Remote for ElizaLaunch. Provides a control and chat UI backed by eliza.runtime.",
+  "mode": "window",
+  "dependencies": {
+    "eliza.runtime": "file:../runtime"
+  },
+  "permissions": {
+    "host": {
+      "manage-remote-plugins": true
+    },
+    "bun": {},
+    "isolation": "shared-worker"
+  },
+  "view": {
+    "relativePath": "src/web/index.html",
+    "title": "Eliza Surface Remote",
+    "width": 1280,
+    "height": 860,
+    "titleBarStyle": "hiddenInset",
+    "transparent": false
+  },
+  "worker": {
+    "relativePath": "src/bun/worker.ts"
+  }
+}

package/platforms/electrobun/remotes/surface/src/bun/worker.ts

@@ -0,0 +1,132 @@
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | { [key: string]: JsonValue } | JsonValue[];
+
+type WorkerRequest = {
+  type: "request";
+  requestId: string | number;
+  method: string;
+  params?: JsonValue;
+};
+
+type HostResponse = {
+  type: "host-response";
+  requestId: number;
+  success: boolean;
+  payload?: JsonValue;
+  error?: string;
+};
+
+type PendingHostRequest = {
+  resolve: (payload: JsonValue | undefined) => void;
+  reject: (error: Error) => void;
+};
+
+const RUNTIME_REMOTE_PLUGIN_ID = "eliza.runtime";
+const pending = new Map<number, PendingHostRequest>();
+let nextHostRequestId = 1;
+
+self.onmessage = (event: MessageEvent) => {
+  const message = event.data;
+  if (isHostResponse(message)) {
+    completeHostRequest(message);
+    return;
+  }
+  if (isWorkerRequest(message)) {
+    void handleRequest(message);
+  }
+};
+
+post({ type: "ready" });
+
+async function handleRequest(message: WorkerRequest): Promise<void> {
+  try {
+    const payload = await invokeRuntime(message.method, message.params);
+    post({
+      type: "response",
+      requestId: message.requestId,
+      success: true,
+      payload,
+    });
+  } catch (error) {
+    post({
+      type: "response",
+      requestId: message.requestId,
+      success: false,
+      error: error instanceof Error ? error.message : "Surface worker failed.",
+    });
+  }
+}
+
+function invokeRuntime(
+  method: string,
+  params?: JsonValue,
+): Promise<JsonValue | undefined> {
+  const requestId = nextHostRequestId++;
+  post({
+    type: "host-request",
+    requestId,
+    method: "invoke-remote-plugin",
+    params: {
+      remotePluginId: RUNTIME_REMOTE_PLUGIN_ID,
+      method,
+      params,
+    },
+  });
+
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      pending.delete(requestId);
+      reject(new Error(`Runtime RemotePlugin request timed out: ${method}`));
+    }, 30_000);
+    pending.set(requestId, {
+      resolve: (payload) => {
+        clearTimeout(timeout);
+        resolve(payload);
+      },
+      reject: (error) => {
+        clearTimeout(timeout);
+        reject(error);
+      },
+    });
+  });
+}
+
+function completeHostRequest(message: HostResponse): void {
+  const request = pending.get(message.requestId);
+  if (!request) return;
+  pending.delete(message.requestId);
+  if (message.success) {
+    request.resolve(message.payload);
+    return;
+  }
+  request.reject(
+    new Error(message.error ?? "Runtime RemotePlugin request failed."),
+  );
+}
+
+function isWorkerRequest(value: unknown): value is WorkerRequest {
+  if (!isRecord(value)) return false;
+  return (
+    value.type === "request" &&
+    (typeof value.requestId === "string" ||
+      typeof value.requestId === "number") &&
+    typeof value.method === "string"
+  );
+}
+
+function isHostResponse(value: unknown): value is HostResponse {
+  if (!isRecord(value)) return false;
+  return (
+    value.type === "host-response" &&
+    typeof value.requestId === "number" &&
+    typeof value.success === "boolean"
+  );
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function post(message: unknown): void {
+  self.postMessage(message);
+}