linkgravity 1.5.3 → 1.5.5

package/bin/cli.js

@@ -50,6 +50,7 @@ function runPm2(args, silent = true) {
     }
 
     let hasSudoInstructions = false;
+    let sudoCommand = null;
     if (silent && result.stdout && (args[0] === 'startup' || args[0] === 'unstartup')) {
         const out = result.stdout.toString();
         const lines = out.split('\n');
@@ -59,11 +60,8 @@ function runPm2(args, silent = true) {
                 line.trim().startsWith('sudo su -c') ||
                 line.includes('sudo ')
             ) {
-                console.log(
-                    `\n\n${color.yellow}⚠ Action Required:${color.reset} To complete setup, copy and paste this command into your terminal:\n`,
-                );
-                console.log(`    ${color.cyan}${line.trim()}${color.reset}\n`);
                 hasSudoInstructions = true;
+                sudoCommand = line.trim();
             }
         }
     }
@@ -74,6 +72,27 @@ function runPm2(args, silent = true) {
         }
         process.exit(result.status);
     }
+
+    return { hasSudoInstructions, sudoCommand };
+}
+
+function runSudoStepThen(sudoCommand, successMessage) {
+    // stdin stays inherited so sudo can still prompt for a password on the real terminal;
+    // stdout/stderr are captured so pm2's own noise only surfaces if this actually fails.
+    const result = spawnSync('sh', ['-c', sudoCommand], { stdio: ['inherit', 'pipe', 'pipe'] });
+    if (result.status === 0) {
+        success(`${successMessage}\n`);
+    } else {
+        console.log(`${color.yellow}⚠${color.reset} That didn't complete:\n`);
+        const output = [
+            (result.stdout || '').toString().trim(),
+            (result.stderr || '').toString().trim(),
+        ]
+            .filter(Boolean)
+            .join('\n');
+        if (output) console.log(output);
+        console.log(`\nRun \`lgy enable\` again to retry.\n`);
+    }
 }
 
 // Matches a leading timestamp from either loguru or aiohttp's access-log format; only strips the first bracket group so aiohttp's second "[INFO ]" bracket is left alone.
@@ -223,11 +242,18 @@ function formatUptime(pmUptimeMs) {
     return `${days}d ${hours % 24}h`;
 }
 
+function visibleLength(s) {
+    return String(s).replace(ANSI_ESCAPE, '').length;
+}
+
 function renderTable(headers, rows) {
     const widths = headers.map((h, i) =>
-        Math.max(h.length, ...rows.map((r) => String(r[i]).length)),
+        Math.max(h.length, ...rows.map((r) => visibleLength(r[i]))),
     );
-    const pad = (s, w) => ` ${String(s).padEnd(w)} `;
+    const pad = (s, w) => {
+        const str = String(s);
+        return ` ${str}${' '.repeat(Math.max(0, w - visibleLength(str)))} `;
+    };
     const sepLine = (l, m, r) => l + widths.map((w) => '─'.repeat(w + 2)).join(m) + r;
     const rowLine = (cells) => '│' + cells.map((c, i) => pad(c, widths[i])).join('│') + '│';
 
@@ -237,7 +263,7 @@ function renderTable(headers, rows) {
     return lines.join('\n');
 }
 
-// Mirrors src/config.py's AGY_BIN resolution (AGY_BIN_PATH env var, else ~/.local/bin/agy), plus a PATH fallback for installs that don't use the default location.
+// Must stay in sync with config.py's AGY_BIN resolution.
 function findAgyBin() {
     const envPath = process.env.AGY_BIN_PATH;
     if (envPath && fs.existsSync(envPath)) return envPath;
@@ -256,12 +282,61 @@ function findAgyBin() {
 function getPm2Proc() {
     const jlist = spawnSync('npx', ['-y', 'pm2', 'jlist'], { stdio: 'pipe' });
     if (jlist.status !== 0) return null;
+
+    // pm2 can print noise before the real JSON (version banners, ANSI escapes, daemon-spawn logs) that
+    // can itself contain '[' - try every '[' left-to-right and keep the first one that parses as JSON.
+    const out = jlist.stdout.toString().replace(/\x1b\[[0-9;?]*[a-zA-Z]/g, '');
+    for (let i = 0; i < out.length; i++) {
+        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;
+        } catch (e) {}
+    }
+
+    console.error(
+        `${color.yellow}⚠${color.reset} Couldn't read pm2 status (no valid JSON found in its output). Raw output:\n${out.trim()}`,
+    );
+    return null;
+}
+
+// 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;
     try {
-        const procs = JSON.parse(jlist.stdout.toString());
-        return procs.find((p) => p.name === LGY_PM2_NAME) || null;
+        const user = os.userInfo().username;
+        if (process.platform === 'linux') {
+            const check = spawnSync('systemctl', ['is-enabled', `pm2-${user}`], { stdio: 'pipe' });
+            if (check.error) return null;
+            const out = check.stdout.toString().trim();
+            if (out === 'enabled') return true;
+            if (out === 'disabled' || check.status !== 0) return false;
+            return null;
+        }
+        if (process.platform === 'darwin') {
+            const plistPath = path.join(
+                os.homedir(),
+                'Library',
+                'LaunchAgents',
+                `pm2.${user}.plist`,
+            );
+            return fs.existsSync(plistPath);
+        }
     } catch (e) {
         return null;
     }
+    return null;
+}
+
+function checkLatestVersionFast(currentVersion) {
+    const view = spawnSync('npm', ['view', 'linkgravity', 'version'], {
+        stdio: 'pipe',
+        timeout: 3000,
+    });
+    if (view.error || view.status !== 0) return null;
+    const latest = view.stdout.toString().trim();
+    if (!latest) return null;
+    return { latest, upToDate: latest === currentVersion };
 }
 
 if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
@@ -390,6 +465,8 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
         }
     }
 
+    const daemonAlive = !!proc && proc.pm2_env.status === 'online';
+
     const rows = Object.entries(PLATFORMS).map(([key, def]) => {
         const { enabled } = platformState(key, settings);
         const sessionCount = Object.values(sessions).filter((s) => s.platform === key).length;
@@ -397,17 +474,54 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
         let connection = '-';
         let since = '-';
         if (enabled) {
-            if (!h) connection = 'unknown';
-            else if (h.status === 'running') connection = 'connected';
-            else if (h.status === 'connecting') connection = 'connecting...';
-            else if (h.status === 'error') connection = `error: ${h.detail || '?'}`;
-            else if (h.status === 'stopped') connection = 'stopped';
-            if (h && h.at) since = formatUptime(new Date(h.at).getTime());
+            if (!daemonAlive) {
+                // health.json freezes at its last value if the process was killed outright (kill -9, OOM, reboot) instead of exiting cleanly, so don't trust it once pm2 confirms the daemon isn't actually running.
+                connection = `${color.red}down${color.reset}`;
+                since = h && h.at ? `last seen ${formatUptime(new Date(h.at).getTime())} ago` : '-';
+            } else if (!h) {
+                connection = 'unknown';
+            } else {
+                if (h.status === 'running') connection = `${color.green}connected${color.reset}`;
+                else if (h.status === 'connecting') connection = 'connecting...';
+                else if (h.status === 'error')
+                    connection = `${color.red}error: ${h.detail || '?'}${color.reset}`;
+                else if (h.status === 'stopped') connection = 'stopped';
+                if (h.at) since = formatUptime(new Date(h.at).getTime());
+            }
         }
         return [def.label, enabled ? 'yes' : 'no', connection, since, String(sessionCount)];
     });
     console.log(renderTable(['platform', 'enabled', 'connection', 'since', 'sessions'], rows));
     console.log();
+
+    const pkg = require('../package.json');
+    const versionCheck = checkLatestVersionFast(pkg.version);
+    const versionLine =
+        versionCheck === null
+            ? pkg.version
+            : versionCheck.upToDate
+              ? `${pkg.version} (up to date)`
+              : `${pkg.version} ${color.yellow}(v${versionCheck.latest} available - run \`lgy update\`)${color.reset}`;
+
+    const agyPath = findAgyBin();
+    const agyLine = agyPath ? `found (${agyPath})` : `${color.yellow}not found${color.reset}`;
+
+    const autostart = isAutostartEnabled();
+    const autostartLine =
+        autostart === null
+            ? 'unknown'
+            : autostart
+              ? `${color.green}enabled${color.reset}`
+              : 'disabled';
+
+    for (const [label, value] of [
+        ['version', versionLine],
+        ['agy', agyLine],
+        ['autostart', autostartLine],
+    ]) {
+        console.log(`${label.padEnd(10)} ${value}`);
+    }
+    console.log();
 } else if (cmd === 'enable') {
     if (isWin) {
         console.log(
@@ -417,9 +531,13 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
         process.exit(1);
     }
     info('Registering LinkGravity to start on system boot...');
-    runPm2(['startup']);
+    const { hasSudoInstructions, sudoCommand } = runPm2(['startup']);
     runPm2(['save']);
-    success('Auto-start configuration saved.\n');
+    if (hasSudoInstructions && sudoCommand) {
+        runSudoStepThen(sudoCommand, 'Auto-start configuration saved.');
+    } else {
+        success('Auto-start configuration saved.\n');
+    }
 } else if (cmd === 'disable') {
     if (isWin) {
         console.log(
@@ -429,9 +547,13 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
         process.exit(1);
     }
     info('Removing LinkGravity from system boot...');
-    runPm2(['unstartup']);
+    const { hasSudoInstructions, sudoCommand } = runPm2(['unstartup']);
     runPm2(['save']);
-    success('Auto-start configuration removed.\n');
+    if (hasSudoInstructions && sudoCommand) {
+        runSudoStepThen(sudoCommand, 'Auto-start configuration removed.');
+    } else {
+        success('Auto-start configuration removed.\n');
+    }
 } else if (cmd === 'setup' || cmd === 'init') {
     const runSetup = require('./setup');
     runSetup().catch((err) => {

package/bin/setup.js

@@ -33,25 +33,39 @@ async function collectSessionScopes(existingScopes) {
         'Server / Channel Access',
     );
 
+    if (hasExisting) {
+        const summary = existingScopes
+            .map(
+                (s) =>
+                    `${s.guild_id}${s.channel_ids.length ? ` (channels: ${s.channel_ids.join(', ')})` : ' (whole server)'}`,
+            )
+            .join('; ');
+        p.note(`Current server/channel settings: ${summary}`, 'Current Setting');
+
+        const change = await p.confirm({
+            message: 'Change the server/channel access list?',
+            initialValue: false,
+        });
+        if (p.isCancel(change)) {
+            p.cancel('Setup cancelled.');
+            process.exit(0);
+        }
+        if (!change) return null; // keep existing config untouched
+    }
+
     let isFirst = true;
     while (true) {
-        const promptSuffix =
-            isFirst && hasExisting
-                ? ' (leave empty to keep your current server/channel settings entirely unchanged)'
-                : ' (leave empty if you have no more servers to add)';
-
         const guildId = await p.text({
-            message: `Server (Guild) ID to allow${promptSuffix}. Right-click the SERVER NAME (not a channel) → Copy Server ID:`,
+            message: isFirst
+                ? 'Server (Guild) ID to allow. Right-click the SERVER NAME (not a channel) → Copy Server ID ' +
+                  '(leave empty if done - an empty list means /new works nowhere):'
+                : 'Another server ID to add (leave empty if done):',
         });
         if (p.isCancel(guildId)) {
             p.cancel('Setup cancelled.');
             process.exit(0);
         }
-
-        if (!guildId) {
-            if (isFirst) return null; // signal: user wants to keep existing config untouched
-            break;
-        }
+        if (!guildId) break;
         isFirst = false;
 
         const channelIds = [];
@@ -103,30 +117,41 @@ async function collectUserIds(existingIds, platformLabel) {
     const hasExisting = existingIds && existingIds.length > 0;
 
     p.note(
-        'ONLY these users can use the bot (leave completely empty on first setup to allow EVERYONE). ' +
+        'ONLY these users can use the bot (leave completely empty to allow EVERYONE). ' +
             'Not related to DMs - this only gates the channel/threads configured above.',
         `Allowed ${platformLabel} Users`,
     );
 
+    if (hasExisting) {
+        p.note(
+            `Current allowed ${platformLabel} users: ${existingIds.join(', ')}`,
+            'Current Setting',
+        );
+
+        const change = await p.confirm({
+            message: `Change the allowed-user list for ${platformLabel}?`,
+            initialValue: false,
+        });
+        if (p.isCancel(change)) {
+            p.cancel('Setup cancelled.');
+            process.exit(0);
+        }
+        if (!change) return null; // keep existing config untouched
+    }
+
     let isFirst = true;
     while (true) {
-        const promptSuffix =
-            isFirst && hasExisting
-                ? ' (leave empty to keep your current allowed-user settings entirely unchanged)'
-                : ' (leave empty if you have no more users to add)';
-
         const userId = await p.text({
-            message: `${platformLabel} User ID to allow${promptSuffix}:`,
+            message: isFirst
+                ? `${platformLabel} User ID to allow (leave empty to allow EVERYONE):`
+                : `Another ${platformLabel} user ID to allow (leave empty if done):`,
         });
         if (p.isCancel(userId)) {
             p.cancel('Setup cancelled.');
             process.exit(0);
         }
 
-        if (!userId) {
-            if (isFirst) return null; // signal: keep existing config untouched
-            break;
-        }
+        if (!userId) break;
         isFirst = false;
 
         ids.push(userId.trim());
@@ -390,13 +415,12 @@ async function platformMenu(key) {
         );
         if (configured)
             options.push({ value: 'edit', label: 'Edit settings (token, access, etc.)' });
-        options.push({ value: 'back', label: '← Back' });
 
         const action = await p.select({
-            message: `${def.label} — currently ${enabled ? 'ON' : 'OFF'}${configured ? '' : ' (not configured)'}`,
+            message: `${def.label} — currently ${enabled ? 'ON' : 'OFF'}${configured ? '' : ' (not configured)'} (Esc to go back)`,
             options,
         });
-        if (p.isCancel(action) || action === 'back') return;
+        if (p.isCancel(action)) return;
 
         if (action === 'off') {
             updateSettings({ [`${key}_enabled`]: false });

package/package.json

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

package/src/cogs/voice_cog.py

@@ -92,7 +92,7 @@ class VoiceCog(commands.Cog):
                 opts.append(app_commands.Choice(name=str(v), value=v))
         return opts
 
-    async def threshold_autocomplete(
+    async def interrupt_threshold_autocomplete(
         self, interaction: discord.Interaction, current: str
     ) -> list[app_commands.Choice[int]]:
         current_val = int(self.bot_settings.get("voice_threshold", 3000))
@@ -105,6 +105,19 @@ class VoiceCog(commands.Cog):
                 opts.append(app_commands.Choice(name=str(v), value=v))
         return opts
 
+    async def wake_sensitivity_autocomplete(
+        self, interaction: discord.Interaction, current: str
+    ) -> list[app_commands.Choice[float]]:
+        current_val = float(self.bot_settings.get("wake_threshold", 0.4))
+        opts = []
+        if str(current_val) in current or not current:
+            opts.append(app_commands.Choice(name=f"{current_val} (current)", value=current_val))
+
+        for v in [0.2, 0.3, 0.4, 0.5, 0.6]:
+            if v != current_val and len(opts) < 25:
+                opts.append(app_commands.Choice(name=str(v), value=v))
+        return opts
+
     async def tts_voice_autocomplete(
         self, interaction: discord.Interaction, current: str
     ) -> list[app_commands.Choice[str]]:
@@ -282,12 +295,13 @@ class VoiceCog(commands.Cog):
 
     @app_commands.command(
         name="sound",
-        description="Configure voice settings (Wake word, active time, threshold, TTS voice/speed, TTS on/off)",
+        description="Configure voice settings (Wake word, active time, thresholds, TTS voice/speed, TTS on/off)",
     )
     @app_commands.describe(
         wake_word="The single word/phrase that wakes the bot (recorded in your voice)",
         active_times="Duration in seconds the bot stays awake",
-        threshold="Voice volume sensitivity (1000~10000)",
+        interrupt_threshold="Mic volume that interrupts (barges into) TTS playback (1000~10000)",
+        wake_sensitivity="Wake word match sensitivity (0.1~0.9, lower = easier to trigger but more false wakes)",
         tts_voice="Select the AI TTS voice",
         tts_enabled="Turn Text-to-Speech ON or OFF",
         tts_speed="TTS playback speed multiplier, e.g. 1.3 for 1.3x (0.5~2.0)",
@@ -295,7 +309,8 @@ class VoiceCog(commands.Cog):
     )
     @app_commands.autocomplete(
         active_times=active_times_autocomplete,
-        threshold=threshold_autocomplete,
+        interrupt_threshold=interrupt_threshold_autocomplete,
+        wake_sensitivity=wake_sensitivity_autocomplete,
         tts_voice=tts_voice_autocomplete,
         tts_enabled=tts_enabled_autocomplete,
         tts_speed=tts_speed_autocomplete,
@@ -306,7 +321,8 @@ class VoiceCog(commands.Cog):
         interaction: discord.Interaction,
         wake_word: str = None,
         active_times: int = None,
-        threshold: int = None,
+        interrupt_threshold: int = None,
+        wake_sensitivity: float = None,
         tts_voice: str = None,
         tts_enabled: str = None,
         tts_speed: float = None,
@@ -321,7 +337,8 @@ class VoiceCog(commands.Cog):
         if (
             wake_word is None
             and active_times is None
-            and threshold is None
+            and interrupt_threshold is None
+            and wake_sensitivity is None
             and tts_voice is None
             and tts_enabled is None
             and tts_speed is None
@@ -329,7 +346,8 @@ class VoiceCog(commands.Cog):
         ):
             curr_wake = (self.bot_settings.get("wake_words") or {}).get(str(interaction.user.id), "None")
             curr_timer = self.bot_settings.get("active_timer", 60)
-            curr_thresh = self.bot_settings.get("voice_threshold", 3000)
+            curr_interrupt_thresh = self.bot_settings.get("voice_threshold", 3000)
+            curr_wake_sens = self.bot_settings.get("wake_threshold", 0.4)
             curr_tts = self.bot_settings.get("tts_voice", "en-US-AriaNeural")
             curr_tts_on = "ON" if self.bot_settings.get("tts_enabled", True) else "OFF"
             curr_tts_speed = self.bot_settings.get("tts_speed", 1.0)
@@ -339,7 +357,8 @@ class VoiceCog(commands.Cog):
             embed.add_field(name="🎙️ Wake Word", value=f"`{curr_wake}`", inline=False)
             embed.add_field(name="🔒 Wake Word Required", value=f"`{'ON' if curr_required else 'OFF'}`", inline=False)
             embed.add_field(name="⏱️ Active Time", value=f"`{curr_timer}s`", inline=False)
-            embed.add_field(name="🔊 Threshold", value=f"`{curr_thresh}`", inline=False)
+            embed.add_field(name="🎯 Wake Sensitivity", value=f"`{curr_wake_sens}`", inline=False)
+            embed.add_field(name="🔊 Interrupt Threshold", value=f"`{curr_interrupt_thresh}`", inline=False)
             embed.add_field(name="🗣️ TTS Voice", value=f"`{curr_tts}`", inline=False)
             embed.add_field(name="🔊 TTS Enabled", value=f"`{curr_tts_on}`", inline=False)
             embed.add_field(name="⏩ TTS Speed", value=f"`{curr_tts_speed}x`", inline=False)
@@ -353,12 +372,25 @@ class VoiceCog(commands.Cog):
         if active_times is not None:
             self.bot_settings["active_timer"] = active_times
             updated.append(f"⏱️ Active Timer: `{active_times}s`")
-        if threshold is not None:
-            self.bot_settings["voice_threshold"] = threshold
-            updated.append(f"🔊 Threshold: `{threshold}`")
+        if interrupt_threshold is not None:
+            self.bot_settings["voice_threshold"] = interrupt_threshold
+            updated.append(f"🔊 Interrupt Threshold: `{interrupt_threshold}`")
+            try:
+                async with aiohttp.ClientSession(timeout=NODE_REQUEST_TIMEOUT) as session:
+                    await session.post(f"{NODE_VOICE_API}/set_config", json={"voice_threshold": interrupt_threshold})
+            except aiohttp.ClientError as e:
+                self.logger.warning(f"Node.js sync failed for {interaction.guild_id}: {e}")
+                updated.append(f"(⚠️ Node.js Sync Failed: {e})")
+            except asyncio.TimeoutError:
+                self.logger.warning(f"Node.js sync timeout for {interaction.guild_id}")
+                updated.append("(⚠️ Node.js Sync Timeout)")
+        if wake_sensitivity is not None:
+            clamped_wake = max(0.05, min(0.95, wake_sensitivity))
+            self.bot_settings["wake_threshold"] = clamped_wake
+            updated.append(f"🎯 Wake Sensitivity: `{clamped_wake}`")
             try:
                 async with aiohttp.ClientSession(timeout=NODE_REQUEST_TIMEOUT) as session:
-                    await session.post(f"{NODE_VOICE_API}/set_config", json={"voice_threshold": threshold})
+                    await session.post(f"{NODE_VOICE_API}/set_config", json={"wake_threshold": clamped_wake})
             except aiohttp.ClientError as e:
                 self.logger.warning(f"Node.js sync failed for {interaction.guild_id}: {e}")
                 updated.append(f"(⚠️ Node.js Sync Failed: {e})")

package/src/config.py

@@ -112,11 +112,15 @@ TTS_VOICE = bot_settings.get("tts_voice", "ko-KR-SunHiNeural")
 
 def is_allowed_session_channel(channel) -> bool:
     """True if a new agy session may be started from this channel (via
-    /new). A channel is allowed if its server is in SESSION_SCOPES AND
-    either that server has no channel restriction (whole-server access)
-    or this specific channel is in its allowed list."""
+    /new). DMs have no guild to scope, so they're always allowed here -
+    gating for DMs is handled separately via ALLOWED_IDS. For a guild
+    channel, it's allowed if its server is in SESSION_SCOPES AND either
+    that server has no channel restriction (whole-server access) or this
+    specific channel is in its allowed list."""
     guild = getattr(channel, "guild", None)
-    if not guild or guild.id not in SESSION_SCOPES:
+    if not guild:
+        return True
+    if guild.id not in SESSION_SCOPES:
         return False
     allowed_channels = SESSION_SCOPES[guild.id]
     return allowed_channels is None or channel.id in allowed_channels