flawed-avatar 0.2.1

package/src/main/settings-preload.cjs

@@ -0,0 +1,153 @@
+// Channel strings duplicated from src/shared/ipc-channels.ts (CJS cannot import ESM).
+// Keep both files in sync when adding/renaming channels.
+const { contextBridge, ipcRenderer } = require("electron");
+
+const IPC = {
+	// Settings window lifecycle
+	CLOSE_SETTINGS: "settings:close",
+	PICK_VRM_FILE: "settings:pick-vrm-file",
+	// Full settings bundle
+	GET_SETTINGS: "avatar:get-settings",
+	// Opacity
+	SET_OPACITY: "avatar:set-opacity",
+	OPACITY_CHANGED: "avatar:opacity-changed",
+	// Scale
+	SET_SCALE: "avatar:set-scale",
+	SCALE_CHANGED: "avatar:scale-changed",
+	// Camera
+	SET_CAMERA_ZOOM: "avatar:set-camera-zoom",
+	SAVE_CAMERA_ZOOM: "avatar:save-camera-zoom",
+	// TTS
+	SET_TTS_ENABLED: "avatar:tts-set-enabled",
+	TTS_ENABLED_CHANGED: "avatar:tts-enabled-changed",
+	SET_TTS_ENGINE: "avatar:tts-set-engine",
+	TTS_ENGINE_CHANGED: "avatar:tts-engine-changed",
+	SET_TTS_VOICE: "avatar:tts-set-voice",
+	TTS_VOICE_CHANGED: "avatar:tts-voice-changed",
+	// Idle timeout
+	SET_IDLE_TIMEOUT: "chat:set-idle-timeout",
+	IDLE_TIMEOUT_CHANGED: "chat:idle-timeout-changed",
+	// Lighting
+	SET_LIGHTING_PROFILE: "avatar:set-lighting-profile",
+	LIGHTING_PROFILE_CHANGED: "avatar:lighting-profile-changed",
+	SET_LIGHTING_CUSTOM: "avatar:set-lighting-custom",
+	LIGHTING_CUSTOM_CHANGED: "avatar:lighting-custom-changed",
+	// VRM model
+	VRM_MODEL_CHANGED: "avatar:vrm-model-changed",
+	// Chat
+	CLEAR_CHAT_HISTORY: "chat:clear-history",
+	// Snap
+	SNAP_TO: "avatar:snap-to",
+};
+
+contextBridge.exposeInMainWorld("settingsBridge", {
+	// Getters (async invoke)
+	getSettings() {
+		return ipcRenderer.invoke(IPC.GET_SETTINGS);
+	},
+
+	// Setters (fire-and-forget send)
+	setOpacity(v) {
+		ipcRenderer.send(IPC.SET_OPACITY, v);
+	},
+
+	setScale(v) {
+		ipcRenderer.send(IPC.SET_SCALE, v);
+	},
+
+	setCameraZoom(v) {
+		ipcRenderer.send(IPC.SAVE_CAMERA_ZOOM, v);
+	},
+
+	setTtsEnabled(v) {
+		ipcRenderer.send(IPC.SET_TTS_ENABLED, v);
+	},
+
+	setTtsEngine(v) {
+		ipcRenderer.send(IPC.SET_TTS_ENGINE, v);
+	},
+
+	setTtsVoice(v) {
+		ipcRenderer.send(IPC.SET_TTS_VOICE, v);
+	},
+
+	setIdleTimeout(ms) {
+		ipcRenderer.send(IPC.SET_IDLE_TIMEOUT, ms);
+	},
+
+	setLightingProfile(profile) {
+		ipcRenderer.send(IPC.SET_LIGHTING_PROFILE, profile);
+	},
+
+	setLightingCustom(custom) {
+		ipcRenderer.send(IPC.SET_LIGHTING_CUSTOM, custom);
+	},
+
+	// Actions
+	pickVrmFile() {
+		return ipcRenderer.invoke(IPC.PICK_VRM_FILE);
+	},
+
+	snapTo(corner) {
+		ipcRenderer.send(IPC.SNAP_TO, corner);
+	},
+
+	clearChat() {
+		ipcRenderer.send(IPC.CLEAR_CHAT_HISTORY);
+	},
+
+	close() {
+		ipcRenderer.send(IPC.CLOSE_SETTINGS);
+	},
+
+	// Change listeners (main -> settings renderer)
+	onOpacityChanged(cb) {
+		ipcRenderer.removeAllListeners(IPC.OPACITY_CHANGED);
+		ipcRenderer.on(IPC.OPACITY_CHANGED, (_event, v) => cb(v));
+	},
+
+	onScaleChanged(cb) {
+		ipcRenderer.removeAllListeners(IPC.SCALE_CHANGED);
+		ipcRenderer.on(IPC.SCALE_CHANGED, (_event, v) => cb(v));
+	},
+
+	onCameraZoomChanged(cb) {
+		ipcRenderer.removeAllListeners(IPC.SET_CAMERA_ZOOM);
+		ipcRenderer.on(IPC.SET_CAMERA_ZOOM, (_event, v) => cb(v));
+	},
+
+	onTtsEnabledChanged(cb) {
+		ipcRenderer.removeAllListeners(IPC.TTS_ENABLED_CHANGED);
+		ipcRenderer.on(IPC.TTS_ENABLED_CHANGED, (_event, v) => cb(v));
+	},
+
+	onTtsEngineChanged(cb) {
+		ipcRenderer.removeAllListeners(IPC.TTS_ENGINE_CHANGED);
+		ipcRenderer.on(IPC.TTS_ENGINE_CHANGED, (_event, v) => cb(v));
+	},
+
+	onTtsVoiceChanged(cb) {
+		ipcRenderer.removeAllListeners(IPC.TTS_VOICE_CHANGED);
+		ipcRenderer.on(IPC.TTS_VOICE_CHANGED, (_event, v) => cb(v));
+	},
+
+	onIdleTimeoutChanged(cb) {
+		ipcRenderer.removeAllListeners(IPC.IDLE_TIMEOUT_CHANGED);
+		ipcRenderer.on(IPC.IDLE_TIMEOUT_CHANGED, (_event, ms) => cb(ms));
+	},
+
+	onLightingProfileChanged(cb) {
+		ipcRenderer.removeAllListeners(IPC.LIGHTING_PROFILE_CHANGED);
+		ipcRenderer.on(IPC.LIGHTING_PROFILE_CHANGED, (_event, v) => cb(v));
+	},
+
+	onLightingCustomChanged(cb) {
+		ipcRenderer.removeAllListeners(IPC.LIGHTING_CUSTOM_CHANGED);
+		ipcRenderer.on(IPC.LIGHTING_CUSTOM_CHANGED, (_event, v) => cb(v));
+	},
+
+	onVrmModelChanged(cb) {
+		ipcRenderer.removeAllListeners(IPC.VRM_MODEL_CHANGED);
+		ipcRenderer.on(IPC.VRM_MODEL_CHANGED, (_event, path) => cb(path));
+	},
+});

package/src/main/stdin-listener.ts

@@ -0,0 +1,34 @@
+import * as readline from "node:readline";
+
+export type StdinCommand =
+	| { type: "show" }
+	| { type: "hide" }
+	| { type: "shutdown" }
+	| { type: "model-switch"; vrmPath: string };
+
+/**
+ * Listen for newline-delimited JSON commands on stdin.
+ * Returns a cleanup function to stop listening.
+ */
+export function createStdinListener(handler: (cmd: StdinCommand) => void): () => void {
+	const rl = readline.createInterface({ input: process.stdin });
+
+	rl.on("line", (line) => {
+		const trimmed = line.trim();
+		if (!trimmed) return;
+
+		try {
+			const parsed = JSON.parse(trimmed);
+			if (typeof parsed?.type === "string") {
+				if (parsed.type === "model-switch" && typeof parsed.vrmPath !== "string") return;
+				handler(parsed as StdinCommand);
+			}
+		} catch {
+			// Ignore malformed lines
+		}
+	});
+
+	return () => {
+		rl.close();
+	};
+}

package/src/main/tray.ts

@@ -0,0 +1,65 @@
+import { Tray, Menu, app } from "electron";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { showVrmPicker } from "./window.js";
+import type { WindowManager } from "./window-manager.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+let tray: Tray | null = null;
+
+export function createTray(wm: WindowManager): Tray {
+	const iconPath = path.join(__dirname, "..", "..", "..", "assets", "icon.png");
+	tray = new Tray(iconPath);
+	tray.setToolTip("Flawed Avatar");
+
+	function rebuildMenu(): void {
+		const menu = Menu.buildFromTemplate([
+			{
+				label: wm.avatarWin.isVisible() ? "Hide Avatar" : "Show Avatar",
+				click() {
+					if (wm.avatarWin.isVisible()) {
+						wm.hideAll();
+					} else {
+						wm.showAvatar();
+					}
+					rebuildMenu();
+				},
+			},
+			{
+				label: "Change Avatar Model\u2026",
+				click() {
+					showVrmPicker(wm.avatarWin);
+				},
+			},
+			{
+				label: "Settings\u2026",
+				click() {
+					wm.showSettings();
+				},
+			},
+			{ type: "separator" },
+			{
+				label: "Quit",
+				click() {
+					app.quit();
+				},
+			},
+		]);
+		tray!.setContextMenu(menu);
+	}
+
+	rebuildMenu();
+
+	tray.on("click", () => {
+		if (wm.avatarWin.isVisible()) {
+			wm.hideAll();
+		} else {
+			wm.showAvatar();
+		}
+		rebuildMenu();
+	});
+
+	return tray;
+}

package/src/main/window-manager.ts

@@ -0,0 +1,298 @@
+import { BrowserWindow, ipcMain, screen } from "electron";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createOverlayWindow } from "./window.js";
+import { IPC } from "../shared/ipc-channels.js";
+import {
+	WINDOW_HEIGHT,
+	CHAT_WINDOW_WIDTH,
+	CHAT_WINDOW_HEIGHT,
+	CHAT_WINDOW_GAP,
+	SETTINGS_WINDOW_WIDTH,
+	SETTINGS_WINDOW_HEIGHT,
+} from "../shared/config.js";
+import type { AgentState } from "../shared/types.js";
+import { clampBoundsToWorkArea } from "./display-utils.js";
+import { setSettingsBroadcastTarget } from "./settings-broadcast.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export interface WindowManager {
+	avatarWin: BrowserWindow;
+	chatWin: BrowserWindow;
+	settingsWin: BrowserWindow | null;
+	chatVisible: boolean;
+	toggleChat(): void;
+	showChat(): void;
+	hideChat(): void;
+	repositionChat(): void;
+	showSettings(): void;
+	hideSettings(): void;
+	toggleSettings(): void;
+	hideAll(): void;
+	showAvatar(): void;
+	sendAgentState(state: AgentState): void;
+	sendToAvatar(channel: string, ...args: unknown[]): void;
+	sendToChat(channel: string, ...args: unknown[]): void;
+	sendToSettings(channel: string, ...args: unknown[]): void;
+	destroyAll(): void;
+}
+
+function computeChatPosition(
+	avatarX: number,
+	avatarY: number,
+	avatarWidth: number,
+): { x: number; y: number } {
+	const point = { x: avatarX + avatarWidth / 2, y: avatarY };
+	const display = screen.getDisplayNearestPoint(point);
+	const workArea = display.workArea;
+
+	const chatX = Math.round(
+		avatarX + avatarWidth / 2 - CHAT_WINDOW_WIDTH / 2,
+	);
+
+	// Try above avatar first
+	const aboveY = avatarY - CHAT_WINDOW_HEIGHT - CHAT_WINDOW_GAP;
+	if (aboveY >= workArea.y) {
+		return clampBoundsToWorkArea(chatX, aboveY, CHAT_WINDOW_WIDTH, CHAT_WINDOW_HEIGHT);
+	}
+
+	// Fall back to below avatar
+	const belowY = avatarY + WINDOW_HEIGHT + CHAT_WINDOW_GAP;
+	return clampBoundsToWorkArea(chatX, belowY, CHAT_WINDOW_WIDTH, CHAT_WINDOW_HEIGHT);
+}
+
+function createChatWindow(): BrowserWindow {
+	const chatWin = new BrowserWindow({
+		width: CHAT_WINDOW_WIDTH,
+		height: CHAT_WINDOW_HEIGHT,
+		transparent: true,
+		frame: false,
+		alwaysOnTop: true,
+		skipTaskbar: true,
+		resizable: false,
+		hasShadow: false,
+		show: false,
+		webPreferences: {
+			contextIsolation: true,
+			nodeIntegration: false,
+			preload: path.join(__dirname, "..", "..", "chat-preload.cjs"),
+		},
+	});
+
+	chatWin.loadFile(
+		path.join(__dirname, "..", "..", "chat-renderer-bundle", "chat-index.html"),
+	);
+
+	// Chat window should be interactive by default (not click-through)
+	// Only the transparent areas around the chat body will pass clicks through
+
+	return chatWin;
+}
+
+function createSettingsWindow(): BrowserWindow {
+	const settingsWin = new BrowserWindow({
+		width: SETTINGS_WINDOW_WIDTH,
+		height: SETTINGS_WINDOW_HEIGHT,
+		transparent: false,
+		frame: false,
+		alwaysOnTop: false,
+		skipTaskbar: false,
+		resizable: true,
+		minWidth: 320,
+		minHeight: 400,
+		show: false,
+		webPreferences: {
+			contextIsolation: true,
+			nodeIntegration: false,
+			preload: path.join(__dirname, "..", "..", "settings-preload.cjs"),
+		},
+	});
+
+	settingsWin.loadFile(
+		path.join(__dirname, "..", "..", "settings-renderer-bundle", "settings-index.html"),
+	);
+
+	return settingsWin;
+}
+
+export function createWindowManager(): WindowManager {
+	const avatarWin = createOverlayWindow();
+	let chatWin = createChatWindow();
+	let chatVisible = false;
+	let settingsWin: BrowserWindow | null = null;
+
+	// Handle chat window being closed externally
+	chatWin.on("closed", () => {
+		chatVisible = false;
+		chatWin = createChatWindow();
+	});
+
+	function repositionChat(): void {
+		if (chatWin.isDestroyed()) return;
+		const [ax, ay] = avatarWin.getPosition();
+		const [aw] = avatarWin.getSize();
+		const pos = computeChatPosition(ax, ay, aw);
+		chatWin.setPosition(pos.x, pos.y);
+	}
+
+	function showChat(): void {
+		if (chatVisible) return;
+		chatVisible = true;
+		repositionChat();
+		chatWin.showInactive();
+		chatWin.webContents.send(IPC.SHOW_CHAT_BUBBLE);
+		avatarWin.webContents.send(IPC.CHAT_VISIBILITY, true);
+	}
+
+	function hideChat(): void {
+		if (!chatVisible) return;
+		chatVisible = false;
+		if (!chatWin.isDestroyed()) chatWin.hide();
+		avatarWin.webContents.send(IPC.CHAT_VISIBILITY, false);
+	}
+
+	function toggleChat(): void {
+		if (chatVisible) {
+			hideChat();
+		} else {
+			showChat();
+		}
+	}
+
+	function showSettings(): void {
+		if (avatarWin.isDestroyed()) return;
+		if (!settingsWin || settingsWin.isDestroyed()) {
+			settingsWin = createSettingsWindow();
+			setSettingsBroadcastTarget(settingsWin);
+			settingsWin.on("closed", () => {
+				settingsWin = null;
+				setSettingsBroadcastTarget(null);
+			});
+		}
+		const [ax, ay] = avatarWin.getPosition();
+		const pos = clampBoundsToWorkArea(
+			ax - SETTINGS_WINDOW_WIDTH - 12,
+			ay,
+			SETTINGS_WINDOW_WIDTH,
+			SETTINGS_WINDOW_HEIGHT,
+		);
+		settingsWin.setPosition(pos.x, pos.y);
+		settingsWin.show();
+		settingsWin.focus();
+	}
+
+	function hideSettings(): void {
+		if (settingsWin && !settingsWin.isDestroyed()) settingsWin.hide();
+	}
+
+	function toggleSettings(): void {
+		if (settingsWin && !settingsWin.isDestroyed() && settingsWin.isVisible()) {
+			hideSettings();
+		} else {
+			showSettings();
+		}
+	}
+
+	function sendToSettings(channel: string, ...args: unknown[]): void {
+		if (settingsWin && !settingsWin.isDestroyed()) {
+			settingsWin.webContents.send(channel, ...args);
+		}
+	}
+
+	function hideAll(): void {
+		hideChat();
+		hideSettings();
+		avatarWin.hide();
+	}
+
+	function showAvatar(): void {
+		avatarWin.show();
+	}
+
+	function sendAgentState(state: AgentState): void {
+		avatarWin.webContents.send(IPC.AGENT_STATE, state);
+		if (!chatWin.isDestroyed()) {
+			chatWin.webContents.send(IPC.AGENT_STATE, state);
+		}
+		// Auto-show chat on non-idle states
+		if (state.phase !== "idle") {
+			showChat();
+		}
+	}
+
+	function sendToAvatar(channel: string, ...args: unknown[]): void {
+		if (!avatarWin.isDestroyed()) {
+			avatarWin.webContents.send(channel, ...args);
+		}
+	}
+
+	function sendToChat(channel: string, ...args: unknown[]): void {
+		if (!chatWin.isDestroyed()) {
+			chatWin.webContents.send(channel, ...args);
+		}
+	}
+
+	function destroyAll(): void {
+		if (settingsWin && !settingsWin.isDestroyed()) settingsWin.destroy();
+		if (!chatWin.isDestroyed()) chatWin.destroy();
+		if (!avatarWin.isDestroyed()) avatarWin.destroy();
+	}
+
+	// Reposition chat when avatar moves
+	avatarWin.on("moved", () => {
+		if (chatVisible) repositionChat();
+	});
+
+	// Toggle chat from avatar renderer
+	ipcMain.on(IPC.TOGGLE_CHAT, () => {
+		toggleChat();
+	});
+
+	// Chat window click-through toggle
+	ipcMain.on(IPC.SET_IGNORE_MOUSE_CHAT, (_event, ignore: unknown) => {
+		if (typeof ignore !== "boolean" || chatWin.isDestroyed()) return;
+		chatWin.setIgnoreMouseEvents(ignore, { forward: true });
+	});
+
+	// Chat content hidden (idle fade) → hide the BrowserWindow
+	ipcMain.on(IPC.CHAT_CONTENT_HIDDEN, () => {
+		hideChat();
+	});
+
+	// Chat content shown → ensure window is visible
+	ipcMain.on(IPC.CHAT_CONTENT_SHOWN, () => {
+		if (!chatVisible) showChat();
+	});
+
+	// Settings window open/close from renderer
+	ipcMain.on(IPC.OPEN_SETTINGS, () => {
+		showSettings();
+	});
+
+	ipcMain.on(IPC.CLOSE_SETTINGS, () => {
+		hideSettings();
+	});
+
+	return {
+		get avatarWin() { return avatarWin; },
+		get chatWin() { return chatWin; },
+		get settingsWin() { return settingsWin; },
+		get chatVisible() { return chatVisible; },
+		toggleChat,
+		showChat,
+		hideChat,
+		repositionChat,
+		showSettings,
+		hideSettings,
+		toggleSettings,
+		hideAll,
+		showAvatar,
+		sendAgentState,
+		sendToAvatar,
+		sendToChat,
+		sendToSettings,
+		destroyAll,
+	};
+}