@whoz-oss/coday-web 0.13.2

package/client/app.js

@@ -0,0 +1,1560 @@
+"use strict";
+
+// libs/coday-events/src/lib/coday-events.ts
+function truncateText(text, maxLength = 80) {
+  if (text.length <= maxLength) return text;
+  try {
+    if (text.trim().startsWith("{") || text.trim().startsWith("[")) {
+      const obj = JSON.parse(text);
+      const simplified = JSON.stringify(obj);
+      if (simplified.length <= maxLength) return simplified;
+      return simplified.substring(0, maxLength) + `...(${simplified.length} chars)`;
+    }
+  } catch (e) {
+  }
+  return text.substring(0, maxLength) + "...";
+}
+var CodayEvent = class {
+  constructor(event, type) {
+    this.type = type;
+    if (!event.timestamp) {
+      const randomSuffix = Math.random().toString(36).substring(2, 7);
+      this.timestamp = `${(/* @__PURE__ */ new Date()).toISOString()}-${randomSuffix}`;
+    } else {
+      this.timestamp = event.timestamp;
+    }
+    this.parentKey = event.parentKey;
+    this.length = 0;
+  }
+  timestamp;
+  parentKey;
+  static type;
+  length;
+};
+var QuestionEvent = class extends CodayEvent {
+  invite;
+  constructor(event, type) {
+    super(event, type);
+    this.invite = event.invite;
+  }
+  buildAnswer(answer) {
+    return new AnswerEvent({ answer, parentKey: this.timestamp, invite: this.invite });
+  }
+};
+var HeartBeatEvent = class _HeartBeatEvent extends CodayEvent {
+  static type = "heartbeat";
+  constructor(event) {
+    super(event, _HeartBeatEvent.type);
+  }
+};
+var InviteEvent = class _InviteEvent extends QuestionEvent {
+  defaultValue;
+  static type = "invite";
+  constructor(event) {
+    super(event, _InviteEvent.type);
+    this.defaultValue = event.defaultValue;
+  }
+};
+var AnswerEvent = class _AnswerEvent extends CodayEvent {
+  answer;
+  invite;
+  static type = "answer";
+  constructor(event) {
+    super(event, _AnswerEvent.type);
+    this.answer = event.answer ?? "No answer";
+    this.invite = event.invite;
+  }
+};
+var TextEvent = class _TextEvent extends CodayEvent {
+  speaker;
+  text;
+  static type = "text";
+  constructor(event) {
+    super(event, _TextEvent.type);
+    this.speaker = event.speaker;
+    this.text = event.text;
+  }
+};
+var WarnEvent = class _WarnEvent extends CodayEvent {
+  warning;
+  static type = "warn";
+  constructor(event) {
+    super(event, _WarnEvent.type);
+    this.warning = event.warning;
+  }
+};
+var ErrorEvent = class _ErrorEvent extends CodayEvent {
+  error;
+  static type = "error";
+  constructor(event) {
+    super(event, _ErrorEvent.type);
+    this.error = event.error;
+  }
+};
+var ChoiceEvent = class _ChoiceEvent extends QuestionEvent {
+  options;
+  optionalQuestion;
+  static type = "choice";
+  constructor(event) {
+    super(event, _ChoiceEvent.type);
+    this.options = event.options;
+    this.optionalQuestion = event.optionalQuestion;
+  }
+};
+var ToolRequestEvent = class _ToolRequestEvent extends CodayEvent {
+  toolRequestId;
+  name;
+  args;
+  static type = "tool_request";
+  constructor(event) {
+    super(event, _ToolRequestEvent.type);
+    this.toolRequestId = event.toolRequestId ?? this.timestamp;
+    this.name = event.name;
+    this.args = event.args;
+    this.length = this.args.length + this.name.length + this.toolRequestId.length + 20;
+  }
+  buildResponse(output) {
+    return new ToolResponseEvent({ output, toolRequestId: this.toolRequestId });
+  }
+  /**
+   * Renders the tool request as a single line string with truncation
+   * @param maxLength Maximum length for the arguments before truncation
+   * @returns A formatted string representation
+   */
+  toSingleLineString(maxLength = 50) {
+    const truncatedArgs = truncateText(this.args, maxLength);
+    return `\u{1F527} ${this.name}(${truncatedArgs})`;
+  }
+};
+var ToolResponseEvent = class _ToolResponseEvent extends CodayEvent {
+  toolRequestId;
+  output;
+  static type = "tool_response";
+  constructor(event) {
+    super(event, _ToolResponseEvent.type);
+    this.toolRequestId = event.toolRequestId || this.timestamp || (/* @__PURE__ */ new Date()).toISOString();
+    this.output = event.output;
+    this.length = this.output.length + this.toolRequestId.length + 20;
+  }
+  /**
+   * Renders the tool response as a single line string with truncation
+   * @param maxLength Maximum length for the output before truncation
+   * @returns A formatted string representation
+   */
+  toSingleLineString(maxLength = 50) {
+    const truncatedOutput = truncateText(this.output, maxLength);
+    return `\u2B91 ${truncatedOutput}`;
+  }
+};
+var ProjectSelectedEvent = class _ProjectSelectedEvent extends CodayEvent {
+  projectName;
+  static type = "project_selected";
+  constructor(event) {
+    super(event, _ProjectSelectedEvent.type);
+    this.projectName = event.projectName;
+  }
+};
+var ThinkingEvent = class _ThinkingEvent extends CodayEvent {
+  static type = "thinking";
+  static debounce = 5e3;
+  constructor(event) {
+    super(event, _ThinkingEvent.type);
+  }
+};
+var MessageEvent = class _MessageEvent extends CodayEvent {
+  role;
+  name;
+  content;
+  static type = "message";
+  constructor(event) {
+    super(event, _MessageEvent.type);
+    this.role = event.role;
+    this.name = event.name;
+    this.content = event.content;
+    this.length = this.content.length + this.role.length + this.name.length + 20;
+  }
+};
+var eventTypeToClassMap = {
+  [MessageEvent.type]: MessageEvent,
+  [AnswerEvent.type]: AnswerEvent,
+  [ChoiceEvent.type]: ChoiceEvent,
+  [ErrorEvent.type]: ErrorEvent,
+  [HeartBeatEvent.type]: HeartBeatEvent,
+  [InviteEvent.type]: InviteEvent,
+  [ProjectSelectedEvent.type]: ProjectSelectedEvent,
+  [ToolRequestEvent.type]: ToolRequestEvent,
+  [ToolResponseEvent.type]: ToolResponseEvent,
+  [TextEvent.type]: TextEvent,
+  [ThinkingEvent.type]: ThinkingEvent,
+  [WarnEvent.type]: WarnEvent
+};
+function buildCodayEvent(data) {
+  const Clazz = eventTypeToClassMap[data.type];
+  return Clazz ? new Clazz(data) : void 0;
+}
+
+// apps/web/client/utils/preferences.ts
+var STORAGE_KEY = "coday-preferences";
+function getPreference(key, defaultValue) {
+  try {
+    const stored = localStorage.getItem(STORAGE_KEY);
+    if (!stored) return defaultValue;
+    const preferences = JSON.parse(stored);
+    return preferences[key] !== void 0 ? preferences[key] : defaultValue;
+  } catch {
+    return defaultValue;
+  }
+}
+function setPreference(key, value) {
+  try {
+    const stored = localStorage.getItem(STORAGE_KEY);
+    const preferences = stored ? JSON.parse(stored) : {};
+    preferences[key] = value;
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(preferences));
+  } catch (error) {
+    console.error("Failed to set preference:", error);
+  }
+}
+
+// apps/web/client/chat-textarea/speech-to-textarea.component.ts
+var SpeechToTextareaComponent = class {
+  constructor(chatTextarea, submitButton) {
+    this.chatTextarea = chatTextarea;
+    this.submitButton = submitButton;
+    this.initializeVoiceInput();
+    window.addEventListener("voiceLanguageChanged", (event) => {
+      this.updateRecognitionLanguage();
+    });
+  }
+  // Voice input properties
+  recognition = null;
+  voiceButton = null;
+  isRecording = false;
+  sessionHadTranscript = false;
+  pendingLineBreaksTimeout = null;
+  initializeVoiceInput() {
+    const SpeechRecognition = window.SpeechRecognition || window.webkitSpeechRecognition;
+    console.log("speechRecognition", SpeechRecognition);
+    if (!SpeechRecognition) return;
+    this.recognition = new SpeechRecognition();
+    this.recognition.continuous = true;
+    this.recognition.interimResults = true;
+    this.recognition.maxAlternatives = 1;
+    this.recognition.lang = this.getSelectedLanguage();
+    try {
+      if ("grammars" in this.recognition) {
+        this.recognition.serviceURI = void 0;
+      }
+    } catch (e) {
+      console.log("Advanced speech recognition parameters not supported");
+    }
+    this.recognition.onresult = (event) => {
+      let finalTranscript = "";
+      for (let i = event.resultIndex; i < event.results.length; i++) {
+        const transcript = event.results[i][0].transcript;
+        if (event.results[i].isFinal) {
+          finalTranscript += transcript;
+        }
+      }
+      if (finalTranscript) {
+        const processedTranscript = this.improveTranscriptPunctuation(finalTranscript.trim());
+        this.sessionHadTranscript = true;
+        console.log("onresult ending, appending to textarea", this.isRecording);
+        this.appendToTextarea(processedTranscript);
+      }
+    };
+    this.recognition.onend = () => {
+      this.isRecording = false;
+      console.log("Recognition ended. Was recording:", this.isRecording);
+      this.updateVoiceButtonState();
+    };
+    this.recognition.onerror = (event) => {
+      console.error("Speech recognition error:", event.error);
+      console.log("Error details:", {
+        error: event.error,
+        message: event.message,
+        timeStamp: event.timeStamp
+      });
+      this.isRecording = false;
+      this.clearPendingLineBreaks();
+      this.updateVoiceButtonState();
+    };
+    this.recognition.onstart = () => {
+      console.log("Recognition started successfully");
+    };
+    this.recognition.onspeechstart = () => {
+      console.log("Speech detected");
+    };
+    this.recognition.onspeechend = () => {
+      console.log("Speech ended");
+    };
+    this.createVoiceControls();
+  }
+  createVoiceControls() {
+    const buttonContainer = this.submitButton.parentElement;
+    if (!buttonContainer) return;
+    this.voiceButton = document.createElement("button");
+    this.voiceButton.type = "button";
+    this.voiceButton.className = "voice-button";
+    this.voiceButton.tabIndex = 0;
+    this.voiceButton.innerHTML = "\u{1F3A4}";
+    this.voiceButton.title = "Maintenir clic souris, touch, ou barre espace pour parler";
+    this.voiceButton.style.marginRight = "8px";
+    buttonContainer.insertBefore(this.voiceButton, this.submitButton);
+    this.voiceButton.addEventListener("mousedown", (e) => {
+      e.preventDefault();
+      this.startRecording();
+    });
+    this.voiceButton.addEventListener("mouseup", () => {
+      this.stopRecording();
+    });
+    this.voiceButton.addEventListener("mouseleave", () => {
+      this.stopRecording();
+    });
+    this.voiceButton.addEventListener("touchstart", (e) => {
+      e.preventDefault();
+      this.startRecording();
+    });
+    this.voiceButton.addEventListener("touchend", (e) => {
+      e.preventDefault();
+      this.stopRecording();
+    });
+    this.voiceButton.addEventListener("keydown", (e) => {
+      if (e.code === "Space" || e.key === " " || e.keyCode === 32) {
+        e.preventDefault();
+        if (!this.isRecording) {
+          this.startRecording();
+        }
+      }
+    });
+    this.voiceButton.addEventListener("keyup", (e) => {
+      if (e.code === "Space" || e.key === " " || e.keyCode === 32) {
+        e.preventDefault();
+        this.stopRecording();
+      }
+    });
+  }
+  async startRecording() {
+    if (!this.recognition || this.isRecording) return;
+    try {
+      this.isRecording = true;
+      this.sessionHadTranscript = false;
+      this.clearPendingLineBreaks();
+      this.updateVoiceButtonState();
+      this.recognition.start();
+    } catch (error) {
+      console.error("Failed to start recording:", error);
+      this.isRecording = false;
+      this.updateVoiceButtonState();
+    }
+  }
+  stopRecording() {
+    if (!this.recognition || !this.isRecording) {
+      console.log("stopRecording not recording");
+      return;
+    }
+    try {
+      console.log("stopRecording recognition stop");
+      this.recognition.stop();
+      this.schedulePendingLineBreaks();
+    } catch (error) {
+      console.error("Failed to stop recording:", error);
+    }
+  }
+  updateVoiceButtonState() {
+    if (!this.voiceButton) return;
+    if (this.isRecording) {
+      this.voiceButton.classList.add("recording");
+      this.voiceButton.innerHTML = "\u{1F534}";
+      this.voiceButton.title = "Recording... (release to stop)";
+    } else {
+      this.voiceButton.classList.remove("recording");
+      this.voiceButton.innerHTML = "\u{1F3A4}";
+      this.voiceButton.title = "Maintenir clic souris, touch, ou barre espace pour parler";
+    }
+  }
+  /**
+   * Get language from global preferences
+   */
+  getSelectedLanguage() {
+    return getPreference("voiceLanguage", "en-US") ?? "en-US";
+  }
+  /**
+   * Update speech recognition language
+   */
+  updateRecognitionLanguage() {
+    if (this.recognition) {
+      const selectedLang = this.getSelectedLanguage();
+      this.recognition.lang = selectedLang;
+      console.log("Language changed to:", selectedLang);
+    }
+  }
+  /**
+   * Improve punctuation from the rather raw transcript
+   */
+  improveTranscriptPunctuation(text) {
+    let improved = text;
+    if (!/[.!?]$/.test(improved.trim())) {
+      improved = improved.trim() + ".";
+    }
+    improved = improved.charAt(0).toUpperCase() + improved.slice(1);
+    improved = improved.replace(/\s+/g, " ");
+    improved = improved + " ";
+    return improved;
+  }
+  appendToTextarea(text) {
+    const currentValue = this.chatTextarea.value;
+    const newValue = currentValue ? `${currentValue}${text}` : text;
+    this.chatTextarea.value = newValue;
+    this.chatTextarea.focus();
+    const length = this.chatTextarea.value.length;
+    this.chatTextarea.setSelectionRange(length, length);
+  }
+  /**
+   * Schedule line breaks to be added after a delay, allowing time for pending transcripts
+   */
+  schedulePendingLineBreaks() {
+    this.clearPendingLineBreaks();
+    this.pendingLineBreaksTimeout = window.setTimeout(() => {
+      if (this.sessionHadTranscript) {
+        console.log("Adding line breaks after transcript session");
+        this.appendToTextarea("\n\n");
+        this.sessionHadTranscript = false;
+      }
+      this.pendingLineBreaksTimeout = null;
+    }, 500);
+  }
+  /**
+   * Clear any pending line break timeouts
+   */
+  clearPendingLineBreaks() {
+    if (this.pendingLineBreaksTimeout) {
+      clearTimeout(this.pendingLineBreaksTimeout);
+      this.pendingLineBreaksTimeout = null;
+    }
+  }
+};
+
+// apps/web/client/chat-textarea/chat-textarea.component.ts
+var MINIMUM_SPEECH_LENGTH = 50;
+var ChatTextareaComponent = class {
+  constructor(postEvent2, voiceSynthesis2) {
+    this.postEvent = postEvent2;
+    this.voiceSynthesis = voiceSynthesis2;
+    this.os = this.detectOS();
+    this.chatForm = document.getElementById("chat-form");
+    this.chatTextarea = document.getElementById("chat-input");
+    this.chatLabel = document.getElementById("chat-label");
+    this.submitButton = document.getElementById("send-button");
+    new SpeechToTextareaComponent(this.chatTextarea, this.submitButton);
+    this.chatForm.onsubmit = async (event) => {
+      event.preventDefault();
+      await this.submit();
+    };
+    this.chatTextarea.addEventListener("keydown", async (e) => {
+      if (this.inviteEvent?.defaultValue) return;
+      const useEnterToSend2 = getPreference("useEnterToSend", false);
+      if (useEnterToSend2) {
+        if (e.key === "Enter" && !e.shiftKey && !e.metaKey && !e.ctrlKey) {
+          e.preventDefault();
+          await this.submit();
+        }
+      } else {
+        if (e.key === "Enter" && (this.os === "mac" && e.metaKey || this.os === "non-mac" && e.ctrlKey)) {
+          e.preventDefault();
+          await this.submit();
+        }
+      }
+      if (e.key === "ArrowUp") {
+        if (this.isCursorAtFirstLine()) {
+          e.preventDefault();
+          this.navigateHistory("up");
+        }
+      } else if (e.key === "ArrowDown") {
+        if (this.isCursorAtLastLine()) {
+          e.preventDefault();
+          this.navigateHistory("down");
+        }
+      }
+    });
+    this.updateSendButtonLabel();
+    window.addEventListener("storage", (event) => {
+      if (event.key === "coday-preferences") {
+        this.updateSendButtonLabel();
+      }
+    });
+    window.addEventListener("voiceModeChanged", (event) => {
+      console.log("[CHAT-TEXTAREA] Voice mode changed to:", event.detail);
+    });
+    window.addEventListener("voiceAnnounceEnabledChanged", (event) => {
+      console.log("[CHAT-TEXTAREA] Voice announce enabled changed to:", event.detail);
+    });
+  }
+  chatForm;
+  chatTextarea;
+  chatLabel;
+  submitButton;
+  inviteEvent;
+  os;
+  // Command history for arrow key navigation
+  promptHistory = [];
+  historyIndex = -1;
+  tempInput = "";
+  /**
+   * Detect operating system for keyboard shortcuts
+   */
+  detectOS() {
+    return navigator.platform.toLowerCase().includes("mac") ? "mac" : "non-mac";
+  }
+  /**
+   * Update the send button label based on preferences and OS
+   */
+  updateSendButtonLabel() {
+    const useEnterToSend2 = getPreference("useEnterToSend", false);
+    if (!this.submitButton) return;
+    if (useEnterToSend2) {
+      this.submitButton.innerHTML = "SEND <br/><br/>enter";
+    } else {
+      if (this.os === "mac") {
+        this.submitButton.innerHTML = "SEND <br/><br/>\u2318 + enter";
+      } else {
+        this.submitButton.innerHTML = "SEND <br/><br/>Ctrl + enter";
+      }
+    }
+  }
+  handle(event) {
+    if (event instanceof InviteEvent) {
+      this.inviteEvent = event;
+      const parsed = marked.parse(this.inviteEvent.invite);
+      if (parsed instanceof Promise) {
+        parsed.then((html) => {
+          this.chatLabel.innerHTML = html;
+          this.setupLabelClickHandler();
+        });
+      } else {
+        this.chatLabel.innerHTML = parsed;
+        this.setupLabelClickHandler();
+      }
+      this.chatForm.style.display = "block";
+      this.chatTextarea.focus();
+      if (this.inviteEvent.defaultValue) {
+        console.log(`handling defaultValue: ${this.inviteEvent.defaultValue}`);
+        this.chatTextarea.value = this.inviteEvent.defaultValue;
+      }
+      const audioEnabled = getPreference("voiceAnnounceEnabled", false) || false;
+      if (audioEnabled) {
+        this.announceLabel(this.inviteEvent.invite);
+      }
+    }
+  }
+  /**
+   * Check if cursor is at the first line of text
+   */
+  isCursorAtFirstLine() {
+    const text = this.chatTextarea.value;
+    const cursorPos = this.chatTextarea.selectionStart;
+    if (cursorPos === 0) return true;
+    const textBeforeCursor = text.substring(0, cursorPos);
+    return textBeforeCursor.indexOf("\n") === -1;
+  }
+  /**
+   * Check if cursor is at the last line of text
+   */
+  isCursorAtLastLine() {
+    const text = this.chatTextarea.value;
+    const cursorPos = this.chatTextarea.selectionStart;
+    if (cursorPos === text.length) return true;
+    const textAfterCursor = text.substring(cursorPos);
+    return textAfterCursor.indexOf("\n") === -1;
+  }
+  /**
+   * Navigate through command history using up/down arrows
+   */
+  navigateHistory(direction) {
+    if (this.promptHistory.length === 0) return;
+    if (direction === "up" && this.historyIndex === -1) {
+      this.tempInput = this.chatTextarea.value;
+    }
+    if (direction === "up" && this.historyIndex < this.promptHistory.length - 1) {
+      this.historyIndex++;
+      this.chatTextarea.value = this.promptHistory[this.promptHistory.length - 1 - this.historyIndex];
+      this.moveCursorToEnd();
+    } else if (direction === "down" && this.historyIndex > -1) {
+      this.historyIndex--;
+      if (this.historyIndex === -1) {
+        this.chatTextarea.value = this.tempInput;
+      } else {
+        this.chatTextarea.value = this.promptHistory[this.promptHistory.length - 1 - this.historyIndex];
+      }
+      this.moveCursorToEnd();
+    }
+  }
+  /**
+   * Move cursor to the end of the textarea
+   */
+  moveCursorToEnd() {
+    const length = this.chatTextarea.value.length;
+    this.chatTextarea.setSelectionRange(length, length);
+  }
+  async submit() {
+    const inputValue = this.chatTextarea.value.trim();
+    const answer = this.inviteEvent?.buildAnswer(inputValue);
+    this.chatTextarea.value = "";
+    if (!answer) {
+      return;
+    }
+    try {
+      this.chatForm.style.display = "none";
+      const response = await this.postEvent(answer);
+      if (response.ok) {
+        if (inputValue && (this.promptHistory.length === 0 || this.promptHistory[this.promptHistory.length - 1] !== inputValue)) {
+          this.promptHistory.push(inputValue);
+        }
+        this.historyIndex = -1;
+        this.tempInput = "";
+      } else {
+        this.chatForm.style.display = "block";
+        this.chatTextarea.focus();
+        console.error("Failed to send message.");
+      }
+    } catch (error) {
+      console.error("Error occurred while sending message:", error);
+    }
+  }
+  setupLabelClickHandler() {
+    this.chatLabel.addEventListener("click", () => {
+      this.voiceSynthesis.stopSpeech();
+    });
+    this.chatLabel.style.cursor = "pointer";
+    this.chatLabel.title = "Click to stop speech";
+  }
+  announceLabel(text) {
+    const mode = getPreference("voiceMode", "speech") || "speech";
+    if (mode === "notification" || text.length <= MINIMUM_SPEECH_LENGTH) {
+      this.voiceSynthesis.ding();
+    } else {
+      this.voiceSynthesis.speak(text);
+    }
+  }
+};
+
+// apps/web/client/choice-select/choice-select.component.ts
+var MINIMUM_SPEECH_LENGTH2 = 50;
+var ChoiceSelectComponent = class {
+  constructor(postEvent2, voiceSynthesis2) {
+    this.postEvent = postEvent2;
+    this.voiceSynthesis = voiceSynthesis2;
+    this.choiceForm = document.getElementById("choice-form");
+    this.choiceSelect = document.getElementById("choice-select");
+    this.choiceLabel = document.getElementById("choices-label");
+    this.choiceForm.onsubmit = async (event) => {
+      event.preventDefault();
+      const answer = this.choiceEvent?.buildAnswer(this.choiceSelect.value);
+      if (!answer) {
+        return;
+      }
+      try {
+        this.choiceForm.style.display = "none";
+        const response = await this.postEvent(answer);
+        if (!response.ok) {
+          this.choiceForm.style.display = "block";
+          this.choiceSelect.focus();
+          console.error("Failed to send message.");
+        }
+      } catch (error) {
+        console.error("Error occurred while sending message:", error);
+      }
+    };
+    window.addEventListener("voiceModeChanged", (event) => {
+      console.log("[CHOICE-SELECT] Voice mode changed to:", event.detail);
+    });
+    window.addEventListener("voiceAnnounceEnabledChanged", (event) => {
+      console.log("[CHOICE-SELECT] Voice announce enabled changed to:", event.detail);
+    });
+  }
+  choiceForm;
+  choiceSelect;
+  choiceLabel;
+  choiceEvent;
+  handle(choiceEvent) {
+    if (!(choiceEvent instanceof ChoiceEvent)) {
+      return;
+    }
+    this.choiceEvent = choiceEvent;
+    const questionText = this.choiceEvent?.optionalQuestion ? marked.parse(this.choiceEvent.optionalQuestion) : "";
+    const inviteText = marked.parse(this.choiceEvent?.invite || "");
+    const updateLabel = async () => {
+      const [questionHtml, inviteHtml] = await Promise.all([
+        questionText instanceof Promise ? questionText : Promise.resolve(questionText),
+        inviteText instanceof Promise ? inviteText : Promise.resolve(inviteText)
+      ]);
+      this.choiceLabel.innerHTML = questionHtml + " " + inviteHtml;
+      this.setupLabelClickHandler();
+      const audioEnabled = getPreference("voiceAnnounceEnabled", false) || false;
+      if (audioEnabled) {
+        const fullText = (this.choiceEvent?.optionalQuestion || "") + " " + (this.choiceEvent?.invite || "");
+        const plainText = this.voiceSynthesis.extractPlainText(fullText);
+        this.announceLabel(plainText);
+      }
+    };
+    updateLabel().catch(console.error);
+    this.choiceSelect.innerHTML = this.choiceEvent?.options.map((option) => `<option value="${option}">${option}</option>`).join("");
+    this.choiceForm.style.display = "block";
+    this.choiceSelect.focus();
+  }
+  setupLabelClickHandler() {
+    this.choiceLabel.addEventListener("click", () => {
+      this.voiceSynthesis.stopSpeech();
+    });
+    this.choiceLabel.style.cursor = "pointer";
+    this.choiceLabel.title = "Click to stop speech";
+  }
+  announceLabel(text) {
+    const mode = getPreference("voiceMode", "speech") || "speech";
+    if (mode === "notification" || text.length <= MINIMUM_SPEECH_LENGTH2) {
+      this.voiceSynthesis.ding();
+    } else {
+      this.voiceSynthesis.speak(text);
+    }
+  }
+};
+
+// apps/web/client/chat-history/chat-history.component.ts
+var PARAGRAPH_MIN_LENGTH = 80;
+var MAX_PARAGRAPHS = 3;
+var MESSAGE_FRESHNESS_THRESHOLD = 5 * 60 * 1e3;
+var ChatHistoryComponent = class {
+  constructor(onStopCallback, voiceSynthesis2) {
+    this.voiceSynthesis = voiceSynthesis2;
+    this.chatHistory = document.getElementById("chat-history");
+    this.thinkingDots = document.getElementById("thinking-dots");
+    this.stopButton = this.thinkingDots.querySelector(".stop-button");
+    this.onStopCallback = onStopCallback;
+    if (this.stopButton) {
+      this.stopButton.addEventListener("click", () => this.onStopCallback());
+    }
+    this.readFullText = getPreference("voiceReadFullText", false) || false;
+    window.addEventListener("voiceReadFullTextChanged", (event) => {
+      this.readFullText = event.detail;
+    });
+    setInterval(() => {
+      this.checkStateConsistency();
+    }, 1e3);
+  }
+  chatHistory;
+  thinkingDots;
+  stopButton;
+  history = /* @__PURE__ */ new Map();
+  thinkingTimeout;
+  onStopCallback;
+  readFullText = false;
+  currentPlayingButton = null;
+  handle(event) {
+    this.history.set(event.timestamp, event);
+    if (event instanceof TextEvent) {
+      if (event.speaker) {
+        this.voiceSynthesis.stopSpeech();
+        this.resetAllPlayButtons();
+        this.addText(event.text, event.speaker, event.timestamp);
+      } else {
+        this.addTechnical(event.text);
+      }
+    }
+    if (event instanceof AnswerEvent) {
+      this.addAnswer(event.answer, event.invite);
+    }
+    if (event instanceof ErrorEvent) {
+      const errorMessage = JSON.stringify(event.error);
+      this.addError(errorMessage);
+    }
+    if (event instanceof WarnEvent) {
+      const warnMessage = JSON.stringify(event.warning);
+      this.addError(warnMessage, "Warning");
+    }
+    if (event instanceof ThinkingEvent) {
+      this.setThinking(true);
+    }
+    if (event instanceof ToolRequestEvent) {
+      this.addToolRequest(event);
+    }
+    if (event instanceof ToolResponseEvent) {
+      this.addToolResponse(event);
+    }
+  }
+  setThinking(value) {
+    if (!this.thinkingDots) {
+      return;
+    }
+    clearTimeout(this.thinkingTimeout);
+    if (value) {
+      this.thinkingTimeout = setTimeout(() => {
+        this.thinkingDots.classList.toggle("visible", false);
+      }, ThinkingEvent.debounce + 1e3);
+    } else {
+      this.scrollToBottom();
+    }
+    this.thinkingDots.classList.toggle("visible", value);
+  }
+  scrollToBottom() {
+    if (this.chatHistory) {
+      this.chatHistory.scrollTo(0, this.chatHistory.scrollHeight);
+    }
+  }
+  addTechnical(text) {
+    const newEntry = this.createMessageElement(text, void 0);
+    newEntry.classList.add("technical");
+    this.appendMessageElement(newEntry);
+  }
+  addText(text, speaker, messageTimestamp) {
+    const newEntry = this.createMessageElement(text, speaker);
+    newEntry.classList.add("text", "left");
+    newEntry.addEventListener("click", () => {
+      this.voiceSynthesis.stopSpeech();
+    });
+    const buttonContainer = document.createElement("div");
+    buttonContainer.classList.add("message-button-container");
+    const playButton = this.createPlayButton(text);
+    buttonContainer.appendChild(playButton);
+    const copyButton = document.createElement("button");
+    copyButton.classList.add("copy-button");
+    copyButton.title = "Copy raw response";
+    copyButton.textContent = "\u{1F4CB}";
+    copyButton.addEventListener("click", (event) => {
+      event.stopPropagation();
+      this.copyToClipboard(text);
+      const clickedButton = event.currentTarget;
+      if (clickedButton) {
+        document.querySelectorAll(".copy-button.active").forEach((btn) => {
+          btn.classList.remove("active");
+          btn.textContent = "\u{1F4CB}";
+        });
+        clickedButton.classList.add("active");
+        clickedButton.textContent = "\u2713";
+        setTimeout(() => {
+          clickedButton.classList.remove("active");
+          clickedButton.textContent = "\u{1F4CB}";
+        }, 2e3);
+      }
+    });
+    buttonContainer.appendChild(copyButton);
+    newEntry.appendChild(buttonContainer);
+    this.appendMessageElement(newEntry);
+    const audioEnabled = getPreference("voiceAnnounceEnabled", false) || false;
+    if (speaker && audioEnabled && this.isMessageRecentEnoughForAnnouncement(messageTimestamp)) {
+      this.announceText(text);
+    }
+  }
+  addAnswer(answer, speaker) {
+    const newEntry = this.createMessageElement(answer, speaker);
+    newEntry.classList.add("text", "right");
+    const buttonContainer = document.createElement("div");
+    buttonContainer.classList.add("message-button-container");
+    const playButton = this.createPlayButton(answer);
+    buttonContainer.appendChild(playButton);
+    const copyButton = document.createElement("button");
+    copyButton.classList.add("copy-button");
+    copyButton.title = "Copy raw message";
+    copyButton.textContent = "\u{1F4CB}";
+    copyButton.addEventListener("click", (event) => {
+      event.stopPropagation();
+      this.copyToClipboard(answer);
+      const clickedButton = event.currentTarget;
+      if (clickedButton) {
+        document.querySelectorAll(".copy-button.active").forEach((btn) => {
+          btn.classList.remove("active");
+          btn.textContent = "\u{1F4CB}";
+        });
+        clickedButton.classList.add("active");
+        clickedButton.textContent = "\u2713";
+        setTimeout(() => {
+          clickedButton.classList.remove("active");
+          clickedButton.textContent = "\u{1F4CB}";
+        }, 2e3);
+      }
+    });
+    buttonContainer.appendChild(copyButton);
+    newEntry.appendChild(buttonContainer);
+    this.appendMessageElement(newEntry);
+  }
+  copyToClipboard(text) {
+    navigator.clipboard.writeText(text).catch((err) => console.error("Failed to copy text: ", err));
+  }
+  createPlayButton(text) {
+    const playButton = document.createElement("button");
+    playButton.classList.add("play-button");
+    playButton.title = "Play message";
+    playButton.textContent = "\u25B6\uFE0F";
+    playButton.addEventListener("click", (event) => {
+      event.stopPropagation();
+      this.togglePlayback(text, playButton);
+    });
+    return playButton;
+  }
+  togglePlayback(text, button) {
+    if (this.voiceSynthesis.isSpeaking() && this.currentPlayingButton === button) {
+      console.log("[CHAT] Stopping current playback");
+      this.voiceSynthesis.stopSpeech();
+      this.resetPlayButton(button);
+      this.currentPlayingButton = null;
+    } else {
+      console.log("[CHAT] Starting new playback, stopping previous if any");
+      this.voiceSynthesis.stopSpeech();
+      this.resetAllPlayButtons();
+      const plainText = this.voiceSynthesis.extractPlainText(text);
+      const onEndCallback = () => {
+        console.log("[CHAT] Playback ended, resetting button");
+        if (this.currentPlayingButton === button) {
+          this.resetPlayButton(button);
+          this.currentPlayingButton = null;
+        }
+      };
+      this.voiceSynthesis.speak(plainText, onEndCallback);
+      this.currentPlayingButton = button;
+      button.textContent = "\u23F8\uFE0F";
+      button.title = "Stop playback";
+      console.log("[CHAT] Button set to pause state");
+    }
+  }
+  resetPlayButton(button) {
+    button.textContent = "\u25B6\uFE0F";
+    button.title = "Play message";
+  }
+  resetAllPlayButtons() {
+    const allPlayButtons = document.querySelectorAll(".play-button");
+    allPlayButtons.forEach((btn) => {
+      const button = btn;
+      button.textContent = "\u25B6\uFE0F";
+      button.title = "Play message";
+    });
+    this.currentPlayingButton = null;
+  }
+  checkStateConsistency() {
+    if (!this.voiceSynthesis.isSpeaking() && this.currentPlayingButton) {
+      console.log("[CHAT] State inconsistency detected: no speech but button still active, fixing...");
+      this.resetAllPlayButtons();
+    }
+  }
+  createMessageElement(content, speaker) {
+    const newEntry = document.createElement("div");
+    newEntry.classList.add("message");
+    if (speaker) {
+      const speakerElement = document.createElement("div");
+      speakerElement.classList.add("speaker");
+      speakerElement.textContent = speaker;
+      newEntry.appendChild(speakerElement);
+      const parsed = marked.parse(content);
+      parsed instanceof Promise ? parsed.then((html) => newEntry.appendChild(this.buildTextElement(html))) : newEntry.appendChild(this.buildTextElement(parsed));
+    } else {
+      const parsed = marked.parse(content);
+      parsed instanceof Promise ? parsed.then((html) => newEntry.innerHTML = html) : newEntry.innerHTML = parsed;
+    }
+    return newEntry;
+  }
+  appendMessageElement(element) {
+    this.chatHistory?.appendChild(element);
+  }
+  buildTextElement(innerHTML) {
+    const textElement = document.createElement("div");
+    textElement.innerHTML = innerHTML;
+    return textElement;
+  }
+  addError(error, level = "Error") {
+    this.setThinking(false);
+    const errorEntry = document.createElement("div");
+    const errorIcon = document.createElement("span");
+    errorIcon.textContent = level === "Error" ? "\u274C" : "\u26A0\uFE0F";
+    errorEntry.appendChild(errorIcon);
+    const errorText = document.createElement("span");
+    errorText.textContent = `${level}: ${error}`;
+    errorEntry.appendChild(errorText);
+    errorEntry.style.color = level === "Error" ? "#e74c3c" : "#e7ab3c";
+    errorEntry.style.background = level === "Error" ? "#ffeeee" : "#fffaee";
+    errorEntry.style.padding = "10px";
+    errorEntry.style.margin = "10px 0";
+    errorEntry.style.borderRadius = "4px";
+    errorEntry.style.border = `1px solid ${level === "Error" ? "#e74c3c" : "#e7ab3c"}`;
+    this.chatHistory?.appendChild(errorEntry);
+    this.scrollToBottom();
+  }
+  getClientId() {
+    const params = new URLSearchParams(window.location.search);
+    return params.get("clientId") || "";
+  }
+  createViewFullLink(eventId) {
+    const clientId2 = this.getClientId();
+    if (!clientId2) return null;
+    const link = document.createElement("a");
+    link.href = `/api/event/${eventId}?clientId=${clientId2}`;
+    link.textContent = "view";
+    link.target = "_blank";
+    link.style.marginLeft = "5px";
+    link.style.fontSize = "0.9em";
+    link.style.color = "var(--color-link)";
+    return link;
+  }
+  addToolRequest(event) {
+    const element = document.createElement("div");
+    element.classList.add("message", "technical");
+    const container = document.createElement("span");
+    const messageText = event.toSingleLineString();
+    container.appendChild(document.createTextNode(messageText));
+    const link = this.createViewFullLink(event.timestamp);
+    if (link) {
+      container.appendChild(link);
+    }
+    element.appendChild(container);
+    this.appendMessageElement(element);
+  }
+  addToolResponse(event) {
+    const element = document.createElement("div");
+    element.classList.add("message", "technical");
+    const container = document.createElement("span");
+    const messageText = event.toSingleLineString();
+    container.appendChild(document.createTextNode(messageText));
+    const link = this.createViewFullLink(event.timestamp);
+    if (link) {
+      container.appendChild(link);
+    }
+    element.appendChild(container);
+    this.appendMessageElement(element);
+  }
+  isMessageRecentEnoughForAnnouncement(messageTimestamp) {
+    if (!messageTimestamp) {
+      return true;
+    }
+    try {
+      const isoDatePart = messageTimestamp.split("-").slice(0, -1).join("-");
+      const messageTime = new Date(isoDatePart).getTime();
+      const now = Date.now();
+      const timeDiff = now - messageTime;
+      return timeDiff <= MESSAGE_FRESHNESS_THRESHOLD;
+    } catch (error) {
+      return true;
+    }
+  }
+  announceText(text) {
+    const mode = getPreference("voiceMode", "speech") || "speech";
+    if (mode === "notification") {
+      this.voiceSynthesis.ding();
+      return;
+    }
+    let plainText = this.voiceSynthesis.extractPlainText(text);
+    let textToSpeak;
+    if (this.readFullText) {
+      textToSpeak = plainText;
+    } else {
+      const speech = plainText.split("\n").reduce(
+        (acc, value) => {
+          if (acc.paragraphs >= MAX_PARAGRAPHS) {
+            return acc;
+          } else {
+            const paragraphIncrement = value.length > PARAGRAPH_MIN_LENGTH ? 1 : 0;
+            return {
+              paragraphs: acc.paragraphs + paragraphIncrement,
+              text: acc.text + "\n" + value
+            };
+          }
+        },
+        { paragraphs: 0, text: "" }
+      );
+      textToSpeak = speech.text;
+    }
+    if (!textToSpeak.trim()) {
+      console.log("[VOICE] No text to speak after processing!");
+      return;
+    }
+    this.voiceSynthesis.speak(textToSpeak);
+  }
+};
+
+// apps/web/client/header/header.component.ts
+var HeaderComponent = class {
+  headerTitle = document.getElementById("header-title");
+  handle(event) {
+    if (event instanceof ProjectSelectedEvent) {
+      const title = event.projectName || `Coday`;
+      document.title = title;
+      this.headerTitle.innerHTML = title;
+    }
+  }
+};
+
+// apps/web/client/voice-synthesis/voice-synthesis.component.ts
+var TestTexts = {
+  fr: "Bonjour, ceci est un test de la voix s\xE9lectionn\xE9e.",
+  en: "Hello, this is a test of the selected voice.",
+  es: "Hola, esta es una prueba de la voz seleccionada.",
+  de: "Hallo, dies ist ein Test der ausgew\xE4hlten Stimme.",
+  it: "Ciao, questo \xE8 un test della voce selezionata.",
+  pt: "Ol\xE1, este \xE9 um teste da voz selecionada.",
+  ja: "\u3053\u3093\u306B\u3061\u306F\u3001\u3053\u308C\u306F\u9078\u629E\u3055\u308C\u305F\u97F3\u58F0\u306E\u30C6\u30B9\u30C8\u3067\u3059\u3002",
+  ko: "\uC548\uB155\uD558\uC138\uC694, \uC774\uAC83\uC740 \uC120\uD0DD\uB41C \uC74C\uC131\uC758 \uD14C\uC2A4\uD2B8\uC785\uB2C8\uB2E4.",
+  zh: "\u4F60\u597D\uFF0C\u8FD9\u662F\u6240\u9009\u8BED\u97F3\u7684\u6D4B\u8BD5\u3002",
+  ru: "\u041F\u0440\u0438\u0432\u0435\u0442, \u044D\u0442\u043E \u0442\u0435\u0441\u0442 \u0432\u044B\u0431\u0440\u0430\u043D\u043D\u043E\u0433\u043E \u0433\u043E\u043B\u043E\u0441\u0430.",
+  ar: "\u0645\u0631\u062D\u0628\u0627\u060C \u0647\u0630\u0627 \u0627\u062E\u062A\u0628\u0627\u0631 \u0644\u0644\u0635\u0648\u062A \u0627\u0644\u0645\u062D\u062F\u062F."
+};
+var VoiceSynthesisComponent = class {
+  voices;
+  currentUtterance = null;
+  currentOnEndCallback = null;
+  volume = 0.8;
+  rate = 1.2;
+  language = "en";
+  selectedVoice;
+  constructor() {
+    if (!("speechSynthesis" in window)) {
+      console.warn("Speech synthesis not available");
+      this.voices = new Promise((resolve) => resolve([]));
+      return;
+    }
+    this.voices = new Promise((resolve, reject) => {
+      const immediateVoices = speechSynthesis.getVoices();
+      if (immediateVoices.length) {
+        resolve(immediateVoices);
+      } else {
+        const handle = setTimeout(() => {
+          reject("no voices found");
+        }, 2e3);
+        speechSynthesis.addEventListener("voiceschanged", () => {
+          const delayedVoices = speechSynthesis.getVoices();
+          if (delayedVoices.length) {
+            clearTimeout(handle);
+            resolve(delayedVoices);
+          }
+        });
+      }
+    });
+  }
+  ding() {
+    try {
+      const audioContext = new (window.AudioContext || window.webkitAudioContext)();
+      const oscillator = audioContext.createOscillator();
+      const gainNode = audioContext.createGain();
+      oscillator.connect(gainNode);
+      gainNode.connect(audioContext.destination);
+      oscillator.frequency.setValueAtTime(800, audioContext.currentTime);
+      gainNode.gain.setValueAtTime(0.1, audioContext.currentTime);
+      gainNode.gain.exponentialRampToValueAtTime(0.01, audioContext.currentTime + 0.1);
+      oscillator.start(audioContext.currentTime);
+      oscillator.stop(audioContext.currentTime + 0.1);
+    } catch (error) {
+      console.error("Notification sound failed:", error);
+    }
+  }
+  extractPlainText(text) {
+    let processed = text.replace(/[\u{1F600}-\u{1F64F}]|[\u{1F300}-\u{1F5FF}]|[\u{1F680}-\u{1F6FF}]|[\u{1F1E0}-\u{1F1FF}]|[\u{2600}-\u{26FF}]|[\u{2700}-\u{27BF}]|⭐/gu, "").replace(/```[\s\S]*?```/g, "code block").replace(/`([^`]+)`/g, "$1").replace(/\*\*\*(.*?)\*\*\*/g, "$1").replace(/\*\*(.*?)\*\*/g, "$1").replace(/\*(.*?)\*/g, "$1").replace(/~~(.*?)~~/g, "$1").replace(/#{1,6}\s*(.*)/g, "$1").replace(/\[([^\]]+)\]\([^\)]+\)/g, "$1").replace(/https?:\/\/[^\s]+/g, "link").replace(/&nbsp;/g, " ").replace(/&amp;/g, "and").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"');
+    processed = this.addNaturalPunctuation(processed);
+    return processed.replace(/\s+/g, " ").trim();
+  }
+  addNaturalPunctuation(text) {
+    return text.replace(/\n+/g, "\n").split("\n").map((line) => this.addPeriodIfNeeded(line.trim())).filter((line) => line.length > 0).join(" ");
+  }
+  addPeriodIfNeeded(line) {
+    if (!line) return "";
+    if (!/[.!?;:]$/.test(line)) {
+      return line + ".";
+    }
+    return line;
+  }
+  speak(markdown, onEnd) {
+    if (!this.selectedVoice) {
+      console.warn("no voice selected");
+      return;
+    }
+    this.stopSpeech();
+    const text = this.extractPlainText(markdown);
+    const utterance = new SpeechSynthesisUtterance(text);
+    utterance.voice = this.selectedVoice;
+    utterance.lang = this.selectedVoice.lang;
+    utterance.volume = this.volume;
+    utterance.rate = this.rate;
+    this.currentOnEndCallback = onEnd || null;
+    if (onEnd) {
+      utterance.onend = () => {
+        if (this.currentOnEndCallback === onEnd) {
+          this.currentOnEndCallback = null;
+          onEnd();
+        }
+      };
+      utterance.onerror = () => {
+        if (this.currentOnEndCallback === onEnd) {
+          this.currentOnEndCallback = null;
+          onEnd();
+        }
+      };
+    }
+    this.currentUtterance = utterance;
+    speechSynthesis.speak(utterance);
+    console.log("[VOICE-COMPONENT] Started speaking:", text.substring(0, 50) + "...");
+  }
+  async getVoices() {
+    const langCode = this.language.slice(0, 2);
+    const matchingVoices = (await this.voices)?.filter((voice) => voice.lang.toLowerCase().startsWith(langCode))?.sort((a, b) => {
+      if (a.localService && !b.localService) return -1;
+      if (!a.localService && b.localService) return 1;
+      return a.name.localeCompare(b.name);
+    }) ?? [];
+    console.log("matching voices", matchingVoices, langCode);
+    return matchingVoices.map((voice) => ({
+      name: voice.name,
+      lang: voice.lang,
+      localService: voice.localService,
+      default: voice.default,
+      displayName: this.formatVoiceDisplayName(voice)
+    }));
+  }
+  formatVoiceDisplayName(voice) {
+    const localMarker = voice.localService ? "\u{1F3E0}" : "\u2601\uFE0F";
+    const defaultMarker = voice.default ? " \u2B50" : "";
+    return `${localMarker} ${voice.name} (${voice.lang})${defaultMarker}`;
+  }
+  async setSelectedVoice(voice) {
+    if (!voice) {
+      this.selectedVoice = void 0;
+      return;
+    }
+    const [voiceName, voiceLang] = voice.split("|");
+    if (!voiceName || !voiceLang) {
+      this.selectedVoice = void 0;
+      return;
+    }
+    const foundVoice = (await this.voices)?.find((v) => v.name === voiceName && v.lang === voiceLang);
+    if (foundVoice) {
+      this.selectedVoice = foundVoice;
+    } else {
+      this.selectedVoice = void 0;
+    }
+  }
+  testSelectedVoice() {
+    setTimeout(() => {
+      if (!this.selectedVoice) {
+        console.log(`[VOICE] no voice selected`);
+        return;
+      }
+      this.stopSpeech();
+      const langCode = this.selectedVoice.lang.slice(0, 2);
+      const testText = TestTexts[langCode] || TestTexts["en"];
+      this.speak(testText);
+    }, 100);
+  }
+  stopSpeech() {
+    if (this.currentUtterance || speechSynthesis.speaking) {
+      speechSynthesis.cancel();
+      this.currentUtterance = null;
+      this.currentOnEndCallback = null;
+      console.log("[VOICE-COMPONENT] Speech stopped");
+    }
+  }
+  isSpeaking() {
+    return speechSynthesis.speaking;
+  }
+};
+
+// apps/web/client/preferences.ts
+var voiceSynthesis = new VoiceSynthesisComponent();
+var voiceAnnounceToggle = document.getElementById("voice-announce-toggle");
+var voiceModeSelect = document.getElementById("voice-mode-select");
+var voiceSelectionContainer = document.getElementById("voice-selection-container");
+var voiceSelect = document.getElementById("voice-select");
+var voiceLanguageSelect = document.getElementById("voice-language-select");
+var voiceRateSelect = document.getElementById("voice-rate-select");
+var voiceVolumeSlider = document.getElementById("voice-volume-slider");
+var volumeDisplay = document.getElementById("volume-display");
+var voiceVolumeControl = document.getElementById("voice-volume-control");
+var voiceReadFullToggle = document.getElementById("voice-read-full-toggle");
+var voiceOptions = document.getElementById("voice-options");
+var savedVoiceLanguage = getPreference("voiceLanguage", "en-US") || "en-US";
+voiceLanguageSelect.value = savedVoiceLanguage;
+voiceSynthesis.language = savedVoiceLanguage;
+var voiceAnnounceEnabled = getPreference("voiceAnnounceEnabled", false);
+voiceAnnounceToggle.checked = voiceAnnounceEnabled !== void 0 ? voiceAnnounceEnabled : false;
+var savedVoiceMode = getPreference("voiceMode", "speech") || "speech";
+voiceModeSelect.value = savedVoiceMode;
+var selectedVoice = getPreference("selectedVoice", "");
+voiceSynthesis.setSelectedVoice(selectedVoice);
+var savedSpeechSpeed = getPreference("speechSpeed", "1.2") || "1.2";
+voiceRateSelect.value = savedSpeechSpeed;
+voiceSynthesis.rate = parseFloat(savedSpeechSpeed);
+var savedSpeechVolume = getPreference("speechVolume", 80) || 80;
+voiceVolumeSlider.value = savedSpeechVolume.toString();
+volumeDisplay.textContent = `${savedSpeechVolume}%`;
+voiceSynthesis.volume = savedSpeechVolume / 100;
+var readFullText = getPreference("voiceReadFullText", false);
+voiceReadFullToggle.checked = readFullText !== void 0 ? readFullText : false;
+function updateVoiceSelectionVisibility() {
+  const showVoiceSelection = voiceAnnounceToggle.checked && voiceModeSelect.value === "speech";
+  voiceSelectionContainer.style.display = showVoiceSelection ? "block" : "none";
+  voiceVolumeControl.style.display = showVoiceSelection ? "flex" : "none";
+  if (showVoiceSelection) {
+    populateVoiceSelect();
+  }
+}
+function updateVoiceOptionsVisibility() {
+  voiceOptions.style.display = voiceAnnounceToggle.checked ? "block" : "none";
+  voiceVolumeControl.style.display = voiceAnnounceToggle.checked && voiceModeSelect.value === "speech" ? "flex" : "none";
+  updateVoiceSelectionVisibility();
+}
+async function populateVoiceSelect() {
+  try {
+    voiceSelect.innerHTML = '<option value="">Loading voices...</option>';
+    const voices = await voiceSynthesis.getVoices();
+    console.log("[VOICE] Populate voice select with", voices.length, "voices for language:", voiceSynthesis.language);
+    voiceSelect.innerHTML = "";
+    if (voices.length === 0) {
+      voiceSelect.innerHTML = '<option value="">No voices available for this language</option>';
+      console.warn("[VOICE] No voices found for language:", voiceSynthesis.language);
+      return;
+    }
+    voices.forEach((voice) => {
+      const option = document.createElement("option");
+      option.value = `${voice.name}|${voice.lang}`;
+      option.textContent = voice.displayName;
+      voiceSelect.appendChild(option);
+    });
+    const savedVoice = voiceSynthesis.selectedVoice;
+    if (savedVoice) {
+      const savedValue = `${savedVoice.name}|${savedVoice.lang}`;
+      voiceSelect.value = savedValue;
+      console.log("[VOICE] Restored saved voice preference:", savedVoice);
+    } else {
+      console.log("[VOICE] No saved voice preference found");
+    }
+  } catch (error) {
+    console.error("[VOICE] Error populating voice select:", error);
+    voiceSelect.innerHTML = '<option value="">Error loading voices</option>';
+  }
+}
+voiceLanguageSelect.addEventListener("change", () => {
+  setPreference("voiceLanguage", voiceLanguageSelect.value);
+  voiceSynthesis.language = voiceLanguageSelect.value;
+  populateVoiceSelect();
+  window.dispatchEvent(new CustomEvent("voiceLanguageChanged", { detail: voiceLanguageSelect.value }));
+});
+voiceAnnounceToggle.addEventListener("change", () => {
+  setPreference("voiceAnnounceEnabled", voiceAnnounceToggle.checked);
+  updateVoiceOptionsVisibility();
+  if (voiceAnnounceToggle.checked) {
+    testAudioAnnouncement();
+  }
+  window.dispatchEvent(new CustomEvent("voiceAnnounceEnabledChanged", { detail: voiceAnnounceToggle.checked }));
+});
+voiceModeSelect.addEventListener("change", () => {
+  setPreference("voiceMode", voiceModeSelect.value);
+  updateVoiceSelectionVisibility();
+  testAudioAnnouncement();
+  window.dispatchEvent(new CustomEvent("voiceModeChanged", { detail: voiceModeSelect.value }));
+});
+voiceSelect.addEventListener("change", () => {
+  const selectedValue = voiceSelect.value;
+  if (selectedValue) {
+    setPreference("selectedVoice", selectedValue);
+    voiceSynthesis.setSelectedVoice(selectedValue);
+    voiceSynthesis.testSelectedVoice();
+  } else {
+    setPreference("selectedVoice", "");
+  }
+});
+voiceRateSelect.addEventListener("change", () => {
+  const selectedRate = voiceRateSelect.value;
+  setPreference("speechSpeed", selectedRate);
+  voiceSynthesis.rate = parseFloat(selectedRate);
+  voiceSynthesis.testSelectedVoice();
+});
+voiceVolumeSlider.addEventListener("input", () => {
+  const volumeValue = parseInt(voiceVolumeSlider.value);
+  volumeDisplay.textContent = `${volumeValue}%`;
+  setPreference("speechVolume", volumeValue);
+  voiceSynthesis.volume = volumeValue / 100;
+});
+voiceReadFullToggle.addEventListener("change", () => {
+  setPreference("voiceReadFullText", voiceReadFullToggle.checked);
+  window.dispatchEvent(new CustomEvent("voiceReadFullTextChanged", { detail: voiceReadFullToggle.checked }));
+});
+function testAudioAnnouncement() {
+  const mode = voiceModeSelect.value;
+  if (mode === "notification") {
+    try {
+      const audioContext = new (window.AudioContext || window.webkitAudioContext)();
+      const oscillator = audioContext.createOscillator();
+      const gainNode = audioContext.createGain();
+      oscillator.connect(gainNode);
+      gainNode.connect(audioContext.destination);
+      oscillator.frequency.setValueAtTime(800, audioContext.currentTime);
+      gainNode.gain.setValueAtTime(0.1, audioContext.currentTime);
+      gainNode.gain.exponentialRampToValueAtTime(0.01, audioContext.currentTime + 0.1);
+      oscillator.start(audioContext.currentTime);
+      oscillator.stop(audioContext.currentTime + 0.1);
+    } catch (error) {
+      console.error("[VOICE] Notification sound test failed:", error);
+    }
+  } else if (mode === "speech") {
+    voiceSynthesis.testSelectedVoice();
+  }
+}
+function initializePreferences() {
+  updateVoiceOptionsVisibility();
+  setTimeout(() => {
+    populateVoiceSelect();
+  }, 100);
+}
+if (document.readyState === "loading") {
+  document.addEventListener("DOMContentLoaded", initializePreferences);
+} else {
+  initializePreferences();
+}
+
+// apps/web/client/app.ts
+function debugLog(context, ...args) {
+  console.log(`[DEBUG ${context}]`, ...args);
+}
+function getOrCreateClientId() {
+  const params = new URLSearchParams(window.location.search);
+  let clientId2 = params.get("clientId");
+  if (!clientId2) {
+    clientId2 = Math.random().toString(36).substring(2, 15);
+    const newUrl = new URL(window.location.href);
+    newUrl.searchParams.set("clientId", clientId2);
+    window.history.pushState({}, "", newUrl);
+  }
+  return clientId2;
+}
+var clientId = getOrCreateClientId();
+debugLog("INIT", `Session started with clientId: ${clientId}`);
+function postEvent(event) {
+  debugLog("API", "Posting event:", event);
+  return fetch(`/api/message?clientId=${clientId}`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(event)
+  });
+}
+var handleStop = () => {
+  debugLog("API", "Stopping execution");
+  fetch(`/api/stop?clientId=${clientId}`, { method: "POST" }).catch(
+    (error) => console.error("Error stopping execution:", error)
+  );
+};
+var chatHistory = new ChatHistoryComponent(handleStop, voiceSynthesis);
+var chatInputComponent = new ChatTextareaComponent(postEvent, voiceSynthesis);
+var choiceInputComponent = new ChoiceSelectComponent(postEvent, voiceSynthesis);
+var components = [chatInputComponent, choiceInputComponent, chatHistory, new HeaderComponent()];
+var eventSource = null;
+var reconnectAttempts = 0;
+var MAX_RECONNECT_ATTEMPTS = 3;
+var RECONNECT_DELAY = 2e3;
+function setupEventSource() {
+  debugLog("SSE", "Setting up new EventSource");
+  if (eventSource) {
+    debugLog("SSE", "Closing existing EventSource");
+    eventSource.close();
+  }
+  eventSource = new EventSource(`/events?clientId=${clientId}`);
+  eventSource.onmessage = (event) => {
+    debugLog("SSE", "Received message:", event.data);
+    reconnectAttempts = 0;
+    try {
+      const data = JSON.parse(event.data);
+      const codayEvent = buildCodayEvent(data);
+      if (codayEvent) {
+        debugLog("EVENT", "Processing event:", codayEvent);
+        components.forEach((c) => c.handle(codayEvent));
+      }
+    } catch (error) {
+      console.error("Could not parse event", event);
+    }
+  };
+  eventSource.onopen = () => {
+    debugLog("SSE", "Connection established");
+    reconnectAttempts = 0;
+  };
+  eventSource.onerror = (error) => {
+    debugLog("SSE", "EventSource error:", error);
+    if (eventSource?.readyState === EventSource.CLOSED) {
+      debugLog("SSE", "Connection closed");
+      if (reconnectAttempts < MAX_RECONNECT_ATTEMPTS) {
+        debugLog("SSE", `Attempting reconnect ${reconnectAttempts + 1}/${MAX_RECONNECT_ATTEMPTS}`);
+        components.forEach(
+          (c) => c.handle(
+            new ErrorEvent({
+              error: new Error(
+                `Connection lost. Attempting to reconnect (${reconnectAttempts + 1}/${MAX_RECONNECT_ATTEMPTS})...`
+              )
+            })
+          )
+        );
+        setTimeout(() => {
+          reconnectAttempts++;
+          setupEventSource();
+        }, RECONNECT_DELAY);
+      } else {
+        debugLog("SSE", "Max reconnection attempts reached");
+        components.forEach(
+          (c) => c.handle(new ErrorEvent({ error: new Error("Connection lost permanently. Please refresh the page.") }))
+        );
+      }
+    }
+  };
+}
+var optionsButton = document.getElementById("options-button");
+var optionsPanel = document.getElementById("options-panel");
+var enterToSendToggle = document.getElementById("enter-to-send-toggle");
+var themeLight = document.getElementById("theme-light");
+var themeDark = document.getElementById("theme-dark");
+var themeSystem = document.getElementById("theme-system");
+var useEnterToSend = getPreference("useEnterToSend", false);
+enterToSendToggle.checked = useEnterToSend !== void 0 ? useEnterToSend : false;
+function applyTheme() {
+  const savedTheme = getPreference("theme", "light");
+  themeLight.checked = savedTheme === "light";
+  themeDark.checked = savedTheme === "dark";
+  themeSystem.checked = savedTheme === "system";
+  if (savedTheme === "system") {
+    const prefersDark = window.matchMedia("(prefers-color-scheme: dark)").matches;
+    if (prefersDark) {
+      document.documentElement.setAttribute("data-theme", "dark");
+    } else {
+      document.documentElement.removeAttribute("data-theme");
+    }
+  } else if (savedTheme === "dark") {
+    document.documentElement.setAttribute("data-theme", "dark");
+  } else {
+    document.documentElement.removeAttribute("data-theme");
+  }
+}
+applyTheme();
+window.matchMedia("(prefers-color-scheme: dark)").addEventListener("change", (e) => {
+  const savedTheme = getPreference("theme", "light");
+  if (savedTheme === "system") {
+    if (e.matches) {
+      document.documentElement.setAttribute("data-theme", "dark");
+    } else {
+      document.documentElement.removeAttribute("data-theme");
+    }
+  }
+});
+optionsButton.addEventListener("click", (event) => {
+  event.stopPropagation();
+  const isVisible = optionsPanel.style.display === "block";
+  optionsPanel.style.display = isVisible ? "none" : "flex";
+});
+document.addEventListener("click", (event) => {
+  if (!optionsPanel.contains(event.target) && event.target !== optionsButton) {
+    optionsPanel.style.display = "none";
+  }
+});
+enterToSendToggle.addEventListener("change", () => {
+  setPreference("useEnterToSend", enterToSendToggle.checked);
+});
+document.querySelectorAll('input[name="theme"]').forEach((input) => {
+  input.addEventListener("change", (e) => {
+    const target = e.target;
+    if (target.checked) {
+      setPreference("theme", target.value);
+      applyTheme();
+    }
+  });
+});
+setupEventSource();
+//# sourceMappingURL=app.js.map