@voxgig/sdkgen 4.32.0 → 4.33.0

package/project/.sdk/tm/zig/feature/debug.zig

@@ -1,9 +1,10 @@
 // Request/response capture for debugging (mirrors go feature/debug_feature.go
 // / rust feature/debug.rs). Records a bounded ring buffer of per-operation
 // traces — method, URL, redacted headers, response status and timing — on the
-// feature's entries. Sensitive header values (matching `redact`, default
-// authorization/cookie/api-key style names) are masked. An optional `onEntry`
-// callback receives each finished entry. `max` caps the buffer (default 100).
+// feature's entries. Every entry passes through the SDK's clean rules
+// (clean.keys and every registered secret); the `redact` option ADDS header
+// names on top of them. An optional `onEntry` callback receives each finished
+// entry. `max` caps the buffer (default 100).
 
 const std = @import("std");
 const h = @import("../core/helpers.zig");
@@ -17,16 +18,6 @@ const OutVal = types.OutVal;
 
 const DEBUG_ENTRY_KEY: []const u8 = "debug_entry";
 
-const DEBUG_DEFAULT_REDACT = [_][]const u8{
-    "authorization",
-    "cookie",
-    "set-cookie",
-    "api-key",
-    "apikey",
-    "x-api-key",
-    "idempotency-key",
-};
-
 pub const DebugFeature = struct {
     name: []const u8 = "debug",
     active: bool = true,
@@ -46,13 +37,11 @@ pub const DebugFeature = struct {
         return @ptrCast(@alignCast(p));
     }
 
-    fn redact(self: *DebugFeature, headers: Value) Value {
+    // The core clean rules apply (clean.keys, every registered value); the
+    // feature's own `redact` list ADDS header names on top of them.
+    fn redact(self: *DebugFeature, ctx: *Context, headers: Value) Value {
         const out = h.omap();
-        const patterns: [][]const u8 = sup.fopt_str_list(self.options, "redact") orelse blk: {
-            var l: std.ArrayList([]const u8) = .empty;
-            for (DEBUG_DEFAULT_REDACT) |p| l.append(h.A(), p) catch {};
-            break :blk l.toOwnedSlice(h.A()) catch &.{};
-        };
+        const patterns: [][]const u8 = sup.fopt_str_list(self.options, "redact") orelse &.{};
         if (headers == .object) {
             var it = headers.object.iterator();
             while (it.next()) |kv| {
@@ -60,19 +49,20 @@ pub const DebugFeature = struct {
                 const lower = std.ascii.allocLowerString(h.A(), key) catch key;
                 var masked = false;
                 for (patterns) |p| {
-                    if (std.mem.eql(u8, lower, p)) {
+                    const plower = std.ascii.allocLowerString(h.A(), p) catch p;
+                    if (std.mem.eql(u8, lower, plower)) {
                         masked = true;
                         break;
                     }
                 }
                 if (masked) {
-                    h.setp(out, key, h.vstr("<redacted>"));
+                    h.setp(out, key, h.vstr("[redacted]"));
                 } else {
                     h.setp(out, key, kv.value_ptr.*);
                 }
             }
         }
-        return out;
+        return ctx.util().clean(ctx, out);
     }
 
     fn finish(self: *DebugFeature, ctx: *Context, ok: bool) void {
@@ -92,7 +82,12 @@ pub const DebugFeature = struct {
             if (ctx.result) |r| h.setp(entry, "status", h.vnum(r.status));
         }
 
-        self.entries.append(h.A(), entry) catch {};
+        // The whole entry leaves through the buffer and the callback: the url
+        // and the error message can carry a query credential the header mask
+        // above never saw.
+        const out = ctx.util().clean(ctx, entry);
+
+        self.entries.append(h.A(), out) catch {};
         const max: usize = @intCast(@max(sup.fopt_int(self.options, "max", 100), 0));
         while (self.entries.items.len > max) {
             _ = self.entries.orderedRemove(0);
@@ -100,7 +95,7 @@ pub const DebugFeature = struct {
 
         const on_entry = h.getp(self.options, "onEntry");
         if (on_entry == .function) {
-            _ = h.call_vfn(on_entry, entry);
+            _ = h.call_vfn(on_entry, out);
         }
     }
 
@@ -120,7 +115,7 @@ pub const DebugFeature = struct {
             } else {
                 h.setp(entry, "url", h.vstr(sp.path));
             }
-            h.setp(entry, "headers", self.redact(sp.headers));
+            h.setp(entry, "headers", self.redact(ctx, sp.headers));
         }
         ctx.out_set(DEBUG_ENTRY_KEY, OutVal{ .val = entry });
     }

package/project/.sdk/tm/zig/feature/log.zig

@@ -46,7 +46,9 @@ pub const LogFeature = struct {
         else
             "";
 
-        std.debug.print("name=log hook={s} op={s} spec={s}\n", .{ hook, opname, specinfo });
+        // A log line leaves the pipeline, so it is cleaned like every record.
+        const line = std.fmt.allocPrint(h.A(), "name=log hook={s} op={s} spec={s}", .{ hook, opname, specinfo }) catch "";
+        std.debug.print("{s}\n", .{ctx.util().clean_str(ctx, line)});
     }
 
     fn vname(p: *anyopaque) []const u8 {

package/project/.sdk/tm/zig/feature/proxy.zig

@@ -83,12 +83,22 @@ pub const ProxyFeature = struct {
         }
         const no_proxy: []const []const u8 = np_list.toOwnedSlice(h.A()) catch &.{};
 
-        self.track.url = url;
+        const util = ctx.util();
+
+        // A proxy URL may carry credentials as userinfo, from the option or
+        // the environment, and neither is under a sensitive key name.
+        for (userinfo_parts(url)) |part| {
+            util.clean_add(ctx, part);
+            util.clean_add(ctx, percent_decode(part));
+        }
+
+        // The tracked url is what a caller reads back, so it is cleaned; the
+        // wrapper routes with the raw one.
+        self.track.url = util.clean_str(ctx, url);
         self.track.no_proxy = no_proxy;
 
-        const util = ctx.util();
         const w = h.A().create(WrapCtx) catch unreachable;
-        w.* = .{ .inner = util.fetcher, .track = self.track };
+        w.* = .{ .inner = util.fetcher, .track = self.track, .url = url };
         util.fetcher = .{ .ctx = @ptrCast(w), .call = wrapCall };
     }
     fn vdispatch(p: *anyopaque, name: []const u8, ctx: *Context) void {
@@ -113,14 +123,46 @@ pub const ProxyFeature = struct {
 const WrapCtx = struct {
     inner: Fetcher,
     track: *ProxyTrack,
+    url: []const u8,
 };
 
 fn wrapCall(p: *anyopaque, ctx: *Context, url: []const u8, fetchdef: Value) err.E!Value {
     const w: *WrapCtx = @ptrCast(@alignCast(p));
-    const routed = route(w.track, url, fetchdef);
+    const routed = route(w.url, w.track, url, fetchdef);
     return w.inner.invoke(ctx, url, routed);
 }
 
+// The user and password of `scheme://user:pass@host`, raw as written.
+fn userinfo_parts(url: []const u8) []const []const u8 {
+    var out: std.ArrayList([]const u8) = .empty;
+    const start = if (std.mem.indexOf(u8, url, "://")) |i| i + 3 else return &.{};
+    const rest = url[start..];
+    const at = std.mem.indexOfScalar(u8, rest, '@') orelse return &.{};
+    const userinfo = rest[0..at];
+    if (std.mem.indexOfScalar(u8, userinfo, '/') != null) return &.{};
+    var it = std.mem.splitScalar(u8, userinfo, ':');
+    while (it.next()) |part| {
+        if (part.len != 0) out.append(h.A(), part) catch {};
+    }
+    return out.toOwnedSlice(h.A()) catch &.{};
+}
+
+fn percent_decode(s: []const u8) []const u8 {
+    var out: std.ArrayList(u8) = .empty;
+    var i: usize = 0;
+    while (i < s.len) : (i += 1) {
+        if (s[i] == '%' and i + 3 <= s.len) {
+            if (std.fmt.parseInt(u8, s[i + 1 .. i + 3], 16)) |byte| {
+                out.append(h.A(), byte) catch {};
+                i += 2;
+                continue;
+            } else |_| {}
+        }
+        out.append(h.A(), s[i]) catch {};
+    }
+    return out.toOwnedSlice(h.A()) catch s;
+}
+
 // Zig 0.16 has no free-standing environment lookup: the block the process was
 // started with is owned by an Io implementation, and library code is expected
 // to be handed one. The SDK's Io is the process-global singleton (core/mem.zig),
@@ -165,8 +207,7 @@ fn bypass(no_proxy: []const []const u8, url: []const u8) bool {
     return false;
 }
 
-fn route(track: *ProxyTrack, url: []const u8, fetchdef: Value) Value {
-    const proxy_url = track.url;
+fn route(proxy_url: []const u8, track: *ProxyTrack, url: []const u8, fetchdef: Value) Value {
     const no_proxy = track.no_proxy;
 
     if (proxy_url.len == 0 or bypass(no_proxy, url)) {

package/project/.sdk/tm/zig/feature/secrets.zig

@@ -300,6 +300,10 @@ pub const SecretsFeature = struct {
         var specs: std.ArrayList(sekreto.ProviderSpec) = .empty;
 
         if (0 != explicit.len) {
+            // Every value this feature resolves or buys is a secret the SDK
+            // handles, and none arrives under an option key the intake
+            // registration saw.
+            util.clean_add(ctx, explicit);
             const keyed = sekreto.envkey(alloc, st.secretname, "") catch
                 sekreto.Answer([]const u8){ .err = "secrets: out of memory" };
             switch (keyed) {
@@ -572,6 +576,7 @@ fn resolve_once(st: *State, ctx: *Context) E!void {
         .err => |message| return ctx.fail(ERRCODE, h.A().dupe(u8, message) catch message),
         .ok => |v| v,
     };
+    if (value) |v| ctx.util().clean_add(ctx, v);
 
     if (st.exchange == null) {
         // An UNCACHED miss after an earlier hit is a revocation: the chain
@@ -793,6 +798,8 @@ fn buy(st: *State, ctx: *Context) E![]const u8 {
         ) catch "secrets: token exchange returned no token");
     }
 
+    ctx.util().clean_add(ctx, token);
+
     st.cred = token;
     return token;
 }

package/project/.sdk/tm/zig/feature/telemetry.zig

@@ -72,12 +72,14 @@ pub const TelemetryFeature = struct {
         h.setp(span, "durationMs", h.vnum(dur));
         h.setp(span, "ok", h.vbool(ok));
 
+        const out = ctx.util().clean(ctx, span);
+
         self.active_spans -= 1;
-        self.spans.append(h.A(), span) catch {};
+        self.spans.append(h.A(), out) catch {};
 
         const exporter = h.getp(self.options, "exporter");
         if (exporter == .function) {
-            _ = h.call_vfn(exporter, span);
+            _ = h.call_vfn(exporter, out);
         }
     }
 

package/project/.sdk/tm/zig/test/feature_test.zig

@@ -697,7 +697,7 @@ test "feature debug: redacts and honours onentry max" {
     try testing.expect(df.entries.items.len == 1);
     try testing.expect(seen.len() == 2);
     const hdrs = h.getp(seen.at(0), "headers");
-    try testing.expect(h.veq(h.getp(hdrs, "authorization"), h.vstr("<redacted>")));
+    try testing.expect(h.veq(h.getp(hdrs, "authorization"), h.vstr("[redacted]")));
 }
 
 test "feature debug: captures failures" {
@@ -728,7 +728,7 @@ test "feature debug: injected clock and custom redact" {
         .{ "x-ok", h.vstr("show") },
     }) });
     const hdrs = h.getp(df.entries.items[0], "headers");
-    try testing.expect(h.veq(h.getp(hdrs, "x-secret"), h.vstr("<redacted>")));
+    try testing.expect(h.veq(h.getp(hdrs, "x-secret"), h.vstr("[redacted]")));
     try testing.expect(h.veq(h.getp(hdrs, "x-ok"), h.vstr("show")));
 }
 

package/project/sdkgen-package.json

@@ -3,7 +3,7 @@
     "package": 1
   },
   "name": "@voxgig/sdkgen",
-  "version": "4.32.0",
+  "version": "4.33.0",
   "provides": {
     "target": [
       "c",

package/src/helpers/naming.ts

@@ -149,7 +149,7 @@ function isPhpReservedType(Name: string): boolean {
 
 
 const PHP_SDK_CLASSES = new Set<string>([
-  'existstest', 'featurecorpustest', 'featuretest', 'netsimtest',
+  'cleantest', 'existstest', 'featurecorpustest', 'featuretest', 'netsimtest',
   'omnismoketest', 'pipelinetest', 'primaryutilitytest',
   'readmeexamplestest', 'structutilitytest',
   'ftclient', 'ftclock', 'ftctrl', 'ftentity', 'ftharness', 'ftrecorder',