Skip to content

graff — a fast agentic coding harness in Zig: multi-provider, MCP, workflows, DGM evolution loop, TS/Python SDKs

Python
8.9 KB
Raw Blame
//! Loopback Streamable HTTP adapter; task execution remains in mcp_server.
const std = @import("std");
const Io = std.Io;
const mcp = @import("mcp_server.zig");
const modern = @import("mcp_server_modern.zig");
const Value = std.json.Value;
const Session = struct { id: [32]u8, server: mcp.Server };
const State = struct {
    io: Io,
    allocator: std.mem.Allocator,
    token: []const u8,
    port: u16,
    prototype: mcp.Server,
    mutex: Io.Mutex = .init,
    sessions: [64]?Session = @splat(null),
    next: usize = 0,
};

pub fn run(io: Io, a: std.mem.Allocator, port: u16, token: []const u8, prototype: mcp.Server) !void {
    if (token.len < 32 or std.mem.indexOfAny(u8, token, "\r\n") != null) return error.InvalidMcpHttpToken;
    const addr = try Io.net.IpAddress.parse("127.0.0.1", port);
    var listener = try addr.listen(io, .{ .reuse_address = true });
    defer listener.deinit(io);
    var group: Io.Group = .init;
    defer group.cancel(io);
    var state: State = .{ .io = io, .allocator = a, .token = token, .port = port, .prototype = prototype };
    @import("serve.zig").serveLog(io, "Codegraff MCP listening at http://127.0.0.1:{d}/mcp", .{port});
    while (true) {
        const stream = try listener.accept(io);
        group.concurrent(io, connection, .{ &state, stream }) catch stream.close(io);
    }
}

fn connection(st: *State, stream: Io.net.Stream) void {
    defer stream.close(st.io);
    var rb: [16 * 1024]u8 = undefined;
    var wb: [4096]u8 = undefined;
    var reader = Io.net.Stream.Reader.init(stream, st.io, &rb);
    var writer = Io.net.Stream.Writer.init(stream, st.io, &wb);
    var http = std.http.Server.init(&reader.interface, &writer.interface);
    var request = http.receiveHead() catch return;
    handle(st, &request) catch return;
}

fn respond(req: *std.http.Server.Request, status: std.http.Status, body: []const u8, sid: ?[]const u8) !void {
    var headers = [_]std.http.Header{
        .{ .name = "content-type", .value = "application/json" },
        .{ .name = "cache-control", .value = "no-store" },
        .{ .name = "Mcp-Session-Id", .value = sid orelse "" },
    };
    try req.respond(body, .{ .status = status, .keep_alive = false, .extra_headers = headers[0..if (sid != null) 3 else 2] });
}

fn handle(st: *State, req: *std.http.Server.Request) !void {
    var arena = std.heap.ArenaAllocator.init(st.allocator);
    defer arena.deinit();
    const a = arena.allocator();
    if (!std.mem.eql(u8, req.head.target, "/mcp")) return respond(req, .not_found, "{}", null);
    const host = try std.fmt.allocPrint(a, "127.0.0.1:{d}", .{st.port});
    const origin = try std.fmt.allocPrint(a, "http://{s}", .{host});
    const bearer = try std.fmt.allocPrint(a, "Bearer {s}", .{st.token});
    var authorized = false;
    var host_ok = false;
    var sid: ?[]const u8 = null;
    var json_type = false;
    var protocol_header: ?[]const u8 = null;
    var method_header: ?[]const u8 = null;
    var name_header: ?[]const u8 = null;
    var headers = req.iterateHeaders();
    while (headers.next()) |h| {
        if (std.ascii.eqlIgnoreCase(h.name, "host")) host_ok = std.mem.eql(u8, h.value, host);
        if (std.ascii.eqlIgnoreCase(h.name, "origin") and !std.mem.eql(u8, h.value, origin)) return respond(req, .forbidden, "{}", null);
        if (std.ascii.eqlIgnoreCase(h.name, "authorization")) authorized = equalToken(h.value, bearer);
        if (std.ascii.eqlIgnoreCase(h.name, "mcp-session-id")) sid = try a.dupe(u8, h.value);
        if (std.ascii.eqlIgnoreCase(h.name, "content-type")) json_type = std.mem.eql(u8, h.value, "application/json") or std.mem.startsWith(u8, h.value, "application/json;");
        if (std.ascii.eqlIgnoreCase(h.name, "mcp-protocol-version")) protocol_header = try a.dupe(u8, h.value);
        if (std.ascii.eqlIgnoreCase(h.name, "mcp-method")) method_header = try a.dupe(u8, h.value);
        if (std.ascii.eqlIgnoreCase(h.name, "mcp-name")) name_header = try a.dupe(u8, h.value);
    }
    if (!host_ok) return respond(req, .forbidden, "{}", null);
    if (!authorized) return respond(req, .unauthorized, "{}", null);
    if (req.head.method != .POST and req.head.method != .DELETE) return respond(req, .method_not_allowed, "{}", null);
    if (protocol_header) |v| {
        const known = for (modern.supported_versions) |s| {
            if (std.mem.eql(u8, v, s)) break true;
        } else false;
        // A legacy client learns nothing from a JSON-RPC body here; a modern
        // one reads -32022 and its supported list.
        if (!known) return respondUnsupported(a, req, v);
    }
    try st.mutex.lock(st.io);
    defer st.mutex.unlock(st.io);
    var legacy_body: ?[]const u8 = null;
    if (req.head.method == .POST and json_type) switch (try modernRequest(st, a, req, protocol_header, method_header, name_header)) {
        .handled => return,
        .legacy => |body| legacy_body = body,
    };
    var slot: ?*?Session = null;
    if (sid) |id| {
        for (&st.sessions) |*entry| if (entry.*) |s| {
            if (std.mem.eql(u8, &s.id, id)) {
                slot = entry;
                break;
            }
        };
        if (slot == null) return respond(req, .not_found, "{}", null);
    }
    if (req.head.method == .DELETE) {
        if (slot) |entry| entry.* = null else return respond(req, .bad_request, "{}", null);
        return respond(req, .no_content, "", null);
    }
    if (!json_type) return respond(req, .unsupported_media_type, "{}", null);
    const body = legacy_body orelse return respond(req, .bad_request, "{}", null);
    const value = std.json.parseFromSliceLeaky(Value, a, body, .{}) catch return respond(req, .bad_request, "{}", null);
    if (value != .object) return respond(req, .bad_request, "{}", null);
    const method = value.object.get("method") orelse return respond(req, .bad_request, "{}", null);
    const initializing = method == .string and std.mem.eql(u8, method.string, "initialize");
    var fresh = st.prototype;
    const server = if (slot) |entry| &entry.*.?.server else &fresh;
    if (slot == null and !initializing) return respond(req, .bad_request, "{}", null);
    var output: Io.Writer.Allocating = .init(a);
    try server.handle(a, &output.writer, body);
    var new_id: ?[]const u8 = null;
    if (slot == null and fresh.initialized) {
        var bytes: [16]u8 = undefined;
        st.io.random(&bytes);
        const id = std.fmt.bytesToHex(bytes, .lower);
        st.sessions[st.next] = .{ .id = id, .server = fresh };
        new_id = &st.sessions[st.next].?.id;
        st.next = (st.next + 1) % st.sessions.len;
    }
    return respond(req, if (output.written().len == 0) .accepted else .ok, output.written(), new_id);
}

fn readBody(a: std.mem.Allocator, req: *std.http.Server.Request) !?[]const u8 {
    if (req.head.content_length) |length| {
        if (length > 65536) return null;
    }
    var buffer: [4096]u8 = undefined;
    const body_reader = try req.readerExpectContinue(&buffer);
    return body_reader.allocRemaining(a, .limited(65536)) catch null;
}

fn respondUnsupported(a: std.mem.Allocator, req: *std.http.Server.Request, requested: []const u8) !void {
    var out: Io.Writer.Allocating = .init(a);
    try modern.unsupported(&out.writer, .null, requested);
    return respond(req, .bad_request, out.written(), null);
}

/// 2026-07-28 POSTs are stateless: no session, a fresh server per request,
/// and headers that must agree with the body. The body is read here either
/// way; a legacy one is handed back for the session path.
const Routed = union(enum) { handled, legacy: []const u8 };

fn modernRequest(st: *State, a: std.mem.Allocator, req: *std.http.Server.Request, protocol_header: ?[]const u8, method_header: ?[]const u8, name_header: ?[]const u8) !Routed {
    const body = (try readBody(a, req)) orelse {
        try respond(req, .payload_too_large, "{}", null);
        return .handled;
    };
    const value = std.json.parseFromSliceLeaky(Value, a, body, .{}) catch return .{ .legacy = body };
    if (value != .object) return .{ .legacy = body };
    const params = value.object.get("params") orelse Value.null;
    const requested = modern.requestedVersion(params) orelse return .{ .legacy = body };
    const id = value.object.get("id") orelse Value.null;
    var out: Io.Writer.Allocating = .init(a);
    if (!modern.isSupported(requested)) {
        try modern.unsupported(&out.writer, id, requested);
        try respond(req, .bad_request, out.written(), null);
        return .handled;
    }
    if (try modern.headerMismatch(a, value, protocol_header, method_header, name_header)) |why| {
        try modern.mismatch(&out.writer, id, why);
        try respond(req, .bad_request, out.written(), null);
        return .handled;
    }
    var fresh = st.prototype;
    try fresh.handle(a, &out.writer, body);
    try respond(req, if (out.written().len == 0) .accepted else .ok, out.written(), null);
    return .handled;
}

pub fn equalToken(a: []const u8, b: []const u8) bool {
    if (a.len != b.len) return false;
    var diff: u8 = 0;
    for (a, b) |x, y| diff |= x ^ y;
    return diff == 0;
}