WHC
2a43ae6622
Build
* cross build switches to pkgsCross.ucrt64 (shell-win.nix); curl (Schannel),
winpthreads and ncurses 6.6 are linked statically, so the release is
cst-agent.exe + busybox.exe (busybox-w32 Unicode) with no extra DLLs
* windres embeds a manifest with activeCodePage=UTF-8 and a version resource
* ncurses 6.6 Windows console driver patches (mouse button state, A_DIM,
wide-char declarations): scripts/patches/
* scripts/bootstrap_msys2.sh builds the same release natively in MSYS2
UCRT64; PR #1's MINGW64 notes now point there
* vendor/tre-regex (musl's TRE) provides <regex.h> on MinGW
UTF-8
* paths cross the system call boundary as UTF-16 (*W APIs); console code
pages set to 65001 and restored on exit; files are read and written in
binary mode
* child output that is not valid UTF-8 is decoded from the console, OEM or
ANSI system code page
* read_file hides CR; edit_file, apply_patch and write_file keep CRLF line
endings and a UTF-8 BOM
OS layer and processes
* os_dir_* and cst_fnmatch replace the POSIX-only directory walks in
subagent, plugins, skills, undo and fs_tools; realpath / path_under and
symlink rejection work on Windows
* every child goes through CreateProcessW with its own environment block
inside a Job Object, so timeouts and Esc end the whole process tree
Sandbox (auto mode, "auto · lowil")
* run_shell runs with a restricted Low integrity token; the workspace gets
an inheritable Low label once, the sandbox TEMP is labeled Low, and the
credentials file gets a no-read-up label
* drive roots, the profile and system folders are never labeled
* network commands still ask, since Low IL does not block the network;
Access denied and MSYS2's 0xc0000142 offer a rerun outside the sandbox
* /sandbox lists labeled folders, /sandbox reset-labels restores them
TUI
* raster console fonts are switched to Consolas / NSimSun while running
* the home logo falls back to text when the console font lacks U+2580
* mouse drag copy goes to the Windows clipboard
Distribution
* scripts/install_windows.ps1 installs a Gitea release into
%LOCALAPPDATA%\Programs\cst-agent and adds it to the user PATH;
cst-agent-update.cmd reruns it; scripts/release_windows.sh uploads the
zip with the token taken from the environment
* scripts/run_windows.bat is gone; docs/README-windows.md is rewritten
Tests
* new test_lowil, test_win_utf8 and test_os_dir; tests made portable
(cst_test_util.h)
* scripts/win_test.sh and scripts/winvm/ run the suite on English and
Chinese Windows Server VMs as Administrator, a standard user and a
Chinese user name: 29/29 on all six
96 lines
3.2 KiB
C
96 lines
3.2 KiB
C
#define _POSIX_C_SOURCE 200809L
|
|
|
|
#include "cst_agent.h"
|
|
#include "os_compat.h"
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
#include "cst_test_util.h"
|
|
|
|
/* run_shell must never hang the agent: timeout kills the whole process
|
|
* group, stdin is empty, huge output is capped. */
|
|
|
|
static int nfail;
|
|
|
|
#define EXPECT(cond, msg) \
|
|
do { \
|
|
if (!(cond)) { \
|
|
fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, msg); \
|
|
nfail++; \
|
|
} \
|
|
} while (0)
|
|
|
|
static char g_ws[256];
|
|
|
|
static int sh(const char *cmd, cst_tool_result_t *r, double *ms) {
|
|
ctl_tool_call_t c;
|
|
memset(&c, 0, sizeof(c));
|
|
snprintf(c.id, sizeof(c.id), "s");
|
|
snprintf(c.name, sizeof(c.name), "run_shell");
|
|
snprintf(c.args[0].key, sizeof(c.args[0].key), "cmd");
|
|
c.args[0].value = (char *)cmd;
|
|
c.args[0].value_len = strlen(cmd);
|
|
c.nargs = 1;
|
|
memset(r, 0, sizeof(*r));
|
|
double t0 = os_now_ms();
|
|
cst_tool_dispatch(g_ws, &c, r);
|
|
*ms = os_now_ms() - t0;
|
|
return r->exit_code;
|
|
}
|
|
|
|
int main(void) {
|
|
if (test_tmpdir(g_ws, sizeof(g_ws), "cst-shell-test") != 0) {
|
|
perror("tmpdir");
|
|
return 1;
|
|
}
|
|
cst_tool_result_t r;
|
|
double ms;
|
|
|
|
EXPECT(sh("echo hi; exit 3", &r, &ms) == 3, "exit code passed through");
|
|
EXPECT(r.out && strstr(r.out, "hi"), "stdout captured");
|
|
cst_tool_result_free(&r);
|
|
|
|
/* stdin is /dev/null: a command reading stdin returns at once */
|
|
sh("cat; echo done", &r, &ms);
|
|
EXPECT(r.out && strstr(r.out, "done") && ms < 5000, "stdin is empty");
|
|
cst_tool_result_free(&r);
|
|
|
|
/* timeout kills the process group, including background children that
|
|
* keep the output pipe open */
|
|
setenv("CST_SHELL_TIMEOUT", "1", 1);
|
|
os_set_run_timeout(1);
|
|
int ec = sh("sleep 30 & sleep 30; echo never", &r, &ms);
|
|
EXPECT(ec == 124, "timeout exit code 124");
|
|
EXPECT(ms < 8000, "timeout returns promptly");
|
|
EXPECT(!r.out || !strstr(r.out, "never"), "command was stopped");
|
|
cst_tool_result_free(&r);
|
|
os_set_run_timeout(0);
|
|
unsetenv("CST_SHELL_TIMEOUT");
|
|
|
|
/* the shell exits but leaves a background child holding the pipe */
|
|
ec = sh("sleep 30 & echo started", &r, &ms);
|
|
EXPECT(ec == 0, "shell exit code kept when a background child lingers");
|
|
EXPECT(r.out && strstr(r.out, "started"), "foreground output kept");
|
|
EXPECT(ms < 5000, "lingering background child does not block");
|
|
cst_tool_result_free(&r);
|
|
|
|
/* huge output: capped and marked, the child is not blocked on the pipe */
|
|
sh("head -c 5000000 /dev/zero | tr '\\0' x; echo; echo tail-marker", &r, &ms);
|
|
EXPECT(r.out && r.out_len < 2000000, "output capped");
|
|
EXPECT(r.out && strstr(r.out, "truncated"), "truncation noted");
|
|
EXPECT(ms < 20000, "large output does not hang");
|
|
cst_tool_result_free(&r);
|
|
|
|
if (test_rmrf(g_ws) != 0)
|
|
fprintf(stderr, "warning: cleanup failed\n");
|
|
if (nfail) {
|
|
fprintf(stderr, "test_shell: %d failed\n", nfail);
|
|
return 1;
|
|
}
|
|
printf("test_shell: OK\n");
|
|
return 0;
|
|
}
|