From 65813a954486421fa020a619b5c150f7508351ef Mon Sep 17 00:00:00 2001 From: Bobby Christopher Date: Wed, 5 Feb 2025 10:57:43 -0600 Subject: [PATCH 1/8] added an api client but its broke --- cmd/cloud.go | 11 +++++++++ internal/util/api.go | 57 ++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 68 insertions(+) create mode 100644 internal/util/api.go diff --git a/cmd/cloud.go b/cmd/cloud.go index 4362f3de..da062f5c 100644 --- a/cmd/cloud.go +++ b/cmd/cloud.go @@ -21,6 +21,8 @@ import ( "github.com/spf13/viper" ) + + var cloudCmd = &cobra.Command{ Use: "cloud", Short: "Cloud related commands", @@ -71,6 +73,13 @@ var cloudDeployCmd = &cobra.Command{ token := viper.GetString("auth.api_key") u, err := url.Parse(apiUrl) + + client := util.NewAPIClient(apiUrl, token) + + var projectResponse projectResponse + + + client.do("GET", fmt.Sprintf("/cli/project/%s", project.ProjectId, ), projectResponse) if err != nil { @@ -196,6 +205,8 @@ var cloudDeployCmd = &cobra.Command{ } if resp.StatusCode != http.StatusOK { buf, _ := io.ReadAll(resp.Body) + + if err := updateDeploymentStatus(apiUrl, token, startResponse.Data.DeploymentId, "failed"); err != nil { logger.Fatal("%s", err) } diff --git a/internal/util/api.go b/internal/util/api.go new file mode 100644 index 00000000..a3e48444 --- /dev/null +++ b/internal/util/api.go @@ -0,0 +1,57 @@ +package util + +import ( + "bytes" + "encoding/json" + "fmt" + "net/http" + "net/url" +) + +type APIClient struct { + baseURL string + token string + client *http.Client +} + +func NewAPIClient(baseURL, token string) *APIClient { + return &APIClient{ + baseURL: baseURL, + token: token, + client: http.DefaultClient, + } +} + +func (c *APIClient) do(method, path string, payload interface{}) error { + u, err := url.Parse(c.baseURL) + if err != nil { + return fmt.Errorf("error parsing base url: %w", err) + } + u.Path = path + + var body []byte + if payload != nil { + body, err = json.Marshal(payload) + if err != nil { + return fmt.Errorf("error marshalling payload: %w", err) + } + } + + req, err := http.NewRequest(method, u.String(), bytes.NewBuffer(body)) + if err != nil { + return fmt.Errorf("error creating request: %w", err) + } + req.Header.Set("Content-Type", "application/json") + req.Header.Set("Authorization", "Bearer "+c.token) + + resp, err := c.client.Do(req) + if err != nil { + return fmt.Errorf("error sending request: %w", err) + } + defer resp.Body.Close() + + if resp.StatusCode != http.StatusAccepted { + return fmt.Errorf("request failed with status (%s)", resp.Status) + } + return nil +} \ No newline at end of file From 3a928955d7bdd621ef086299e376e3da5ab3fed7 Mon Sep 17 00:00:00 2001 From: Bobby Christopher Date: Wed, 5 Feb 2025 18:40:26 -0600 Subject: [PATCH 2/8] added api client --- cmd/cloud.go | 99 ++++---------------------------------------- internal/util/api.go | 12 +++++- 2 files changed, 19 insertions(+), 92 deletions(-) diff --git a/cmd/cloud.go b/cmd/cloud.go index da062f5c..446c70e0 100644 --- a/cmd/cloud.go +++ b/cmd/cloud.go @@ -1,12 +1,9 @@ package cmd import ( - "bytes" - "encoding/json" "fmt" "io" "net/http" - "net/url" "os" "path/filepath" "strconv" @@ -21,8 +18,6 @@ import ( "github.com/spf13/viper" ) - - var cloudCmd = &cobra.Command{ Use: "cloud", Short: "Cloud related commands", @@ -72,67 +67,20 @@ var cloudDeployCmd = &cobra.Command{ appUrl := viper.GetString("overrides.app_url") token := viper.GetString("auth.api_key") - u, err := url.Parse(apiUrl) - client := util.NewAPIClient(apiUrl, token) + // Get project details var projectResponse projectResponse - - - client.do("GET", fmt.Sprintf("/cli/project/%s", project.ProjectId, ), projectResponse) - - - if err != nil { - logger.Fatal("error parsing api url: %s. %s", apiUrl, err) - } - u.Path = fmt.Sprintf("/cli/project/%s", project.ProjectId) - req, err := http.NewRequest("GET", u.String(), nil) - if err != nil { - logger.Fatal("error creating project request: %s", err) - } - req.Header.Set("Authorization", "Bearer "+token) - resp, err := http.DefaultClient.Do(req) - if err != nil { + if err := client.DoWithResponse("GET", fmt.Sprintf("/cli/project/%s", project.ProjectId), nil, &projectResponse); err != nil { logger.Fatal("error requesting project: %s", err) } - defer resp.Body.Close() - if resp.StatusCode != http.StatusOK { - logger.Fatal("unexpected error requesting project (%s)", resp.Status) - } - enc := json.NewDecoder(resp.Body) - var projectResponse projectResponse - if err := enc.Decode(&projectResponse); err != nil { - logger.Fatal("error decoding project response json: %s", err) - } orgId := projectResponse.Data.OrgId - - // start the deployment request to get a one-time upload url - u.Path = fmt.Sprintf("/cli/deploy/start/%s/%s", orgId, project.ProjectId) - req, err = http.NewRequest("PUT", u.String(), nil) - if err != nil { - logger.Fatal("error creating url route: %s", err) - } - req.Header.Set("Authorization", "Bearer "+token) - resp, err = http.DefaultClient.Do(req) - if err != nil { - logger.Fatal("error creating start request for upload: %s", err) - } - defer resp.Body.Close() - if resp.StatusCode != http.StatusAccepted { - logger.Fatal("unexpected error uploading (%s)", resp.Status) - } - enc = json.NewDecoder(resp.Body) + // Start deployment var startResponse startResponse - if err := enc.Decode(&startResponse); err != nil { - logger.Fatal("error decoding start response json: %s", err) - } - resp.Body.Close() - if !startResponse.Success { - logger.Fatal("error generating start authentication: %s", startResponse.Message) + if err := client.DoWithResponse("PUT", fmt.Sprintf("/cli/deploy/start/%s/%s", orgId, project.ProjectId), nil, &startResponse); err != nil { + logger.Fatal("error starting deployment: %s", err) } - logger.Debug("upload api is %s", startResponse.Data.Url) - logger.Debug("deployment id is %s", startResponse.Data.DeploymentId) // load up any gitignore files gitignore := filepath.Join(dir, ignore.Ignore) @@ -187,7 +135,7 @@ var cloudDeployCmd = &cobra.Command{ started = time.Now() // send the zip file to the upload endpoint provided - req, err = http.NewRequest("PUT", startResponse.Data.Url, of) + req, err := http.NewRequest("PUT", startResponse.Data.Url, of) if err != nil { logger.Fatal("error creating PUT request", err) } @@ -195,18 +143,15 @@ var cloudDeployCmd = &cobra.Command{ req.Header.Set("Content-Type", "application/zip") req.Header.Set("Content-Length", strconv.FormatInt(fi.Size(), 10)) - resp, err = http.DefaultClient.Do(req) + resp, err := http.DefaultClient.Do(req) if err != nil { if err := updateDeploymentStatus(apiUrl, token, startResponse.Data.DeploymentId, "failed"); err != nil { logger.Fatal("%s", err) } logger.Fatal("error uploading deployment: %s", err) - } if resp.StatusCode != http.StatusOK { buf, _ := io.ReadAll(resp.Body) - - if err := updateDeploymentStatus(apiUrl, token, startResponse.Data.DeploymentId, "failed"); err != nil { logger.Fatal("%s", err) } @@ -225,35 +170,9 @@ var cloudDeployCmd = &cobra.Command{ } func updateDeploymentStatus(apiUrl, token, deploymentId, status string) error { - u, err := url.Parse(apiUrl) - if err != nil { - return fmt.Errorf("error parsing api url: %s", err) - } - u.Path = fmt.Sprintf("/cli/deploy/upload/%s", deploymentId) - + client := util.NewAPIClient(apiUrl, token) payload := map[string]string{"state": status} - body, err := json.Marshal(payload) - if err != nil { - return fmt.Errorf("error marshalling payload: %s", err) - } - - req, err := http.NewRequest("PUT", u.String(), bytes.NewBuffer(body)) - if err != nil { - return fmt.Errorf("error creating status update request: %s", err) - } - req.Header.Set("Content-Type", "application/json") - req.Header.Set("Authorization", "Bearer "+token) - - resp, err := http.DefaultClient.Do(req) - if err != nil { - return fmt.Errorf("error sending status update request: %s", err) - } - defer resp.Body.Close() - - if resp.StatusCode != http.StatusAccepted { - return fmt.Errorf("error updating deployment status (%s)", resp.Status) - } - return nil + return client.DoWithResponse("PUT", fmt.Sprintf("/cli/deploy/upload/%s", deploymentId), payload, nil) } func init() { diff --git a/internal/util/api.go b/internal/util/api.go index a3e48444..bc6f48b2 100644 --- a/internal/util/api.go +++ b/internal/util/api.go @@ -22,7 +22,7 @@ func NewAPIClient(baseURL, token string) *APIClient { } } -func (c *APIClient) do(method, path string, payload interface{}) error { +func (c *APIClient) DoWithResponse(method, path string, payload interface{}, response interface{}) error { u, err := url.Parse(c.baseURL) if err != nil { return fmt.Errorf("error parsing base url: %w", err) @@ -50,8 +50,16 @@ func (c *APIClient) do(method, path string, payload interface{}) error { } defer resp.Body.Close() - if resp.StatusCode != http.StatusAccepted { + if method == "GET" && resp.StatusCode != http.StatusOK { return fmt.Errorf("request failed with status (%s)", resp.Status) + } else if method != "GET" && resp.StatusCode != http.StatusAccepted { + return fmt.Errorf("request failed with status (%s)", resp.Status) + } + + if response != nil { + if err := json.NewDecoder(resp.Body).Decode(response); err != nil { + return fmt.Errorf("error decoding response: %w", err) + } } return nil } \ No newline at end of file From 3adfa85b2b51ff2728a19d4cb4ec42f472dfa6bc Mon Sep 17 00:00:00 2001 From: Bobby Christopher Date: Wed, 5 Feb 2025 20:20:43 -0600 Subject: [PATCH 3/8] added api client --- cmd/cloud.go | 6 +++--- internal/util/api.go | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/cmd/cloud.go b/cmd/cloud.go index 446c70e0..4c050853 100644 --- a/cmd/cloud.go +++ b/cmd/cloud.go @@ -71,14 +71,14 @@ var cloudDeployCmd = &cobra.Command{ // Get project details var projectResponse projectResponse - if err := client.DoWithResponse("GET", fmt.Sprintf("/cli/project/%s", project.ProjectId), nil, &projectResponse); err != nil { + if err := client.Do("GET", fmt.Sprintf("/cli/project/%s", project.ProjectId), nil, &projectResponse); err != nil { logger.Fatal("error requesting project: %s", err) } orgId := projectResponse.Data.OrgId // Start deployment var startResponse startResponse - if err := client.DoWithResponse("PUT", fmt.Sprintf("/cli/deploy/start/%s/%s", orgId, project.ProjectId), nil, &startResponse); err != nil { + if err := client.Do("PUT", fmt.Sprintf("/cli/deploy/start/%s/%s", orgId, project.ProjectId), nil, &startResponse); err != nil { logger.Fatal("error starting deployment: %s", err) } @@ -172,7 +172,7 @@ var cloudDeployCmd = &cobra.Command{ func updateDeploymentStatus(apiUrl, token, deploymentId, status string) error { client := util.NewAPIClient(apiUrl, token) payload := map[string]string{"state": status} - return client.DoWithResponse("PUT", fmt.Sprintf("/cli/deploy/upload/%s", deploymentId), payload, nil) + return client.Do("PUT", fmt.Sprintf("/cli/deploy/upload/%s", deploymentId), payload, nil) } func init() { diff --git a/internal/util/api.go b/internal/util/api.go index bc6f48b2..f5fd0116 100644 --- a/internal/util/api.go +++ b/internal/util/api.go @@ -22,7 +22,7 @@ func NewAPIClient(baseURL, token string) *APIClient { } } -func (c *APIClient) DoWithResponse(method, path string, payload interface{}, response interface{}) error { +func (c *APIClient) Do(method, path string, payload interface{}, response interface{}) error { u, err := url.Parse(c.baseURL) if err != nil { return fmt.Errorf("error parsing base url: %w", err) From 0b232976f1e8e11a3943ce91754156e2d08b5901 Mon Sep 17 00:00:00 2001 From: Bobby Christopher Date: Wed, 5 Feb 2025 21:38:59 -0600 Subject: [PATCH 4/8] added set env get env cli --- cmd/project.go | 93 +++++++++++++++++++++++++++++++++++++ internal/project/project.go | 31 +++++++++++++ internal/util/api.go | 6 +-- 3 files changed, 126 insertions(+), 4 deletions(-) diff --git a/cmd/project.go b/cmd/project.go index 529c5133..ffdbc394 100644 --- a/cmd/project.go +++ b/cmd/project.go @@ -1,6 +1,7 @@ package cmd import ( + "fmt" "os" "path/filepath" @@ -213,8 +214,100 @@ var projectInitCmd = &cobra.Command{ }, } +var projectEnvSetCmd = &cobra.Command{ + Use: "env:set [directory]", + Short: "Set environment variables for a project", + Args: cobra.MaximumNArgs(1), + Run: func(cmd *cobra.Command, args []string) { + logger := env.NewLogger(cmd) + dir := "." + if len(args) > 0 { + dir = args[0] + } + dir = resolveDir(logger, dir, false) + envFile := filepath.Join(dir, ".env") + + envLines, err := env.ParseEnvFile(envFile) + if err != nil { + logger.Fatal("failed to parse .env file: %s", err) + } + + // Print local env vars to stdout + for _, envLine := range envLines { + fmt.Printf("%s=%s\n", envLine.Key, envLine.Val) + } + + apiUrl := viper.GetString("overrides.api_url") + apiKey := viper.GetString("auth.api_key") + if apiKey == "" { + logger.Fatal("you are not logged in") + } + + project := project.NewProject() + if err := project.Load(dir); err != nil { + logger.Fatal("failed to load project: %s", err) + } + + secretMap := make(map[string]interface{}) + for _, envLine := range envLines { + secretMap[envLine.Key] = envLine.Val + } + + project.SetProjectSecrets(logger, apiUrl, apiKey, secretMap) + + if err != nil { + logger.Fatal("failed to set project env: %s", err) + } + + printSuccess("Project environment variables set successfully") + + }, +} + +var projectEnvCmd = &cobra.Command{ + Use: "env [directory]", + Short: "Get environment variables for a project", + Args: cobra.MaximumNArgs(1), + Run: func(cmd *cobra.Command, args []string) { + logger := env.NewLogger(cmd) + + dir := "." + if len(args) > 0 { + dir = args[0] + } + dir = resolveDir(logger, dir, false) + + apiUrl := viper.GetString("overrides.api_url") + apiKey := viper.GetString("auth.api_key") + if apiKey == "" { + logger.Fatal("you are not logged in") + } + + project := project.NewProject() + if err := project.Load(dir); err != nil { + logger.Fatal("failed to load project: %s", err) + } + logger.Info("Getting environment variables for project %s", project.ProjectId) + + projectData, err := project.GetProjectEnv(logger, apiUrl, apiKey) + if err != nil { + logger.Fatal("failed to get project env: %s", err) + } + // Print remote env vars and secrets to stdout + for key, value := range projectData.Env { + fmt.Printf("%s=%s\n", key, value) + } + for key, value := range projectData.Secrets { + fmt.Printf("%s=%s\n", key, value) + } + + }, +} + func init() { rootCmd.AddCommand(projectCmd) projectCmd.AddCommand(projectInitCmd) projectCmd.AddCommand(projectNewCmd) + projectCmd.AddCommand(projectEnvCmd) + projectCmd.AddCommand(projectEnvSetCmd) } diff --git a/internal/project/project.go b/internal/project/project.go index b0e0ec52..38111014 100644 --- a/internal/project/project.go +++ b/internal/project/project.go @@ -8,7 +8,9 @@ import ( "os" "path/filepath" + "github.com/agentuity/cli/internal/util" "github.com/agentuity/go-common/logger" + "gopkg.in/yaml.v3" "k8s.io/apimachinery/pkg/api/resource" ) @@ -26,6 +28,8 @@ type initProjectResult struct { type ProjectData struct { APIKey string `json:"api_key"` ProjectId string `json:"id"` + Env map[string]interface{} `json:"env"` + Secrets map[string]interface{} `json:"secrets"` } // InitProject will create a new project in the organization. @@ -151,3 +155,30 @@ func (p *Project) Save(dir string) error { func NewProject() *Project { return &Project{} } + +type ProjectResponse struct { + Success bool `json:"success"` + Message string `json:"message"` + Data ProjectData `json:"data"` +} + +func (p *Project) GetProjectEnv(logger logger.Logger, baseUrl string, token string) (*ProjectData, error) { + client := util.NewAPIClient(baseUrl, token) + + var projectResponse ProjectResponse + if err := client.Do("GET", fmt.Sprintf("/cli/project/%s", p.ProjectId), nil, &projectResponse); err != nil { + logger.Fatal("error getting project env: %s", err) + } + return &projectResponse.Data, nil +} + +func (p *Project) SetProjectSecrets(logger logger.Logger, baseUrl string, token string, secrets map[string]interface{}) (*ProjectData, error) { + client := util.NewAPIClient(baseUrl, token) + var projectResponse ProjectResponse + if err := client.Do("PUT", fmt.Sprintf("/cli/project/%s", p.ProjectId), map[string]interface{}{ + "secrets": secrets, + }, &projectResponse); err != nil { + logger.Fatal("error setting project env: %s", err) + } + return &projectResponse.Data, nil +} \ No newline at end of file diff --git a/internal/util/api.go b/internal/util/api.go index f5fd0116..932f8148 100644 --- a/internal/util/api.go +++ b/internal/util/api.go @@ -50,11 +50,9 @@ func (c *APIClient) Do(method, path string, payload interface{}, response interf } defer resp.Body.Close() - if method == "GET" && resp.StatusCode != http.StatusOK { + if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusAccepted { return fmt.Errorf("request failed with status (%s)", resp.Status) - } else if method != "GET" && resp.StatusCode != http.StatusAccepted { - return fmt.Errorf("request failed with status (%s)", resp.Status) - } + } if response != nil { if err := json.NewDecoder(resp.Body).Decode(response); err != nil { From d64ff0d36e80de9c27659210d9f58aa29d0efa98 Mon Sep 17 00:00:00 2001 From: Bobby Christopher Date: Wed, 5 Feb 2025 22:18:32 -0600 Subject: [PATCH 5/8] added env cmd --- cmd/env.go | 109 ++++++++++++++++++++++++++++++++++++ cmd/project.go | 94 ------------------------------- internal/project/project.go | 6 +- 3 files changed, 112 insertions(+), 97 deletions(-) create mode 100644 cmd/env.go diff --git a/cmd/env.go b/cmd/env.go new file mode 100644 index 00000000..841ffed1 --- /dev/null +++ b/cmd/env.go @@ -0,0 +1,109 @@ +package cmd + +import ( + "fmt" + + "github.com/agentuity/cli/internal/project" + "github.com/agentuity/go-common/env" + "github.com/spf13/cobra" + "github.com/spf13/viper" +) + +var envCmd = &cobra.Command{ + Use: "env", + Short: "Environment related commands", + Run: func(cmd *cobra.Command, args []string) { + cmd.Help() + }, +} + + +var envSetCmd = &cobra.Command{ + Use: "set [key] [value]", + Short: "Set environment variables", + Args: cobra.MinimumNArgs(2), + Run: func(cmd *cobra.Command, args []string) { + logger := env.NewLogger(cmd) + dir := resolveProjectDir(logger, cmd) + apiUrl := viper.GetString("overrides.api_url") + apiKey := viper.GetString("auth.api_key") + if apiKey == "" { + logger.Fatal("you are not logged in") + } + project := project.NewProject() + if err := project.Load(dir); err != nil { + logger.Fatal("failed to load project: %s", err) + } + projectData, err := project.SetProjectEnv(logger, apiUrl, apiKey, map[string]interface{}{args[0]: args[1]}) + if err != nil { + logger.Fatal("failed to set project env: %s", err) + } + for key, value := range projectData.Env { + if key == args[0] { + fmt.Printf("%s=%s\n", key, value) + } + } + }, +} + + +var envGetCmd = &cobra.Command{ + Use: "get", + Short: "Get environment variables", + Args: cobra.MinimumNArgs(1), + Run: func(cmd *cobra.Command, args []string) { + logger := env.NewLogger(cmd) + dir := resolveProjectDir(logger, cmd) + apiUrl := viper.GetString("overrides.api_url") + apiKey := viper.GetString("auth.api_key") + if apiKey == "" { + logger.Fatal("you are not logged in") + } + project := project.NewProject() + if err := project.Load(dir); err != nil { + logger.Fatal("failed to load project: %s", err) + } + projectData, err := project.ListProjectEnv(logger, apiUrl, apiKey) + if err != nil { + logger.Fatal("failed to list project env: %s", err) + } + for key, value := range projectData.Env { + if key == args[0] { + fmt.Printf("%s=%s\n", key, value) + } + } + }, +} + +var envListCmd = &cobra.Command{ + Use: "list", + Short: "List all environment variables", + Run: func(cmd *cobra.Command, args []string) { + logger := env.NewLogger(cmd) + dir := resolveProjectDir(logger, cmd) + apiUrl := viper.GetString("overrides.api_url") + apiKey := viper.GetString("auth.api_key") + if apiKey == "" { + logger.Fatal("you are not logged in") + } + project := project.NewProject() + if err := project.Load(dir); err != nil { + logger.Fatal("failed to load project: %s", err) + } + projectData, err := project.ListProjectEnv(logger, apiUrl, apiKey) + if err != nil { + logger.Fatal("failed to list project env: %s", err) + } + for key, value := range projectData.Env { + fmt.Printf("%s=%s\n", key, value) + } + }, +} + + +func init() { + rootCmd.AddCommand(envCmd) + envCmd.AddCommand(envSetCmd) + envCmd.AddCommand(envListCmd ) + envCmd.AddCommand(envGetCmd) +} diff --git a/cmd/project.go b/cmd/project.go index ffdbc394..35871f2a 100644 --- a/cmd/project.go +++ b/cmd/project.go @@ -1,7 +1,6 @@ package cmd import ( - "fmt" "os" "path/filepath" @@ -213,101 +212,8 @@ var projectInitCmd = &cobra.Command{ logger.Info("Project initialized successfully") }, } - -var projectEnvSetCmd = &cobra.Command{ - Use: "env:set [directory]", - Short: "Set environment variables for a project", - Args: cobra.MaximumNArgs(1), - Run: func(cmd *cobra.Command, args []string) { - logger := env.NewLogger(cmd) - dir := "." - if len(args) > 0 { - dir = args[0] - } - dir = resolveDir(logger, dir, false) - envFile := filepath.Join(dir, ".env") - - envLines, err := env.ParseEnvFile(envFile) - if err != nil { - logger.Fatal("failed to parse .env file: %s", err) - } - - // Print local env vars to stdout - for _, envLine := range envLines { - fmt.Printf("%s=%s\n", envLine.Key, envLine.Val) - } - - apiUrl := viper.GetString("overrides.api_url") - apiKey := viper.GetString("auth.api_key") - if apiKey == "" { - logger.Fatal("you are not logged in") - } - - project := project.NewProject() - if err := project.Load(dir); err != nil { - logger.Fatal("failed to load project: %s", err) - } - - secretMap := make(map[string]interface{}) - for _, envLine := range envLines { - secretMap[envLine.Key] = envLine.Val - } - - project.SetProjectSecrets(logger, apiUrl, apiKey, secretMap) - - if err != nil { - logger.Fatal("failed to set project env: %s", err) - } - - printSuccess("Project environment variables set successfully") - - }, -} - -var projectEnvCmd = &cobra.Command{ - Use: "env [directory]", - Short: "Get environment variables for a project", - Args: cobra.MaximumNArgs(1), - Run: func(cmd *cobra.Command, args []string) { - logger := env.NewLogger(cmd) - - dir := "." - if len(args) > 0 { - dir = args[0] - } - dir = resolveDir(logger, dir, false) - - apiUrl := viper.GetString("overrides.api_url") - apiKey := viper.GetString("auth.api_key") - if apiKey == "" { - logger.Fatal("you are not logged in") - } - - project := project.NewProject() - if err := project.Load(dir); err != nil { - logger.Fatal("failed to load project: %s", err) - } - logger.Info("Getting environment variables for project %s", project.ProjectId) - - projectData, err := project.GetProjectEnv(logger, apiUrl, apiKey) - if err != nil { - logger.Fatal("failed to get project env: %s", err) - } - // Print remote env vars and secrets to stdout - for key, value := range projectData.Env { - fmt.Printf("%s=%s\n", key, value) - } - for key, value := range projectData.Secrets { - fmt.Printf("%s=%s\n", key, value) - } - - }, -} - func init() { rootCmd.AddCommand(projectCmd) projectCmd.AddCommand(projectInitCmd) projectCmd.AddCommand(projectNewCmd) - projectCmd.AddCommand(projectEnvCmd) - projectCmd.AddCommand(projectEnvSetCmd) } diff --git a/internal/project/project.go b/internal/project/project.go index fffb2998..11896eb0 100644 --- a/internal/project/project.go +++ b/internal/project/project.go @@ -162,7 +162,7 @@ type ProjectResponse struct { Data ProjectData `json:"data"` } -func (p *Project) GetProjectEnv(logger logger.Logger, baseUrl string, token string) (*ProjectData, error) { +func (p *Project) ListProjectEnv(logger logger.Logger, baseUrl string, token string) (*ProjectData, error) { client := util.NewAPIClient(baseUrl, token) var projectResponse ProjectResponse @@ -172,11 +172,11 @@ func (p *Project) GetProjectEnv(logger logger.Logger, baseUrl string, token stri return &projectResponse.Data, nil } -func (p *Project) SetProjectSecrets(logger logger.Logger, baseUrl string, token string, secrets map[string]interface{}) (*ProjectData, error) { +func (p *Project) SetProjectEnv (logger logger.Logger, baseUrl string, token string, env map[string]interface{}) (*ProjectData, error) { client := util.NewAPIClient(baseUrl, token) var projectResponse ProjectResponse if err := client.Do("PUT", fmt.Sprintf("/cli/project/%s", p.ProjectId), map[string]interface{}{ - "secrets": secrets, + "env": env, }, &projectResponse); err != nil { logger.Fatal("error setting project env: %s", err) } From 1a5426291d2e1bbfae4d084248afb69ed3137b69 Mon Sep 17 00:00:00 2001 From: Bobby Christopher Date: Wed, 5 Feb 2025 22:26:30 -0600 Subject: [PATCH 6/8] added whitespace back --- cmd/project.go | 1 + 1 file changed, 1 insertion(+) diff --git a/cmd/project.go b/cmd/project.go index 35871f2a..529c5133 100644 --- a/cmd/project.go +++ b/cmd/project.go @@ -212,6 +212,7 @@ var projectInitCmd = &cobra.Command{ logger.Info("Project initialized successfully") }, } + func init() { rootCmd.AddCommand(projectCmd) projectCmd.AddCommand(projectInitCmd) From 47f8612464e03b5e05590f5df055d81eb8fa5b87 Mon Sep 17 00:00:00 2001 From: Bobby Christopher Date: Wed, 5 Feb 2025 22:36:04 -0600 Subject: [PATCH 7/8] added fmt and better help text --- cmd/env.go | 15 ++++----------- internal/project/project.go | 15 ++++++++------- internal/util/api.go | 4 ++-- 3 files changed, 14 insertions(+), 20 deletions(-) diff --git a/cmd/env.go b/cmd/env.go index 841ffed1..f023fbcc 100644 --- a/cmd/env.go +++ b/cmd/env.go @@ -17,7 +17,6 @@ var envCmd = &cobra.Command{ }, } - var envSetCmd = &cobra.Command{ Use: "set [key] [value]", Short: "Set environment variables", @@ -34,21 +33,16 @@ var envSetCmd = &cobra.Command{ if err := project.Load(dir); err != nil { logger.Fatal("failed to load project: %s", err) } - projectData, err := project.SetProjectEnv(logger, apiUrl, apiKey, map[string]interface{}{args[0]: args[1]}) + _, err := project.SetProjectEnv(logger, apiUrl, apiKey, map[string]interface{}{args[0]: args[1]}) if err != nil { logger.Fatal("failed to set project env: %s", err) } - for key, value := range projectData.Env { - if key == args[0] { - fmt.Printf("%s=%s\n", key, value) - } - } + printSuccess(fmt.Sprintf("Environment variable %s set successfully", args[0])) }, } - var envGetCmd = &cobra.Command{ - Use: "get", + Use: "get [key]", Short: "Get environment variables", Args: cobra.MinimumNArgs(1), Run: func(cmd *cobra.Command, args []string) { @@ -100,10 +94,9 @@ var envListCmd = &cobra.Command{ }, } - func init() { rootCmd.AddCommand(envCmd) envCmd.AddCommand(envSetCmd) - envCmd.AddCommand(envListCmd ) + envCmd.AddCommand(envListCmd) envCmd.AddCommand(envGetCmd) } diff --git a/internal/project/project.go b/internal/project/project.go index 11896eb0..4ceb34b8 100644 --- a/internal/project/project.go +++ b/internal/project/project.go @@ -26,10 +26,10 @@ type initProjectResult struct { } type ProjectData struct { - APIKey string `json:"api_key"` - ProjectId string `json:"id"` - Env map[string]interface{} `json:"env"` - Secrets map[string]interface{} `json:"secrets"` + APIKey string `json:"api_key"` + ProjectId string `json:"id"` + Env map[string]interface{} `json:"env"` + Secrets map[string]interface{} `json:"secrets"` } // InitProject will create a new project in the organization. @@ -157,8 +157,8 @@ func NewProject() *Project { } type ProjectResponse struct { - Success bool `json:"success"` - Message string `json:"message"` + Success bool `json:"success"` + Message string `json:"message"` Data ProjectData `json:"data"` } @@ -172,7 +172,7 @@ func (p *Project) ListProjectEnv(logger logger.Logger, baseUrl string, token str return &projectResponse.Data, nil } -func (p *Project) SetProjectEnv (logger logger.Logger, baseUrl string, token string, env map[string]interface{}) (*ProjectData, error) { +func (p *Project) SetProjectEnv(logger logger.Logger, baseUrl string, token string, env map[string]interface{}) (*ProjectData, error) { client := util.NewAPIClient(baseUrl, token) var projectResponse ProjectResponse if err := client.Do("PUT", fmt.Sprintf("/cli/project/%s", p.ProjectId), map[string]interface{}{ @@ -182,6 +182,7 @@ func (p *Project) SetProjectEnv (logger logger.Logger, baseUrl string, token str } return &projectResponse.Data, nil } + type DeploymentConfig struct { Provider string `yaml:"provider"` Language string `yaml:"language"` diff --git a/internal/util/api.go b/internal/util/api.go index 932f8148..a67d4711 100644 --- a/internal/util/api.go +++ b/internal/util/api.go @@ -52,7 +52,7 @@ func (c *APIClient) Do(method, path string, payload interface{}, response interf if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusAccepted { return fmt.Errorf("request failed with status (%s)", resp.Status) - } + } if response != nil { if err := json.NewDecoder(resp.Body).Decode(response); err != nil { @@ -60,4 +60,4 @@ func (c *APIClient) Do(method, path string, payload interface{}, response interf } } return nil -} \ No newline at end of file +} From 74614c1963f0d9b4b343309191952c8cc2a285d6 Mon Sep 17 00:00:00 2001 From: Bobby Christopher Date: Wed, 5 Feb 2025 22:44:11 -0600 Subject: [PATCH 8/8] added new url --- internal/project/project.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/internal/project/project.go b/internal/project/project.go index 4ceb34b8..8c7d735b 100644 --- a/internal/project/project.go +++ b/internal/project/project.go @@ -175,7 +175,7 @@ func (p *Project) ListProjectEnv(logger logger.Logger, baseUrl string, token str func (p *Project) SetProjectEnv(logger logger.Logger, baseUrl string, token string, env map[string]interface{}) (*ProjectData, error) { client := util.NewAPIClient(baseUrl, token) var projectResponse ProjectResponse - if err := client.Do("PUT", fmt.Sprintf("/cli/project/%s", p.ProjectId), map[string]interface{}{ + if err := client.Do("PUT", fmt.Sprintf("/cli/project/%s/env", p.ProjectId), map[string]interface{}{ "env": env, }, &projectResponse); err != nil { logger.Fatal("error setting project env: %s", err)