fix: auto-resolve IDs and strip ObjectID prefixes

internal/cmd/deployment/get/get.go

@@ -69,6 +69,15 @@ func runGetInteractive(f *cmdutil.Factory, opts *Options) error {
 }
 
 func runGetNonInteractive(f *cmdutil.Factory, opts *Options) (err error) {
+	if opts.deploymentID == "" && opts.environmentID == "" {
+		projectID := f.Config.GetContext().GetProject().GetID()
+		envID, resolveErr := util.ResolveEnvironmentID(f.ApiClient, projectID)
+		if resolveErr != nil {
+			return resolveErr
+		}
+		opts.environmentID = envID
+	}
+
 	if err = paramCheck(opts); err != nil {
 		return err
 	}

internal/cmd/deployment/list/list.go

@@ -65,6 +65,15 @@ func runListInteractive(f *cmdutil.Factory, opts *Options) error {
 }
 
 func runListNonInteractive(f *cmdutil.Factory, opts *Options) error {
+	if opts.environmentID == "" {
+		projectID := f.Config.GetContext().GetProject().GetID()
+		envID, err := util.ResolveEnvironmentID(f.ApiClient, projectID)
+		if err != nil {
+			return err
+		}
+		opts.environmentID = envID
+	}
+
 	if err := paramCheck(opts); err != nil {
 		return err
 	}

internal/cmd/deployment/log/log.go

@@ -13,6 +13,7 @@ import (
 )
 
 type Options struct {
+	projectID     string
 	serviceID     string
 	serviceName   string
 	environmentID string
@@ -42,6 +43,7 @@ func NewCmdLog(f *cmdutil.Factory) *cobra.Command {
 
 	zctx := f.Config.GetContext()
 
+	cmd.Flags().StringVar(&opts.projectID, "project-id", zctx.GetProject().GetID(), "Project ID")
 	cmd.Flags().StringVar(&opts.deploymentID, "deployment-id", "", "Deployment ID")
 	cmd.Flags().StringVar(&opts.serviceID, "service-id", zctx.GetService().GetID(), "Service ID")
 	cmd.Flags().StringVar(&opts.serviceName, "service-name", zctx.GetService().GetName(), "Service Name")
@@ -61,8 +63,13 @@ func runLog(f *cmdutil.Factory, opts *Options) error {
 }
 
 func runLogInteractive(f *cmdutil.Factory, opts *Options) error {
+	zctx := f.Config.GetContext()
+
+	if opts.projectID == "" {
+		opts.projectID = zctx.GetProject().GetID()
+	}
+
 	if opts.deploymentID == "" {
-		zctx := f.Config.GetContext()
 		_, err := f.ParamFiller.ServiceByNameWithEnvironment(fill.ServiceByNameWithEnvironmentOptions{
 			ProjectCtx:    zctx,
 			ServiceID:     &opts.serviceID,
@@ -79,114 +86,134 @@ func runLogInteractive(f *cmdutil.Factory, opts *Options) error {
 }
 
 func runLogNonInteractive(f *cmdutil.Factory, opts *Options) (err error) {
-	if err = paramCheck(opts); err != nil {
-		return err
+	// Resolve serviceID from serviceName first
+	if opts.serviceID == "" && opts.serviceName != "" {
+		service, err := util.GetServiceByName(f.Config, f.ApiClient, opts.serviceName)
+		if err != nil {
+			return fmt.Errorf("failed to get service: %w", err)
+		}
+		opts.serviceID = service.ID
 	}
 
-	if opts.watch {
-		if opts.deploymentID != "" {
-			var logChan <-chan model.Log
-			var subscriptionErr error
-
-			switch opts.logType {
-			case logTypeRuntime:
-				logChan, subscriptionErr = f.ApiClient.WatchRuntimeLogs(context.Background(), opts.deploymentID)
-			case logTypeBuild:
-				logChan, subscriptionErr = f.ApiClient.WatchBuildLogs(context.Background(), opts.deploymentID)
-			default:
-				logChan, subscriptionErr = f.ApiClient.WatchRuntimeLogs(context.Background(), opts.deploymentID)
-			}
-			if subscriptionErr != nil {
-				return fmt.Errorf("failed to watch logs: %w", err)
-			}
-
-			for log := range logChan {
-				f.Printer.Table(log.Header(), log.Rows())
-			}
+	// When serviceID is available, always resolve projectID and environmentID from the service
+	// instead of relying on context (which may point to a different project).
+	if opts.serviceID != "" {
+		service, err := f.ApiClient.GetService(context.Background(), opts.serviceID, "", "", "")
+		if err != nil {
+			return fmt.Errorf("failed to get service: %w", err)
 		}
-
-		return nil
-	} else {
-		var logs model.Logs
-
-		// If deployment id is provided, get deployment by deployment id
-		if opts.deploymentID != "" {
-			logs, err = logDeploymentByID(f, opts.deploymentID, opts.logType)
-		} else {
-			// or, get deployment by service id and environment id
-
-			// If service id is not provided, get service id by service name
-			if opts.serviceID == "" {
-				var service *model.Service
-				if service, err = util.GetServiceByName(f.Config, f.ApiClient, opts.serviceName); err != nil {
-					return fmt.Errorf("failed to get service: %w", err)
-				} else {
-					opts.serviceID = service.ID
-				}
-			}
-			logs, err = logDeploymentByServiceAndEnvironment(f, opts.serviceID, opts.environmentID, opts.logType)
+		if service.Project != nil {
+			opts.projectID = service.Project.ID
+		}
+		envID, resolveErr := util.ResolveEnvironmentID(f.ApiClient, opts.projectID)
+		if resolveErr != nil {
+			return resolveErr
 		}
+		opts.environmentID = envID
+	}
 
-		if err != nil {
-			return err
+	// Fallback: resolve environmentID from context project if still empty
+	if opts.deploymentID == "" && opts.environmentID == "" {
+		projectID := opts.projectID
+		if projectID == "" {
+			projectID = f.Config.GetContext().GetProject().GetID()
 		}
+		envID, resolveErr := util.ResolveEnvironmentID(f.ApiClient, projectID)
+		if resolveErr != nil {
+			return resolveErr
+		}
+		opts.environmentID = envID
+	}
 
-		f.Printer.Table(logs.Header(), logs.Rows())
+	if err = paramCheck(opts); err != nil {
+		return err
+	}
 
-		return nil
+	if opts.watch {
+		return watchLogs(f, opts)
 	}
+	return queryLogs(f, opts)
 }
 
-func logDeploymentByID(f *cmdutil.Factory, deploymentID, logType string) (model.Logs, error) {
-	switch logType {
+func queryLogs(f *cmdutil.Factory, opts *Options) error {
+	var logs model.Logs
+	var err error
+
+	switch opts.logType {
 	case logTypeRuntime:
-		logs, err := f.ApiClient.GetRuntimeLogs(context.Background(), deploymentID, "", "")
+		logs, err = f.ApiClient.GetRuntimeLogs(context.Background(), opts.serviceID, opts.environmentID, opts.deploymentID)
 		if err != nil {
-			return nil, fmt.Errorf("failed to get runtime logs: %w", err)
+			return fmt.Errorf("failed to get runtime logs: %w", err)
 		}
-		return logs, nil
 	case logTypeBuild:
-		logs, err := f.ApiClient.GetBuildLogs(context.Background(), deploymentID)
+		deploymentID := opts.deploymentID
+		if deploymentID == "" {
+			deployment, exist, e := f.ApiClient.GetLatestDeployment(context.Background(), opts.serviceID, opts.environmentID)
+			if e != nil {
+				return fmt.Errorf("failed to get latest deployment: %w", e)
+			}
+			if !exist {
+				return fmt.Errorf("no deployment found for service %s and environment %s", opts.serviceID, opts.environmentID)
+			}
+			deploymentID = deployment.ID
+			f.Log.Infof("Deployment ID: %s", deploymentID)
+		}
+		logs, err = f.ApiClient.GetBuildLogs(context.Background(), deploymentID)
 		if err != nil {
-			return nil, fmt.Errorf("failed to get build logs: %w", err)
+			return fmt.Errorf("failed to get build logs: %w", err)
 		}
-		return logs, nil
 	default:
-		return nil, fmt.Errorf("unknown log type: %s", logType)
+		return fmt.Errorf("unknown log type: %s", opts.logType)
 	}
+
+	f.Printer.Table(logs.Header(), logs.Rows())
+	return nil
 }
 
-func logDeploymentByServiceAndEnvironment(f *cmdutil.Factory, serviceID, environmentID, logType string) (model.Logs, error) {
-	switch logType {
+func watchLogs(f *cmdutil.Factory, opts *Options) error {
+	var logChan <-chan model.Log
+	var err error
+
+	switch opts.logType {
 	case logTypeRuntime:
-		logs, err := f.ApiClient.GetRuntimeLogs(context.Background(), "", serviceID, environmentID)
-		if err != nil {
-			return nil, fmt.Errorf("failed to get runtime logs: %w", err)
+		if opts.serviceID == "" || opts.environmentID == "" {
+			return errors.New("service-id and env-id are required for watching runtime logs")
 		}
-		return logs, nil
+		logChan, err = f.ApiClient.WatchRuntimeLogs(context.Background(), opts.projectID, opts.serviceID, opts.environmentID, opts.deploymentID)
 	case logTypeBuild:
-		deployment, exist, err := f.ApiClient.GetLatestDeployment(context.Background(), serviceID, environmentID)
-		if err != nil {
-			return nil, fmt.Errorf("failed to get latest deployment: %w", err)
-		}
-		if !exist {
-			return nil, fmt.Errorf("no deployment found for service %s and environment %s", serviceID, environmentID)
-		}
-		f.Log.Infof("Deployment ID: %s", deployment.ID)
-		logs, err := f.ApiClient.GetBuildLogs(context.Background(), deployment.ID)
-		if err != nil {
-			return nil, fmt.Errorf("failed to get build logs: %w", err)
+		deploymentID := opts.deploymentID
+		if deploymentID == "" {
+			deployment, exist, e := f.ApiClient.GetLatestDeployment(context.Background(), opts.serviceID, opts.environmentID)
+			if e != nil {
+				return fmt.Errorf("failed to get latest deployment: %w", e)
+			}
+			if !exist {
+				return fmt.Errorf("no deployment found for service %s and environment %s", opts.serviceID, opts.environmentID)
+			}
+			deploymentID = deployment.ID
+			f.Log.Infof("Deployment ID: %s", deploymentID)
 		}
-		return logs, nil
+		logChan, err = f.ApiClient.WatchBuildLogs(context.Background(), opts.projectID, deploymentID)
 	default:
-		return nil, fmt.Errorf("unknown log type: %s", logType)
+		return fmt.Errorf("unknown log type: %s", opts.logType)
+	}
+
+	if err != nil {
+		return fmt.Errorf("failed to watch logs: %w", err)
+	}
+
+	for log := range logChan {
+		f.Printer.Table(log.Header(), log.Rows())
 	}
+
+	return nil
 }
 
 func paramCheck(opts *Options) error {
 	if opts.logType != logTypeRuntime && opts.logType != logTypeBuild {
 		return errors.New("log type must be runtime or build")
 	}
+
 	if opts.deploymentID != "" {
 		return nil
 	}

internal/cmd/project/export/export.go

@@ -49,16 +49,11 @@ func runExport(f *cmdutil.Factory, opts Options) error {
 	}
 
 	if opts.EnvironmentID == "" {
-		environments, err := f.ApiClient.ListEnvironments(context.Background(), opts.ProjectID)
+		envID, err := util.ResolveEnvironmentID(f.ApiClient, opts.ProjectID)
 		if err != nil {
-			return fmt.Errorf("list environments for project<%s> failed: %w", opts.ProjectID, err)
+			return err
 		}
-
-		if len(environments) == 0 {
-			return fmt.Errorf("no environment found in project %s", opts.ProjectID)
-		}
-
-		opts.EnvironmentID = environments[0].ID
+		opts.EnvironmentID = envID
 	}
 
 	exportedTemplate, err := f.ApiClient.ExportProject(context.Background(), opts.ProjectID, opts.EnvironmentID)

internal/cmd/service/delete/delete.go

@@ -67,6 +67,15 @@ func runDeleteInteractive(f *cmdutil.Factory, opts *Options) error {
 }
 
 func runDeleteNonInteractive(f *cmdutil.Factory, opts *Options) error {
+	if opts.environmentID == "" {
+		projectID := f.Config.GetContext().GetProject().GetID()
+		envID, err := util.ResolveEnvironmentID(f.ApiClient, projectID)
+		if err != nil {
+			return err
+		}
+		opts.environmentID = envID
+	}
+
 	if err := checkParams(opts); err != nil {
 		return err
 	}

internal/cmd/service/expose/expose.go

@@ -56,6 +56,15 @@ func runExpose(f *cmdutil.Factory, opts *Options) error {
 }
 
 func runExposeNonInteractive(f *cmdutil.Factory, opts *Options) error {
+	if opts.environmentID == "" {
+		projectID := f.Config.GetContext().GetProject().GetID()
+		envID, err := util.ResolveEnvironmentID(f.ApiClient, projectID)
+		if err != nil {
+			return err
+		}
+		opts.environmentID = envID
+	}
+
 	err := paramCheck(opts)
 	if err != nil {
 		return err

internal/cmd/service/metric/metric.go

@@ -79,6 +79,15 @@ func runMetricInteractive(f *cmdutil.Factory, opts *Options) error {
 }
 
 func runMetricNonInteractive(f *cmdutil.Factory, opts *Options) error {
+	if opts.environmentID == "" {
+		projectID := f.Config.GetContext().GetProject().GetID()
+		envID, err := util.ResolveEnvironmentID(f.ApiClient, projectID)
+		if err != nil {
+			return err
+		}
+		opts.environmentID = envID
+	}
+
 	if err := paramCheck(opts); err != nil {
 		return err
 	}

internal/cmd/service/redeploy/redeploy.go

@@ -68,6 +68,15 @@ func runRedeployInteractive(f *cmdutil.Factory, opts *Options) error {
 }
 
 func runRedeployNonInteractive(f *cmdutil.Factory, opts *Options) error {
+	if opts.environmentID == "" {
+		projectID := f.Config.GetContext().GetProject().GetID()
+		envID, err := util.ResolveEnvironmentID(f.ApiClient, projectID)
+		if err != nil {
+			return err
+		}
+		opts.environmentID = envID
+	}
+
 	if err := checkParams(opts); err != nil {
 		return err
 	}

internal/cmd/service/restart/restart.go

@@ -68,6 +68,15 @@ func runRestartInteractive(f *cmdutil.Factory, opts *Options) error {
 }
 
 func runRestartNonInteractive(f *cmdutil.Factory, opts *Options) error {
+	if opts.environmentID == "" {
+		projectID := f.Config.GetContext().GetProject().GetID()
+		envID, err := util.ResolveEnvironmentID(f.ApiClient, projectID)
+		if err != nil {
+			return err
+		}
+		opts.environmentID = envID
+	}
+
 	if err := checkParams(opts); err != nil {
 		return err
 	}

internal/cmd/service/suspend/suspend.go

@@ -68,6 +68,15 @@ func runSuspendInteractive(f *cmdutil.Factory, opts *Options) error {
 }
 
 func runSuspendNonInteractive(f *cmdutil.Factory, opts *Options) error {
+	if opts.environmentID == "" {
+		projectID := f.Config.GetContext().GetProject().GetID()
+		envID, err := util.ResolveEnvironmentID(f.ApiClient, projectID)
+		if err != nil {
+			return err
+		}
+		opts.environmentID = envID
+	}
+
 	if err := checkParams(opts); err != nil {
 		return err
 	}