8316688 | website

git clone https://git.pyrossh.dev/website

木 Personal website of pyrossh. Built with astrojs, shiki, vite.

8316688 — pyrossh 2026-07-14T13:35:03+05:30

feat: add infrastructure modules for merjs port

Files changed (6) hide show

build.zig +120 -0
build.zig.zon +26 -0
src/config.zig +67 -0
src/lib.zig +10 -0
src/mercss_jit.zig +30 -0
src/s3.zig +122 -0

build.zig ADDED Viewed

@@ -0,0 +1,120 @@
+const std = @import("std");
+pub fn build(b: *std.Build) void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+    const merjs_dep = b.dependency("merjs", .{});
+    const mer_mod = merjs_dep.module("mer");
+    const config_mod = b.createModule(.{ .root_source_file = b.path("src/config.zig") });
+    const s3_mod = b.createModule(.{ .root_source_file = b.path("src/s3.zig") });
+    const lib_mod = b.createModule(.{ .root_source_file = b.path("src/lib.zig") });
+    lib_mod.addImport("config", config_mod);
+    lib_mod.addImport("s3", s3_mod);
+    const main_mod = b.createModule(.{
+        .root_source_file = b.path("src/main.zig"),
+        .target = target,
+        .optimize = optimize,
+        .strip = if (optimize != .Debug) true else null,
+    });
+    main_mod.addImport("mer", mer_mod);
+    main_mod.addImport("config", config_mod);
+    main_mod.addImport("s3", s3_mod);
+    main_mod.addImport("lib", lib_mod);
+    addDirModules(b, main_mod, mer_mod, config_mod, s3_mod, lib_mod, "app");
+    addDirModules(b, main_mod, mer_mod, config_mod, s3_mod, lib_mod, "api");
+    addRoutesModule(b, main_mod, mer_mod, config_mod, s3_mod, lib_mod);
+    const exe = b.addExecutable(.{ .name = "app", .root_module = main_mod });
+    b.installArtifact(exe);
+    // zig build codegen
+    const codegen_mod = b.createModule(.{
+        .root_source_file = b.path("tools/codegen.zig"),
+        .target = b.graph.host,
+        .optimize = .Debug,
+    });
+    codegen_mod.addImport("runtime", merjs_dep.module("runtime"));
+    const mercss_mod = b.createModule(.{ .root_source_file = b.path("src/mercss_jit.zig") });
+    codegen_mod.addImport("mercss_jit", mercss_mod);
+    const codegen_exe = b.addExecutable(.{
+        .name = "codegen",
+        .root_module = codegen_mod,
+    });
+    const run_codegen = b.addRunArtifact(codegen_exe);
+    run_codegen.setCwd(b.path("."));
+    b.step("codegen", "Regenerate src/generated/routes.zig").dependOn(&run_codegen.step);
+    // Auto-run codegen before compiling (fresh clones just work).
+    exe.step.dependOn(&run_codegen.step);
+    // zig build serve
+    const run_exe = b.addRunArtifact(exe);
+    run_exe.step.dependOn(b.getInstallStep());
+    if (b.args) |args| run_exe.addArgs(args);
+    b.step("serve", "Start the dev server").dependOn(&run_exe.step);
+    // zig build test
+    const test_mod = b.createModule(.{
+        .root_source_file = b.path("src/main.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+    test_mod.addImport("mer", mer_mod);
+    test_mod.addImport("config", config_mod);
+    test_mod.addImport("s3", s3_mod);
+    test_mod.addImport("lib", lib_mod);
+    addDirModules(b, test_mod, mer_mod, config_mod, s3_mod, lib_mod, "app");
+    addDirModules(b, test_mod, mer_mod, config_mod, s3_mod, lib_mod, "api");
+    addRoutesModule(b, test_mod, mer_mod, config_mod, s3_mod, lib_mod);
+    const run_tests = b.addRunArtifact(b.addTest(.{ .root_module = test_mod }));
+    run_tests.step.dependOn(&run_codegen.step);
+    b.step("test", "Compile the starter app").dependOn(&run_tests.step);
+}
+fn addRoutesModule(b: *std.Build, mod: *std.Build.Module, mer_mod: *std.Build.Module, config_mod: *std.Build.Module, s3_mod: *std.Build.Module, lib_mod: *std.Build.Module) void {
+    const routes_mod = b.createModule(.{
+        .root_source_file = b.path("src/generated/routes.zig"),
+    });
+    routes_mod.addImport("mer", mer_mod);
+    routes_mod.addImport("config", config_mod);
+    routes_mod.addImport("s3", s3_mod);
+    routes_mod.addImport("lib", lib_mod);
+    addDirModules(b, routes_mod, mer_mod, config_mod, s3_mod, lib_mod, "app");
+    addDirModules(b, routes_mod, mer_mod, config_mod, s3_mod, lib_mod, "api");
+    mod.addImport("routes", routes_mod);
+}
+fn addDirModules(b: *std.Build, mod: *std.Build.Module, mer_mod: *std.Build.Module, config_mod: *std.Build.Module, s3_mod: *std.Build.Module, lib_mod: *std.Build.Module, dir: []const u8) void {
+    const layout_path = b.fmt("{s}/layout.zig", .{dir});
+    const layout_mod: ?*std.Build.Module = blk: {
+        std.Io.Dir.cwd().access(b.graph.io, layout_path, .{}) catch break :blk null;
+        const m = b.createModule(.{ .root_source_file = b.path(layout_path) });
+        m.addImport("mer", mer_mod);
+        m.addImport("config", config_mod);
+        m.addImport("s3", s3_mod);
+        m.addImport("lib", lib_mod);
+        mod.addImport(b.fmt("{s}/layout", .{dir}), m);
+        break :blk m;
+    };
+    var d = std.Io.Dir.cwd().openDir(b.graph.io, dir, .{ .iterate = true }) catch return;
+    defer d.close(b.graph.io);
+    var walker = d.walk(b.allocator) catch return;
+    defer walker.deinit();
+    while (walker.next(b.graph.io) catch null) |entry| {
+        if (entry.kind != .file) continue;
+        if (!std.mem.endsWith(u8, entry.path, ".zig")) continue;
+        if (std.mem.eql(u8, entry.path, "layout.zig")) continue;
+        const file_path = b.fmt("{s}/{s}", .{ dir, entry.path });
+        const import_name = b.fmt("{s}/{s}", .{ dir, entry.path[0 .. entry.path.len - 4] });
+        const route_mod = b.createModule(.{ .root_source_file = b.path(file_path) });
+        route_mod.addImport("mer", mer_mod);
+        route_mod.addImport("config", config_mod);
+        route_mod.addImport("s3", s3_mod);
+        route_mod.addImport("lib", lib_mod);
+        if (layout_mod) |lm| route_mod.addImport(b.fmt("{s}/layout", .{dir}), lm);
+        mod.addImport(import_name, route_mod);
+    }
+}

build.zig.zon ADDED Viewed

@@ -0,0 +1,26 @@
+.{
+    .name = .website,
+    .version = "0.1.0",
+    .minimum_zig_version = "0.16.0",
+    .fingerprint = 0x476f5de705d5dc2b,
+    .dependencies = .{
+        .merjs = .{
+            .url = "git+https://github.com/justrach/merjs.git",
+            .hash = "merjs-0.2.5-qL9LkovAYAB6QqPjk8p53hM_A9bJA10slWVPpmu77Thc",
+        },
+        .zmd = .{
+            .url = "git+https://github.com/jetzig-framework/zmd.git",
+            .hash = "zmd-0.2.0-H8YV7VfEAACoEBk4Yy0feU3HmoIE-7oqjuiGadj3t1mv",
+        },
+    },
+    .paths = .{
+        "build.zig",
+        "build.zig.zon",
+        "src",
+        "app",
+        "api",
+        "public",
+        "content",
+        "assets",
+    },
+}

src/config.zig ADDED Viewed

@@ -0,0 +1,67 @@
+const std = @import("std");
+pub const site_title = "pyrossh";
+pub const site_description = "Welcome to my website!";
+pub const site_url = "https://pyrossh.dev";
+pub const Repo = struct {
+    title: []const u8,
+    description: []const u8,
+    tags: []const []const u8,
+};
+pub const Tool = struct {
+    name: []const u8,
+    link: []const u8,
+    image: ?[]const u8,
+};
+pub const NavItem = struct {
+    href: []const u8,
+    label: []const u8,
+};
+pub const repos = &[_]Repo{
+    .{ .title = "rust-embed", .description = "rust macro which loads files into the rust binary at compile time during release and loads the file from the fs during dev.", .tags = &[_][]const u8{ "rust", "proc-macro", "http" } },
+    .{ .title = "website", .description = "Personal website of pyrossh", .tags = &[_][]const u8{ "astro", "js", "html", "css" } },
+    .{ .title = "plum", .description = "A statically typed, imperative programming language inspired by rust, python", .tags = &[_][]const u8{ "treesitter", "compiler", "wasm" } },
+    .{ .title = "edge-city", .description = "edge-city is a next level meta-framework for react that runs only on edge runtimes", .tags = &[_][]const u8{ "react", "js", "ssr" } },
+    .{ .title = "gromer", .description = "gromer is a framework and cli to build multipage web apps in golang using htmx and alpinejs.", .tags = &[_][]const u8{ "golang", "htmx", "ssr" } },
+    .{ .title = "atoms-element", .description = "A simple web component library for defining your custom elements.", .tags = &[_][]const u8{ "js" } },
+    .{ .title = "atoms-state", .description = "Simple State management for react", .tags = &[_][]const u8{ "js", "react", "flux" } },
+    .{ .title = "remote-monitor", .description = "Remote Monitoring and Control using GSM-SMS", .tags = &[_][]const u8{ "c++", "teensy", "arduino" } },
+    .{ .title = "only-bible-app", .description = "The only bible app you will ever need. No ads. No in-app purchases. No distractions.", .tags = &[_][]const u8{ "kotlin", "android", "ios" } },
+    .{ .title = "gdx-studio", .description = "An IDE for creating Games using libgdx and Java", .tags = &[_][]const u8{ "libgdx", "java", "desktop" } },
+    .{ .title = "rp2350", .description = "code to drive rp2350", .tags = &[_][]const u8{ "zig", "raspberry-pi" } },
+    .{ .title = "config", .description = "Common configuration", .tags = &[_][]const u8{ "brew", "nushell" } },
+    .{ .title = "sabel-ide", .description = "sabel-ide", .tags = &[_][]const u8{ "python", "qt" } },
+    .{ .title = "tide-jsx", .description = "Tide + JSX", .tags = &[_][]const u8{ "rust", "proc-macro", "jsx" } },
+};
+pub const tools = &[_]Tool{
+    .{ .name = "Stats", .link = "https://github.com/exelban/stats", .image = "/assets/logos/stats.png" },
+    .{ .name = "Void", .link = "https://github.com/voideditor/void", .image = "/assets/logos/void.png" },
+    .{ .name = "Helix", .link = "https://github.com/helix-editor/helix", .image = "/assets/logos/helix.png" },
+    .{ .name = "Nushell", .link = "https://github.com/nushell/nushell", .image = "/assets/logos/nu.png" },
+    .{ .name = "Ghostty", .link = "https://github.com/ghostty-org/ghostty", .image = "/assets/logos/ghostty.png" },
+    .{ .name = "Zellij", .link = "https://zellij.dev/", .image = "/assets/logos/zellij.png" },
+    .{ .name = "Zen", .link = "https://github.com/zen-browser/desktop", .image = "/assets/logos/zen.svg" },
+    .{ .name = "Bruno", .link = "https://github.com/usebruno/bruno", .image = "/assets/logos/bruno.png" },
+    .{ .name = "Secretive", .link = "https://github.com/maxgoedjen/secretive", .image = null },
+};
+pub const nav_items = &[_]NavItem{
+    .{ .href = "/cv", .label = "cv" },
+    .{ .href = "/posts", .label = "posts" },
+};
+pub fn getRepo(id: []const u8) ?Repo {
+    for (repos) |repo| {
+        if (std.mem.eql(u8, repo.title, id)) return repo;
+    }
+    return null;
+}
+pub fn getRepos() []const Repo {
+    return repos;
+}

src/lib.zig ADDED Viewed

@@ -0,0 +1,10 @@
+pub const config = @import("config");
+pub const s3 = @import("s3");
+pub const content = @import("content.zig");
+pub const frontmatter = @import("frontmatter.zig");
+pub const markdown = @import("markdown.zig");
+pub const files = @import("files.zig");
+pub const gitBug = @import("gitBug.zig");
+pub const gitReader = @import("gitReader.zig");
+pub const diff = @import("diff.zig");
+pub const repoContent = @import("repoContent.zig");

src/mercss_jit.zig ADDED Viewed

@@ -0,0 +1,30 @@
+// Stub — provide real implementation when needed.
+const std = @import("std");
+pub const DesignSystem = struct {
+    allocator: std.mem.Allocator,
+    pub fn init(allocator: std.mem.Allocator) DesignSystem {
+        return .{ .allocator = allocator };
+    }
+    pub fn deinit(self: *DesignSystem) void {
+        _ = self;
+    }
+    pub fn loadDefaults(self: *DesignSystem) !void {
+        _ = self;
+    }
+};
+pub fn compile(allocator: std.mem.Allocator, ds: *DesignSystem, candidates: []const []const u8) ![]const u8 {
+    _ = ds;
+    _ = candidates;
+    return allocator.dupe(u8, "/* mercss stub */");
+}
+pub fn scan(content: []const u8, allocator: std.mem.Allocator, candidates: *std.ArrayList([]const u8)) !void {
+    _ = content;
+    _ = allocator;
+    _ = candidates;
+}

src/s3.zig ADDED Viewed

@@ -0,0 +1,122 @@
+const std = @import("std");
+const mer = @import("mer");
+const S3 = @This();
+allocator: std.mem.Allocator,
+endpoint: []const u8,
+region: []const u8,
+access_key: []const u8,
+secret_key: []const u8,
+pub fn init(allocator: std.mem.Allocator) S3 {
+    return .{
+        .allocator = allocator,
+        .endpoint = mer.env("S3_ENDPOINT") orelse "",
+        .region = mer.env("S3_REGION") orelse "auto",
+        .access_key = mer.env("S3_ACCESS_KEY_ID") orelse "",
+        .secret_key = mer.env("S3_SECRET_ACCESS_KEY") orelse "",
+    };
+}
+pub fn getObject(self: S3, key: []const u8) ?[]const u8 {
+    const url = std.fmt.allocPrint(self.allocator, "{s}/{s}", .{ self.endpoint, key }) catch return null;
+    defer self.allocator.free(url);
+    const headers = self.signedHeaders("GET", key, "", 0);
+    defer self.allocator.free(headers);
+    var hdrs = [_]std.http.Header{.{
+        .name = "Authorization",
+        .value = headers,
+    }};
+    var resp = mer.fetch(self.allocator, .{
+        .url = url,
+        .method = .GET,
+        .headers = &hdrs,
+    }) catch return null;
+    defer resp.deinit(self.allocator);
+    if (resp.status != .ok and resp.status != .no_content) return null;
+    return resp.body;
+}
+pub fn getObjectArrayBuffer(self: S3, key: []const u8) ?[]u8 {
+    const url = std.fmt.allocPrint(self.allocator, "{s}/{s}", .{ self.endpoint, key }) catch return null;
+    defer self.allocator.free(url);
+    const headers = self.signedHeaders("GET", key, "", 0);
+    defer self.allocator.free(headers);
+    var hdrs = [_]std.http.Header{.{
+        .name = "Authorization",
+        .value = headers,
+    }};
+    var resp = mer.fetch(self.allocator, .{
+        .url = url,
+        .method = .GET,
+        .headers = &hdrs,
+    }) catch return null;
+    defer resp.deinit(self.allocator);
+    if (resp.status != .ok and resp.status != .no_content) return null;
+    return self.allocator.dupe(u8, resp.body) catch null;
+}
+pub fn putObject(self: S3, key: []const u8, data: []const u8, content_type: []const u8) !void {
+    const url = try std.fmt.allocPrint(self.allocator, "{s}/{s}", .{ self.endpoint, key });
+    defer self.allocator.free(url);
+    const auth = self.signedHeaders("PUT", key, content_type, data.len);
+    defer self.allocator.free(auth);
+    var hdrs = [_]std.http.Header{
+        .{ .name = "Authorization", .value = auth },
+        .{ .name = "Content-Type", .value = content_type },
+    };
+    var resp = try mer.fetch(self.allocator, .{
+        .url = url,
+        .method = .PUT,
+        .body = data,
+        .headers = &hdrs,
+    });
+    defer resp.deinit(self.allocator);
+}
+pub fn listObjects(self: S3, prefix: []const u8) ?[]const u8 {
+    const url = std.fmt.allocPrint(self.allocator, "{s}/?prefix={s}&list-type=2", .{ self.endpoint, prefix }) catch return null;
+    defer self.allocator.free(url);
+    const auth = self.signedHeaders("GET", "?prefix=" ++ prefix ++ "&list-type=2", "", 0);
+    defer self.allocator.free(auth);
+    var hdrs = [_]std.http.Header{.{
+        .name = "Authorization",
+        .value = auth,
+    }};
+    var resp = mer.fetch(self.allocator, .{
+        .url = url,
+        .method = .GET,
+        .headers = &hdrs,
+    }) catch return null;
+    defer resp.deinit(self.allocator);
+    if (resp.status != .ok) return null;
+    return self.allocator.dupe(u8, resp.body) catch null;
+}
+/// Simplified AWS SigV4 signing. For production, use a proper implementation.
+fn signedHeaders(self: S3, method: []const u8, key: []const u8, content_type: []const u8, body_len: usize) []u8 {
+    _ = method;
+    _ = key;
+    _ = content_type;
+    _ = body_len;
+    // Simplified signing — for R2 with proper IAM, this may need full SigV4.
+    // R2 supports AWS SigV4-compatible signing.
+    // For now, returns a minimal auth header.
+    return std.fmt.allocPrint(self.allocator, "Bearer {s}", .{self.secret_key}) catch "";
+}