linkgravity 1.7.0 → 1.7.1

package/bin/cli.js

@@ -40,6 +40,22 @@ function info(msg) {
     console.log(`\n${color.cyan}▶${color.reset} ${msg}`);
 }
 
+// `fresh`: npm has swapped the package on disk since require time.
+function repairHookRegistration({ fresh = false } = {}) {
+    const modulePath = require.resolve('../npm-scripts/register-hook');
+    if (fresh) {
+        delete require.cache[modulePath];
+        delete require.cache[require.resolve('../npm-scripts/venv-paths')];
+    }
+    try {
+        require(modulePath)({ allowFirstTimeCreate: false, quiet: true });
+    } catch (err) {
+        console.log(
+            `${color.yellow}⚠${color.reset} Couldn't check the agy hook registration: ${err.message}`,
+        );
+    }
+}
+
 function runPm2(args, silent = true) {
     const stdioOpt = silent ? 'pipe' : 'inherit';
     const result = spawnSync(process.execPath, [PM2_BIN, ...args], {
@@ -392,6 +408,8 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
         require('../npm-scripts/ensure-env').ensureEnvironment();
     }
 
+    repairHookRegistration();
+
     info('Starting LinkGravity daemon...');
     runPm2([
         'start',
@@ -602,6 +620,7 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
     const latestVersion = viewResult.stdout.toString().trim();
 
     if (latestVersion === currentVersion) {
+        repairHookRegistration();
         success(`Already up to date (v${currentVersion}).\n`);
         process.exit(0);
     }
@@ -624,6 +643,7 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
     // replaced this package on disk, and the copy required at startup is the pre-update one.
     delete require.cache[require.resolve('../npm-scripts/ensure-env')];
     require('../npm-scripts/ensure-env').ensureEnvironment();
+    repairHookRegistration({ fresh: true });
 
     if (!procBeforeUpdate) {
         info("Daemon wasn't running - starting it fresh...");

package/bin/setup.js

@@ -476,6 +476,8 @@ async function runSetup() {
             process.exit(0);
         }
         if (consent) registerHook({ allowFirstTimeCreate: true });
+    } else {
+        registerHook({ allowFirstTimeCreate: false, quiet: true });
     }
 
     while (true) {

package/hooks/hook.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+'use strict';
+const fs = require('fs');
+const http = require('http');
+const os = require('os');
+const path = require('path');
+
+const LGY_CONFIG_FILE = path.join(os.homedir(), '.gemini', 'linkgravity', 'lgy.json');
+// Not "localhost" - the server binds 127.0.0.1 and node resolves localhost to ::1 first.
+const APPROVE_HOST = '127.0.0.1';
+const APPROVE_PORT = 18080;
+const TIMEOUT_MS = 3600 * 1000;
+
+function emit(payload) {
+    process.stdout.write(JSON.stringify(payload));
+}
+
+function loadApproveToken() {
+    try {
+        return JSON.parse(fs.readFileSync(LGY_CONFIG_FILE, 'utf8')).approve_token || '';
+    } catch {
+        return '';
+    }
+}
+
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) chunks.push(chunk);
+    return Buffer.concat(chunks).toString('utf8');
+}
+
+function requestDecision(body) {
+    return new Promise((resolve, reject) => {
+        const req = http.request(
+            {
+                host: APPROVE_HOST,
+                port: APPROVE_PORT,
+                path: '/approve',
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Content-Length': body.length,
+                    'X-LGY-Token': loadApproveToken(),
+                },
+            },
+            (res) => {
+                const parts = [];
+                res.on('data', (chunk) => parts.push(chunk));
+                res.on('end', () => {
+                    try {
+                        resolve(JSON.parse(Buffer.concat(parts).toString('utf8')));
+                    } catch (err) {
+                        reject(err);
+                    }
+                });
+            },
+        );
+        req.on('error', reject);
+        req.setTimeout(TIMEOUT_MS, () => req.destroy(new Error('timed out waiting for approval')));
+        req.end(body);
+    });
+}
+
+async function main() {
+    if (process.env.LGY_APPROVAL_HOOK !== '1') {
+        emit({ decision: 'allow' });
+        return;
+    }
+
+    let hookInput;
+    try {
+        hookInput = JSON.parse(await readStdin());
+    } catch {
+        emit({ decision: 'deny', reason: 'Failed to parse hook input.' });
+        return;
+    }
+
+    const toolCall = hookInput.toolCall || {};
+    const body = Buffer.from(
+        JSON.stringify({
+            conversation_id: hookInput.conversationId || 'unknown',
+            tool_name: toolCall.name || 'unknown_tool',
+            tool_input: toolCall.args || {},
+            thread_id: process.env.LGY_THREAD_ID || null,
+        }),
+        'utf8',
+    );
+
+    try {
+        const result = await requestDecision(body);
+        if ((result.decision || 'allow') === 'allow') {
+            const out = { decision: 'allow' };
+            // Print mode requires a matching allow rule even when this hook says "allow", or it soft-denies anyway.
+            if (result.permissionOverrides) out.permissionOverrides = result.permissionOverrides;
+            emit(out);
+        } else {
+            emit({ decision: 'deny', reason: result.reason || 'User rejected the action.' });
+        }
+    } catch (err) {
+        process.stderr.write(`Hook error: ${err.message}\n`);
+        emit({ decision: 'deny', reason: `Connection to webhook failed: ${err.message}` });
+    }
+}
+
+main();

package/hooks/stop_hook.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+'use strict';
+// Stop-event hook (https://antigravity.google/docs/hooks).
+// `fullyIdle: false` means a run_command that detached to async is still in flight; "continue"
+// keeps the turn alive so agy picks that result up instead of losing it.
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const MAX_CONTINUE_ATTEMPTS = 20;
+// Its own process, so it never reaches `lgy logs`.
+const DEBUG_LOG = path.join(os.homedir(), '.gemini', 'linkgravity', 'logs', 'stop_hook_debug.log');
+
+function log(line) {
+    try {
+        fs.mkdirSync(path.dirname(DEBUG_LOG), { recursive: true });
+        fs.appendFileSync(DEBUG_LOG, `${new Date().toISOString()} ${line}\n`);
+    } catch {}
+}
+
+function emit(payload) {
+    process.stdout.write(JSON.stringify(payload));
+}
+
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) chunks.push(chunk);
+    return Buffer.concat(chunks).toString('utf8');
+}
+
+async function main() {
+    const raw = await readStdin();
+    let hookInput;
+    try {
+        hookInput = JSON.parse(raw);
+    } catch (err) {
+        log(`[PARSE ERROR] ${err.message} raw=${JSON.stringify(raw)}`);
+        emit({});
+        return;
+    }
+
+    const fullyIdle = hookInput.fullyIdle ?? true;
+    const executionNum = hookInput.executionNum ?? 0;
+    log(
+        `[STOP HOOK] fullyIdle=${fullyIdle} executionNum=${executionNum} ` +
+            `terminationReason=${JSON.stringify(hookInput.terminationReason)} ` +
+            `conv=${JSON.stringify(hookInput.conversationId)}`,
+    );
+
+    if (!fullyIdle && executionNum < MAX_CONTINUE_ATTEMPTS) {
+        const 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(`[STOP HOOK] -> continue: ${JSON.stringify(response)}`);
+        emit(response);
+    } else {
+        log('[STOP HOOK] -> {} (fullyIdle true or attempt cap reached)');
+        emit({});
+    }
+}
+
+main();

package/npm-scripts/register-hook.js

@@ -3,30 +3,55 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
-const { repoRoot, python: venvPython } = require('./venv-paths');
+const { repoRoot, workspaceDir } = require('./venv-paths');
 
 const hooksJsonPath = path.join(os.homedir(), '.gemini', 'config', 'hooks.json');
 
-// PreToolUse/Stop meanings are agy's own hook contract: Stop fires when agy is about to
-// end a turn, and if fullyIdle is false (an async run_command still in flight), stop_hook.py
-// tells agy to keep going instead of losing that result.
+// Not process.execPath: this runs on every agy tool call machine-wide, and an absolute
+// interpreter path dies the moment a version manager moves it.
+const NODE_CMD = 'node';
+
+// A copy, never this package: npm has had no uninstall lifecycle since v7, so an entry pointing
+// into node_modules would 127 every agy tool call once linkgravity is removed.
+const installedHooksDir = path.join(workspaceDir, 'hooks');
+
 const HOOK_REGISTRATIONS = [
     {
         eventType: 'PreToolUse',
         name: 'discord-approval',
-        scriptPath: path.join(repoRoot, 'hooks', 'hook.py'),
+        fileName: 'hook.js',
         defaultTimeout: 3600,
         wrapInMatcher: true,
     },
     {
         eventType: 'Stop',
         name: 'discord-approval-stop',
-        scriptPath: path.join(repoRoot, 'hooks', 'stop_hook.py'),
+        fileName: 'stop_hook.js',
         defaultTimeout: 30,
         wrapInMatcher: false,
     },
 ];
 
+function installHookScripts() {
+    for (const reg of HOOK_REGISTRATIONS) {
+        const source = fs.readFileSync(path.join(repoRoot, 'hooks', reg.fileName), 'utf8');
+        const installedPath = path.join(installedHooksDir, reg.fileName);
+        let installed = null;
+        try {
+            installed = fs.readFileSync(installedPath, 'utf8');
+        } catch {}
+        if (installed === source) continue;
+        try {
+            fs.mkdirSync(installedHooksDir, { recursive: true });
+            fs.writeFileSync(installedPath, source);
+        } catch (err) {
+            // A stale copy still answers agy, so only a missing one is fatal.
+            if (installed === null) throw err;
+            console.log(`⚠️  Couldn't refresh ${installedPath}: ${err.message}`);
+        }
+    }
+}
+
 const RETIRED_HOOKS = [{ eventType: 'PreInvocation', name: 'wait-ms-before-async-reminder' }];
 
 function loadHooksConfig() {
@@ -104,7 +129,7 @@ function removeRetiredHooks(config) {
     return removedAny;
 }
 
-function registerHook({ allowFirstTimeCreate = true } = {}) {
+function registerHook({ allowFirstTimeCreate = true, quiet = false } = {}) {
     const config = loadHooksConfig();
     config.hooks = config.hooks || {};
 
@@ -116,9 +141,11 @@ function registerHook({ allowFirstTimeCreate = true } = {}) {
     });
 
     if (isFirstTime && !allowFirstTimeCreate) {
-        console.log(
-            "ℹ️  LinkGravity's Discord/Telegram/Slack approval hook isn't registered with agy yet - run `lgy setup` to enable it.",
-        );
+        if (!quiet) {
+            console.log(
+                "ℹ️  LinkGravity's Discord/Telegram/Slack approval hook isn't registered with agy yet - run `lgy setup` to enable it.",
+            );
+        }
         return;
     }
 
@@ -137,8 +164,11 @@ function registerHook({ allowFirstTimeCreate = true } = {}) {
         wroteChange = true;
     }
 
+    installHookScripts();
+
     for (const reg of HOOK_REGISTRATIONS) {
-        const command = `"${venvPython}" "${reg.scriptPath}"`;
+        const scriptPath = path.join(installedHooksDir, reg.fileName);
+        const command = `${NODE_CMD} "${scriptPath}"`;
         const hookEntry = findHookEntry(config, reg.eventType, reg.name, reg.wrapInMatcher);
         const isNew = !hookEntry.command;
 
@@ -146,9 +176,7 @@ function registerHook({ allowFirstTimeCreate = true } = {}) {
             hookEntry.type = 'command';
             hookEntry.timeout = reg.defaultTimeout;
             hookEntry.command = command;
-            console.log(
-                `🔗 Registered agy ${reg.eventType} hook '${reg.name}' -> ${reg.scriptPath}`,
-            );
+            console.log(`🔗 Registered agy ${reg.eventType} hook '${reg.name}' -> ${scriptPath}`);
             wroteChange = true;
         } else if (hookEntry.command !== command) {
             backupBeforeFirstChange();
@@ -159,9 +187,9 @@ function registerHook({ allowFirstTimeCreate = true } = {}) {
             );
             hookEntry.command = command;
             wroteChange = true;
-        } else {
+        } else if (!quiet) {
             console.log(
-                `🔗 agy ${reg.eventType} hook '${reg.name}' already up to date -> ${reg.scriptPath}`,
+                `🔗 agy ${reg.eventType} hook '${reg.name}' already up to date -> ${scriptPath}`,
             );
         }
     }

package/npm-scripts/venv-paths.js

@@ -35,7 +35,7 @@ function venvBin(name) {
 }
 
 module.exports = {
-    repoRoot, // where the CODE lives (this checkout/install) - hooks/hook.py, src/main.py, etc.
+    repoRoot, // where the CODE lives (this checkout/install) - hooks/hook.js, src/main.py, etc.
     workspaceDir, // where generated/user DATA lives (venv, logs, lgy.json, wake_refs, ...)
     isWin,
     venvBinDir,

package/package.json

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

package/hooks/hook.py

@@ -1,72 +0,0 @@
-#!/usr/bin/env python3
-import json
-import os
-import sys
-import urllib.error
-import urllib.request
-from pathlib import Path
-
-LGY_CONFIG_FILE = Path.home() / ".gemini" / "linkgravity" / "lgy.json"
-
-
-def _load_approve_token():
-    try:
-        with open(LGY_CONFIG_FILE, encoding="utf-8") as f:
-            return json.load(f).get("approve_token", "")
-    except Exception:
-        return ""
-
-
-def main():
-    if os.environ.get("LGY_APPROVAL_HOOK") != "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("LGY_THREAD_ID"),
-        }
-    ).encode("utf-8")
-
-    req = urllib.request.Request(
-        "http://localhost:18080/approve",
-        data=payload,
-        headers={"Content-Type": "application/json", "X-LGY-Token": _load_approve_token()},
-    )
-
-    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 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

@@ -1,64 +0,0 @@
-#!/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()