flawed-avatar 0.2.1

package/src/main/gateway-client.ts

@@ -0,0 +1,312 @@
+import WebSocket from "ws";
+import { randomUUID } from "node:crypto";
+import { GATEWAY_RECONNECT_BASE_MS, GATEWAY_RECONNECT_MAX_MS } from "../shared/config.js";
+import type { AgentState } from "../shared/types.js";
+
+const PROTOCOL_VERSION = 3;
+
+type AgentEventPayload = {
+	runId: string;
+	seq: number;
+	stream: string;
+	ts: number;
+	data: Record<string, unknown>;
+	sessionKey?: string;
+};
+
+type EventFrame = {
+	type: "event";
+	event: string;
+	payload?: unknown;
+	seq?: number;
+};
+
+type ResponseFrame = {
+	type: "res";
+	id: string;
+	ok: boolean;
+	payload?: unknown;
+	error?: { message?: string };
+};
+
+/**
+ * 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: string,
+	onStateChange: (state: AgentState) => void,
+	onModelSwitch: (vrmPath: string) => void,
+	agentConfigs?: Record<string, { vrmPath?: string }>,
+	authToken?: string,
+): { destroy: () => void; sendChat: (text: string, sessionKey: string | null) => void; getCurrentAgentId: () => string | null } {
+	let ws: WebSocket | null = null;
+	let destroyed = false;
+	let backoffMs = GATEWAY_RECONNECT_BASE_MS;
+	let reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+	let connectNonce: string | null = null;
+	let connectSent = false;
+	let connectTimer: ReturnType<typeof setTimeout> | null = null;
+	let currentSessionKey: string | null = null;
+	// Track pending request IDs to match responses
+	let sessionsListRequestId: string | null = null;
+	let agentsListRequestId: string | null = null;
+	// Track if we've completed initial connection setup
+	let connectionSetupDone = false;
+
+	function processAgentEvent(evt: AgentEventPayload): void {
+		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: string): void {
+		try {
+			const parsed = JSON.parse(raw);
+
+			// Event frames
+			if (parsed?.type === "event") {
+				const evt = parsed as EventFrame;
+
+				// Handle connect challenge: gateway sends a nonce before we send connect
+				if (evt.event === "connect.challenge") {
+					const payload = evt.payload as { nonce?: string } | undefined;
+					if (payload?.nonce) {
+						connectNonce = payload.nonce;
+						sendConnect();
+					}
+					return;
+				}
+
+				// Agent events drive the avatar
+				if (evt.event === "agent" && evt.payload) {
+					processAgentEvent(evt.payload as AgentEventPayload);
+				}
+				return;
+			}
+
+			// Response frames (for our connect request, sessions list, or agents list)
+			if (parsed?.type === "res") {
+				const res = parsed as ResponseFrame;
+				if (res.ok) {
+					const payload = res.payload as Record<string, unknown> | undefined;
+
+					// Check if this is a sessions.list response
+					if (res.id === sessionsListRequestId && payload?.sessions && Array.isArray(payload.sessions)) {
+						sessionsListRequestId = null;
+						const sessions = payload.sessions as Array<{ key?: string; updatedAt?: number; displayName?: string }>;
+						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 as Array<Record<string, unknown>>;
+						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(): void {
+		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(): void {
+		connectNonce = null;
+		connectSent = false;
+		connectionSetupDone = false; // Reset for new connection
+		if (connectTimer) clearTimeout(connectTimer);
+		connectTimer = setTimeout(() => sendConnect(), 750);
+	}
+
+	function requestSessionsList(): void {
+		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(): void {
+		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(): void {
+		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(): void {
+		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: string, sessionKey: string | null) {
+			// 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/src/main/main.ts

@@ -0,0 +1,169 @@
+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, type StdinCommand } 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, saveVrmModelPath } from "./persistence/index.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Parse CLI args
+function getCliArg(prefix: string): string | undefined {
+	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(): string | undefined {
+	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: Record<string, { vrmPath?: string }> | undefined;
+if (cliAgentConfigs) {
+	try {
+		const parsed: unknown = JSON.parse(cliAgentConfigs);
+		if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+			const safe: Record<string, { vrmPath?: string }> = Object.create(null);
+			for (const [key, val] of Object.entries(parsed as Record<string, unknown>)) {
+				if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+				if (typeof val === "object" && val !== null) {
+					const v = val as Record<string, unknown>;
+					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"] as const;
+		const clips: Record<string, string[]> = {};
+
+		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 is string => f !== null);
+			} catch {
+				clips[phase] = [];
+			}
+		}
+		return { clips };
+	});
+
+	// Stdin listener for commands from the plugin service
+	const cleanupStdin = createStdinListener((cmd: StdinCommand) => {
+		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: unknown) => {
+		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/src/main/persistence/chat-store.ts

@@ -0,0 +1,143 @@
+import {
+	CHAT_HISTORY_FILE,
+	CHAT_MAX_HISTORY,
+	CHAT_DEBOUNCE_MS,
+	APPEND_QUEUE_FLUSH_MS,
+} from "../../shared/config.js";
+import { createFileStore, type FileStore } from "./file-store.js";
+import {
+	ChatHistorySchema,
+	createDefaultChatHistory,
+	type ChatHistory,
+	type ChatMessage,
+} from "./types.js";
+
+let store: FileStore<ChatHistory> | null = null;
+let appendQueue: ChatMessage[] = [];
+let appendTimeout: ReturnType<typeof setTimeout> | null = null;
+
+function getStore(): FileStore<ChatHistory> {
+	if (!store) {
+		store = createFileStore({
+			filename: CHAT_HISTORY_FILE,
+			schema: ChatHistorySchema,
+			defaultValue: createDefaultChatHistory,
+			debounceMs: CHAT_DEBOUNCE_MS,
+		});
+	}
+	return store;
+}
+
+function generateId(): string {
+	// Simple unique ID: timestamp + random hex
+	return `${Date.now()}-${Math.random().toString(16).slice(2, 10)}`;
+}
+
+function flushAppendQueue(): void {
+	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: ChatHistory = {
+		...current,
+		messages: pruned,
+		lastUpdated: Date.now(),
+	};
+
+	getStore().save(updated);
+	appendQueue = [];
+}
+
+export function loadChatHistory(): ChatHistory {
+	const result = getStore().load();
+	return result.ok ? result.data : result.fallback;
+}
+
+export function appendMessage(
+	role: "user" | "assistant",
+	text: string,
+	agentId?: string,
+): ChatMessage {
+	const message: ChatMessage = {
+		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(): void {
+	// Clear pending queue
+	appendQueue = [];
+	if (appendTimeout) {
+		clearTimeout(appendTimeout);
+		appendTimeout = null;
+	}
+
+	// Save empty history
+	const empty = createDefaultChatHistory();
+	getStore().save(empty);
+}
+
+export function getRecentMessages(limit: number = 50): ChatMessage[] {
+	// 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(): ChatHistory {
+	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(): Promise<void> {
+	// Flush append queue first
+	if (appendTimeout) {
+		clearTimeout(appendTimeout);
+		appendTimeout = null;
+	}
+	flushAppendQueue();
+
+	// Then flush store
+	await getStore().flush();
+}
+
+export function cleanupChat(): void {
+	if (appendTimeout) {
+		clearTimeout(appendTimeout);
+		appendTimeout = null;
+	}
+	// Synchronously flush queue
+	if (appendQueue.length > 0) {
+		flushAppendQueue();
+	}
+	getStore().cleanup();
+}