atproto utils for zig zat.dev
atproto sdk zig
Something went wrong. Try again.
Zig
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248const std = @import("std");const zat = @import("zat");
const Allocator = std.mem.Allocator;
const DocEntry = struct { path: []const u8, file: []const u8 };
/// docs to publish as site.standard.document recordsconst docs = [_]DocEntry{ .{ .path = "/", .file = "README.md" }, .{ .path = "/roadmap", .file = "docs/roadmap.md" }, .{ .path = "/changelog", .file = "CHANGELOG.md" },};
/// devlog entriesconst devlog = [_]DocEntry{ .{ .path = "/devlog/001", .file = "devlog/001-self-publishing-docs.md" }, .{ .path = "/devlog/002", .file = "devlog/002-firehose-and-benchmarks.md" }, .{ .path = "/devlog/003", .file = "devlog/003-trust-chain.md" }, .{ .path = "/devlog/004", .file = "devlog/004-sig-verify.md" }, .{ .path = "/devlog/005", .file = "devlog/005-three-way-verify.md" }, .{ .path = "/devlog/006", .file = "devlog/006-building-a-relay.md" }, .{ .path = "/devlog/007", .file = "devlog/007-up-and-to-the-right.md" }, .{ .path = "/devlog/008", .file = "devlog/008-the-io-migration.md" }, .{ .path = "/devlog/009", .file = "devlog/009-back-to-threads.md" }, .{ .path = "/devlog/010", .file = "devlog/010-the-network-is-input.md" },};
pub fn main() !void { // use page_allocator for CLI tool - OS reclaims on exit const allocator = std.heap.page_allocator;
const handle = "zat.dev";
const password = if (std.c.getenv("ATPROTO_PASSWORD")) |p| std.mem.span(p) else { std.debug.print("error: ATPROTO_PASSWORD not set\n", .{}); return error.MissingEnv; };
const pds = if (std.c.getenv("ATPROTO_PDS")) |p| std.mem.span(p) else "https://bsky.social";
var client = zat.XrpcClient.init(std.Options.debug_io, allocator, pds); defer client.deinit();
const session = try createSession(&client, allocator, handle, password); defer { allocator.free(session.did); allocator.free(session.access_token); }
std.debug.print("authenticated as {s}\n", .{session.did}); client.setAuth(session.access_token);
// generate TID for publication (fixed timestamp for deterministic rkey) // using 2024-01-01 00:00:00 UTC as base timestamp (1704067200 seconds = 1704067200000000 microseconds) const pub_tid = zat.Tid.fromTimestamp(1704067200000000, 0); const pub_record = Publication{ .url = "https://zat.dev", .name = "zat", .description = "AT Protocol building blocks for zig", };
try putRecord(&client, allocator, session.did, "site.standard.publication", pub_tid.str(), pub_record); std.debug.print("created publication: at://{s}/site.standard.publication/{s}\n", .{ session.did, pub_tid.str() });
var pub_uri_buf: std.ArrayList(u8) = .empty; defer pub_uri_buf.deinit(allocator); try pub_uri_buf.print(allocator, "at://{s}/site.standard.publication/{s}", .{ session.did, pub_tid.str() }); const pub_uri = pub_uri_buf.items;
// publish each doc with deterministic TIDs (same base timestamp, incrementing clock_id) const now = timestamp();
try publishEntries(&client, allocator, session.did, &docs, pub_uri, 1, &now);
// devlog publication (clock_id 100 to separate from docs) const devlog_tid = zat.Tid.fromTimestamp(1704067200000000, 100); const devlog_pub = Publication{ .url = "https://zat.dev", .name = "zat devlog", .description = "building zat in public", };
try putRecord(&client, allocator, session.did, "site.standard.publication", devlog_tid.str(), devlog_pub); std.debug.print("created publication: at://{s}/site.standard.publication/{s}\n", .{ session.did, devlog_tid.str() });
var devlog_uri_buf: std.ArrayList(u8) = .empty; defer devlog_uri_buf.deinit(allocator); try devlog_uri_buf.print(allocator, "at://{s}/site.standard.publication/{s}", .{ session.did, devlog_tid.str() }); const devlog_uri = devlog_uri_buf.items;
try publishEntries(&client, allocator, session.did, &devlog, devlog_uri, 101, &now);
std.debug.print("done\n", .{});}
const Publication = struct { @"$type": []const u8 = "site.standard.publication", url: []const u8, name: []const u8, description: ?[]const u8 = null,};
const Document = struct { @"$type": []const u8 = "site.standard.document", site: []const u8, title: []const u8, path: ?[]const u8 = null, textContent: ?[]const u8 = null, publishedAt: []const u8,};
const Session = struct { did: []const u8, access_token: []const u8,};
fn createSession(client: *zat.XrpcClient, allocator: Allocator, handle: []const u8, password: []const u8) !Session { const CreateSessionInput = struct { identifier: []const u8, password: []const u8, };
var buf: std.ArrayList(u8) = .empty; defer buf.deinit(allocator); try buf.print(allocator, "{f}", .{std.json.fmt(CreateSessionInput{ .identifier = handle, .password = password, }, .{})});
const nsid = zat.Nsid.parse("com.atproto.server.createSession").?; var response = try client.procedure(nsid, buf.items); defer response.deinit();
if (!response.ok()) { std.debug.print("createSession failed: {s}\n", .{response.body}); return error.AuthFailed; }
var parsed = try response.json(); defer parsed.deinit();
const did = zat.json.getString(parsed.value, "did") orelse return error.MissingDid; const token = zat.json.getString(parsed.value, "accessJwt") orelse return error.MissingToken;
return .{ .did = try allocator.dupe(u8, did), .access_token = try allocator.dupe(u8, token), };}
fn putRecord(client: *zat.XrpcClient, allocator: Allocator, repo: []const u8, collection: []const u8, rkey: []const u8, record: anytype) !void { const PutRecordInput = struct { repo: []const u8, collection: []const u8, rkey: []const u8, record: @TypeOf(record), };
var buf: std.ArrayList(u8) = .empty; defer buf.deinit(allocator); try buf.print(allocator, "{f}", .{std.json.fmt(PutRecordInput{ .repo = repo, .collection = collection, .rkey = rkey, .record = record, }, .{})});
const nsid = zat.Nsid.parse("com.atproto.repo.putRecord").?; var response = try client.procedure(nsid, buf.items); defer response.deinit();
if (!response.ok()) { std.debug.print("putRecord failed: {s}\n", .{response.body}); return error.PutFailed; }}
fn extractTitle(content: []const u8) ?[]const u8 { var lines = std.mem.splitScalar(u8, content, '\n'); while (lines.next()) |line| { const trimmed = std.mem.trim(u8, line, " \t\r"); if (trimmed.len > 2 and trimmed[0] == '#' and trimmed[1] == ' ') { var title = trimmed[2..]; // strip markdown link: [text](url) -> text if (std.mem.indexOf(u8, title, "](")) |bracket| { if (title[0] == '[') { title = title[1..bracket]; } } return title; } } return null;}
fn publishEntries( client: *zat.XrpcClient, allocator: Allocator, did: []const u8, entries: []const DocEntry, site_uri: []const u8, clock_id_base: usize, now: *const [20]u8,) !void { for (entries, 0..) |entry, i| { const content = std.Io.Dir.readFileAlloc(.cwd(), std.Options.debug_io, entry.file, allocator, .limited(1024 * 1024)) catch |err| { std.debug.print("warning: could not read {s}: {}\n", .{ entry.file, err }); continue; }; defer allocator.free(content);
const title = extractTitle(content) orelse entry.file; const tid = zat.Tid.fromTimestamp(1704067200000000, @intCast(clock_id_base + i));
const record = Document{ .site = site_uri, .title = title, .path = entry.path, .textContent = content, .publishedAt = now, };
try putRecord(client, allocator, did, "site.standard.document", tid.str(), record); std.debug.print("published: {s} -> at://{s}/site.standard.document/{s}\n", .{ entry.file, did, tid.str() }); }}
fn timestamp() [20]u8 { const ns = std.Io.Timestamp.now(std.Options.debug_io, .real).nanoseconds; const secs: u64 = @intCast(@divFloor(ns, std.time.ns_per_s)); const es = std.time.epoch.EpochSeconds{ .secs = secs }; const yd = es.getEpochDay().calculateYearDay(); const md = yd.calculateMonthDay(); const ds = es.getDaySeconds();
var buf: [20]u8 = undefined; _ = std.fmt.bufPrint(&buf, "{d:0>4}-{d:0>2}-{d:0>2}T{d:0>2}:{d:0>2}:{d:0>2}Z", .{ yd.year, @as(u32, md.month.numeric()), @as(u32, md.day_index) + 1, @as(u32, ds.getHoursIntoDay()), @as(u32, ds.getMinutesIntoHour()), @as(u32, ds.getSecondsIntoMinute()), }) catch unreachable; return buf;}