linkgravity 1.7.4 → 1.8.0

package/README.md

@@ -60,7 +60,7 @@ Slack has more moving parts than the others - two separate tokens, and a few set
     - It's easy to grab the wrong token here - the page also shows a **User OAuth Token** (`xoxp-...`) further down, which is a different thing and won't work for this bot.
 5. **App Home** (left sidebar) > under **Show Tabs**, turn on **Messages Tab**, then check **Allow users to send Slash commands and messages from the messages tab** - this is what lets you DM the bot at all. (If this section looks greyed out, it's because step 3 hasn't been saved/installed yet - go back and do that first.)
 6. **Event Subscriptions** (left sidebar) > toggle **Enable Events** on > under **Subscribe to bot events**, add `message.channels`, `message.groups`, `message.im`, and `message.mpim` > **Save Changes**.
-7. **Slash Commands** (left sidebar) > **Create New Command**, four times, for `/new`, `/model`, `/credit`, and `/permissions` (any description/hint text is fine - only the command name matters).
+7. **Slash Commands** (left sidebar) > **Create New Command**, five times, for `/new`, `/model`, `/credit`, `/permissions`, and `/automode` (any description/hint text is fine - only the command name matters).
 8. Back on **OAuth & Permissions**, since scopes/events changed after the initial install, click **Reinstall to Workspace** to push those changes live. Any time you change scopes or events later, you'll need to repeat this step.
 9. In Slack itself, for any **channel** (not DM) you want the bot usable in, run `/invite @<your bot's name>` there first - the bot can't post in a channel it hasn't been added to.
 

package/bin/cli.js

@@ -59,6 +59,20 @@ function repairHookRegistration({ fresh = false } = {}) {
     }
 }
 
+function repairShellCompletion() {
+    // Runs on every update too (not just the rarely-rerun setup) so existing installs get cleaned up.
+    try {
+        const result = require('./completion').installCompletion();
+        if (result?.cleaned) {
+            console.log(
+                `${color.dim}Cleaned up a stale completion line in your shell rc file.${color.reset}`,
+            );
+        }
+    } catch {
+        // Best-effort - a broken shell rc file shouldn't fail the update.
+    }
+}
+
 function runPm2(args, silent = true) {
     const stdioOpt = silent ? 'pipe' : 'inherit';
     const result = spawnSync(process.execPath, [PM2_BIN, ...args], {
@@ -342,7 +356,10 @@ function launchBlocker() {
     return null;
 }
 
-function getPm2Proc() {
+// 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;
 
@@ -353,7 +370,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) {}
     }
 
@@ -363,6 +380,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;
@@ -403,8 +485,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`,
@@ -425,16 +510,11 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
 
     repairHookRegistration();
 
+    if (stale.length) clearRegistrations(registered);
+
     info('Starting LinkGravity daemon...');
-    runPm2([
-        'start',
-        LGY_SCRIPT_PATH,
-        '--interpreter',
-        daemonPython,
-        '--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...');
@@ -442,6 +522,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]);
@@ -636,12 +728,15 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
 
     if (latestVersion === currentVersion) {
         repairHookRegistration();
+        repairShellCompletion();
         success(`Already up to date (v${currentVersion}).\n`);
         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' });
@@ -657,6 +752,7 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
     delete require.cache[require.resolve('../npm-scripts/ensure-env')];
     require('../npm-scripts/ensure-env').ensureEnvironment();
     repairHookRegistration({ fresh: true });
+    repairShellCompletion();
 
     if (!procBeforeUpdate) {
         const blocker = launchBlocker();
@@ -666,15 +762,20 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
             process.exit(0);
         }
         info("Daemon wasn't running - starting it fresh...");
-        runPm2([
-            'start',
-            LGY_SCRIPT_PATH,
-            '--interpreter',
-            daemonPython,
-            '--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...');
@@ -753,7 +854,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/completion.js

@@ -29,13 +29,21 @@ function installCompletion(shell = path.basename(process.env.SHELL || '')) {
 
     const dest = path.join(os.homedir(), ...target.dest);
     let rcUpdated = false;
+    let cleaned = false;
     try {
         fs.mkdirSync(path.dirname(dest), { recursive: true });
         fs.copyFileSync(path.join(__dirname, 'completions', target.src), dest);
 
         if (target.rc) {
             const rc = path.join(os.homedir(), target.rc);
-            const existing = fs.existsSync(rc) ? fs.readFileSync(rc, 'utf8') : '';
+            let existing = fs.existsSync(rc) ? fs.readFileSync(rc, 'utf8') : '';
+            // Strip any pre-marker `eval "$(lgy completion ...)"` line - lgy never had that subcommand.
+            const stale = /^\s*eval "\$\(lgy completion[^)]*\)"\s*$/gm;
+            if (stale.test(existing)) {
+                fs.writeFileSync(rc, existing.replace(stale, '').replace(/\n{3,}/g, '\n\n'));
+                existing = fs.readFileSync(rc, 'utf8');
+                cleaned = true;
+            }
             if (!existing.includes(MARKER)) {
                 fs.appendFileSync(rc, zshRcBlock(path.dirname(dest)));
                 rcUpdated = true;
@@ -44,7 +52,12 @@ function installCompletion(shell = path.basename(process.env.SHELL || '')) {
     } catch {
         return null;
     }
-    return { shell, file: dest, rc: rcUpdated ? path.join(os.homedir(), target.rc) : null };
+    return {
+        shell,
+        file: dest,
+        rc: rcUpdated ? path.join(os.homedir(), target.rc) : null,
+        cleaned,
+    };
 }
 
 module.exports = { installCompletion };

package/package.json

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

package/src/api/ui_routes.py

@@ -188,8 +188,8 @@ async def handle_approve_request(request):
                 if not sub_cmd:
                     continue
 
-                is_auto_allowed = False
-                if "\n" not in sub_cmd and "|" not in sub_cmd:
+                is_auto_allowed = session_manager.is_auto_mode()
+                if not is_auto_allowed and "\n" not in sub_cmd and "|" not in sub_cmd:
                     try:
                         tokens = shlex.split(sub_cmd)
                         for scope in session_manager.persistent_allowed.get("commands", []):
@@ -270,7 +270,7 @@ async def handle_approve_request(request):
             return allow_response(tool_name, tool_input)
 
         else:
-            if is_tool_allowed(tool_name, tool_input):
+            if session_manager.is_auto_mode() or is_tool_allowed(tool_name, tool_input):
                 if target_thread and tool_msg_text:
                     await send_ordered(
                         target_thread_id, lambda: _send_chunked(adapter, target_thread, tool_msg_formatted)

package/src/cogs/general_cog.py

@@ -275,6 +275,21 @@ class GeneralCog(commands.Cog):
         await handle.send(interaction.channel)
         await interaction.response.send_message("🔐 Permission list posted above.", ephemeral=True)
 
+    @app_commands.command(
+        name="automode", description="Auto-allow every approval globally, across all sessions (on/off)"
+    )
+    @app_commands.describe(state="on or off")
+    async def cmd_automode(self, interaction: discord.Interaction, state: str):
+        if not allowed(interaction.user.id):
+            return await interaction.response.send_message("❌ Denied", ephemeral=True)
+        if state.lower() not in ("on", "off"):
+            return await interaction.response.send_message("Use `on` or `off`.", ephemeral=True)
+
+        from services import permissions
+
+        msg = permissions.set_auto_mode(state.lower() == "on")
+        await interaction.response.send_message(msg)
+
     @app_commands.command(
         name="stop", description="Stop the currently generating response or task (Equivalent to ESC in CLI)"
     )

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/core/session_manager.py

@@ -54,14 +54,22 @@ class SessionManager:
     def _load_persistent(self) -> dict:
         from config import logger
 
-        data = safe_load_json(self.persistent_file, {"tools": [], "commands": []}, logger=logger)
+        data = safe_load_json(self.persistent_file, {"tools": [], "commands": [], "auto_mode": False}, logger=logger)
         if isinstance(data, list):
-            return {"tools": data, "commands": []}
+            return {"tools": data, "commands": [], "auto_mode": False}
+        data.setdefault("auto_mode", False)
         return data
 
     def save_persistent(self):
         atomic_write_json(self.persistent_file, self.persistent_allowed)
 
+    def is_auto_mode(self) -> bool:
+        return bool(self.persistent_allowed.get("auto_mode"))
+
+    def set_auto_mode(self, enabled: bool):
+        self.persistent_allowed["auto_mode"] = enabled
+        self.save_persistent()
+
     def register_queue(self, thread_id: str, queue: asyncio.Queue):
         self.active_queues[str(thread_id)] = queue
 

package/src/main_slack.py

@@ -83,9 +83,14 @@ async def cmd_model(ack, body, respond, context) -> None:
         return
     conversation_id, session = found
 
-    from cogs.general_cog import load_cached_models
+    import time
 
-    cached_models = load_cached_models()
+    import cogs.general_cog as general_cog
+
+    if time.time() - general_cog.last_models_fetch > 3600 and not general_cog.fetching_models:
+        general_cog.fetching_models = True
+        await general_cog.fetch_models_background()
+    cached_models = general_cog.cached_models
     current_model = session.get("model") or bot_settings.get("default_model")
 
     def _apply_model(final_model: str) -> str:
@@ -150,6 +155,24 @@ async def cmd_permissions(ack, body, respond, context) -> None:
     await handle.send(SlackConversationRef(channel=channel, thread_ts=None))
 
 
+async def cmd_automode(ack, body, respond, context) -> None:
+    await ack()
+    user_id = body["user_id"]
+
+    if not allowed(user_id, "slack"):
+        await respond("❌ Denied")
+        return
+
+    state = (body.get("text") or "").strip().lower()
+    if state not in ("on", "off"):
+        await respond("Usage: /automode on|off")
+        return
+
+    from services import permissions
+
+    await respond(permissions.set_auto_mode(state == "on"))
+
+
 async def cmd_credit(ack, body, respond, context) -> None:
     await ack()
     adapter: SlackAdapter = context["adapter"]
@@ -234,6 +257,7 @@ def build_app() -> tuple[AsyncApp, SlackAdapter]:
     app.command("/model")(cmd_model)
     app.command("/credit")(cmd_credit)
     app.command("/permissions")(cmd_permissions)
+    app.command("/automode")(cmd_automode)
     app.event("message")(on_message)
     app.action(re.compile(".*"))(on_action)
     app.view(re.compile(".*"))(on_view_submission)
@@ -258,7 +282,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 +290,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/main_telegram.py

@@ -95,9 +95,14 @@ async def cmd_model(update: Update, context) -> None:
         await update.message.reply_text("⚠️ No active session here. Start one with /new first.")
         return
 
-    from cogs.general_cog import load_cached_models
+    import time
 
-    cached_models = load_cached_models()
+    import cogs.general_cog as general_cog
+
+    if time.time() - general_cog.last_models_fetch > 3600 and not general_cog.fetching_models:
+        general_cog.fetching_models = True
+        await general_cog.fetch_models_background()
+    cached_models = general_cog.cached_models
     current_model = session.get("model") or bot_settings.get("default_model")
 
     def _apply_model(final_model: str) -> str:
@@ -157,6 +162,22 @@ async def cmd_permissions(update: Update, context) -> None:
     await handle.send(update.effective_chat.id)
 
 
+async def cmd_automode(update: Update, context) -> None:
+    user = update.effective_user
+    if not allowed(user.id, "telegram"):
+        await update.message.reply_text("❌ Denied")
+        return
+
+    state = (context.args[0] if context.args else "").lower()
+    if state not in ("on", "off"):
+        await update.message.reply_text("Usage: /automode on|off")
+        return
+
+    from services import permissions
+
+    await update.message.reply_text(permissions.set_auto_mode(state == "on"))
+
+
 async def cmd_credit(update: Update, context) -> None:
     user = update.effective_user
     adapter: TelegramAdapter = context.bot_data["adapter"]
@@ -230,6 +251,7 @@ async def on_ready(app: Application) -> None:
             BotCommand("model", "Change the AI model for this session"),
             BotCommand("credit", "Turn AI Credits on/off"),
             BotCommand("permissions", "View and remove allowed tools and commands"),
+            BotCommand("automode", "Auto-allow every approval globally (on/off)"),
         ]
     )
     logger.info(f"✅ Bot is fully online and ready! Logged in as @{app.bot.username}")
@@ -245,6 +267,7 @@ def build_application() -> Application:
     app.add_handler(CommandHandler("model", cmd_model))
     app.add_handler(CommandHandler("credit", cmd_credit))
     app.add_handler(CommandHandler("permissions", cmd_permissions))
+    app.add_handler(CommandHandler("automode", cmd_automode))
     app.add_handler(CallbackQueryHandler(adapter.handle_callback_query))
     app.add_handler(MessageHandler(filters.ALL & ~filters.COMMAND, on_message))
     app.add_error_handler(on_error)

package/src/services/permissions.py

@@ -5,6 +5,17 @@ from messengers.base import PermissionEntry
 PAGE_SIZE = 20
 
 
+def set_auto_mode(enabled: bool) -> str:
+    session_manager.set_auto_mode(enabled)
+    if enabled:
+        return (
+            "⚠️ **Auto-mode ON** — every tool/command approval will be auto-allowed globally, "
+            "across all sessions and platforms, until you run `/automode off`. Protected paths "
+            "are still blocked regardless."
+        )
+    return "🔒 Auto-mode OFF — approvals are back to normal."
+
+
 def list_entries() -> list[PermissionEntry]:
     allowed = session_manager.persistent_allowed
     return [