feat(application): add application management commands (#199)

* feat(application): add application management commands

* fix: use auth.OAuthClientID instead of login

Author: LorrisSaintGenez

api/dashboard/client.go

@@ -337,6 +337,57 @@ func (c *Client) ListRegions(accessToken string) ([]Region, error) {
 	return regionsResp.RegionCodes, nil
 }
 
+// WriteACL is the set of permissions for API keys created by the CLI.
+var WriteACL = []string{
+	"search", "browse", "seeUnretrievableAttributes", "listIndexes",
+	"analytics", "logs", "addObject", "deleteObject", "deleteIndex",
+	"settings", "editSettings", "recommendation",
+}
+
+// CreateAPIKey creates a new API key with the given ACL for the specified application.
+func (c *Client) CreateAPIKey(accessToken, appID string, acl []string, description string) (string, error) {
+	payload := CreateAPIKeyRequest{ACL: acl, Description: description}
+	body, err := json.Marshal(payload)
+	if err != nil {
+		return "", err
+	}
+
+	endpoint := fmt.Sprintf("%s/1/applications/%s/api-keys", c.APIURL, url.PathEscape(appID))
+	req, err := http.NewRequest(http.MethodPost, endpoint, bytes.NewReader(body))
+	if err != nil {
+		return "", err
+	}
+	c.setAPIHeaders(req, accessToken)
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := c.client.Do(req)
+	if err != nil {
+		return "", fmt.Errorf("create API key request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	respBody, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", fmt.Errorf("failed to read API key response: %w", err)
+	}
+
+	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusCreated {
+		return "", fmt.Errorf("create API key failed with status %d: %s", resp.StatusCode, string(respBody))
+	}
+
+	var keyResp CreateAPIKeyResponse
+	if err := json.Unmarshal(respBody, &keyResp); err != nil {
+		return "", fmt.Errorf("failed to parse API key response: %w (body: %s)", err, string(respBody))
+	}
+
+	key := keyResp.Data.Attributes.Value
+	if key == "" {
+		return "", fmt.Errorf("API key creation succeeded but no key was returned in the response: %s", string(respBody))
+	}
+
+	return key, nil
+}
+
 func (c *Client) setAPIHeaders(req *http.Request, accessToken string) {
 	req.Header.Set("Authorization", "Bearer "+accessToken)
 	req.Header.Set("Accept", "application/vnd.api+json")

api/dashboard/types.go

@@ -88,6 +88,29 @@ type OAuthErrorResponse struct {
 	ErrorDescription string `json:"error_description"`
 }
 
+// CreateAPIKeyRequest is the payload for POST /1/applications/{application_id}/api-keys.
+type CreateAPIKeyRequest struct {
+	ACL         []string `json:"acl"`
+	Description string   `json:"description"`
+}
+
+// APIKeyResource is a JSON:API resource wrapper for an API key.
+type APIKeyResource struct {
+	ID         string           `json:"id"`
+	Type       string           `json:"type"`
+	Attributes APIKeyAttributes `json:"attributes"`
+}
+
+// APIKeyAttributes contains the actual API key fields.
+type APIKeyAttributes struct {
+	Value string `json:"value"`
+}
+
+// CreateAPIKeyResponse is the JSON:API response from POST /1/applications/{application_id}/api-keys.
+type CreateAPIKeyResponse struct {
+	Data APIKeyResource `json:"data"`
+}
+
 // toApplication flattens a JSON:API resource into a simple Application.
 func (r *ApplicationResource) toApplication() Application {
 	return Application{

pkg/cmd/application/application.go

@@ -0,0 +1,25 @@
+package application
+
+import (
+	"github.com/spf13/cobra"
+
+	"github.com/algolia/cli/pkg/cmd/application/create"
+	"github.com/algolia/cli/pkg/cmd/application/list"
+	"github.com/algolia/cli/pkg/cmd/application/selectapp"
+	"github.com/algolia/cli/pkg/cmdutil"
+)
+
+// NewApplicationCmd returns a new command for managing applications.
+func NewApplicationCmd(f *cmdutil.Factory) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "application",
+		Aliases: []string{"app"},
+		Short:   "Manage your Algolia applications",
+	}
+
+	cmd.AddCommand(create.NewCreateCmd(f))
+	cmd.AddCommand(list.NewListCmd(f))
+	cmd.AddCommand(selectapp.NewSelectCmd(f))
+
+	return cmd
+}

pkg/cmd/application/create/create.go

@@ -0,0 +1,121 @@
+package create
+
+import (
+	"fmt"
+
+	"github.com/MakeNowJust/heredoc"
+	"github.com/spf13/cobra"
+
+	"github.com/algolia/cli/api/dashboard"
+	"github.com/algolia/cli/pkg/auth"
+	"github.com/algolia/cli/pkg/cmd/shared/apputil"
+	"github.com/algolia/cli/pkg/cmdutil"
+	"github.com/algolia/cli/pkg/config"
+	"github.com/algolia/cli/pkg/iostreams"
+	"github.com/algolia/cli/pkg/validators"
+)
+
+type CreateOptions struct {
+	IO     *iostreams.IOStreams
+	Config config.IConfig
+
+	Name        string
+	Region      string
+	ProfileName string
+	Default     bool
+	DryRun      bool
+
+	PrintFlags *cmdutil.PrintFlags
+
+	NewDashboardClient func(clientID string) *dashboard.Client
+}
+
+func NewCreateCmd(f *cmdutil.Factory) *cobra.Command {
+	opts := &CreateOptions{
+		IO:         f.IOStreams,
+		Config:     f.Config,
+		PrintFlags: cmdutil.NewPrintFlags(),
+		NewDashboardClient: func(clientID string) *dashboard.Client {
+			return dashboard.NewClient(clientID)
+		},
+	}
+
+	cmd := &cobra.Command{
+		Use:   "create",
+		Short: "Create a new Algolia application",
+		Long: heredoc.Doc(`
+			Create a new Algolia application and optionally configure it as a CLI profile.
+			Requires an active session (run "algolia auth login" first).
+		`),
+		Example: heredoc.Doc(`
+			# Create an application interactively
+			$ algolia application create
+
+			# Create with specific options
+			$ algolia application create --name "My App" --region CA
+
+			# Create and set as default profile
+			$ algolia application create --name "My App" --region CA --default
+
+			# Preview what would be created without actually creating it
+			$ algolia application create --name "My App" --region CA --dry-run
+		`),
+		Args: validators.NoArgs(),
+		Annotations: map[string]string{
+			"skipAuthCheck": "true",
+		},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return runCreateCmd(opts)
+		},
+	}
+
+	cmd.Flags().StringVar(&opts.Name, "name", "My First Application", "Name for the application")
+	cmd.Flags().StringVar(&opts.Region, "region", "", "Region code (e.g. CA, US, EU)")
+	cmd.Flags().StringVar(&opts.ProfileName, "profile-name", "", "Name for the CLI profile (defaults to app name)")
+	cmd.Flags().BoolVar(&opts.Default, "default", false, "Set the new profile as the default")
+	cmd.Flags().BoolVar(&opts.DryRun, "dry-run", false, "Preview the create request without sending it")
+
+	opts.PrintFlags.AddFlags(cmd)
+
+	return cmd
+}
+
+func runCreateCmd(opts *CreateOptions) error {
+	if opts.DryRun {
+		summary := map[string]any{
+			"action":  "create_application",
+			"name":    opts.Name,
+			"region":  opts.Region,
+			"default": opts.Default,
+			"dryRun":  true,
+		}
+		return cmdutil.PrintRunSummary(
+			opts.IO,
+			opts.PrintFlags,
+			summary,
+			fmt.Sprintf("Dry run: would create application %q in region %q", opts.Name, opts.Region),
+		)
+	}
+
+	client := opts.NewDashboardClient(auth.OAuthClientID())
+
+	accessToken, err := auth.EnsureAuthenticated(opts.IO, client)
+	if err != nil {
+		return err
+	}
+
+	appDetails, err := apputil.CreateAndFetchApplication(opts.IO, client, accessToken, opts.Region, opts.Name)
+	if err != nil {
+		return err
+	}
+
+	if opts.PrintFlags.OutputFlagSpecified() && opts.PrintFlags.OutputFormat != nil {
+		p, err := opts.PrintFlags.ToPrinter()
+		if err != nil {
+			return err
+		}
+		return p.Print(opts.IO, appDetails)
+	}
+
+	return apputil.ConfigureProfile(opts.IO, opts.Config, appDetails, opts.ProfileName, opts.Default)
+}