Polish API naming: remove SSH prefixes across module

Author: wiedymi

Examples/E2E/main.swift

@@ -15,9 +15,9 @@ struct CloudflaredE2ECLI {
         case serviceToken = "2"
     }
 
-    private struct ManualOAuthFlow: SSHOAuthFlow {
+    private struct ManualOAuthFlow: OAuthFlow {
         func fetchToken(teamDomain: String, appDomain: String, callbackScheme: String, hostname: String) async throws -> String {
-            let originURL = try SSHURLTools.normalizeOriginURL(from: hostname)
+            let originURL = try URLTools.normalizeOriginURL(from: hostname)
 
             print("")
             print("Open this protected app URL in your browser and complete Cloudflare Access login:")
@@ -30,7 +30,7 @@ struct CloudflaredE2ECLI {
                 .trimmingCharacters(in: .whitespacesAndNewlines)
 
             guard !token.isEmpty else {
-                throw SSHFailure.auth("oauth token input was empty")
+                throw Failure.auth("oauth token input was empty")
             }
 
             return token
@@ -40,7 +40,7 @@ struct CloudflaredE2ECLI {
     static func main() async {
         do {
             try await run()
-        } catch let failure as SSHFailure {
+        } catch let failure as Failure {
             fputs("Error: \(failure)\n", stderr)
             Foundation.exit(1)
         } catch {
@@ -56,14 +56,14 @@ struct CloudflaredE2ECLI {
         let hostname = try promptRequired("Cloudflare-protected hostname (e.g. ssh.example.com): ")
         let authChoice = try promptAuthChoice()
 
-        let authProvider: any SSHAuthProviding
-        let method: SSHAuthMethod
+        let authProvider: any AuthProviding
+        let method: AuthMethod
 
         switch authChoice {
         case .oauth:
-            let oauthProvider = SSHOAuthProvider(
+            let oauthProvider = OAuthProvider(
                 flow: ManualOAuthFlow(),
-                tokenStore: SSHInMemoryTokenStore()
+                tokenStore: InMemoryTokenStore()
             )
             authProvider = oauthProvider
             method = try await resolveOAuthMethod(hostname: hostname)
@@ -72,14 +72,14 @@ struct CloudflaredE2ECLI {
             let clientID = try promptRequired("Service token client ID: ")
             let clientSecret = try promptSecretRequired("Service token client secret: ")
 
-            authProvider = SSHServiceTokenProvider()
+            authProvider = ServiceTokenProvider()
             method = .serviceToken(teamDomain: "local", clientID: clientID, clientSecret: clientSecret)
         }
 
-        let session = SSHSessionActor(
+        let session = SessionActor(
             authProvider: authProvider,
-            tunnelProvider: SSHCloudflareTunnelProvider(),
-            retryPolicy: SSHRetryPolicy(maxReconnectAttempts: 2, baseDelayNanoseconds: 500_000_000),
+            tunnelProvider: CloudflareTunnelProvider(),
+            retryPolicy: RetryPolicy(maxReconnectAttempts: 2, baseDelayNanoseconds: 500_000_000),
             oauthFallback: nil,
             sleep: { delay in
                 try? await Task.sleep(nanoseconds: delay)
@@ -120,19 +120,19 @@ struct CloudflaredE2ECLI {
         stateTask.cancel()
     }
 
-    private struct URLSessionHTTPClient: SSHHTTPClient {
+    private struct URLSessionHTTPClient: HTTPClient {
         func send(_ request: URLRequest) async throws -> (Data, HTTPURLResponse) {
             let (data, response) = try await URLSession.shared.data(for: request)
             guard let http = response as? HTTPURLResponse else {
-                throw SSHFailure.protocolViolation("non-http response while resolving app info")
+                throw Failure.protocolViolation("non-http response while resolving app info")
             }
             return (data, http)
         }
     }
 
-    private static func resolveOAuthMethod(hostname: String) async throws -> SSHAuthMethod {
-        let originURL = try SSHURLTools.normalizeOriginURL(from: hostname)
-        let resolver = SSHAppInfoResolver(client: URLSessionHTTPClient(), userAgent: "cloudflared-e2e")
+    private static func resolveOAuthMethod(hostname: String) async throws -> AuthMethod {
+        let originURL = try URLTools.normalizeOriginURL(from: hostname)
+        let resolver = AppInfoResolver(client: URLSessionHTTPClient(), userAgent: "cloudflared-e2e")
 
         if let appInfo = try? await resolver.resolve(appURL: originURL) {
             return .oauth(
@@ -149,7 +149,7 @@ struct CloudflaredE2ECLI {
         )
     }
 
-    private static func describe(_ state: SSHConnectionState) -> String {
+    private static func describe(_ state: ConnectionState) -> String {
         switch state {
         case .idle:
             return "idle"
@@ -227,7 +227,7 @@ struct CloudflaredE2ECLI {
     private static func runTunnelProbe(localPort: UInt16) throws -> ProbeResult {
         let fd = socket(AF_INET, SOCK_STREAM, 0)
         guard fd >= 0 else {
-            throw SSHFailure.transport("probe failed to create socket", retryable: true)
+            throw Failure.transport("probe failed to create socket", retryable: true)
         }
         defer { _ = close(fd) }
 
@@ -240,7 +240,7 @@ struct CloudflaredE2ECLI {
 
         let pton = "127.0.0.1".withCString { inet_pton(AF_INET, $0, &address.sin_addr) }
         guard pton == 1 else {
-            throw SSHFailure.transport("probe failed to encode loopback", retryable: false)
+            throw Failure.transport("probe failed to encode loopback", retryable: false)
         }
 
         let connectResult = withUnsafePointer(to: &address) {
@@ -249,7 +249,7 @@ struct CloudflaredE2ECLI {
             }
         }
         guard connectResult == 0 else {
-            throw SSHFailure.transport("probe failed to connect to local tunnel", retryable: true)
+            throw Failure.transport("probe failed to connect to local tunnel", retryable: true)
         }
 
         var timeout = timeval(tv_sec: 2, tv_usec: 0)
@@ -266,7 +266,7 @@ struct CloudflaredE2ECLI {
         }
 
         if count == 0 {
-            throw SSHFailure.transport(
+            throw Failure.transport(
                 "probe socket closed immediately; Cloudflare auth/upstream connection likely failed",
                 retryable: false
             )
@@ -276,6 +276,6 @@ struct CloudflaredE2ECLI {
             return .openWithoutData
         }
 
-        throw SSHFailure.transport("probe recv failed with errno \(errno)", retryable: true)
+        throw Failure.transport("probe recv failed with errno \(errno)", retryable: true)
     }
 }

README.md

@@ -53,10 +53,10 @@ Then add the library target:
 ```swift
 import Cloudflared
 
-let session = SSHSessionActor(
-    authProvider: SSHServiceTokenProvider(),
-    tunnelProvider: SSHCloudflareTunnelProvider(),
-    retryPolicy: SSHRetryPolicy(maxReconnectAttempts: 2, baseDelayNanoseconds: 500_000_000),
+let session = SessionActor(
+    authProvider: ServiceTokenProvider(),
+    tunnelProvider: CloudflareTunnelProvider(),
+    retryPolicy: RetryPolicy(maxReconnectAttempts: 2, baseDelayNanoseconds: 500_000_000),
     oauthFallback: nil,
     sleep: { delay in try? await Task.sleep(nanoseconds: delay) }
 )
@@ -76,12 +76,12 @@ print("Tunnel endpoint: 127.0.0.1:\(localPort)")
 
 ## OAuth Flow Integration
 
-OAuth UI/token acquisition is app-owned via `SSHOAuthFlow`:
+OAuth UI/token acquisition is app-owned via `OAuthFlow`:
 
 ```swift
 import Cloudflared
 
-struct MyOAuthFlow: SSHOAuthFlow {
+struct MyOAuthFlow: OAuthFlow {
     func fetchToken(
         teamDomain: String,
         appDomain: String,
@@ -90,17 +90,17 @@ struct MyOAuthFlow: SSHOAuthFlow {
     ) async throws -> String {
         // Implement your Access login UX (for example ASWebAuthenticationSession)
         // and return CF_Authorization JWT.
-        throw SSHFailure.auth("not implemented")
+        throw Failure.auth("not implemented")
     }
 }
 
-let oauthProvider = SSHOAuthProvider(
+let oauthProvider = OAuthProvider(
     flow: MyOAuthFlow(),
-    tokenStore: SSHKeychainTokenStore()
+    tokenStore: KeychainTokenStore()
 )
 ```
 
-For app metadata discovery (`authDomain`, `appDomain`, `appAUD`) you can use `SSHAppInfoResolver`.
+For app metadata discovery (`authDomain`, `appDomain`, `appAUD`) you can use `AppInfoResolver`.
 
 ## State Stream
 
@@ -131,34 +131,34 @@ Example runtime mapping:
 
 ## Token Storage Customization
 
-If you need your own keychain layout or storage backend, implement `SSHTokenStore`:
+If you need your own keychain layout or storage backend, implement `TokenStore`:
 
 ```swift
 import Cloudflared
 
-actor CustomTokenStore: SSHTokenStore {
+actor CustomTokenStore: TokenStore {
     func readToken(for key: String) async throws -> String? { nil }
     func writeToken(_ token: String, for key: String) async throws {}
     func removeToken(for key: String) async throws {}
 }
 ```
 
-Then inject it into `SSHOAuthProvider`.
+Then inject it into `OAuthProvider`.
 
-`SSHKeychainTokenStore` defaults:
+`KeychainTokenStore` defaults:
 - iOS/tvOS/watchOS: `kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly`
 - macOS: `kSecAttrAccessibleAfterFirstUnlock` + data-protection keychain mode
 
 ## Local Security Defaults
 
-`SSHCloudflareTunnelProvider` defaults to:
+`CloudflareTunnelProvider` defaults to:
 - `maxConcurrentConnections = 1`
 - `stopAcceptingAfterFirstConnection = true`
 
 You can override via:
 
 ```swift
-let tunnel = SSHCloudflareTunnelProvider(
+let tunnel = CloudflareTunnelProvider(
     connectionLimits: .init(
         maxConcurrentConnections: 2,
         stopAcceptingAfterFirstConnection: false
@@ -193,7 +193,7 @@ swift build
 Optional keychain integration test:
 
 ```bash
-CLOUDFLARED_KEYCHAIN_TESTS=1 swift test --filter SSHTokenStoreTests/testKeychainStoreRoundTrip
+CLOUDFLARED_KEYCHAIN_TESTS=1 swift test --filter TokenStoreTests/testKeychainStoreRoundTrip
 ```
 
 ## Docs

…urces/Cloudflared/SSHAccessHeaders.swift Sources/Cloudflared/AccessHeaders.swiftSources/Cloudflared/SSHAccessHeaders.swift renamed to Sources/Cloudflared/AccessHeaders.swift Sources/Cloudflared/SSHAccessHeaders.swift renamed to Sources/Cloudflared/AccessHeaders.swift

@@ -1,4 +1,4 @@
-public enum SSHAccessHeader {
+public enum AccessHeader {
     public static let accessToken = "Cf-Access-Token"
     public static let clientID = "Cf-Access-Client-Id"
     public static let clientSecret = "Cf-Access-Client-Secret"
@@ -8,6 +8,6 @@ public enum SSHAccessHeader {
     public static let appAUD = "CF-Access-Aud"
 }
 
-public enum SSHAccessPath {
+public enum AccessPath {
     public static let login = "/cdn-cgi/access/login"
 }

Sources/Cloudflared/Auth/SSHAppInfo.swift Sources/Cloudflared/Auth/AppInfo.swiftSources/Cloudflared/Auth/SSHAppInfo.swift renamed to Sources/Cloudflared/Auth/AppInfo.swift

@@ -1,6 +1,6 @@
 import Foundation
 
-public struct SSHAppInfo: Sendable, Equatable {
+public struct AppInfo: Sendable, Equatable {
     public let authDomain: String
     public let appAUD: String
     public let appDomain: String
@@ -12,55 +12,55 @@ public struct SSHAppInfo: Sendable, Equatable {
     }
 }
 
-public enum SSHAppInfoParser {
-    public static func parse(requestURL: URL, response: HTTPURLResponse) throws -> SSHAppInfo {
+public enum AppInfoParser {
+    public static func parse(requestURL: URL, response: HTTPURLResponse) throws -> AppInfo {
         guard let finalURL = response.url, let authDomain = finalURL.host, !authDomain.isEmpty else {
-            throw SSHFailure.protocolViolation("response is missing final URL host")
+            throw Failure.protocolViolation("response is missing final URL host")
         }
 
-        let appDomain = response.value(forHTTPHeaderField: SSHAccessHeader.appDomain) ?? ""
+        let appDomain = response.value(forHTTPHeaderField: AccessHeader.appDomain) ?? ""
         guard !appDomain.isEmpty else {
-            throw SSHFailure.protocolViolation("missing \(SSHAccessHeader.appDomain) header")
+            throw Failure.protocolViolation("missing \(AccessHeader.appDomain) header")
         }
 
         let appAUD: String
-        if finalURL.path.contains(SSHAccessPath.login) {
+        if finalURL.path.contains(AccessPath.login) {
             appAUD = URLComponents(url: finalURL, resolvingAgainstBaseURL: false)?
                 .queryItems?
                 .first(where: { $0.name == "kid" })?
                 .value ?? ""
             guard !appAUD.isEmpty else {
-                throw SSHFailure.protocolViolation("missing kid query parameter in login redirect")
+                throw Failure.protocolViolation("missing kid query parameter in login redirect")
             }
-        } else if let headerAUD = response.value(forHTTPHeaderField: SSHAccessHeader.appAUD), !headerAUD.isEmpty {
+        } else if let headerAUD = response.value(forHTTPHeaderField: AccessHeader.appAUD), !headerAUD.isEmpty {
             appAUD = headerAUD
         } else {
-            throw SSHFailure.protocolViolation("unable to resolve app AUD for \(requestURL.absoluteString)")
+            throw Failure.protocolViolation("unable to resolve app AUD for \(requestURL.absoluteString)")
         }
 
-        return SSHAppInfo(authDomain: authDomain, appAUD: appAUD, appDomain: appDomain)
+        return AppInfo(authDomain: authDomain, appAUD: appAUD, appDomain: appDomain)
     }
 }
 
-public protocol SSHHTTPClient: Sendable {
+public protocol HTTPClient: Sendable {
     func send(_ request: URLRequest) async throws -> (Data, HTTPURLResponse)
 }
 
-public struct SSHAppInfoResolver: Sendable {
-    private let client: any SSHHTTPClient
+public struct AppInfoResolver: Sendable {
+    private let client: any HTTPClient
     private let userAgent: String
 
-    public init(client: any SSHHTTPClient, userAgent: String = "swift-cloudflared") {
+    public init(client: any HTTPClient, userAgent: String = "swift-cloudflared") {
         self.client = client
         self.userAgent = userAgent
     }
 
-    public func resolve(appURL: URL) async throws -> SSHAppInfo {
+    public func resolve(appURL: URL) async throws -> AppInfo {
         var request = URLRequest(url: appURL)
         request.httpMethod = "HEAD"
         request.setValue(userAgent, forHTTPHeaderField: "User-Agent")
 
         let (_, response) = try await client.send(request)
-        return try SSHAppInfoParser.parse(requestURL: appURL, response: response)
+        return try AppInfoParser.parse(requestURL: appURL, response: response)
     }
 }