flawed-avatar 0.2.1

package/dist/main/main/gateway-client.js

@@ -0,0 +1,265 @@
+import WebSocket from "ws";
+import { randomUUID } from "node:crypto";
+import { GATEWAY_RECONNECT_BASE_MS, GATEWAY_RECONNECT_MAX_MS } from "../shared/config.js";
+const PROTOCOL_VERSION = 3;
+/**
+ * Lightweight gateway WebSocket client for the Electron main process.
+ * Implements the minimal protocol v3 handshake (without device auth)
+ * and listens for "agent" event frames to drive avatar animations.
+ */
+export function createGatewayClient(gatewayUrl, onStateChange, onModelSwitch, agentConfigs, authToken) {
+    let ws = null;
+    let destroyed = false;
+    let backoffMs = GATEWAY_RECONNECT_BASE_MS;
+    let reconnectTimer = null;
+    let connectNonce = null;
+    let connectSent = false;
+    let connectTimer = null;
+    let currentSessionKey = null;
+    // Track pending request IDs to match responses
+    let sessionsListRequestId = null;
+    let agentsListRequestId = null;
+    // Track if we've completed initial connection setup
+    let connectionSetupDone = false;
+    function processAgentEvent(evt) {
+        const { stream, data, sessionKey } = evt;
+        // Track session changes - agent events contain the actual sessionKey
+        if (sessionKey && sessionKey !== currentSessionKey) {
+            console.log("flawed-avatar: setting currentSessionKey from agent event:", sessionKey);
+            currentSessionKey = sessionKey;
+            if (agentConfigs?.[sessionKey]?.vrmPath) {
+                onModelSwitch(agentConfigs[sessionKey].vrmPath);
+            }
+        }
+        if (stream === "lifecycle") {
+            const phase = data?.phase;
+            if (phase === "start") {
+                onStateChange({ phase: "thinking", agentId: sessionKey });
+            }
+            else if (phase === "end" || phase === "error") {
+                onStateChange({ phase: "idle", agentId: sessionKey });
+            }
+        }
+        else if (stream === "assistant") {
+            const text = typeof data?.text === "string" ? data.text : undefined;
+            onStateChange({ phase: "speaking", text, agentId: sessionKey });
+        }
+        else if (stream === "tool") {
+            onStateChange({ phase: "working", agentId: sessionKey });
+        }
+        else if (stream === "error") {
+            onStateChange({ phase: "idle", agentId: sessionKey });
+        }
+    }
+    function handleMessage(raw) {
+        try {
+            const parsed = JSON.parse(raw);
+            // Event frames
+            if (parsed?.type === "event") {
+                const evt = parsed;
+                // Handle connect challenge: gateway sends a nonce before we send connect
+                if (evt.event === "connect.challenge") {
+                    const payload = evt.payload;
+                    if (payload?.nonce) {
+                        connectNonce = payload.nonce;
+                        sendConnect();
+                    }
+                    return;
+                }
+                // Agent events drive the avatar
+                if (evt.event === "agent" && evt.payload) {
+                    processAgentEvent(evt.payload);
+                }
+                return;
+            }
+            // Response frames (for our connect request, sessions list, or agents list)
+            if (parsed?.type === "res") {
+                const res = parsed;
+                if (res.ok) {
+                    const payload = res.payload;
+                    // Check if this is a sessions.list response
+                    if (res.id === sessionsListRequestId && payload?.sessions && Array.isArray(payload.sessions)) {
+                        sessionsListRequestId = null;
+                        const sessions = payload.sessions;
+                        if (sessions.length > 0 && !currentSessionKey) {
+                            // Use the most recently active session (sessions are sorted by activity)
+                            const firstSession = sessions[0];
+                            if (firstSession.key) {
+                                currentSessionKey = firstSession.key;
+                                console.log("flawed-avatar: auto-detected session from sessions.list:", currentSessionKey, "displayName:", firstSession.displayName);
+                            }
+                        }
+                    }
+                    // Check if this is an agents list response (fallback)
+                    if (res.id === agentsListRequestId && payload?.agents && Array.isArray(payload.agents)) {
+                        agentsListRequestId = null;
+                        const agents = payload.agents;
+                        if (agents.length > 0 && !currentSessionKey) {
+                            // Use first agent's main session key as fallback
+                            const firstAgent = agents[0];
+                            const agentId = firstAgent.id ?? "main";
+                            const sessionKey = `agent:${agentId}:main`;
+                            currentSessionKey = sessionKey;
+                            console.log("flawed-avatar: fallback to agent main session:", currentSessionKey);
+                        }
+                    }
+                    // Connect success - request active sessions once
+                    if (connectSent && !connectionSetupDone && !sessionsListRequestId && !agentsListRequestId) {
+                        connectionSetupDone = true;
+                        console.log("flawed-avatar: gateway connected successfully");
+                        backoffMs = GATEWAY_RECONNECT_BASE_MS;
+                        // Request recently active sessions
+                        requestSessionsList();
+                    }
+                }
+                else {
+                    console.error("flawed-avatar: gateway response error:", res.error?.message ?? "unknown");
+                    // If sessions.list failed, fall back to agents.list
+                    if (res.id === sessionsListRequestId) {
+                        sessionsListRequestId = null;
+                        if (!currentSessionKey) {
+                            requestAgentsList();
+                        }
+                    }
+                }
+            }
+        }
+        catch (err) {
+            console.warn("flawed-avatar: failed to parse gateway message:", err);
+        }
+    }
+    function sendConnect() {
+        if (connectSent || !ws || ws.readyState !== WebSocket.OPEN)
+            return;
+        connectSent = true;
+        if (connectTimer) {
+            clearTimeout(connectTimer);
+            connectTimer = null;
+        }
+        const frame = {
+            type: "req",
+            id: randomUUID(),
+            method: "connect",
+            params: {
+                minProtocol: PROTOCOL_VERSION,
+                maxProtocol: PROTOCOL_VERSION,
+                client: {
+                    id: "gateway-client",
+                    displayName: "Flawed Avatar",
+                    version: "0.1.0",
+                    platform: process.platform,
+                    mode: "backend",
+                },
+                caps: [],
+                role: "operator",
+                scopes: ["operator.admin"],
+                auth: authToken ? { token: authToken } : {},
+            },
+        };
+        ws.send(JSON.stringify(frame));
+    }
+    function queueConnect() {
+        connectNonce = null;
+        connectSent = false;
+        connectionSetupDone = false; // Reset for new connection
+        if (connectTimer)
+            clearTimeout(connectTimer);
+        connectTimer = setTimeout(() => sendConnect(), 750);
+    }
+    function requestSessionsList() {
+        if (!ws || ws.readyState !== WebSocket.OPEN)
+            return;
+        sessionsListRequestId = randomUUID();
+        const frame = {
+            type: "req",
+            id: sessionsListRequestId,
+            method: "sessions.list",
+            params: {
+                // Get recently active sessions (within last 60 minutes)
+                activeMinutes: 60,
+                includeGlobal: false,
+                includeUnknown: false,
+                limit: 10,
+            },
+        };
+        console.log("flawed-avatar: requesting sessions list");
+        ws.send(JSON.stringify(frame));
+    }
+    function requestAgentsList() {
+        if (!ws || ws.readyState !== WebSocket.OPEN)
+            return;
+        agentsListRequestId = randomUUID();
+        const frame = {
+            type: "req",
+            id: agentsListRequestId,
+            method: "agents.list",
+            params: {},
+        };
+        console.log("flawed-avatar: requesting agents list (fallback)");
+        ws.send(JSON.stringify(frame));
+    }
+    function connect() {
+        if (destroyed)
+            return;
+        ws = new WebSocket(gatewayUrl, { maxPayload: 25 * 1024 * 1024 });
+        ws.on("open", () => {
+            console.log("flawed-avatar: ws open, sending connect frame");
+            queueConnect();
+        });
+        ws.on("message", (data) => {
+            const raw = typeof data === "string" ? data : data.toString();
+            handleMessage(raw);
+        });
+        ws.on("close", (code, reason) => {
+            console.log(`flawed-avatar: ws closed (code=${code}, reason=${reason?.toString() ?? ""})`);
+            ws = null;
+            scheduleReconnect();
+        });
+        ws.on("error", (err) => {
+            console.error("flawed-avatar: gateway connection error:", err.message);
+        });
+    }
+    function scheduleReconnect() {
+        if (destroyed)
+            return;
+        const delay = backoffMs;
+        backoffMs = Math.min(backoffMs * 2, GATEWAY_RECONNECT_MAX_MS);
+        reconnectTimer = setTimeout(() => connect(), delay);
+    }
+    // Start the initial connection
+    connect();
+    return {
+        destroy() {
+            destroyed = true;
+            if (reconnectTimer)
+                clearTimeout(reconnectTimer);
+            if (connectTimer)
+                clearTimeout(connectTimer);
+            if (ws) {
+                ws.removeAllListeners();
+                ws.close();
+                ws = null;
+            }
+        },
+        sendChat(text, sessionKey) {
+            // Use provided sessionKey, or fall back to auto-detected session, or default
+            const effectiveSessionKey = sessionKey ?? currentSessionKey ?? "agent:main:main";
+            if (!ws || ws.readyState !== WebSocket.OPEN)
+                return;
+            const frame = {
+                type: "req",
+                id: randomUUID(),
+                method: "chat.send",
+                params: {
+                    sessionKey: effectiveSessionKey,
+                    message: text,
+                    idempotencyKey: randomUUID(),
+                },
+            };
+            ws.send(JSON.stringify(frame));
+        },
+        getCurrentAgentId() {
+            return currentSessionKey;
+        },
+    };
+}

package/dist/main/main/main.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/main/main/main.js

@@ -0,0 +1,157 @@
+import { app, ipcMain } from "electron";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { fileURLToPath } from "node:url";
+import { createWindowManager } from "./window-manager.js";
+import { createTray } from "./tray.js";
+import { createStdinListener } from "./stdin-listener.js";
+import { createGatewayClient } from "./gateway-client.js";
+import { IPC } from "../shared/ipc-channels.js";
+import { GATEWAY_URL_DEFAULT, CHAT_INPUT_MAX_LENGTH } from "../shared/config.js";
+import { getVrmModelPath } from "./persistence/index.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Parse CLI args
+function getCliArg(prefix) {
+    for (const arg of process.argv) {
+        if (arg.startsWith(prefix)) {
+            return arg.slice(prefix.length);
+        }
+    }
+    return undefined;
+}
+const cliGatewayUrl = getCliArg("--gateway-url=");
+const cliVrmPath = getCliArg("--vrm-path=");
+const cliAgentConfigs = getCliArg("--agent-configs=");
+const cliAuthToken = getCliArg("--auth-token=");
+// Resolve auth token: CLI arg > env var > openclaw.json
+function resolveAuthToken() {
+    if (cliAuthToken)
+        return cliAuthToken;
+    if (process.env.OPENCLAW_GATEWAY_TOKEN)
+        return process.env.OPENCLAW_GATEWAY_TOKEN;
+    try {
+        const configPath = path.join(os.homedir(), ".openclaw", "openclaw.json");
+        const raw = fs.readFileSync(configPath, "utf-8");
+        const config = JSON.parse(raw);
+        const token = config?.gateway?.auth?.token;
+        if (typeof token === "string" && token.length > 0)
+            return token;
+    }
+    catch {
+        // No config or unreadable
+    }
+    return undefined;
+}
+// Parse per-agent VRM configs if provided (with prototype pollution protection)
+let agentConfigs;
+if (cliAgentConfigs) {
+    try {
+        const parsed = JSON.parse(cliAgentConfigs);
+        if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+            const safe = Object.create(null);
+            for (const [key, val] of Object.entries(parsed)) {
+                if (key === "__proto__" || key === "constructor" || key === "prototype")
+                    continue;
+                if (typeof val === "object" && val !== null) {
+                    const v = val;
+                    safe[key] = { vrmPath: typeof v.vrmPath === "string" ? v.vrmPath : undefined };
+                }
+            }
+            agentConfigs = safe;
+        }
+    }
+    catch {
+        // Ignore malformed JSON
+    }
+}
+// Prevent multiple instances
+const gotLock = app.requestSingleInstanceLock();
+if (!gotLock) {
+    app.quit();
+}
+app.whenReady().then(() => {
+    const wm = createWindowManager();
+    createTray(wm);
+    // Return VRM model path (CLI override > persisted > default)
+    const defaultVrmPath = path.join(__dirname, "..", "..", "..", "assets", "models", "default-avatar.vrm");
+    ipcMain.handle(IPC.GET_VRM_PATH, () => {
+        if (cliVrmPath)
+            return cliVrmPath;
+        const persisted = getVrmModelPath();
+        if (persisted && fs.existsSync(persisted))
+            return persisted;
+        return defaultVrmPath;
+    });
+    // Return animation clip paths from assets/animations/{phase}/ directories
+    ipcMain.handle(IPC.GET_ANIMATIONS_CONFIG, () => {
+        const animBase = path.resolve(__dirname, "..", "..", "..", "assets", "animations");
+        const phases = ["idle", "thinking", "speaking", "working"];
+        const clips = {};
+        for (const phase of phases) {
+            const dir = path.join(animBase, phase);
+            try {
+                clips[phase] = fs.readdirSync(dir)
+                    .filter(f => f.toLowerCase().endsWith(".fbx"))
+                    .filter(f => !/[\\\/]/.test(f))
+                    .map(f => {
+                    const full = fs.realpathSync(path.join(dir, f));
+                    if (!full.replace(/\\/g, "/").startsWith(animBase.replace(/\\/g, "/"))) {
+                        return null;
+                    }
+                    return full;
+                })
+                    .filter((f) => f !== null);
+            }
+            catch {
+                clips[phase] = [];
+            }
+        }
+        return { clips };
+    });
+    // Stdin listener for commands from the plugin service
+    const cleanupStdin = createStdinListener((cmd) => {
+        switch (cmd.type) {
+            case "show":
+                wm.showAvatar();
+                break;
+            case "hide":
+                wm.hideAll();
+                break;
+            case "shutdown":
+                app.quit();
+                break;
+            case "model-switch":
+                wm.sendToAvatar(IPC.VRM_MODEL_CHANGED, cmd.vrmPath);
+                break;
+        }
+    });
+    // Connect to gateway WebSocket for agent event streaming
+    const gatewayUrl = cliGatewayUrl ?? GATEWAY_URL_DEFAULT;
+    const authToken = resolveAuthToken();
+    console.log(`flawed-avatar: connecting to ${gatewayUrl} (auth=${authToken ? "token" : "none"})`);
+    const gw = createGatewayClient(gatewayUrl, (state) => wm.sendAgentState(state), (vrmPath) => wm.sendToAvatar(IPC.VRM_MODEL_CHANGED, vrmPath), agentConfigs, authToken);
+    // IPC: send chat message to active agent
+    ipcMain.on(IPC.SEND_CHAT, (_event, text) => {
+        console.log("flawed-avatar: SEND_CHAT received:", text);
+        if (typeof text !== "string" || text.trim().length === 0 || text.length > CHAT_INPUT_MAX_LENGTH) {
+            console.log("flawed-avatar: SEND_CHAT rejected (validation failed)");
+            return;
+        }
+        const agentId = gw.getCurrentAgentId();
+        console.log("flawed-avatar: current agentId:", agentId);
+        console.log("flawed-avatar: sending chat to gateway");
+        gw.sendChat(text.trim(), agentId);
+    });
+    // Clean up resources on quit
+    app.on("before-quit", () => {
+        gw.destroy();
+        cleanupStdin();
+        wm.destroyAll();
+    });
+});
+// Keep app alive when all windows are closed (tray stays)
+app.on("window-all-closed", () => {
+    // no-op: tray keeps the app alive
+});

package/dist/main/main/persistence/chat-store.d.ts

@@ -0,0 +1,8 @@
+import { type ChatHistory, type ChatMessage } from "./types.js";
+export declare function loadChatHistory(): ChatHistory;
+export declare function appendMessage(role: "user" | "assistant", text: string, agentId?: string): ChatMessage;
+export declare function clearChatHistory(): void;
+export declare function getRecentMessages(limit?: number): ChatMessage[];
+export declare function getChatHistory(): ChatHistory;
+export declare function flushChat(): Promise<void>;
+export declare function cleanupChat(): void;

package/dist/main/main/persistence/chat-store.js

@@ -0,0 +1,110 @@
+import { CHAT_HISTORY_FILE, CHAT_MAX_HISTORY, CHAT_DEBOUNCE_MS, APPEND_QUEUE_FLUSH_MS, } from "../../shared/config.js";
+import { createFileStore } from "./file-store.js";
+import { ChatHistorySchema, createDefaultChatHistory, } from "./types.js";
+let store = null;
+let appendQueue = [];
+let appendTimeout = null;
+function getStore() {
+    if (!store) {
+        store = createFileStore({
+            filename: CHAT_HISTORY_FILE,
+            schema: ChatHistorySchema,
+            defaultValue: createDefaultChatHistory,
+            debounceMs: CHAT_DEBOUNCE_MS,
+        });
+    }
+    return store;
+}
+function generateId() {
+    // Simple unique ID: timestamp + random hex
+    return `${Date.now()}-${Math.random().toString(16).slice(2, 10)}`;
+}
+function flushAppendQueue() {
+    if (appendQueue.length === 0)
+        return;
+    const current = getStore().getCache() ?? loadChatHistory();
+    const messages = [...current.messages, ...appendQueue];
+    // Prune if over limit
+    const pruned = messages.length > CHAT_MAX_HISTORY
+        ? messages.slice(-CHAT_MAX_HISTORY)
+        : messages;
+    const updated = {
+        ...current,
+        messages: pruned,
+        lastUpdated: Date.now(),
+    };
+    getStore().save(updated);
+    appendQueue = [];
+}
+export function loadChatHistory() {
+    const result = getStore().load();
+    return result.ok ? result.data : result.fallback;
+}
+export function appendMessage(role, text, agentId) {
+    const message = {
+        id: generateId(),
+        timestamp: Date.now(),
+        role,
+        text,
+        agentId,
+    };
+    appendQueue.push(message);
+    // Coalesce rapid appends
+    if (appendTimeout) {
+        clearTimeout(appendTimeout);
+    }
+    appendTimeout = setTimeout(() => {
+        appendTimeout = null;
+        flushAppendQueue();
+    }, APPEND_QUEUE_FLUSH_MS);
+    return message;
+}
+export function clearChatHistory() {
+    // Clear pending queue
+    appendQueue = [];
+    if (appendTimeout) {
+        clearTimeout(appendTimeout);
+        appendTimeout = null;
+    }
+    // Save empty history
+    const empty = createDefaultChatHistory();
+    getStore().save(empty);
+}
+export function getRecentMessages(limit = 50) {
+    // First, include any pending messages not yet flushed
+    const current = getStore().getCache() ?? loadChatHistory();
+    const allMessages = [...current.messages, ...appendQueue];
+    return allMessages.slice(-limit);
+}
+export function getChatHistory() {
+    const current = getStore().getCache() ?? loadChatHistory();
+    // Include pending queue in response
+    if (appendQueue.length > 0) {
+        return {
+            ...current,
+            messages: [...current.messages, ...appendQueue],
+        };
+    }
+    return current;
+}
+export async function flushChat() {
+    // Flush append queue first
+    if (appendTimeout) {
+        clearTimeout(appendTimeout);
+        appendTimeout = null;
+    }
+    flushAppendQueue();
+    // Then flush store
+    await getStore().flush();
+}
+export function cleanupChat() {
+    if (appendTimeout) {
+        clearTimeout(appendTimeout);
+        appendTimeout = null;
+    }
+    // Synchronously flush queue
+    if (appendQueue.length > 0) {
+        flushAppendQueue();
+    }
+    getStore().cleanup();
+}

package/dist/main/main/persistence/file-store.d.ts

@@ -0,0 +1,17 @@
+import type { z } from "zod";
+import type { LoadResult } from "./types.js";
+export interface StoreOptions<T> {
+    filename: string;
+    schema: z.ZodType<T>;
+    defaultValue: () => T;
+    debounceMs?: number;
+}
+export interface FileStore<T> {
+    load(): LoadResult<T>;
+    save(data: T): void;
+    flush(): Promise<void>;
+    getCache(): T | null;
+    cleanup(): void;
+}
+export declare function createFileStore<T>(options: StoreOptions<T>): FileStore<T>;
+export declare function getOpenclawDir(): string;