echoact 0.1.1__tar.gz → 0.1.2__tar.gz

echoact-0.1.2/.vscode/mcp.json

@@ -0,0 +1,17 @@
+{
+  "servers": {
+    "echoact": {
+      "type": "stdio",
+      "command": "C:/Users/lhj56/ws/echo-act/.venv/Scripts/python.exe",
+      "args": [
+        "-m",
+        "echoact.mcp"
+      ],
+      "env": {
+        "ECHOACT_URL": "http://127.0.0.1:8765",
+        "PYTHONPATH": "C:/Users/lhj56/ws/echo-act",
+        "ECHOACT_TOKEN": "eak_my-mcp-client-ea9056_oLrZDOpS2idR3xt3MaNKGGnNMc-nA_OZi7aLVfJbOBdM"
+      }
+    }
+  }
+}

{echoact-0.1.1 → echoact-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: echoact
-Version: 0.1.1
+Version: 0.1.2
 Summary: Local Korean/English speech generation for the desktop
 Project-URL: Homepage, https://github.com/ZeroAct/echo-act
 Project-URL: Issues, https://github.com/ZeroAct/echo-act/issues

{echoact-0.1.1 → echoact-0.1.2}/echoact/config/settings.py

@@ -56,6 +56,7 @@ from ..paths import redact, settings_path
 from ..policy import (
     AUTOPLAY_DEFAULT,
     AUTOSAVE_DOCUMENTS_DEFAULT,
+    CLOSE_TO_TRAY_DEFAULT,
     CPU_PERCENT_DEFAULT,
     CPU_PERCENT_MAX,
     CPU_PERCENT_MIN,
@@ -295,6 +296,9 @@ class Settings:
     # -- presentation (F-86, 4.1) -----------------------------------------
     display_language: DisplayLanguage = field(default_factory=_default_display_language)
     os_notifications: bool = OS_NOTIFICATIONS_DEFAULT
+    #: Closing the window hides it to the tray when a tray exists; jobs keep
+    #: running.  Quitting stays an explicit act (tray menu, or Settings off).
+    close_to_tray: bool = CLOSE_TO_TRAY_DEFAULT
 
     # -- integrations (4.1, F-46) -----------------------------------------
     rest_enabled: bool = REST_ENABLED_DEFAULT
@@ -460,6 +464,7 @@ class Settings:
             "output_device": self.output_device,
             "display_language": self.display_language.value,
             "os_notifications": self.os_notifications,
+            "close_to_tray": self.close_to_tray,
             "rest_enabled": self.rest_enabled,
             "rest_port": self.rest_port,
             "mcp_enabled": self.mcp_enabled,
@@ -555,6 +560,12 @@ class Settings:
                     "os_notifications",
                     problems,
                 ),
+                close_to_tray=_read_bool(
+                    d.get("close_to_tray"),
+                    defaults.close_to_tray,
+                    "close_to_tray",
+                    problems,
+                ),
                 rest_enabled=_read_bool(
                     d.get("rest_enabled"), defaults.rest_enabled, "rest_enabled", problems
                 ),
@@ -632,6 +643,7 @@ _KNOWN_KEYS: Final[frozenset[str]] = frozenset(
         "output_device",
         "display_language",
         "os_notifications",
+        "close_to_tray",
         "rest_enabled",
         "rest_port",
         "mcp_enabled",

{echoact-0.1.1 → echoact-0.1.2}/echoact/policy.py

@@ -179,6 +179,10 @@ MCP_PROTOCOL_REVISION: Final = "2026-07-28"
 VOICE_PRESET_MAX: Final = 100  # 4.1
 PLAYBACK_VOLUME_DEFAULT: Final = 1.0
 OS_NOTIFICATIONS_DEFAULT: Final = False
+#: Closing the window hides EchoAct to the tray rather than quitting, so a
+#: job keeps running.  On because it is the Windows convention; the first
+#: hide explains itself with a tray message, and Settings can turn it off.
+CLOSE_TO_TRAY_DEFAULT: Final = True
 AUTOPLAY_DEFAULT: Final = True  # F-83
 EXTERNAL_PLAY_DEFAULT: Final = True  # F-89
 # F-57 wants a hint a client can honour rather than guess at.  The figure is

{echoact-0.1.1 → echoact-0.1.2}/echoact/ui/main_window.py

@@ -20,6 +20,7 @@ from pathlib import Path
 from PySide6.QtCore import QObject, Qt, QTimer, Signal
 from PySide6.QtGui import QAction, QCloseEvent, QKeySequence
 from PySide6.QtWidgets import (
+    QApplication,
     QDialog,
     QFileDialog,
     QFrame,
@@ -46,7 +47,7 @@ from ..policy import MAX_INPUT_CODEPOINTS
 from ..text.loader import load_file
 from ..util import ids
 from ..util.logging import get_logger
-from . import icons
+from . import brand, icons
 from .bridge import EngineBridge, PlayRequestBridge
 from .controls import (
     TransportBar,
@@ -66,10 +67,12 @@ from .notifications import (
     NotificationCentre,
     completion_notice,
     failure_notice,
+    tray_sink,
 )
 from .reading import ReadingSurface
 from .theme import METRICS, Mode, Palette
 from .theme import apply as apply_theme
+from .tray import TrayController, build_tray
 
 log = get_logger("ui.window")
 
@@ -115,6 +118,10 @@ add_korean(
         "This file covers {percent}% of the text.": "이 파일은 본문의 {percent}%를 담고 있습니다.",
         "Line endings were normalised.": "줄바꿈 문자를 정규화했습니다.",
         "Playing a request from {client}": "{client}의 요청을 재생하는 중",
+        "EchoAct is still running": "EchoAct이 계속 실행 중입니다",
+        "Close sent EchoAct to the system tray. Double-click the icon to bring it back.":
+            "창을 닫아도 EchoAct은 시스템 트레이에서 실행을 계속합니다. "
+            "아이콘을 두 번 누르면 다시 나타납니다.",
         "an app": "어떤 앱",
         "Your text and reading position are untouched. Stop silences it.":
             "입력한 본문과 읽는 위치는 그대로입니다. 정지를 누르면 소리가 멈춥니다.",
@@ -330,8 +337,21 @@ class MainWindow(QMainWindow):
             remember(self, lambda a=action, s=source: a.setText(tr(s)))
 
     def _wire(self) -> None:
+        self.tray: TrayController | None = build_tray(self, brand.app_icon(self.palette_tokens))
+        self._tray_hinted = False
+        if self.tray is not None:
+            # With the window hideable, closing it is no longer an intent to
+            # quit -- only the tray's Quit is.  Set only when a tray exists,
+            # so a session without one keeps stock quit-on-last-window-closed.
+            QApplication.instance().setQuitOnLastWindowClosed(False)
+            self.tray.show_requested.connect(self.show_from_tray)
+            self.tray.stop_requested.connect(self._stop)
+            self.tray.quit_requested.connect(self._quit_from_tray)
+        # F-70's OS notices finally have somewhere to go: tray_sink was
+        # written for this icon and had never been given one.
         self.notifications = NotificationCentre(
-            os_notifications=self.app.settings.os_notifications
+            os_notifications=self.app.settings.os_notifications,
+            os_sink=tray_sink(self.tray.icon) if self.tray is not None else None,
         )
         self.bridge = EngineBridge(self.app.engine, self)
         self.bridge.accepted.connect(self._on_accepted)
@@ -628,6 +648,11 @@ class MainWindow(QMainWindow):
             self.transport.set_position(self.app.player.position_ms())
 
     def _on_tick(self) -> None:
+        if self.tray is not None:
+            # The tooltip is the only status a hidden app can show, and the
+            # status line is already the plain-language summary of the job.
+            status = self.status.text()
+            self.tray.set_tooltip(f"EchoAct — {status}" if status else "EchoAct")
         player = self.app.player
         self.external.poll()
         if self.external.active:
@@ -1166,6 +1191,7 @@ class MainWindow(QMainWindow):
             ("credential_days_changed", "credential_days"),
             ("retention_changed", "retention_bytes"),
             ("os_notifications_changed", "os_notifications"),
+            ("close_to_tray_changed", "close_to_tray"),
             ("autosave_documents_changed", "autosave_documents"),
             ("retain_history_changed", "retain_history"),
         )
@@ -1247,6 +1273,8 @@ class MainWindow(QMainWindow):
         apply_translations(self)
         self.voice_panel.retranslate()
         self.transport.retranslate()
+        if self.tray is not None:
+            self.tray.retranslate()
         source, fmt = self._status_source
         self._set_status(source, **fmt)
         self._render_counter()
@@ -1301,6 +1329,8 @@ class MainWindow(QMainWindow):
         self.transport.stop.setEnabled(playable or self.external.active)
         self.save_button.setEnabled(playable)
         self.open_button.setEnabled(not busy)
+        if self.tray is not None:
+            self.tray.set_stop_enabled(playable or self.external.active)
 
     def _set_status(self, source: str, **fmt: object) -> None:
         """Show a status line from its English source, not its rendering.
@@ -1399,18 +1429,66 @@ class MainWindow(QMainWindow):
     # Exit (F-77, F-52)
     # ------------------------------------------------------------------
 
-    def closeEvent(self, event: QCloseEvent) -> None:  # noqa: N802 - Qt override
-        if self.app.engine.busy:
-            answer = QMessageBox.question(
-                self,
-                tr("A job is still running."),
-                tr("The text you have now has not been saved."),
-                QMessageBox.StandardButton.Close | QMessageBox.StandardButton.Cancel,
+    def show_from_tray(self) -> None:
+        self.show()
+        self.raise_()
+        self.activateWindow()
+
+    def _hide_to_tray(self) -> None:
+        """The close button ends the *window*, not the job it was running.
+
+        Nothing is asked first, whatever is running: jobs continuing while
+        hidden is the whole point, and the F-89 service and the engine never
+        looked at window visibility anyway.  The first hide of a session
+        explains itself, because the taskbar button vanishing is easy to
+        mistake for a quit.  Child dialogs are left alone -- they are
+        independent tasks that close on their own.
+        """
+        self.hide()
+        if self.tray is not None and not self._tray_hinted:
+            self._tray_hinted = True
+            self.tray.notify(
+                tr("EchoAct is still running"),
+                tr("Close sent EchoAct to the system tray. Double-click the icon to bring it back."),
             )
-            if answer is not QMessageBox.StandardButton.Close:
-                event.ignore()
+
+    def _quit_from_tray(self) -> None:
+        # A modal owned by a hidden window can surface behind other apps on
+        # Windows and read as a hang, so the window is back before it asks.
+        if self.app.engine.busy:
+            self.show()
+            self.raise_()
+            if not self._confirm_quit_with_job():
                 return
+        self._quit()
+
+    def _confirm_quit_with_job(self) -> bool:
+        answer = QMessageBox.question(
+            self,
+            tr("A job is still running."),
+            tr("The text you have now has not been saved."),
+            QMessageBox.StandardButton.Close | QMessageBox.StandardButton.Cancel,
+        )
+        return answer is QMessageBox.StandardButton.Close
+
+    def _quit(self) -> None:
+        """The one teardown: every accepted exit comes through here."""
         self._tick.stop()
         self.bridge.detach()
         self.app.shutdown()
+        if self.tray is not None:
+            self.tray.hide()
+        # With quitOnLastWindowClosed off, nothing else ends the event loop;
+        # any future code that accepts a close must route through here.
+        QApplication.instance().quit()
+
+    def closeEvent(self, event: QCloseEvent) -> None:  # noqa: N802 - Qt override
+        if self.app.settings.close_to_tray and self.tray is not None:
+            event.ignore()
+            self._hide_to_tray()
+            return
+        if self.app.engine.busy and not self._confirm_quit_with_job():
+            event.ignore()
+            return
+        self._quit()
         event.accept()

{echoact-0.1.1 → echoact-0.1.2}/echoact/ui/settings_view.py

@@ -53,6 +53,7 @@ from PySide6.QtWidgets import (
     QSizePolicy,
     QSlider,
     QSpinBox,
+    QSystemTrayIcon,
     QTreeWidget,
     QTreeWidgetItem,
     QVBoxLayout,
@@ -178,6 +179,10 @@ add_korean(
         "Changing the display language does not change your documents, saved jobs, "
         "or what the local service answers.":
             "표시 언어를 바꿔도 문서, 저장된 작업, 로컬 서비스의 응답은 바뀌지 않습니다.",
+        "Keep running in the tray": "창을 닫아도 트레이에서 계속 실행",
+        "Closing the window then hides EchoAct beside the clock; jobs keep running.":
+            "창을 닫으면 EchoAct가 시계 옆 트레이로 숨겨지고, 작업은 계속 실행됩니다.",
+        "Notify me with a system message": "시스템 메시지로 알림",
         # -- integrations ---------------------------------------------------
         "Integrations": "연동",
         "Local REST service": "로컬 REST 서비스",
@@ -526,6 +531,12 @@ class SettingsView(QScrollArea):
     #: ``Settings.to_dict`` when saving, and ``_render_languages`` here --
     #: raises.  F-86 would then neither persist nor retranslate.
     display_language_changed = Signal(object)
+    #: Closing the window hides it to the tray instead of quitting.
+    close_to_tray_changed = Signal(bool)
+    #: F-70's other half: mirror notices to the tray icon.  The pairs table
+    #: in ``MainWindow._connect_settings`` has named this signal since it
+    #: was written; the row that emits it is only now here.
+    os_notifications_changed = Signal(bool)
 
     # -- integrations (F-46, F-71, F-79) ------------------------------------
     rest_enabled_changed = Signal(bool)
@@ -1175,10 +1186,28 @@ class SettingsView(QScrollArea):
         box.addWidget(self.autoplay)
         box.addWidget(self.follow)
 
+        # Both rows speak for the tray icon; with no tray on this machine
+        # there is nothing for either to mean, so neither is shown rather
+        # than one shown and inert.
+        has_tray = QSystemTrayIcon.isSystemTrayAvailable()
+        self.close_to_tray = self._check("Keep running in the tray")
+        self.tray_note = self._label(
+            "Closing the window then hides EchoAct beside the clock; jobs keep running.",
+            "muted",
+        )
+        self.os_notifications = self._check("Notify me with a system message")
+        box.addWidget(self.close_to_tray)
+        box.addWidget(self.tray_note)
+        box.addWidget(self.os_notifications)
+        for row in (self.close_to_tray, self.tray_note, self.os_notifications):
+            row.setVisible(has_tray)
+
         self._render_languages()
         self.language.currentIndexChanged.connect(self._on_language)
         self.autoplay.toggled.connect(self._on_autoplay)
         self.follow.toggled.connect(self._on_follow)
+        self.close_to_tray.toggled.connect(self._on_close_to_tray)
+        self.os_notifications.toggled.connect(self._on_os_notifications)
         return panel
 
     def _render_languages(self) -> None:
@@ -1210,6 +1239,14 @@ class SettingsView(QScrollArea):
         if not self._loading:
             self.follow_changed.emit(bool(checked))
 
+    def _on_close_to_tray(self, checked: bool) -> None:
+        if not self._loading:
+            self.close_to_tray_changed.emit(bool(checked))
+
+    def _on_os_notifications(self, checked: bool) -> None:
+        if not self._loading:
+            self.os_notifications_changed.emit(bool(checked))
+
     # ==================================================================
     # Integrations (F-46, F-71, F-79, N-31, 4.1)
     # ==================================================================
@@ -2122,6 +2159,8 @@ class SettingsView(QScrollArea):
             self.muted.setChecked(settings.muted)
             self.autoplay.setChecked(settings.autoplay)
             self.follow.setChecked(settings.follow)
+            self.close_to_tray.setChecked(settings.close_to_tray)
+            self.os_notifications.setChecked(settings.os_notifications)
             self.rest.setChecked(settings.rest_enabled)
             self.port.setValue(
                 max(MIN_USER_PORT, min(MAX_PORT, settings.rest_port))

echoact-0.1.2/echoact/ui/tray.py

@@ -0,0 +1,120 @@
+"""Living beside the clock.
+
+Closing the window hides EchoAct rather than ending it, because a job
+already accepted (F-47) must run to its end whatever the window is doing;
+the tray icon is then the only visible half of the app, so it carries the
+three things that still need a hand while nobody is watching: bring the
+window back, silence playback, and truly quit.
+
+It also completes F-70's other half.  ``notifications.tray_sink`` was
+written for exactly this icon and had never been constructed, so OS
+notices had nowhere to go; the icon is built whenever the platform offers
+one, whether or not closing hides.  The close button obeys the
+``close_to_tray`` setting, and no tray (a headless test run, a session
+without one) means the window closes and quits exactly as it always did.
+"""
+
+from __future__ import annotations
+
+from PySide6.QtCore import QObject, Signal
+from PySide6.QtGui import QIcon
+from PySide6.QtWidgets import QMenu, QSystemTrayIcon
+
+from .controls import apply_translations, remember
+from .i18n import add_korean, tr
+
+add_korean(
+    {
+        "Show EchoAct": "EchoAct 열기",
+        "Quit EchoAct": "EchoAct 종료",
+        # "Stop" is translated in i18n.py already.
+    }
+)
+
+#: Reasons that mean "the user wants the window back".  ``Context`` is the
+#: menu, which handles its own clicks, and the middle click has no meaning
+#: here; a press is ``Trigger``, whatever the platform's one-or-two-click
+#: convention turns out to be.
+_RESTORE = (
+    QSystemTrayIcon.ActivationReason.Trigger,
+    QSystemTrayIcon.ActivationReason.DoubleClick,
+)
+
+
+class TrayController(QObject):
+    """The tray icon and its menu; it emits intent and decides nothing.
+
+    Same contract as the transport bar: the window owns every choice, so
+    quitting from here travels the very teardown ``closeEvent`` uses.
+    """
+
+    show_requested = Signal()
+    stop_requested = Signal()
+    quit_requested = Signal()
+
+    def __init__(self, parent: QObject, icon: QIcon) -> None:
+        super().__init__(parent)
+        self.icon = QSystemTrayIcon(icon, self)
+        # QMenu wants a *widget* parent and a tray controller is not one;
+        # setContextMenu does not take ownership either.  The reference here
+        # is what keeps the menu's C++ object alive as long as the icon.
+        menu = QMenu()
+        self._menu = menu
+        show = menu.addAction("")
+        remember(self, lambda: show.setText(tr("Show EchoAct")))
+        show.triggered.connect(self.show_requested.emit)
+        menu.addSeparator()
+        self._stop = menu.addAction("")
+        remember(self, lambda: self._stop.setText(tr("Stop")))
+        self._stop.triggered.connect(self.stop_requested.emit)
+        menu.addSeparator()
+        quit_ = menu.addAction("")
+        remember(self, lambda: quit_.setText(tr("Quit EchoAct")))
+        quit_.triggered.connect(self.quit_requested.emit)
+        self.icon.setContextMenu(menu)
+        self.icon.activated.connect(self._on_activated)
+        self._tooltip = "EchoAct"
+        self.icon.setToolTip(self._tooltip)
+        self.icon.show()
+
+    def _on_activated(self, reason: QSystemTrayIcon.ActivationReason) -> None:  # noqa: N802
+        if reason in _RESTORE:
+            self.show_requested.emit()
+
+    def retranslate(self) -> None:
+        apply_translations(self)
+
+    def set_tooltip(self, text: str) -> None:
+        # Called from the window's 40 ms tick; re-setting identical text
+        # would churn the shell's notification area for nothing.
+        if text != self._tooltip:
+            self._tooltip = text
+            self.icon.setToolTip(text)
+
+    def set_stop_enabled(self, enabled: bool) -> None:
+        self._stop.setEnabled(enabled)
+
+    def notify(self, title: str, detail: str = "") -> None:
+        # A machine with per-app notifications turned off is not a failure;
+        # tray_sink makes the same bargain for the same reason.
+        try:
+            self.icon.showMessage(title, detail, QSystemTrayIcon.MessageIcon.Information, 6000)
+        except Exception:  # noqa: BLE001 - the notice still exists in-app
+            pass
+
+    def show(self) -> None:
+        self.icon.show()
+
+    def hide(self) -> None:
+        self.icon.hide()
+
+
+def build_tray(parent: QObject, app_icon: QIcon) -> TrayController | None:
+    """The tray, or ``None`` where there is nowhere to put one.
+
+    ``None`` is a supported outcome, not a degraded one: the caller keeps
+    its pre-tray behaviour, including stock quit-on-last-window-closed.
+    """
+    if not QSystemTrayIcon.isSystemTrayAvailable():
+        return None
+    return TrayController(parent, app_icon)

{echoact-0.1.1 → echoact-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "echoact"
-version = "0.1.1"
+version = "0.1.2"
 description = "Local Korean/English speech generation for the desktop"
 readme = "README.md"
 requires-python = ">=3.12,<3.13"

{echoact-0.1.1 → echoact-0.1.2}/tests/test_packaging.py

@@ -31,10 +31,19 @@ def _spec_suffixes() -> set[str]:
 
 
 def _runtime_suffixes() -> set[str]:
+    # The fonts directory is the spec's one whole-directory copy
+    # (``font_data`` ships everything under it, whatever the suffix), so
+    # scanning it would flag files that a build plainly does contain.
+    # Nothing else ships that way, and no suffix goes unexamined: any file
+    # added elsewhere still has to name its suffix in the collector.
+    fonts = PACKAGE / "assets" / "fonts"
     return {
         path.suffix.lower()
         for path in PACKAGE.rglob("*")
-        if path.is_file() and path.suffix != ".py" and "__pycache__" not in path.parts
+        if path.is_file()
+        and path.suffix != ".py"
+        and "__pycache__" not in path.parts
+        and fonts not in path.parents
     }
 
 

{echoact-0.1.1 → echoact-0.1.2}/tests/test_settings.py

@@ -29,6 +29,7 @@ from echoact.domain import Budget, Gender, Language, SpeakingStyle, VoiceSetting
 from echoact.errors import Code, EchoActError
 from echoact.policy import (
     AUTOPLAY_DEFAULT,
+    CLOSE_TO_TRAY_DEFAULT,
     CPU_PERCENT_DEFAULT,
     CREDENTIAL_DAYS_DEFAULT,
     FOLLOW_DEFAULT,
@@ -82,6 +83,7 @@ def test_defaults_match_the_documented_first_launch_policy() -> None:
     assert s.follow is FOLLOW_DEFAULT is True
     assert (s.volume, s.muted, s.output_device) == (1.0, False, None)
     assert s.os_notifications is False
+    assert s.close_to_tray is CLOSE_TO_TRAY_DEFAULT is True
     assert (s.rest_enabled, s.rest_port, s.mcp_enabled) == (True, REST_PORT_DEFAULT, True)
     assert s.external_play is True  # F-89
     assert s.credential_days == CREDENTIAL_DAYS_DEFAULT
@@ -107,6 +109,7 @@ def test_every_remembered_setting_survives_a_save_and_reload() -> None:
         output_device=output_device_key("MME", "Speakers (Realtek)"),
         display_language=DisplayLanguage.KO,
         os_notifications=True,
+        close_to_tray=False,
         rest_enabled=False,
         rest_port=9100,
         mcp_enabled=False,

{echoact-0.1.1 → echoact-0.1.2}/tests/test_ui_settings.py

@@ -266,6 +266,21 @@ def test_showing_remembered_settings_emits_nothing(app: QApplication) -> None:
     assert view.memory.value() == pytest.approx(3.0)
 
 
+def test_the_tray_and_notice_toggles_reflect_and_emit(app: QApplication) -> None:
+    """The F-70 row the pairs table has always named, and the tray's own."""
+    view, _ = make_view(app)
+    seen_tray = capture(view.close_to_tray_changed)
+    seen_notice = capture(view.os_notifications_changed)
+    view.apply(Settings(close_to_tray=False, os_notifications=True))
+    assert seen_tray == [] and seen_notice == []
+    assert view.close_to_tray.isChecked() is False
+    assert view.os_notifications.isChecked() is True
+    view.close_to_tray.toggle()
+    view.os_notifications.toggle()
+    assert seen_tray == [True]
+    assert seen_notice == [False]
+
+
 def test_the_applied_budget_is_shown_apart_from_the_configured_one(app: QApplication) -> None:
     view, _ = make_view(app, Settings(cpu_percent=60, memory_bytes=6 * GIB))
     view.set_resource_state(