codex-telegram-bridge 0.6.2__tar.gz → 0.6.4__tar.gz

{codex_telegram_bridge-0.6.2/codex_telegram_bridge.egg-info → codex_telegram_bridge-0.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-telegram-bridge
-Version: 0.6.2
+Version: 0.6.4
 Summary: Control a live Codex CLI session from Telegram.
 Author: Kang Daejong
 License: MIT
@@ -132,7 +132,7 @@ Answer media attachments
   -> send the actual media with sendPhoto/sendVideo/sendVoice/sendAudio
 
 Service restart
-  -> run a local watchdog every 60 seconds on Linux/WSL and macOS
+  -> run a local watchdog every 60 seconds
   -> restart or kickstart the bridge if the user service is inactive
   -> load a persistent JSONL cursor and final-answer dedup ring
   -> resume from the cursor when it still matches the current session file
@@ -219,8 +219,8 @@ The wizard will:
 - install `~/.local/bin/telegram-agent-bridge-run`
 - install and start a user service with systemd on Linux/WSL, launchd on macOS,
   or a per-user Windows Startup launcher
-- install a watchdog timer/LaunchAgent on Linux/WSL and macOS that recovers an
-  inactive bridge service
+- install a watchdog timer/LaunchAgent/Scheduled Task that recovers an inactive
+  bridge service
 - send a setup-complete test message
 
 Default setup mode is `repl`, which supports the visible Codex CLI transcript,
@@ -504,8 +504,8 @@ service was restarting.
 
 ## Service Watchdog
 
-When the setup wizard installs a background service on Linux/WSL or macOS, it
-also installs a small watchdog.
+When the setup wizard installs a background service, it also installs a small
+watchdog.
 
 On Windows, the wizard writes a per-user Startup launcher at
 `%APPDATA%\Microsoft\Windows\Start Menu\Programs\Startup\telegram-agent-bridge.bat`.
@@ -513,9 +513,13 @@ This does not require administrator rights. Setup also starts that launcher once
 immediately so you can send `/ping` without logging out and back in. If an older
 per-user `telegram-agent-bridge` Scheduled Task exists, `doctor` still reports
 its `schtasks /query` status; otherwise it reports whether the Startup launcher
-is installed. Windows watchdog install is not automated; `doctor` reports that
-Startup autostart is the supported Windows path instead of recommending another
-setup run for watchdog.
+is installed.
+
+The Windows watchdog is a separate per-user Scheduled Task named
+`telegram-agent-bridge-watchdog`. It runs `bridge_watchdog.py` every minute
+without administrator rights. If the bridge process is missing, it first restarts
+an older service Scheduled Task when present, otherwise it re-runs the Startup
+launcher and writes the same status file.
 
 On Linux and WSL, the wizard writes:
 

{codex_telegram_bridge-0.6.2 → codex_telegram_bridge-0.6.4}/README.md

@@ -105,7 +105,7 @@ Answer media attachments
   -> send the actual media with sendPhoto/sendVideo/sendVoice/sendAudio
 
 Service restart
-  -> run a local watchdog every 60 seconds on Linux/WSL and macOS
+  -> run a local watchdog every 60 seconds
   -> restart or kickstart the bridge if the user service is inactive
   -> load a persistent JSONL cursor and final-answer dedup ring
   -> resume from the cursor when it still matches the current session file
@@ -192,8 +192,8 @@ The wizard will:
 - install `~/.local/bin/telegram-agent-bridge-run`
 - install and start a user service with systemd on Linux/WSL, launchd on macOS,
   or a per-user Windows Startup launcher
-- install a watchdog timer/LaunchAgent on Linux/WSL and macOS that recovers an
-  inactive bridge service
+- install a watchdog timer/LaunchAgent/Scheduled Task that recovers an inactive
+  bridge service
 - send a setup-complete test message
 
 Default setup mode is `repl`, which supports the visible Codex CLI transcript,
@@ -477,8 +477,8 @@ service was restarting.
 
 ## Service Watchdog
 
-When the setup wizard installs a background service on Linux/WSL or macOS, it
-also installs a small watchdog.
+When the setup wizard installs a background service, it also installs a small
+watchdog.
 
 On Windows, the wizard writes a per-user Startup launcher at
 `%APPDATA%\Microsoft\Windows\Start Menu\Programs\Startup\telegram-agent-bridge.bat`.
@@ -486,9 +486,13 @@ This does not require administrator rights. Setup also starts that launcher once
 immediately so you can send `/ping` without logging out and back in. If an older
 per-user `telegram-agent-bridge` Scheduled Task exists, `doctor` still reports
 its `schtasks /query` status; otherwise it reports whether the Startup launcher
-is installed. Windows watchdog install is not automated; `doctor` reports that
-Startup autostart is the supported Windows path instead of recommending another
-setup run for watchdog.
+is installed.
+
+The Windows watchdog is a separate per-user Scheduled Task named
+`telegram-agent-bridge-watchdog`. It runs `bridge_watchdog.py` every minute
+without administrator rights. If the bridge process is missing, it first restarts
+an older service Scheduled Task when present, otherwise it re-runs the Startup
+launcher and writes the same status file.
 
 On Linux and WSL, the wizard writes:
 

{codex_telegram_bridge-0.6.2 → codex_telegram_bridge-0.6.4}/bridge_setup.py

@@ -27,6 +27,7 @@ APP_NAME = "telegram-agent-bridge"
 SERVICE_NAME = "telegram-agent-bridge.service"
 LAUNCHD_LABEL = "com.user.telegram-agent-bridge"
 WINDOWS_TASK_NAME = APP_NAME
+WINDOWS_WATCHDOG_TASK_NAME = f"{APP_NAME}-watchdog"
 WATCHDOG_SERVICE_NAME = "telegram-agent-bridge-watchdog.service"
 WATCHDOG_TIMER_NAME = "telegram-agent-bridge-watchdog.timer"
 WATCHDOG_LAUNCHD_LABEL = "com.user.telegram-agent-bridge-watchdog"
@@ -148,7 +149,7 @@ def setup_command(command: str) -> None:
 def doctor_command_hint() -> str:
     invoked = Path(sys.argv[0]).name
     if invoked == "bridge_setup.py":
-        python_cmd = "python" if platform.system() == "Windows" else "python3"
+        python_cmd = windows_command_quote(sys.executable or "python") if platform.system() == "Windows" else "python3"
         return f"{python_cmd} bridge_setup.py doctor"
     if invoked in {"codex-telegram-bridge", "telegram-agent-bridge"}:
         return f"{invoked} doctor"
@@ -159,6 +160,8 @@ def setup_command_hint(*, mode: str | None = None) -> str:
     invoked = Path(sys.argv[0]).name
     if invoked in {"codex-telegram-bridge", "telegram-agent-bridge"}:
         command = f"{invoked} setup"
+    elif platform.system() == "Windows":
+        command = f"{windows_command_quote(sys.executable or 'python')} bridge_setup.py setup"
     else:
         command = "python bridge_setup.py setup"
     if mode:
@@ -187,7 +190,7 @@ def chmod_private(path: Path) -> None:
 def write_text_atomic(path: Path, value: str, mode: int | None = None) -> None:
     path.parent.mkdir(parents=True, exist_ok=True)
     tmp = path.with_name(path.name + ".tmp")
-    tmp.write_text(value, encoding="utf-8")
+    tmp.write_text(value, encoding="utf-8", newline="\n")
     if mode is not None:
         tmp.chmod(mode)
     tmp.replace(path)
@@ -320,7 +323,7 @@ def wait_for_chat_id(
 
 
 def service_is_running(status: str | None) -> bool:
-    return (status or "").strip().lower() in {"active", "running", "startup-installed"}
+    return (status or "").strip().lower() in {"active", "running"}
 
 
 def send_test_message(
@@ -331,12 +334,7 @@ def send_test_message(
     service_status_text: str | None = None,
     start_command: str | None = None,
 ) -> bool:
-    if (service_status_text or "").strip().lower() == "startup-installed":
-        text = (
-            "telegram-agent-bridge setup complete. Windows Startup autostart is installed "
-            "and was launched. Send /ping to test the bridge."
-        )
-    elif service_status_text and service_is_running(service_status_text):
+    if service_status_text and service_is_running(service_status_text):
         text = "telegram-agent-bridge setup complete. Background service is running. Send /ping to test the bridge."
     elif start_command:
         status = service_status_text or "unknown"
@@ -420,7 +418,61 @@ def write_env_config(
     write_text_atomic(path, content, mode=0o600)
 
 
-def install_runner(runner_file: Path, env_file: Path) -> None:
+def python_runner_content(env_file: Path) -> str:
+    return "\n".join(
+        [
+            "#!/usr/bin/env python3",
+            "import os",
+            "import shlex",
+            "import subprocess",
+            "import sys",
+            "from pathlib import Path",
+            "",
+            f"ENV_FILE = Path({str(env_file)!r})",
+            f"REPL_SCRIPT = Path({str(REPL_BRIDGE_SCRIPT)!r})",
+            f"EXEC_SCRIPT = Path({str(EXEC_BRIDGE_SCRIPT)!r})",
+            "",
+            "if not ENV_FILE.exists():",
+            "    print(f\"config file not found: {ENV_FILE}\", file=sys.stderr)",
+            "    raise SystemExit(2)",
+            "",
+            "for raw_line in ENV_FILE.read_text(encoding='utf-8').splitlines():",
+            "    line = raw_line.strip()",
+            "    if not line or line.startswith('#') or '=' not in line:",
+            "        continue",
+            "    key, raw_value = line.split('=', 1)",
+            "    key = key.strip()",
+            "    raw_value = raw_value.strip()",
+            "    try:",
+            "        parts = shlex.split(raw_value)",
+            "        value = parts[0] if parts else ''",
+            "    except ValueError:",
+            "        value = raw_value.strip(\"'\\\"\")",
+            "    if key:",
+            "        os.environ[key] = value",
+            "",
+            "mode = os.environ.get('TAB_BRIDGE_MODE', 'repl')",
+            "if mode == 'repl':",
+            "    script = REPL_SCRIPT",
+            "elif mode == 'exec':",
+            "    script = EXEC_SCRIPT",
+            "else:",
+            "    print(f\"unknown TAB_BRIDGE_MODE: {mode}\", file=sys.stderr)",
+            "    raise SystemExit(2)",
+            "",
+            "os.environ.setdefault('PYTHONUNBUFFERED', '1')",
+            "raise SystemExit(subprocess.call([sys.executable, str(script)]))",
+            "",
+        ]
+    )
+
+
+def install_runner(runner_file: Path, env_file: Path, *, os_name: str | None = None) -> None:
+    os_name = os_name or platform.system()
+    if os_name == "Windows":
+        write_text_atomic(runner_file, python_runner_content(env_file), mode=0o755)
+        return
+
     runner = "\n".join(
         [
             "#!/usr/bin/env bash",
@@ -768,6 +820,14 @@ def windows_command_quote(value: str) -> str:
     return value
 
 
+def windows_python_executable() -> str:
+    return sys.executable or shutil.which("python") or "python"
+
+
+def windows_python_runner_command(runner_file: Path) -> tuple[str, list[str]]:
+    return windows_python_executable(), [str(runner_file)]
+
+
 def windows_manual_start_command(host: WindowsBashHost, runner_file: Path) -> str:
     if host.kind == "wsl":
         args: list[str] = []
@@ -789,10 +849,8 @@ def manual_start_command_for_runner(
 ) -> str:
     os_name = os_name or platform.system()
     if os_name == "Windows":
-        try:
-            return windows_manual_start_command(detect_windows_bash_host(run=run), runner_file)
-        except SetupError:
-            return str(runner_file)
+        executable, args = windows_python_runner_command(runner_file)
+        return " ".join(windows_command_quote(part) for part in [executable, *args])
     return str(runner_file)
 
 
@@ -834,32 +892,55 @@ def install_windows_scheduled_task(
     return f"Scheduled Task: {task_name}"
 
 
+def windows_watchdog_task_action() -> str:
+    python_bin = sys.executable or shutil.which("python") or shutil.which("python3") or "python"
+    return " ".join(windows_command_quote(part) for part in [str(python_bin), str(WATCHDOG_SCRIPT)])
+
+
+def install_windows_watchdog_task(
+    *,
+    start: bool,
+    task_name: str,
+    run: Callable[..., subprocess.CompletedProcess[str]],
+) -> str | None:
+    create = run(
+        [
+            "schtasks",
+            "/Create",
+            "/TN",
+            task_name,
+            "/SC",
+            "MINUTE",
+            "/MO",
+            "1",
+            "/TR",
+            windows_watchdog_task_action(),
+            "/F",
+        ]
+    )
+    if create.returncode != 0:
+        detail = command_output(create) or "unknown error"
+        warn(f"failed to create Windows watchdog Scheduled Task {task_name}: {detail}")
+        return None
+
+    if start:
+        started = run(["schtasks", "/Run", "/TN", task_name])
+        if started.returncode != 0:
+            warn(f"could not start Windows watchdog Scheduled Task {task_name}: {command_output(started)}")
+    return f"Scheduled Task: {task_name}"
+
+
 def powershell_invoke_command(executable: str, args: list[str]) -> str:
     return " ".join(["&", powershell_single_quote(executable), *[powershell_single_quote(arg) for arg in args]])
 
 
-def windows_startup_launcher_command(host: WindowsBashHost, runner_file: Path) -> tuple[str, str]:
-    executable, args = windows_bash_host_runner_command(host, runner_file)
-    inner = powershell_invoke_command(executable, args)
-    nested_args = [
-        "-NoProfile",
-        "-ExecutionPolicy",
-        "Bypass",
-        "-Command",
-        inner,
-    ]
-    quoted_args = ", ".join(powershell_single_quote(arg) for arg in nested_args)
-    script = (
-        "Start-Process -WindowStyle Hidden "
-        f"-FilePath {powershell_single_quote('powershell.exe')} "
-        f"-ArgumentList @({quoted_args})"
-    )
-    script_arg = '"' + script.replace('"', '`"') + '"'
-    return "powershell.exe", f"-NoProfile -WindowStyle Hidden -ExecutionPolicy Bypass -Command {script_arg}"
+def windows_startup_launcher_command(runner_file: Path) -> tuple[str, str]:
+    executable, args = windows_python_runner_command(runner_file)
+    return windows_scheduled_task_exec(executable, args)
 
 
-def windows_startup_launcher_content(host: WindowsBashHost, runner_file: Path) -> str:
-    command, arguments = windows_startup_launcher_command(host, runner_file)
+def windows_startup_launcher_content(runner_file: Path) -> str:
+    command, arguments = windows_startup_launcher_command(runner_file)
     return "\r\n".join(
         [
             "@echo off",
@@ -879,16 +960,12 @@ def install_windows_startup_launcher(
     startup_dir: Path | None = None,
     app_name: str = APP_NAME,
 ) -> Path | None:
-    try:
-        host = bash_host or detect_windows_bash_host(run=run)
-    except SetupError as exc:
-        warn(str(exc))
-        return None
+    _ = bash_host
 
     launcher_file = default_windows_startup_launcher_file(startup_dir, app_name=app_name)
     write_text_atomic(
         launcher_file,
-        windows_startup_launcher_content(host, runner_file),
+        windows_startup_launcher_content(runner_file),
         mode=0o644,
     )
     if start:
@@ -919,6 +996,19 @@ def windows_scheduled_task_status(
     return parse_windows_scheduled_task_status(proc.stdout or proc.stderr or "")
 
 
+def windows_bridge_process_running(run: Callable[..., subprocess.CompletedProcess[str]]) -> bool:
+    script = (
+        "$ErrorActionPreference='SilentlyContinue'; "
+        "$p = Get-CimInstance Win32_Process | Where-Object { "
+        "$_.ProcessId -ne $PID -and $_.CommandLine -and "
+        "$_.CommandLine -match 'telegram_agent_bridge\\.py|codex_repl_bridge\\.py|telegram-agent-bridge-run' "
+        "} | Select-Object -First 1; "
+        "if ($p) { 'running'; exit 0 } else { 'missing'; exit 1 }"
+    )
+    proc = run(["powershell.exe", "-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", script])
+    return proc.returncode == 0
+
+
 def windows_startup_launcher_status(
     startup_dir: Path | None = None,
     *,
@@ -1035,11 +1125,11 @@ def install_watchdog(
         return plist_file
 
     if os_name == "Windows":
-        warn(
-            "Windows watchdog install is not automated; "
-            "setup installs the Startup launcher autostart only"
+        return install_windows_watchdog_task(
+            start=start,
+            task_name=WINDOWS_WATCHDOG_TASK_NAME,
+            run=run,
         )
-        return None
 
     warn(f"watchdog install is not automated for {os_name}")
     return None
@@ -1107,6 +1197,11 @@ def uninstall_watchdog(
             pass
         return
 
+    if os_name == "Windows":
+        run(["schtasks", "/End", "/TN", WINDOWS_WATCHDOG_TASK_NAME])
+        run(["schtasks", "/Delete", "/TN", WINDOWS_WATCHDOG_TASK_NAME, "/F"])
+        return
+
     warn(f"watchdog uninstall is not automated for {os_name}")
 
 
@@ -1133,6 +1228,8 @@ def service_status(
         task_status = windows_scheduled_task_status(task_name=task_name, run=run)
         if task_status != "not-installed":
             return task_status
+        if windows_bridge_process_running(run):
+            return "running"
         return windows_startup_launcher_status(windows_startup_dir, app_name=task_name)
     return "manual"
 
@@ -1141,7 +1238,7 @@ def watchdog_status(
     *,
     os_name: str | None = None,
     run: Callable[..., subprocess.CompletedProcess[str]] = run_command,
-    task_name: str = WINDOWS_TASK_NAME,
+    task_name: str = WINDOWS_WATCHDOG_TASK_NAME,
 ) -> str:
     os_name = os_name or platform.system()
     if os_name == "Linux":
@@ -1323,13 +1420,13 @@ def setup_bridge(options: SetupOptions, api_call: ApiCall = telegram_call) -> in
     ok(f"wrote private config: {options.config_file}")
     setup_note("The config file is chmod 600 and should stay out of git.")
 
-    install_runner(options.runner_file, options.config_file)
+    current_os = platform.system()
+    install_runner(options.runner_file, options.config_file, os_name=current_os)
     ok(f"installed runner: {options.runner_file}")
 
     setup_step(5, "Install the background service")
     service_state: str | None = None
     start_command: str | None = None
-    current_os = platform.system()
     if options.install_service:
         installed = install_service(options.runner_file, start=options.start_service)
         if installed:
@@ -1337,7 +1434,12 @@ def setup_bridge(options: SetupOptions, api_call: ApiCall = telegram_call) -> in
             ok(f"installed service: {installed}")
             service_state = service_status()
             if options.start_service:
-                ok(f"service status: {service_state}")
+                if service_is_running(service_state):
+                    ok(f"service status: {service_state}")
+                else:
+                    warn(f"service status: {service_state}")
+                    if current_os == "Windows" and service_state == "startup-installed":
+                        setup_note("Windows Startup autostart exists, but the bridge process is not confirmed running.")
         else:
             start_command = manual_start_command_for_runner(options.runner_file, os_name=current_os)
             warn("service install did not complete; run the bridge manually")
@@ -1500,6 +1602,8 @@ def doctor(config_file: Path, runner_file: Path, api_call: ApiCall = telegram_ca
                 add_next_step(f"Install Windows Startup autostart: {setup_command_hint()}")
             else:
                 add_next_step(f"Run setup again to install service/watchdog: {setup_command_hint()}")
+        elif current_os == "Windows" and status == "startup-installed":
+            add_next_step(f"Start Windows Startup launcher: {service_start_command(os_name=current_os, runner_file=runner_file)}")
         warnings += 1
 
     wd_status = watchdog_status()
@@ -1509,10 +1613,7 @@ def doctor(config_file: Path, runner_file: Path, api_call: ApiCall = telegram_ca
         warn(f"watchdog status: {wd_status}")
         if wd_status == "not-installed":
             if current_os == "Windows":
-                setup_note(
-                    "Windows watchdog install is not automated; "
-                    "the Startup launcher covers logon autostart but not periodic recovery."
-                )
+                add_next_step(f"Run setup again to install Windows watchdog: {setup_command_hint()}")
             else:
                 add_next_step(f"Run setup again to install service/watchdog: {setup_command_hint()}")
         warnings += 1

{codex_telegram_bridge-0.6.2 → codex_telegram_bridge-0.6.4}/bridge_watchdog.py

@@ -15,6 +15,7 @@ from typing import Callable
 APP_NAME = "telegram-agent-bridge"
 SERVICE_NAME = "telegram-agent-bridge.service"
 LAUNCHD_LABEL = "com.user.telegram-agent-bridge"
+WINDOWS_TASK_NAME = APP_NAME
 
 RunCommand = Callable[[list[str]], subprocess.CompletedProcess[str]]
 
@@ -41,6 +42,83 @@ def status_text(proc: subprocess.CompletedProcess[str]) -> str:
     return (proc.stdout or proc.stderr or "").strip()
 
 
+def default_windows_startup_dir() -> Path:
+    appdata = os.environ.get("APPDATA")
+    if appdata:
+        return (
+            Path(appdata)
+            / "Microsoft"
+            / "Windows"
+            / "Start Menu"
+            / "Programs"
+            / "Startup"
+        )
+    return (
+        Path.home()
+        / "AppData"
+        / "Roaming"
+        / "Microsoft"
+        / "Windows"
+        / "Start Menu"
+        / "Programs"
+        / "Startup"
+    )
+
+
+def default_windows_startup_launcher_file(
+    startup_dir: Path | None = None,
+    *,
+    app_name: str = APP_NAME,
+) -> Path:
+    return (startup_dir or default_windows_startup_dir()) / f"{app_name}.bat"
+
+
+def powershell_single_quote(value: str | Path) -> str:
+    return "'" + str(value).replace("'", "''") + "'"
+
+
+def windows_startup_launcher_start_command(launcher_file: Path) -> list[str]:
+    script = f"Start-Process -WindowStyle Hidden -FilePath {powershell_single_quote(launcher_file)}"
+    return [
+        "powershell.exe",
+        "-NoProfile",
+        "-ExecutionPolicy",
+        "Bypass",
+        "-Command",
+        script,
+    ]
+
+
+def parse_windows_scheduled_task_status(output: str) -> str:
+    for line in output.replace("\r\n", "\n").splitlines():
+        if ":" not in line:
+            continue
+        key, value = line.split(":", 1)
+        if key.strip().lower() == "status":
+            return value.strip() or "unknown"
+    return "unknown"
+
+
+def windows_scheduled_task_status(*, task_name: str, run: RunCommand) -> str:
+    proc = run(["schtasks", "/Query", "/TN", task_name, "/FO", "LIST", "/V"])
+    if proc.returncode != 0:
+        return "not-installed"
+    return parse_windows_scheduled_task_status(proc.stdout or proc.stderr or "")
+
+
+def windows_bridge_process_running(run: RunCommand) -> bool:
+    script = (
+        "$ErrorActionPreference='SilentlyContinue'; "
+        "$p = Get-CimInstance Win32_Process | Where-Object { "
+        "$_.ProcessId -ne $PID -and $_.CommandLine -and "
+        "$_.CommandLine -match 'telegram_agent_bridge\\.py|codex_repl_bridge\\.py|telegram-agent-bridge-run' "
+        "}; "
+        "if ($p) { 'running'; exit 0 } else { 'missing'; exit 1 }"
+    )
+    proc = run(["powershell.exe", "-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", script])
+    return proc.returncode == 0
+
+
 def launchd_state(output: str) -> str:
     for line in output.splitlines():
         stripped = line.strip()
@@ -130,12 +208,54 @@ def watch_macos(
     return 1
 
 
+def watch_windows(
+    *,
+    service_task_name: str,
+    startup_launcher: Path | None,
+    status_file: Path,
+    run: RunCommand,
+    settle_seconds: float,
+) -> int:
+    if windows_bridge_process_running(run):
+        write_status(status_file, "active", "windows-process")
+        return 0
+
+    task_status = windows_scheduled_task_status(task_name=service_task_name, run=run)
+    if task_status != "not-installed":
+        start = run(["schtasks", "/Run", "/TN", service_task_name])
+        if settle_seconds > 0:
+            time.sleep(settle_seconds)
+        if windows_bridge_process_running(run):
+            write_status(status_file, "recovered", f"windows-task:{service_task_name}")
+            return 0
+        detail = status_text(start) or f"windows-task:{service_task_name}:{task_status}:start-failed"
+        write_status(status_file, "failed", detail)
+        return 1
+
+    launcher = startup_launcher or default_windows_startup_launcher_file()
+    if launcher.exists():
+        start = run(windows_startup_launcher_start_command(launcher))
+        if settle_seconds > 0:
+            time.sleep(settle_seconds)
+        if windows_bridge_process_running(run):
+            write_status(status_file, "recovered", f"windows-startup:{launcher}")
+            return 0
+        detail = status_text(start) or f"windows-startup:{launcher}:process-not-detected"
+        write_status(status_file, "failed", detail)
+        return 1
+
+    write_status(status_file, "failed", "windows:not-installed")
+    return 1
+
+
 def watch_once(
     *,
     os_name: str | None = None,
     service_name: str = SERVICE_NAME,
     launchd_label: str = LAUNCHD_LABEL,
     launchd_plist: Path | None = None,
+    windows_service_task_name: str = WINDOWS_TASK_NAME,
+    windows_startup_launcher: Path | None = None,
     status_file: Path | None = None,
     run: RunCommand = run_command,
     settle_seconds: float = 2.0,
@@ -158,6 +278,14 @@ def watch_once(
             run=run,
             settle_seconds=settle_seconds,
         )
+    if os_name == "Windows":
+        return watch_windows(
+            service_task_name=windows_service_task_name,
+            startup_launcher=windows_startup_launcher,
+            status_file=status_file,
+            run=run,
+            settle_seconds=settle_seconds,
+        )
 
     write_status(status_file, "unsupported", os_name)
     return 0

{codex_telegram_bridge-0.6.2 → codex_telegram_bridge-0.6.4/codex_telegram_bridge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-telegram-bridge
-Version: 0.6.2
+Version: 0.6.4
 Summary: Control a live Codex CLI session from Telegram.
 Author: Kang Daejong
 License: MIT
@@ -132,7 +132,7 @@ Answer media attachments
   -> send the actual media with sendPhoto/sendVideo/sendVoice/sendAudio
 
 Service restart
-  -> run a local watchdog every 60 seconds on Linux/WSL and macOS
+  -> run a local watchdog every 60 seconds
   -> restart or kickstart the bridge if the user service is inactive
   -> load a persistent JSONL cursor and final-answer dedup ring
   -> resume from the cursor when it still matches the current session file
@@ -219,8 +219,8 @@ The wizard will:
 - install `~/.local/bin/telegram-agent-bridge-run`
 - install and start a user service with systemd on Linux/WSL, launchd on macOS,
   or a per-user Windows Startup launcher
-- install a watchdog timer/LaunchAgent on Linux/WSL and macOS that recovers an
-  inactive bridge service
+- install a watchdog timer/LaunchAgent/Scheduled Task that recovers an inactive
+  bridge service
 - send a setup-complete test message
 
 Default setup mode is `repl`, which supports the visible Codex CLI transcript,
@@ -504,8 +504,8 @@ service was restarting.
 
 ## Service Watchdog
 
-When the setup wizard installs a background service on Linux/WSL or macOS, it
-also installs a small watchdog.
+When the setup wizard installs a background service, it also installs a small
+watchdog.
 
 On Windows, the wizard writes a per-user Startup launcher at
 `%APPDATA%\Microsoft\Windows\Start Menu\Programs\Startup\telegram-agent-bridge.bat`.
@@ -513,9 +513,13 @@ This does not require administrator rights. Setup also starts that launcher once
 immediately so you can send `/ping` without logging out and back in. If an older
 per-user `telegram-agent-bridge` Scheduled Task exists, `doctor` still reports
 its `schtasks /query` status; otherwise it reports whether the Startup launcher
-is installed. Windows watchdog install is not automated; `doctor` reports that
-Startup autostart is the supported Windows path instead of recommending another
-setup run for watchdog.
+is installed.
+
+The Windows watchdog is a separate per-user Scheduled Task named
+`telegram-agent-bridge-watchdog`. It runs `bridge_watchdog.py` every minute
+without administrator rights. If the bridge process is missing, it first restarts
+an older service Scheduled Task when present, otherwise it re-runs the Startup
+launcher and writes the same status file.
 
 On Linux and WSL, the wizard writes:
 

{codex_telegram_bridge-0.6.2 → codex_telegram_bridge-0.6.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "codex-telegram-bridge"
-version = "0.6.2"
+version = "0.6.4"
 description = "Control a live Codex CLI session from Telegram."
 readme = "README.md"
 requires-python = ">=3.10"

{codex_telegram_bridge-0.6.2 → codex_telegram_bridge-0.6.4}/tests/test_setup_wizard.py

@@ -5,6 +5,7 @@ import subprocess
 import tempfile
 import unittest
 from pathlib import Path
+from unittest import mock
 
 import bridge_setup as setup
 
@@ -174,7 +175,23 @@ class SetupWizardTests(unittest.TestCase):
         self.assertIn("/mnt/c/Users/Ada/very-long-profile-segment", xml_text)
         self.assertIn(("schtasks", "/Run", "/TN", "tab-test-autostart"), commands)
 
-    def test_install_service_windows_installs_startup_launcher_without_schtasks(self):
+    def test_install_runner_windows_writes_python_runner_with_lf(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            runner = Path(tmpdir) / "telegram-agent-bridge-run"
+            env_file = Path(r"C:\Users\gb\.config\telegram-agent-bridge.env")
+
+            setup.install_runner(runner, env_file, os_name="Windows")
+
+            raw = runner.read_bytes()
+            text = raw.decode("utf-8")
+            self.assertNotIn(b"\r", raw)
+            self.assertIn("import os", text)
+            self.assertIn("shlex.split", text)
+            self.assertIn(repr(str(env_file)), text)
+            self.assertIn("telegram_agent_bridge.py", text)
+            self.assertNotIn("set -euo pipefail", text)
+
+    def test_install_service_windows_installs_native_startup_launcher_without_bash(self):
         commands = []
 
         def run(cmd, check=False):
@@ -183,22 +200,26 @@ class SetupWizardTests(unittest.TestCase):
 
         with tempfile.TemporaryDirectory() as tmpdir:
             startup_dir = Path(tmpdir) / "Startup"
-            installed = setup.install_service(
-                Path(r"C:\Users\gb\.local\bin\telegram-agent-bridge-run"),
-                os_name="Windows",
-                run=run,
-                task_name="telegram-agent-bridge",
-                bash_host=setup.WindowsBashHost(kind="git-bash", executable=r"C:\Program Files\Git\bin\bash.exe"),
-                windows_startup_dir=startup_dir,
-            )
+            with mock.patch.object(setup.sys, "executable", r"C:\Python312\python.exe"):
+                installed = setup.install_service(
+                    Path(r"C:\Users\gb\.local\bin\telegram-agent-bridge-run"),
+                    os_name="Windows",
+                    run=run,
+                    task_name="telegram-agent-bridge",
+                    bash_host=setup.WindowsBashHost(kind="git-bash", executable=r"C:\Program Files\Git\bin\bash.exe"),
+                    windows_startup_dir=startup_dir,
+                )
 
             launcher = startup_dir / "telegram-agent-bridge.bat"
             self.assertEqual(installed, launcher)
             self.assertTrue(launcher.exists())
             launcher_text = launcher.read_text(encoding="utf-8")
             self.assertIn("Start-Process", launcher_text)
-            self.assertIn("C:\\Program Files\\Git\\bin\\bash.exe", launcher_text)
-            self.assertIn("/c/Users/gb/.local/bin/telegram-agent-bridge-run", launcher_text)
+            self.assertIn(r"C:\Python312\python.exe", launcher_text)
+            self.assertIn(r"C:\Users\gb\.local\bin\telegram-agent-bridge-run", launcher_text)
+            self.assertNotIn("bash.exe", launcher_text)
+            self.assertNotIn("wsl.exe", launcher_text)
+            self.assertNotIn("/c/Users/gb", launcher_text)
             self.assertIn(">NUL 2>NUL", launcher_text)
 
         self.assertNotIn(("schtasks", "/Create"), [cmd[:2] for cmd in commands])
@@ -215,8 +236,11 @@ class SetupWizardTests(unittest.TestCase):
             launcher.write_text("@echo off\n", encoding="utf-8")
 
             def missing_task(cmd, check=False):
-                self.assertEqual(cmd[:4], ["schtasks", "/Query", "/TN", "telegram-agent-bridge"])
-                return completed(cmd, returncode=1, stderr="ERROR: Access is denied.\r\n")
+                if cmd[:4] == ["schtasks", "/Query", "/TN", "telegram-agent-bridge"]:
+                    return completed(cmd, returncode=1, stderr="ERROR: Access is denied.\r\n")
+                if cmd[0] == "powershell.exe" and "Get-CimInstance" in cmd[-1]:
+                    return completed(cmd, returncode=1, stdout="missing")
+                self.fail(f"unexpected command: {cmd}")
 
             self.assertEqual(
                 setup.service_status(
@@ -228,6 +252,26 @@ class SetupWizardTests(unittest.TestCase):
                 "startup-installed",
             )
 
+            def running_process(cmd, check=False):
+                if cmd[:4] == ["schtasks", "/Query", "/TN", "telegram-agent-bridge"]:
+                    return completed(cmd, returncode=1, stderr="ERROR: Access is denied.\r\n")
+                if cmd[0] == "powershell.exe" and "Get-CimInstance" in cmd[-1]:
+                    return completed(cmd, returncode=0, stdout="running")
+                self.fail(f"unexpected command: {cmd}")
+
+            self.assertEqual(
+                setup.service_status(
+                    os_name="Windows",
+                    run=running_process,
+                    task_name="telegram-agent-bridge",
+                    windows_startup_dir=startup_dir,
+                ),
+                "running",
+            )
+
+    def test_windows_startup_installed_is_not_running(self):
+        self.assertFalse(setup.service_is_running("startup-installed"))
+
     def test_windows_service_status_parses_schtasks_query(self):
         def running(cmd, check=False):
             self.assertEqual(cmd[:4], ["schtasks", "/Query", "/TN", "tab-test-autostart"])
@@ -276,7 +320,7 @@ class SetupWizardTests(unittest.TestCase):
         self.assertIn("/ping", params["text"])
         self.assertIn("schtasks /Run /TN telegram-agent-bridge", params["text"])
 
-    def test_setup_complete_message_treats_windows_startup_launcher_as_ready(self):
+    def test_setup_complete_message_treats_windows_startup_launcher_as_not_confirmed_running(self):
         api = FakeApi()
 
         self.assertTrue(
@@ -291,9 +335,9 @@ class SetupWizardTests(unittest.TestCase):
 
         _token, method, _timeout, params = api.calls[-1]
         self.assertEqual(method, "sendMessage")
-        self.assertIn("Windows Startup autostart is installed", params["text"])
+        self.assertIn("Background service is not running (startup-installed)", params["text"])
         self.assertIn("/ping", params["text"])
-        self.assertNotIn("Start it with", params["text"])
+        self.assertIn("Start it with", params["text"])
 
     def test_noninteractive_setup_writes_config_and_runner(self):
         with tempfile.TemporaryDirectory() as tmpdir: