usecomputer 0.0.3 → 0.1.0

package/zig/src/main.zig

@@ -0,0 +1,382 @@
+/// Standalone CLI for usecomputer — no Node.js required.
+/// Calls the same native functions as the N-API module via lib.zig.
+const std = @import("std");
+const zeke = @import("zeke");
+const lib = @import("usecomputer_lib");
+
+const File = std.fs.File;
+const Writer = File.DeprecatedWriter;
+
+fn getStdout() Writer {
+    return File.stdout().deprecatedWriter();
+}
+
+fn getStderr() Writer {
+    return File.stderr().deprecatedWriter();
+}
+
+// ─── Helpers ───
+
+fn parseF64(s: []const u8) ?f64 {
+    return std.fmt.parseFloat(f64, s) catch null;
+}
+
+fn parseRegion(s: []const u8) ?lib.ScreenshotRegion {
+    // Parse "x,y,w,h" format
+    var iter = std.mem.splitScalar(u8, s, ',');
+    const x_str = iter.next() orelse return null;
+    const y_str = iter.next() orelse return null;
+    const w_str = iter.next() orelse return null;
+    const h_str = iter.next() orelse return null;
+    return .{
+        .x = std.fmt.parseFloat(f64, x_str) catch return null,
+        .y = std.fmt.parseFloat(f64, y_str) catch return null,
+        .width = std.fmt.parseFloat(f64, w_str) catch return null,
+        .height = std.fmt.parseFloat(f64, h_str) catch return null,
+    };
+}
+
+fn printError(result: anytype) void {
+    const stderr = getStderr();
+    if (result.@"error") |err| {
+        stderr.print("error: {s} ({s})\n", .{ err.message, err.code }) catch {};
+    } else {
+        stderr.print("error: command failed\n", .{}) catch {};
+    }
+}
+
+fn printScreenshotJson(data: lib.ScreenshotOutput) void {
+    const stdout = getStdout();
+    stdout.print(
+        "{{\"path\":\"{s}\",\"desktopIndex\":{d:.0},\"captureX\":{d:.0},\"captureY\":{d:.0},\"captureWidth\":{d:.0},\"captureHeight\":{d:.0},\"imageWidth\":{d:.0},\"imageHeight\":{d:.0}}}\n",
+        .{ data.path, data.desktopIndex, data.captureX, data.captureY, data.captureWidth, data.captureHeight, data.imageWidth, data.imageHeight },
+    ) catch {};
+}
+
+// ─── Command definitions ───
+
+const Screenshot = zeke.cmd("screenshot [path]", "Take a screenshot")
+    .option("--region [region]", "Capture specific region (x,y,w,h)")
+    .option("--display [id]", "Target display")
+    .option("--window [id]", "Target window")
+    .option("--annotate", "Annotate with grid overlay")
+    .option("--json", "Output as JSON");
+
+const Click = zeke.cmd("click [target]", "Click at coordinates or target")
+    .option("-x <x>", "X coordinate")
+    .option("-y <y>", "Y coordinate")
+    .option("--button [button]", "Mouse button: left, right, middle")
+    .option("--count [count]", "Click count");
+
+const DebugPoint = zeke.cmd("debug-point [target]", "Validate click coordinates visually")
+    .option("-x [x]", "X coordinate")
+    .option("-y [y]", "Y coordinate")
+    .option("--output [path]", "Save annotated screenshot")
+    .option("--json", "Output as JSON");
+
+const TypeText = zeke.cmd("type [text]", "Type text using keyboard")
+    .option("--delay [ms]", "Delay between keystrokes in ms");
+
+const Press = zeke.cmd("press <key>", "Press a key or key combination")
+    .option("--count [n]", "Number of times to press")
+    .option("--delay [ms]", "Delay between presses in ms");
+
+const Scroll = zeke.cmd("scroll <direction> [amount]", "Scroll in a direction")
+    .option("--at [coords]", "Scroll at specific coordinates (x,y)");
+
+const Drag = zeke.cmd("drag <from> <to>", "Drag from one point to another")
+    .option("--duration [ms]", "Drag duration in ms")
+    .option("--button [button]", "Mouse button");
+
+const Hover = zeke.cmd("hover", "Move mouse without clicking")
+    .option("-x <x>", "X coordinate")
+    .option("-y <y>", "Y coordinate");
+
+const MouseMove = zeke.cmd("mouse move", "Move to absolute coordinates")
+    .option("-x <x>", "X coordinate")
+    .option("-y <y>", "Y coordinate");
+
+const MouseDown = zeke.cmd("mouse down", "Press and hold mouse button")
+    .option("--button [button]", "Mouse button");
+
+const MouseUp = zeke.cmd("mouse up", "Release mouse button")
+    .option("--button [button]", "Mouse button");
+
+const MousePosition = zeke.cmd("mouse position", "Print current mouse position")
+    .option("--json", "Output as JSON");
+
+const DisplayList = zeke.cmd("display list", "List connected displays")
+    .option("--json", "Output as JSON");
+
+const WindowList = zeke.cmd("window list", "List open windows")
+    .option("--json", "Output as JSON");
+
+const ClipboardGet = zeke.cmd("clipboard get", "Print clipboard text");
+
+const ClipboardSet = zeke.cmd("clipboard set <text>", "Set clipboard text");
+
+// ─── Action functions ───
+
+fn screenshotAction(args: Screenshot.Args, opts: Screenshot.Options) !void {
+    const result = lib.screenshot(.{
+        .path = args.path,
+        .display = if (opts.display) |d| parseF64(d) else null,
+        .window = if (opts.window) |w| parseF64(w) else null,
+        .region = if (opts.region) |r| parseRegion(r) else null,
+        .annotate = opts.annotate,
+    });
+    if (!result.ok) {
+        printError(result);
+        return error.CommandFailed;
+    }
+    if (opts.json) {
+        if (result.data) |data| {
+            printScreenshotJson(data);
+        }
+    } else {
+        const stdout = getStdout();
+        if (result.data) |data| {
+            try stdout.print("Screenshot saved to {s} ({d:.0}x{d:.0})\n", .{
+                data.path, data.imageWidth, data.imageHeight,
+            });
+        }
+    }
+}
+
+fn clickAction(_: Click.Args, opts: Click.Options) !void {
+    const x = parseF64(opts.x) orelse return error.InvalidCoordinate;
+    const y = parseF64(opts.y) orelse return error.InvalidCoordinate;
+    const result = lib.click(.{
+        .point = .{ .x = x, .y = y },
+        .button = opts.button,
+        .count = if (opts.count) |c| parseF64(c) else null,
+    });
+    if (!result.ok) {
+        printError(result);
+        return error.CommandFailed;
+    }
+}
+
+fn debugPointAction(_: DebugPoint.Args, _: DebugPoint.Options) !void {
+    const stderr = getStderr();
+    try stderr.print("debug-point: TODO\n", .{});
+}
+
+fn typeTextAction(args: TypeText.Args, opts: TypeText.Options) !void {
+    const text = args.text orelse {
+        const stderr = getStderr();
+        try stderr.print("error: text argument required\n", .{});
+        return error.MissingArgument;
+    };
+    const result = lib.typeText(.{
+        .text = text,
+        .delayMs = if (opts.delay) |d| parseF64(d) else null,
+    });
+    if (!result.ok) {
+        printError(result);
+        return error.CommandFailed;
+    }
+}
+
+fn pressAction(args: Press.Args, opts: Press.Options) !void {
+    const result = lib.press(.{
+        .key = args.key,
+        .count = if (opts.count) |c| parseF64(c) else null,
+        .delayMs = if (opts.delay) |d| parseF64(d) else null,
+    });
+    if (!result.ok) {
+        printError(result);
+        return error.CommandFailed;
+    }
+}
+
+fn scrollAction(args: Scroll.Args, opts: Scroll.Options) !void {
+    const amount: f64 = if (args.amount) |a| (parseF64(a) orelse 3.0) else 3.0;
+    var at: ?lib.Point = null;
+    if (opts.at) |at_str| {
+        var iter = std.mem.splitScalar(u8, at_str, ',');
+        const x_str = iter.next() orelse return error.InvalidCoordinate;
+        const y_str = iter.next() orelse return error.InvalidCoordinate;
+        at = .{
+            .x = std.fmt.parseFloat(f64, x_str) catch return error.InvalidCoordinate,
+            .y = std.fmt.parseFloat(f64, y_str) catch return error.InvalidCoordinate,
+        };
+    }
+    const result = lib.scroll(.{
+        .direction = args.direction,
+        .amount = amount,
+        .at = at,
+    });
+    if (!result.ok) {
+        printError(result);
+        return error.CommandFailed;
+    }
+}
+
+fn dragAction(args: Drag.Args, opts: Drag.Options) !void {
+    // Parse "x,y" format for from and to
+    const from = parsePointArg(args.from) orelse return error.InvalidCoordinate;
+    const to = parsePointArg(args.to) orelse return error.InvalidCoordinate;
+    const result = lib.drag(.{
+        .from = from,
+        .to = to,
+        .durationMs = if (opts.duration) |d| parseF64(d) else null,
+        .button = opts.button,
+    });
+    if (!result.ok) {
+        printError(result);
+        return error.CommandFailed;
+    }
+}
+
+fn parsePointArg(s: []const u8) ?lib.Point {
+    var iter = std.mem.splitScalar(u8, s, ',');
+    const x_str = iter.next() orelse return null;
+    const y_str = iter.next() orelse return null;
+    return .{
+        .x = std.fmt.parseFloat(f64, x_str) catch return null,
+        .y = std.fmt.parseFloat(f64, y_str) catch return null,
+    };
+}
+
+fn hoverAction(_: Hover.Args, opts: Hover.Options) !void {
+    const x = parseF64(opts.x) orelse return error.InvalidCoordinate;
+    const y = parseF64(opts.y) orelse return error.InvalidCoordinate;
+    const result = lib.hover(.{ .x = x, .y = y });
+    if (!result.ok) {
+        printError(result);
+        return error.CommandFailed;
+    }
+}
+
+fn mouseMoveAction(_: MouseMove.Args, opts: MouseMove.Options) !void {
+    const x = parseF64(opts.x) orelse return error.InvalidCoordinate;
+    const y = parseF64(opts.y) orelse return error.InvalidCoordinate;
+    const result = lib.mouseMove(.{ .x = x, .y = y });
+    if (!result.ok) {
+        printError(result);
+        return error.CommandFailed;
+    }
+}
+
+fn mouseDownAction(_: MouseDown.Args, opts: MouseDown.Options) !void {
+    const result = lib.mouseDown(.{ .button = opts.button });
+    if (!result.ok) {
+        printError(result);
+        return error.CommandFailed;
+    }
+}
+
+fn mouseUpAction(_: MouseUp.Args, opts: MouseUp.Options) !void {
+    const result = lib.mouseUp(.{ .button = opts.button });
+    if (!result.ok) {
+        printError(result);
+        return error.CommandFailed;
+    }
+}
+
+fn mousePositionAction(_: MousePosition.Args, opts: MousePosition.Options) !void {
+    const result = lib.mousePosition();
+    if (!result.ok) {
+        printError(result);
+        return error.CommandFailed;
+    }
+    if (result.data) |pos| {
+        const stdout = getStdout();
+        if (opts.json) {
+            try stdout.print("{{\"x\":{d:.0},\"y\":{d:.0}}}\n", .{ pos.x, pos.y });
+        } else {
+            try stdout.print("{d:.0}, {d:.0}\n", .{ pos.x, pos.y });
+        }
+    }
+}
+
+fn displayListAction(_: DisplayList.Args, opts: DisplayList.Options) !void {
+    const result = lib.displayList();
+    if (!result.ok) {
+        printError(result);
+        return error.CommandFailed;
+    }
+    if (result.data) |data| {
+        const stdout = getStdout();
+        if (opts.json) {
+            try stdout.print("{s}\n", .{data});
+        } else {
+            try stdout.print("{s}\n", .{data});
+        }
+    }
+}
+
+fn windowListAction(_: WindowList.Args, opts: WindowList.Options) !void {
+    const result = lib.windowList();
+    if (!result.ok) {
+        printError(result);
+        return error.CommandFailed;
+    }
+    if (result.data) |data| {
+        const stdout = getStdout();
+        if (opts.json) {
+            try stdout.print("{s}\n", .{data});
+        } else {
+            try stdout.print("{s}\n", .{data});
+        }
+    }
+}
+
+fn clipboardGetAction(_: ClipboardGet.Args, _: ClipboardGet.Options) !void {
+    const result = lib.clipboardGet();
+    if (!result.ok) {
+        printError(result);
+        return error.CommandFailed;
+    }
+    if (result.data) |data| {
+        const stdout = getStdout();
+        try stdout.print("{s}\n", .{data});
+    }
+}
+
+fn clipboardSetAction(args: ClipboardSet.Args, _: ClipboardSet.Options) !void {
+    const result = lib.clipboardSet(.{ .text = args.text });
+    if (!result.ok) {
+        printError(result);
+        return error.CommandFailed;
+    }
+}
+
+// ─── Main ───
+
+pub fn main() !void {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    defer _ = gpa.deinit();
+
+    var app = zeke.App(.{
+        Screenshot.bind(screenshotAction),
+        Click.bind(clickAction),
+        DebugPoint.bind(debugPointAction),
+        TypeText.bind(typeTextAction),
+        Press.bind(pressAction),
+        Scroll.bind(scrollAction),
+        Drag.bind(dragAction),
+        Hover.bind(hoverAction),
+        MouseMove.bind(mouseMoveAction),
+        MouseDown.bind(mouseDownAction),
+        MouseUp.bind(mouseUpAction),
+        MousePosition.bind(mousePositionAction),
+        DisplayList.bind(displayListAction),
+        WindowList.bind(windowListAction),
+        ClipboardGet.bind(clipboardGetAction),
+        ClipboardSet.bind(clipboardSetAction),
+    }).init(gpa.allocator(), "usecomputer");
+
+    app.setVersion("0.0.4");
+    app.run() catch |err| {
+        switch (err) {
+            error.CommandFailed, error.InvalidCoordinate, error.MissingArgument => {},
+            else => {
+                const stderr = getStderr();
+                stderr.print("error: {s}\n", .{@errorName(err)}) catch {};
+            },
+        }
+        std.process.exit(1);
+    };
+}

package/zig/src/scroll.zig

@@ -0,0 +1,213 @@
+// Cross-platform native scroll event helpers for the usecomputer Zig module.
+
+const std = @import("std");
+const builtin = @import("builtin");
+
+const c_macos = if (builtin.target.os.tag == .macos) @cImport({
+    @cInclude("CoreGraphics/CoreGraphics.h");
+    @cInclude("CoreFoundation/CoreFoundation.h");
+}) else struct {};
+
+const c_windows = if (builtin.target.os.tag == .windows) @cImport({
+    @cInclude("windows.h");
+}) else struct {};
+
+const c_x11 = if (builtin.target.os.tag == .linux) @cImport({
+    @cInclude("X11/Xlib.h");
+    @cInclude("X11/extensions/XTest.h");
+}) else struct {};
+
+pub const ScrollArgs = struct {
+    direction: []const u8,
+    amount: f64,
+    at_x: ?f64 = null,
+    at_y: ?f64 = null,
+};
+
+const ScrollDirection = enum {
+    up,
+    down,
+    left,
+    right,
+};
+
+pub fn scroll(args: ScrollArgs) !void {
+    const direction = try parseDirection(args.direction);
+    const steps = try normalizeAmount(args.amount);
+
+    switch (builtin.target.os.tag) {
+        .macos => {
+            try scrollMacos(.{ .direction = direction, .steps = steps, .at_x = args.at_x, .at_y = args.at_y });
+        },
+        .windows => {
+            try scrollWindows(.{ .direction = direction, .steps = steps, .at_x = args.at_x, .at_y = args.at_y });
+        },
+        .linux => {
+            try scrollX11(.{ .direction = direction, .steps = steps, .at_x = args.at_x, .at_y = args.at_y });
+        },
+        else => {
+            return error.UnsupportedPlatform;
+        },
+    }
+}
+
+fn parseDirection(direction: []const u8) !ScrollDirection {
+    if (std.ascii.eqlIgnoreCase(direction, "up")) {
+        return .up;
+    }
+    if (std.ascii.eqlIgnoreCase(direction, "down")) {
+        return .down;
+    }
+    if (std.ascii.eqlIgnoreCase(direction, "left")) {
+        return .left;
+    }
+    if (std.ascii.eqlIgnoreCase(direction, "right")) {
+        return .right;
+    }
+    return error.InvalidDirection;
+}
+
+fn normalizeAmount(amount: f64) !i32 {
+    if (!std.math.isFinite(amount)) {
+        return error.InvalidAmount;
+    }
+    const rounded = @as(i64, @intFromFloat(std.math.round(amount)));
+    if (rounded <= 0) {
+        return error.InvalidAmount;
+    }
+    if (rounded > std.math.maxInt(i32)) {
+        return error.AmountTooLarge;
+    }
+    return @as(i32, @intCast(rounded));
+}
+
+fn scrollMacos(args: struct {
+    direction: ScrollDirection,
+    steps: i32,
+    at_x: ?f64,
+    at_y: ?f64,
+}) !void {
+    if (args.at_x != null and args.at_y != null) {
+        const point: c_macos.CGPoint = .{ .x = args.at_x.?, .y = args.at_y.? };
+        const warp_result = c_macos.CGWarpMouseCursorPosition(point);
+        if (warp_result != c_macos.kCGErrorSuccess) {
+            return error.CGWarpMouseFailed;
+        }
+    }
+
+    var delta_y: i32 = 0;
+    var delta_x: i32 = 0;
+    switch (args.direction) {
+        .up => {
+            delta_y = args.steps;
+        },
+        .down => {
+            delta_y = -args.steps;
+        },
+        .left => {
+            delta_x = -args.steps;
+        },
+        .right => {
+            delta_x = args.steps;
+        },
+    }
+
+    const event = c_macos.CGEventCreateScrollWheelEvent(
+        null,
+        c_macos.kCGScrollEventUnitLine,
+        2,
+        delta_y,
+        delta_x,
+    );
+    if (event == null) {
+        return error.CGEventCreateFailed;
+    }
+    defer c_macos.CFRelease(event);
+
+    if (args.at_x != null and args.at_y != null) {
+        const location: c_macos.CGPoint = .{ .x = args.at_x.?, .y = args.at_y.? };
+        c_macos.CGEventSetLocation(event, location);
+    }
+
+    c_macos.CGEventPost(c_macos.kCGHIDEventTap, event);
+}
+
+fn scrollWindows(args: struct {
+    direction: ScrollDirection,
+    steps: i32,
+    at_x: ?f64,
+    at_y: ?f64,
+}) !void {
+    if (args.at_x != null and args.at_y != null) {
+        const x = @as(i64, @intFromFloat(std.math.round(args.at_x.?)));
+        const y = @as(i64, @intFromFloat(std.math.round(args.at_y.?)));
+        if (x < std.math.minInt(i32) or x > std.math.maxInt(i32) or y < std.math.minInt(i32) or y > std.math.maxInt(i32)) {
+            return error.InvalidPoint;
+        }
+        _ = c_windows.SetCursorPos(@as(c_int, @intCast(x)), @as(c_int, @intCast(y)));
+    }
+
+    var flags: u32 = 0;
+    var delta: i32 = 0;
+    switch (args.direction) {
+        .up => {
+            flags = c_windows.MOUSEEVENTF_WHEEL;
+            delta = args.steps;
+        },
+        .down => {
+            flags = c_windows.MOUSEEVENTF_WHEEL;
+            delta = -args.steps;
+        },
+        .left => {
+            flags = c_windows.MOUSEEVENTF_HWHEEL;
+            delta = -args.steps;
+        },
+        .right => {
+            flags = c_windows.MOUSEEVENTF_HWHEEL;
+            delta = args.steps;
+        },
+    }
+
+    var event = std.mem.zeroes(c_windows.INPUT);
+    event.type = c_windows.INPUT_MOUSE;
+    event.Anonymous.mi.dwFlags = flags;
+    event.Anonymous.mi.mouseData = @as(c_uint, @intCast(delta * c_windows.WHEEL_DELTA));
+    const sent = c_windows.SendInput(1, &event, @sizeOf(c_windows.INPUT));
+    if (sent == 0) {
+        return error.EventPostFailed;
+    }
+}
+
+fn scrollX11(args: struct {
+    direction: ScrollDirection,
+    steps: i32,
+    at_x: ?f64,
+    at_y: ?f64,
+}) !void {
+    const display = c_x11.XOpenDisplay(null) orelse return error.XOpenDisplayFailed;
+    defer _ = c_x11.XCloseDisplay(display);
+
+    if (args.at_x != null and args.at_y != null) {
+        const x = @as(i64, @intFromFloat(std.math.round(args.at_x.?)));
+        const y = @as(i64, @intFromFloat(std.math.round(args.at_y.?)));
+        if (x < std.math.minInt(i32) or x > std.math.maxInt(i32) or y < std.math.minInt(i32) or y > std.math.maxInt(i32)) {
+            return error.InvalidPoint;
+        }
+        _ = c_x11.XWarpPointer(display, 0, c_x11.XDefaultRootWindow(display), 0, 0, 0, 0, @as(c_int, @intCast(x)), @as(c_int, @intCast(y)));
+    }
+
+    const button_code: c_uint = switch (args.direction) {
+        .up => 4,
+        .down => 5,
+        .left => 6,
+        .right => 7,
+    };
+
+    const repeat_count: u32 = @as(u32, @intCast(args.steps));
+    var index: u32 = 0;
+    while (index < repeat_count) : (index += 1) {
+        _ = c_x11.XTestFakeButtonEvent(display, button_code, c_x11.True, c_x11.CurrentTime);
+        _ = c_x11.XTestFakeButtonEvent(display, button_code, c_x11.False, c_x11.CurrentTime);
+    }
+    _ = c_x11.XFlush(display);
+}