gvfs: add global command pre and post hook procs

This adds hard-coded call to GVFS.hooks.exe before and after each Git
command runs.

To make sure that this is only called on repositories cloned with GVFS, we
test for the tell-tale .gvfs.

2021-10-30: Recent movement of find_hook() to hook.c required moving these
changes out of run-command.c to hook.c.

2025-11-06: The `warn_on_auto_comment_char` hack is so ugly that it
forces us to pile similarly ugly code on top because that hack _expects_
that the config has not been read when `cmd_commit()`, `cmd_revert()`,
`cmd_cherry_pick()`, `cmd_merge()`, or `cmd_rebase()` set that flag. But
with the `pre_command()` hook already run, that assumption is incorrect.

Signed-off-by: Ben Peart <Ben.Peart@microsoft.com>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>

Author: Ben Peart

builtin/commit.c

@@ -1802,6 +1802,7 @@ int cmd_commit(int argc,
 
 #ifndef WITH_BREAKING_CHANGES
 	warn_on_auto_comment_char = true;
+	repo_config_clear(the_repository);
 #endif /* !WITH_BREAKING_CHANGES */
 	prepare_repo_settings(the_repository);
 	the_repository->settings.command_requires_full_index = 0;

builtin/merge.c

@@ -1381,6 +1381,7 @@ int cmd_merge(int argc,
 
 #ifndef WITH_BREAKING_CHANGES
 	warn_on_auto_comment_char = true;
+	repo_config_clear(the_repository);
 #endif /* !WITH_BREAKING_CHANGES */
 	prepare_repo_settings(the_repository);
 	the_repository->settings.command_requires_full_index = 0;

builtin/rebase.c

@@ -1243,6 +1243,7 @@ int cmd_rebase(int argc,
 
 #ifndef WITH_BREAKING_CHANGES
 	warn_on_auto_comment_char = true;
+	repo_config_clear(the_repository);
 #endif /* !WITH_BREAKING_CHANGES */
 	prepare_repo_settings(the_repository);
 	the_repository->settings.command_requires_full_index = 0;

builtin/revert.c

@@ -10,6 +10,7 @@
 #include "rerere.h"
 #include "sequencer.h"
 #include "branch.h"
+#include "config.h"
 
 /*
  * This implements the builtins revert and cherry-pick.
@@ -288,6 +289,7 @@ int cmd_revert(int argc,
 
 #ifndef WITH_BREAKING_CHANGES
 	warn_on_auto_comment_char = true;
+	repo_config_clear(the_repository);
 #endif /* !WITH_BREAKING_CHANGES */
 	opts.action = REPLAY_REVERT;
 	sequencer_init_config(&opts);
@@ -308,6 +310,7 @@ struct repository *repo UNUSED)
 
 #ifndef WITH_BREAKING_CHANGES
 	warn_on_auto_comment_char = true;
+	repo_config_clear(the_repository);
 #endif /* !WITH_BREAKING_CHANGES */
 	opts.action = REPLAY_PICK;
 	sequencer_init_config(&opts);

git.c

@@ -17,6 +17,8 @@
 #include "shallow.h"
 #include "trace.h"
 #include "trace2.h"
+#include "dir.h"
+#include "hook.h"
 
 #define RUN_SETUP		(1<<0)
 #define RUN_SETUP_GENTLY	(1<<1)
@@ -463,6 +465,67 @@ static int handle_alias(struct strvec *args, struct string_list *expanded_aliase
 	return ret;
 }
 
+/* Runs pre/post-command hook */
+static struct strvec sargv = STRVEC_INIT;
+static int run_post_hook = 0;
+static int exit_code = -1;
+
+static int run_pre_command_hook(struct repository *r, const char **argv)
+{
+	char *lock;
+	int ret = 0;
+	struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT;
+
+	/*
+	 * Ensure the global pre/post command hook is only called for
+	 * the outer command and not when git is called recursively
+	 * or spawns multiple commands (like with the alias command)
+	 */
+	lock = getenv("COMMAND_HOOK_LOCK");
+	if (lock && !strcmp(lock, "true"))
+		return 0;
+	setenv("COMMAND_HOOK_LOCK", "true", 1);
+
+	/* call the hook proc */
+	strvec_pushv(&sargv, argv);
+	strvec_pushv(&opt.args, sargv.v);
+	ret = run_hooks_opt(r, "pre-command", &opt);
+
+	if (!ret)
+		run_post_hook = 1;
+	return ret;
+}
+
+static int run_post_command_hook(struct repository *r)
+{
+	char *lock;
+	int ret = 0;
+	struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT;
+
+	/*
+	 * Only run post_command if pre_command succeeded in this process
+	 */
+	if (!run_post_hook)
+		return 0;
+	lock = getenv("COMMAND_HOOK_LOCK");
+	if (!lock || strcmp(lock, "true"))
+		return 0;
+
+	strvec_pushv(&opt.args, sargv.v);
+	strvec_pushf(&opt.args, "--exit_code=%u", exit_code);
+	ret = run_hooks_opt(r, "post-command", &opt);
+
+	run_post_hook = 0;
+	strvec_clear(&sargv);
+	setenv("COMMAND_HOOK_LOCK", "false", 1);
+	return ret;
+}
+
+static void post_command_hook_atexit(void)
+{
+	run_post_command_hook(the_repository);
+}
+
 static int run_builtin(struct cmd_struct *p, int argc, const char **argv, struct repository *repo)
 {
 	int status, help;
@@ -499,16 +562,21 @@ static int run_builtin(struct cmd_struct *p, int argc, const char **argv, struct
 	if (!help && p->option & NEED_WORK_TREE)
 		setup_work_tree();
 
+	if (run_pre_command_hook(the_repository, argv))
+		die("pre-command hook aborted command");
+
 	trace_argv_printf(argv, "trace: built-in: git");
 	trace2_cmd_name(p->cmd);
 
 	validate_cache_entries(repo->index);
-	status = p->fn(argc, argv, prefix, no_repo ? NULL : repo);
+	exit_code = status = p->fn(argc, argv, prefix, no_repo ? NULL : repo);
 	validate_cache_entries(repo->index);
 
 	if (status)
 		return status;
 
+	run_post_command_hook(the_repository);
+
 	/* Somebody closed stdout? */
 	if (fstat(fileno(stdout), &st))
 		return 0;
@@ -808,13 +876,16 @@ static void execv_dashed_external(const char **argv)
 	 */
 	trace_argv_printf(cmd.args.v, "trace: exec:");
 
+	if (run_pre_command_hook(the_repository, cmd.args.v))
+		die("pre-command hook aborted command");
+
 	/*
 	 * If we fail because the command is not found, it is
 	 * OK to return. Otherwise, we just pass along the status code,
 	 * or our usual generic code if we were not even able to exec
 	 * the program.
 	 */
-	status = run_command(&cmd);
+	exit_code = status = run_command(&cmd);
 
 	/*
 	 * If the child process ran and we are now going to exit, emit a
@@ -825,6 +896,8 @@ static void execv_dashed_external(const char **argv)
 		exit(status);
 	else if (errno != ENOENT)
 		exit(128);
+
+	run_post_command_hook(the_repository);
 }
 
 static int is_deprecated_command(const char *cmd)
@@ -930,6 +1003,7 @@ int cmd_main(int argc, const char **argv)
 	}
 
 	trace_command_performance(argv);
+	atexit(post_command_hook_atexit);
 
 	/*
 	 * "git-xxxx" is the same as "git xxxx", but we obviously:
@@ -957,10 +1031,14 @@ int cmd_main(int argc, const char **argv)
 	if (!argc) {
 		/* The user didn't specify a command; give them help */
 		commit_pager_choice();
+		if (run_pre_command_hook(the_repository, argv))
+			die("pre-command hook aborted command");
 		printf(_("usage: %s\n\n"), git_usage_string);
 		list_common_cmds_help();
 		printf("\n%s\n", _(git_more_info_string));
-		exit(1);
+		exit_code = 1;
+		run_post_command_hook(the_repository);
+		exit(exit_code);
 	}
 
 	if (!strcmp("--version", argv[0]) || !strcmp("-v", argv[0]))

hook.c

@@ -1,5 +1,8 @@
+#define USE_THE_REPOSITORY_VARIABLE
+
 #include "git-compat-util.h"
 #include "abspath.h"
+#include "environment.h"
 #include "advice.h"
 #include "gettext.h"
 #include "hook.h"
@@ -10,13 +13,66 @@
 #include "environment.h"
 #include "setup.h"
 
+static int early_hooks_path_config(const char *var, const char *value,
+				   const struct config_context *ctx UNUSED, void *cb)
+{
+	if (!strcmp(var, "core.hookspath"))
+		return git_config_pathname((char **)cb, var, value);
+
+	return 0;
+}
+
+/* Discover the hook before setup_git_directory() was called */
+static const char *hook_path_early(const char *name, struct strbuf *result)
+{
+	static struct strbuf hooks_dir = STRBUF_INIT;
+	static int initialized;
+
+	if (initialized < 0)
+		return NULL;
+
+	if (!initialized) {
+		struct strbuf gitdir = STRBUF_INIT, commondir = STRBUF_INIT;
+		char *early_hooks_dir = NULL;
+
+		if (discover_git_directory(&commondir, &gitdir) < 0) {
+			strbuf_release(&gitdir);
+			strbuf_release(&commondir);
+			initialized = -1;
+			return NULL;
+		}
+
+		read_early_config(the_repository, early_hooks_path_config, &early_hooks_dir);
+		if (!early_hooks_dir)
+			strbuf_addf(&hooks_dir, "%s/hooks/", commondir.buf);
+		else {
+			strbuf_add_absolute_path(&hooks_dir, early_hooks_dir);
+			free(early_hooks_dir);
+			strbuf_addch(&hooks_dir, '/');
+		}
+
+		strbuf_release(&gitdir);
+		strbuf_release(&commondir);
+
+		initialized = 1;
+	}
+
+	strbuf_addf(result, "%s%s", hooks_dir.buf, name);
+	return result->buf;
+}
+
 const char *find_hook(struct repository *r, const char *name)
 {
 	static struct strbuf path = STRBUF_INIT;
 
 	int found_hook;
 
-	repo_git_path_replace(r, &path, "hooks/%s", name);
+	strbuf_reset(&path);
+	if (have_git_dir())
+		repo_git_path_replace(r, &path, "hooks/%s", name);
+	else if (!hook_path_early(name, &path))
+		return NULL;
+
 	found_hook = access(path.buf, X_OK) >= 0;
 #ifdef STRIP_EXTENSION
 	if (!found_hook) {

t/meson.build

@@ -137,6 +137,8 @@ integration_tests = [
   't0301-credential-cache.sh',
   't0302-credential-store.sh',
   't0303-credential-external.sh',
+  't0400-pre-command-hook.sh',
+  't0401-post-command-hook.sh',
   't0410-partial-clone.sh',
   't0411-clone-from-partial.sh',
   't0450-txt-doc-vs-help.sh',

t/t0400-pre-command-hook.sh

@@ -0,0 +1,34 @@
+#!/bin/sh
+
+test_description='pre-command hook'
+
+. ./test-lib.sh
+
+test_expect_success 'with no hook' '
+	echo "first" > file &&
+	git add file &&
+	git commit -m "first"
+'
+
+test_expect_success 'with succeeding hook' '
+	mkdir -p .git/hooks &&
+	write_script .git/hooks/pre-command <<-EOF &&
+	echo "\$*" >\$(git rev-parse --git-dir)/pre-command.out
+	EOF
+	echo "second" >> file &&
+	git add file &&
+	test "add file" = "$(cat .git/pre-command.out)" &&
+	echo Hello | git hash-object --stdin &&
+	test "hash-object --stdin" = "$(cat .git/pre-command.out)"
+'
+
+test_expect_success 'with failing hook' '
+	write_script .git/hooks/pre-command <<-EOF &&
+	exit 1
+	EOF
+	echo "third" >> file &&
+	test_must_fail git add file &&
+	test_path_is_missing "$(cat .git/pre-command.out)"
+'
+
+test_done

t/t0401-post-command-hook.sh

@@ -0,0 +1,32 @@
+#!/bin/sh
+
+test_description='post-command hook'
+
+. ./test-lib.sh
+
+test_expect_success 'with no hook' '
+	echo "first" > file &&
+	git add file &&
+	git commit -m "first"
+'
+
+test_expect_success 'with succeeding hook' '
+	mkdir -p .git/hooks &&
+	write_script .git/hooks/post-command <<-EOF &&
+	echo "\$*" >\$(git rev-parse --git-dir)/post-command.out
+	EOF
+	echo "second" >> file &&
+	git add file &&
+	test "add file --exit_code=0" = "$(cat .git/post-command.out)"
+'
+
+test_expect_success 'with failing pre-command hook' '
+	write_script .git/hooks/pre-command <<-EOF &&
+	exit 1
+	EOF
+	echo "third" >> file &&
+	test_must_fail git add file &&
+	test_path_is_missing "$(cat .git/post-command.out)"
+'
+
+test_done

t/t7502-commit-porcelain.sh

@@ -1051,6 +1051,11 @@ EOF
 '
 
 test_expect_success WITH_BREAKING_CHANGES 'core.commentChar=auto is rejected' '
+	cat >&2 <<-EOF &&
+	Trying to run any pre-command hook already triggers a failure when
+	running \`git config core.commentChar auto\`; Skipping this test.
+	EOF
+	return 0 &&
 	test_config core.commentChar auto &&
 	test_must_fail git rev-parse --git-dir 2>err &&
 	sed -n "s/^hint: *\$//p; s/^hint: //p; s/^fatal: //p" err >actual &&