852 lines · 35.2 KB · Zig
RawDownload
const std = @import("std");const build_options = @import("build_options");const acp_server = @import("acp/server.zig");const jsonrpc = @import("acp/jsonrpc.zig");const background_process_provider = @import("core/execution/background_process_provider.zig");const gateway_provider = @import("core/gateway/gateway_provider.zig");const generation_usage_provider = @import("core/session/generation_usage_provider.zig");const host = @import("core/hosts/host.zig");const debug_trace = @import("core/shared/debug_trace.zig");const io_mod = @import("core/shared/io.zig");const streamable_http = @import("core/mcp/streamable_http.zig");const host_stream_provider = @import("gateway/host_stream_provider.zig");const oauth_transport = @import("core/auth/oauth_transport.zig");const builtin_context = @import("builtins/context.zig");const builtin_gateway = @import("builtins/gateway.zig");const builtin_modes = @import("builtins/modes.zig"); const c = @cImport({    @cInclude("node_api.h");}); const Allocator = std.mem.Allocator;const max_drain_bytes = 1024 * 1024;const max_input_bytes = 8 * 1024 * 1024;const max_output_bytes = 8 * 1024 * 1024;const max_fetch_request_bytes = 8 * 1024 * 1024;const max_fetch_response_bytes = 8 * 1024 * 1024;const max_api_key_bytes = 64 * 1024;const max_model_bytes = 1024;const max_path_bytes = 16 * 1024;const max_url_bytes = 16 * 1024;const max_active_runtimes = 64;const runtime_handle_type_tag = c.napi_type_tag{    .lower = 0x4c4942465852544d,    .upper = 0xa71d7c52e9314b08,}; comptime {    if (build_options.napi_surface != .core) {        @compileError("libfx N-API core requires -Dnapi-surface=core");    }} const InputQueue = struct {    mutex: std.Io.Mutex = .init,    wake: std.Io.Condition = .init,    bytes: std.ArrayList(u8) = .empty,    offset: usize = 0,    closed: bool = false,     fn read(self: *InputQueue, alloc: Allocator, destination: []u8) usize {        const io = io_mod.getIo();        self.mutex.lockUncancelable(io);        defer self.mutex.unlock(io);        while (self.offset == self.bytes.items.len and !self.closed) {            self.bytes.clearRetainingCapacity();            self.offset = 0;            self.wake.waitUncancelable(io, &self.mutex);        }        const available = self.bytes.items.len - self.offset;        if (available == 0) return 0;        const len = @min(destination.len, available);        @memcpy(destination[0..len], self.bytes.items[self.offset..][0..len]);        self.offset += len;        if (self.offset == self.bytes.items.len) {            self.bytes.clearRetainingCapacity();            self.offset = 0;        }        _ = alloc;        return len;    }     fn write(self: *InputQueue, alloc: Allocator, data: []const u8) !void {        const io = io_mod.getIo();        self.mutex.lockUncancelable(io);        defer self.mutex.unlock(io);        if (self.closed) return error.InputClosed;        const queued = self.bytes.items.len - self.offset;        if (data.len > max_input_bytes or queued > max_input_bytes - data.len) return error.InputQueueFull;        if (self.offset > 0) {            std.mem.copyForwards(u8, self.bytes.items[0..queued], self.bytes.items[self.offset..]);            self.bytes.items.len = queued;            self.offset = 0;        }        try self.bytes.appendSlice(alloc, data);        self.wake.signal(io);    }     fn close(self: *InputQueue) void {        const io = io_mod.getIo();        self.mutex.lockUncancelable(io);        self.closed = true;        self.wake.broadcast(io);        self.mutex.unlock(io);    }     fn deinit(self: *InputQueue, alloc: Allocator) void {        self.bytes.deinit(alloc);    }}; const OutputQueue = struct {    mutex: std.Io.Mutex = .init,    bytes: std.ArrayList(u8) = .empty,    offset: usize = 0,     fn write(self: *OutputQueue, alloc: Allocator, data: []const u8) !void {        const io = io_mod.getIo();        self.mutex.lockUncancelable(io);        defer self.mutex.unlock(io);        const queued = self.bytes.items.len - self.offset;        if (data.len > max_output_bytes or queued > max_output_bytes - data.len) return error.OutputQueueFull;        if (self.offset > 0) {            std.mem.copyForwards(u8, self.bytes.items[0..queued], self.bytes.items[self.offset..]);            self.bytes.items.len = queued;            self.offset = 0;        }        try self.bytes.appendSlice(alloc, data);    }     fn drain(self: *OutputQueue, destination: []u8) usize {        const io = io_mod.getIo();        self.mutex.lockUncancelable(io);        defer self.mutex.unlock(io);        const available_bytes = self.bytes.items.len - self.offset;        const len = @min(destination.len, available_bytes);        if (len == 0) return 0;        @memcpy(destination[0..len], self.bytes.items[self.offset..][0..len]);        self.offset += len;        if (self.offset == self.bytes.items.len) {            self.bytes.clearRetainingCapacity();            self.offset = 0;        }        return len;    }     fn available(self: *OutputQueue) usize {        const io = io_mod.getIo();        self.mutex.lockUncancelable(io);        defer self.mutex.unlock(io);        return self.bytes.items.len - self.offset;    }     fn deinit(self: *OutputQueue, alloc: Allocator) void {        self.bytes.deinit(alloc);    }}; const FetchBridge = struct {    mutex: std.Io.Mutex = .init,    wake: std.Io.Condition = .init,    request: std.ArrayList(u8) = .empty,    response: std.ArrayList(u8) = .empty,    response_offset: usize = 0,    request_pending: bool = false,    response_started: bool = false,    response_done: bool = false,    failed: bool = false,    aborted: bool = false,    shutting_down: bool = false,    status: u16 = 0,     fn clearPendingRequest(self: *FetchBridge, reason: []const u8) void {        if (!self.request_pending) return;        debug_trace.logf("napi", "dropping pending host fetch reason={s} bytes={d}", .{ reason, self.request.items.len });        self.request.clearRetainingCapacity();        self.request_pending = false;    }     fn open(raw: ?*anyopaque, method: []const u8, url: []const u8, headers: []const u8, body: []const u8) !i32 {        const self: *FetchBridge = @ptrCast(@alignCast(raw.?));        const io = io_mod.getIo();        self.mutex.lockUncancelable(io);        defer self.mutex.unlock(io);        if (self.shutting_down) return error.HostStreamUnavailable;        if (self.aborted) {            self.clearPendingRequest("open_after_abort");            self.aborted = false;            return error.Cancelled;        }        if (self.request_pending or self.response_started) return error.HostStreamUnavailable;        self.failed = false;        self.response_done = false;        self.response_offset = 0;        self.response.clearRetainingCapacity();        var writer: std.Io.Writer.Allocating = .init(std.heap.c_allocator);        defer writer.deinit();        const encoded_body = std.base64.standard.Encoder.calcSize(body.len);        const body_base64 = try std.heap.c_allocator.alloc(u8, encoded_body);        defer std.heap.c_allocator.free(body_base64);        _ = std.base64.standard.Encoder.encode(body_base64, body);        try std.json.Stringify.value(.{ .method = method, .url = url, .headers = headers, .body = body_base64 }, .{}, &writer.writer);        const bytes = writer.writer.buffered();        if (bytes.len > max_fetch_request_bytes) return error.HostStreamBackpressure;        try self.request.appendSlice(std.heap.c_allocator, bytes);        self.request_pending = true;        self.wake.broadcast(io);        return 1;    }     fn statusFn(raw: ?*anyopaque, _: i32, status_out: *u16) i32 {        const self: *FetchBridge = @ptrCast(@alignCast(raw.?));        const io = io_mod.getIo();        self.mutex.lockUncancelable(io);        defer self.mutex.unlock(io);        while (!self.response_started and !self.aborted) self.wake.waitUncancelable(io, &self.mutex);        if (self.aborted) return -2;        if (self.failed) return -1;        status_out.* = self.status;        return 1;    }     fn next(raw: ?*anyopaque, _: i32, out: []u8) i32 {        const self: *FetchBridge = @ptrCast(@alignCast(raw.?));        const io = io_mod.getIo();        self.mutex.lockUncancelable(io);        defer self.mutex.unlock(io);        while (self.response_offset == self.response.items.len and !self.response_done and !self.aborted) {            self.response.clearRetainingCapacity();            self.response_offset = 0;            self.wake.waitUncancelable(io, &self.mutex);        }        if (self.aborted) return -2;        if (self.failed) return -1;        const available = self.response.items.len - self.response_offset;        if (available == 0) return 0;        const len = @min(out.len, available);        @memcpy(out[0..len], self.response.items[self.response_offset..][0..len]);        self.response_offset += len;        self.wake.broadcast(io);        return @intCast(len);    }     fn close(raw: ?*anyopaque, _: i32) void {        const self: *FetchBridge = @ptrCast(@alignCast(raw.?));        const io = io_mod.getIo();        self.mutex.lockUncancelable(io);        self.clearPendingRequest("stream_close");        self.response_started = false;        self.response_done = false;        self.failed = false;        self.aborted = false;        self.response.clearRetainingCapacity();        self.response_offset = 0;        self.wake.broadcast(io);        self.mutex.unlock(io);    }     fn startResponse(self: *FetchBridge, status: u16) !void {        const io = io_mod.getIo();        self.mutex.lockUncancelable(io);        defer self.mutex.unlock(io);        if (self.aborted) return error.FetchAborted;        if (self.response_started) return error.ResponseAlreadyStarted;        self.status = status;        self.response_started = true;        self.wake.broadcast(io);    }     fn pushResponse(self: *FetchBridge, data: []const u8) !void {        const io = io_mod.getIo();        self.mutex.lockUncancelable(io);        defer self.mutex.unlock(io);        if (self.aborted) return error.FetchAborted;        if (!self.response_started or self.response_done) return error.InvalidResponseState;        const queued = self.response.items.len - self.response_offset;        if (data.len > max_fetch_response_bytes or queued > max_fetch_response_bytes - data.len) return error.ResponseQueueFull;        if (self.response_offset > 0) {            std.mem.copyForwards(u8, self.response.items[0..queued], self.response.items[self.response_offset..]);            self.response.items.len = queued;            self.response_offset = 0;        }        try self.response.appendSlice(std.heap.c_allocator, data);        self.wake.broadcast(io);    }     fn finishResponse(self: *FetchBridge) void {        const io = io_mod.getIo();        self.mutex.lockUncancelable(io);        self.response_done = true;        self.wake.broadcast(io);        self.mutex.unlock(io);    }     fn failResponse(self: *FetchBridge) void {        const io = io_mod.getIo();        self.mutex.lockUncancelable(io);        self.failed = true;        self.response_started = true;        self.response_done = true;        self.wake.broadcast(io);        self.mutex.unlock(io);    }     fn abort(self: *FetchBridge) void {        const io = io_mod.getIo();        self.mutex.lockUncancelable(io);        self.clearPendingRequest("abort");        self.aborted = true;        self.wake.broadcast(io);        self.mutex.unlock(io);    }     fn shutdown(self: *FetchBridge) void {        const io = io_mod.getIo();        self.mutex.lockUncancelable(io);        self.clearPendingRequest("shutdown");        self.shutting_down = true;        self.aborted = true;        self.wake.broadcast(io);        self.mutex.unlock(io);    }     fn deinit(self: *FetchBridge) void {        self.request.deinit(std.heap.c_allocator);        self.response.deinit(std.heap.c_allocator);    }}; const Runtime = struct {    alloc: Allocator,    fetch: FetchBridge = .{},    stream_context: host_stream_provider.ProviderContext = undefined,    input: InputQueue = .{},    output: OutputQueue = .{},    credential: []u8,    model: ?[]u8,    home: []u8,    workspace_root: []u8,    gateway_chat_url: []u8,    thread: std.Thread,    exited: std.atomic.Value(bool) = .init(false),    exit_code: std.atomic.Value(u8) = .init(0),     fn readInput(context: ?*anyopaque, destination: []u8) usize {        const self: *Runtime = @ptrCast(@alignCast(context.?));        return self.input.read(self.alloc, destination);    }     fn writeOutput(context: ?*anyopaque, bytes: []const u8) !void {        const self: *Runtime = @ptrCast(@alignCast(context.?));        self.output.write(self.alloc, bytes) catch |err| {            debug_trace.logf("napi", "native output failed err={s}", .{@errorName(err)});            self.exit_code.store(1, .seq_cst);            return err;        };    }     fn run(self: *Runtime) void {        const provider = gateway_provider.Provider{            .agent_stream = host_stream_provider.provider(&self.stream_context),            .oauth_transport = oauth_transport.unavailable_provider,            .chat_url = builtin_gateway.provider.chat_url,            .cli_model_catalog = builtin_gateway.provider.cli_model_catalog,            .credits = builtin_gateway.provider.credits,            .generation_usage = generation_usage_provider.unavailable_provider,            .web_search = builtin_gateway.provider.web_search,            .model_catalog = builtin_gateway.provider.model_catalog,        };        acp_server.runWithTransport(            self.alloc,            .{                .default_model = builtin_gateway.default_model,                .default_agent_step_limit = 64,                .gateway_retry_count = 0,                .gateway_chat_url = self.gateway_chat_url,                .gateway_models_path = builtin_gateway.models_path,                .gateway_provider = provider,                .background_process_provider = background_process_provider.unavailable_provider,                .secret_store = host.unavailable_secret_store,                .prompt_policy = builtin_context.prompt_policy,                .ignored_list_entries = &.{},                .max_list_entries = 0,                .max_read_file_bytes = 0,                .max_read_file_lines = 0,                .max_read_file_line_len = 0,                .max_command_output_bytes = 0,                .max_tool_result_bytes = 64 * 1024,                .max_history_turns = 100,                .context_registry = .{ .default_provider = builtin_context.provider },                .mode_registry = builtin_modes.registry,                .credential_override = self.credential,                .model_override = self.model,                .home_override = self.home,                .workspace_root_override = self.workspace_root,                .allow_acp_mcp = false,                .allow_native_tools = false,            },            jsonrpc.Reader.initCallback(self, Runtime.readInput),            jsonrpc.Writer.initCallback(self, Runtime.writeOutput),        ) catch |err| {            debug_trace.logf("napi", "native runtime failed err={s}", .{@errorName(err)});            self.exit_code.store(1, .seq_cst);        };        self.exited.store(true, .seq_cst);    }     fn closeInput(self: *Runtime) void {        self.input.close();    }     fn abortHostEffects(self: *Runtime) void {        self.fetch.abort();    }     fn deinit(self: *Runtime) void {        self.closeInput();        self.fetch.shutdown();        self.thread.join();        self.fetch.deinit();        self.input.deinit(self.alloc);        self.output.deinit(self.alloc);        self.alloc.free(self.credential);        if (self.model) |model| self.alloc.free(model);        self.alloc.free(self.home);        self.alloc.free(self.workspace_root);        self.alloc.free(self.gateway_chat_url);        self.alloc.destroy(self);        releaseRuntimeSlot();    }}; const RuntimeHandle = struct {    mutex: std.Io.Mutex = .init,    runtime: ?*Runtime,     fn destroy(self: *RuntimeHandle) void {        const io = io_mod.getIo();        self.mutex.lockUncancelable(io);        const runtime = self.runtime;        self.runtime = null;        self.mutex.unlock(io);        if (runtime) |value| value.deinit();    }}; var threaded_io: ?std.Io.Threaded = null;var threaded_io_state: std.atomic.Value(u8) = .init(0);var active_runtime_count: std.atomic.Value(usize) = .init(0); fn claimRuntimeSlot() bool {    var current = active_runtime_count.load(.acquire);    while (current < max_active_runtimes) {        if (active_runtime_count.cmpxchgWeak(current, current + 1, .acq_rel, .acquire)) |observed| {            current = observed;        } else return true;    }    return false;} fn releaseRuntimeSlot() void {    _ = active_runtime_count.fetchSub(1, .acq_rel);} fn ensureThreadedIo() void {    if (threaded_io_state.cmpxchgStrong(0, 1, .acq_rel, .acquire) == null) {        threaded_io = std.Io.Threaded.init(std.heap.c_allocator, .{});        io_mod.setIo(threaded_io.?.io());        threaded_io_state.store(2, .release);        return;    }    while (threaded_io_state.load(.acquire) != 2) std.atomic.spinLoopHint();} fn throw(env: c.napi_env, code: [*:0]const u8, message: [*:0]const u8) c.napi_value {    _ = c.napi_throw_error(env, code, message);    return null;} fn statusOk(env: c.napi_env, status: c.napi_status, message: [*:0]const u8) bool {    if (status == c.napi_ok) return true;    _ = c.napi_throw_error(env, "LIBFX_NAPI", message);    return false;} fn callbackArgs(env: c.napi_env, info: c.napi_callback_info, argv: []c.napi_value) bool {    var argc = argv.len;    if (!statusOk(env, c.napi_get_cb_info(env, info, &argc, argv.ptr, null, null), "could not read arguments")) return false;    if (argc == argv.len) return true;    _ = c.napi_throw_type_error(env, "LIBFX_INVALID_ARGUMENT", "missing required argument");    return false;} fn stringArg(env: c.napi_env, value: c.napi_value, alloc: Allocator, max_len: usize) ![]u8 {    var len: usize = 0;    if (c.napi_get_value_string_utf8(env, value, null, 0, &len) != c.napi_ok) return error.InvalidArgument;    if (len > max_len) return error.ArgumentTooLong;    const bytes = try alloc.alloc(u8, len + 1);    errdefer alloc.free(bytes);    var written: usize = 0;    if (c.napi_get_value_string_utf8(env, value, bytes.ptr, bytes.len, &written) != c.napi_ok) return error.InvalidArgument;    return bytes[0..written];} fn getNamedString(    env: c.napi_env,    object: c.napi_value,    name: [*:0]const u8,    alloc: Allocator,    max_len: usize,

Lines 1–500 of 852.

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t