alive-ai 0.1.8 → 0.1.10

package/README.md

@@ -61,10 +61,11 @@ alive-ai init my-ai
 | `npx . demo` | Run a keyless animated dashboard demo. |
 | `npx . start` | Start the runtime using the configured input channel, usually Telegram. |
 | `npx . start --skip-install` | Start again without reinstalling Python dependencies. |
+| `npx . stop` | Stop the running Alive-AI process for this project. |
 | `npx . update` | Refresh runtime files from the latest npm package while preserving config/data/media. |
 | `npx . uninstall` | Remove Alive-AI runtime files, config, venv, cache, data, and media from the project. |
 
-`start` and `chat` check npm for a newer Alive-AI version. You can update, skip once, or skip that specific version. Stop terminal chat with `/exit` or `Ctrl+C`.
+`start` and `chat` check npm for a newer Alive-AI version. You can update, skip once, or skip that specific version. Stop terminal chat with `/exit` or `Ctrl+C`. Stop foreground Telegram/runtime mode with `Ctrl+C`; if a stale process is still alive, run `npx . stop` from the project root.
 
 `doctor --fix` is conservative: it prints the exact install command before running anything and asks separately for each missing tool. On macOS it uses Homebrew, on Windows it uses winget, and on Linux it supports apt, dnf, and pacman where possible. Redis is optional; doctor only checks or fixes it when `REDIS_VECTOR_MEMORY_ENABLED` is true.
 
@@ -292,7 +293,7 @@ Implemented:
 - [x] Local WebUI dashboard with live state streaming
 - [x] Optional hybrid OpenMind cloud/local semantic memory
 - [x] Optional Redis Stack vector cache with setup and doctor checks
-- [x] npm/npx CLI scaffold, setup, doctor, demo, chat, and start commands
+- [x] npm/npx CLI scaffold, setup, doctor, demo, chat, start, stop, and uninstall commands
 - [x] Update prompt and project uninstall command
 - [x] `doctor --fix` guided system dependency installer
 - [x] Clean public repo with private personas, media, runtime data, and multi-AI orchestration removed

package/cli/index.js

@@ -48,6 +48,7 @@ Usage:
   alive-ai demo [--port 8080]     Run the animated dashboard demo
   alive-ai update [--yes]         Update this project from the latest package
   alive-ai start [--skip-install] Install Python deps if needed and start runtime
+  alive-ai stop                   Stop the running project runtime
   alive-ai chat [--skip-install]  Start split-pane terminal chat and logs
   alive-ai chat --plain           Start raw terminal chat without the TUI
   alive-ai doctor [--fix]         Check local prerequisites and optionally install missing tools
@@ -61,6 +62,7 @@ Quick start:
   npx . chat
   npx . demo
   npx . start
+  npx . stop
   npx . uninstall`);
 }
 
@@ -934,6 +936,116 @@ function ensurePythonEnv(skipInstall) {
   return pythonBin;
 }
 
+function isChildRunning(child) {
+  return child && child.exitCode === null && child.signalCode === null;
+}
+
+function signalExitCode(signal) {
+  if (signal === "SIGINT") return 130;
+  if (signal === "SIGTERM") return 143;
+  if (signal === "SIGHUP") return 129;
+  if (signal === "SIGKILL") return 137;
+  return 1;
+}
+
+function runtimeInfoPath() {
+  return path.join(process.cwd(), ".alive-ai", "runtime.json");
+}
+
+function legacyRuntimePidPath() {
+  return path.join(process.cwd(), ".alive-ai", "runtime.pid");
+}
+
+function readRuntimeInfo() {
+  try {
+    const info = readJson(runtimeInfoPath());
+    const pid = Number(info.pid);
+    return Number.isInteger(pid) && pid > 0 ? { ...info, pid } : null;
+  } catch {}
+
+  try {
+    const pid = Number(fs.readFileSync(legacyRuntimePidPath(), "utf8").trim());
+    return Number.isInteger(pid) && pid > 0 ? { pid } : null;
+  } catch {
+    return null;
+  }
+}
+
+function writeRuntimeInfo(pid, details = {}) {
+  if (!Number.isInteger(pid) || pid <= 0) return;
+  writeJson(runtimeInfoPath(), {
+    pid,
+    cwd: process.cwd(),
+    startedAt: new Date().toISOString(),
+    ...details,
+  });
+}
+
+function clearRuntimeInfo(pid) {
+  const info = readRuntimeInfo();
+  if (info && pid && info.pid !== pid) return;
+  for (const filePath of [runtimeInfoPath(), legacyRuntimePidPath()]) {
+    try {
+      fs.rmSync(filePath, { force: true });
+    } catch {}
+  }
+}
+
+function processIsAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error && error.code === "EPERM";
+  }
+}
+
+function waitForProcessExit(pid, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  return new Promise((resolve) => {
+    const tick = () => {
+      if (!processIsAlive(pid)) return resolve(true);
+      if (Date.now() >= deadline) return resolve(false);
+      setTimeout(tick, 150);
+    };
+    tick();
+  });
+}
+
+async function stopProjectRuntime() {
+  const info = readRuntimeInfo();
+  if (!info || !info.pid) {
+    console.log("No Alive-AI runtime pid found for this project.");
+    return;
+  }
+
+  if (!processIsAlive(info.pid)) {
+    clearRuntimeInfo(info.pid);
+    console.log("Removed stale Alive-AI runtime pid file.");
+    return;
+  }
+
+  console.log(`Stopping Alive-AI runtime pid ${info.pid}...`);
+  try {
+    process.kill(info.pid, "SIGTERM");
+  } catch (error) {
+    console.error(`Could not stop pid ${info.pid}: ${error.message}`);
+    process.exit(1);
+  }
+
+  if (!(await waitForProcessExit(info.pid, 5000))) {
+    console.error("Alive-AI did not stop cleanly; forcing shutdown.");
+    try {
+      process.kill(info.pid, "SIGKILL");
+    } catch {}
+    await waitForProcessExit(info.pid, 2000);
+  }
+
+  clearRuntimeInfo(info.pid);
+  console.log("Alive-AI stopped.");
+}
+
 async function startRuntime(args, options = {}) {
   if (!fs.existsSync(path.join(process.cwd(), "config", "settings.json"))) {
     console.log("Missing config/settings.json. Starting onboarding first.");
@@ -969,25 +1081,105 @@ async function startRuntime(args, options = {}) {
   };
   if (options.tui) env.ALIVE_AI_TUI = "1";
 
+  const existingRuntime = readRuntimeInfo();
+  if (existingRuntime && processIsAlive(existingRuntime.pid)) {
+    console.error(`Alive-AI already appears to be running for this project (pid ${existingRuntime.pid}).`);
+    console.error("Run `npx . stop` before starting a new session.");
+    process.exit(1);
+  }
+  if (existingRuntime) clearRuntimeInfo(existingRuntime.pid);
+
   const child = spawn(pythonBin, ["main.py", ...extraArgs], {
     stdio: options.tui ? ["pipe", "pipe", "pipe"] : "inherit",
     cwd: process.cwd(),
     env,
   });
+  writeRuntimeInfo(child.pid, { inputChannel: effectiveInputChannel });
 
   if (options.tui) {
     const code = await runRuntimeTui(child, {
       dashboard: `http://127.0.0.1:${readProjectSettings().WEBUI_PORT || DEFAULT_PORT}`,
     });
+    clearRuntimeInfo(child.pid);
     process.exitCode = code;
     return;
   }
 
   await new Promise((resolve) => {
-    child.on("exit", (code) => {
-      process.exitCode = code || 0;
+    let stopRequested = false;
+    let stopSignal = null;
+    let finished = false;
+    const timers = [];
+
+    function cleanup() {
+      for (const timer of timers) clearTimeout(timer);
+      process.off("SIGINT", onSignal);
+      process.off("SIGTERM", onSignal);
+      process.off("SIGHUP", onSignal);
+      clearRuntimeInfo(child.pid);
+    }
+
+    function requestStop(signal) {
+      stopSignal = stopSignal || signal;
+      if (stopRequested) {
+        if (isChildRunning(child)) {
+          console.error("\nAlive-AI is still stopping; forcing shutdown.");
+          child.kill("SIGKILL");
+        }
+        return;
+      }
+
+      stopRequested = true;
+      process.exitCode = signalExitCode(signal);
+      console.log(`\nStopping Alive-AI (${signal})...`);
+
+      try {
+        child.kill(signal === "SIGHUP" ? "SIGTERM" : signal);
+      } catch {}
+
+      timers.push(setTimeout(() => {
+        if (isChildRunning(child)) child.kill("SIGTERM");
+      }, 1500));
+
+      timers.push(setTimeout(() => {
+        if (isChildRunning(child)) {
+          console.error("Alive-AI did not stop cleanly; forcing shutdown.");
+          child.kill("SIGKILL");
+        }
+      }, 5000));
+
+      for (const timer of timers) timer.unref();
+    }
+
+    function onSignal(signal) {
+      requestStop(signal);
+    }
+
+    child.on("error", (error) => {
+      if (finished) return;
+      finished = true;
+      cleanup();
+      console.error(`Alive-AI failed to start: ${error.message}`);
+      process.exitCode = 1;
       resolve();
     });
+    child.on("close", (code, signal) => {
+      if (finished) return;
+      finished = true;
+      cleanup();
+      if (stopRequested) {
+        process.exitCode = code && code !== 0 ? code : signalExitCode(signal || stopSignal);
+      } else if (typeof code === "number") {
+        process.exitCode = code;
+      } else {
+        process.exitCode = signalExitCode(signal || stopSignal);
+      }
+      resolve();
+    });
+
+    process.on("SIGINT", onSignal);
+    process.on("SIGTERM", onSignal);
+    process.on("SIGHUP", onSignal);
   });
 }
 
@@ -1082,6 +1274,7 @@ async function main() {
   if (command === "update") return updateProject(args);
   if (command === "demo") return startDemo(args);
   if (command === "start") return startRuntime(args);
+  if (command === "stop") return stopProjectRuntime(args);
   if (command === "chat") return startTerminalChat(args);
   if (command === "doctor") return doctor(args);
   if (command === "uninstall") return uninstallProject(args);

package/cli/tui.js

@@ -65,6 +65,10 @@ function runRuntimeTui(child, options = {}) {
   let resolved = false;
   const isTty = process.stdin.isTTY && process.stdout.isTTY;
 
+  function childRunning() {
+    return child.exitCode === null && child.signalCode === null;
+  }
+
   function addChat(role, text) {
     state.chat.push({ role, text: String(text || "") });
     if (state.chat.length > 200) state.chat = state.chat.slice(-200);
@@ -173,10 +177,10 @@ function runRuntimeTui(child, options = {}) {
       if (child.stdin.writable) child.stdin.end();
     } catch {}
     setTimeout(() => {
-      if (!child.killed && child.exitCode === null) child.kill("SIGTERM");
+      if (childRunning()) child.kill("SIGTERM");
     }, 1200).unref();
     setTimeout(() => {
-      if (!child.killed && child.exitCode === null) child.kill("SIGKILL");
+      if (childRunning()) child.kill("SIGKILL");
     }, 3500).unref();
   }
 

package/core/message_handler.py

@@ -1102,7 +1102,12 @@ async def _send_response(self, response, emotion, chat_id, text, user_id="defaul
         await self.nervous.emit("chat_action_voice", {})
         vp = await self._voice.generate(response, mood=mood)
         if vp:
-            await self.nervous.emit("send_voice_file", {"file_path": vp, "chat_id": chat_id})
+            await self.nervous.emit("send_voice_file", {
+                "file_path": vp,
+                "chat_id": chat_id,
+                "fallback_text": response,
+                "mood": mood,
+            })
             return
     await self.nervous.emit("send_text", {"text": response, "mood": mood, "chat_id": chat_id})
 

package/docs/index.html

@@ -291,9 +291,9 @@ npx . chat</code></pre>
     <p>`npx . setup` asks for the minimum required configuration and lets optional systems be skipped. Use `local` for Ollama, `skip` for optional keys, OpenMind cloud or local for shared long-term semantic memory, and leave Redis off unless you specifically want a local Redis Stack vector cache.</p>
     <div class="steps">
       <div class="step"><strong>Start local terminal chat</strong><span>`npx . chat` starts the same runtime with chat on the left, logs on the right, and the WebUI at `http://127.0.0.1:8080`.</span></div>
-      <div class="step"><strong>Start Telegram/runtime mode</strong><span>`npx . start` starts the configured input channel and validates Telegram before polling. Stop foreground runs with `Ctrl+C`.</span></div>
+      <div class="step"><strong>Start Telegram/runtime mode</strong><span>`npx . start` starts the configured input channel and validates Telegram before polling. Stop foreground runs with `Ctrl+C`; use `npx . stop` to clear a stale project runtime.</span></div>
       <div class="step"><strong>Install missing tools</strong><span>`npx . doctor --fix` asks `y/N` for each missing tool. Redis is checked only when the Redis vector cache is enabled.</span></div>
-      <div class="step"><strong>Keep it updated</strong><span>`start` and `chat` check npm for newer versions. Use `npx . update` manually or `npx . uninstall` to remove local runtime files.</span></div>
+      <div class="step"><strong>Keep it updated</strong><span>`start` and `chat` check npm for newer versions. Use `npx . update` manually, `npx . stop` for a stuck session, or `npx . uninstall` to remove local runtime files.</span></div>
       <div class="step"><strong>Use OpenMind</strong><span>Choose `openmind-cloud` for `https://theopenmind.pro` or `openmind-local` for `http://127.0.0.1:3333`.</span></div>
       <div class="step"><strong>Preview the dashboard</strong><span>`npx . demo` is keyless. The real runtime dashboard streams local state over SSE.</span></div>
     </div>

package/input/telegram/listener.py

@@ -4,6 +4,7 @@ Listen for Telegram messages and send reactions, voice, images
 """
 
 import asyncio
+import contextlib
 import os
 from pathlib import Path
 from telegram import Update, InputFile, ReactionTypeEmoji
@@ -30,6 +31,8 @@ class TelegramListener:
         self.chat_id = None
         self.user_id = None
         self.last_message_id = None
+        self._stop_event = None
+        self._stopping = False
 
         # Command handler (initialized later with dependencies)
         self.commands = None
@@ -63,6 +66,8 @@ class TelegramListener:
 
     async def start(self):
         """Start listening - blocks forever"""
+        self._stop_event = asyncio.Event()
+
         # First check environment variable (from secrets.env), then settings
         token = os.environ.get("TELEGRAM_TOKEN") or self.config.settings.get("telegram_token")
 
@@ -178,20 +183,34 @@ class TelegramListener:
             ) from None
 
         # Block forever - keep the bot alive
-        await asyncio.Event().wait()
+        try:
+            await self._stop_event.wait()
+        except asyncio.CancelledError:
+            await self.stop()
+            raise
+        finally:
+            await self.stop()
 
     async def stop(self):
         """Stop Telegram cleanly if it was started."""
-        if not self.app:
+        if self._stop_event and not self._stop_event.is_set():
+            self._stop_event.set()
+        if self._stopping or not self.app:
             return
+        self._stopping = True
+        app = self.app
+        self.app = None
         try:
-            if self.app.updater and self.app.updater.running:
-                await self.app.updater.stop()
-            if self.app.running:
-                await self.app.stop()
-            await self.app.shutdown()
+            if app.updater and app.updater.running:
+                with contextlib.suppress(Exception):
+                    await app.updater.stop()
+            if app.running:
+                with contextlib.suppress(Exception):
+                    await app.stop()
+            with contextlib.suppress(Exception):
+                await app.shutdown()
         finally:
-            self.app = None
+            self._stopping = False
 
     async def _on_message(self, update: Update, context):
         """Handle incoming message"""
@@ -359,12 +378,13 @@ class TelegramListener:
             print(f"[Telegram] Send text error: {e}")
 
     async def _send_voice_file(self, data: dict):
-        """Send voice file (OGG format for Telegram)"""
+        """Send voice file, falling back to audio/text if Telegram rejects it."""
         if not self.app:
             return
 
         chat_id = data.get("chat_id", self.chat_id)
         file_path = data.get("file_path", "")
+        fallback_text = data.get("fallback_text", "")
 
         if not chat_id or not file_path:
             return
@@ -372,18 +392,32 @@ class TelegramListener:
         path = Path(file_path)
         if not path.exists():
             print(f"[Telegram] Voice file not found: {file_path}")
+            if fallback_text:
+                await self._send_text({"chat_id": chat_id, "text": fallback_text})
             return
 
         try:
-            with open(path, "rb") as voice_file:
-                await self.app.bot.send_voice(
+            if path.suffix.lower() == ".ogg":
+                with open(path, "rb") as voice_file:
+                    await self.app.bot.send_voice(
+                        chat_id=chat_id,
+                        voice=voice_file,
+                        caption=data.get("caption", "")
+                    )
+                print(f"[Telegram] Sent voice: {file_path}")
+                return
+
+            with open(path, "rb") as audio_file:
+                await self.app.bot.send_audio(
                     chat_id=chat_id,
-                    voice=voice_file,
+                    audio=audio_file,
                     caption=data.get("caption", "")
                 )
-            print(f"[Telegram] Sent voice: {file_path}")
+            print(f"[Telegram] Sent audio fallback: {file_path}")
         except Exception as e:
-            print(f"[Telegram] Send voice error: {e}")
+            print(f"[Telegram] Send voice/audio error: {e}")
+            if fallback_text:
+                await self._send_text({"chat_id": chat_id, "text": fallback_text})
 
     async def _send_image(self, data: dict):
         """Send image file"""

package/main.py

@@ -12,6 +12,7 @@ import argparse
 import contextlib
 import json
 import os
+import signal
 import sys
 import traceback
 from pathlib import Path
@@ -91,6 +92,28 @@ async def main() -> None:
 
     ai = Self(ROOT)
     webui_task = None
+    runtime_task = None
+    stop_task = None
+    stop_event = asyncio.Event()
+    loop = asyncio.get_running_loop()
+
+    def request_stop(signame: str) -> None:
+        if stop_event.is_set():
+            return
+        print(f"\n[Alive-AI] Stopping ({signame})...")
+        stop_event.set()
+
+    signal_handlers = []
+    for signame in ("SIGINT", "SIGTERM"):
+        signum = getattr(signal, signame, None)
+        if signum is None:
+            continue
+        try:
+            loop.add_signal_handler(signum, request_stop, signame)
+            signal_handlers.append(signum)
+        except (NotImplementedError, RuntimeError, ValueError):
+            pass
+
     webui_enabled = str(settings.get("WEBUI_ENABLED", os.environ.get("WEBUI_ENABLED", "true"))).lower() != "false"
     webui_port = int(settings.get("WEBUI_PORT", os.environ.get("WEBUI_PORT", "8080")))
 
@@ -108,7 +131,25 @@ async def main() -> None:
                 print(f"[Alive-AI] WebUI unavailable: {exc}")
 
         input_channel = args.input or os.environ.get("ALIVE_AI_INPUT_CHANNEL") or settings.get("INPUT_CHANNEL", "telegram")
-        await ai.start(input_channel=input_channel)
+        runtime_task = asyncio.create_task(ai.start(input_channel=input_channel))
+        stop_task = asyncio.create_task(stop_event.wait())
+        done, _pending = await asyncio.wait(
+            {runtime_task, stop_task},
+            return_when=asyncio.FIRST_COMPLETED,
+        )
+
+        if stop_task in done:
+            if runtime_task and not runtime_task.done():
+                runtime_task.cancel()
+                with contextlib.suppress(asyncio.CancelledError):
+                    await runtime_task
+            return
+
+        if stop_task and not stop_task.done():
+            stop_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await stop_task
+        await runtime_task
     except KeyboardInterrupt:
         print("\n[Alive-AI] Stopping...")
     except Exception as exc:
@@ -120,6 +161,17 @@ async def main() -> None:
                 print("[Alive-AI] Telegram could not start. Check the bot token/network, or run `npx . chat` for terminal mode.")
         sys.exit(1)
     finally:
+        for signum in signal_handlers:
+            with contextlib.suppress(Exception):
+                loop.remove_signal_handler(signum)
+        if stop_task and not stop_task.done():
+            stop_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await stop_task
+        if runtime_task and not runtime_task.done():
+            runtime_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await runtime_task
         with contextlib.suppress(Exception):
             await ai.stop()
         if webui_task:

package/output/voice/gtts_tts.py

@@ -8,6 +8,7 @@ import asyncio
 import re
 import tempfile
 import subprocess
+import warnings
 from pathlib import Path
 from typing import Optional
 from concurrent.futures import ThreadPoolExecutor
@@ -113,17 +114,29 @@ class GTTS:
             tts.write_to_fp(mp3_buffer)
             mp3_buffer.seek(0)
 
-            # Convert MP3 to OGG for Telegram
-            # If pydub is available, convert to OGG
+            # Convert MP3 to OGG Opus for Telegram voice notes.
+            # pydub's default OGG codec can resolve to Vorbis, which Telegram
+            # does not want for voice notes and some ffmpeg builds do not ship.
             try:
+                warnings.filterwarnings("ignore", category=SyntaxWarning, module=r"pydub\..*")
                 from pydub import AudioSegment
                 audio = AudioSegment.from_mp3(mp3_buffer)
                 ogg_buffer = io.BytesIO()
-                audio.export(ogg_buffer, format="ogg")
+                audio.export(
+                    ogg_buffer,
+                    format="ogg",
+                    codec="libopus",
+                    bitrate="32k",
+                    parameters=["-application", "voip"],
+                )
                 ogg_buffer.seek(0)
                 return ogg_buffer.read()
             except ImportError:
-                # No pydub - return MP3, Telegram accepts it too
+                # No pydub - return MP3 and let the sender use send_audio.
+                mp3_buffer.seek(0)
+                return mp3_buffer.read()
+            except Exception as exc:
+                print(f"[GTTS] OGG Opus conversion failed, falling back to MP3: {exc}")
                 mp3_buffer.seek(0)
                 return mp3_buffer.read()
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alive-ai",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Local-first emotional AI runtime with memory, impulses, and a live dashboard.",
   "license": "MIT",
   "homepage": "https://vindepemarte.github.io/alive-ai/",

package/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "alive-ai-runtime"
-version = "0.1.8"
+version = "0.1.9"
 description = "Local-first emotional AI runtime with memory, impulses, and a live dashboard."
 readme = "README.md"
 requires-python = ">=3.11"