fix: add involves edge from task to agent:nomos at creation

Plus sync vendor directory for Docker build compatibility.

vendor/github.com/infisical/go-sdk/packages/api/kms/create_key.go

@@ -0,0 +1,27 @@
+package api
+
+import (
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callKmsCreateKeyOperationV1 = "CallKmsCreateKeyV1"
+
+func CallKmsCreateKeyV1(httpClient *resty.Client, request KmsCreateKeyV1Request) (KmsCreateKeyV1Response, error) {
+	kmsCreateKeyResponse := KmsCreateKeyV1Response{}
+
+	res, err := httpClient.R().
+		SetResult(&kmsCreateKeyResponse).
+		SetBody(request).
+		Post("/v1/kms/keys")
+
+	if err != nil {
+		return KmsCreateKeyV1Response{}, errors.NewRequestError(callKmsCreateKeyOperationV1, err)
+	}
+
+	if res.IsError() {
+		return KmsCreateKeyV1Response{}, errors.NewAPIErrorWithResponse(callKmsCreateKeyOperationV1, res)
+	}
+
+	return kmsCreateKeyResponse, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/kms/decrypt_data.go

@@ -0,0 +1,29 @@
+package api
+
+import (
+	"fmt"
+
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callKmsDecryptDataOperationV1 = "CallKmsDecryptDataV1"
+
+func CallKmsDecryptDataV1(httpClient *resty.Client, request KmsDecryptDataV1Request) (KmsDecryptDataV1Response, error) {
+	kmsDecryptDataResponse := KmsDecryptDataV1Response{}
+
+	res, err := httpClient.R().
+		SetResult(&kmsDecryptDataResponse).
+		SetBody(request).
+		Post(fmt.Sprintf("/v1/kms/keys/%s/decrypt", request.KeyId))
+
+	if err != nil {
+		return KmsDecryptDataV1Response{}, errors.NewRequestError(callKmsDecryptDataOperationV1, err)
+	}
+
+	if res.IsError() {
+		return KmsDecryptDataV1Response{}, errors.NewAPIErrorWithResponse(callKmsDecryptDataOperationV1, res)
+	}
+
+	return kmsDecryptDataResponse, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/kms/delete_key.go

@@ -0,0 +1,29 @@
+package api
+
+import (
+	"fmt"
+
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callKmsDeleteKeyOperationV1 = "CallKmsDeleteKeyV1"
+
+func CallKmsDeleteKeyV1(httpClient *resty.Client, request KmsDeleteKeyV1Request) (KmsDeleteKeyV1Response, error) {
+	kmsDeleteKeyResponse := KmsDeleteKeyV1Response{}
+
+	res, err := httpClient.R().
+		SetResult(&kmsDeleteKeyResponse).
+		SetBody(request).
+		Delete(fmt.Sprintf("/v1/kms/keys/%s", request.KeyId))
+
+	if err != nil {
+		return KmsDeleteKeyV1Response{}, errors.NewRequestError(callKmsDeleteKeyOperationV1, err)
+	}
+
+	if res.IsError() {
+		return KmsDeleteKeyV1Response{}, errors.NewAPIErrorWithResponse(callKmsDeleteKeyOperationV1, res)
+	}
+
+	return kmsDeleteKeyResponse, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/kms/encrypt_data.go

@@ -0,0 +1,29 @@
+package api
+
+import (
+	"fmt"
+
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callKmsEncryptDataOperationV1 = "CallKmsEncryptDataV1"
+
+func CallKmsEncryptDataV1(httpClient *resty.Client, request KmsEncryptDataV1Request) (KmsEncryptDataV1Response, error) {
+	kmsEncryptDataResponse := KmsEncryptDataV1Response{}
+
+	res, err := httpClient.R().
+		SetResult(&kmsEncryptDataResponse).
+		SetBody(request).
+		Post(fmt.Sprintf("/v1/kms/keys/%s/encrypt", request.KeyId))
+
+	if err != nil {
+		return KmsEncryptDataV1Response{}, errors.NewRequestError(callKmsEncryptDataOperationV1, err)
+	}
+
+	if res.IsError() {
+		return KmsEncryptDataV1Response{}, errors.NewAPIErrorWithResponse(callKmsEncryptDataOperationV1, res)
+	}
+
+	return kmsEncryptDataResponse, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/kms/get_key_by_name.go

@@ -0,0 +1,28 @@
+package api
+
+import (
+	"fmt"
+
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callKmsGetKeyByNameOperationV1 = "CallKmsGetKeyByNameV1"
+
+func CallKmsGetKeyByNameV1(httpClient *resty.Client, request KmsGetKeyByNameV1Request) (KmsGetKeyV1Response, error) {
+	kmsGetKeyByNameResponse := KmsGetKeyV1Response{}
+
+	res, err := httpClient.R().
+		SetResult(&kmsGetKeyByNameResponse).
+		Get(fmt.Sprintf("/v1/kms/keys/key-name/%s?projectId=%s", request.KeyName, request.ProjectId))
+
+	if err != nil {
+		return KmsGetKeyV1Response{}, errors.NewRequestError(callKmsGetKeyByNameOperationV1, err)
+	}
+
+	if res.IsError() {
+		return KmsGetKeyV1Response{}, errors.NewAPIErrorWithResponse(callKmsGetKeyByNameOperationV1, res)
+	}
+
+	return kmsGetKeyByNameResponse, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/kms/get_public_key.go

@@ -0,0 +1,28 @@
+package api
+
+import (
+	"fmt"
+
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callKmsGetPublicKeyOperationV1 = "CallKmsGetPublicKeyV1"
+
+func CallKmsGetPublicKeyV1(httpClient *resty.Client, request KmsGetPublicKeyV1Request) (KmsGetPublicKeyV1Response, error) {
+	kmsGetPublicKeyResponse := KmsGetPublicKeyV1Response{}
+
+	res, err := httpClient.R().
+		SetResult(&kmsGetPublicKeyResponse).
+		Get(fmt.Sprintf("/v1/kms/keys/%s/public-key", request.KeyId))
+
+	if err != nil {
+		return KmsGetPublicKeyV1Response{}, errors.NewRequestError(callKmsGetPublicKeyOperationV1, err)
+	}
+
+	if res.IsError() {
+		return KmsGetPublicKeyV1Response{}, errors.NewAPIErrorWithResponse(callKmsGetPublicKeyOperationV1, res)
+	}
+
+	return kmsGetPublicKeyResponse, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/kms/get_signing_algorithms.go

@@ -0,0 +1,29 @@
+package api
+
+import (
+	"fmt"
+
+	"github.com/go-resty/resty/v2"
+
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callKmsGetSigningAlgorithmsOperationV1 = "CallKmsGetSigningAlgorithmsV1"
+
+func CallKmsGetSigningAlgorithmsV1(httpClient *resty.Client, request KmsListSigningAlgorithmsV1Request) (KmsListSigningAlgorithmsV1Response, error) {
+	kmsListSigningAlgorithmsResponse := KmsListSigningAlgorithmsV1Response{}
+
+	res, err := httpClient.R().
+		SetResult(&kmsListSigningAlgorithmsResponse).
+		Get(fmt.Sprintf("/v1/kms/keys/%s/signing-algorithms", request.KeyId))
+
+	if err != nil {
+		return KmsListSigningAlgorithmsV1Response{}, errors.NewRequestError(callKmsGetSigningAlgorithmsOperationV1, err)
+	}
+
+	if res.IsError() {
+		return KmsListSigningAlgorithmsV1Response{}, errors.NewAPIErrorWithResponse(callKmsGetSigningAlgorithmsOperationV1, res)
+	}
+
+	return kmsListSigningAlgorithmsResponse, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/kms/models.go

@@ -0,0 +1,114 @@
+package api
+
+type KmsEncryptDataV1Request struct {
+	KeyId     string
+	Plaintext string `json:"plaintext"`
+}
+
+type KmsEncryptDataV1Response struct {
+	Ciphertext string `json:"ciphertext"`
+}
+
+type KmsDecryptDataV1Request struct {
+	KeyId      string
+	Ciphertext string `json:"ciphertext"`
+}
+
+type KmsDecryptDataV1Response struct {
+	Plaintext string `json:"plaintext"`
+}
+
+type KmsSignDataV1Request struct {
+	KeyId            string
+	Data             string `json:"data"`
+	SigningAlgorithm string `json:"signingAlgorithm"`
+	IsDigest         bool   `json:"isDigest"`
+}
+
+type KmsSignDataV1Response struct {
+	Signature        string `json:"signature"`
+	KeyId            string `json:"keyId"`
+	SigningAlgorithm string `json:"signingAlgorithm"`
+}
+
+type KmsVerifyDataV1Request struct {
+	KeyId            string
+	Data             string `json:"data"` // Data must be base64 encoded
+	Signature        string `json:"signature"`
+	SigningAlgorithm string `json:"signingAlgorithm"`
+	IsDigest         bool   `json:"isDigest"`
+}
+
+type KmsVerifyDataV1Response struct {
+	SignatureValid   bool   `json:"signatureValid"`
+	KeyId            string `json:"keyId"`
+	SigningAlgorithm string `json:"signingAlgorithm"`
+}
+
+type KmsListSigningAlgorithmsV1Request struct {
+	KeyId string
+}
+
+type KmsListSigningAlgorithmsV1Response struct {
+	SigningAlgorithms []string `json:"signingAlgorithms"`
+}
+
+type KmsGetPublicKeyV1Request struct {
+	KeyId string
+}
+
+type KmsGetPublicKeyV1Response struct {
+	PublicKey string `json:"publicKey"`
+}
+
+type KmsCreateKeyV1Request struct {
+	// KeyUsage is the usage of the key. Can be either sign-verify or encrypt-decrypt
+	KeyUsage string `json:"keyUsage"`
+
+	// Description is the description of the key.
+	Description string `json:"description"`
+
+	// Name is the name of the key.
+	Name string `json:"name"`
+
+	// EncryptionAlgorithm is the algorithm that will be used for the key itself.
+	// `sign-verify algorithms`: `rsa-4096`, `ecc-nist-p256`
+	// `encrypt-decrypt algorithms`: `aes-256-gcm`, `aes-128-gcm`
+	EncryptionAlgorithm string `json:"encryptionAlgorithm"`
+
+	// ProjectId is the project ID that the key will be created in.
+	ProjectId string `json:"projectId"`
+}
+
+type KmsCreateKeyV1Response struct {
+	Key KmsKey `json:"key"`
+}
+
+type KmsDeleteKeyV1Request struct {
+	KeyId string
+}
+
+type KmsDeleteKeyV1Response struct {
+	Key KmsKey `json:"key"`
+}
+
+type KmsGetKeyByNameV1Request struct {
+	KeyName   string
+	ProjectId string
+}
+
+type KmsGetKeyV1Response struct {
+	Key KmsKey `json:"key"`
+}
+
+type KmsKey struct {
+	KeyId               string `json:"id"`
+	Description         string `json:"description"`
+	IsDisabled          bool   `json:"isDisabled"`
+	OrgId               string `json:"orgId"`
+	Name                string `json:"name"`
+	ProjectId           string `json:"projectId"`
+	KeyUsage            string `json:"keyUsage"`
+	Version             int    `json:"version"`
+	EncryptionAlgorithm string `json:"encryptionAlgorithm"`
+}

vendor/github.com/infisical/go-sdk/packages/api/kms/sign_data.go

@@ -0,0 +1,29 @@
+package api
+
+import (
+	"fmt"
+
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callKmsSignDataOperationV1 = "CallKmsSignDataV1"
+
+func CallKmsSignDataV1(httpClient *resty.Client, request KmsSignDataV1Request) (KmsSignDataV1Response, error) {
+	kmsSignDataResponse := KmsSignDataV1Response{}
+
+	res, err := httpClient.R().
+		SetResult(&kmsSignDataResponse).
+		SetBody(request).
+		Post(fmt.Sprintf("/v1/kms/keys/%s/sign", request.KeyId))
+
+	if err != nil {
+		return KmsSignDataV1Response{}, errors.NewRequestError(callKmsSignDataOperationV1, err)
+	}
+
+	if res.IsError() {
+		return KmsSignDataV1Response{}, errors.NewAPIErrorWithResponse(callKmsSignDataOperationV1, res)
+	}
+
+	return kmsSignDataResponse, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/kms/verify_data.go

@@ -0,0 +1,29 @@
+package api
+
+import (
+	"fmt"
+
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callKmsVerifyDataOperationV1 = "CallKmsVerifyDataV1"
+
+func CallKmsVerifyDataV1(httpClient *resty.Client, request KmsVerifyDataV1Request) (KmsVerifyDataV1Response, error) {
+	kmsVerifyDataResponse := KmsVerifyDataV1Response{}
+
+	res, err := httpClient.R().
+		SetResult(&kmsVerifyDataResponse).
+		SetBody(request).
+		Post(fmt.Sprintf("/v1/kms/keys/%s/verify", request.KeyId))
+
+	if err != nil {
+		return KmsVerifyDataV1Response{}, errors.NewRequestError(callKmsVerifyDataOperationV1, err)
+	}
+
+	if res.IsError() {
+		return KmsVerifyDataV1Response{}, errors.NewAPIErrorWithResponse(callKmsVerifyDataOperationV1, res)
+	}
+
+	return kmsVerifyDataResponse, nil
+}