linkgravity 1.7.3 → 1.7.5

package/bin/cli.js

@@ -14,7 +14,7 @@ const {
     LGY_SCRIPT_PATH,
 } = require('./platforms');
 
-const { python: pythonExe, isWin } = require('../npm-scripts/venv-paths');
+const { daemonPython, isWin } = require('../npm-scripts/venv-paths');
 const { isEnvironmentReady } = require('../npm-scripts/ensure-env');
 
 const cmd = process.argv[2];
@@ -203,15 +203,34 @@ function verifyStartup() {
             cwd: PM2_CWD,
         });
 
+        const baseline = getPm2Proc()?.pm2_env?.restart_time ?? 0;
+
         let settled = false;
         const finish = (ok) => {
             if (settled) return;
             settled = true;
             clearTimeout(timer);
+            clearInterval(watchdog);
             cp.kill();
             resolve(ok);
         };
 
+        // A process that exits on startup never logs anything for the stream below to match, so
+        // pm2's own counters are the only signal that it is dying and being restarted.
+        const watchdog = setInterval(() => {
+            const proc = getPm2Proc();
+            if (!proc) return;
+            const { status, restart_time: restarts = 0 } = proc.pm2_env;
+            if (status === 'errored' || restarts > baseline) {
+                console.log(
+                    `\n\n${color.yellow}❌ The daemon keeps exiting - pm2 has restarted it ` +
+                        `${restarts - baseline} time(s) (status: ${status}).${color.reset}`,
+                );
+                console.log(`   Run ${color.cyan}lgy logs${color.reset} to see why.\n`);
+                finish(false);
+            }
+        }, 2000);
+
         let timer = setTimeout(() => {
             console.log(
                 `\n\n${color.yellow}⏳ Startup verification timed out. Run 'lgy logs' to check status manually.${color.reset}`,
@@ -302,7 +321,31 @@ function findAgyBin() {
     return null;
 }
 
-function getPm2Proc() {
+// Returns null when the daemon can be started, or the reason it can't.
+function launchBlocker() {
+    const settings = getSettings();
+    const anyConfigured = Object.keys(PLATFORMS).some(
+        (key) => platformState(key, settings).configured,
+    );
+    if (!anyConfigured) {
+        return (
+            'No messenger is configured yet - set up at least one of Discord, Telegram, or ' +
+            `Slack first: ${color.cyan}lgy setup${color.reset}`
+        );
+    }
+    if (!findAgyBin()) {
+        return (
+            "Couldn't find the agy CLI (checked $AGY_BIN_PATH, ~/.local/bin/agy, and PATH). " +
+            'Install/configure agy first, or set the AGY_BIN_PATH environment variable to its location.'
+        );
+    }
+    return null;
+}
+
+// pm2 keys an app by name AND script path, so an install that moved (node version switch, npm prefix
+// change, npm link) registers a second app under the same name instead of replacing the first, and
+// every name-based pm2 command then acts on both at once.
+function getPm2Procs() {
     const jlist = spawnSync(process.execPath, [PM2_BIN, 'jlist'], { stdio: 'pipe' });
     if (jlist.status !== 0) return null;
 
@@ -313,7 +356,7 @@ function getPm2Proc() {
         if (out[i] !== '[') continue;
         try {
             const procs = JSON.parse(out.slice(i));
-            if (Array.isArray(procs)) return procs.find((p) => p.name === LGY_PM2_NAME) || null;
+            if (Array.isArray(procs)) return procs.filter((p) => p.name === LGY_PM2_NAME);
         } catch (e) {}
     }
 
@@ -323,6 +366,71 @@ function getPm2Proc() {
     return null;
 }
 
+function isOurRegistration(proc) {
+    const registered = proc.pm2_env.pm_exec_path || '';
+    if (!isWin) return registered === LGY_SCRIPT_PATH;
+    return registered.toLowerCase() === LGY_SCRIPT_PATH.toLowerCase();
+}
+
+function printRegistrations(procs) {
+    for (const proc of procs) {
+        const mine = isOurRegistration(proc) ? '  <- this install' : '';
+        console.log(
+            `    ${String(proc.pm2_env.status).padEnd(8)} ${proc.pm2_env.pm_exec_path}${mine}`,
+        );
+    }
+}
+
+let duplicatesReported = false;
+function pickPm2Proc(procs) {
+    if (!procs || procs.length === 0) return null;
+
+    if (procs.length > 1 && !duplicatesReported) {
+        duplicatesReported = true;
+        console.log(
+            `\n${color.yellow}⚠${color.reset} pm2 has ${procs.length} apps registered as '${LGY_PM2_NAME}' - only this install's should be:`,
+        );
+        printRegistrations(procs);
+        console.log(
+            `   Everything below reports on one of them. Run ${color.cyan}lgy start${color.reset} to drop the stale ones.\n`,
+        );
+    }
+
+    const isOnline = (proc) => proc.pm2_env.status === 'online';
+    return (
+        procs.find((proc) => isOnline(proc) && isOurRegistration(proc)) ||
+        procs.find(isOnline) ||
+        procs.find(isOurRegistration) ||
+        procs[0]
+    );
+}
+
+function getPm2Proc() {
+    return pickPm2Proc(getPm2Procs());
+}
+
+function startDaemon() {
+    runPm2([
+        'start',
+        LGY_SCRIPT_PATH,
+        '--interpreter',
+        daemonPython,
+        '--name',
+        LGY_PM2_NAME,
+        '--update-env',
+    ]);
+}
+
+// The saved autostart list keeps the removed paths until pm2 save runs, so a reboot restores them.
+function clearRegistrations(procs) {
+    console.log(
+        `\n${color.yellow}⚠${color.reset} pm2 has ${procs.length} app(s) registered as '${LGY_PM2_NAME}', not all from this install:`,
+    );
+    printRegistrations(procs);
+    console.log('   Removing all of them and registering this install alone.\n');
+    runPm2(['delete', LGY_PM2_NAME]);
+}
+
 // Best-effort: pm2 has no API for "is this registered to start on boot", so this checks the OS directly and returns null (unknown) if that check itself isn't available.
 function isAutostartEnabled() {
     if (isWin) return null;
@@ -363,8 +471,11 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
     const pkg = require('../package.json');
     console.log(`linkgravity v${pkg.version}`);
 } else if (cmd === 'start') {
-    const existing = getPm2Proc();
-    if (existing && existing.pm2_env.status === 'online') {
+    const registered = getPm2Procs() || [];
+    const stale = registered.filter((proc) => !isOurRegistration(proc));
+    const existing = registered.find(isOurRegistration);
+
+    if (!stale.length && existing && existing.pm2_env.status === 'online') {
         console.log(
             `\n${color.yellow}⚠${color.reset} LinkGravity is already running. ` +
                 `Use ${color.cyan}lgy restart${color.reset} to apply changes, or ${color.cyan}lgy stop${color.reset} first.\n`,
@@ -372,24 +483,9 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
         process.exit(1);
     }
 
-    const settings = getSettings();
-    const anyConfigured = Object.keys(PLATFORMS).some(
-        (key) => platformState(key, settings).configured,
-    );
-    if (!anyConfigured) {
-        console.log(
-            `\n${color.yellow}⚠${color.reset} No messenger is configured yet - ` +
-                `set up at least one of Discord, Telegram, or Slack first: ${color.cyan}lgy setup${color.reset}\n`,
-        );
-        process.exit(1);
-    }
-
-    if (!findAgyBin()) {
-        console.log(
-            `\n${color.yellow}⚠${color.reset} Couldn't find the agy CLI ` +
-                `(checked $AGY_BIN_PATH, ~/.local/bin/agy, and PATH). Install/configure agy first, ` +
-                `or set the AGY_BIN_PATH environment variable to its location.\n`,
-        );
+    const blocker = launchBlocker();
+    if (blocker) {
+        console.log(`\n${color.yellow}⚠${color.reset} ${blocker}\n`);
         process.exit(1);
     }
 
@@ -400,16 +496,11 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
 
     repairHookRegistration();
 
+    if (stale.length) clearRegistrations(registered);
+
     info('Starting LinkGravity daemon...');
-    runPm2([
-        'start',
-        LGY_SCRIPT_PATH,
-        '--interpreter',
-        pythonExe,
-        '--name',
-        LGY_PM2_NAME,
-        '--update-env',
-    ]);
+    startDaemon();
+    if (stale.length) runPm2(['save']);
     verifyStartup().then((ok) => process.exit(ok ? 0 : 1));
 } else if (cmd === 'stop') {
     info('Stopping LinkGravity daemon...');
@@ -417,6 +508,18 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
     runPm2(['reset', LGY_PM2_NAME]);
     success('Daemon stopped successfully.\n');
 } else if (cmd === 'restart') {
+    const registered = getPm2Procs() || [];
+    if (registered.some((proc) => !isOurRegistration(proc))) {
+        console.log(
+            `\n${color.yellow}⚠${color.reset} pm2 has ${registered.length} app(s) registered as '${LGY_PM2_NAME}', and a restart would start every one of them:`,
+        );
+        printRegistrations(registered);
+        console.log(
+            `   Run ${color.cyan}lgy start${color.reset} instead - it drops the stale ones first.\n`,
+        );
+        process.exit(1);
+    }
+
     info('Restarting LinkGravity daemon...');
     runPm2(['restart', LGY_PM2_NAME, '--update-env']);
     runPm2(['reset', LGY_PM2_NAME]);
@@ -615,8 +718,10 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
         process.exit(0);
     }
 
-    const procBeforeUpdate = getPm2Proc();
+    const registeredBeforeUpdate = getPm2Procs() || [];
+    const procBeforeUpdate = pickPm2Proc(registeredBeforeUpdate);
     const wasOnline = !!procBeforeUpdate && procBeforeUpdate.pm2_env.status === 'online';
+    const hadStale = registeredBeforeUpdate.some((proc) => !isOurRegistration(proc));
 
     info(`Updating: v${currentVersion} -> v${latestVersion}...`);
     const installResult = runNpm(['install', '-g', 'linkgravity@latest'], { stdio: 'inherit' });
@@ -634,16 +739,27 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
     repairHookRegistration({ fresh: true });
 
     if (!procBeforeUpdate) {
+        const blocker = launchBlocker();
+        if (blocker) {
+            console.log(`\n${color.yellow}⚠${color.reset} ${blocker}\n`);
+            success('Update finished - the daemon was left stopped.\n');
+            process.exit(0);
+        }
         info("Daemon wasn't running - starting it fresh...");
-        runPm2([
-            'start',
-            LGY_SCRIPT_PATH,
-            '--interpreter',
-            pythonExe,
-            '--name',
-            LGY_PM2_NAME,
-            '--update-env',
-        ]);
+        startDaemon();
+        verifyStartup().then((ok) => process.exit(ok ? 0 : 1));
+    } else if (hadStale) {
+        clearRegistrations(registeredBeforeUpdate);
+        if (!wasOnline) {
+            runPm2(['save']);
+            success(
+                `Daemon was stopped - leaving it stopped. Run 'lgy start' when you're ready.\n`,
+            );
+            process.exit(0);
+        }
+        info('Starting the daemon from this install...');
+        startDaemon();
+        runPm2(['save']);
         verifyStartup().then((ok) => process.exit(ok ? 0 : 1));
     } else if (wasOnline) {
         info('Restarting daemon to apply the update...');
@@ -722,7 +838,9 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
         spawnSync(process.argv[0], [process.argv[1], action], { stdio: 'inherit' });
     })();
 } else {
-    console.log(
+    // Not stdout: an eval "$(lgy ...)" line in a shell rc would run this message as commands.
+    console.error(
         `\n❌ Unknown command: ${cmd || 'none'}\n💡 Run 'lgy help' to see available commands.`,
     );
+    process.exit(1);
 }

package/bin/pm2.js

@@ -10,6 +10,9 @@ function pm2Env() {
         ...process.env,
         // pm2 gives Python a pipe not a TTY, so it block-buffers stdout and can sit on log lines indefinitely - force line buffering.
         PYTHONUNBUFFERED: '1',
+        // Without this Python inherits the console codepage (cp949 on Korean Windows) and loguru
+        // drops every line it can't encode - including the one verifyStartup waits for.
+        PYTHONIOENCODING: 'utf-8',
         // pm2 merges --update-env rather than replacing, so a LOG_LEVEL from an earlier run
         // survives unless a value is passed every time.
         LOG_LEVEL: process.env.LOG_LEVEL || 'INFO',

package/bin/setup.js

@@ -1,6 +1,6 @@
 const p = require('@clack/prompts');
 const { spawnSync } = require('child_process');
-const { python: pythonExe } = require('../npm-scripts/venv-paths');
+const { daemonPython } = require('../npm-scripts/venv-paths');
 const { PM2_BIN, PM2_CWD, pm2Env } = require('./pm2');
 const {
     getSettings,
@@ -224,7 +224,7 @@ function startOrRestartDaemon(pm2Name, scriptPath, label) {
             'start',
             scriptPath,
             '--interpreter',
-            pythonExe,
+            daemonPython,
             '--name',
             pm2Name,
         ]);

package/npm-scripts/venv-paths.js

@@ -40,6 +40,10 @@ module.exports = {
     isWin,
     venvBinDir,
     python: venvBin('python'),
+    // Only for pm2's --interpreter: pm2 spawns with detached:true, which on Windows forces a
+    // console window and ignores its own windowsHide option. pythonw is GUI-subsystem so no
+    // console is ever allocated, and pm2 pipes stdio anyway so no output is lost.
+    daemonPython: venvBin(isWin ? 'pythonw' : 'python'),
     pip: venvBin('pip'),
     preCommit: venvBin('pre-commit'),
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linkgravity",
-  "version": "1.7.3",
+  "version": "1.7.5",
   "description": "Discord/Telegram bot bridge for the Antigravity (agy) CLI, with voice interaction support",
   "scripts": {
     "start": "node npm-scripts/run-dev.js",

package/src/cogs/general_cog.py

@@ -51,7 +51,7 @@ async def fetch_models_background():
     import time
 
     try:
-        from config import AGY_BIN
+        from config import AGY_BIN, CREATION_FLAGS
 
         logger.debug(f"Starting fetch_models_background using AGY_BIN: {AGY_BIN}")
         env = os.environ.copy()
@@ -63,6 +63,7 @@ async def fetch_models_background():
             stderr=asyncio.subprocess.PIPE,
             stdin=asyncio.subprocess.DEVNULL,
             env=env,
+            creationflags=CREATION_FLAGS,
         )
         try:
             stdout, stderr = await asyncio.wait_for(p.communicate(), timeout=30.0)

package/src/cogs/voice_cog.py

@@ -583,7 +583,7 @@ class VoiceCog(commands.Cog):
             wake_syllables = len(re.sub(r"[^\w가-힣]", "", matched_wake_word or ""))
             min_prefix_similarity = 0.55 if wake_syllables <= 2 else 0.35
             if is_waking_up and prefix_similarity is not None and prefix_similarity < min_prefix_similarity:
-                self.logger.info(
+                self.logger.debug(
                     f"STT: ignoring wake - '{text}' doesn't resemble '{matched_wake_word}' "
                     f"(prefix similarity {prefix_similarity:.2f}, needed {min_prefix_similarity:.2f})"
                 )

package/src/config.py

@@ -1,5 +1,7 @@
 import os
 import secrets
+import shutil
+import subprocess
 from pathlib import Path
 
 from core.atomic_io import atomic_write_json, safe_load_json
@@ -158,7 +160,22 @@ MODEL_CHOICES = {
     "pro": "Gemini 3.1 Pro",
 }
 
-AGY_BIN = os.getenv("AGY_BIN_PATH", str(Path.home() / ".local/bin/agy"))
+
+def _resolve_agy_bin() -> str:
+    fallback = str(Path.home() / ".local/bin/agy")
+    for candidate in (os.getenv("AGY_BIN_PATH"), fallback):
+        if candidate and Path(candidate).is_file():
+            return candidate
+    # Windows installs agy under AppData and adds it to PATH instead.
+    return shutil.which("agy") or fallback
+
+
+# Must stay in sync with findAgyBin() in bin/cli.js.
+AGY_BIN = _resolve_agy_bin()
+
+# pm2 spawns the daemon with detached:true, so on Windows it owns no console; without this
+# flag every child it launches gets a console window of its own.
+CREATION_FLAGS = subprocess.CREATE_NO_WINDOW if os.name == "nt" else 0
 
 session_manager = SessionManager(DATA_DIR)
 

package/src/core/agy_runner.py

@@ -163,7 +163,7 @@ async def run_agy(
                 if os.name == "nt":
                     import subprocess
 
-                    kwargs["creationflags"] = subprocess.CREATE_NEW_PROCESS_GROUP
+                    kwargs["creationflags"] = subprocess.CREATE_NEW_PROCESS_GROUP | subprocess.CREATE_NO_WINDOW
                 elif hasattr(os, "setsid"):
                     kwargs["preexec_fn"] = os.setsid
 

package/src/main_discord.py

@@ -11,7 +11,7 @@ from functools import partial
 import discord
 from discord.ext import commands
 
-from config import DISCORD_TOKEN, logger, session_manager
+from config import CREATION_FLAGS, DISCORD_TOKEN, logger, session_manager
 from handlers.message_router import handle_message
 from messengers.discord_adapter import DiscordAdapter
 from messengers.registry import register_adapter
@@ -128,7 +128,7 @@ async def status_updater_task():
 
 
 def _spawn_voice_process(voice_dir: str) -> subprocess.Popen:
-    return subprocess.Popen(["node", "index.js"], cwd=voice_dir)
+    return subprocess.Popen(["node", "index.js"], cwd=voice_dir, creationflags=CREATION_FLAGS)
 
 
 async def _supervise_voice_process(voice_dir: str):

package/src/main_slack.py

@@ -258,7 +258,7 @@ async def run_slack(stop_event: asyncio.Event) -> None:
 
     app, adapter = build_app()
     try:
-        await adapter.resolve_bot_user_id()
+        bot_user_id = await adapter.resolve_bot_user_id()
     except SlackApiError as e:
         logger.critical(f"Slack auth_test failed - check slack_bot_token: {e}")
         return
@@ -266,6 +266,9 @@ async def run_slack(stop_event: asyncio.Event) -> None:
     handler = AsyncSocketModeHandler(app, SLACK_APP_TOKEN)
     logger.info("✅ Slack bot starting (Socket Mode)...")
     await handler.connect_async()
+    # cli.js's verifyStartup() waits for this exact sentence - without it a Slack-only install
+    # never reports a successful startup and every lgy start/restart/update times out.
+    logger.info(f"✅ Bot is fully online and ready! Logged in as {bot_user_id}")
     platform_health.set_status("slack", "running")
     try:
         await stop_event.wait()

package/src/services/response.py

@@ -1,7 +1,7 @@
 from pathlib import Path
 from typing import Any
 
-from config import MAX_EMBED_LEN, MODEL_CHOICES, session_manager
+from config import MAX_EMBED_LEN, bot_settings, session_manager
 from messengers.registry import get_adapter_for_platform
 from services.discord_helpers import split_message
 from utils.utils import get_current_model
@@ -18,8 +18,8 @@ async def send_agy_response(
     adapter = get_adapter_for_platform(session.get("platform", "discord"))
     session_manager.save_sessions()
 
-    session_model = session.get("model")
-    model_display = MODEL_CHOICES.get(session_model, session_model) if session_model else get_current_model()
+    # Same precedence as the /model autocomplete in general_cog.
+    model_display = session.get("model") or bot_settings.get("default_model") or get_current_model()
 
     parts = split_message(response_text, MAX_EMBED_LEN)
     for idx, part in enumerate(parts):