feat(cli): add non-interactive mode for configure sources and targets

Add CLI flags to enable non-interactive operation for `speakeasy configure sources`
and `speakeasy configure targets` commands, allowing usage in CI/CD pipelines
and automated workflows without requiring a TTY.

For configure sources:
- --location: OpenAPI document location (local file or URL)
- --source-name: name for the source
- --auth-header: authentication header name (optional)
- --output: output path for compiled source (optional)

For configure targets:
- --target-type: language type (typescript, python, go, java, etc.)
- --source: name of the source to generate from
- --target-name: name for the target (defaults to target-type)
- --sdk-class-name: SDK class name (optional)
- --package-name: package name (optional)
- --base-server-url: base server URL (optional)
- --output: output directory (optional)

Non-interactive mode is automatically enabled when the required flags are provided.

Closes: GEN-2415

Author: vishalg0wda

cmd/configure.go

@@ -77,14 +77,18 @@ var configureGenerationCmd = &model.CommandGroup{
 }
 
 type ConfigureSourcesFlags struct {
-	ID  string `json:"id"`
-	New bool   `json:"new"`
+	ID         string `json:"id"`
+	New        bool   `json:"new"`
+	Location   string `json:"location"`
+	SourceName string `json:"source-name"`
+	AuthHeader string `json:"auth-header"`
+	OutputPath string `json:"output"`
 }
 
 var configureSourcesCmd = &model.ExecutableCommand[ConfigureSourcesFlags]{
 	Usage:        "sources",
 	Short:        "Configure new or existing sources.",
-	Long:         "Guided prompts to configure a new or existing source in your speakeasy workflow.",
+	Long:         "Guided prompts to configure a new or existing source in your speakeasy workflow. When --location and --source-name are provided, runs in non-interactive mode suitable for CI/CD.",
 	Run:          configureSources,
 	RequiresAuth: true,
 	Flags: []flag.Flag{
@@ -98,18 +102,44 @@ var configureSourcesCmd = &model.ExecutableCommand[ConfigureSourcesFlags]{
 			Shorthand:   "n",
 			Description: "configure a new source",
 		},
+		flag.StringFlag{
+			Name:        "location",
+			Shorthand:   "l",
+			Description: "location of the OpenAPI document (local file path or URL); enables non-interactive mode when combined with --source-name",
+		},
+		flag.StringFlag{
+			Name:        "source-name",
+			Shorthand:   "s",
+			Description: "name for the source; enables non-interactive mode when combined with --location",
+		},
+		flag.StringFlag{
+			Name:        "auth-header",
+			Description: "authentication header name for remote documents (value from $OPENAPI_DOC_AUTH_TOKEN)",
+		},
+		flag.StringFlag{
+			Name:        "output",
+			Shorthand:   "o",
+			Description: "output path for the compiled source document",
+		},
 	},
 }
 
 type ConfigureTargetFlags struct {
-	ID  string `json:"id"`
-	New bool   `json:"new"`
+	ID            string `json:"id"`
+	New           bool   `json:"new"`
+	TargetType    string `json:"target-type"`
+	SourceID      string `json:"source"`
+	TargetName    string `json:"target-name"`
+	SDKClassName  string `json:"sdk-class-name"`
+	PackageName   string `json:"package-name"`
+	BaseServerURL string `json:"base-server-url"`
+	OutputDir     string `json:"output"`
 }
 
 var configureTargetCmd = &model.ExecutableCommand[ConfigureTargetFlags]{
 	Usage:        "targets",
 	Short:        "Configure new or existing targets.",
-	Long:         "Guided prompts to configure a new or existing target in your speakeasy workflow.",
+	Long:         "Guided prompts to configure a new or existing target in your speakeasy workflow. When --target-type and --source are provided, runs in non-interactive mode suitable for CI/CD.",
 	Run:          configureTarget,
 	RequiresAuth: true,
 	Flags: []flag.Flag{
@@ -123,6 +153,37 @@ var configureTargetCmd = &model.ExecutableCommand[ConfigureTargetFlags]{
 			Shorthand:   "n",
 			Description: "configure a new target",
 		},
+		flag.StringFlag{
+			Name:        "target-type",
+			Shorthand:   "t",
+			Description: "target language/type: typescript, python, go, java, csharp, php, ruby, terraform, mcp-typescript; enables non-interactive mode",
+		},
+		flag.StringFlag{
+			Name:        "source",
+			Shorthand:   "s",
+			Description: "name of the source to generate from; enables non-interactive mode when combined with --target-type",
+		},
+		flag.StringFlag{
+			Name:        "target-name",
+			Description: "name for the target (defaults to target-type if not specified)",
+		},
+		flag.StringFlag{
+			Name:        "sdk-class-name",
+			Description: "SDK class name (PascalCase, e.g., MyCompanySDK)",
+		},
+		flag.StringFlag{
+			Name:        "package-name",
+			Description: "package name for the generated SDK",
+		},
+		flag.StringFlag{
+			Name:        "base-server-url",
+			Description: "base server URL for the SDK",
+		},
+		flag.StringFlag{
+			Name:        "output",
+			Shorthand:   "o",
+			Description: "output directory for the generated target",
+		},
 	},
 }
 
@@ -218,6 +279,11 @@ func configureSources(ctx context.Context, flags ConfigureSourcesFlags) error {
 		}
 	}
 
+	// Non-interactive mode: when both --location and --source-name are provided
+	if flags.Location != "" && flags.SourceName != "" {
+		return configureSourcesNonInteractive(ctx, workingDir, workflowFile, flags)
+	}
+
 	var existingSourceName string
 	var existingSource *workflow.Source
 	if source, ok := workflowFile.Sources[flags.ID]; ok {
@@ -291,6 +357,81 @@ func configureSources(ctx context.Context, flags ConfigureSourcesFlags) error {
 	return nil
 }
 
+// configureSourcesNonInteractive handles source configuration without interactive prompts.
+// This is used when --location and --source-name flags are both provided.
+func configureSourcesNonInteractive(ctx context.Context, workingDir string, workflowFile *workflow.Workflow, flags ConfigureSourcesFlags) error {
+	logger := log.From(ctx)
+
+	// Validate source name doesn't already exist
+	if _, ok := workflowFile.Sources[flags.SourceName]; ok {
+		return fmt.Errorf("a source with the name %q already exists", flags.SourceName)
+	}
+
+	// Validate source name format
+	if strings.Contains(flags.SourceName, " ") {
+		return fmt.Errorf("source name must not contain spaces")
+	}
+
+	// Build the source document
+	document := workflow.Document{
+		Location: workflow.LocationString(flags.Location),
+	}
+
+	// Add authentication if provided
+	if flags.AuthHeader != "" {
+		document.Auth = &workflow.Auth{
+			Header: flags.AuthHeader,
+			Secret: "$openapi_doc_auth_token",
+		}
+	}
+
+	// Build the source
+	source := workflow.Source{
+		Inputs: []workflow.Document{document},
+	}
+
+	// Set output path if provided
+	if flags.OutputPath != "" {
+		source.Output = &flags.OutputPath
+	}
+
+	// Validate the source
+	if err := source.Validate(); err != nil {
+		return errors.Wrap(err, "failed to validate source configuration")
+	}
+
+	// Add source to workflow
+	workflowFile.Sources[flags.SourceName] = source
+
+	// Validate the workflow
+	if err := workflowFile.Validate(generate.GetSupportedTargetNames()); err != nil {
+		return errors.Wrap(err, "failed to validate workflow file")
+	}
+
+	// Ensure .speakeasy directory exists
+	if _, err := os.Stat(".speakeasy"); os.IsNotExist(err) {
+		if err := os.MkdirAll(".speakeasy", 0o755); err != nil {
+			return err
+		}
+	}
+
+	// Save the workflow
+	if err := workflow.Save(workingDir, workflowFile); err != nil {
+		return errors.Wrap(err, "failed to save workflow file")
+	}
+
+	// Print success message
+	logger.Printf("Successfully configured source %q with location %q\n", flags.SourceName, flags.Location)
+	if flags.OutputPath != "" {
+		logger.Printf("  Output path: %s\n", flags.OutputPath)
+	}
+	if flags.AuthHeader != "" {
+		logger.Printf("  Auth header: %s (value from $OPENAPI_DOC_AUTH_TOKEN)\n", flags.AuthHeader)
+	}
+
+	return nil
+}
+
 func configureTarget(ctx context.Context, flags ConfigureTargetFlags) error {
 	workingDir, err := os.Getwd()
 	if err != nil {
@@ -312,6 +453,11 @@ func configureTarget(ctx context.Context, flags ConfigureTargetFlags) error {
 		workflowFile.Targets = make(map[string]workflow.Target)
 	}
 
+	// Non-interactive mode: when --target-type and --source are provided
+	if flags.TargetType != "" && flags.SourceID != "" {
+		return configureTargetNonInteractive(ctx, workingDir, workflowFile, flags)
+	}
+
 	existingTarget := ""
 	if _, ok := workflowFile.Targets[flags.ID]; ok {
 		existingTarget = flags.ID
@@ -452,6 +598,166 @@ func configureTarget(ctx context.Context, flags ConfigureTargetFlags) error {
 	return nil
 }
 
+// configureTargetNonInteractive handles target configuration without interactive prompts.
+// This is used when --target-type and --source flags are both provided.
+func configureTargetNonInteractive(ctx context.Context, workingDir string, workflowFile *workflow.Workflow, flags ConfigureTargetFlags) error {
+	logger := log.From(ctx)
+
+	// Validate target type is supported
+	supportedTargets := generate.GetSupportedTargetNames()
+	if !slices.Contains(supportedTargets, flags.TargetType) {
+		return fmt.Errorf("unsupported target type %q; supported types: %s", flags.TargetType, strings.Join(supportedTargets, ", "))
+	}
+
+	// Validate source exists
+	if _, ok := workflowFile.Sources[flags.SourceID]; !ok {
+		var sourceNames []string
+		for name := range workflowFile.Sources {
+			sourceNames = append(sourceNames, name)
+		}
+		return fmt.Errorf("source %q not found; available sources: %s", flags.SourceID, strings.Join(sourceNames, ", "))
+	}
+
+	// Default target name to target type if not provided
+	targetName := flags.TargetName
+	if targetName == "" {
+		targetName = flags.TargetType
+	}
+
+	// Validate target name doesn't already exist
+	if _, ok := workflowFile.Targets[targetName]; ok {
+		return fmt.Errorf("a target with the name %q already exists", targetName)
+	}
+
+	// Validate target name format
+	if strings.Contains(targetName, " ") {
+		return fmt.Errorf("target name must not contain spaces")
+	}
+
+	// Build the target
+	target := workflow.Target{
+		Target: flags.TargetType,
+		Source: flags.SourceID,
+	}
+
+	// Set output directory if provided
+	if flags.OutputDir != "" {
+		target.Output = &flags.OutputDir
+	}
+
+	// Validate the target
+	if err := target.Validate(supportedTargets, workflowFile.Sources); err != nil {
+		return errors.Wrap(err, "failed to validate target configuration")
+	}
+
+	// Add target to workflow
+	workflowFile.Targets[targetName] = target
+
+	// Build config for target
+	targetConfig, err := config.GetDefaultConfig(true, generate.GetLanguageConfigDefaults, map[string]bool{flags.TargetType: true})
+	if err != nil {
+		return errors.Wrapf(err, "failed to generate config for target %s", targetName)
+	}
+
+	// Set SDK class name if provided
+	if flags.SDKClassName != "" {
+		targetConfig.Generation.SDKClassName = flags.SDKClassName
+	}
+
+	// Set base server URL if provided
+	if flags.BaseServerURL != "" {
+		targetConfig.Generation.BaseServerURL = flags.BaseServerURL
+	}
+
+	// Set package name if provided
+	if flags.PackageName != "" {
+		if langConfig, ok := targetConfig.Languages[flags.TargetType]; ok {
+			if langConfig.Cfg == nil {
+				langConfig.Cfg = make(map[string]interface{})
+			}
+			// Different languages use different config keys for package name
+			switch flags.TargetType {
+			case "go":
+				langConfig.Cfg["modulePath"] = flags.PackageName
+			case "java":
+				// For Java, split packageName into groupID and artifactID if it contains a colon
+				if strings.Contains(flags.PackageName, ":") {
+					parts := strings.SplitN(flags.PackageName, ":", 2)
+					langConfig.Cfg["groupID"] = parts[0]
+					langConfig.Cfg["artifactID"] = parts[1]
+				} else {
+					langConfig.Cfg["groupID"] = flags.PackageName
+				}
+			default:
+				langConfig.Cfg["packageName"] = flags.PackageName
+			}
+			targetConfig.Languages[flags.TargetType] = langConfig
+		}
+	}
+
+	// Determine output directory
+	outDir := workingDir
+	if target.Output != nil {
+		outDir = *target.Output
+	}
+
+	// Ensure .speakeasy directory exists in output dir
+	if _, err := os.Stat(filepath.Join(outDir, ".speakeasy")); os.IsNotExist(err) {
+		if err := os.MkdirAll(filepath.Join(outDir, ".speakeasy"), 0o755); err != nil {
+			return err
+		}
+	}
+
+	// Create empty gen.yaml if it doesn't exist
+	genYamlPath := filepath.Join(outDir, ".speakeasy/gen.yaml")
+	if _, err := os.Stat(genYamlPath); os.IsNotExist(err) {
+		if err := os.WriteFile(genYamlPath, []byte{}, 0o644); err != nil {
+			return err
+		}
+	}
+
+	// Save config
+	if err := config.SaveConfig(outDir, targetConfig); err != nil {
+		return errors.Wrapf(err, "failed to save config for target %s", targetName)
+	}
+
+	// Validate the workflow
+	if err := workflowFile.Validate(supportedTargets); err != nil {
+		return errors.Wrap(err, "failed to validate workflow file")
+	}
+
+	// Ensure .speakeasy directory exists in working dir
+	if _, err := os.Stat(".speakeasy"); os.IsNotExist(err) {
+		if err := os.MkdirAll(".speakeasy", 0o755); err != nil {
+			return err
+		}
+	}
+
+	// Save the workflow
+	if err := workflow.Save(workingDir, workflowFile); err != nil {
+		return errors.Wrap(err, "failed to save workflow file")
+	}
+
+	// Print success message
+	logger.Printf("Successfully configured target %q\n", targetName)
+	logger.Printf("  Type: %s\n", flags.TargetType)
+	logger.Printf("  Source: %s\n", flags.SourceID)
+	if flags.OutputDir != "" {
+		logger.Printf("  Output: %s\n", flags.OutputDir)
+	}
+	if flags.SDKClassName != "" {
+		logger.Printf("  SDK Class Name: %s\n", flags.SDKClassName)
+	}
+	if flags.PackageName != "" {
+		logger.Printf("  Package Name: %s\n", flags.PackageName)
+	}
+	if flags.BaseServerURL != "" {
+		logger.Printf("  Base Server URL: %s\n", flags.BaseServerURL)
+	}
+
+	return nil
+}
+
 func configurePublishing(ctx context.Context, flags ConfigureGithubFlags) error {
 	logger := log.From(ctx)