373 unit tests, up from 266. Three files, split the way the modules are: `test_mcp_authorizations.py` is standard library and touches no SDK, `test_mcp_http.py` drives a real ASGI stack, and the additions to `test_mcp_server.py` are about the command line now that it has subcommands. Four of these exist for properties that a refactor breaks silently rather than loudly, which is the only reason they are worth their length: * **the file never holds a token.** A store that started writing the secret instead of its digest would pass every functional test here, so one test reads the bytes on disk and looks for the token and for a usable prefix of it. * **a concurrent mint is not lost.** Thirty threads mint into one table and all thirty tokens must still verify. The atomic replace stops a torn read; it does nothing about two writers loading the same table and the second replacing the first's addition. Without the flock this fails. * **`--toolsets` before the subcommand survives it.** argparse copies a subparser's namespace over the top-level one, so an ordinary default on the subcommand's copy would overwrite the value with `None` and `hhstream-mcp --toolsets=frames serve` would quietly serve all twenty-one tools. `SUPPRESS` prevents it and this test notices if it goes. * **a token verb never claims the transport.** `mint` prints a secret on stdout, which on stdio *is* the transport, so `claim_transport` is monkeypatched to fail the test if it is ever reached. The refusal tests assert the absence of information as much as the status code: an empty body, no echo of the token in body or headers, and unknown/revoked/expired arriving as one answer byte for byte -- telling them apart would tell someone who guessed a real id that they had. An unknown path is a 401 before a 404, so an unauthenticated caller does not learn what is mounted; the token is checked before the Host, so it does not learn the allowlist either. `test_resources_are_not_narrowed_by_a_token` asserts a *limit*, on purpose: a token scoped to `frames` can still read `hhstream://sessions`, and that is written down rather than left for someone to discover. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01KchcvnbfhhZhUHy83YL3Ya
120 lines
4.5 KiB
Nix
120 lines
4.5 KiB
Nix
# `hhstream-mcp` -- the MCP server, as its own derivation.
|
|
#
|
|
# Separate from `nix/package.nix` on purpose, and the separation is the point:
|
|
# the frame socket, the CLI and the broker are stdlib-only by policy
|
|
# (`pyproject.toml`, `docs/CONTRACT-sessions.md` §6 rule 3), the MCP SDK is a
|
|
# third-party dependency, and `packages.hhstream` runs as the compositor's own
|
|
# units. So the dependency lives here, in a package nothing else imports, and
|
|
# `packages.hhstream` keeps the closure it had.
|
|
#
|
|
# `hhstream` is a *library* dependency here and not a binary one: the tools call
|
|
# `hhstream.cli`'s handlers in process (see that module's docstring), so what
|
|
# this package needs is the import path. `toPythonModule` is what makes an
|
|
# application's site-packages visible to a dependent, which a bare
|
|
# `buildPythonApplication` output is not.
|
|
#
|
|
# `grim` and `ffmpeg` do go on PATH, because the CLI itself spawns them --
|
|
# `shot --output` and `record` are two of the twenty-three tools, and the server
|
|
# is launched by an MCP client whose PATH is not ours to predict. `--prefix`
|
|
# and not `--set`, so a deployment that wants its own ahead of these puts them
|
|
# on PATH and wins.
|
|
{
|
|
lib,
|
|
python3,
|
|
hhstream,
|
|
grim,
|
|
ffmpeg,
|
|
makeWrapper,
|
|
}:
|
|
python3.pkgs.buildPythonApplication {
|
|
pname = "hhstream-mcp";
|
|
version = "0.1.0";
|
|
pyproject = true;
|
|
|
|
# The package directory is the project root: its own pyproject.toml lives
|
|
# there and maps the package name onto `.`. See the comment in that file for
|
|
# why it is not at the repository root.
|
|
src = ../src/hhstream_mcp;
|
|
|
|
build-system = [ python3.pkgs.setuptools ];
|
|
|
|
dependencies = [
|
|
python3.pkgs.mcp
|
|
python3.pkgs.anyio
|
|
# The HTTP transport's own two, declared for the reason `anyio` is: the SDK
|
|
# propagates both today, and `hhstream_mcp.http` imports them by name. See
|
|
# the note in src/hhstream_mcp/pyproject.toml.
|
|
python3.pkgs.starlette
|
|
python3.pkgs.uvicorn
|
|
# An application is not importable by a dependent until this converts it,
|
|
# and `hhstream_mcp.invoke` imports `hhstream.cli` directly.
|
|
(python3.pkgs.toPythonModule hhstream)
|
|
];
|
|
|
|
nativeBuildInputs = [ makeWrapper ];
|
|
|
|
makeWrapperArgs = [
|
|
"--prefix"
|
|
"PATH"
|
|
":"
|
|
"${lib.makeBinPath [
|
|
grim
|
|
ffmpeg
|
|
]}"
|
|
];
|
|
|
|
# The suite lives in `tests/` at the repository root and runs in the flake's
|
|
# `checks.unit`, which is also where `mcp` reaches it. Same choice as
|
|
# nix/package.nix, for the same reason.
|
|
doCheck = false;
|
|
|
|
# Cheap proof that both tables build and the SDK wiring imports: `tools` and
|
|
# `resources` construct every entry at import time, and `server` is the only
|
|
# module that touches `mcp`. A missing SDK, a schema that is not a dict, or a
|
|
# tool named twice all fail here rather than at an agent's first call.
|
|
pythonImportsCheck = [
|
|
"hhstream_mcp.tools"
|
|
"hhstream_mcp.resources"
|
|
"hhstream_mcp.server"
|
|
];
|
|
|
|
# `pythonImportsCheck` proves the modules load; it does not prove the script
|
|
# Nix wrapped can run, and the script is what an MCP client spawns.
|
|
# `--list-tools` and `--list-resources` are the two code paths that exercise
|
|
# argument parsing and both whole tables without opening stdio, so together
|
|
# they are the honest smoke test. `--toolsets` is in it because a selection
|
|
# that silently served everything would be the failure nobody notices.
|
|
#
|
|
# A `postPhases` entry and not `postInstall`, because the script is wrapped in
|
|
# `fixupPhase`: run any earlier and it has no PYTHONPATH, so `import mcp`
|
|
# fails and the check tests the wrong thing. `installCheckPhase` is no use
|
|
# either -- `buildPythonPackage` does not include that phase at all.
|
|
postPhases = [ "entryPointCheckPhase" ];
|
|
entryPointCheckPhase = ''
|
|
echo "checking the wrapped entry point..."
|
|
tools=$($out/bin/hhstream-mcp --list-tools)
|
|
echo "$tools"
|
|
test "$(echo "$tools" | wc -l)" -eq 23
|
|
|
|
resources=$($out/bin/hhstream-mcp --list-resources)
|
|
echo "$resources"
|
|
test "$(echo "$resources" | wc -l)" -eq 10
|
|
|
|
narrowed=$($out/bin/hhstream-mcp --list-tools --toolsets keyboard | wc -l)
|
|
echo "--toolsets keyboard offers $narrowed tools"
|
|
test "$narrowed" -eq 4
|
|
|
|
# An unknown toolset must be argparse's exit 2, not a server with no tools.
|
|
if $out/bin/hhstream-mcp --list-tools --toolsets nonsense; then
|
|
echo "an unknown toolset was accepted" >&2
|
|
exit 1
|
|
fi
|
|
'';
|
|
|
|
meta = {
|
|
description = "Drive a headless Hyprland session over the Model Context Protocol";
|
|
license = lib.licenses.mit;
|
|
mainProgram = "hhstream-mcp";
|
|
};
|
|
}
|