flawed-avatar 0.2.1

package/dist/main/main/persistence/types.d.ts

@@ -0,0 +1,72 @@
+import { z } from "zod";
+export declare const SETTINGS_SCHEMA_VERSION = 3;
+export declare const CHAT_SCHEMA_VERSION = 1;
+export declare const LightingCustomSchema: z.ZodObject<{
+    intensity: z.ZodDefault<z.ZodNumber>;
+    color: z.ZodDefault<z.ZodString>;
+    ambient: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type LightingCustom = z.infer<typeof LightingCustomSchema>;
+export declare const SettingsSchema: z.ZodObject<{
+    schemaVersion: z.ZodDefault<z.ZodNumber>;
+    position: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>>;
+    camera: z.ZodOptional<z.ZodObject<{
+        zoom: z.ZodNumber;
+    }, z.core.$strip>>;
+    opacity: z.ZodDefault<z.ZodNumber>;
+    idleTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    ttsEnabled: z.ZodDefault<z.ZodBoolean>;
+    ttsEngine: z.ZodDefault<z.ZodEnum<{
+        "web-speech": "web-speech";
+        kokoro: "kokoro";
+    }>>;
+    ttsVoice: z.ZodDefault<z.ZodString>;
+    vrmModelPath: z.ZodOptional<z.ZodString>;
+    scale: z.ZodDefault<z.ZodNumber>;
+    lightingProfile: z.ZodDefault<z.ZodString>;
+    lightingCustom: z.ZodOptional<z.ZodObject<{
+        intensity: z.ZodDefault<z.ZodNumber>;
+        color: z.ZodDefault<z.ZodString>;
+        ambient: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Settings = z.infer<typeof SettingsSchema>;
+export declare const ChatMessageSchema: z.ZodObject<{
+    id: z.ZodString;
+    timestamp: z.ZodNumber;
+    role: z.ZodEnum<{
+        user: "user";
+        assistant: "assistant";
+    }>;
+    text: z.ZodString;
+    agentId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ChatHistorySchema: z.ZodObject<{
+    schemaVersion: z.ZodDefault<z.ZodNumber>;
+    messages: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        timestamp: z.ZodNumber;
+        role: z.ZodEnum<{
+            user: "user";
+            assistant: "assistant";
+        }>;
+        text: z.ZodString;
+        agentId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    lastUpdated: z.ZodNumber;
+}, z.core.$strip>;
+export type ChatMessage = z.infer<typeof ChatMessageSchema>;
+export type ChatHistory = z.infer<typeof ChatHistorySchema>;
+export type LoadResult<T> = {
+    ok: true;
+    data: T;
+} | {
+    ok: false;
+    error: string;
+    fallback: T;
+};
+export declare function createDefaultSettings(): Settings;
+export declare function createDefaultChatHistory(): ChatHistory;

package/dist/main/main/persistence/types.js

@@ -0,0 +1,69 @@
+import { z } from "zod";
+import { CAMERA_ZOOM_MIN, CAMERA_ZOOM_MAX, CAMERA_ZOOM_DEFAULT, OPACITY_MIN, OPACITY_MAX, OPACITY_DEFAULT, IDLE_TIMEOUT_DEFAULT, CHAT_MAX_HISTORY, TTS_ENABLED_DEFAULT, TTS_ENGINE_DEFAULT, TTS_VOICE_DEFAULT, SCALE_MIN, SCALE_MAX, SCALE_DEFAULT, LIGHTING_PROFILE_DEFAULT, } from "../../shared/config.js";
+export const SETTINGS_SCHEMA_VERSION = 3;
+export const CHAT_SCHEMA_VERSION = 1;
+// === Lighting Custom Schema ===
+export const LightingCustomSchema = z.object({
+    intensity: z.number().min(0).max(2).default(0.3),
+    color: z.string().default("#ffffff"),
+    ambient: z.number().min(0).max(1).default(0.5),
+});
+// === Settings Schema ===
+export const SettingsSchema = z.object({
+    schemaVersion: z.number().default(SETTINGS_SCHEMA_VERSION),
+    position: z
+        .record(z.string(), z.object({
+        x: z.number().finite(),
+        y: z.number().finite(),
+    }))
+        .optional(),
+    camera: z
+        .object({
+        zoom: z.number().finite().min(CAMERA_ZOOM_MIN).max(CAMERA_ZOOM_MAX),
+    })
+        .optional(),
+    opacity: z.number().min(OPACITY_MIN).max(OPACITY_MAX).default(OPACITY_DEFAULT),
+    idleTimeoutMs: z.number().int().min(0).default(IDLE_TIMEOUT_DEFAULT),
+    ttsEnabled: z.boolean().default(TTS_ENABLED_DEFAULT),
+    ttsEngine: z.enum(["web-speech", "kokoro"]).default(TTS_ENGINE_DEFAULT),
+    ttsVoice: z.string().default(TTS_VOICE_DEFAULT),
+    vrmModelPath: z.string().optional(),
+    scale: z.number().min(SCALE_MIN).max(SCALE_MAX).default(SCALE_DEFAULT),
+    lightingProfile: z.string().default(LIGHTING_PROFILE_DEFAULT),
+    lightingCustom: LightingCustomSchema.optional(),
+});
+// === Chat Message Schema ===
+export const ChatMessageSchema = z.object({
+    id: z.string(),
+    timestamp: z.number().int().positive(),
+    role: z.enum(["user", "assistant"]),
+    text: z.string().max(10000),
+    agentId: z.string().optional(),
+});
+export const ChatHistorySchema = z.object({
+    schemaVersion: z.number().default(CHAT_SCHEMA_VERSION),
+    messages: z.array(ChatMessageSchema).max(CHAT_MAX_HISTORY).default([]),
+    lastUpdated: z.number().int().positive(),
+});
+// === Default Factories ===
+export function createDefaultSettings() {
+    return {
+        schemaVersion: SETTINGS_SCHEMA_VERSION,
+        position: {},
+        camera: { zoom: CAMERA_ZOOM_DEFAULT },
+        opacity: OPACITY_DEFAULT,
+        idleTimeoutMs: IDLE_TIMEOUT_DEFAULT,
+        ttsEnabled: TTS_ENABLED_DEFAULT,
+        ttsEngine: TTS_ENGINE_DEFAULT,
+        ttsVoice: TTS_VOICE_DEFAULT,
+        scale: SCALE_DEFAULT,
+        lightingProfile: LIGHTING_PROFILE_DEFAULT,
+    };
+}
+export function createDefaultChatHistory() {
+    return {
+        schemaVersion: CHAT_SCHEMA_VERSION,
+        messages: [],
+        lastUpdated: Date.now(),
+    };
+}

package/dist/main/main/settings-broadcast.d.ts

@@ -0,0 +1,3 @@
+import type { BrowserWindow } from "electron";
+export declare function setSettingsBroadcastTarget(win: BrowserWindow | null): void;
+export declare function broadcastToSettings(channel: string, ...args: unknown[]): void;

package/dist/main/main/settings-broadcast.js

@@ -0,0 +1,9 @@
+let target = null;
+export function setSettingsBroadcastTarget(win) {
+    target = win;
+}
+export function broadcastToSettings(channel, ...args) {
+    if (target && !target.isDestroyed()) {
+        target.webContents.send(channel, ...args);
+    }
+}

package/dist/main/main/stdin-listener.d.ts

@@ -0,0 +1,15 @@
+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 declare function createStdinListener(handler: (cmd: StdinCommand) => void): () => void;

package/dist/main/main/stdin-listener.js

@@ -0,0 +1,27 @@
+import * as readline from "node:readline";
+/**
+ * Listen for newline-delimited JSON commands on stdin.
+ * Returns a cleanup function to stop listening.
+ */
+export function createStdinListener(handler) {
+    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);
+            }
+        }
+        catch {
+            // Ignore malformed lines
+        }
+    });
+    return () => {
+        rl.close();
+    };
+}

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

@@ -0,0 +1,3 @@
+import { Tray } from "electron";
+import type { WindowManager } from "./window-manager.js";
+export declare function createTray(wm: WindowManager): Tray;

package/dist/main/main/tray.js

@@ -0,0 +1,59 @@
+import { Tray, Menu, app } from "electron";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { showVrmPicker } from "./window.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+let tray = null;
+export function createTray(wm) {
+    const iconPath = path.join(__dirname, "..", "..", "..", "assets", "icon.png");
+    tray = new Tray(iconPath);
+    tray.setToolTip("Flawed Avatar");
+    function rebuildMenu() {
+        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/dist/main/main/window-manager.d.ts

@@ -0,0 +1,23 @@
+import { BrowserWindow } from "electron";
+import type { AgentState } from "../shared/types.js";
+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;
+}
+export declare function createWindowManager(): WindowManager;

package/dist/main/main/window-manager.js

@@ -0,0 +1,232 @@
+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 { clampBoundsToWorkArea } from "./display-utils.js";
+import { setSettingsBroadcastTarget } from "./settings-broadcast.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+function computeChatPosition(avatarX, avatarY, avatarWidth) {
+    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() {
+    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() {
+    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() {
+    const avatarWin = createOverlayWindow();
+    let chatWin = createChatWindow();
+    let chatVisible = false;
+    let settingsWin = null;
+    // Handle chat window being closed externally
+    chatWin.on("closed", () => {
+        chatVisible = false;
+        chatWin = createChatWindow();
+    });
+    function repositionChat() {
+        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() {
+        if (chatVisible)
+            return;
+        chatVisible = true;
+        repositionChat();
+        chatWin.showInactive();
+        chatWin.webContents.send(IPC.SHOW_CHAT_BUBBLE);
+        avatarWin.webContents.send(IPC.CHAT_VISIBILITY, true);
+    }
+    function hideChat() {
+        if (!chatVisible)
+            return;
+        chatVisible = false;
+        if (!chatWin.isDestroyed())
+            chatWin.hide();
+        avatarWin.webContents.send(IPC.CHAT_VISIBILITY, false);
+    }
+    function toggleChat() {
+        if (chatVisible) {
+            hideChat();
+        }
+        else {
+            showChat();
+        }
+    }
+    function showSettings() {
+        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() {
+        if (settingsWin && !settingsWin.isDestroyed())
+            settingsWin.hide();
+    }
+    function toggleSettings() {
+        if (settingsWin && !settingsWin.isDestroyed() && settingsWin.isVisible()) {
+            hideSettings();
+        }
+        else {
+            showSettings();
+        }
+    }
+    function sendToSettings(channel, ...args) {
+        if (settingsWin && !settingsWin.isDestroyed()) {
+            settingsWin.webContents.send(channel, ...args);
+        }
+    }
+    function hideAll() {
+        hideChat();
+        hideSettings();
+        avatarWin.hide();
+    }
+    function showAvatar() {
+        avatarWin.show();
+    }
+    function sendAgentState(state) {
+        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, ...args) {
+        if (!avatarWin.isDestroyed()) {
+            avatarWin.webContents.send(channel, ...args);
+        }
+    }
+    function sendToChat(channel, ...args) {
+        if (!chatWin.isDestroyed()) {
+            chatWin.webContents.send(channel, ...args);
+        }
+    }
+    function destroyAll() {
+        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) => {
+        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,
+    };
+}

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

@@ -0,0 +1,3 @@
+import { BrowserWindow } from "electron";
+export declare function showVrmPicker(win: BrowserWindow): Promise<string | null>;
+export declare function createOverlayWindow(): BrowserWindow;