linkgravity 1.0.0

package/hooks/hook.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+import json
+import os
+import sys
+import urllib.error
+import urllib.request
+
+
+def main():
+    if os.environ.get("AGY_DISCORD_BOT") != "1":
+        print(json.dumps({"decision": "allow"}))
+        return
+
+    try:
+        raw_input = sys.stdin.read()
+        hook_input = json.loads(raw_input)
+    except Exception:
+        print(json.dumps({"decision": "deny", "reason": "Failed to parse hook input."}))
+        return
+
+    tool_call = hook_input.get("toolCall", {})
+    tool_name = tool_call.get("name", "unknown_tool")
+
+    tool_input_data = tool_call.get("args", {})
+    conv_id = hook_input.get("conversationId", "unknown")
+
+    payload = json.dumps(
+        {
+            "conversation_id": conv_id,
+            "tool_name": tool_name,
+            "tool_input": tool_input_data,
+            "thread_id": os.environ.get("DISCORD_THREAD_ID"),
+        }
+    ).encode("utf-8")
+
+    req = urllib.request.Request(
+        "http://localhost:18080/approve", data=payload, headers={"Content-Type": "application/json"}
+    )
+
+    try:
+        with urllib.request.urlopen(req, timeout=3600) as response:
+            res_data = json.loads(response.read().decode("utf-8"))
+            decision = res_data.get("decision", "allow")
+            if decision == "allow":
+                out = {"decision": "allow"}
+                # Print mode requires a matching allow rule even when this
+                # hook says "allow", or it soft-denies the tool call anyway.
+                if res_data.get("permissionOverrides"):
+                    out["permissionOverrides"] = res_data["permissionOverrides"]
+                print(json.dumps(out))
+            else:
+                reason = res_data.get("reason", "User rejected the action.")
+                print(json.dumps({"decision": "deny", "reason": reason}))
+    except Exception as e:
+        sys.stderr.write(f"Hook error: {e}\n")
+        print(json.dumps({"decision": "deny", "reason": f"Connection to webhook failed: {e}"}))
+
+
+if __name__ == "__main__":
+    main()

package/hooks/stop_hook.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+"""Stop-event hook (https://antigravity.google/docs/hooks#stop).
+
+`fullyIdle: false` means a run_command call detached to async (its
+WaitMsBeforeAsync budget ran out) is still in flight. Returning
+{"decision": "continue"} keeps the turn alive so agy can pick up that
+result instead of ending the turn with it lost. Capped by executionNum
+so a genuinely stuck command doesn't loop forever.
+"""
+
+import json
+import sys
+from datetime import datetime
+from pathlib import Path
+
+MAX_CONTINUE_ATTEMPTS = 20
+# This runs as its own process, invoked directly by agy - not visible in
+# `lgy logs`. Plain-file logging is the only way to inspect it.
+DEBUG_LOG = Path.home() / ".gemini" / "linkgravity" / "logs" / "stop_hook_debug.log"
+
+
+def log(line: str):
+    try:
+        DEBUG_LOG.parent.mkdir(parents=True, exist_ok=True)
+        with open(DEBUG_LOG, "a", encoding="utf-8") as f:
+            f.write(f"{datetime.now().isoformat()} {line}\n")
+    except Exception:
+        pass
+
+
+def main():
+    try:
+        raw = sys.stdin.read()
+        hook_input = json.loads(raw)
+    except Exception as e:
+        log(f"[PARSE ERROR] {e} raw={raw!r}")
+        print(json.dumps({}))
+        return
+
+    fully_idle = hook_input.get("fullyIdle", True)
+    execution_num = hook_input.get("executionNum", 0)
+    termination_reason = hook_input.get("terminationReason")
+    log(
+        f"[STOP HOOK] fullyIdle={fully_idle!r} executionNum={execution_num!r} "
+        f"terminationReason={termination_reason!r} conv={hook_input.get('conversationId')!r}"
+    )
+
+    if not fully_idle and execution_num < MAX_CONTINUE_ATTEMPTS:
+        response = {
+            "decision": "continue",
+            "reason": (
+                "A background command is still running. Wait for it to finish, "
+                "then report its actual result to the user before ending your turn."
+            ),
+        }
+        log(f"[STOP HOOK] -> continue: {response}")
+        print(json.dumps(response))
+    else:
+        log("[STOP HOOK] -> {} (fullyIdle true or attempt cap reached)")
+        print(json.dumps({}))
+
+
+if __name__ == "__main__":
+    main()

package/npm-scripts/postinstall.js

@@ -0,0 +1,62 @@
+const { execSync } = require('child_process');
+const os = require('os');
+const path = require('path');
+const fs = require('fs');
+const { pip: venvPip, workspaceDir } = require('./venv-paths');
+
+console.log('⚙️  Setting up Python Virtual Environment...');
+console.log(`   (in ${path.join(workspaceDir, 'venv')} - not inside this install, so it survives`);
+console.log('    package updates/reinstalls and works the same whether this is a global');
+console.log('    `npm install -g linkgravity` or a local dev clone.)');
+
+// Use python on Windows, python3 on Mac/Linux - this is the *system*
+// python used only to create the venv below; once it exists, every
+// other script (this one included) goes through venv-paths.js instead.
+const isWin = os.platform() === 'win32';
+const pyCmd = isWin ? 'python' : 'python3';
+
+async function main() {
+    try {
+        // 1. Create Python virtual environment (venv) in the fixed
+        // workspace dir, not in cwd - see venv-paths.js for why.
+        fs.mkdirSync(workspaceDir, { recursive: true });
+        execSync(`${pyCmd} -m venv "${path.join(workspaceDir, 'venv')}"`, { stdio: 'inherit' });
+
+        // 2. Install Python packages
+        console.log('📦 Installing Python dependencies...');
+        execSync(`"${venvPip}" install -r requirements.txt`, { stdio: 'inherit' });
+
+        // 3. Install Node.js voice service packages (includes
+        // rustpotter-web, which handles both wake-word detection AND
+        // building .rpw reference files in-process - no separate
+        // binary download needed for either).
+        console.log('🎙️  Installing Voice Service dependencies...');
+        execSync('npm install', {
+            stdio: 'inherit',
+            cwd: path.join(__dirname, '..', 'voice-service'),
+        });
+
+        // 4. Register this install's location with agy as its
+        // tool-approval hook (~/.gemini/config/hooks.json) - always
+        // re-run so the registered path self-heals if this checkout
+        // gets moved/renamed later, instead of silently going stale.
+        // Guarded on its own: agy may not be installed/configured yet
+        // on a brand new machine, and that shouldn't fail the rest of
+        // the install - just means the hook needs registering once agy
+        // itself is set up (re-running `npm install` after does it).
+        try {
+            require('./register-hook')();
+        } catch (err) {
+            console.warn(
+                `⚠️  Couldn't register the agy tool-approval hook: ${err.message.split('\n')[0]}`,
+            );
+        }
+
+        console.log('✅ Installation complete!');
+    } catch (error) {
+        console.error('❌ Installation failed. Please ensure Python 3.10+ is installed.');
+        process.exit(1);
+    }
+}
+
+main();

package/npm-scripts/prepare.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+// Runs at `prepare` time - which npm only triggers for a local `npm
+// install` inside this repo (i.e. a git clone / contributor checkout),
+// never for `npm install -g linkgravity` end users installing the published
+// package from the registry. That's exactly why dev-only setup (git
+// hooks, lint tooling) lives here instead of postinstall.js, which runs
+// for everyone, including end users who don't need any of this.
+'use strict';
+const { execSync } = require('child_process');
+const fs = require('fs');
+const { repoRoot, pip, preCommit } = require('./venv-paths');
+
+if (!fs.existsSync(pip)) {
+    console.warn(
+        '⚠️  No venv found yet - skipping dev tooling install and git hook setup. ' +
+            'Run `npm install` again once the venv exists, or set it up manually.',
+    );
+    return;
+}
+
+// 1. Dev-only Python tooling into the same venv postinstall.js already
+// created (prepare always runs after postinstall in npm's lifecycle
+// order): ruff (editor/manual use) and pre-commit itself, which is
+// what actually runs the hooks declared in .pre-commit-config.yaml.
+try {
+    execSync(`"${pip}" install -r requirements-dev.txt`, { stdio: 'inherit', cwd: repoRoot });
+} catch (err) {
+    console.warn(`⚠️  Couldn't install dev Python tooling: ${err.message.split('\n')[0]}`);
+    return;
+}
+
+// 2. Register the actual git hooks. --hook-type is passed explicitly
+// here even though .pre-commit-config.yaml's default_install_hook_types
+// already covers it, just so this line is self-explanatory on its own.
+try {
+    execSync(`"${preCommit}" install --hook-type pre-commit --hook-type commit-msg`, {
+        stdio: 'inherit',
+        cwd: repoRoot,
+    });
+} catch (err) {
+    console.warn(
+        `⚠️  Couldn't install git hooks (${err.message.split('\n')[0]}). ` +
+            "Pre-commit checks won't run until `venv/bin/pre-commit install --hook-type pre-commit --hook-type commit-msg` is run manually.",
+    );
+}

package/npm-scripts/register-hook.js

@@ -0,0 +1,182 @@
+'use strict';
+// Registers/fixes this project's agy hooks in ~/.gemini/config/hooks.json
+// (schema: https://antigravity.google/docs/hooks). Runs on every `npm
+// install` so paths stay correct if this checkout moves, identifying its
+// own entries by `name` (not command string) so a stale path gets fixed
+// in place rather than duplicated, leaving any other configured hooks
+// untouched. Only ever overwrites `command` - never `type`/`timeout`,
+// which the user may have customized - logging old/new values on change.
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { repoRoot, python: venvPython } = require('./venv-paths');
+
+const hooksJsonPath = path.join(os.homedir(), '.gemini', 'config', 'hooks.json');
+
+// PreToolUse: tool-approval gate, matcher-wrapped per schema.
+// Stop: fires when agy is about to end a turn; if fullyIdle is false
+// (an async run_command is still in flight), stop_hook.py tells agy to
+// keep going instead of ending the turn with that result lost. Flat
+// array per schema (no matcher - nothing to match tool names against).
+const HOOK_REGISTRATIONS = [
+    {
+        eventType: 'PreToolUse',
+        name: 'discord-approval',
+        scriptPath: path.join(repoRoot, 'hooks', 'hook.py'),
+        defaultTimeout: 3600,
+        wrapInMatcher: true,
+    },
+    {
+        eventType: 'Stop',
+        name: 'discord-approval-stop',
+        scriptPath: path.join(repoRoot, 'hooks', 'stop_hook.py'),
+        defaultTimeout: 30,
+        wrapInMatcher: false,
+    },
+];
+
+// Hooks retired from HOOK_REGISTRATIONS but listed here so an existing
+// install actually gets the stale entry removed from hooks.json, instead
+// of a zombie entry pointing at a script that no longer exists.
+const RETIRED_HOOKS = [{ eventType: 'PreInvocation', name: 'wait-ms-before-async-reminder' }];
+
+function loadHooksConfig() {
+    if (!fs.existsSync(hooksJsonPath)) {
+        return { hooks: {} };
+    }
+    try {
+        return JSON.parse(fs.readFileSync(hooksJsonPath, 'utf8'));
+    } catch (err) {
+        // Back up rather than silently clobbering whatever was there -
+        // it may have other hooks configured that have nothing to do
+        // with this project.
+        const backupPath = `${hooksJsonPath}.corrupted-${Date.now()}`;
+        fs.copyFileSync(hooksJsonPath, backupPath);
+        console.warn(
+            `⚠️  ${hooksJsonPath} was invalid JSON - backed up to ${backupPath} and starting fresh.`,
+        );
+        return { hooks: {} };
+    }
+}
+
+function findHookEntry(config, eventType, name, wrapInMatcher) {
+    config.hooks[eventType] = config.hooks[eventType] || [];
+    if (wrapInMatcher) {
+        let matcher = config.hooks[eventType].find((m) =>
+            (m.hooks || []).some((h) => h.name === name),
+        );
+        if (!matcher) {
+            matcher = { matcher: '.*', hooks: [] };
+            config.hooks[eventType].push(matcher);
+        }
+        let hookEntry = matcher.hooks.find((h) => h.name === name);
+        if (!hookEntry) {
+            hookEntry = { name };
+            matcher.hooks.push(hookEntry);
+        }
+        return hookEntry;
+    }
+    // Flat array (Stop/PreInvocation/PostInvocation) - no matcher wrapper.
+    let hookEntry = config.hooks[eventType].find((h) => h.name === name);
+    if (!hookEntry) {
+        hookEntry = { name };
+        config.hooks[eventType].push(hookEntry);
+    }
+    return hookEntry;
+}
+
+function removeRetiredHooks(config) {
+    let removedAny = false;
+    for (const retired of RETIRED_HOOKS) {
+        const arr = config.hooks[retired.eventType];
+        if (!arr) continue;
+
+        const nextArr = [];
+        for (const entry of arr) {
+            if (Array.isArray(entry.hooks)) {
+                // Matcher-wrapped shape - drop the matcher block too if
+                // nothing's left in it.
+                const beforeLen = entry.hooks.length;
+                entry.hooks = entry.hooks.filter((h) => h.name !== retired.name);
+                if (entry.hooks.length !== beforeLen) {
+                    removedAny = true;
+                    console.log(
+                        `🧹 Removed retired agy ${retired.eventType} hook '${retired.name}' from ${hooksJsonPath}`,
+                    );
+                }
+                if (entry.hooks.length > 0) nextArr.push(entry);
+            } else {
+                // Flat shape.
+                if (entry.name === retired.name) {
+                    removedAny = true;
+                    console.log(
+                        `🧹 Removed retired agy ${retired.eventType} hook '${retired.name}' from ${hooksJsonPath}`,
+                    );
+                } else {
+                    nextArr.push(entry);
+                }
+            }
+        }
+        config.hooks[retired.eventType] = nextArr;
+    }
+    return removedAny;
+}
+
+function registerHook() {
+    const config = loadHooksConfig();
+    config.hooks = config.hooks || {};
+    let wroteChange = false;
+    let backedUp = false;
+
+    const backupBeforeFirstChange = () => {
+        if (!backedUp && fs.existsSync(hooksJsonPath)) {
+            fs.copyFileSync(hooksJsonPath, `${hooksJsonPath}.bak`);
+            backedUp = true;
+        }
+    };
+
+    if (removeRetiredHooks(config)) {
+        backupBeforeFirstChange();
+        wroteChange = true;
+    }
+
+    for (const reg of HOOK_REGISTRATIONS) {
+        const command = `"${venvPython}" "${reg.scriptPath}"`;
+        const hookEntry = findHookEntry(config, reg.eventType, reg.name, reg.wrapInMatcher);
+        const isNew = !hookEntry.command;
+
+        if (isNew) {
+            hookEntry.type = 'command';
+            hookEntry.timeout = reg.defaultTimeout;
+            hookEntry.command = command;
+            console.log(
+                `🔗 Registered agy ${reg.eventType} hook '${reg.name}' -> ${reg.scriptPath}`,
+            );
+            wroteChange = true;
+        } else if (hookEntry.command !== command) {
+            backupBeforeFirstChange();
+            console.log(
+                `🔗 Fixing agy ${reg.eventType} hook '${reg.name}' in ${hooksJsonPath}` +
+                    (backedUp ? ` (previous version backed up to ${hooksJsonPath}.bak)` : '') +
+                    `:\n   was: ${hookEntry.command}\n   now: ${command}`,
+            );
+            hookEntry.command = command;
+            wroteChange = true;
+        } else {
+            console.log(
+                `🔗 agy ${reg.eventType} hook '${reg.name}' already up to date -> ${reg.scriptPath}`,
+            );
+        }
+    }
+
+    if (wroteChange) {
+        fs.mkdirSync(path.dirname(hooksJsonPath), { recursive: true });
+        fs.writeFileSync(hooksJsonPath, JSON.stringify(config, null, 2));
+    }
+}
+
+module.exports = registerHook;
+
+if (require.main === module) {
+    registerHook();
+}

package/npm-scripts/run-dev.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+// Used by the "start"/"dev" npm scripts.
+'use strict';
+const { spawnSync } = require('child_process');
+const path = require('path');
+const { python, repoRoot } = require('./venv-paths');
+
+const result = spawnSync(python, [path.join(repoRoot, 'src', 'main.py')], { stdio: 'inherit' });
+process.exit(result.status === null ? 1 : result.status);

package/npm-scripts/venv-paths.js

@@ -0,0 +1,45 @@
+'use strict';
+// Single source of truth for "where's the venv's stuff on this OS".
+// Previously bin/cli.js, postinstall.js, prepare.js, and
+// .lintstagedrc.cjs each computed their own `isWin ? 'Scripts' : 'bin'`
+// branch independently - four copies of the same three lines, with no
+// guarantee they'd stay in sync if one changed. Everything that needs
+// a path inside venv/ should require() this instead of recomputing it.
+const path = require('path');
+const os = require('os');
+
+const repoRoot = path.join(__dirname, '..');
+const isWin = os.platform() === 'win32';
+
+// The venv is generated, mutable, potentially large (hundreds of MB
+// once dependencies are installed) runtime state - not "package code" -
+// so, like every other piece of this project's persistent state
+// (lgy.json, logs/, wake_refs/ - see WORKSPACE_DIR in src/config.py),
+// it belongs in the user's own fixed data directory, not wherever this
+// copy of the code happens to be checked out or installed.
+//
+// This matters concretely for a real `npm install -g linkgravity`: the global
+// npm install location often isn't writable without sudo, and isn't
+// meant to hold generated mutable data in the first place - npm can
+// replace that directory's contents wholesale on update/reinstall.
+// Putting the venv there would reproduce both problems. One fixed
+// location, shared by every checkout/install on the machine, matches
+// this project's existing single-workspace assumption (there's already
+// only one lgy.json / one wake_refs/ / one logs/ for the whole
+// machine, not one per checkout).
+const workspaceDir = path.join(os.homedir(), '.gemini', 'linkgravity');
+const venvBinDir = path.join(workspaceDir, 'venv', isWin ? 'Scripts' : 'bin');
+
+function venvBin(name) {
+    return path.join(venvBinDir, isWin ? `${name}.exe` : name);
+}
+
+module.exports = {
+    repoRoot, // where the CODE lives (this checkout/install) - hooks/hook.py, src/main.py, etc.
+    workspaceDir, // where generated/user DATA lives (venv, logs, lgy.json, wake_refs, ...)
+    isWin,
+    venvBinDir,
+    python: venvBin('python'),
+    pip: venvBin('pip'),
+    preCommit: venvBin('pre-commit'),
+};

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "linkgravity",
+  "version": "1.0.0",
+  "description": "Discord bot bridge for the Antigravity (agy) CLI, with voice interaction support",
+  "scripts": {
+    "postinstall": "node npm-scripts/postinstall.js",
+    "start": "node npm-scripts/run-dev.js",
+    "dev": "node npm-scripts/run-dev.js",
+    "format": "prettier --write \"bin/**/*.js\" \"npm-scripts/**/*.js\" \"voice-service/*.js\"",
+    "format:check": "prettier --check \"bin/**/*.js\" \"npm-scripts/**/*.js\" \"voice-service/*.js\"",
+    "prepare": "node npm-scripts/prepare.js"
+  },
+  "author": "dev-sseul",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dev-sseul/linkgravity.git"
+  },
+  "homepage": "https://github.com/dev-sseul/linkgravity#readme",
+  "bugs": {
+    "url": "https://github.com/dev-sseul/linkgravity/issues"
+  },
+  "keywords": [
+    "discord",
+    "discord-bot",
+    "antigravity",
+    "agy",
+    "cli",
+    "voice",
+    "ai-agent"
+  ],
+  "bin": {
+    "lgy": "./bin/cli.js",
+    "linkgravity": "./bin/cli.js"
+  },
+  "files": [
+    "bin",
+    "npm-scripts",
+    "hooks",
+    "src",
+    "voice-service/index.js",
+    "voice-service/package.json",
+    "voice-service/package-lock.json",
+    "requirements.txt",
+    "!**/__pycache__/**",
+    "!**/*.py[cod]"
+  ],
+  "engines": {
+    "node": ">=18.0.0",
+    "python": ">=3.10"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.7.0",
+    "pm2": "^5.3.0"
+  },
+  "devDependencies": {
+    "prettier": "^3.3.0"
+  }
+}

package/requirements.txt

@@ -0,0 +1,13 @@
+discord.py[voice]>=2.4.0
+PyNaCl>=1.5.0
+numpy>=1.24.0
+edge-tts
+google-genai>=1.0.0
+aiohttp==3.10.3
+aiofiles==24.1.0
+SpeechRecognition>=3.17.0
+schedule==1.2.1
+jamo>=0.4.1
+loguru>=0.7.0
+mcp>=1.0.0
+requests>=2.31.0

package/src/api/server.py

@@ -0,0 +1,48 @@
+from aiohttp import web
+
+from config import logger, session_manager
+
+
+def is_tool_allowed(tool_name, tool_input):
+    if tool_name == "manage_task" and tool_input.get("Action") in ["list", "status", "kill", "send_input"]:
+        return True
+    if tool_name == "list_dir":
+        return True
+    if tool_name == "view_file":
+        return True
+    if tool_name == "read_file":
+        return True
+    if tool_name == "read_url_content":
+        return True
+    if tool_name in session_manager.persistent_allowed.get("tools", []):
+        return True
+    return False
+
+
+async def setup_webhook_server(bot):
+    app = web.Application(client_max_size=50 * 1024 * 1024)
+    app["bot"] = bot
+
+    from api.ui_routes import handle_approve_request, handle_mcp_ask, handle_mcp_send_channel
+    from api.voice_routes import (
+        handle_enroll_sample,
+        handle_stt_input,
+        handle_stt_partial,
+        handle_stt_partial_cancel,
+        handle_tts_finished,
+    )
+
+    app.router.add_post("/approve", handle_approve_request)
+    app.router.add_post("/mcp_ask", handle_mcp_ask)
+    app.router.add_post("/mcp_send_channel", handle_mcp_send_channel)
+    app.router.add_post("/stt_input", handle_stt_input)
+    app.router.add_post("/tts_finished", handle_tts_finished)
+    app.router.add_post("/stt_partial", handle_stt_partial)
+    app.router.add_post("/stt_partial_cancel", handle_stt_partial_cancel)
+    app.router.add_post("/enroll_sample", handle_enroll_sample)
+
+    runner = web.AppRunner(app)
+    await runner.setup()
+    site = web.TCPSite(runner, "0.0.0.0", 18080)
+    await site.start()
+    logger.info("Webhook / MCP / STT Server started on port 18080")