linkgravity 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 linkgravity contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,114 @@
+# LinkGravity (lgy)
+
+A Discord bot interface for the Antigravity (agy) agentic AI system. It translates Antigravity CLI prompts into Discord UI components and provides voice interaction capabilities.
+
+## Features
+
+- **Environment Sync:** Automatically syncs with the host's `~/.gemini` configuration.
+- **Voice Interaction:** Supports voice channels with adaptive VAD (Voice Activity Detection) to segment speech and filter environmental noise, plus live "listening..." feedback while you're still talking.
+- **Wake Word Recognition:** Uses phoneme-level similarity to detect wake words and activate voice commands.
+- **CLI Prompt Interception:** Converts CLI prompts (`ask_question`, `run_command` approvals) into interactive Discord buttons.
+- **Command Security:** Parses chained shell commands (`&&`, `||`, `;`) and requires individual approval for each command. Supports prefix-based scope whitelisting.
+- **Multi-Modal Input:** Attach any file (not just images) for the AI to read; audio attachments (`.ogg`/`.mp3`/`.m4a`/`.wav`) are transcribed to text automatically.
+
+## Prerequisites
+
+- Node.js >= 18
+- Python >= 3.10
+- `agy` (Antigravity CLI) installed on this machine
+- `ffmpeg` on your PATH (needed for TTS/voice playback)
+- A Discord bot token, and at least one server/channel to allow it in
+
+### Creating the Discord bot
+
+In the [Discord Developer Portal](https://discord.com/developers/applications), create an application and bot, then:
+
+- Under **Bot**, enable the **Message Content** privileged intent (required - the bot reads message text/attachments).
+- Under **OAuth2 → URL Generator**, select the **bot** and **applications.commands** scopes, then these bot permissions:
+  - Send Messages, Send Messages in Threads, Create Public Threads
+  - Read Message History, Attach Files, Embed Links, Add Reactions
+  - Connect, Speak (for voice channel support)
+- Use the generated URL to invite the bot to your server.
+
+## Installation
+
+```bash
+npm install -g linkgravity
+```
+
+This runs a postinstall step that creates a Python virtual environment at `~/.gemini/linkgravity/venv/` (kept outside the package install location on purpose - see `npm-scripts/venv-paths.js`) and installs `requirements.txt` into it - no manual `pip install` needed.
+
+## Setup
+
+Run the configuration wizard once to set your bot token, allowed servers/channels, and other settings:
+
+```bash
+lgy setup
+```
+
+This writes to `~/.gemini/linkgravity/lgy.json` (outside the package directory, so `npm update`/reinstall never touches it). You can re-run `lgy setup` any time to change settings later - each field keeps its current value if you leave it empty.
+
+During setup you'll be asked for one or more Discord servers to allow, and optionally specific channels within each:
+
+- Leave the channel list empty for a server → **the whole server** is allowed (any channel can start a session).
+- List specific channel IDs for a server → **only those channels** in that server are allowed.
+
+A new session is only ever started with the **`/new`** slash command in Discord - never just by typing a message. `/new` works both in a regular channel and from inside an existing thread.
+
+## Usage
+
+```bash
+lgy start      # Start the bot as a background daemon (via PM2)
+lgy stop       # Stop it
+lgy restart    # Restart it
+lgy logs       # View live logs (add -f to follow, --tail N for more lines)
+lgy enable     # Register the bot to auto-start on system boot
+lgy disable    # Remove it from system boot
+lgy            # Interactive menu (same commands, picked from a list)
+```
+
+## Development
+
+This project uses [Ruff](https://docs.astral.sh/ruff/) for Python linting/formatting and [Prettier](https://prettier.io/) for the Node.js side. `npm install` sets both up automatically (installs `requirements-dev.txt` into the venv at `~/.gemini/linkgravity/venv/`, registers git hooks) - manual install is only needed if you want to run them yourself outside of a commit. The venv lives outside this checkout (see `npm-scripts/venv-paths.js` for why), so on macOS/Linux:
+
+```bash
+~/.gemini/linkgravity/venv/bin/ruff check src/    # lint
+~/.gemini/linkgravity/venv/bin/ruff format src/   # format
+
+npm run format:check        # check JS formatting
+npm run format              # format JS
+```
+
+(On Windows, replace `venv/bin/ruff` with `venv\Scripts\ruff.exe` under the same `~/.gemini/linkgravity/` directory.)
+
+Git hooks (via [pre-commit](https://pre-commit.com/), config in `.pre-commit-config.yaml`) run automatically once you `npm install`:
+
+- **pre-commit**: runs `ruff` (lint + format) and `prettier` on staged files, auto-fixing what it can.
+- **commit-msg**: enforces [Conventional Commits](https://www.conventionalcommits.org/) (e.g. `fix: ...`, `feat: ...`, `docs: ...`) via [conventional-pre-commit](https://github.com/compilerla/conventional-pre-commit).
+
+If a hook doesn't seem to be running, check `git config --get core.hooksPath` - it should be unset (or point at `.git/hooks`, pre-commit's default). A leftover `.husky` value from an older checkout will silently make git skip pre-commit's hooks entirely; `git config --unset core.hooksPath` fixes it.
+
+## Debugging
+
+Set `LOG_LEVEL=DEBUG` in your shell before `lgy restart` for verbose logs, including agy's raw stdout for each turn (`lgy` passes your shell's environment through to the daemon on restart). Defaults to `INFO`. Use `lgy logs -t` (or `--timestamp`) to include timestamps - they're stripped by default.
+
+## Known Issues
+
+**Wake word false positives on short words** (e.g. "시리", "잼민이"): Rustpotter's phoneme matching carries less signal for 1-2 syllable words, so genuine-match and unrelated-speech score distributions overlap - no single threshold cleanly separates them. Current mitigations in `voice-service/index.js`'s `getDetectorForUser` and `cogs/voice_cog.py`'s `handle_stt_input`:
+
+- `score_mode: Max` (each of the 5 enrollment samples can cover a different natural tone/pace, instead of requiring all 5 to be delivered consistently like `Median` did)
+- `min_scores: 4` (requires a candidate to keep winning across several frames, compensating for `Max` being more permissive per-frame)
+- The STT-based text cross-check is tightened specifically for short wake words (similarity floor 0.55, vs. 0.35 for longer ones) - this is currently doing most of the real work of rejecting false positives
+
+This isn't fully solved. If issues persist after real-world use, prefer these over further threshold guessing:
+
+1. Encourage re-enrolling with a longer/more distinctive wake word (a 1-2 syllable word is close to a hard ceiling for this approach, regardless of tuning)
+2. Log `bestWakeScore` + outcome (no raw audio) during a trial period and re-tune the constants above against that data instead of guessing
+
+## Security Warning
+
+This bot gives an AI agent broad access to the machine it runs on - **that's inherent to what it does, so don't expose it publicly or run it somewhere you don't fully trust its users.**
+
+- `allowed_user_ids` (set via `lgy setup`) is your primary access control - always set it.
+- Tool calls (including shell commands) go through an approval flow in Discord by default; treat anyone in `allowed_user_ids` as having effectively full control of this machine.
+- Your Discord token and other settings live in `~/.gemini/linkgravity/lgy.json`, outside this repo/package directory - never commit or share that file.

package/bin/cli.js

@@ -0,0 +1,278 @@
+#!/usr/bin/env node
+
+const { spawn, spawnSync } = require('child_process');
+const path = require('path');
+
+// Find the absolute path to the Python bot script
+const botPath = path.join(__dirname, '..', 'src', 'main.py');
+const { python: pythonExe, isWin } = require('../npm-scripts/venv-paths');
+
+const cmd = process.argv[2];
+
+const color = {
+    reset: '\x1b[0m',
+    green: '\x1b[32m',
+    cyan: '\x1b[36m',
+    yellow: '\x1b[33m',
+    dim: '\x1b[2m',
+};
+
+function success(msg) {
+    console.log(`${color.green}✔${color.reset} ${msg}`);
+}
+
+function info(msg) {
+    console.log(`\n${color.cyan}▶${color.reset} ${msg}`);
+}
+
+function runPm2(args, silent = true) {
+    const stdioOpt = silent ? 'pipe' : 'inherit';
+    const result = spawnSync('npx', ['-y', 'pm2', ...args], {
+        stdio: stdioOpt,
+        cwd: path.join(__dirname, '..'),
+        // pm2 pipes the Python process's stdout rather than giving it a
+        // TTY, so Python defaults to block-buffering it - occasional
+        // log lines (like a single WARNING) can sit in that buffer
+        // indefinitely instead of reaching `pm2 logs`/bot.log. This
+        // forces line-by-line flushing regardless of interpreter/OS.
+        env: { ...process.env, PYTHONUNBUFFERED: '1' },
+    });
+
+    if (result.error) {
+        console.error('Failed to execute PM2:', result.error.message);
+        process.exit(1);
+    }
+
+    let hasSudoInstructions = false;
+    if (silent && result.stdout && (args[0] === 'startup' || args[0] === 'unstartup')) {
+        const out = result.stdout.toString();
+        const lines = out.split('\n');
+        for (const line of lines) {
+            if (
+                line.trim().startsWith('sudo env PATH') ||
+                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;
+            }
+        }
+    }
+
+    if (result.status !== 0 && !hasSudoInstructions) {
+        if (silent && result.stderr) {
+            console.error(result.stderr.toString().trim());
+        }
+        process.exit(result.status);
+    }
+}
+
+// Matches a leading timestamp in either format our logs actually use:
+//   "2026-07-19 19:11:25 INFO  ..."          (loguru)
+//   "[2026-07-19 14:31:53] [INFO    ] ..."   (aiohttp access log)
+// Only strips the FIRST bracket group if present, so aiohttp's second
+// "[INFO ]" bracket (not a timestamp) is left alone.
+const TIMESTAMP_PREFIX = /^\[?\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}\]?\s*/;
+
+function runPm2LogsClean(args, showStamps = false) {
+    const cp = spawn('npx', ['-y', 'pm2', ...args], { cwd: path.join(__dirname, '..') });
+
+    const filterAndPrint = (data) => {
+        const lines = data.toString().split('\n');
+        for (const line of lines) {
+            if (line.trim().length === 0) continue;
+            if (
+                line.includes('In-memory PM2') ||
+                line.includes('pm2 update') ||
+                line.includes('[TAILING]') ||
+                line.includes('.pm2/logs/lgy') ||
+                line.includes('In memory PM2 version') ||
+                line.includes('Local PM2 version') ||
+                line.match(/^>+ /)
+            ) {
+                continue;
+            }
+            console.log(showStamps ? line : line.replace(TIMESTAMP_PREFIX, ''));
+        }
+    };
+
+    cp.stdout.on('data', filterAndPrint);
+    cp.stderr.on('data', filterAndPrint);
+}
+
+function verifyStartup() {
+    process.stdout.write(
+        `${color.cyan}▶${color.reset} Verifying startup status (waiting for bot to come online)...`,
+    );
+
+    let cp = spawn('npx', ['-y', 'pm2', 'logs', 'lgy', '--raw', '--lines', '0'], {
+        cwd: path.join(__dirname, '..'),
+    });
+
+    let timer = setTimeout(() => {
+        console.log(
+            `\n\n${color.yellow}⏳ Startup verification timed out. Run 'lgy logs' to check status manually.${color.reset}`,
+        );
+        cp.kill();
+        process.exit(1);
+    }, 15000);
+
+    const checkLog = (data) => {
+        const str = data.toString();
+        if (str.includes('Bot is fully online and ready!')) {
+            clearTimeout(timer);
+            console.log(
+                `\n${color.green}✔${color.reset} Bot successfully came online and is connected to Discord!\n`,
+            );
+            cp.kill();
+            process.exit(0);
+        } else if (
+            str.includes('Traceback (most recent call last):') ||
+            str.includes('Error:') ||
+            str.includes('Exception:')
+        ) {
+            clearTimeout(timer);
+            console.log(`\n\n${color.yellow}❌ Error detected during startup:${color.reset}`);
+            const errorLines = str
+                .split('\n')
+                .filter(
+                    (l) =>
+                        !l.includes('In-memory') && !l.includes('[TAILING]') && l.trim().length > 0,
+                );
+            console.log(errorLines.join('\n'));
+            cp.kill();
+            process.exit(1);
+        }
+    };
+
+    cp.stdout.on('data', checkLog);
+    cp.stderr.on('data', checkLog);
+}
+
+if (cmd === 'start') {
+    info('Starting LinkGravity daemon...');
+    runPm2(['start', botPath, '--interpreter', pythonExe, '--name', 'lgy']);
+    verifyStartup();
+} else if (cmd === 'stop') {
+    info('Stopping LinkGravity daemon...');
+    runPm2(['stop', 'lgy']);
+    success('Daemon stopped successfully.\n');
+} else if (cmd === 'restart') {
+    info('Restarting LinkGravity daemon...');
+    runPm2(['restart', 'lgy', '--update-env']);
+    verifyStartup();
+} else if (cmd === 'logs') {
+    let args = process.argv.slice(3);
+    let pm2Args = ['logs', 'lgy'];
+    let isFollow = false;
+    let showStamps = false;
+
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--tail' || args[i] === '-n') {
+            pm2Args.push('--lines', args[i + 1] || '15');
+            i++;
+        } else if (args[i] === '-f') {
+            isFollow = true;
+        } else if (args[i] === '-t' || args[i] === '--stamp' || args[i] === '--timestamp' || args[i] === '--timestamps') {
+            showStamps = true;
+        } else {
+            pm2Args.push(args[i]);
+        }
+    }
+
+    if (!isFollow) {
+        pm2Args.push('--nostream');
+    }
+    pm2Args.push('--raw');
+    runPm2LogsClean(pm2Args, showStamps);
+} else if (cmd === 'enable') {
+    if (isWin) {
+        console.log(
+            `\n${color.yellow}⚠${color.reset} pm2 doesn't support auto-start-on-boot on Windows natively. ` +
+                `Use a third-party tool like pm2-windows-startup (https://github.com/marklagendijk/node-pm2-windows-startup) instead.`,
+        );
+        process.exit(1);
+    }
+    info('Registering LinkGravity to start on system boot...');
+    runPm2(['startup']);
+    runPm2(['save']);
+    success('Auto-start configuration saved.\n');
+} else if (cmd === 'disable') {
+    if (isWin) {
+        console.log(
+            `\n${color.yellow}⚠${color.reset} pm2 doesn't support auto-start-on-boot on Windows natively - ` +
+                `nothing to disable here. If you set it up via a third-party tool, remove it through that tool.`,
+        );
+        process.exit(1);
+    }
+    info('Removing LinkGravity from system boot...');
+    runPm2(['unstartup']);
+    runPm2(['save']);
+    success('Auto-start configuration removed.\n');
+} else if (cmd === 'setup' || cmd === 'init') {
+    const runSetup = require('./setup');
+    runSetup().catch((err) => {
+        console.error('Setup wizard crashed:', err.message);
+    });
+} else if (cmd === 'help') {
+    console.log(
+        [
+            '',
+            '🌌 LinkGravity (lgy / linkgravity)',
+            '',
+            'Usage: lgy <command> [options]',
+            '',
+            'Commands:',
+            '  start      Start bot in the background (PM2 daemon)',
+            '  stop       Stop the background bot',
+            '  restart    Restart the background bot',
+            '  logs       View bot logs (Options: --tail, -n, -f, -t/--timestamp)',
+            '  enable     Register bot to start automatically on system boot',
+            '  disable    Remove bot from system boot',
+            '  setup      Run the configuration wizard (init)',
+            '  help       Show this help message',
+            '',
+        ].join('\n'),
+    );
+} else if (!cmd) {
+    const p = require('@clack/prompts');
+    (async () => {
+        console.log();
+        p.intro(`${color.cyan}🌌 LinkGravity Interactive Menu${color.reset}`);
+
+        const action = await p.select({
+            message: 'What would you like to do?',
+            options: [
+                { label: 'Start', value: 'start', hint: 'Start the bot daemon in the background' },
+                { label: 'Stop', value: 'stop', hint: 'Stop the running daemon' },
+                { label: 'Restart', value: 'restart', hint: 'Restart the running daemon' },
+                { label: 'Logs', value: 'logs', hint: 'View the live console logs' },
+                { label: 'Setup', value: 'setup', hint: 'Configure bot tokens and settings' },
+                {
+                    label: 'Enable Auto-start',
+                    value: 'enable',
+                    hint: 'Turn ON automatic boot on system startup',
+                },
+                { label: 'Disable Auto-start', value: 'disable', hint: 'Turn OFF automatic boot' },
+                { label: 'Exit', value: 'exit', hint: 'Close this menu' },
+            ],
+        });
+
+        if (p.isCancel(action) || action === 'exit') {
+            p.cancel('Menu closed.');
+            process.exit(0);
+        }
+
+        p.outro(`Executing: ${action}`);
+        const { spawnSync } = require('child_process');
+        spawnSync(process.argv[0], [process.argv[1], action], { stdio: 'inherit' });
+    })();
+} else {
+    // If no valid command was provided, show help
+    console.log(
+        `\n❌ Unknown command: ${cmd || 'none'}\n💡 Run 'lgy help' to see available commands.`,
+    );
+}

package/bin/setup.js

@@ -0,0 +1,260 @@
+const p = require('@clack/prompts');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { spawnSync } = require('child_process');
+
+const color = {
+    reset: '\x1b[0m',
+    green: '\x1b[32m',
+    cyan: '\x1b[36m',
+    yellow: '\x1b[33m',
+};
+
+const workspaceDir = path.join(os.homedir(), '.gemini', 'linkgravity');
+const settingsPath = path.join(workspaceDir, 'lgy.json');
+
+if (!fs.existsSync(workspaceDir)) fs.mkdirSync(workspaceDir, { recursive: true });
+
+function getSettings() {
+    if (fs.existsSync(settingsPath)) {
+        try {
+            return JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+        } catch (e) {}
+    }
+    return {};
+}
+
+function updateSettings(updates) {
+    const settings = getSettings();
+    for (const [key, value] of Object.entries(updates)) {
+        settings[key] = value;
+    }
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 4));
+}
+
+function splitIds(raw) {
+    return raw.split(/[\s,;]+/).filter(Boolean);
+}
+
+async function collectSessionScopes(existingScopes) {
+    const scopes = [];
+    const hasExisting = existingScopes && existingScopes.length > 0;
+
+    p.note(
+        'A new AI session can only be started with the /new command in Discord - never just by ' +
+            'typing a message. This step controls WHERE /new is allowed to work.\n\n' +
+            'For each server: leave "channels" empty to allow /new in EVERY channel of that server, ' +
+            'or list specific channel IDs to restrict it to just those.',
+        'Server / Channel Access',
+    );
+
+    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:`,
+        });
+        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;
+        }
+        isFirst = false;
+
+        const channelIds = await p.text({
+            message:
+                'Restrict to specific channel ID(s) in this server? Right-click a CHANNEL → Copy Channel ID. ' +
+                'Comma-separated, or leave empty to allow the WHOLE server:',
+        });
+        if (p.isCancel(channelIds)) {
+            p.cancel('Setup cancelled.');
+            process.exit(0);
+        }
+
+        scopes.push({
+            guild_id: guildId.trim(),
+            channel_ids: channelIds ? splitIds(channelIds) : [],
+        });
+
+        const addAnother = await p.confirm({ message: 'Add another server?', initialValue: false });
+        if (p.isCancel(addAnother)) {
+            p.cancel('Setup cancelled.');
+            process.exit(0);
+        }
+        if (!addAnother) break;
+    }
+
+    return scopes;
+}
+
+async function collectUserIds(existingIds) {
+    const ids = [];
+    const hasExisting = existingIds && existingIds.length > 0;
+
+    p.note(
+        'ONLY these users can use the bot (leave completely empty on first setup to allow EVERYONE). ' +
+            "Not related to DMs - this only gates the channel/threads configured above.",
+        'Allowed Discord Users',
+    );
+
+    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: `Discord User ID to allow${promptSuffix}:`,
+        });
+        if (p.isCancel(userId)) {
+            p.cancel('Setup cancelled.');
+            process.exit(0);
+        }
+
+        if (!userId) {
+            if (isFirst) return null; // signal: keep existing config untouched
+            break;
+        }
+        isFirst = false;
+
+        ids.push(userId.trim());
+
+        const addAnother = await p.confirm({ message: 'Add another user?', initialValue: false });
+        if (p.isCancel(addAnother)) {
+            p.cancel('Setup cancelled.');
+            process.exit(0);
+        }
+        if (!addAnother) break;
+    }
+
+    return ids;
+}
+
+async function runSetup() {
+    console.log();
+    p.intro(`${color.cyan}▶ LinkGravity Setup Wizard${color.reset}`);
+
+    const platform = await p.select({
+        message: 'Which messenger platform would you like to configure?',
+        options: [{ label: 'Discord', value: 'discord', hint: 'Configure Discord bot settings' }],
+    });
+    if (p.isCancel(platform)) {
+        p.cancel('Setup cancelled.');
+        process.exit(0);
+    }
+
+    const discordToken = await p.password({
+        message: 'Discord Bot Token (Leave empty to keep current):',
+    });
+    if (p.isCancel(discordToken)) {
+        p.cancel('Setup cancelled.');
+        process.exit(0);
+    }
+
+    const existingSettings = getSettings();
+    const sessionScopes = await collectSessionScopes(existingSettings.session_scopes);
+
+    const existingUserIds = existingSettings.allowed_user_ids
+        ? splitIds(existingSettings.allowed_user_ids)
+        : [];
+    const userIds = await collectUserIds(existingUserIds);
+
+    p.note(
+        'Wake words aren\'t set here anymore - they need a voice recording to register '
+            + '(so only your voice triggers them), which this terminal wizard can\'t do. '
+            + 'Set them from Discord with `/sound wake_words:<word>` once the bot is running.',
+        'Wake Words',
+    );
+
+    const group = await p.group(
+        {
+            tts_voice: () =>
+                p.select({
+                    message:
+                        'TTS Voice Model (Select default voice - you can change this anytime later in Discord via /sound, which lists many more):',
+                    options: [
+                        {
+                            label: 'ko-KR-SunHiNeural (Korean Female - Default)',
+                            value: 'ko-KR-SunHiNeural',
+                        },
+                        { label: 'ko-KR-InJoonNeural (Korean Male)', value: 'ko-KR-InJoonNeural' },
+                        { label: 'en-US-AriaNeural (English Female)', value: 'en-US-AriaNeural' },
+                        { label: 'en-US-GuyNeural (English Male)', value: 'en-US-GuyNeural' },
+                        {
+                            label: 'en-US-AnaNeural (English Female, child-like)',
+                            value: 'en-US-AnaNeural',
+                        },
+                        {
+                            label: 'en-US-ChristopherNeural (English Male)',
+                            value: 'en-US-ChristopherNeural',
+                        },
+                        {
+                            label: 'en-GB-SoniaNeural (English Female, UK)',
+                            value: 'en-GB-SoniaNeural',
+                        },
+                        { label: 'en-GB-RyanNeural (English Male, UK)', value: 'en-GB-RyanNeural' },
+                        {
+                            label: 'en-AU-NatashaNeural (English Female, AU)',
+                            value: 'en-AU-NatashaNeural',
+                        },
+                        {
+                            label: 'en-AU-WilliamNeural (English Male, AU)',
+                            value: 'en-AU-WilliamNeural',
+                        },
+                        {
+                            label: 'ja-JP-NanamiNeural (Japanese Female)',
+                            value: 'ja-JP-NanamiNeural',
+                        },
+                        { label: 'ja-JP-KeitaNeural (Japanese Male)', value: 'ja-JP-KeitaNeural' },
+                        {
+                            label: 'fr-FR-DeniseNeural (French Female)',
+                            value: 'fr-FR-DeniseNeural',
+                        },
+                        { label: 'de-DE-KatjaNeural (German Female)', value: 'de-DE-KatjaNeural' },
+                        {
+                            label: 'es-ES-ElviraNeural (Spanish Female)',
+                            value: 'es-ES-ElviraNeural',
+                        },
+                    ],
+                }),
+        },
+        {
+            onCancel: () => {
+                p.cancel('Setup cancelled.');
+                process.exit(0);
+            },
+        },
+    );
+
+    const settingsUpdates = {};
+    if (discordToken) settingsUpdates.discord_token = discordToken;
+    if (sessionScopes !== null) settingsUpdates.session_scopes = sessionScopes;
+    if (userIds !== null) settingsUpdates.allowed_user_ids = userIds.join(',');
+    if (group.tts_voice) settingsUpdates.tts_voice = group.tts_voice;
+
+    if (Object.keys(settingsUpdates).length > 0) {
+        updateSettings(settingsUpdates);
+    }
+
+    p.note('Configuration saved to lgy.json successfully!', 'Success');
+
+    console.log(`${color.cyan}▶${color.reset} Restarting daemon to apply changes...`);
+    spawnSync('npx', ['-y', 'pm2', 'restart', 'lgy', '--update-env'], {
+        stdio: 'pipe',
+        env: { ...process.env, PYTHONUNBUFFERED: '1' },
+    });
+
+    p.outro('Daemon restarted.');
+}
+
+module.exports = runSetup;