Merge pull request #12 from godon-dev/credentials_commands

feat(cli): add credential management commands

Author: cherusk

.github/workflows/ci.yml

@@ -11,6 +11,14 @@ jobs:
     steps:
     - name: Checkout code
       uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+        clean: true
+
+    - name: Clean working directory
+      run: |
+        git clean -ffdx
+        git status
 
     - name: Install Nix
       uses: cachix/install-nix-action@v25
@@ -69,6 +77,13 @@ jobs:
 
     - name: Start Prism mock container
       run: |
+        # Docker debug info
+        echo "=== Docker Debug Info ==="
+        docker --version
+        docker info
+        echo "=== Checking Docker daemon ==="
+        docker ps
+
         # Download the OpenAPI spec with retry
         echo "Downloading OpenAPI spec..."
         curl -L --retry 3 --retry-delay 5 -o openapi.yml \
@@ -90,45 +105,69 @@ jobs:
         grep -E "^\s*/" openapi.yml || echo "No path definitions found"
 
         # Start Prism container in background
+        echo "=== Starting Prism container ==="
         docker run -d --name prism -p 4010:4010 \
+          --log-driver json-file \
+          --log-opt max-size=10m \
           -v $(pwd)/openapi.yml:/tmp/openapi.yml \
           stoplight/prism:4 \
           mock --host 0.0.0.0 /tmp/openapi.yml
 
         # Check if container started
-        echo "Checking container status..."
-        docker ps | grep prism || echo "Container not found in docker ps"
-        echo "=== Container logs ==="
+        echo "=== Checking container status ==="
+        sleep 5
+        docker ps -a | grep prism || echo "Container not found in docker ps"
+        
+        echo "=== Container detailed info ==="
+        docker ps -a --filter name=prism
         docker logs prism || echo "No logs available"
+        
         echo "=== Container inspection ==="
-        docker inspect prism | grep -A 10 -B 10 "State" || echo "Could not inspect container"
+        docker inspect prism || echo "Could not inspect container"
         echo "=== Network ports ==="
         docker port prism || echo "Could not get port mappings"
 
-        # Wait for Prism to start
-        echo "Waiting for Prism to start..."
-        sleep 15
-
-        # Test basic connectivity
-        echo "Testing basic connectivity to localhost:4010..."
-        curl -v http://localhost:4010 || echo "Basic connection failed"
-
-        # Verify Prism is running with retry
-        for i in {1..5}; do
-          echo "=== Attempt $i: Testing Prism health ==="
-          if curl -v http://localhost:4010/health 2>&1 | head -10; then
-            echo "✅ Prism container started successfully on port 4010"
+        # Wait for Prism to start with better error handling
+        echo "=== Waiting for Prism to start ==="
+        for i in {1..10}; do
+          echo "Attempt $i: Checking if Prism is ready..."
+          
+          # Check if container is still running
+          if ! docker ps | grep -q prism; then
+            echo "❌ Container stopped unexpectedly"
+            echo "=== Container exit logs ==="
+            docker logs prism
+            docker ps -a --filter name=prism
+            exit 1
+          fi
+          
+          # Try to connect to an actual endpoint from our spec
+          if curl -sf http://localhost:4010/breeders > /dev/null 2>&1; then
+            echo "✅ Prism is ready!"
             break
           else
-            echo "❌ Attempt $i: Prism not ready yet, waiting..."
-            echo "Container still running?"
-            docker ps | grep prism || echo "Container stopped"
-            echo "Recent logs:"
-            docker logs --tail 5 prism
-            sleep 5
+            echo "Prism not ready yet, waiting..."
+            sleep 3
+          fi
+          
+          if [ $i -eq 10 ]; then
+            echo "❌ Prism failed to start after 10 attempts"
+            echo "=== Final container state ==="
+            docker ps -a --filter name=prism
+            echo "=== Final container logs ==="
+            docker logs prism
+            exit 1
           fi
         done
 
+        # Test basic connectivity
+        echo "=== Testing basic connectivity ==="
+        curl -v http://localhost:4010 || echo "Basic connection failed"
+
+        # Verify Prism is responding
+        echo "=== Testing Prism health ==="
+        curl -v http://localhost:4010/health || echo "Health check failed"
+
         # Test available endpoints
         echo "=== Testing available Prism endpoints ==="
         echo "Testing root path:"
@@ -151,6 +190,16 @@ jobs:
         curl -X POST -H "Content-Type: application/json" -d '{"name":"test"}' \
           http://localhost:4010/breeders 2>&1 | head -10 || echo "POST /breeders failed"
 
+        echo "Testing /credentials (new endpoints):"
+        curl -v http://localhost:4010/credentials 2>&1 | head -10 || echo "/credentials failed"
+
+        echo "Testing POST /credentials:"
+        curl -X POST -H "Content-Type: application/json" \
+          -d '{"name":"test","credential_type":"ssh_private_key","content":"test_key_content"}' \
+          http://localhost:4010/credentials 2>&1 | head -10 || echo "POST /credentials failed"
+
+        echo "=== Prism setup complete ==="
+
     - name: Integration tests against Prism mock
       run: |
         # Get the binary path
@@ -209,6 +258,36 @@ jobs:
         $BINARY_PATH --help
         $BINARY_PATH breeder --help || true  # May fail but tests argument parsing
 
+        # === Credential Command Tests ===
+        echo ""
+        echo "=== Testing Credential Commands ==="
+
+        # Test credential list
+        echo "Testing: credential list"
+        $BINARY_PATH --hostname=localhost --port=4010 credential list
+
+        # Create test credential YAML file
+        echo 'name: "test_ssh_key"' > test_credential.yml
+        echo 'credential_type: "ssh_private_key"' >> test_credential.yml
+        echo 'description: "Test SSH key for CI"' >> test_credential.yml
+        echo 'content: "-----BEGIN RSA PRIVATE KEY-----\nMIIEpAIBAAKCAQEA2Z2H7V..."' >> test_credential.yml
+
+        # Test credential create
+        echo "Testing: credential create"
+        $BINARY_PATH --hostname=localhost --port=4010 credential create --file=test_credential.yml
+
+        # Test credential show with mock UUID
+        echo "Testing: credential show (including content)"
+        $BINARY_PATH --hostname=localhost --port=4010 credential show --id=550e8400-e29b-41d4-a716-446655440001
+
+        # Test credential delete
+        echo "Testing: credential delete"
+        $BINARY_PATH --hostname=localhost --port=4010 credential delete --id=550e8400-e29b-41d4-a716-446655440001
+
+        # Test help shows credential commands
+        echo "Testing: help shows credential commands"
+        $BINARY_PATH --help | grep -q "credential" && echo "✅ Credential commands documented in help" || echo "❌ Credential commands missing from help"
+
     - name: Cleanup Prism container
       if: always()
       run: |

src/godon/client.nim

@@ -63,6 +63,23 @@ proc handleResponse*[T](client: GodonClient; response: Response): ApiResponse[T]
     try:
       echo "Raw response body: ", response.body
       let jsonData = parseJson(response.body)
+      
+      # Handle nested response structures like {"breeders": [...]} or {"credentials": [...]}
+      if jsonData.kind == JObject:
+        # Check for wrapped list responses
+        when T is seq:
+          for key, value in jsonData.pairs:
+            if value.kind == JArray:
+              result = ApiResponse[T](success: true, data: value.to(T), error: "")
+              return
+        # Check for wrapped single object responses
+        else:
+          for key, value in jsonData.pairs:
+            if value.kind == JObject:
+              result = ApiResponse[T](success: true, data: value.to(T), error: "")
+              return
+      
+      # Fallback to direct conversion
       result = ApiResponse[T](success: true, data: jsonData.to(T), error: "")
     except CatchableError as e:
       result = ApiResponse[T](success: false, data: default(T), error: "JSON parse error: " & e.msg)

src/godon/credential.nim

@@ -0,0 +1,160 @@
+import std/[httpclient, json, strutils, uri, tables]
+import yaml
+import client, types
+
+# Credential API client methods
+
+proc listCredentials*(client: GodonClient): ApiResponseList[Credential] =
+  ## List all credentials
+  let url = client.baseUrl() & "/credentials"
+  
+  try:
+    let response = client.httpClient.get(url)
+    if response.code == Http200:
+      let body = parseJson(response.body)
+      let credentials = body["credentials"]
+      
+      var result: seq[Credential] = @[]
+      for cred in credentials.items:
+        result.add(parseCredentialFromJson(cred))
+      
+      return ApiResponseList[Credential](
+        success: true,
+        data: result,
+        error: ""
+      )
+    else:
+      return ApiResponseList[Credential](
+        success: false,
+        data: @[],
+        error: "Failed to list credentials: " & response.status
+      )
+  except Exception as e:
+    return ApiResponseList[Credential](
+      success: false,
+      data: @[],
+      error: "Exception: " & e.msg
+    )
+
+proc createCredential*(client: GodonClient, credentialData: JsonNode): ApiResponseSingle[Credential] =
+  ## Create a new credential
+  let url = client.baseUrl() & "/credentials"
+  
+  try:
+    client.httpClient.headers = newHttpHeaders({"Content-Type": "application/json"})
+    let response = client.httpClient.post(url, $credentialData)
+    if response.code == Http201:
+      let body = parseJson(response.body)
+      let credential = parseCredentialFromJson(body["credential"])
+      
+      return ApiResponseSingle[Credential](
+        success: true,
+        data: credential,
+        error: ""
+      )
+    else:
+      return ApiResponseSingle[Credential](
+        success: false,
+        data: Credential(),
+        error: "Failed to create credential: " & response.status
+      )
+  except Exception as e:
+    return ApiResponseSingle[Credential](
+      success: false,
+      data: Credential(),
+      error: "Exception: " & e.msg
+    )
+
+proc getCredential*(client: GodonClient, credentialId: string): ApiResponseSingle[Credential] =
+  ## Get a specific credential by ID (including content)
+  let url = client.baseUrl() & "/credentials/" & encodeUrl(credentialId)
+  
+  try:
+    let response = client.httpClient.get(url)
+    if response.code == Http200:
+      let body = parseJson(response.body)
+      let credential = parseCredentialFromJson(body["credential"])
+      
+      return ApiResponseSingle[Credential](
+        success: true,
+        data: credential,
+        error: ""
+      )
+    else:
+      return ApiResponseSingle[Credential](
+        success: false,
+        data: Credential(),
+        error: "Failed to get credential: " & response.status
+      )
+  except Exception as e:
+    return ApiResponseSingle[Credential](
+      success: false,
+      data: Credential(),
+      error: "Exception: " & e.msg
+    )
+
+proc deleteCredential*(client: GodonClient, credentialId: string): ApiResponse[JsonNode] =
+  ## Delete a credential by ID
+  let url = client.baseUrl() & "/credentials/" & encodeUrl(credentialId)
+  
+  try:
+    let response = client.httpClient.delete(url)
+    if response.code == Http200:
+      let body = parseJson(response.body)
+      
+      return ApiResponse[JsonNode](
+        success: true,
+        data: body,
+        error: ""
+      )
+    else:
+      return ApiResponse[JsonNode](
+        success: false,
+        data: nil,
+        error: "Failed to delete credential: " & response.status
+      )
+  except Exception as e:
+    return ApiResponse[JsonNode](
+      success: false,
+      data: nil,
+      error: "Exception: " & e.msg
+    )
+
+proc createCredentialFromYaml*(client: GodonClient, yamlContent: string): ApiResponseSingle[Credential] =
+  ## Create credential from YAML content
+  ## This is a convenience method that parses YAML and converts to JSON
+  
+  try:
+    # Parse YAML to a generic table, then construct JsonNode manually
+    let yamlData = yaml.loadAs[Table[string, string]](yamlContent)
+    
+    # Build JsonNode from the parsed YAML
+    var credentialData = newJObject()
+    
+    # Add required fields
+    credentialData.add("name", newJString(yamlData["name"]))
+    credentialData.add("credential_type", newJString(yamlData["credential_type"]))
+    
+    # Add optional fields
+    if "description" in yamlData:
+      credentialData.add("description", newJString(yamlData["description"]))
+    else:
+      credentialData.add("description", newJString(""))
+    
+    # Ensure content field exists for credentials
+    if "content" in yamlData:
+      credentialData.add("content", newJString(yamlData["content"]))
+    else:
+      return ApiResponseSingle[Credential](
+        success: false,
+        data: Credential(),
+        error: "Missing required field: content"
+      )
+    
+    return client.createCredential(credentialData)
+  except Exception as e:
+    return ApiResponseSingle[Credential](
+      success: false,
+      data: Credential(),
+      error: "Failed to parse YAML: " & e.msg
+    )