nprasad2077/codebase-memory-mcp
1
0 Fork 0
mirror of https://github.com/DeusData/codebase-memory-mcp.git synced 2026-11-04 10:48:20 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
ffeb06f595cf5fe00dc41cd7e0ff6f2cbceba1e2
codebase-memory-mcp/tests/test_config_json_like.c
T

1601 lines
64 KiB
C
Raw Blame History

/*
* test_config_json_like.c — Structure-preserving JSON/JSONC/JSON5 edits.
*
* This suite is intentionally standalone. The installation work that consumes
* the editor can register it with the main runner alongside its build wiring.
*/
#include "test_framework.h"
#define CBM_JSON_LIKE_ENABLE_TEST_API 1
#include "../src/cli/config_json_like.h"
#define CBM_CONFIG_EDIT_PATH_ENABLE_TEST_API 1
#include "../src/cli/config_edit_path.h"
#include "../src/foundation/compat.h"
#include "../src/foundation/compat_fs.h"
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifndef _WIN32
#include <sys/stat.h>
#include <unistd.h>
#endif
typedef struct {
char directory[512];
char path[640];
} jl_fixture_t;
static int jl_fixture_open(jl_fixture_t *fixture) {
snprintf(fixture->directory, sizeof(fixture->directory), "%s/cbm-json-like-XXXXXX",
cbm_tmpdir());
if (!cbm_mkdtemp(fixture->directory)) {
return -1;
}
int written =
snprintf(fixture->path, sizeof(fixture->path), "%s/config.json", fixture->directory);
return written >= 0 && (size_t)written < sizeof(fixture->path) ? 0 : -1;
}
static void jl_fixture_close(jl_fixture_t *fixture) {
cbm_dir_t *directory = cbm_opendir(fixture->directory);
if (directory) {
cbm_dirent_t *entry = NULL;
while ((entry = cbm_readdir(directory)) != NULL) {
if (strncmp(entry->name, "config.json.cbm.tmp.", strlen("config.json.cbm.tmp.")) == 0) {
char temp_path[sizeof(fixture->path) + 96U];
int written = snprintf(temp_path, sizeof(temp_path), "%s/%s", fixture->directory,
entry->name);
if (written >= 0 && (size_t)written < sizeof(temp_path)) {
(void)cbm_unlink(temp_path);
}
}
}
cbm_closedir(directory);
}
(void)cbm_unlink(fixture->path);
(void)cbm_rmdir(fixture->directory);
}
static size_t jl_temp_file_count(const jl_fixture_t *fixture) {
cbm_dir_t *directory = cbm_opendir(fixture->directory);
if (!directory) {
return SIZE_MAX;
}
size_t count = 0U;
cbm_dirent_t *entry = NULL;
while ((entry = cbm_readdir(directory)) != NULL) {
if (strncmp(entry->name, "config.json.cbm.tmp.", strlen("config.json.cbm.tmp.")) == 0) {
count++;
}
}
cbm_closedir(directory);
return count;
}
static int jl_write(const char *path, const char *content) {
FILE *file = cbm_fopen(path, "wb");
if (!file) {
return -1;
}
size_t length = strlen(content);
size_t written = fwrite(content, 1U, length, file);
int close_result = fclose(file);
return written == length && close_result == 0 ? 0 : -1;
}
static char *jl_read(const char *path) {
FILE *file = cbm_fopen(path, "rb");
if (!file || fseek(file, 0, SEEK_END) != 0) {
if (file) {
fclose(file);
}
return NULL;
}
long size = ftell(file);
if (size < 0 || fseek(file, 0, SEEK_SET) != 0) {
fclose(file);
return NULL;
}
char *content = malloc((size_t)size + 1U);
if (!content) {
fclose(file);
return NULL;
}
size_t read_count = fread(content, 1U, (size_t)size, file);
int failed = ferror(file);
fclose(file);
if (read_count != (size_t)size || failed) {
free(content);
return NULL;
}
content[read_count] = '\0';
return content;
}
static int jl_failed_unchanged(const char *path, const char *original,
const char *const *object_path, size_t path_len, const char *key,
const char *value) {
if (jl_write(path, original) != 0) {
return 0;
}
if (cbm_json_like_upsert_entry(path, object_path, path_len, key, value) == 0) {
return 0;
}
char *after = jl_read(path);
int unchanged = after && strcmp(after, original) == 0;
free(after);
return unchanged;
}
static size_t jl_occurrences(const char *text, const char *needle) {
size_t count = 0;
size_t needle_length = strlen(needle);
while (needle_length > 0U && (text = strstr(text, needle)) != NULL) {
count++;
text += needle_length;
}
return count;
}
typedef struct {
const char *content;
const char *backup_path;
bool replace_identity;
int result;
} jl_precommit_change_t;
static void jl_change_before_commit(const char *path, void *context) {
jl_precommit_change_t *change = context;
if (change->replace_identity &&
(!change->backup_path || cbm_rename_replace(path, change->backup_path) != 0)) {
change->result = -1;
return;
}
change->result = jl_write(path, change->content);
}
TEST(config_json_like_rejects_stale_content_and_cleans_temp) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
ASSERT_EQ(jl_write(fixture.path, "{\"keep\":1}\n"), 0);
const char *root[] = {NULL};
jl_precommit_change_t change = {
.content = "{\"concurrent\":true}\n",
.backup_path = NULL,
.replace_identity = false,
.result = -1,
};
cbm_json_like_set_precommit_hook_for_testing(jl_change_before_commit, &change);
int result = cbm_json_like_upsert_entry(fixture.path, root, 0U, "owned", "true");
cbm_json_like_set_precommit_hook_for_testing(NULL, NULL);
ASSERT_EQ(change.result, 0);
ASSERT_EQ(result, -1);
char *content = jl_read(fixture.path);
ASSERT_NOT_NULL(content);
ASSERT_STR_EQ(content, "{\"concurrent\":true}\n");
free(content);
ASSERT_EQ(jl_temp_file_count(&fixture), 0U);
jl_fixture_close(&fixture);
PASS();
}
TEST(config_json_like_rejects_stale_identity_with_same_content) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
const char *original = "{\"keep\":1}\n";
ASSERT_EQ(jl_write(fixture.path, original), 0);
char backup[sizeof(fixture.path) + 32U];
ASSERT(snprintf(backup, sizeof(backup), "%s/original.json", fixture.directory) > 0);
const char *root[] = {NULL};
jl_precommit_change_t change = {
.content = original,
.backup_path = backup,
.replace_identity = true,
.result = -1,
};
cbm_json_like_set_precommit_hook_for_testing(jl_change_before_commit, &change);
int result = cbm_json_like_upsert_entry(fixture.path, root, 0U, "owned", "true");
cbm_json_like_set_precommit_hook_for_testing(NULL, NULL);
ASSERT_EQ(change.result, 0);
ASSERT_EQ(result, -1);
char *content = jl_read(fixture.path);
ASSERT_NOT_NULL(content);
ASSERT_STR_EQ(content, original);
free(content);
ASSERT_EQ(jl_temp_file_count(&fixture), 0U);
ASSERT_EQ(cbm_unlink(backup), 0);
jl_fixture_close(&fixture);
PASS();
}
TEST(config_json_like_missing_target_race_does_not_replace_winner) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
const char *root[] = {NULL};
jl_precommit_change_t race = {
.content = "{\"winner\":true}\n",
.backup_path = NULL,
.replace_identity = false,
.result = -1,
};
cbm_json_like_set_prepublish_hook_for_testing(jl_change_before_commit, &race);
int result = cbm_json_like_upsert_entry(fixture.path, root, 0U, "owned", "true");
cbm_json_like_set_prepublish_hook_for_testing(NULL, NULL);
ASSERT_EQ(race.result, 0);
ASSERT_EQ(result, -1);
char *content = jl_read(fixture.path);
ASSERT_NOT_NULL(content);
ASSERT_STR_EQ(content, "{\"winner\":true}\n");
free(content);
ASSERT_EQ(jl_temp_file_count(&fixture), 0U);
jl_fixture_close(&fixture);
PASS();
}
TEST(config_json_like_existing_target_swap_after_check_preserves_winner) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
const char *original = "{\"keep\":1}\n";
const char *winner = "{\"winner\":true}\n";
ASSERT_EQ(jl_write(fixture.path, original), 0);
char backup[sizeof(fixture.path) + 32U];
ASSERT(snprintf(backup, sizeof(backup), "%s/original.json", fixture.directory) > 0);
const char *root[] = {NULL};
jl_precommit_change_t race = {
.content = winner,
.backup_path = backup,
.replace_identity = true,
.result = -1,
};
cbm_json_like_set_prepublish_hook_for_testing(jl_change_before_commit, &race);
int result = cbm_json_like_upsert_entry(fixture.path, root, 0U, "owned", "true");
cbm_json_like_set_prepublish_hook_for_testing(NULL, NULL);
ASSERT_EQ(race.result, 0);
ASSERT_EQ(result, -1);
char *content = jl_read(fixture.path);
ASSERT_NOT_NULL(content);
ASSERT_STR_EQ(content, winner);
free(content);
ASSERT_EQ(jl_temp_file_count(&fixture), 0U);
ASSERT_EQ(cbm_unlink(backup), 0);
jl_fixture_close(&fixture);
PASS();
}
TEST(config_json_like_rejects_non_regular_path) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
ASSERT_EQ(cbm_mkdir(fixture.path), 0);
const char *root[] = {NULL};
ASSERT_EQ(cbm_json_like_upsert_entry(fixture.path, root, 0U, "owned", "true"), -1);
ASSERT_EQ(jl_temp_file_count(&fixture), 0U);
ASSERT_EQ(cbm_rmdir(fixture.path), 0);
jl_fixture_close(&fixture);
PASS();
}
#ifndef _WIN32
/* Any editor temp file left anywhere in the fixture directory, whatever
* document it was staged for: a link's target lives in the same directory. */
static size_t jl_stray_temp_count(const jl_fixture_t *fixture) {
cbm_dir_t *directory = cbm_opendir(fixture->directory);
if (!directory) {
return SIZE_MAX;
}
size_t count = 0U;
cbm_dirent_t *entry = NULL;
while ((entry = cbm_readdir(directory)) != NULL) {
if (strstr(entry->name, ".cbm.tmp.")) {
count++;
}
}
cbm_closedir(directory);
return count;
}
/* A link owned by someone else is never followed. A test cannot create a
* foreign-owned link without root, so the observer moves instead (test seam):
* the refusal touches neither the link nor its target and stages no temp file. */
TEST(config_json_like_rejects_foreign_owned_symlink_without_touching_target) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
char target[sizeof(fixture.path) + 32U];
ASSERT(snprintf(target, sizeof(target), "%s/target.json", fixture.directory) > 0);
const char *original = "{\"target\":true}\n";
ASSERT_EQ(jl_write(target, original), 0);
ASSERT_EQ(symlink(target, fixture.path), 0);
ASSERT_EQ(cbm_config_edit_path_follow_add_root(fixture.directory), 0);
cbm_config_edit_path_set_invoking_uid_for_test((unsigned)geteuid() + 1U, 1);
const char *root[] = {NULL};
int upsert_rc = cbm_json_like_upsert_entry(fixture.path, root, 0U, "owned", "true");
char reason[256];
int refused = cbm_config_edit_path_refusal(fixture.path, reason, sizeof(reason));
cbm_config_edit_path_set_invoking_uid_for_test(0U, 0);
cbm_config_edit_path_follow_clear();
ASSERT_EQ(upsert_rc, -1);
ASSERT_EQ(refused, 1);
ASSERT_NOT_NULL(strstr(reason, "not the invoking user"));
struct stat link_state;
ASSERT_EQ(lstat(fixture.path, &link_state), 0);
ASSERT(S_ISLNK(link_state.st_mode));
char *content = jl_read(target);
ASSERT_NOT_NULL(content);
ASSERT_STR_EQ(content, original);
free(content);
ASSERT_EQ(jl_stray_temp_count(&fixture), 0U);
ASSERT_EQ(cbm_unlink(fixture.path), 0);
ASSERT_EQ(cbm_unlink(target), 0);
jl_fixture_close(&fixture);
PASS();
}
/* A root process never follows a link a non-root user owns: a user-planted
* link must not redirect a privileged writer. A real root run (CI containers)
* demotes the link to an unprivileged owner first; elsewhere the observer moves. */
TEST(config_json_like_root_refuses_user_owned_symlink) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
char target[sizeof(fixture.path) + 32U];
ASSERT(snprintf(target, sizeof(target), "%s/target.json", fixture.directory) > 0);
const char *original = "{\"target\":true}\n";
ASSERT_EQ(jl_write(target, original), 0);
ASSERT_EQ(symlink(target, fixture.path), 0);
if (geteuid() == 0 && lchown(fixture.path, 65534, 65534) != 0) {
(void)cbm_unlink(fixture.path);
(void)cbm_unlink(target);
jl_fixture_close(&fixture);
FAIL("lchown to an unprivileged owner failed");
}
ASSERT_EQ(cbm_config_edit_path_follow_add_root(fixture.directory), 0);
cbm_config_edit_path_set_invoking_uid_for_test(0U, 1);
const char *root[] = {NULL};
int upsert_rc = cbm_json_like_upsert_entry(fixture.path, root, 0U, "owned", "true");
char reason[256];
int refused = cbm_config_edit_path_refusal(fixture.path, reason, sizeof(reason));
cbm_config_edit_path_set_invoking_uid_for_test(0U, 0);
cbm_config_edit_path_follow_clear();
ASSERT_EQ(upsert_rc, -1);
ASSERT_EQ(refused, 1);
ASSERT_NOT_NULL(strstr(reason, "root process"));
struct stat link_state;
ASSERT_EQ(lstat(fixture.path, &link_state), 0);
ASSERT(S_ISLNK(link_state.st_mode));
char *content = jl_read(target);
ASSERT_NOT_NULL(content);
ASSERT_STR_EQ(content, original);
free(content);
ASSERT_EQ(jl_stray_temp_count(&fixture), 0U);
ASSERT_EQ(cbm_unlink(fixture.path), 0);
ASSERT_EQ(cbm_unlink(target), 0);
jl_fixture_close(&fixture);
PASS();
}
TEST(config_json_like_refuses_dangling_symlink) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
char missing[sizeof(fixture.path) + 32U];
ASSERT(snprintf(missing, sizeof(missing), "%s/missing.json", fixture.directory) > 0);
ASSERT_EQ(symlink(missing, fixture.path), 0);
ASSERT_EQ(cbm_config_edit_path_follow_add_root(fixture.directory), 0);
const char *root[] = {NULL};
int upsert_rc = cbm_json_like_upsert_entry(fixture.path, root, 0U, "owned", "true");
char *document = NULL;
size_t length = 0U;
int read_rc = cbm_json_like_read_document(fixture.path, &document, &length);
free(document);
char reason[256];
int refused = cbm_config_edit_path_refusal(fixture.path, reason, sizeof(reason));
cbm_config_edit_path_follow_clear();
ASSERT_EQ(upsert_rc, -1);
ASSERT_EQ(read_rc, -1);
ASSERT_EQ(refused, 1);
ASSERT_NOT_NULL(strstr(reason, "dangling"));
struct stat state;
ASSERT_EQ(lstat(fixture.path, &state), 0);
ASSERT(S_ISLNK(state.st_mode));
ASSERT(lstat(missing, &state) != 0);
ASSERT_EQ(jl_stray_temp_count(&fixture), 0U);
ASSERT_EQ(cbm_unlink(fixture.path), 0);
jl_fixture_close(&fixture);
PASS();
}
TEST(config_json_like_refuses_symlink_to_directory) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
char sub[sizeof(fixture.path) + 32U];
ASSERT(snprintf(sub, sizeof(sub), "%s/sub", fixture.directory) > 0);
ASSERT_EQ(cbm_mkdir(sub), 0);
ASSERT_EQ(symlink(sub, fixture.path), 0);
ASSERT_EQ(cbm_config_edit_path_follow_add_root(fixture.directory), 0);
const char *root[] = {NULL};
int upsert_rc = cbm_json_like_upsert_entry(fixture.path, root, 0U, "owned", "true");
char reason[256];
int refused = cbm_config_edit_path_refusal(fixture.path, reason, sizeof(reason));
cbm_config_edit_path_follow_clear();
ASSERT_EQ(upsert_rc, -1);
ASSERT_EQ(refused, 1);
ASSERT_NOT_NULL(strstr(reason, "directory"));
struct stat state;
ASSERT_EQ(lstat(fixture.path, &state), 0);
ASSERT(S_ISLNK(state.st_mode));
ASSERT_EQ(jl_stray_temp_count(&fixture), 0U);
ASSERT_EQ(cbm_unlink(fixture.path), 0);
ASSERT_EQ(cbm_rmdir(sub), 0);
jl_fixture_close(&fixture);
PASS();
}
/* Without the agent-config writers' opt-in, a same-owner link is still
* refused: the follow is never a property of every editor caller. */
TEST(config_json_like_refuses_symlink_without_opt_in) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
char target[sizeof(fixture.path) + 32U];
ASSERT(snprintf(target, sizeof(target), "%s/target.json", fixture.directory) > 0);
const char *original = "{\"target\":true}\n";
ASSERT_EQ(jl_write(target, original), 0);
ASSERT_EQ(symlink(target, fixture.path), 0);
cbm_config_edit_path_follow_clear();
const char *root[] = {NULL};
ASSERT_EQ(cbm_json_like_upsert_entry(fixture.path, root, 0U, "owned", "true"), -1);
char reason[256];
ASSERT_EQ(cbm_config_edit_path_refusal(fixture.path, reason, sizeof(reason)), 1);
ASSERT_NOT_NULL(strstr(reason, "not followed by this command"));
/* An opt-in for a different root does not cover this link either. */
char elsewhere[sizeof(fixture.path) + 32U];
ASSERT(snprintf(elsewhere, sizeof(elsewhere), "%s/elsewhere", fixture.directory) > 0);
ASSERT_EQ(cbm_mkdir(elsewhere), 0);
ASSERT_EQ(cbm_config_edit_path_follow_add_root(elsewhere), 0);
int outside_rc = cbm_json_like_upsert_entry(fixture.path, root, 0U, "owned", "true");
int outside_refused = cbm_config_edit_path_refusal(fixture.path, reason, sizeof(reason));
cbm_config_edit_path_follow_clear();
ASSERT_EQ(outside_rc, -1);
ASSERT_EQ(outside_refused, 1);
ASSERT_NOT_NULL(strstr(reason, "outside the opted-in configuration roots"));
struct stat link_state;
ASSERT_EQ(lstat(fixture.path, &link_state), 0);
ASSERT(S_ISLNK(link_state.st_mode));
char *content = jl_read(target);
ASSERT_NOT_NULL(content);
ASSERT_STR_EQ(content, original);
free(content);
ASSERT_EQ(jl_stray_temp_count(&fixture), 0U);
ASSERT_EQ(cbm_rmdir(elsewhere), 0);
ASSERT_EQ(cbm_unlink(fixture.path), 0);
ASSERT_EQ(cbm_unlink(target), 0);
jl_fixture_close(&fixture);
PASS();
}
/* The validated descriptor must be the very file stat(realpath) saw: a
* target swapped between the two checks (seam) is refused, untouched. */
TEST(config_json_like_refuses_symlink_when_target_identity_skews) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
char target[sizeof(fixture.path) + 32U];
ASSERT(snprintf(target, sizeof(target), "%s/target.json", fixture.directory) > 0);
const char *original = "{\"target\":true}\n";
ASSERT_EQ(jl_write(target, original), 0);
ASSERT_EQ(symlink(target, fixture.path), 0);
ASSERT_EQ(cbm_config_edit_path_follow_add_root(fixture.directory), 0);
cbm_config_edit_path_set_identity_skew_for_test(1);
const char *root[] = {NULL};
int upsert_rc = cbm_json_like_upsert_entry(fixture.path, root, 0U, "owned", "true");
char reason[256];
int refused = cbm_config_edit_path_refusal(fixture.path, reason, sizeof(reason));
cbm_config_edit_path_set_identity_skew_for_test(0);
cbm_config_edit_path_follow_clear();
ASSERT_EQ(upsert_rc, -1);
ASSERT_EQ(refused, 1);
ASSERT_NOT_NULL(strstr(reason, "changed while it was being checked"));
char *content = jl_read(target);
ASSERT_NOT_NULL(content);
ASSERT_STR_EQ(content, original);
free(content);
ASSERT_EQ(jl_stray_temp_count(&fixture), 0U);
ASSERT_EQ(cbm_unlink(fixture.path), 0);
ASSERT_EQ(cbm_unlink(target), 0);
jl_fixture_close(&fixture);
PASS();
}
/* The target's parent directory is pinned and must not be writable by others
* (a sticky directory is fine): otherwise anyone could stage a swap there. */
TEST(config_json_like_refuses_symlink_with_world_writable_parent) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
char dotfiles[sizeof(fixture.path) + 32U];
char target[sizeof(fixture.path) + 64U];
ASSERT(snprintf(dotfiles, sizeof(dotfiles), "%s/dotfiles", fixture.directory) > 0);
ASSERT(snprintf(target, sizeof(target), "%s/target.json", dotfiles) > 0);
ASSERT_EQ(cbm_mkdir(dotfiles), 0);
const char *original = "{\"target\":true}\n";
ASSERT_EQ(jl_write(target, original), 0);
ASSERT_EQ(symlink(target, fixture.path), 0);
ASSERT_EQ(chmod(dotfiles, 0777), 0);
ASSERT_EQ(cbm_config_edit_path_follow_add_root(fixture.directory), 0);
const char *root[] = {NULL};
int loose_rc = cbm_json_like_upsert_entry(fixture.path, root, 0U, "owned", "true");
char reason[256];
int loose_refused = cbm_config_edit_path_refusal(fixture.path, reason, sizeof(reason));
ASSERT_EQ(chmod(dotfiles, 0755), 0);
int tight_rc = cbm_json_like_upsert_entry(fixture.path, root, 0U, "owned", "true");
cbm_config_edit_path_follow_clear();
ASSERT_EQ(loose_rc, -1);
ASSERT_EQ(loose_refused, 1);
ASSERT_NOT_NULL(strstr(reason, "writable by others"));
ASSERT_EQ(tight_rc, 0);
char *content = jl_read(target);
ASSERT_NOT_NULL(content);
ASSERT_NOT_NULL(strstr(content, "\"owned\""));
free(content);
ASSERT_EQ(cbm_unlink(fixture.path), 0);
ASSERT_EQ(cbm_unlink(target), 0);
ASSERT_EQ(cbm_rmdir(dotfiles), 0);
jl_fixture_close(&fixture);
PASS();
}
typedef struct {
char seen_path[640];
size_t temps_beside_target;
size_t calls;
} jl_follow_hook_state_t;
/* Pre-commit hook: the editor hands over the path it is about to publish —
* for a followed link that must be the RESOLVED target, with the staged
* temp file sitting right beside it, never beside the link. */
static void jl_follow_precommit_hook(const char *path, void *context) {
jl_follow_hook_state_t *state = context;
state->calls++;
(void)snprintf(state->seen_path, sizeof(state->seen_path), "%s", path);
char directory[640];
(void)snprintf(directory, sizeof(directory), "%s", path);
char *slash = strrchr(directory, '/');
if (!slash) {
return;
}
const char *base = slash + 1;
char prefix[320];
(void)snprintf(prefix, sizeof(prefix), "%s.cbm.tmp.", base);
*slash = '\0';
cbm_dir_t *handle = cbm_opendir(directory);
if (!handle) {
return;
}
cbm_dirent_t *entry = NULL;
while ((entry = cbm_readdir(handle)) != NULL) {
if (strncmp(entry->name, prefix, strlen(prefix)) == 0) {
state->temps_beside_target++;
}
}
cbm_closedir(handle);
}
/* Decision C (#1954): a symlink the invoking user owns, pointing at a regular
* file the same user owns, is edited THROUGH once the writer opted in — the
* link survives and still points at the same target, the temp file is staged
* beside the target, and every edit is byte-identical to the same edit on a
* plain file. */
TEST(config_json_like_follows_user_owned_symlink_in_place) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
char target[sizeof(fixture.path) + 32U];
char control[sizeof(fixture.path) + 32U];
ASSERT(snprintf(target, sizeof(target), "%s/target.json", fixture.directory) > 0);
ASSERT(snprintf(control, sizeof(control), "%s/control.json", fixture.directory) > 0);
const char *original = "{\n // dotfiles\n \"mcpServers\": {\n"
" \"keep\": {\"command\": \"x\"}\n }\n}\n";
ASSERT_EQ(jl_write(target, original), 0);
ASSERT_EQ(jl_write(control, original), 0);
/* Relative, the way a dotfiles checkout links its files. */
ASSERT_EQ(symlink("target.json", fixture.path), 0);
ASSERT_EQ(cbm_config_edit_path_follow_add_root(fixture.directory), 0);
char target_real[CBM_CONFIG_EDIT_PATH_MAX];
ASSERT_EQ(cbm_canonical_path(target, target_real, sizeof(target_real)), 1);
jl_follow_hook_state_t hook_state = {0};
cbm_json_like_set_precommit_hook_for_testing(jl_follow_precommit_hook, &hook_state);
const char *path[] = {"mcpServers"};
int through_rc =
cbm_json_like_upsert_entry(fixture.path, path, 1U, "owned", "{\"command\":\"y\"}");
cbm_json_like_set_precommit_hook_for_testing(NULL, NULL);
int plain_rc = cbm_json_like_upsert_entry(control, path, 1U, "owned", "{\"command\":\"y\"}");
if (through_rc != 0 || plain_rc != 0) {
cbm_config_edit_path_follow_clear();
}
ASSERT_EQ(through_rc, 0);
ASSERT_EQ(plain_rc, 0);
ASSERT_EQ(hook_state.calls, 1U);
ASSERT_STR_EQ(hook_state.seen_path, target_real);
ASSERT_EQ(hook_state.temps_beside_target, 1U);
struct stat link_state;
ASSERT_EQ(lstat(fixture.path, &link_state), 0);
ASSERT(S_ISLNK(link_state.st_mode));
char link_value[256] = {0};
ASSERT(readlink(fixture.path, link_value, sizeof(link_value) - 1U) > 0);
ASSERT_STR_EQ(link_value, "target.json");
char *through = jl_read(target);
char *plain = jl_read(control);
ASSERT_NOT_NULL(through);
ASSERT_NOT_NULL(plain);
ASSERT_STR_EQ(through, plain);
ASSERT_NOT_NULL(strstr(through, "\"owned\""));
ASSERT_NOT_NULL(strstr(through, "// dotfiles"));
/* Reading through the link sees the target, and the compare-and-remove
* form uninstall relies on works through the link as well. */
char *document = NULL;
size_t length = 0U;
ASSERT_EQ(cbm_json_like_read_document(fixture.path, &document, &length), 0);
ASSERT_NOT_NULL(document);
ASSERT_STR_EQ(document, through);
ASSERT_EQ(
cbm_json_like_remove_entry_if_unchanged(fixture.path, path, 1U, "owned", document, length),
0);
ASSERT_EQ(cbm_json_like_remove_entry(control, path, 1U, "owned"), 0);
free(document);
free(through);
free(plain);
through = jl_read(target);
plain = jl_read(control);
ASSERT_NOT_NULL(through);
ASSERT_NOT_NULL(plain);
ASSERT_STR_EQ(through, plain);
ASSERT_NULL(strstr(through, "\"owned\""));
free(through);
free(plain);
cbm_config_edit_path_follow_clear();
ASSERT_EQ(lstat(fixture.path, &link_state), 0);
ASSERT(S_ISLNK(link_state.st_mode));
ASSERT_EQ(jl_stray_temp_count(&fixture), 0U);
ASSERT_EQ(cbm_unlink(fixture.path), 0);
ASSERT_EQ(cbm_unlink(target), 0);
ASSERT_EQ(cbm_unlink(control), 0);
jl_fixture_close(&fixture);
PASS();
}
TEST(config_json_like_rejects_hard_link_without_splitting_identity) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
char alias[sizeof(fixture.path) + 32U];
ASSERT(snprintf(alias, sizeof(alias), "%s/alias.json", fixture.directory) > 0);
const char *original = "{\"shared\":true}\n";
ASSERT_EQ(jl_write(fixture.path, original), 0);
ASSERT_EQ(link(fixture.path, alias), 0);
const char *root[] = {NULL};
ASSERT_EQ(cbm_json_like_upsert_entry(fixture.path, root, 0U, "owned", "true"), -1);
char *content = jl_read(alias);
ASSERT_NOT_NULL(content);
ASSERT_STR_EQ(content, original);
free(content);
ASSERT_EQ(cbm_unlink(alias), 0);
jl_fixture_close(&fixture);
PASS();
}
TEST(config_json_like_preserves_owner_group_and_mode) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
ASSERT_EQ(jl_write(fixture.path, "{\"keep\":1}\n"), 0);
ASSERT_EQ(chmod(fixture.path, 0640), 0);
struct stat before;
ASSERT_EQ(stat(fixture.path, &before), 0);
const char *root[] = {NULL};
ASSERT_EQ(cbm_json_like_upsert_entry(fixture.path, root, 0U, "owned", "true"), 0);
struct stat after;
ASSERT_EQ(stat(fixture.path, &after), 0);
ASSERT_EQ(after.st_uid, before.st_uid);
ASSERT_EQ(after.st_gid, before.st_gid);
ASSERT_EQ(after.st_mode & 07777, before.st_mode & 07777);
jl_fixture_close(&fixture);
PASS();
}
#endif
TEST(config_json_like_supports_bom_and_common_json5_whitespace) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
const char *original = "\xEF\xBB\xBF"
"{\x0C"
"theme:'dark',\x0B"
"// retained\xE2\x80\xA8"
"mcp:\xC2\xA0{servers:{}},\xE2\x80\xA9"
"}";
ASSERT_EQ(jl_write(fixture.path, original), 0);
const char *path[] = {"mcp", "servers"};
ASSERT_EQ(cbm_json_like_upsert_entry(fixture.path, path, 2U, "owned", "true"), 0);
char *content = jl_read(fixture.path);
ASSERT_NOT_NULL(content);
ASSERT(memcmp(content, "\xEF\xBB\xBF", 3U) == 0);
ASSERT(strstr(content, "// retained\xE2\x80\xA8") != NULL);
ASSERT(strstr(content, "theme:'dark'") != NULL);
ASSERT(strstr(content, "\"owned\": true") != NULL);
free(content);
jl_fixture_close(&fixture);
PASS();
}
TEST(config_json_like_rejects_json5_decimal_escapes_byte_identical) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
const char *root[] = {NULL};
ASSERT(jl_failed_unchanged(fixture.path, "{bad:'\\8'}\n", root, 0U, "owned", "true"));
ASSERT(jl_failed_unchanged(fixture.path, "{bad:'\\01'}\n", root, 0U, "owned", "true"));
jl_fixture_close(&fixture);
PASS();
}
TEST(config_json_like_fresh_strict_upsert_replace_remove) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
const char *root[] = {NULL};
ASSERT_EQ(cbm_json_like_upsert_entry(fixture.path, root, 0U, "owned", "{\"command\":\"cbm\"}"),
0);
char *content = jl_read(fixture.path);
ASSERT_NOT_NULL(content);
ASSERT_STR_EQ(content, "{\n \"owned\": {\"command\":\"cbm\"}\n}\n");
free(content);
ASSERT_EQ(jl_write(fixture.path, "{\"keep\":1,\"owned\":false}\n"), 0);
ASSERT_EQ(cbm_json_like_upsert_entry(fixture.path, root, 0U, "owned", "[1,2]"), 0);
content = jl_read(fixture.path);
ASSERT_NOT_NULL(content);
ASSERT_STR_EQ(content, "{\"keep\":1,\"owned\":[1,2]}\n");
free(content);
ASSERT_EQ(cbm_json_like_remove_entry(fixture.path, root, 0U, "owned"), 0);
content = jl_read(fixture.path);
ASSERT_NOT_NULL(content);
ASSERT(strstr(content, "\"keep\":1") != NULL);
ASSERT(strstr(content, "owned") == NULL);
free(content);
jl_fixture_close(&fixture);
PASS();
}
TEST(config_json_like_preserves_jsonc_comments) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
const char *original = "{\n"
" // user preference\n"
" \"theme\": \"dark\",\n"
" \"mcpServers\": {\n"
" /* retained server */\n"
" \"other\": {\"command\": \"other\"},\n"
" },\n"
"}\n";
ASSERT_EQ(jl_write(fixture.path, original), 0);
const char *path[] = {"mcpServers"};
ASSERT_EQ(cbm_json_like_upsert_entry(fixture.path, path, 1U, "codebase-memory",
"{\"command\":\"cbm\"}"),
0);
char *content = jl_read(fixture.path);
ASSERT_NOT_NULL(content);
ASSERT(strstr(content, "// user preference") != NULL);
ASSERT(strstr(content, "/* retained server */") != NULL);
ASSERT(strstr(content, "\"theme\": \"dark\"") != NULL);
ASSERT(strstr(content, "\"other\": {\"command\": \"other\"}") != NULL);
ASSERT(strstr(content, "\"codebase-memory\": {\"command\":\"cbm\"}") != NULL);
free(content);
jl_fixture_close(&fixture);
PASS();
}
TEST(config_json_like_openclaw_json5_nested_servers) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
const char *original =
"{ theme: 'dark', mcp: { servers: { other: { command: 'other' }, }, }, }";
ASSERT_EQ(jl_write(fixture.path, original), 0);
const char *path[] = {"mcp", "servers"};
ASSERT_EQ(cbm_json_like_upsert_entry(fixture.path, path, 2U, "codebase-memory",
"{\"command\":\"cbm\",\"args\":[]}"),
0);
char *content = jl_read(fixture.path);
ASSERT_NOT_NULL(content);
ASSERT(strstr(content, "theme: 'dark'") != NULL);
ASSERT(strstr(content, "other: { command: 'other' }") != NULL);
ASSERT(strstr(content, "\"codebase-memory\"") != NULL);
free(content);
ASSERT_EQ(cbm_json_like_remove_entry(fixture.path, path, 2U, "codebase-memory"), 0);
content = jl_read(fixture.path);
ASSERT_NOT_NULL(content);
ASSERT(strstr(content, "codebase-memory") == NULL);
ASSERT(strstr(content, "theme: 'dark'") != NULL);
ASSERT(strstr(content, "other: { command: 'other' }") != NULL);
free(content);
jl_fixture_close(&fixture);
PASS();
}
TEST(config_json_like_creates_missing_nested_path) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
ASSERT_EQ(jl_write(fixture.path, "{\n \"theme\": \"dark\"\n}\n"), 0);
const char *path[] = {"mcp", "servers"};
ASSERT_EQ(cbm_json_like_upsert_entry(fixture.path, path, 2U, "codebase-memory",
"{\"command\":\"cbm\"}"),
0);
char *content = jl_read(fixture.path);
ASSERT_NOT_NULL(content);
ASSERT(strstr(content, "\"theme\": \"dark\"") != NULL);
ASSERT(strstr(content, "\"mcp\": {") != NULL);
ASSERT(strstr(content, "\"servers\": {") != NULL);
ASSERT(strstr(content, "\"codebase-memory\": {\"command\":\"cbm\"}") != NULL);
free(content);
jl_fixture_close(&fixture);
PASS();
}
TEST(config_json_like_rejects_duplicate_path_byte_identical) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
const char *path[] = {"mcp"};
const char *duplicate = "{\"mcp\":{}, 'mcp':{}}\n";
ASSERT(jl_failed_unchanged(fixture.path, duplicate, path, 1U, "owned", "true"));
const char *root[] = {NULL};
const char *duplicate_entry = "{\"owned\":1, owned:2}\n";
ASSERT(jl_failed_unchanged(fixture.path, duplicate_entry, root, 0U, "owned", "3"));
jl_fixture_close(&fixture);
PASS();
}
TEST(config_json_like_rejects_invalid_and_malformed_byte_identical) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
const char *root[] = {NULL};
ASSERT(jl_failed_unchanged(fixture.path, "{\"keep\":1}\n", root, 0U, "owned", "{\"broken\":}"));
ASSERT(jl_failed_unchanged(fixture.path, "{\"keep\":1}\n", root, 0U, "owned", ".5"));
ASSERT(jl_failed_unchanged(fixture.path, "{\"keep\":1 /* never closes", root, 0U, "owned",
"true"));
ASSERT(jl_failed_unchanged(fixture.path, "{\"keep\":[1,2}\n", root, 0U, "owned", "true"));
const char *path[] = {"mcp"};
ASSERT(jl_failed_unchanged(fixture.path, "{\"mcp\":false}\n", path, 1U, "owned", "true"));
ASSERT_EQ(jl_write(fixture.path, "{\"keep\":1}\n"), 0);
ASSERT_EQ(cbm_json_like_upsert_entry(fixture.path, root, 0U, "bad\nkey", "true"), -1);
ASSERT_EQ(cbm_json_like_upsert_entry(NULL, root, 0U, "owned", "true"), -1);
ASSERT_EQ(cbm_json_like_upsert_entry(fixture.path, NULL, 0U, "owned", "true"), -1);
const char *deep_path[64];
for (size_t i = 0; i < sizeof(deep_path) / sizeof(deep_path[0]); i++) {
deep_path[i] = "level";
}
ASSERT_EQ(cbm_json_like_upsert_entry(fixture.path, deep_path, 64U, "owned", "true"), -1);
char *content = jl_read(fixture.path);
ASSERT_NOT_NULL(content);
ASSERT_STR_EQ(content, "{\"keep\":1}\n");
free(content);
jl_fixture_close(&fixture);
PASS();
}
TEST(config_json_like_upsert_is_byte_idempotent) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
ASSERT_EQ(jl_write(fixture.path, "{\n \"mcp\": {}\n}\n"), 0);
const char *path[] = {"mcp"};
const char *value = "{\"command\":\"cbm\",\"args\":[\"serve\"]}";
ASSERT_EQ(cbm_json_like_upsert_entry(fixture.path, path, 1U, "owned", value), 0);
char *first = jl_read(fixture.path);
ASSERT_NOT_NULL(first);
ASSERT_EQ(cbm_json_like_upsert_entry(fixture.path, path, 1U, "owned", value), 0);
char *second = jl_read(fixture.path);
ASSERT_NOT_NULL(second);
ASSERT_STR_EQ(second, first);
free(first);
free(second);
jl_fixture_close(&fixture);
PASS();
}
TEST(config_json_like_ignores_braces_and_comments_inside_strings) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
const char *original = "{\"note\":\"} // text /* text */ \\\" {\",\"mcp\":{\"servers\":{}}}\n";
ASSERT_EQ(jl_write(fixture.path, original), 0);
const char *path[] = {"mcp", "servers"};
ASSERT_EQ(cbm_json_like_upsert_entry(fixture.path, path, 2U, "owned", "{\"command\":\"cbm\"}"),
0);
char *content = jl_read(fixture.path);
ASSERT_NOT_NULL(content);
ASSERT(strstr(content, "} // text /* text */ \\\" {") != NULL);
ASSERT(strstr(content, "\"owned\": {\"command\":\"cbm\"}") != NULL);
free(content);
jl_fixture_close(&fixture);
PASS();
}
TEST(config_json_like_handles_trailing_commas) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
const char *original = "{\n mcp: {\n servers: {\n other: [1, 2,],\n },\n },\n}\n";
ASSERT_EQ(jl_write(fixture.path, original), 0);
const char *path[] = {"mcp", "servers"};
ASSERT_EQ(cbm_json_like_upsert_entry(fixture.path, path, 2U, "owned", "true"), 0);
char *content = jl_read(fixture.path);
ASSERT_NOT_NULL(content);
ASSERT(strstr(content, "other: [1, 2,]") != NULL);
ASSERT(strstr(content, "\"owned\": true,") != NULL);
free(content);
ASSERT_EQ(cbm_json_like_remove_entry(fixture.path, path, 2U, "owned"), 0);
content = jl_read(fixture.path);
ASSERT_NOT_NULL(content);
ASSERT(strstr(content, "owned") == NULL);
ASSERT(strstr(content, "other: [1, 2,]") != NULL);
free(content);
jl_fixture_close(&fixture);
PASS();
}
TEST(config_json_like_removes_first_middle_last_and_only) {
static const char *inputs[] = {
"{\"owned\":1,\"b\":2,\"c\":3}",
"{\"a\":1,\"owned\":2,\"c\":3}",
"{\"a\":1,\"b\":2,\"owned\":3}",
"{\"owned\":1}",
};
static const char *required[] = {"\"b\":2", "\"a\":1", "\"b\":2", "{"};
const char *root[] = {NULL};
for (size_t i = 0; i < sizeof(inputs) / sizeof(inputs[0]); i++) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
ASSERT_EQ(jl_write(fixture.path, inputs[i]), 0);
ASSERT_EQ(cbm_json_like_remove_entry(fixture.path, root, 0U, "owned"), 0);
char *content = jl_read(fixture.path);
ASSERT_NOT_NULL(content);
ASSERT(strstr(content, "owned") == NULL);
ASSERT(strstr(content, required[i]) != NULL);
ASSERT_EQ(cbm_json_like_remove_entry(fixture.path, root, 0U, "owned"), 0);
free(content);
jl_fixture_close(&fixture);
}
PASS();
}
TEST(config_json_like_removal_preserves_comments_and_siblings) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
const char *original =
"{\n \"first\": 1,\n /* keep this comment */\n \"owned\": 2, // keep this too\n"
" \"last\": 3\n}\n";
ASSERT_EQ(jl_write(fixture.path, original), 0);
const char *root[] = {NULL};
ASSERT_EQ(cbm_json_like_remove_entry(fixture.path, root, 0U, "owned"), 0);
char *content = jl_read(fixture.path);
ASSERT_NOT_NULL(content);
ASSERT(strstr(content, "owned") == NULL);
ASSERT(strstr(content, "/* keep this comment */") != NULL);
ASSERT(strstr(content, "// keep this too") != NULL);
ASSERT(strstr(content, "\"first\": 1") != NULL);
ASSERT(strstr(content, "\"last\": 3") != NULL);
free(content);
jl_fixture_close(&fixture);
PASS();
}
TEST(config_json_like_top_level_array_unique_string) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
const char *original = "{\n"
" theme: 'dark',\n"
" instructions: [\n"
" '~/rules/other.md',\n"
" // keep this user comment\n"
" ],\n"
"}\n";
const char *owned = "~/.config/kilo/rules/codebase-memory-mcp.md";
ASSERT_EQ(jl_write(fixture.path, original), 0);
ASSERT_EQ(cbm_json_like_add_unique_string(fixture.path, "instructions", owned), 0);
char *first = jl_read(fixture.path);
ASSERT_NOT_NULL(first);
ASSERT(strstr(first, "// keep this user comment") != NULL);
ASSERT(strstr(first, "'~/rules/other.md'") != NULL);
ASSERT_EQ(jl_occurrences(first, owned), 1U);
ASSERT_EQ(cbm_json_like_add_unique_string(fixture.path, "instructions", owned), 0);
char *second = jl_read(fixture.path);
ASSERT_NOT_NULL(second);
ASSERT_STR_EQ(second, first);
free(first);
free(second);
ASSERT_EQ(cbm_json_like_remove_string(fixture.path, "instructions", owned), 0);
char *removed = jl_read(fixture.path);
ASSERT_NOT_NULL(removed);
ASSERT(strstr(removed, owned) == NULL);
ASSERT(strstr(removed, "// keep this user comment") != NULL);
ASSERT(strstr(removed, "'~/rules/other.md'") != NULL);
free(removed);
jl_fixture_close(&fixture);
PASS();
}
/* OpenHands profiles ship `"mcp_server_refs": null` (#1826). A null value is
* the documented "no list yet" shape, so adding a unique string must replace
* exactly that token with a one-element array, preserving everything around
* it, and stay idempotent. Removal leaves the minimal edit: an empty array. */
TEST(config_json_like_array_add_replaces_null_value_issue1826) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
const char *original = "{\n"
" \"name\": \"default\",\n"
" \"mcp_server_refs\": null, // keep this user comment\n"
" \"tools\": [\"bash\"]\n"
"}\n";
ASSERT_EQ(jl_write(fixture.path, original), 0);
ASSERT_EQ(
cbm_json_like_add_unique_string(fixture.path, "mcp_server_refs", "codebase-memory-mcp"), 0);
char *first = jl_read(fixture.path);
ASSERT_NOT_NULL(first);
ASSERT_STR_EQ(first,
"{\n"
" \"name\": \"default\",\n"
" \"mcp_server_refs\": [\"codebase-memory-mcp\"], // keep this user comment\n"
" \"tools\": [\"bash\"]\n"
"}\n");
ASSERT_EQ(
cbm_json_like_add_unique_string(fixture.path, "mcp_server_refs", "codebase-memory-mcp"), 0);
char *second = jl_read(fixture.path);
ASSERT_NOT_NULL(second);
ASSERT_STR_EQ(second, first);
free(first);
free(second);
ASSERT_EQ(cbm_json_like_remove_string(fixture.path, "mcp_server_refs", "codebase-memory-mcp"),
0);
char *removed = jl_read(fixture.path);
ASSERT_NOT_NULL(removed);
ASSERT_STR_EQ(removed, "{\n"
" \"name\": \"default\",\n"
" \"mcp_server_refs\": [], // keep this user comment\n"
" \"tools\": [\"bash\"]\n"
"}\n");
free(removed);
/* Only the literal null converts; any other non-array value still fails
* closed byte-identically. */
const char *wrong_type = "{\"mcp_server_refs\": \"null\", \"keep\": true}\n";
ASSERT_EQ(jl_write(fixture.path, wrong_type), 0);
ASSERT_EQ(cbm_json_like_add_unique_string(fixture.path, "mcp_server_refs", "x"), -1);
char *content = jl_read(fixture.path);
ASSERT_NOT_NULL(content);
ASSERT_STR_EQ(content, wrong_type);
free(content);
jl_fixture_close(&fixture);
PASS();
}
/* The OpenHands settings entry carries `enabled: true` (#1826). A literal shape
* lets ownership matching require that token exactly, so uninstall recognises
* our own entry instead of treating the boolean as a foreign annotation. */
static int jl_match_openhands_entry(const char *document,
const cbm_json_like_object_field_t *fields, size_t field_count,
char **captured) {
static const char *const path[] = {"mcp_config"};
return cbm_json_like_match_object_entry(document, strlen(document), path, 1U,
"codebase-memory-mcp", fields, field_count, captured);
}
TEST(config_json_like_match_object_entry_literal_shape_issue1826) {
const cbm_json_like_object_field_t fields[] = {
{.key = "command",
.shape = CBM_JSON_LIKE_VALUE_STRING,
.expected_string = NULL,
.flags = CBM_JSON_LIKE_FIELD_REQUIRED | CBM_JSON_LIKE_FIELD_CAPTURE_STRING},
{.key = "transport",
.shape = CBM_JSON_LIKE_VALUE_STRING,
.expected_string = "stdio",
.flags = CBM_JSON_LIKE_FIELD_REQUIRED},
{.key = "enabled",
.shape = CBM_JSON_LIKE_VALUE_LITERAL,
.expected_string = "true",
.flags = CBM_JSON_LIKE_FIELD_REQUIRED},
};
char *captured = NULL;
const char *ours = "{\"mcp_config\": {\"codebase-memory-mcp\": {\"transport\": \"stdio\", "
"\"command\": \"/x/cbm\", \"enabled\": true}}}\n";
ASSERT_EQ(jl_match_openhands_entry(ours, fields, 3U, &captured), CBM_JSON_LIKE_OBJECT_MATCH);
ASSERT_NOT_NULL(captured);
ASSERT_STR_EQ(captured, "/x/cbm");
free(captured);
/* Trivia around the token is not part of the value. */
const char *spaced = "{\"mcp_config\": {\"codebase-memory-mcp\": {\"transport\": \"stdio\", "
"\"command\": \"/x/cbm\", \"enabled\" : true /* on */ }}}\n";
ASSERT_EQ(jl_match_openhands_entry(spaced, fields, 3U, &captured), CBM_JSON_LIKE_OBJECT_MATCH);
free(captured);
const char *disabled = "{\"mcp_config\": {\"codebase-memory-mcp\": {\"transport\": \"stdio\", "
"\"command\": \"/x/cbm\", \"enabled\": false}}}\n";
ASSERT_EQ(jl_match_openhands_entry(disabled, fields, 3U, &captured),
CBM_JSON_LIKE_OBJECT_MISMATCH);
ASSERT_NULL(captured);
const char *quoted = "{\"mcp_config\": {\"codebase-memory-mcp\": {\"transport\": \"stdio\", "
"\"command\": \"/x/cbm\", \"enabled\": \"true\"}}}\n";
ASSERT_EQ(jl_match_openhands_entry(quoted, fields, 3U, &captured),
CBM_JSON_LIKE_OBJECT_MISMATCH);
ASSERT_NULL(captured);
const char *missing = "{\"mcp_config\": {\"codebase-memory-mcp\": {\"transport\": \"stdio\", "
"\"command\": \"/x/cbm\"}}}\n";
ASSERT_EQ(jl_match_openhands_entry(missing, fields, 3U, &captured),
CBM_JSON_LIKE_OBJECT_MISMATCH);
ASSERT_NULL(captured);
/* A literal field can neither lack its token nor be captured. */
const cbm_json_like_object_field_t no_token[] = {
fields[0],
{.key = "enabled",
.shape = CBM_JSON_LIKE_VALUE_LITERAL,
.expected_string = NULL,
.flags = CBM_JSON_LIKE_FIELD_REQUIRED},
};
ASSERT_EQ(jl_match_openhands_entry(ours, no_token, 2U, &captured), -1);
const cbm_json_like_object_field_t captured_literal[] = {
{.key = "enabled",
.shape = CBM_JSON_LIKE_VALUE_LITERAL,
.expected_string = "true",
.flags = CBM_JSON_LIKE_FIELD_REQUIRED | CBM_JSON_LIKE_FIELD_CAPTURE_STRING},
};
ASSERT_EQ(jl_match_openhands_entry(ours, captured_literal, 1U, &captured), -1);
PASS();
}
/* An OpenHands profile with an existing single-line list (#1826): the added
* name follows the list's own spacing, and removing it again restores the
* original bytes exactly — no stray space before the closing bracket. */
static bool jl_round_trips(jl_fixture_t *fixture, const char *original, const char *expected) {
if (jl_write(fixture->path, original) != 0 ||
cbm_json_like_add_unique_string(fixture->path, "mcp_server_refs", "codebase-memory-mcp") !=
0) {
return false;
}
char *added = jl_read(fixture->path);
bool ok = added && strcmp(added, expected) == 0;
free(added);
if (!ok ||
cbm_json_like_remove_string(fixture->path, "mcp_server_refs", "codebase-memory-mcp") != 0) {
return false;
}
char *restored = jl_read(fixture->path);
ok = restored && strcmp(restored, original) == 0;
free(restored);
return ok;
}
TEST(config_json_like_single_line_array_round_trips_byte_for_byte_issue1826) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
ASSERT_TRUE(jl_round_trips(
&fixture, "{\"name\": \"custom\", \"mcp_server_refs\": [\"other-mcp\"]}\n",
"{\"name\": \"custom\", \"mcp_server_refs\": [\"other-mcp\", \"codebase-memory-mcp\"]}\n"));
ASSERT_TRUE(
jl_round_trips(&fixture, "{ \"mcp_server_refs\": [ \"other-mcp\" ] }\n",
"{ \"mcp_server_refs\": [ \"other-mcp\", \"codebase-memory-mcp\" ] }\n"));
ASSERT_TRUE(jl_round_trips(&fixture, "{\"mcp_server_refs\": [ ]}\n",
"{\"mcp_server_refs\": [ \"codebase-memory-mcp\" ]}\n"));
jl_fixture_close(&fixture);
PASS();
}
TEST(config_json_like_top_level_array_create_escape_and_fail_closed) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
const char *owned = "C:\\rules\\\"main\".md";
ASSERT_EQ(cbm_json_like_add_unique_string(fixture.path, "instructions", owned), 0);
char *content = jl_read(fixture.path);
ASSERT_NOT_NULL(content);
ASSERT(strstr(content, "\"instructions\": [") != NULL);
ASSERT(strstr(content, "C:") != NULL);
ASSERT(strstr(content, "rules") != NULL);
free(content);
ASSERT_EQ(cbm_json_like_remove_string(fixture.path, "instructions", owned), 0);
content = jl_read(fixture.path);
ASSERT_NOT_NULL(content);
ASSERT(strstr(content, "rules") == NULL);
free(content);
const char *duplicate = "{instructions:['owned', \"owned\",], keep:true}\n";
ASSERT_EQ(jl_write(fixture.path, duplicate), 0);
ASSERT_EQ(cbm_json_like_add_unique_string(fixture.path, "instructions", "owned"), -1);
content = jl_read(fixture.path);
ASSERT_NOT_NULL(content);
ASSERT_STR_EQ(content, duplicate);
free(content);
ASSERT_EQ(cbm_json_like_remove_string(fixture.path, "instructions", "owned"), -1);
content = jl_read(fixture.path);
ASSERT_NOT_NULL(content);
ASSERT_STR_EQ(content, duplicate);
free(content);
const char *wrong_type = "{instructions:false, keep:true}\n";
ASSERT_EQ(jl_write(fixture.path, wrong_type), 0);
ASSERT_EQ(cbm_json_like_add_unique_string(fixture.path, "instructions", "owned"), -1);
content = jl_read(fixture.path);
ASSERT_NOT_NULL(content);
ASSERT_STR_EQ(content, wrong_type);
free(content);
jl_fixture_close(&fixture);
PASS();
}
TEST(config_json_like_nested_array_creates_missing_path_and_escapes) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
const char *path[] = {"agents", "defaults", "compaction"};
const char *owned = "Session \"memory\"\\path\nsection";
ASSERT_EQ(cbm_json_like_add_unique_string_at_path(fixture.path, path, 3U,
"postCompactionSections", owned),
0);
char *content = jl_read(fixture.path);
ASSERT_NOT_NULL(content);
ASSERT(strstr(content, "\"agents\": {") != NULL);
ASSERT(strstr(content, "\"defaults\": {") != NULL);
ASSERT(strstr(content, "\"compaction\": {") != NULL);
ASSERT(strstr(content, "\"postCompactionSections\": [") != NULL);
ASSERT(strstr(content, "Session \\\"memory\\\"\\\\path\\nsection") != NULL);
free(content);
ASSERT_EQ(cbm_json_like_remove_string_at_path(fixture.path, path, 3U, "postCompactionSections",
owned),
0);
content = jl_read(fixture.path);
ASSERT_NOT_NULL(content);
ASSERT(strstr(content, "postCompactionSections") != NULL);
ASSERT(strstr(content, "Session") == NULL);
free(content);
jl_fixture_close(&fixture);
PASS();
}
TEST(config_json_like_nested_array_preserves_jsonc_and_is_idempotent) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
const char *original = "{\n"
" // retain root comment\n"
" theme: 'dark',\n"
" options: {\n"
" keep: true,\n"
" context_paths: [\n"
" 'memory.md.bak',\n"
" // retain array comment\n"
" ],\n"
" },\n"
"}\n";
const char *path[] = {"options"};
const char *owned = "memory.md";
ASSERT_EQ(jl_write(fixture.path, original), 0);
ASSERT_EQ(
cbm_json_like_add_unique_string_at_path(fixture.path, path, 1U, "context_paths", owned), 0);
char *first = jl_read(fixture.path);
ASSERT_NOT_NULL(first);
ASSERT(strstr(first, "// retain root comment") != NULL);
ASSERT(strstr(first, "// retain array comment") != NULL);
ASSERT(strstr(first, "theme: 'dark'") != NULL);
ASSERT(strstr(first, "keep: true") != NULL);
ASSERT(strstr(first, "'memory.md.bak',") != NULL);
ASSERT_EQ(jl_occurrences(first, "\"memory.md\""), 1U);
ASSERT_EQ(
cbm_json_like_add_unique_string_at_path(fixture.path, path, 1U, "context_paths", owned), 0);
char *second = jl_read(fixture.path);
ASSERT_NOT_NULL(second);
ASSERT_STR_EQ(second, first);
free(first);
free(second);
ASSERT_EQ(cbm_json_like_remove_string_at_path(fixture.path, path, 1U, "context_paths", owned),
0);
char *removed = jl_read(fixture.path);
ASSERT_NOT_NULL(removed);
ASSERT(strstr(removed, "\"memory.md\"") == NULL);
ASSERT(strstr(removed, "'memory.md.bak'") != NULL);
ASSERT(strstr(removed, "// retain array comment") != NULL);
ASSERT(strstr(removed, "keep: true") != NULL);
free(removed);
jl_fixture_close(&fixture);
PASS();
}
TEST(config_json_like_nested_array_fails_closed_on_ambiguous_or_invalid_paths) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
const char *path[] = {"options"};
const char *wrong_type = "{options:false, keep:true}\n";
ASSERT_EQ(jl_write(fixture.path, wrong_type), 0);
ASSERT_EQ(
cbm_json_like_add_unique_string_at_path(fixture.path, path, 1U, "context_paths", "owned"),
-1);
char *content = jl_read(fixture.path);
ASSERT_NOT_NULL(content);
ASSERT_STR_EQ(content, wrong_type);
free(content);
const char *duplicate_path = "{options:{context_paths:[]}, options:{keep:true}}\n";
ASSERT_EQ(jl_write(fixture.path, duplicate_path), 0);
ASSERT_EQ(
cbm_json_like_add_unique_string_at_path(fixture.path, path, 1U, "context_paths", "owned"),
-1);
content = jl_read(fixture.path);
ASSERT_NOT_NULL(content);
ASSERT_STR_EQ(content, duplicate_path);
free(content);
const char *duplicate_array =
"{options:{context_paths:['owned'], context_paths:[]}, keep:true}\n";
ASSERT_EQ(jl_write(fixture.path, duplicate_array), 0);
ASSERT_EQ(cbm_json_like_remove_string_at_path(fixture.path, path, 1U, "context_paths", "owned"),
-1);
content = jl_read(fixture.path);
ASSERT_NOT_NULL(content);
ASSERT_STR_EQ(content, duplicate_array);
free(content);
ASSERT_EQ(
cbm_json_like_add_unique_string_at_path(fixture.path, NULL, 1U, "context_paths", "owned"),
-1);
const char *null_path[] = {NULL};
ASSERT_EQ(cbm_json_like_add_unique_string_at_path(fixture.path, null_path, 1U, "context_paths",
"owned"),
-1);
const char *control_path[] = {"bad\npath"};
ASSERT_EQ(cbm_json_like_remove_string_at_path(fixture.path, control_path, 1U, "context_paths",
"owned"),
-1);
const char *deep_path[64];
for (size_t i = 0; i < sizeof(deep_path) / sizeof(deep_path[0]); i++) {
deep_path[i] = "level";
}
ASSERT_EQ(cbm_json_like_add_unique_string_at_path(fixture.path, deep_path, 64U, "context_paths",
"owned"),
-1);
content = jl_read(fixture.path);
ASSERT_NOT_NULL(content);
ASSERT_STR_EQ(content, duplicate_array);
free(content);
jl_fixture_close(&fixture);
PASS();
}
#ifndef _WIN32
TEST(config_json_like_nested_array_rejects_foreign_symlink_and_hardlink) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
const char *path[] = {"options"};
const char *original = "{options:{context_paths:[]}}\n";
char target[sizeof(fixture.path) + 32U];
ASSERT(snprintf(target, sizeof(target), "%s/target.json", fixture.directory) > 0);
ASSERT_EQ(jl_write(target, original), 0);
ASSERT_EQ(symlink(target, fixture.path), 0);
/* Foreign-owned link (observer moved by the test seam): still refused. */
ASSERT_EQ(cbm_config_edit_path_follow_add_root(fixture.directory), 0);
cbm_config_edit_path_set_invoking_uid_for_test((unsigned)geteuid() + 1U, 1);
int add_rc =
cbm_json_like_add_unique_string_at_path(fixture.path, path, 1U, "context_paths", "owned");
char *workspace = (char *)(uintptr_t)1U;
int get_rc =
cbm_json_like_get_string_at_path(fixture.path, path, 1U, "context_paths", &workspace);
cbm_config_edit_path_set_invoking_uid_for_test(0U, 0);
cbm_config_edit_path_follow_clear();
ASSERT_EQ(add_rc, -1);
ASSERT_EQ(get_rc, -1);
ASSERT_NULL(workspace);
char *content = jl_read(target);
ASSERT_NOT_NULL(content);
ASSERT_STR_EQ(content, original);
free(content);
ASSERT_EQ(cbm_unlink(fixture.path), 0);
ASSERT_EQ(jl_write(fixture.path, original), 0);
char alias[sizeof(fixture.path) + 32U];
ASSERT(snprintf(alias, sizeof(alias), "%s/alias.json", fixture.directory) > 0);
ASSERT_EQ(link(fixture.path, alias), 0);
ASSERT_EQ(cbm_json_like_remove_string_at_path(fixture.path, path, 1U, "context_paths", "owned"),
-1);
workspace = (char *)(uintptr_t)1U;
ASSERT_EQ(cbm_json_like_get_string_at_path(fixture.path, path, 1U, "context_paths", &workspace),
-1);
ASSERT_NULL(workspace);
content = jl_read(fixture.path);
ASSERT_NOT_NULL(content);
ASSERT_STR_EQ(content, original);
free(content);
ASSERT_EQ(cbm_unlink(alias), 0);
ASSERT_EQ(cbm_unlink(target), 0);
jl_fixture_close(&fixture);
PASS();
}
#endif
TEST(config_json_like_nested_array_rejects_precommit_content_and_identity_races) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
const char *path[] = {"options"};
const char *original = "{options:{context_paths:['owned']}, keep:true}\n";
ASSERT_EQ(jl_write(fixture.path, original), 0);
jl_precommit_change_t content_change = {
.content = "{concurrent:true}\n",
.backup_path = NULL,
.replace_identity = false,
.result = -1,
};
cbm_json_like_set_precommit_hook_for_testing(jl_change_before_commit, &content_change);
int result =
cbm_json_like_add_unique_string_at_path(fixture.path, path, 1U, "context_paths", "new");
cbm_json_like_set_precommit_hook_for_testing(NULL, NULL);
ASSERT_EQ(content_change.result, 0);
ASSERT_EQ(result, -1);
char *content = jl_read(fixture.path);
ASSERT_NOT_NULL(content);
ASSERT_STR_EQ(content, "{concurrent:true}\n");
free(content);
ASSERT_EQ(jl_temp_file_count(&fixture), 0U);
ASSERT_EQ(jl_write(fixture.path, original), 0);
char backup[sizeof(fixture.path) + 32U];
ASSERT(snprintf(backup, sizeof(backup), "%s/original.json", fixture.directory) > 0);
jl_precommit_change_t identity_change = {
.content = original,
.backup_path = backup,
.replace_identity = true,
.result = -1,
};
cbm_json_like_set_precommit_hook_for_testing(jl_change_before_commit, &identity_change);
result = cbm_json_like_remove_string_at_path(fixture.path, path, 1U, "context_paths", "owned");
cbm_json_like_set_precommit_hook_for_testing(NULL, NULL);
ASSERT_EQ(identity_change.result, 0);
ASSERT_EQ(result, -1);
content = jl_read(fixture.path);
ASSERT_NOT_NULL(content);
ASSERT_STR_EQ(content, original);
free(content);
ASSERT_EQ(jl_temp_file_count(&fixture), 0U);
ASSERT_EQ(cbm_unlink(backup), 0);
jl_fixture_close(&fixture);
PASS();
}
TEST(config_json_like_nested_string_lookup_decodes_json5_workspace) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
const char *document =
"{agents:{defaults:{workspace:'~\\/Open\\x43law\\u0020work\\\'space'}}}\n";
const char *path[] = {"agents", "defaults"};
ASSERT_EQ(jl_write(fixture.path, document), 0);
char *workspace = NULL;
ASSERT_EQ(cbm_json_like_get_string_at_path(fixture.path, path, 2U, "workspace", &workspace), 0);
ASSERT_NOT_NULL(workspace);
ASSERT_STR_EQ(workspace, "~/OpenClaw work'space");
free(workspace);
jl_fixture_close(&fixture);
PASS();
}
TEST(config_json_like_nested_string_lookup_distinguishes_missing_and_fails_closed) {
jl_fixture_t fixture;
ASSERT_EQ(jl_fixture_open(&fixture), 0);
const char *path[] = {"agents", "defaults"};
char *workspace = (char *)(uintptr_t)1U;
ASSERT_EQ(cbm_json_like_get_string_at_path(fixture.path, path, 2U, "workspace", &workspace), 1);
ASSERT_NULL(workspace);
const char *missing = "{agents:{defaults:{keep:true}}}\n";
ASSERT_EQ(jl_write(fixture.path, missing), 0);
workspace = (char *)(uintptr_t)1U;
ASSERT_EQ(cbm_json_like_get_string_at_path(fixture.path, path, 2U, "workspace", &workspace), 1);
ASSERT_NULL(workspace);
const char *non_string = "{agents:{defaults:{workspace:false}}}\n";
ASSERT_EQ(jl_write(fixture.path, non_string), 0);
workspace = (char *)(uintptr_t)1U;
ASSERT_EQ(cbm_json_like_get_string_at_path(fixture.path, path, 2U, "workspace", &workspace),
-1);
ASSERT_NULL(workspace);
const char *duplicate_key = "{agents:{defaults:{workspace:'one', workspace:'two'}}}\n";
ASSERT_EQ(jl_write(fixture.path, duplicate_key), 0);
workspace = (char *)(uintptr_t)1U;
ASSERT_EQ(cbm_json_like_get_string_at_path(fixture.path, path, 2U, "workspace", &workspace),
-1);
ASSERT_NULL(workspace);
const char *duplicate_path =
"{agents:{defaults:{workspace:'one'}}, agents:{defaults:{workspace:'two'}}}\n";
ASSERT_EQ(jl_write(fixture.path, duplicate_path), 0);
workspace = (char *)(uintptr_t)1U;
ASSERT_EQ(cbm_json_like_get_string_at_path(fixture.path, path, 2U, "workspace", &workspace),
-1);
ASSERT_NULL(workspace);
jl_fixture_close(&fixture);
PASS();
}
SUITE(config_json_like) {
RUN_TEST(config_json_like_rejects_stale_content_and_cleans_temp);
RUN_TEST(config_json_like_rejects_stale_identity_with_same_content);
RUN_TEST(config_json_like_missing_target_race_does_not_replace_winner);
RUN_TEST(config_json_like_existing_target_swap_after_check_preserves_winner);
RUN_TEST(config_json_like_rejects_non_regular_path);
#ifndef _WIN32
RUN_TEST(config_json_like_rejects_foreign_owned_symlink_without_touching_target);
RUN_TEST(config_json_like_root_refuses_user_owned_symlink);
RUN_TEST(config_json_like_refuses_dangling_symlink);
RUN_TEST(config_json_like_refuses_symlink_to_directory);
RUN_TEST(config_json_like_refuses_symlink_without_opt_in);
RUN_TEST(config_json_like_refuses_symlink_when_target_identity_skews);
RUN_TEST(config_json_like_refuses_symlink_with_world_writable_parent);
RUN_TEST(config_json_like_follows_user_owned_symlink_in_place);
RUN_TEST(config_json_like_rejects_hard_link_without_splitting_identity);
RUN_TEST(config_json_like_preserves_owner_group_and_mode);
#endif
RUN_TEST(config_json_like_supports_bom_and_common_json5_whitespace);
RUN_TEST(config_json_like_rejects_json5_decimal_escapes_byte_identical);
RUN_TEST(config_json_like_fresh_strict_upsert_replace_remove);
RUN_TEST(config_json_like_preserves_jsonc_comments);
RUN_TEST(config_json_like_openclaw_json5_nested_servers);
RUN_TEST(config_json_like_creates_missing_nested_path);
RUN_TEST(config_json_like_rejects_duplicate_path_byte_identical);
RUN_TEST(config_json_like_rejects_invalid_and_malformed_byte_identical);
RUN_TEST(config_json_like_upsert_is_byte_idempotent);
RUN_TEST(config_json_like_ignores_braces_and_comments_inside_strings);
RUN_TEST(config_json_like_handles_trailing_commas);
RUN_TEST(config_json_like_removes_first_middle_last_and_only);
RUN_TEST(config_json_like_removal_preserves_comments_and_siblings);
RUN_TEST(config_json_like_top_level_array_unique_string);
RUN_TEST(config_json_like_array_add_replaces_null_value_issue1826);
RUN_TEST(config_json_like_match_object_entry_literal_shape_issue1826);
RUN_TEST(config_json_like_single_line_array_round_trips_byte_for_byte_issue1826);
RUN_TEST(config_json_like_top_level_array_create_escape_and_fail_closed);
RUN_TEST(config_json_like_nested_array_creates_missing_path_and_escapes);
RUN_TEST(config_json_like_nested_array_preserves_jsonc_and_is_idempotent);
RUN_TEST(config_json_like_nested_array_fails_closed_on_ambiguous_or_invalid_paths);
#ifndef _WIN32
RUN_TEST(config_json_like_nested_array_rejects_foreign_symlink_and_hardlink);
#endif
RUN_TEST(config_json_like_nested_array_rejects_precommit_content_and_identity_races);
RUN_TEST(config_json_like_nested_string_lookup_decodes_json5_workspace);
RUN_TEST(config_json_like_nested_string_lookup_distinguishes_missing_and_fails_closed);
}
Reference in new issue View Git Blame Copy Permalink