@voxgig/sdkgen 4.32.0 → 4.33.0

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/feature/DebugFeature.swift

@@ -1,9 +1,10 @@
 // Request/response capture for debugging. 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 (e.g. to
-// stream to a console). `max` caps the buffer (default 100).
+// timing - on the feature's entries. Every entry passes through the SDK's
+// clean utility (clean.keys and every registered secret value); the
+// `redact` option ADDS header names on top of that. An optional `onEntry`
+// callback receives each finished entry (e.g. to stream to a console).
+// `max` caps the buffer (default 100).
 
 import Foundation
 
@@ -16,11 +17,6 @@ public final class DebugFeature: BaseFeature {
 
   private static let entryKey = "debug_entry"
 
-  private static let defaultRedact: [String] = [
-    "authorization", "cookie", "set-cookie", "api-key", "apikey",
-    "x-api-key", "idempotency-key",
-  ]
-
   public override init() {
     super.init()
     version = "0.0.1"
@@ -48,7 +44,7 @@ public final class DebugFeature: BaseFeature {
     if let spec = ctx.spec {
       entry.entries["method"] = .string(spec.method)
       entry.entries["url"] = .string(spec.url != "" ? spec.url : spec.path)
-      entry.entries["headers"] = .map(redact(spec.headers))
+      entry.entries["headers"] = .map(redact(ctx, spec.headers))
     }
     ctx.out[DebugFeature.entryKey] = entry
   }
@@ -83,10 +79,11 @@ public final class DebugFeature: BaseFeature {
 
   private func finish(_ ctx: Context, _ ok: Bool) {
     // Finish once per operation: the marker in ctx.out is consumed here.
-    guard let entry = ctx.out[DebugFeature.entryKey] as? VMap else {
+    guard let raw = ctx.out[DebugFeature.entryKey] as? VMap else {
       return
     }
     ctx.out.removeValue(forKey: DebugFeature.entryKey)
+    var entry = raw
 
     entry.entries["ok"] = .bool(ok && (ctx.result == nil || ctx.result!.ok))
     let sv = gp(entry, "start")
@@ -100,6 +97,11 @@ public final class DebugFeature: BaseFeature {
       entry.entries["status"] = .int(Int64(result.status))
     }
 
+    // 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.
+    entry = fclean(ctx, entry)
+
     entries.append(entry)
     let max = foptInt(options, "max", 100)
     while entries.count > max {
@@ -111,16 +113,18 @@ public final class DebugFeature: BaseFeature {
     }
   }
 
-  private func redact(_ headers: VMap?) -> VMap {
+  // The core clean rules apply (clean.keys, every registered value); the
+  // feature's own `redact` list ADDS header names on top of them.
+  private func redact(_ ctx: Context, _ headers: VMap?) -> VMap {
     let redacted = VMap()
     guard let headers = headers else {
       return redacted
     }
-    let patterns = foptStrList(options, "redact") ?? DebugFeature.defaultRedact
+    let patterns = (foptStrList(options, "redact") ?? []).map { $0.lowercased() }
     for (k, v) in headers.entries {
       let masked = patterns.contains(k.lowercased())
-      redacted.entries[k] = masked ? .string("<redacted>") : v
+      redacted.entries[k] = masked ? .string("[redacted]") : v
     }
-    return redacted
+    return fclean(ctx, redacted)
   }
 }

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/feature/FeatureOptions.swift

@@ -94,3 +94,19 @@ func fresHeader(_ res: Value, _ name: String) -> (String, Bool) {
 func fparseInt(_ s: String, _ def: Int) -> Int {
   Int(s.trimmingCharacters(in: .whitespaces)) ?? def
 }
+
+// fclean passes a record a feature is about to emit through the SDK's clean
+// utility: every sink, buffer and logger receives the masked copy.
+func fclean(_ ctx: Context, _ record: VMap) -> VMap {
+  guard let clean = ctx.utility?.clean, let out = clean(ctx, .map(record)).asMap else {
+    return record
+  }
+  return out
+}
+
+func fcleanStr(_ ctx: Context, _ text: String) -> String {
+  guard let clean = ctx.utility?.clean, let out = clean(ctx, .string(text)).asString else {
+    return text
+  }
+  return out
+}

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/feature/LogFeature.swift

@@ -64,6 +64,9 @@ public final class LogFeature: BaseFeature {
     if let op = ctx.op { attrs.entries["op"] = .string(op.name) }
     if let spec = ctx.spec { attrs.entries["spec"] = .string(spec.method + " " + spec.path) }
 
-    logger(level, "hook", attrs)
+    // A log line leaves the pipeline, so it carries the cleaned record: a
+    // path can hold a query credential, and a logger serialises whatever it
+    // is handed.
+    logger(level, "hook", fclean(ctx, attrs))
   }
 }

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/feature/ProxyFeature.swift

@@ -13,6 +13,10 @@ public final class ProxyFeature: BaseFeature {
   private var options: VMap?
   private var noProxy: [String] = []
 
+  // The proxy target as configured, for routing; `url` below is the cleaned
+  // form, since a proxy URL may carry credentials as userinfo.
+  private var target = ""
+
   // Activity tracking (mirrors the ts client._proxy record).
   public var routed = 0
   public var url = ""
@@ -36,12 +40,12 @@ public final class ProxyFeature: BaseFeature {
       return
     }
 
-    url = foptStr(options, "url", "")
+    target = foptStr(options, "url", "")
     var noProxyList = foptStrList(options, "noProxy")
 
     if foptBool(options, "fromEnv", false) {
-      if url == "" {
-        url = firstEnv("HTTPS_PROXY", "https_proxy", "HTTP_PROXY", "http_proxy")
+      if target == "" {
+        target = firstEnv("HTTPS_PROXY", "https_proxy", "HTTP_PROXY", "http_proxy")
       }
       if noProxyList == nil {
         let np = firstEnv("NO_PROXY", "no_proxy")
@@ -59,6 +63,17 @@ public final class ProxyFeature: BaseFeature {
       }
     }
 
+    // A proxy URL may carry credentials as userinfo, from the option or the
+    // environment, and neither is under a sensitive key name.
+    if target != "", let parsed = URLComponents(string: target) {
+      for part in [parsed.percentEncodedUser, parsed.percentEncodedPassword, parsed.user, parsed.password] {
+        if let p = part, p != "" {
+          ctx.utility!.cleanAdd(ctx, .string(p))
+        }
+      }
+    }
+    url = fcleanStr(ctx, target)
+
     let inner = ctx.utility!.fetcher!
 
     ctx.utility!.fetcher = { ctx2, url, fetchdef in
@@ -68,7 +83,7 @@ public final class ProxyFeature: BaseFeature {
   }
 
   private func route(_ requestUrl: String, _ fetchdef: VMap) -> VMap {
-    if url == "" || bypass(requestUrl) {
+    if target == "" || bypass(requestUrl) {
       return fetchdef
     }
 
@@ -76,7 +91,7 @@ public final class ProxyFeature: BaseFeature {
     for (k, v) in fetchdef.entries {
       routedDef.entries[k] = v
     }
-    routedDef.entries["proxy"] = .string(url)
+    routedDef.entries["proxy"] = .string(target)
 
     routed += 1
     return routedDef

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/feature/SecretsFeature.swift

@@ -155,6 +155,15 @@ public final class SecretsFeature: BaseFeature {
     return getcred()
   }
 
+  // Every value this feature resolves or buys is a secret the SDK handles,
+  // and none arrives under an option key the intake registration saw.
+  private func register(_ value: String?) {
+    guard let v = value, let ctx = client?.getRootCtx(), let add = ctx.utility?.cleanAdd else {
+      return
+    }
+    add(ctx, .string(v))
+  }
+
   // Sync by feature contract: build the chain, never look anything up here.
   public override func initFeature(_ ctx: Context, _ options: VMap) {
     client = ctx.client
@@ -221,6 +230,7 @@ public final class SecretsFeature: BaseFeature {
     var chain: [Sekreto.ChainItem] = []
 
     if "" != explicit {
+      register(explicit)
       do {
         let key = try envkey(secretname)
         chain.append(.spec(ProviderSpec(
@@ -353,6 +363,7 @@ public final class SecretsFeature: BaseFeature {
     // A provider ERROR throws out of here and fails the op (via the
     // transport gate); only a MISS (nil) falls through.
     let found = try s.tryget(secretname)
+    register(found)
 
     if nil == exchange {
       // An UNCACHED miss after an earlier hit is a revocation: the chain
@@ -646,6 +657,8 @@ public final class SecretsFeature: BaseFeature {
         "secrets: token exchange returned no '" + x.response + "' field from " + url)
     }
 
+    register(token)
+
     return token
   }
 

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/feature/TelemetryFeature.swift

@@ -96,11 +96,13 @@ public final class TelemetryFeature: BaseFeature {
     span.entries["durationMs"] = .int(dur)
     span.entries["ok"] = .bool(ok)
 
+    let finished = fclean(ctx, span)
+
     activeSpans -= 1
-    spans.append(span)
+    spans.append(finished)
 
     if let exporter = gp(options, "exporter").asNative as? (VMap) -> Void {
-      exporter(span)
+      exporter(finished)
     }
   }
 

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/utility/MakeError.swift

@@ -20,21 +20,31 @@ func makeErrorUtil(_ ctx: Context, _ err: Error?) throws -> Value {
   if e == nil { e = ctx.makeError("unknown", "unknown error") }
 
   let errmsg = errMessage(e!)
-  var msg = "ProjectNameSDK: " + opname + ": " + errmsg
-  msg = cleanUtil(ctx, .string(msg)).asString ?? msg
+  let msg = "ProjectNameSDK: " + opname + ": " + errmsg
 
   result.err = nil
 
   let spec = ctx.spec
 
+  // The context stays reachable on the error for a debugger; the error type
+  // keeps it out of every printer and mirror.
+  let code = (e as? ProjectNameError)?.code ?? ""
+  let sdkErr = ProjectNameError(code, msg, ctx)
+
+  _ = cleanUtil(ctx, .nat(sdkErr))
+
+  // The HTTP status at the top level, so a consumer can branch on
+  // err.status instead of reaching into err.resultVal.
+  sdkErr.status = result.status
+
   if let explain = ctx.ctrl.explain {
     let em = VMap()
-    em.entries["message"] = .string(msg)
+    em.entries["code"] = .string(sdkErr.code)
+    em.entries["message"] = .string(sdkErr.message)
+    em.entries["status"] = .int(Int64(sdkErr.status))
     explain.entries["err"] = .map(em)
   }
 
-  let code = (e as? ProjectNameError)?.code ?? ""
-  let sdkErr = ProjectNameError(code, msg, ctx)
   sdkErr.resultVal = cleanUtil(ctx, .nat(result))
   sdkErr.specVal = spec == nil ? .noval : cleanUtil(ctx, .nat(spec!))
 

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/utility/MakeOptions.swift

@@ -53,6 +53,31 @@ func makeOptionsUtil(_ ctx: Context) -> VMap {
     opts.entries.removeValue(forKey: "auth")
   }
 
+  let config = ctx.config ?? VMap()
+  let cfgopts = gp(config, "options").asMap ?? VMap()
+
+  // The secret registry exists BEFORE validation, fed from the raw input, so
+  // the constructor's own rejection of a mistyped credential is clean too.
+  // (Here validate never throws - the struct port collects its errors - so
+  // there is no rejection to clean; the registry is early for the same
+  // reason regardless.)
+  var cleanlayers: [Value] = [.map(VMap()), clone(gp(SdkSchema.optspec, "clean"))]
+  // Maps only: merge lets any other value replace the defaults outright.
+  for block in [gp(cfgopts, "clean"), opts.entries["clean"] ?? .noval] {
+    if let m = block.asMap {
+      cleanlayers.append(clone(.map(m)))
+    }
+  }
+  let cleancfg = makeCleanConfig(merge(.list(cleanlayers)))
+  let cleanctx = Context(
+    ["options": vm(("__derived__", .map(vm(("clean", .nat(cleancfg))))))], nil)
+  cleanAddOptions(cleanctx, cleanOmit(opts, ["clean"]))
+  let cleanvalues = cleanSplitValues(gpath(cfgopts, "clean", "values"))
+    + cleanSplitValues(gpath(opts, "clean", "values"))
+  for raw in cleanvalues {
+    cleanAddUtil(cleanctx, .string(raw))
+  }
+
   // Feature add-order. options.feature may be given as an ordered LIST of
   // { name, active, ...opts } entries (the list position IS the order in which
   // features are added), or as a { name: {opts} } map. Normalize a list to a
@@ -73,9 +98,6 @@ func makeOptionsUtil(_ ctx: Context) -> VMap {
     opts.entries["feature"] = .map(fmap)
   }
 
-  let config = ctx.config ?? VMap()
-  let cfgopts = gp(config, "options").asMap ?? VMap()
-
   // THE OPTION SPEC IS GENERATED, NOT WRITTEN HERE.
   //
   // Built from the model: `main.kit.optspec` for the standard options, plus
@@ -117,16 +139,6 @@ func makeOptionsUtil(_ ctx: Context) -> VMap {
     }
   }
 
-  // Derived clean config.
-  var cleanKeys = "key,token,id"
-  if let cks = gpath(result, "clean", "keys").asString { cleanKeys = cks }
-
-  let filtered = cleanKeys.split(separator: ",", omittingEmptySubsequences: false)
-    .map { $0.trimmingCharacters(in: .whitespaces) }
-    .filter { $0 != "" }
-    .map { escre(.string($0)) }
-  let keyre = filtered.joined(separator: "|")
-
   // Resolve the feature add-order: an explicit list order (above) wins;
   // otherwise order the map test-first, then the remaining names sorted, so
   // the outcome is deterministic and `test` is always the base transport.
@@ -154,14 +166,41 @@ func makeOptionsUtil(_ ctx: Context) -> VMap {
   }
 
   let derived = VMap()
-  derived.entries["clean"] = .map(VMap())
-  if keyre != "" {
-    let cm = VMap()
-    cm.entries["keyre"] = .string(keyre)
-    derived.entries["clean"] = .map(cm)
-  }
+  derived.entries["clean"] = .nat(cleancfg)
   derived.entries["featureorder"] = .list(VList(featureorder))
   result.entries["__derived__"] = .map(derived)
 
+  // Again over the merged result: the config's own defaults can carry one.
+  cleanAddOptions(Context(["options": result], nil), cleanOmit(result, ["clean", "__derived__"]))
+
   return result
 }
+
+// A feature's name is not a field name: only the sensitive names inside its
+// settings count, so `secrets` does not make every setting a secret. Entity
+// blocks hold entity settings and seeded records, never a credential.
+private func cleanAddOptions(_ ctx: Context, _ opts: VMap) {
+  let top = cleanOmit(opts, ["feature", "entity"])
+  if let test = top.entries["test"] {
+    top.entries["test"] = cleanWithoutEntity(test)
+  }
+  cleanAddSensitiveUtil(ctx, .map(top))
+  let feature = opts.entries["feature"] ?? .noval
+  let settings: [Value] = feature.asMap?.entries.values ?? feature.asList?.items ?? [feature]
+  for fopts in settings {
+    cleanAddSensitiveUtil(ctx, cleanWithoutEntity(fopts))
+  }
+}
+
+private func cleanWithoutEntity(_ block: Value) -> Value {
+  guard let m = block.asMap else { return block }
+  return .map(cleanOmit(m, ["entity"]))
+}
+
+private func cleanOmit(_ src: VMap, _ names: [String]) -> VMap {
+  let out = VMap()
+  for (k, v) in src.entries where !names.contains(k) {
+    out.entries[k] = v
+  }
+  return out
+}

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/utility/Register.swift

@@ -5,6 +5,7 @@ import Foundation
 
 func registerAll(_ u: Utility) {
   u.clean = cleanUtil
+  u.cleanAdd = cleanAddUtil
   u.done = doneUtil
   u.makeError = makeErrorUtil
   u.featureAdd = featureAddUtil