Fix host parser to handle IPv6

Author: ItsMeSamey

src/core/events.zig

@@ -124,14 +124,17 @@ fn domainForEvent(event: types.LifecycleEvent) ?[]const u8 {
 }
 
 fn hostFromUrl(url: []const u8) ?[]const u8 {
-    const scheme = std.mem.indexOf(u8, url, "://") orelse return null;
-    const rest = url[scheme + 3 ..];
-    const slash = std.mem.indexOfScalar(u8, rest, '/') orelse rest.len;
-    const host_port = rest[0..slash];
-    const colon = std.mem.indexOfScalar(u8, host_port, ':') orelse host_port.len;
-    const host = host_port[0..colon];
-    if (host.len == 0) return null;
-    return host;
+    const parsed = std.Uri.parse(url) catch return null;
+    const host_component = parsed.host orelse return null;
+    const raw_host = switch (host_component) {
+        .raw => |value| value,
+        .percent_encoded => |value| value,
+    };
+    if (raw_host.len == 0) return null;
+    if (raw_host.len >= 2 and raw_host[0] == '[' and raw_host[raw_host.len - 1] == ']') {
+        return raw_host[1 .. raw_host.len - 1];
+    }
+    return raw_host;
 }
 
 fn domainMatches(value: []const u8, filter: []const u8) bool {
@@ -149,6 +152,8 @@ fn freeSubscription(allocator: std.mem.Allocator, sub: EventSubscription) void {
 test "host parser extracts host" {
     try std.testing.expectEqualStrings("example.com", hostFromUrl("https://example.com/path").?);
     try std.testing.expectEqualStrings("example.com", hostFromUrl("https://example.com:443/path").?);
+    try std.testing.expectEqualStrings("2001:db8::1", hostFromUrl("https://[2001:db8::1]:443/path").?);
+    try std.testing.expectEqualStrings("example.com", hostFromUrl("https://user:pass@example.com/path?x=1").?);
     try std.testing.expect(hostFromUrl("data:text/html,hello") == null);
 }
 

src/core/network.zig

@@ -233,18 +233,22 @@ pub fn listNetworkRecords(
     allocator: std.mem.Allocator,
     include_bodies: bool,
 ) ![]types.NetworkRecord {
-    session.network_lock.lock();
-    var out = try allocator.alloc(types.NetworkRecord, session.network_records.items.len);
-    var copied: usize = 0;
-    errdefer {
-        for (out[0..copied]) |*record| freeNetworkRecord(allocator, record);
-        allocator.free(out);
-    }
-    for (session.network_records.items, 0..) |record, idx| {
-        out[idx] = try cloneNetworkRecord(allocator, record, include_bodies);
-        copied = idx + 1;
-    }
-    session.network_lock.unlock();
+    const out = blk: {
+        session.network_lock.lock();
+        defer session.network_lock.unlock();
+
+        var copied_out = try allocator.alloc(types.NetworkRecord, session.network_records.items.len);
+        var copied_count: usize = 0;
+        errdefer {
+            for (copied_out[0..copied_count]) |*record| freeNetworkRecord(allocator, record);
+            allocator.free(copied_out);
+        }
+        for (session.network_records.items, 0..) |record, idx| {
+            copied_out[idx] = try cloneNetworkRecord(allocator, record, include_bodies);
+            copied_count = idx + 1;
+        }
+        break :blk copied_out;
+    };
 
     if (!include_bodies or session.transport != .cdp_ws) return out;
 

src/core/session.zig

@@ -46,6 +46,7 @@ pub const Session = struct {
     event_subscriptions: std.ArrayList(events.EventSubscription) = .empty,
     next_event_subscription_id: u64 = 1,
     challenge_active: bool = false,
+    challenge_lock: std.Thread.Mutex = .{},
     network_lock: std.Thread.Mutex = .{},
     network_records: std.ArrayList(types.NetworkRecord) = .empty,
     frames_lock: std.Thread.Mutex = .{},
@@ -148,7 +149,8 @@ pub const Session = struct {
     }
 
     pub fn reload(self: *Session) !void {
-        const url = currentUrlForLifecycle(self);
+        const url = try currentUrlForLifecycle(self);
+        defer self.allocator.free(url);
         events.emit(self, .{ .navigation_started = .{ .url = url, .cause = .reload } });
         events.emit(self, .{ .reload_started = .{ .url = url, .cause = .reload } });
         capturePhaseSnapshotBestEffort(self, .navigation_started, url);
@@ -731,10 +733,11 @@ fn elapsedSince(start_ms: i64) u32 {
     return @intCast(delta);
 }
 
-fn currentUrlForLifecycle(self: *Session) []const u8 {
+fn currentUrlForLifecycle(self: *Session) ![]u8 {
     self.state_lock.lock();
     defer self.state_lock.unlock();
-    return self.current_url orelse "";
+    if (self.current_url) |url| return self.allocator.dupe(u8, url);
+    return self.allocator.dupe(u8, "");
 }
 
 fn emitNavigationMilestones(self: *Session, url: []const u8, cause: types.NavigationCause) !void {
@@ -867,6 +870,7 @@ const SessionEventCapture = struct {
     last_navigation_completed_cause: ?types.NavigationCause = null,
     last_navigation_failed_error: ?[]const u8 = null,
     last_navigation_failed_cause: ?types.NavigationCause = null,
+    reload_url_buf: [512]u8 = [_]u8{0} ** 512,
     last_reload_url: ?[]const u8 = null,
     last_reload_failed_error: ?[]const u8 = null,
     last_wait_target: ?types.WaitTargetTag = null,
@@ -900,12 +904,16 @@ fn captureSessionEvent(event: types.LifecycleEvent) void {
         },
         .reload_started => |e| {
             session_event_capture.reload_started += 1;
-            session_event_capture.last_reload_url = e.url;
+            const copy_len = @min(e.url.len, session_event_capture.reload_url_buf.len);
+            @memcpy(session_event_capture.reload_url_buf[0..copy_len], e.url[0..copy_len]);
+            session_event_capture.last_reload_url = session_event_capture.reload_url_buf[0..copy_len];
         },
         .reload_completed => session_event_capture.reload_completed += 1,
         .reload_failed => |e| {
             session_event_capture.reload_failed += 1;
-            session_event_capture.last_reload_url = e.url;
+            const copy_len = @min(e.url.len, session_event_capture.reload_url_buf.len);
+            @memcpy(session_event_capture.reload_url_buf[0..copy_len], e.url[0..copy_len]);
+            session_event_capture.last_reload_url = session_event_capture.reload_url_buf[0..copy_len];
             session_event_capture.last_reload_failed_error = e.error_code;
         },
         .wait_started => |e| {

src/core/wait.zig

@@ -168,7 +168,9 @@ fn waitNetworkIdleStep(session: *Session) !bool {
 fn waitUrlContainsStep(session: *Session, needle: []const u8) !bool {
     const payload = try evaluateForWait(session, "location.href");
     defer session.allocator.free(payload);
-    return strings.containsIgnoreCase(payload, needle);
+    const url = try extractEvaluationString(session.allocator, payload);
+    defer session.allocator.free(url);
+    return strings.containsIgnoreCase(url, needle);
 }
 
 fn waitCookieStep(session: *Session, query: types.CookieQuery) !bool {
@@ -274,16 +276,21 @@ fn maybeEmitChallengeSignals(session: *Session) !void {
     if (!session.supports(.js_eval)) return;
     const title_payload = try evaluateForWait(session, "document.title");
     defer session.allocator.free(title_payload);
+    const title = try extractEvaluationString(session.allocator, title_payload);
+    defer session.allocator.free(title);
 
-    const looks_like_challenge = strings.containsIgnoreCase(title_payload, "challenge") or
-        strings.containsIgnoreCase(title_payload, "just a moment") or
-        strings.containsIgnoreCase(title_payload, "attention required") or
-        strings.containsIgnoreCase(title_payload, "cf-chl") or
-        strings.containsIgnoreCase(title_payload, "cloudflare");
+    const looks_like_challenge = strings.containsIgnoreCase(title, "challenge") or
+        strings.containsIgnoreCase(title, "just a moment") or
+        strings.containsIgnoreCase(title, "attention required") or
+        strings.containsIgnoreCase(title, "cf-chl") or
+        strings.containsIgnoreCase(title, "cloudflare");
 
     const current_url = try currentUrl(session);
     defer session.allocator.free(current_url);
 
+    session.challenge_lock.lock();
+    defer session.challenge_lock.unlock();
+
     if (looks_like_challenge and !session.challenge_active) {
         session.challenge_active = true;
         events.emit(session, .{
@@ -306,14 +313,27 @@ fn maybeEmitChallengeSignals(session: *Session) !void {
 fn currentUrl(session: *Session) ![]u8 {
     if (session.supports(.js_eval)) {
         const payload = try evaluateForWait(session, "location.href");
-        return payload;
+        defer session.allocator.free(payload);
+        return extractEvaluationString(session.allocator, payload);
     }
     session.state_lock.lock();
     defer session.state_lock.unlock();
     if (session.current_url) |url| return session.allocator.dupe(u8, url);
     return session.allocator.dupe(u8, "");
 }
 
+fn extractEvaluationString(allocator: std.mem.Allocator, payload: []const u8) ![]u8 {
+    var parsed = std.json.parseFromSlice(std.json.Value, allocator, payload, .{}) catch {
+        return allocator.dupe(u8, payload);
+    };
+    defer parsed.deinit();
+    const value = extractEvaluationValue(parsed.value) orelse return allocator.dupe(u8, payload);
+    return switch (value) {
+        .string => allocator.dupe(u8, value.string),
+        else => std.json.Stringify.valueAlloc(allocator, value, .{}),
+    };
+}
+
 fn clampTimeout(poll_interval_ms: u32) u32 {
     if (poll_interval_ms < 25) return 25;
     if (poll_interval_ms > 500) return 500;

src/protocol/executor.zig

@@ -117,7 +117,7 @@ fn subscribeBidiCoreEvents(session: *Session) !void {
     const raw = callBidi(
         session,
         "session.subscribe",
-        "{\"events\":[\"network.beforeRequestSent\",\"network.responseStarted\",\"network.responseCompleted\",\"browsingContext.domContentLoaded\",\"browsingContext.load\"]}",
+        "{\"events\":[\"network.beforeRequestSent\",\"network.responseCompleted\",\"browsingContext.domContentLoaded\",\"browsingContext.load\"]}",
     ) catch |err| switch (err) {
         error.ProtocolCommandFailed => return,
         else => return err,
@@ -870,8 +870,7 @@ fn processBidiNotification(session: *Session, payload: []const u8) void {
         handleBidiBeforeRequest(session, params);
         return;
     }
-    if (std.mem.eql(u8, method, "network.responseStarted") or
-        std.mem.eql(u8, method, "network.responseCompleted"))
+    if (std.mem.eql(u8, method, "network.responseCompleted"))
     {
         handleBidiResponse(session, params);
         return;
@@ -933,7 +932,6 @@ fn handleCdpResponseReceived(session: *Session, params: std.json.ObjectMap) void
     const headers = stringifyObjectField(session.allocator, response, "headers") catch session.allocator.dupe(u8, "{}") catch return;
     defer session.allocator.free(headers);
 
-    session.recordNetworkStatus(request_id, status, timestampFromEvent(params, "timestamp"));
     session.emitNetworkResponseObserved(.{
         .request_id = request_id,
         .status = status,
@@ -1034,7 +1032,6 @@ fn handleBidiResponse(session: *Session, params: std.json.ObjectMap) void {
     defer session.allocator.free(headers);
     const body = jsonObjectString(response, "body");
 
-    session.recordNetworkStatus(request_id, status, nowMs());
     session.emitNetworkResponseObserved(.{
         .request_id = request_id,
         .status = status,

src/runtime.zig

@@ -38,9 +38,10 @@ pub fn launch(allocator: std.mem.Allocator, opts: types.LaunchOptions) !Session
     const transport = common.transportForAdapter(adapter_kind);
     const capability_set = capabilitiesFor(opts.install.engine, adapter_kind);
     const effective_profile_dir = try resolveEffectiveProfileDir(allocator, opts.profile_mode, opts.profile_dir);
+    const should_cleanup_ephemeral_profile = opts.profile_mode == .ephemeral and opts.profile_dir == null;
     var profile_dir_owned = true;
     defer if (profile_dir_owned) allocator.free(effective_profile_dir);
-    errdefer if (opts.profile_mode == .ephemeral) {
+    errdefer if (should_cleanup_ephemeral_profile) {
         std.fs.cwd().deleteTree(effective_profile_dir) catch {};
     };
 
@@ -127,7 +128,7 @@ pub fn launch(allocator: std.mem.Allocator, opts: types.LaunchOptions) !Session
 
     const id = session_mod.nextSessionId();
     const endpoint = try buildEndpoint(allocator, adapter_kind, id, debug_port);
-    const ephemeral_profile_dir = if (opts.profile_mode == .ephemeral) blk: {
+    const ephemeral_profile_dir = if (should_cleanup_ephemeral_profile) blk: {
         profile_dir_owned = false;
         break :blk effective_profile_dir;
     } else null;

src/session_cache/store.zig

@@ -39,6 +39,11 @@ pub const SessionCacheStore = struct {
 
         var entry = try parseEntry(allocator, payload);
         errdefer deinitEntry(allocator, &entry);
+        if (!std.mem.eql(u8, entry.domain, domain) or !std.mem.eql(u8, entry.profile_key, profile_key)) {
+            _ = self.invalidate(domain, profile_key) catch {};
+            deinitEntry(allocator, &entry);
+            return error.InvalidState;
+        }
 
         if (entry.expires_at_ms) |expires_at| {
             if (expires_at <= nowMs()) {
@@ -283,12 +288,14 @@ fn cachePathFor(
     domain: []const u8,
     profile_key: []const u8,
 ) ![]u8 {
-    var hasher = std.hash.Wyhash.init(0);
+    var digest: [32]u8 = undefined;
+    var hasher = std.crypto.hash.sha2.Sha256.init(.{});
     hasher.update(domain);
-    hasher.update("|");
+    hasher.update(&[_]u8{0});
     hasher.update(profile_key);
-    const key = hasher.final();
-    const file_name = try std.fmt.allocPrint(allocator, "{x}.json", .{key});
+    hasher.final(&digest);
+    const digest_hex = std.fmt.bytesToHex(digest, .lower);
+    const file_name = try std.fmt.allocPrint(allocator, "{s}.json", .{digest_hex[0..]});
     defer allocator.free(file_name);
     return std.fs.path.join(allocator, &.{ root_dir, file_name });
 }
@@ -613,6 +620,28 @@ test "session cache payload mask supports custom combos" {
     try std.testing.expect(!mask.extra_headers);
 }
 
+test "session cache load rejects mismatched identity payload" {
+    const allocator = std.testing.allocator;
+    var tmp = std.testing.tmpDir(.{});
+    defer tmp.cleanup();
+
+    const root = try std.fs.path.join(allocator, &.{ ".zig-cache", "tmp", &tmp.sub_path, "cache-identity" });
+    defer allocator.free(root);
+
+    var store = try SessionCacheStore.open(allocator, root);
+    defer store.deinit();
+
+    const path = try cachePathFor(allocator, store.root_dir, "example.com", "default");
+    defer allocator.free(path);
+
+    const payload =
+        \\{"schema_version":1,"domain":"wrong.example","profile_key":"default","captured_at_ms":1,"expires_at_ms":null,"user_agent":"ua","cookies":[],"local_storage":[],"session_storage":[],"current_url":null,"extra_headers":[]}
+    ;
+    try atomicWriteFile(path, payload);
+
+    try std.testing.expectError(error.InvalidState, store.load(allocator, "example.com", "default"));
+}
+
 test "session cache ttl expiry invalidates on load" {
     const allocator = std.testing.allocator;
     var tmp = std.testing.tmpDir(.{});

src/types.zig

@@ -594,6 +594,7 @@ pub const LaunchError = error{
     UnsupportedEngine,
     SpawnFailed,
     PersistentProfileDirRequired,
+    Timeout,
 };
 
 fn browserTierForKind(kind: BrowserKind) ApiTier {