WHC/CST-agent
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Extensions: skills, plugins, MCP, sub-agents; configurable keys

Browse Source 
- Skills (SKILL.md discovery, skill tool, /skills /skill)
- plugin.json exec tools with permission prompts, timeouts and workspace trust (/plugins)
- MCP stdio client: JSON-RPC initialize/tools/list/tools/call, mcp__server__tool, /mcp and sidebar status
- task tool with general/explore/plan and .agent/agents/*.md roles, parallel read-only runs, cancel propagation, /agents
- Keymap with Ctrl+X leader, keybinds.json overrides and /keys panel
- Collapsed thinking, throttled streaming Markdown, leaner tool output, parallel read-only tools
- Spawn: close-on-exec pipes and a process-wide fork lock
- Tests for keymap, skills, plugins, MCP, sub-agents, shell compaction; docs/plugins.md
This commit is contained in:
WHC
2026-10-05 14:55:31 +08:00
parent c81df42f0b
commit 7d3ec9fcb9
38 changed files with 8356 additions and 399 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/test_keymap.c
+126
View File
@@ -0,0 +1,126 @@
#include "cst_keymap.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define CHECK(c) \
do { \
if (!(c)) { \
fprintf(stderr, "%s:%d: CHECK(%s) failed\n", __FILE__, __LINE__, #c); \
exit(1); \
} \
} while (0)
static int lookup1(const cst_keymap_t *km, int k, int *a) {
int seq[1] = {k};
return cst_keymap_lookup(km, seq, 1, a);
}
static int lookup2(const cst_keymap_t *km, int k1, int k2, int *a) {
int seq[2] = {k1, k2};
return cst_keymap_lookup(km, seq, 2, a);
}
static void test_parse(void) {
char b[32];
CHECK(cst_key_parse("ctrl+p") == 16);
CHECK(cst_key_parse("Ctrl+X") == 24);
CHECK(cst_key_parse("tab") == 9);
CHECK(cst_key_parse("shift+tab") == CST_K_BTAB);
CHECK(cst_key_parse("alt+enter") == (13 | CST_KEY_ALT));
CHECK(cst_key_parse("alt+up") == CST_K_ALT_UP);
CHECK(cst_key_parse("ctrl+home") == CST_K_CTRL_HOME);
CHECK(cst_key_parse("f1") == CST_K_F1);
CHECK(cst_key_parse("f12") == CST_K_F1 + 11);
CHECK(cst_key_parse("pgdn") == CST_K_PGDN);
CHECK(cst_key_parse("n") == 'n');
CHECK(cst_key_parse("é") == 0xE9);
CHECK(cst_key_parse("ctrl+") == -1);
CHECK(cst_key_parse("hyper+x") == -1);
CHECK(cst_key_parse("f13") == -1);
CHECK(cst_key_parse("ctrl+f1") == -1);
CHECK(strcmp(cst_key_name(24, b, sizeof(b)), "ctrl+x") == 0);
CHECK(strcmp(cst_key_name(CST_K_BTAB, b, sizeof(b)), "shift+tab") == 0);
CHECK(strcmp(cst_key_name(13 | CST_KEY_ALT, b, sizeof(b)), "alt+enter") ==
0);
CHECK(strcmp(cst_key_name(CST_K_F1 + 1, b, sizeof(b)), "f2") == 0);
for (int a = 1; a < CST_KA_COUNT; a++) {
const cst_key_action_info_t *in = cst_key_action_info(a);
CHECK(in && in->name && in->group && in->desc);
CHECK(cst_key_action_find(in->name) == a);
}
}
static void test_defaults(void) {
cst_keymap_t km;
cst_keymap_defaults(&km);
int a = 0;
CHECK(lookup1(&km, 16, &a) == CST_KM_MATCH && a == CST_KA_PALETTE);
CHECK(lookup1(&km, 24, &a) == CST_KM_PREFIX);
CHECK(lookup2(&km, 24, 'n', &a) == CST_KM_MATCH && a == CST_KA_NEW_SESSION);
CHECK(lookup2(&km, 24, 'z', &a) == CST_KM_NONE);
CHECK(lookup1(&km, 'q', &a) == CST_KM_NONE);
CHECK(lookup1(&km, CST_K_F1, &a) == CST_KM_MATCH && a == CST_KA_KEYS);
char d[64];
cst_keymap_describe(&km, CST_KA_KEYS, d, sizeof(d));
CHECK(strcmp(d, "ctrl+x h, f1") == 0);
char conf[256];
CHECK(cst_keymap_conflicts(&km, conf, sizeof(conf)) == 0);
}
static void test_json(void) {
cst_keymap_t km;
cst_keymap_defaults(&km);
char err[128];
CHECK(cst_keymap_apply_json(&km,
"{\"leader\":\"ctrl+g\",\"palette\":\"f2\","
"\"todo\":\"none\",\"model\":[\"<leader> M\","
"\"alt+m\"]}",
err, sizeof(err)) == 0);
int a = 0;
CHECK(lookup1(&km, 16, &a) == CST_KM_NONE);
CHECK(lookup1(&km, CST_K_F1 + 1, &a) == CST_KM_MATCH && a == CST_KA_PALETTE);
CHECK(lookup1(&km, 20, &a) == CST_KM_NONE); /* ctrl+t unbound */
CHECK(lookup1(&km, 24, &a) == CST_KM_NONE); /* ctrl+x no longer leader */
CHECK(lookup2(&km, 7, 'n', &a) == CST_KM_MATCH && a == CST_KA_NEW_SESSION);
CHECK(lookup2(&km, 7, 'M', &a) == CST_KM_MATCH && a == CST_KA_MODEL);
CHECK(lookup2(&km, 7, 'm', &a) == CST_KM_NONE);
CHECK(lookup1(&km, 'm' | CST_KEY_ALT, &a) == CST_KM_MATCH &&
a == CST_KA_MODEL);
int user = 0;
for (int i = 0; i < km.n; i++)
if (km.b[i].action == CST_KA_MODEL)
user += km.b[i].user;
CHECK(user == 2);
/* bad entries are reported, the rest still applies */
cst_keymap_defaults(&km);
CHECK(cst_keymap_apply_json(&km,
"{\"nope\":\"f3\",\"undo\":\"ctrl+\","
"\"retry\":\"f4\"}",
err, sizeof(err)) == -1);
CHECK(strstr(err, "nope") != NULL);
CHECK(lookup1(&km, CST_K_F1 + 3, &a) == CST_KM_MATCH && a == CST_KA_RETRY);
CHECK(cst_keymap_apply_json(&km, "[1]", err, sizeof(err)) == -1);
/* conflicts: same key twice, and a single key shadowing a prefix */
cst_keymap_defaults(&km);
CHECK(cst_keymap_apply_json(&km, "{\"undo\":\"ctrl+o\",\"redo_none\":1}",
err, sizeof(err)) == -1);
char conf[256];
CHECK(cst_keymap_conflicts(&km, conf, sizeof(conf)) == 1);
CHECK(strstr(conf, "ctrl+o") && strstr(conf, "undo"));
cst_keymap_defaults(&km);
CHECK(cst_keymap_apply_json(&km, "{\"copy\":\"ctrl+x\"}", err,
sizeof(err)) == 0);
CHECK(cst_keymap_conflicts(&km, conf, sizeof(conf)) > 0);
}
int main(void) {
test_parse();
test_defaults();
test_json();
puts("test_keymap: ok");
return 0;
}
tests/test_mcp.c
+297
View File
@@ -0,0 +1,297 @@
/* MCP client: the test binary doubles as a stdio MCP server (--server).
* Covers the handshake, paginated tools/list, registration, tools/call
* content mapping, isError, server->client requests, stdout noise,
* cancellation, a crashing server and bad configs. */
#define _POSIX_C_SOURCE 200809L
#include "cJSON.h"
#include "cst_mcp.h"
#include "cst_tools.h"
#include "os_compat.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
static int nfail;
#define CHECK(cond, msg) \
do { \
if (!(cond)) { \
fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, msg); \
nfail++; \
} \
} while (0)
/* ---------- fake server ---------- */
static void reply(const cJSON *id, cJSON *result) {
cJSON *m = cJSON_CreateObject();
cJSON_AddStringToObject(m, "jsonrpc", "2.0");
cJSON_AddItemToObject(m, "id", cJSON_Duplicate(id, 1));
cJSON_AddItemToObject(m, "result", result);
char *s = cJSON_PrintUnformatted(m);
printf("%s\n", s);
fflush(stdout);
free(s);
cJSON_Delete(m);
}
static cJSON *tool(const char *name, const char *desc) {
cJSON *t = cJSON_CreateObject();
cJSON_AddStringToObject(t, "name", name);
cJSON_AddStringToObject(t, "description", desc);
cJSON *s = cJSON_AddObjectToObject(t, "inputSchema");
cJSON_AddStringToObject(s, "type", "object");
cJSON *p = cJSON_AddObjectToObject(s, "properties");
cJSON *n = cJSON_AddObjectToObject(p, "n");
cJSON_AddStringToObject(n, "type", "integer");
cJSON *x = cJSON_AddObjectToObject(p, "text");
cJSON_AddStringToObject(x, "type", "string");
return t;
}
static cJSON *text_result(const char *text, int is_error) {
cJSON *r = cJSON_CreateObject();
cJSON *c = cJSON_AddArrayToObject(r, "content");
cJSON *it = cJSON_CreateObject();
cJSON_AddStringToObject(it, "type", "text");
cJSON_AddStringToObject(it, "text", text);
cJSON_AddItemToArray(c, it);
if (is_error)
cJSON_AddTrueToObject(r, "isError");
return r;
}
static int server(void) {
fprintf(stderr, "fake server starting\n");
printf("this line is not JSON-RPC\n");
fflush(stdout);
char line[65536];
while (fgets(line, sizeof(line), stdin)) {
cJSON *m = cJSON_Parse(line);
const cJSON *id = cJSON_GetObjectItemCaseSensitive(m, "id");
const cJSON *method = cJSON_GetObjectItemCaseSensitive(m, "method");
const char *mt = cJSON_IsString(method) ? method->valuestring : "";
const cJSON *params = cJSON_GetObjectItemCaseSensitive(m, "params");
if (strcmp(mt, "initialize") == 0) {
cJSON *r = cJSON_CreateObject();
cJSON_AddStringToObject(r, "protocolVersion", "2025-06-18");
cJSON_AddObjectToObject(cJSON_AddObjectToObject(r, "capabilities"),
"tools");
cJSON *si = cJSON_AddObjectToObject(r, "serverInfo");
cJSON_AddStringToObject(si, "name", "fake");
reply(id, r);
} else if (strcmp(mt, "tools/list") == 0) {
const cJSON *cur = cJSON_GetObjectItemCaseSensitive(params, "cursor");
cJSON *r = cJSON_CreateObject();
cJSON *tools = cJSON_AddArrayToObject(r, "tools");
if (!cur) {
cJSON_AddItemToArray(tools, tool("echo", "Echo the arguments."));
cJSON_AddItemToArray(tools, tool("odd.name/x", "Sanitized name."));
cJSON_AddStringToObject(r, "nextCursor", "page2");
} else {
cJSON_AddItemToArray(tools, tool("fail", "Always fails."));
cJSON_AddItemToArray(tools, tool("mixed", "Mixed content."));
cJSON_AddItemToArray(tools, tool("hang", "Never answers."));
cJSON_AddItemToArray(tools, tool("crash", "Exits."));
}
reply(id, r);
} else if (strcmp(mt, "tools/call") == 0) {
const char *name = cJSON_GetObjectItemCaseSensitive(params, "name")
->valuestring;
const cJSON *args = cJSON_GetObjectItemCaseSensitive(params, "arguments");
if (strcmp(name, "echo") == 0) {
/* a server->client request first; the client must answer it */
printf("{\"jsonrpc\":\"2.0\",\"id\":\"s1\",\"method\":\"ping\"}\n");
fflush(stdout);
char pong[4096];
int ok = fgets(pong, sizeof(pong), stdin) && strstr(pong, "\"s1\"") &&
strstr(pong, "\"result\"");
char *a = cJSON_PrintUnformatted(args);
char out[8192];
const char *env = getenv("FAKE_ENV");
snprintf(out, sizeof(out), "args=%s ping=%s env=%s", a,
ok ? "ok" : "missing", env ? env : "");
free(a);
reply(id, text_result(out, 0));
} else if (strcmp(name, "fail") == 0) {
reply(id, text_result("bad input", 1));
} else if (strcmp(name, "mixed") == 0) {
cJSON *r = text_result("first", 0);
cJSON *c = cJSON_GetObjectItemCaseSensitive(r, "content");
cJSON *img = cJSON_CreateObject();
cJSON_AddStringToObject(img, "type", "image");
cJSON_AddStringToObject(img, "mimeType", "image/png");
cJSON_AddStringToObject(img, "data", "AAAA");
cJSON_AddItemToArray(c, img);
cJSON *res = cJSON_CreateObject();
cJSON_AddStringToObject(res, "type", "resource");
cJSON *rr = cJSON_AddObjectToObject(res, "resource");
cJSON_AddStringToObject(rr, "uri", "file:///x");
cJSON_AddStringToObject(rr, "text", "resource text");
cJSON_AddItemToArray(c, res);
reply(id, r);
} else if (strcmp(name, "crash") == 0) {
fprintf(stderr, "fatal: fake crash\n");
exit(3);
}
/* hang: no reply */
}
cJSON_Delete(m);
}
return 0;
}
/* ---------- client ---------- */
static int call(const char *tool, const char *k, const char *v,
cst_tool_result_t *r) {
ctl_tool_call_t c;
memset(&c, 0, sizeof(c));
snprintf(c.name, sizeof(c.name), "%s", tool);
if (k) {
snprintf(c.args[0].key, sizeof(c.args[0].key), "%s", k);
c.args[0].value = (char *)v;
c.args[0].value_len = strlen(v);
c.nargs = 1;
}
cst_tool_ctx_t ctx;
memset(&ctx, 0, sizeof(ctx));
ctx.workspace_root = "/tmp";
memset(r, 0, sizeof(*r));
return cst_tool_run(&ctx, &c, r);
}
static const cst_mcp_info_t *info_of(const char *name, cst_mcp_info_t *buf,
int n) {
for (int i = 0; i < n; i++)
if (strcmp(buf[i].name, name) == 0)
return &buf[i];
return NULL;
}
int main(int argc, char **argv) {
if (argc > 1 && strcmp(argv[1], "--server") == 0)
return server();
char self[OS_PATH_MAX];
if (os_realpath(argv[0], self, sizeof(self)) != 0) {
fprintf(stderr, "cannot resolve %s\n", argv[0]);
return 1;
}
setenv("CST_TEST_SECRET", "s3cret", 1);
char cfg[OS_PATH_MAX + 128];
snprintf(cfg, sizeof(cfg),
"{\"command\": \"%s\", \"args\": [\"--server\"], "
"\"env\": {\"FAKE_ENV\": \"v=${CST_TEST_SECRET}\"}, "
"\"autoApprove\": [\"echo\"]}",
self);
CHECK(cst_mcp_add_config_json("fake", cfg, NULL, "user") == 0, "add fake");
CHECK(cst_mcp_add_config_json("fake", cfg, NULL, "user") != 0,
"duplicate name rejected");
CHECK(cst_mcp_add_config_json("remote", "{\"url\": \"https://x\"}", NULL,
"user") == 0,
"url server recorded");
CHECK(cst_mcp_add_config_json("ghost",
"{\"command\": \"/nonexistent/cst-mcp\"}",
NULL, "user") == 0,
"ghost server recorded");
CHECK(cst_mcp_add_config_json("off", "{\"command\": \"true\", "
"\"disabled\": true}",
NULL, "user") == 0,
"disabled server recorded");
int ready = -1, total = -1;
cst_mcp_counts(&ready, &total);
CHECK(ready == 0 && total == 3, "counts before start (disabled excluded)");
cst_mcp_start_all("/tmp");
cst_mcp_wait_ready(10000);
cst_mcp_info_t mi[CST_MCP_MAX];
int n = cst_mcp_info(mi, CST_MCP_MAX);
const cst_mcp_info_t *f = info_of("fake", mi, n);
CHECK(f && f->state == CST_MCP_READY && f->ntools == 6,
"fake ready with 6 tools over two pages");
const cst_mcp_info_t *rm = info_of("remote", mi, n);
CHECK(rm && rm->state == CST_MCP_FAILED && strstr(rm->error, "stdio"),
"url servers unsupported");
const cst_mcp_info_t *gh = info_of("ghost", mi, n);
CHECK(gh && gh->state != CST_MCP_READY && gh->error[0],
"missing command fails");
const cst_mcp_info_t *of = info_of("off", mi, n);
CHECK(of && of->state == CST_MCP_OFF, "disabled stays off");
cst_mcp_counts(&ready, &total);
CHECK(ready == 1 && total == 3, "counts after start");
const cst_tool_def_t *d = cst_tool_find("mcp__fake__echo");
CHECK(d && d->perm == CST_TP_READ && d->schema_json &&
strstr(d->schema_json, "\"integer\""),
"echo registered, autoApprove -> read, schema kept");
d = cst_tool_find("mcp__fake__fail");
CHECK(d && d->perm == CST_TP_NET, "others need approval (net)");
CHECK(cst_tool_find("mcp__fake__odd_name_x"), "tool name sanitized");
cst_tool_result_t r;
call("mcp__fake__echo", "n", "42", &r);
CHECK(r.exit_code == 0 && r.out && strstr(r.out, "args={\"n\":42}"),
"typed arguments");
CHECK(r.out && strstr(r.out, "ping=ok"), "server ping answered");
CHECK(r.out && strstr(r.out, "env=v=s3cret"), "env with ${VAR} expansion");
cst_tool_result_free(&r);
call("mcp__fake__fail", NULL, NULL, &r);
CHECK(r.exit_code == 1 && r.out && strstr(r.out, "bad input"),
"isError -> exit 1");
cst_tool_result_free(&r);
call("mcp__fake__mixed", NULL, NULL, &r);
CHECK(r.exit_code == 0 && r.out && strstr(r.out, "first\n[image image/png") &&
strstr(r.out, "resource text"),
"content items mapped to text");
cst_tool_result_free(&r);
volatile int cancel = 1;
os_set_cancel_flag(&cancel);
double t0 = os_now_ms();
call("mcp__fake__hang", NULL, NULL, &r);
CHECK(r.exit_code == 1 && r.out && strstr(r.out, "cancelled") &&
os_now_ms() - t0 < 5000,
"cancel stops waiting");
cst_tool_result_free(&r);
os_set_cancel_flag(NULL);
call("mcp__fake__crash", NULL, NULL, &r);
CHECK(r.exit_code == 1 && r.out && strstr(r.out, "fake crash"),
"crash reported with the stderr tail");
cst_tool_result_free(&r);
n = cst_mcp_info(mi, CST_MCP_MAX);
f = info_of("fake", mi, n);
CHECK(f && f->state == CST_MCP_EXITED, "crashed server marked exited");
call("mcp__fake__echo", "n", "1", &r);
CHECK(r.exit_code == 1 && r.out && strstr(r.out, "not running"),
"calls after a crash fail fast");
cst_tool_result_free(&r);
cst_mcp_stop_all();
CHECK(!cst_tool_find("mcp__fake__echo"), "stop unregisters tools");
cst_mcp_counts(&ready, &total);
CHECK(total == 0, "stop forgets configs");
/* a live server stops cleanly too */
CHECK(cst_mcp_add_config_json("fake2", cfg, NULL, "user") == 0, "re-add");
cst_mcp_start_all("/tmp");
cst_mcp_wait_ready(10000);
CHECK(cst_tool_find("mcp__fake2__echo"), "second server ready");
t0 = os_now_ms();
cst_mcp_stop_all();
CHECK(os_now_ms() - t0 < 3000, "stop is prompt");
if (nfail) {
fprintf(stderr, "test_mcp: %d failure(s)\n", nfail);
return 1;
}
printf("test_mcp: OK\n");
return 0;
}
tests/test_plugins.c
+219
View File
@@ -0,0 +1,219 @@
/* Plugins: plugin.json exec tools (stdin JSON, env, timeout, perm), skills
* and MCP entries from plugins, and workspace trust. */
#define _POSIX_C_SOURCE 200809L
#include "cst_agent.h"
#include "cst_ext.h"
#include "cst_mcp.h"
#include "cst_plugins.h"
#include "cst_skills.h"
#include "cst_tools.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
static int nfail;
#define CHECK(cond, msg) \
do { \
if (!(cond)) { \
fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, msg); \
nfail++; \
} \
} while (0)
static char g_root[256];
static void put(const char *rel, const char *text) {
char p[512];
snprintf(p, sizeof(p), "%s/%s", g_root, rel);
for (char *q = p + strlen(g_root) + 1; *q; q++) {
if (*q == '/') {
*q = 0;
mkdir(p, 0755);
*q = '/';
}
}
FILE *fp = fopen(p, "w");
if (fp) {
fputs(text, fp);
fclose(fp);
}
}
static void run(const char *ws, const char *tool, const char *k1,
const char *v1, const char *k2, const char *v2,
cst_tool_result_t *r) {
ctl_tool_call_t c;
memset(&c, 0, sizeof(c));
snprintf(c.name, sizeof(c.name), "%s", tool);
if (k1) {
snprintf(c.args[c.nargs].key, sizeof(c.args[0].key), "%s", k1);
c.args[c.nargs].value = (char *)v1;
c.args[c.nargs].value_len = strlen(v1);
c.nargs++;
}
if (k2) {
snprintf(c.args[c.nargs].key, sizeof(c.args[0].key), "%s", k2);
c.args[c.nargs].value = (char *)v2;
c.args[c.nargs].value_len = strlen(v2);
c.nargs++;
}
cst_tool_ctx_t ctx;
memset(&ctx, 0, sizeof(ctx));
ctx.workspace_root = ws;
memset(r, 0, sizeof(*r));
cst_tool_run(&ctx, &c, r);
}
int main(void) {
snprintf(g_root, sizeof(g_root), "/tmp/cst-plugins-%d", (int)getpid());
mkdir(g_root, 0755);
char ws[300], cfgdir[300];
snprintf(ws, sizeof(ws), "%s/ws", g_root);
snprintf(cfgdir, sizeof(cfgdir), "%s/cfg", g_root);
setenv("XDG_CONFIG_HOME", cfgdir, 1);
put("cfg/cst-agent/plugins/echo/plugin.json",
"{\"name\": \"echo\", \"description\": \"Test plugin.\",\n"
" \"tools\": [\n"
" {\"name\": \"echo_args\", \"description\": \"Echo stdin.\",\n"
" \"command\": [\"sh\", \"run.sh\", \"--flag\"], \"perm\": \"read\",\n"
" \"parameters\": {\"type\": \"object\", \"properties\": {\n"
" \"name\": {\"type\": \"string\"}, \"count\": {\"type\": "
"\"integer\"},\n"
" \"tags\": {\"type\": \"array\"}}, \"required\": [\"name\"]}},\n"
" {\"name\": \"slow\", \"command\": \"sleep 5\", \"timeout\": 1},\n"
" {\"name\": \"missing\", \"command\": [\"cst-no-such-cmd-xyz\"], "
"\"perm\": \"write\"},\n"
" {\"name\": \"piped\", \"command\": \"tr a-z A-Z | tr -d '{}'\", "
"\"perm\": \"net\"},\n"
" {\"name\": \"bad\"}\n"
" ],\n"
" \"mcpServers\": {\"plug-srv\": {\"command\": \"true\"}}}\n");
put("cfg/cst-agent/plugins/echo/run.sh",
"cat\necho\necho \"arg=$1 dir=$(basename \"$CST_PLUGIN_DIR\") "
"tool=$CST_TOOL ws=$(basename \"$CST_WORKSPACE\")\"\n");
put("cfg/cst-agent/plugins/echo/skills/plug-skill/SKILL.md",
"---\nname: plug-skill\ndescription: Shipped by a plugin.\n---\nP\n");
put("cfg/cst-agent/plugins/notaplugin/readme.txt", "no plugin.json\n");
put("ws/.agent/plugins/local/plugin.json",
"{\"tools\": [{\"name\": \"local_tool\", \"command\": \"echo local\"}]}");
put("ws/keep.txt", "x\n");
int untrusted = -1;
int n = cst_plugins_load(ws, cst_settings_trusted(ws), &untrusted);
CHECK(n == 1, "one user plugin (workspace not trusted)");
CHECK(untrusted == 1, "workspace plugin counted as untrusted");
CHECK(!cst_tool_find("local_tool"), "untrusted workspace plugin not loaded");
const cst_tool_def_t *d = cst_tool_find("echo_args");
CHECK(d && d->perm == CST_TP_READ, "perm read");
d = cst_tool_find("slow");
CHECK(d && d->perm == CST_TP_SHELL, "perm defaults to shell");
d = cst_tool_find("missing");
CHECK(d && d->perm == CST_TP_WRITE, "perm write");
d = cst_tool_find("piped");
CHECK(d && d->perm == CST_TP_NET, "perm net");
CHECK(!cst_tool_find("bad"), "tool without command skipped");
cst_plugin_info_t info[CST_PLUGINS_MAX];
int ni = cst_plugins_info(info, CST_PLUGINS_MAX);
CHECK(ni == 1 && strcmp(info[0].name, "echo") == 0 && info[0].ntools == 4 &&
info[0].nmcp == 1 && info[0].nskills_root == 1 &&
strstr(info[0].error, "bad"),
"plugin info");
cst_tool_result_t r;
run(ws, "echo_args", "count", "3", "name", "x y", &r);
CHECK(r.exit_code == 0 && r.out && strstr(r.out, "\"count\":3") &&
strstr(r.out, "\"name\":\"x y\""),
"typed JSON on stdin");
CHECK(r.out && strstr(r.out, "arg=--flag dir=echo tool=echo_args ws=ws"),
"argv and CST_* environment");
cst_tool_result_free(&r);
run(ws, "echo_args", "count", "3", NULL, NULL, &r);
CHECK(r.exit_code != 0 && r.out && strstr(r.out, "name"),
"schema required enforced");
cst_tool_result_free(&r);
run(ws, "piped", "name", "abc", NULL, NULL, &r);
CHECK(r.exit_code == 0 && r.out && strstr(r.out, "\"NAME\":\"ABC\""),
"string command: whole pipeline reads stdin");
cst_tool_result_free(&r);
run(ws, "slow", NULL, NULL, NULL, NULL, &r);
CHECK(r.exit_code == 124 && r.out && strstr(r.out, "timed out after 1 s"),
"per-tool timeout");
cst_tool_result_free(&r);
run(ws, "missing", NULL, NULL, NULL, NULL, &r);
CHECK(r.exit_code == 127 && r.out && strstr(r.out, "command not found"),
"missing command hint");
cst_tool_result_free(&r);
cst_skill_t sv[CST_SKILLS_MAX];
int ns = cst_skills_list(ws, sv, CST_SKILLS_MAX);
CHECK(ns == 1 && strcmp(sv[0].name, "plug-skill") == 0 &&
strcmp(sv[0].source, "plugin:echo") == 0,
"plugin skills root");
cst_mcp_info_t mi[CST_MCP_MAX];
int nm = cst_mcp_info(mi, CST_MCP_MAX);
CHECK(nm == 1 && strcmp(mi[0].name, "plug-srv") == 0 &&
strcmp(mi[0].source, "plugin:echo") == 0,
"plugin MCP server config");
cst_mcp_stop_all();
cst_plugins_unload();
CHECK(!cst_tool_find("echo_args"), "unload drops tools");
CHECK(cst_skills_list(ws, sv, CST_SKILLS_MAX) == 0, "unload drops skills");
/* trust the workspace -> its plugin loads too */
CHECK(cst_settings_trust(ws, 1) == 0 && cst_settings_trusted(ws),
"trust saved");
n = cst_plugins_load(ws, cst_settings_trusted(ws), &untrusted);
CHECK(n == 2 && untrusted == 0 && cst_tool_find("local_tool"),
"trusted workspace plugin loads");
run(ws, "local_tool", NULL, NULL, NULL, NULL, &r);
CHECK(r.exit_code == 0 && r.out && strstr(r.out, "local"), "local tool");
cst_tool_result_free(&r);
cst_plugins_unload();
cst_mcp_stop_all();
CHECK(cst_settings_trust(ws, 0) == 0 && !cst_settings_trusted(ws),
"untrust saved");
/* extensions: the minimal profile loads nothing */
cst_agent_config_t cfg;
memset(&cfg, 0, sizeof(cfg));
snprintf(cfg.workspace_root, sizeof(cfg.workspace_root), "%s", ws);
cfg.tool_profile = CST_TOOLS_MINIMAL;
char rep[256];
cst_extensions_load(&cfg, rep, sizeof(rep));
CHECK(!rep[0] && !cst_tool_find("echo_args"), "minimal: no extensions");
cfg.tool_profile = CST_TOOLS_DEFAULT;
cst_extensions_load(&cfg, rep, sizeof(rep));
CHECK(strstr(rep, "1 skill") && strstr(rep, "1 plugin (4 tools)") &&
strstr(rep, "untrusted"),
"extensions report");
CHECK(cst_tool_find("skill") && cst_tool_find("echo_args"),
"extensions register tools");
cst_extensions_unload();
CHECK(!cst_tool_find("skill") && !cst_tool_find("echo_args"),
"extensions unload");
char cmd[400];
snprintf(cmd, sizeof(cmd), "rm -rf %s", g_root);
if (system(cmd) != 0)
fprintf(stderr, "note: cleanup failed\n");
if (nfail) {
fprintf(stderr, "test_plugins: %d failure(s)\n", nfail);
return 1;
}
printf("test_plugins: OK\n");
return 0;
}
tests/test_registry.c
+96 -1
View File
@@ -28,7 +28,102 @@ static int schema_has(cJSON *arr, const char *name) {
return 0;
}
static int echo_run(const cst_tool_ctx_t *ctx, const ctl_tool_call_t *c,
cst_tool_result_t *r, void *ud) {
(void)ctx;
const cst_tool_def_t *self = ud;
char *j = cst_tool_args_json(self, c);
r->out = j;
r->out_len = j ? strlen(j) : 0;
r->exit_code = 0;
return 0;
}
static void dynamic_tools(void) {
cst_agent_config_t cfg;
memset(&cfg, 0, sizeof(cfg));
int base = cst_tool_count();
cst_tool_def_t d;
memset(&d, 0, sizeof(d));
d.name = "dyn_echo";
d.desc = "Echo the arguments.";
d.schema_json = "{\"type\":\"object\",\"properties\":{\"text\":{"
"\"type\":\"string\"},\"n\":{\"type\":\"integer\"},"
"\"opts\":{\"type\":\"object\"}},\"required\":[\"text\"]}";
d.perm = CST_TP_READ;
d.run_ex = echo_run;
d.owner = "test:echo";
EXPECT(cst_tool_register(&d) == 0, "register");
EXPECT(cst_tool_register(&d) != 0, "duplicate name refused");
EXPECT(cst_tool_count() == base + 1, "count grows");
const cst_tool_def_t *t = cst_tool_find("dyn_echo");
EXPECT(t && t != &d && strcmp(t->owner, "test:echo") == 0, "copied def");
/* the runner gets its own def as ud for typing */
((cst_tool_def_t *)t)->ud = (void *)t;
cJSON *sc = cst_tools_schema_cfg(&cfg);
char *ss = cJSON_PrintUnformatted(sc);
EXPECT(ss && strstr(ss, "\"name\":\"dyn_echo\"") &&
strstr(ss, "\"required\":[\"text\"]"),
"schema passes the JSON Schema through");
free(ss);
cJSON_Delete(sc);
char *pr = cst_tools_prompt(&cfg);
EXPECT(pr && strstr(pr, "- dyn_echo(text, n?, opts?): Echo the arguments."),
"text prompt lists schema params");
free(pr);
ctl_tool_call_t c;
memset(&c, 0, sizeof(c));
snprintf(c.name, sizeof(c.name), "dyn_echo");
cst_tool_ctx_t ctx;
memset(&ctx, 0, sizeof(ctx));
cst_tool_result_t r;
memset(&r, 0, sizeof(r));
cst_tool_run(&ctx, &c, &r);
EXPECT(r.exit_code == 1 && r.out && strstr(r.out, "needs argument \"text\""),
"schema required checked");
cst_tool_result_free(&r);
c.nargs = 3;
snprintf(c.args[0].key, sizeof(c.args[0].key), "text");
c.args[0].value = "42";
c.args[0].value_len = 2;
snprintf(c.args[1].key, sizeof(c.args[1].key), "n");
c.args[1].value = "7";
c.args[1].value_len = 1;
snprintf(c.args[2].key, sizeof(c.args[2].key), "opts");
c.args[2].value = "{\"a\":true}";
c.args[2].value_len = strlen(c.args[2].value);
memset(&r, 0, sizeof(r));
cst_tool_run(&ctx, &c, &r);
EXPECT(r.exit_code == 0 && r.out &&
strcmp(r.out, "{\"text\":\"42\",\"n\":7,\"opts\":{\"a\":true}}") == 0,
"args typed by schema");
cst_tool_result_free(&r);
cst_tool_set_disabled(&cfg, "dyn_echo", 1);
cst_tool_set_disabled(&cfg, "grep", 1);
EXPECT(!cst_tool_active(&cfg, t) &&
!cst_tool_active(&cfg, cst_tool_find("grep")),
"disable by name");
cst_tool_set_disabled(&cfg, "dyn_echo", 0);
EXPECT(cst_tool_active(&cfg, t) &&
!cst_tool_active(&cfg, cst_tool_find("grep")),
"re-enable one name");
cst_tool_set_disabled(&cfg, "grep", 0);
EXPECT(cfg.tools_off[0] == 0, "set empties");
char nm[64];
cst_tool_sanitize_name("mcp__my server__do.it", nm, sizeof(nm));
EXPECT(strcmp(nm, "mcp__my_server__do_it") == 0, "sanitize");
EXPECT(cst_tool_unregister_owner("test:echo") == 1 &&
!cst_tool_find("dyn_echo") && cst_tool_count() == base,
"unregister by owner");
}
int main(void) {
dynamic_tools();
cst_agent_config_t cfg;
memset(&cfg, 0, sizeof(cfg));
@@ -85,7 +180,7 @@ int main(void) {
free(pdef);
/* /tools off: grep disappears everywhere */
cfg.tools_off = 1ULL << cst_tool_index("grep");
cst_tool_set_disabled(&cfg, "grep", 1);
EXPECT(!cst_tool_active(&cfg, cst_tool_find("grep")), "grep off");
cJSON *off = cst_tools_schema_cfg(&cfg);
EXPECT(!schema_has(off, "grep") && schema_has(off, "glob"), "schema off");
tests/test_shell_compact.c
+116
View File
@@ -0,0 +1,116 @@
/* cst_shell_compact: ANSI stripping, \r progress folding, repeated-line
* collapse and head/tail cutting of run_shell output. */
#include "cst_tools.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
static int nfail;
#define CHECK(cond, msg) \
do { \
if (!(cond)) { \
fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, msg); \
nfail++; \
} \
} while (0)
static char *compact(const char *s) {
size_t n = 0;
return cst_shell_compact(s, strlen(s), &n);
}
int main(void) {
char *o;
o = compact("plain\noutput\n");
CHECK(o && strcmp(o, "plain\noutput\n") == 0, "clean output unchanged");
free(o);
o = compact("no newline");
CHECK(o && strcmp(o, "no newline") == 0, "missing final newline kept");
free(o);
o = compact("");
CHECK(o && strcmp(o, "") == 0, "empty");
free(o);
o = compact("a\n\nb\n");
CHECK(o && strcmp(o, "a\n\nb\n") == 0, "blank lines kept");
free(o);
o = compact("\x1b[1;31merror\x1b[0m: bad\n\x1b]0;title\x07ok\n");
CHECK(o && strcmp(o, "error: bad\nok\n") == 0, "ANSI CSI and OSC removed");
free(o);
o = compact(" 0%\r 50%\r100%\ndone\r\n");
CHECK(o && strcmp(o, "100%\ndone\n") == 0, "\\r progress folded, CRLF ok");
free(o);
o = compact("ab\bc\n");
CHECK(o && strcmp(o, "ac\n") == 0, "backspace applied");
free(o);
o = compact("x\nx\ny\n");
CHECK(o && strcmp(o, "x\nx\ny\n") == 0, "a pair is kept as is");
free(o);
o = compact("start\nwarn\nwarn\nwarn\nwarn\nend\n");
CHECK(o && strcmp(o, "start\nwarn\n… (previous line repeated 3 more "
"times)\nend\n") == 0,
"runs collapsed");
free(o);
{
char *big = malloc(1000 * 16);
size_t used = 0;
for (int i = 1; i <= 1000; i++)
used += (size_t)sprintf(big + used, "line %d\n", i);
o = compact(big);
CHECK(o && strstr(o, "line 1\n") && strstr(o, "line 80\n") &&
!strstr(o, "line 81\n") && strstr(o, "… 800 lines omitted …\n") &&
strstr(o, "line 881\n") && strstr(o, "line 1000\n"),
"head + tail with omitted count");
free(o);
free(big);
}
{
char *wide = malloc(5000 + 2);
memset(wide, 'w', 5000);
wide[5000] = '\n';
wide[5001] = 0;
o = compact(wide);
CHECK(o && strstr(o, " … [+3000 bytes]\n") && strlen(o) < 2100,
"long line cut");
free(o);
free(wide);
}
{
/* 200 lines of 1 KB: over the byte budget, the tail wins */
char *fat = malloc(200 * 1030);
size_t used = 0;
for (int i = 1; i <= 200; i++) {
used += (size_t)sprintf(fat + used, "%04d ", i);
memset(fat + used, 'f', 1000);
used += 1000;
fat[used++] = '\n';
}
fat[used] = 0;
o = compact(fat);
CHECK(o && strlen(o) <= 42 * 1024 && strstr(o, "0200 ") &&
strstr(o, "lines omitted"),
"byte budget keeps the tail");
free(o);
free(fat);
}
if (nfail) {
fprintf(stderr, "test_shell_compact: %d failure(s)\n", nfail);
return 1;
}
printf("test_shell_compact: OK\n");
return 0;
}
tests/test_skills.c
+193
View File
@@ -0,0 +1,193 @@
/* Skills: frontmatter, discovery order, prompt index, the skill tool and
* path containment. */
#define _POSIX_C_SOURCE 200809L
#include "cst_agent.h"
#include "cst_skills.h"
#include "cst_tools.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
static int nfail;
#define CHECK(cond, msg) \
do { \
if (!(cond)) { \
fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, msg); \
nfail++; \
} \
} while (0)
static char g_root[256];
static void put(const char *rel, const char *text) {
char p[512];
snprintf(p, sizeof(p), "%s/%s", g_root, rel);
for (char *q = p + strlen(g_root) + 1; *q; q++) {
if (*q == '/') {
*q = 0;
mkdir(p, 0755);
*q = '/';
}
}
FILE *fp = fopen(p, "w");
if (fp) {
fputs(text, fp);
fclose(fp);
}
}
static void frontmatter(void) {
char v[256];
const char *t = "---\nname: \"pdf-tools\"\ndescription: >\n Fill PDF\n "
"forms.\ntools: [read_file, grep ]\nmodel: deepseek-pro\n"
"list:\n - a\n - b\nlit: |\n one\n two\n---\n\n# Body\n";
CHECK(cst_fm_get(t, "name", v, sizeof(v)) && strcmp(v, "pdf-tools") == 0,
"quoted value");
CHECK(cst_fm_get(t, "description", v, sizeof(v)) &&
strcmp(v, "Fill PDF forms.") == 0,
"folded value");
CHECK(cst_fm_get(t, "tools", v, sizeof(v)) &&
strcmp(v, "read_file,grep") == 0,
"flow list");
CHECK(cst_fm_get(t, "list", v, sizeof(v)) && strcmp(v, "a,b") == 0,
"block list");
CHECK(cst_fm_get(t, "lit", v, sizeof(v)) && strcmp(v, "one\ntwo") == 0,
"literal block");
CHECK(!cst_fm_get(t, "nope", v, sizeof(v)), "missing key");
CHECK(strcmp(cst_fm_body(t), "# Body\n") == 0, "body after fence");
CHECK(strcmp(cst_fm_body("no frontmatter\n"), "no frontmatter\n") == 0,
"no frontmatter: whole text");
CHECK(!cst_fm_get("---\nname: x\n", "name", v, sizeof(v)),
"unclosed frontmatter ignored");
}
int main(void) {
frontmatter();
snprintf(g_root, sizeof(g_root), "/tmp/cst-skills-%d", (int)getpid());
mkdir(g_root, 0755);
char ws[300], cfgdir[300];
snprintf(ws, sizeof(ws), "%s/ws", g_root);
snprintf(cfgdir, sizeof(cfgdir), "%s/cfg", g_root);
setenv("XDG_CONFIG_HOME", cfgdir, 1);
put("ws/.agent/skills/zeta/SKILL.md",
"---\nname: zeta\ndescription: Last one alphabetically.\n---\nDo Z.\n");
put("ws/.agent/skills/forms/SKILL.md",
"---\nname: pdf-forms\ndescription: Fill PDF forms with the bundled "
"script.\n---\n# PDF forms\n\nRun scripts/fill.py.\n");
put("ws/.agent/skills/forms/scripts/fill.py", "print('fill')\n");
put("ws/.agent/skills/forms/reference.md", "Field names...\n");
put("ws/.claude/skills/plain/SKILL.md", "# Plain\n\nA skill without "
"frontmatter.\n");
put("cfg/cst-agent/skills/forms2/SKILL.md",
"---\nname: pdf-forms\ndescription: shadowed by the workspace\n---\n");
put("cfg/cst-agent/skills/userskill/SKILL.md",
"---\nname: user-skill\ndescription: From the config dir.\n---\nU\n");
put("ws/secret.txt", "top secret\n");
{
char link[512], target[512];
snprintf(link, sizeof(link), "%s/ws/.agent/skills/forms/leak", g_root);
snprintf(target, sizeof(target), "%s/ws/secret.txt", g_root);
if (symlink(target, link) != 0)
perror("symlink");
}
cst_skill_t v[CST_SKILLS_MAX];
int n = cst_skills_list(ws, v, CST_SKILLS_MAX);
CHECK(n == 4, "four distinct skills");
CHECK(n == 4 && strcmp(v[0].name, "pdf-forms") == 0 &&
strcmp(v[1].name, "plain") == 0 &&
strcmp(v[2].name, "user-skill") == 0 &&
strcmp(v[3].name, "zeta") == 0,
"sorted by name");
CHECK(n == 4 && strcmp(v[0].source, "workspace") == 0 &&
strstr(v[0].desc, "bundled script"),
"workspace wins over the config dir");
CHECK(n == 4 && strcmp(v[1].source, "claude") == 0 &&
strcmp(v[1].desc, "A skill without frontmatter.") == 0,
".claude skill, description from the body");
char *ix = cst_skills_index(ws);
CHECK(ix && strstr(ix, "- pdf-forms: Fill PDF forms") &&
strstr(ix, "- zeta: Last one"),
"index lists name: description");
free(ix);
int code = -1;
char *out = cst_skill_read(ws, "pdf-forms", NULL, &code);
CHECK(code == 0 && out && strstr(out, "# PDF forms\n\nRun scripts/fill.py.") &&
!strstr(out, "description:"),
"SKILL.md body without frontmatter");
CHECK(out && strstr(out, "- reference.md\n") &&
strstr(out, "- scripts/fill.py\n"),
"file list");
free(out);
out = cst_skill_read(ws, "pdf-forms", "scripts/fill.py", &code);
CHECK(code == 0 && out && strstr(out, "print('fill')"), "read a skill file");
free(out);
out = cst_skill_read(ws, "pdf-forms", "../../../secret.txt", &code);
CHECK(code == 1 && out && !strstr(out, "top secret"), "no ../ escape");
free(out);
out = cst_skill_read(ws, "pdf-forms", "leak", &code);
CHECK(code == 1 && out && !strstr(out, "top secret"), "no symlink escape");
free(out);
out = cst_skill_read(ws, "missing", NULL, &code);
CHECK(code == 1 && out && strstr(out, "available: pdf-forms, plain"),
"unknown skill lists names");
free(out);
char *pr = cst_skill_prompt(ws, "zeta", "do the thing");
CHECK(pr && strstr(pr, "<skill>") && strstr(pr, "Do Z.") &&
strstr(pr, "do the thing"),
"/skill prompt inlines the instructions");
free(pr);
/* tool + system prompt */
CHECK(cst_skills_register_tool() == 0 && cst_tool_find("skill"),
"skill tool registered");
cst_agent_config_t cfg;
memset(&cfg, 0, sizeof(cfg));
snprintf(cfg.workspace_root, sizeof(cfg.workspace_root), "%s", ws);
ctl_tool_call_t c;
memset(&c, 0, sizeof(c));
snprintf(c.name, sizeof(c.name), "skill");
c.nargs = 1;
snprintf(c.args[0].key, sizeof(c.args[0].key), "name");
c.args[0].value = "user-skill";
c.args[0].value_len = strlen(c.args[0].value);
cst_tool_ctx_t ctx;
memset(&ctx, 0, sizeof(ctx));
ctx.workspace_root = ws;
cst_tool_result_t r;
memset(&r, 0, sizeof(r));
cst_tool_run(&ctx, &c, &r);
CHECK(r.exit_code == 0 && r.out && strstr(r.out, "skill user-skill (user)"),
"skill tool runs");
cst_tool_result_free(&r);
char *sp = cst_agent_build_prompt(&cfg, CST_PROTO_NATIVE_EOS, NULL);
CHECK(sp && strstr(sp, "Skills (call skill(name)") &&
strstr(sp, "- user-skill: From the config dir."),
"system prompt carries the index");
free(sp);
cfg.tool_profile = CST_TOOLS_MINIMAL;
sp = cst_agent_build_prompt(&cfg, CST_PROTO_NATIVE_EOS, NULL);
CHECK(sp && !strstr(sp, "Skills ("), "minimal prompt unchanged");
free(sp);
char cmd[400];
snprintf(cmd, sizeof(cmd), "rm -rf %s", g_root);
if (system(cmd) != 0)
fprintf(stderr, "note: cleanup failed\n");
if (nfail) {
fprintf(stderr, "test_skills: %d failure(s)\n", nfail);
return 1;
}
printf("test_skills: OK\n");
return 0;
}
tests/test_subagent.c
+484
View File
@@ -0,0 +1,484 @@
/* Sub-agents end to end against a local fake OpenAI-style SSE server: the
* parent calls task twice (explore, in parallel), each child reads a file
* and reports, the parent sees both reports. Also: tool restrictions in the
* child, progress hooks, transcripts, roles from .agent/agents, depth
* limit, unknown roles and cancellation. */
#define _POSIX_C_SOURCE 200809L
#ifndef _DEFAULT_SOURCE
#define _DEFAULT_SOURCE
#endif
#include "cJSON.h"
#include "cst_agent.h"
#include "cst_subagent.h"
#include "cst_tools.h"
#include "cst_util.h"
#include "os_compat.h"
#include <arpa/inet.h>
#include <curl/curl.h>
#include <netinet/in.h>
#include <pthread.h>
#include <signal.h>
#include <stdatomic.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <unistd.h>
static int nfail;
#define CHECK(cond, msg) \
do { \
if (!(cond)) { \
fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, msg); \
nfail++; \
} \
} while (0)
/* ---------- fake server ---------- */
static atomic_int g_child_active, g_child_max, g_child_reqs;
static atomic_int g_child_saw_task, g_child_saw_write, g_child_role_prompt;
static atomic_int g_parent_saw_task;
static void send_all(int fd, const char *s, size_t n) {
while (n > 0) {
ssize_t w = send(fd, s, n, MSG_NOSIGNAL);
if (w <= 0)
return;
s += w;
n -= (size_t)w;
}
}
static void sse(int fd, cJSON *delta, const char *finish) {
cJSON *o = cJSON_CreateObject();
cJSON *ch = cJSON_AddArrayToObject(o, "choices");
cJSON *c0 = cJSON_CreateObject();
cJSON_AddNumberToObject(c0, "index", 0);
cJSON_AddItemToObject(c0, "delta", delta);
if (finish)
cJSON_AddStringToObject(c0, "finish_reason", finish);
else
cJSON_AddNullToObject(c0, "finish_reason");
cJSON_AddItemToArray(ch, c0);
if (finish) {
cJSON *u = cJSON_AddObjectToObject(o, "usage");
cJSON_AddNumberToObject(u, "prompt_tokens", 1200);
cJSON_AddNumberToObject(u, "completion_tokens", 20);
}
char *txt = cJSON_PrintUnformatted(o);
char *line = malloc(strlen(txt) + 16);
int n = sprintf(line, "data: %s\n\n", txt);
send_all(fd, line, (size_t)n);
free(line);
free(txt);
cJSON_Delete(o);
}
static void reply_text(int fd, const char *text) {
cJSON *d = cJSON_CreateObject();
cJSON_AddStringToObject(d, "role", "assistant");
cJSON_AddStringToObject(d, "content", text);
sse(fd, d, NULL);
sse(fd, cJSON_CreateObject(), "stop");
send_all(fd, "data: [DONE]\n\n", 14);
}
/* calls: {name, args_json} pairs */
static void reply_calls(int fd, const char *const *calls, int n) {
for (int i = 0; i < n; i++) {
cJSON *d = cJSON_CreateObject();
cJSON *tc = cJSON_AddArrayToObject(d, "tool_calls");
cJSON *c = cJSON_CreateObject();
cJSON_AddNumberToObject(c, "index", i);
char id[16];
snprintf(id, sizeof(id), "call_%d", i);
cJSON_AddStringToObject(c, "id", id);
cJSON_AddStringToObject(c, "type", "function");
cJSON *f = cJSON_AddObjectToObject(c, "function");
cJSON_AddStringToObject(f, "name", calls[2 * i]);
cJSON_AddStringToObject(f, "arguments", calls[2 * i + 1]);
cJSON_AddItemToArray(tc, c);
sse(fd, d, NULL);
}
sse(fd, cJSON_CreateObject(), "tool_calls");
send_all(fd, "data: [DONE]\n\n", 14);
}
static int has_tool(const cJSON *body, const char *name) {
const cJSON *t = NULL;
cJSON_ArrayForEach(t, cJSON_GetObjectItemCaseSensitive(body, "tools")) {
const cJSON *f = cJSON_GetObjectItemCaseSensitive(t, "function");
const cJSON *n = cJSON_GetObjectItemCaseSensitive(f, "name");
if (cJSON_IsString(n) && strcmp(n->valuestring, name) == 0)
return 1;
}
return 0;
}
static void handle(int fd, const char *body_txt) {
cJSON *body = cJSON_Parse(body_txt);
const cJSON *msgs = cJSON_GetObjectItemCaseSensitive(body, "messages");
int nm = cJSON_GetArraySize(msgs);
const cJSON *sys = cJSON_GetObjectItemCaseSensitive(
cJSON_GetArrayItem(msgs, 0), "content");
const cJSON *last = cJSON_GetArrayItem(msgs, nm - 1);
const char *last_role =
cJSON_GetObjectItemCaseSensitive(last, "role")->valuestring;
const char *user = "";
for (int i = 0; i < nm; i++) {
const cJSON *m = cJSON_GetArrayItem(msgs, i);
const cJSON *r = cJSON_GetObjectItemCaseSensitive(m, "role");
const cJSON *c = cJSON_GetObjectItemCaseSensitive(m, "content");
if (strcmp(r->valuestring, "user") == 0 && cJSON_IsString(c))
user = c->valuestring;
}
const char *hdr = "HTTP/1.1 200 OK\r\nContent-Type: text/event-stream\r\n"
"Connection: close\r\n\r\n";
send_all(fd, hdr, strlen(hdr));
int child = cJSON_IsString(sys) && strstr(sys->valuestring, "SUB-AGENT");
if (child) {
atomic_fetch_add(&g_child_reqs, 1);
int now = atomic_fetch_add(&g_child_active, 1) + 1;
int mx = atomic_load(&g_child_max);
while (now > mx && !atomic_compare_exchange_weak(&g_child_max, &mx, now))
;
if (has_tool(body, "task"))
atomic_store(&g_child_saw_task, 1);
if (has_tool(body, "write_file") || has_tool(body, "run_shell"))
atomic_store(&g_child_saw_write, 1);
if (strstr(sys->valuestring, "Role instructions:\nYou only read."))
atomic_store(&g_child_role_prompt, 1);
if (strstr(user, "Slow")) {
usleep(4000 * 1000); /* cancelled before this ends */
} else {
usleep(300 * 1000);
}
if (strcmp(last_role, "user") == 0) {
const char *calls[] = {"read_file", "{\"path\":\"a.txt\"}"};
reply_calls(fd, calls, 1);
} else {
char out[256];
snprintf(out, sizeof(out), "child report %s", user + strlen(user) - 1);
reply_text(fd, out);
}
atomic_fetch_sub(&g_child_active, 1);
} else {
if (has_tool(body, "task"))
atomic_store(&g_parent_saw_task, 1);
if (strcmp(last_role, "user") == 0 && strstr(user, "cancel test")) {
const char *calls[] = {
"task", "{\"description\":\"slow one\",\"prompt\":\"Slow\","
"\"agent\":\"explore\"}"};
reply_calls(fd, calls, 1);
} else if (strcmp(last_role, "user") == 0) {
const char *calls[] = {
"task",
"{\"description\":\"find A\",\"prompt\":\"Find A\","
"\"agent\":\"explore\"}",
"task",
"{\"description\":\"find B\",\"prompt\":\"Find B\","
"\"agent\":\"explore\"}"};
reply_calls(fd, calls, 2);
} else {
cst_buf_t b = {0};
cst_buf_puts(&b, "parent done:");
for (int i = 0; i < nm; i++) {
const cJSON *m = cJSON_GetArrayItem(msgs, i);
const cJSON *r = cJSON_GetObjectItemCaseSensitive(m, "role");
const cJSON *c = cJSON_GetObjectItemCaseSensitive(m, "content");
const char *rep = cJSON_IsString(c) ? strstr(c->valuestring,
"child report ")
: NULL;
if (strcmp(r->valuestring, "tool") == 0 && rep)
cst_buf_printf(&b, " [%.14s]", rep);
}
reply_text(fd, b.buf);
cst_buf_free(&b);
}
}
cJSON_Delete(body);
}
static void *conn_main(void *p) {
int fd = (int)(intptr_t)p;
cst_buf_t req = {0};
char tmp[8192];
long need = -1;
size_t hdr_end = 0;
for (;;) {
ssize_t n = recv(fd, tmp, sizeof(tmp), 0);
if (n <= 0)
break;
cst_buf_append(&req, tmp, (size_t)n);
if (!hdr_end) {
char *e = strstr(req.buf, "\r\n\r\n");
if (e) {
hdr_end = (size_t)(e - req.buf) + 4;
char *cl = strcasestr(req.buf, "Content-Length:");
need = cl ? atol(cl + 15) : 0;
}
}
if (hdr_end && (long)(req.len - hdr_end) >= need)
break;
}
if (hdr_end)
handle(fd, req.buf + hdr_end);
cst_buf_free(&req);
close(fd);
return NULL;
}
static int g_lfd;
static void *server_main(void *p) {
(void)p;
for (;;) {
int fd = accept(g_lfd, NULL, NULL);
if (fd < 0)
return NULL;
pthread_t th;
if (pthread_create(&th, NULL, conn_main, (void *)(intptr_t)fd) == 0)
pthread_detach(th);
else
close(fd);
}
}
/* ---------- client ---------- */
static atomic_int g_progress;
static char g_progress_last[256];
static void on_tool_event(const char *phase, const ctl_tool_call_t *call,
const char *detail, void *ud) {
(void)call;
(void)ud;
if (strcmp(phase, "progress") == 0 && detail) {
atomic_fetch_add(&g_progress, 1);
if (strstr(detail, "read_file"))
snprintf(g_progress_last, sizeof(g_progress_last), "%s", detail);
}
}
static const char *last_assistant(cst_agent_t *a) {
cst_session_t *s = cst_agent_session(a);
for (int i = cst_session_count(s) - 1; i >= 0; i--) {
const cst_message_t *m = cst_session_get(s, i);
if (m->role == CST_ROLE_ASSISTANT && m->content && m->content[0])
return m->content;
}
return "";
}
static void put(const char *root, const char *rel, const char *text) {
char p[1024];
snprintf(p, sizeof(p), "%s/%s", root, rel);
for (char *q = p + strlen(root) + 1; *q; q++)
if (*q == '/') {
*q = 0;
mkdir(p, 0755);
*q = '/';
}
FILE *fp = fopen(p, "w");
if (fp) {
fputs(text, fp);
fclose(fp);
}
}
static void *cancel_later(void *p) {
usleep(800 * 1000);
cst_agent_request_cancel(p);
return NULL;
}
int main(void) {
signal(SIGPIPE, SIG_IGN);
curl_global_init(CURL_GLOBAL_DEFAULT);
g_lfd = socket(AF_INET, SOCK_STREAM, 0);
struct sockaddr_in addr;
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
socklen_t al = sizeof(addr);
if (bind(g_lfd, (struct sockaddr *)&addr, sizeof(addr)) != 0 ||
listen(g_lfd, 16) != 0 ||
getsockname(g_lfd, (struct sockaddr *)&addr, &al) != 0) {
perror("listen");
return 1;
}
pthread_t srv;
pthread_create(&srv, NULL, server_main, NULL);
char root[256], ws[300];
snprintf(root, sizeof(root), "/tmp/cst-sub-%d", (int)getpid());
snprintf(ws, sizeof(ws), "%s/ws", root);
mkdir(root, 0755);
setenv("XDG_CONFIG_HOME", root, 1);
put(root, "ws/a.txt", "alpha\n");
put(root, "ws/.agent/agents/reviewer.md",
"---\nname: reviewer\ndescription: Reviews diffs.\ntools: read_file, "
"grep\nreadonly: true\nmax_steps: 4\n---\nReview carefully.\n");
put(root, "ws/.agent/agents/explore.md",
"---\ndescription: Custom explorer.\nreadonly: yes\n---\nYou only "
"read. Custom.\n");
put(root, "ws/.agent/sessions/.keep", "");
/* roles */
cst_agent_role_t roles[CST_ROLES_MAX];
int nr = cst_roles_list(ws, roles, CST_ROLES_MAX);
CHECK(nr == 4, "three built-ins + reviewer (explore overridden)");
CHECK(nr == 4 && strcmp(roles[0].name, "general") == 0 &&
strcmp(roles[3].name, "reviewer") == 0 &&
strcmp(roles[3].tools, ",read_file,grep,") == 0 &&
roles[3].read_only && roles[3].max_steps == 4 &&
strcmp(roles[3].prompt, "Review carefully.\n") == 0,
"custom role parsed");
CHECK(nr == 4 && strcmp(roles[1].name, "explore") == 0 &&
strcmp(roles[1].source, "workspace") == 0 &&
strcmp(roles[1].desc, "Custom explorer.") == 0,
"workspace overrides a built-in");
cst_roles_free(roles, nr);
char *ix = cst_subagent_index(ws);
CHECK(ix && strstr(ix, "- reviewer (read-only): Reviews diffs.") &&
strstr(ix, "- general: "),
"roles index");
free(ix);
CHECK(cst_subagent_register_tool(ws) == 0 && cst_tool_find("task"),
"task registered");
const cst_tool_def_t *td = cst_tool_find("task");
ctl_tool_call_t pc;
memset(&pc, 0, sizeof(pc));
snprintf(pc.name, sizeof(pc.name), "task");
pc.nargs = 1;
snprintf(pc.args[0].key, sizeof(pc.args[0].key), "agent");
pc.args[0].value = "explore";
CHECK(td->parallel && td->parallel(&pc, td->ud), "explore runs in parallel");
pc.args[0].value = "general";
CHECK(!td->parallel(&pc, td->ud), "general does not");
pc.args[0].value = "reviewer";
CHECK(td->parallel(&pc, td->ud), "read-only custom role does");
/* parent agent */
cst_agent_config_t cfg;
memset(&cfg, 0, sizeof(cfg));
snprintf(cfg.workspace_root, sizeof(cfg.workspace_root), "%s", ws);
snprintf(cfg.session_path, sizeof(cfg.session_path),
"%s/.agent/sessions/parent1.jsonl", ws);
snprintf(cfg.api_base, sizeof(cfg.api_base), "http://127.0.0.1:%d",
ntohs(addr.sin_port));
snprintf(cfg.model, sizeof(cfg.model), "m");
cfg.protocol = CST_PROTO_NATIVE_EOS;
cfg.max_steps = 6;
cfg.auto_approve = 1;
cst_agent_t *a = cst_agent_create(&cfg);
CHECK(a != NULL, "parent created");
cst_agent_hooks_t h;
memset(&h, 0, sizeof(h));
h.on_tool_event = on_tool_event;
char err[512];
double t0 = os_now_ms();
int rc = cst_agent_run_turn_ex(a, "go", &h, err, sizeof(err));
double ms = os_now_ms() - t0;
CHECK(rc == 0, err);
const char *fin = last_assistant(a);
CHECK(strstr(fin, "[child report A") && strstr(fin, "[child report B"),
"parent got both reports");
CHECK(atomic_load(&g_parent_saw_task), "parent offered task");
CHECK(!atomic_load(&g_child_saw_task), "child not offered task");
CHECK(!atomic_load(&g_child_saw_write), "explore child has no write/shell");
CHECK(atomic_load(&g_child_role_prompt), "role instructions in the prompt");
CHECK(atomic_load(&g_child_max) == 2, "two children ran at once");
CHECK(atomic_load(&g_child_reqs) == 4, "two model calls per child");
CHECK(ms < 2400, "parallel children overlap in time");
CHECK(atomic_load(&g_progress) >= 4 &&
strstr(g_progress_last, "explore · read_file a.txt"),
"progress events");
cst_subagent_rec_t recs[8];
int nrec = cst_subagent_list(ws, "parent1", recs, 8);
CHECK(nrec == 2 && strcmp(recs[0].file, "sub-2") == 0 &&
strcmp(recs[0].status, "done") == 0 && recs[0].steps == 2 &&
recs[0].tools == 1 && strcmp(recs[0].role, "explore") == 0,
"transcript records");
char tp[1024];
CHECK(cst_subagent_path(ws, "parent1", "sub-1", tp, sizeof(tp)) == 0 &&
access(tp, F_OK) == 0,
"transcript file");
char ids[8][128];
int nids = cst_agent_store_list(ws, ids, 8);
CHECK(nids == 1 && strcmp(ids[0], "parent1") == 0,
"sub-agent transcripts are not sessions");
/* direct calls: unknown role, depth limit */
cst_tool_ctx_t ctx;
memset(&ctx, 0, sizeof(ctx));
ctx.workspace_root = ws;
ctx.agent = a;
ctl_tool_call_t c;
memset(&c, 0, sizeof(c));
snprintf(c.name, sizeof(c.name), "task");
c.nargs = 3;
snprintf(c.args[0].key, sizeof(c.args[0].key), "description");
c.args[0].value = "x";
snprintf(c.args[1].key, sizeof(c.args[1].key), "prompt");
c.args[1].value = "y";
snprintf(c.args[2].key, sizeof(c.args[2].key), "agent");
c.args[2].value = "nobody";
for (int i = 0; i < 3; i++)
c.args[i].value_len = strlen(c.args[i].value);
cst_tool_result_t r;
memset(&r, 0, sizeof(r));
cst_tool_run(&ctx, &c, &r);
CHECK(r.exit_code == 1 && r.out &&
strstr(r.out, "available: general, explore, plan, reviewer"),
"unknown role lists the roles");
cst_tool_result_free(&r);
cst_agent_config_mut(a)->depth = 1;
c.args[2].value = "explore";
c.args[2].value_len = 7;
memset(&r, 0, sizeof(r));
cst_tool_run(&ctx, &c, &r);
CHECK(r.exit_code == 1 && r.out && strstr(r.out, "cannot start sub-agents"),
"depth limit");
cst_tool_result_free(&r);
CHECK(!cst_tool_active(cst_agent_config(a), td), "task hidden at depth 1");
cst_agent_config_mut(a)->depth = 0;
/* cancelling the parent stops the child */
pthread_t cth;
pthread_create(&cth, NULL, cancel_later, a);
t0 = os_now_ms();
rc = cst_agent_run_turn_ex(a, "cancel test", &h, err, sizeof(err));
ms = os_now_ms() - t0;
pthread_join(cth, NULL);
CHECK(rc != 0 && ms < 3500, "cancel reaches the child");
nrec = cst_subagent_list(ws, "parent1", recs, 8);
CHECK(nrec == 3 && strcmp(recs[0].status, "cancelled") == 0,
"cancelled run recorded");
cst_agent_destroy(a);
cst_tool_unregister_owner("builtin:task");
CHECK(cst_agent_store_delete(ws, "parent1") == 0, "delete session");
CHECK(cst_subagent_list(ws, "parent1", recs, 8) == 0,
"delete removes sub-agent transcripts");
char cmd[400];
snprintf(cmd, sizeof(cmd), "rm -rf %s", root);
if (system(cmd) != 0)
fprintf(stderr, "note: cleanup failed\n");
close(g_lfd);
if (nfail) {
fprintf(stderr, "test_subagent: %d failure(s)\n", nfail);
return 1;
}
printf("test_subagent: OK\n");
return 0;
}
tests/test_tools_fs.c
+55 -4
View File
@@ -167,6 +167,45 @@ int main(void) {
"missing required arg");
reset(&r);
/* compact read_file (default profile) */
ctx.compact = 1;
EXPECT(run(&ctx, mk("read_file", "path", "src/notes.txt", NULL), &r) == 0 &&
strcmp(r.out, "src/notes.txt · 1 line\n1|TODO: x\n") == 0,
"compact read: header + numbers");
reset(&r);
EXPECT(run(&ctx, mk("read_file", "path", "lines.txt", "offset", "10",
"limit", "3", NULL),
&r) == 0 &&
strstr(r.out, "lines.txt · lines 10-12 of 100\n10|line 10\n") ==
r.out &&
strstr(r.out, "… 88 more lines; continue with offset=13"),
"compact slice header and continuation");
reset(&r);
EXPECT(run(&ctx, mk("read_file", "path", "src/notes.txt", "line_numbers",
"false", NULL),
&r) == 0 &&
strstr(r.out, "\nTODO: x\n") && !strstr(r.out, "1|"),
"compact read without numbers");
reset(&r);
{
char big[5000];
memset(big, 'a', sizeof(big) - 2);
big[sizeof(big) - 2] = '\n';
big[sizeof(big) - 1] = 0;
wfile("long.txt", big);
EXPECT(run(&ctx, mk("read_file", "path", "long.txt", NULL), &r) == 0 &&
strstr(r.out, "[line cut, +2998 bytes]") &&
strstr(r.out, "1 long line cut"),
"compact read cuts long lines");
reset(&r);
}
wfile("empty.txt", "");
EXPECT(run(&ctx, mk("read_file", "path", "empty.txt", NULL), &r) == 0 &&
strstr(r.out, "empty file"),
"compact read of an empty file");
reset(&r);
ctx.compact = 0;
/* list_dir */
EXPECT(run(&ctx, mk("list_dir", NULL), &r) == 0, "list_dir ok");
EXPECT(r.out && strstr(r.out, "src/") && strstr(r.out, " main.c"),
@@ -180,6 +219,8 @@ int main(void) {
EXPECT(run(&ctx, mk("list_dir", "path", "src", "depth", "1", NULL), &r) == 0 &&
strstr(r.out, "deep/") && !strstr(r.out, "util.c"),
"list_dir depth");
EXPECT(r.out && strstr(r.out, "deep/ (1 entry)"),
"list_dir counts entries at the depth limit");
reset(&r);
/* glob */
@@ -205,20 +246,22 @@ int main(void) {
/* grep */
EXPECT(run(&ctx, mk("grep", "pattern", "int add", NULL), &r) == 0, "grep ok");
EXPECT(r.out && strstr(r.out, "src/deep/util.c:1:int add"), "grep hit");
EXPECT(r.out && strstr(r.out, "src/deep/util.c\n1:int add"), "grep hit grouped");
EXPECT(r.out && strncmp(r.out, "1 match in 1 file\n", 18) == 0,
"grep summary first");
EXPECT(r.out && !strstr(r.out, "junk.c") && !strstr(r.out, "run.log"),
"grep skips node_modules and ignored files");
reset(&r);
EXPECT(run(&ctx, mk("grep", "pattern", "x = \\d+", "glob", "*.c", NULL),
&r) == 0 &&
strstr(r.out, "src/main.c:3:"),
strstr(r.out, "src/main.c\n3:"),
"grep translates \\d");
reset(&r);
EXPECT(run(&ctx, mk("grep", "pattern", "RETURN", "ignore_case", "true",
"path", "src/main.c", "context", "1", NULL),
&r) == 0 &&
strstr(r.out, "src/main.c:5: return 0;") &&
strstr(r.out, "src/main.c-4-") && strstr(r.out, "src/main.c-6-"),
strstr(r.out, "\n5: return 0;") && strstr(r.out, "\n4-") &&
strstr(r.out, "\n6-"),
"grep single file, icase, context");
reset(&r);
EXPECT(run(&ctx, mk("grep", "pattern", "(", NULL), &r) == 1 &&
@@ -241,11 +284,19 @@ int main(void) {
strstr(r.out, "not found"),
"edit not found");
reset(&r);
EXPECT(run(&ctx, mk("edit_file", "path", "src/main.c", "old_string",
"int main(void) {\n int x = 7;", "new_string", "y",
NULL),
&r) == 1 &&
strstr(r.out, "appears (whitespace aside) at line 2"),
"edit not found points at the near line");
reset(&r);
EXPECT(run(&ctx, mk("edit_file", "path", "src/deep/util.c", "old_string",
"int a, int b", "new_string", "long a, long b", NULL),
&r) == 1 &&
strstr(r.out, "matches 2 places"),
"edit ambiguous");
EXPECT(r.out && strstr(r.out, "(lines 1, 2)"), "edit ambiguous lines");
reset(&r);
EXPECT(run(&ctx, mk("edit_file", "path", "src/deep/util.c", "old_string",
"int a, int b", "new_string", "long a, long b",